1 /*
2  * Copyright (c) 2022 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 #include "audio_lib_common.h"
17 #include "audio_librender_test.h"
18 using namespace std;
19 using namespace testing::ext;
20 using namespace OHOS::Audio;
21 
22 namespace {
23 const string BIND_CONTROL = "control";
24 
25 class AudioAlsaLibRenderTest : public testing::Test {
26 public:
27     static void SetUpTestCase(void);
28     static void TearDownTestCase(void);
29     void SetUp();
30     void TearDown();
31     static int32_t (*InterfaceLibOutputRender)(struct DevHandle *handle, int cmdId,
32         struct AudioHwRenderParam *handleData);
33     static int32_t (*InterfaceLibCtlRender)(struct DevHandle *handle, int cmdId,
34         struct AudioHwRenderParam *handleData);
35     static void *ptrHandle;
36     static struct DevHandle *handle;
37     static struct DevHandle *(*BindServiceRender)(const char *serverName);
38     static void (*CloseServiceRender)(struct DevHandle *handle);
39     uint32_t PcmBytesToFrames(const struct AudioFrameRenderMode &frameRenderMode, uint64_t bytes) const;
40     int32_t FrameLibStart(FILE *file, struct AudioSampleAttributes attrs,
41         struct AudioHeadInfo wavHeadInfo, struct AudioHwRender *hwRender) const;
42     int32_t LibRenderStart(struct AudioHwRender *hwRender, struct DevHandle *handlerender) const;
43     int32_t CreatHwRender(struct AudioHwRender *&hwRender, const std::string adapterNameCase) const;
44 };
45 
46 int32_t (*AudioAlsaLibRenderTest::InterfaceLibOutputRender)(struct DevHandle *handle, int cmdId,
47     struct AudioHwRenderParam *handleData) = nullptr;
48 int32_t (*AudioAlsaLibRenderTest::InterfaceLibCtlRender)(struct DevHandle *handle, int cmdId,
49     struct AudioHwRenderParam *handleData) = nullptr;
50 void *AudioAlsaLibRenderTest::ptrHandle = nullptr;
51 struct DevHandle *AudioAlsaLibRenderTest::handle = nullptr;
52 struct DevHandle *(*AudioAlsaLibRenderTest::BindServiceRender)(const char *serverName) = nullptr;
53 void (*AudioAlsaLibRenderTest::CloseServiceRender)(struct DevHandle *handle) = nullptr;
SetUpTestCase(void)54 void AudioAlsaLibRenderTest::SetUpTestCase(void)
55 {
56     char resolvedPath[] = HDF_LIBRARY_FULL_PATH("libaudio_render_adapter");
57     ptrHandle = dlopen(resolvedPath, RTLD_LAZY);
58     ASSERT_NE(nullptr, ptrHandle);
59     InterfaceLibOutputRender = (int32_t (*)(struct DevHandle *, int,
60         struct AudioHwRenderParam *))dlsym(ptrHandle, "AudioInterfaceLibOutputRender");
61     ASSERT_NE(nullptr, InterfaceLibOutputRender);
62     InterfaceLibCtlRender = (int32_t (*)(struct DevHandle *, int,
63         struct AudioHwRenderParam *))dlsym(ptrHandle, "AudioInterfaceLibCtlRender");
64     ASSERT_NE(nullptr, InterfaceLibCtlRender);
65     BindServiceRender = reinterpret_cast<struct DevHandle* (*)(const char *)>(dlsym(ptrHandle,
66         "AudioBindServiceRender"));
67     ASSERT_NE(nullptr, BindServiceRender);
68     CloseServiceRender = (void (*)(static_cast<struct DevHandle *>))dlsym(ptrHandle, "AudioCloseServiceRender");
69     ASSERT_NE(nullptr, CloseServiceRender);
70 }
71 
TearDownTestCase(void)72 void AudioAlsaLibRenderTest::TearDownTestCase(void)
73 {
74     if (InterfaceLibOutputRender != nullptr) {
75         InterfaceLibOutputRender = nullptr;
76     }
77     if (InterfaceLibCtlRender != nullptr) {
78         InterfaceLibCtlRender = nullptr;
79     }
80     if (ptrHandle != nullptr) {
81         dlclose(ptrHandle);
82         ptrHandle = nullptr;
83     }
84 }
85 
SetUp(void)86 void AudioAlsaLibRenderTest::SetUp(void)
87 {
88     handle = BindServiceRender(BIND_CONTROL.c_str());
89     ASSERT_NE(nullptr, handle);
90 }
91 
TearDown(void)92 void AudioAlsaLibRenderTest::TearDown(void)
93 {
94     CloseServiceRender(handle);
95 }
96 
PcmBytesToFrames(const struct AudioFrameRenderMode & frameRenderMode,uint64_t bytes) const97 uint32_t AudioAlsaLibRenderTest::PcmBytesToFrames(const struct AudioFrameRenderMode &frameRenderMode,
98                                                   uint64_t bytes) const
99 {
100     uint32_t replyByte = static_cast<uint32_t>(bytes);
101     uint32_t frameCount = (frameRenderMode.attrs.channelCount * (PcmFormatToBits(frameRenderMode.attrs.format) >>
102         MOVE_RIGHT_NUM));
103     if (frameCount == 0) {
104         return 0;
105     }
106     return replyByte / frameCount;
107 }
108 
109 /**
110  * @brief Reading audio file frame.
111  *
112  * @param file audio file path
113  * @param AudioSampleAttributes
114  * @param struct AudioHeadInfo wavHeadInfo
115  * @param struct AudioHwRender *hwRender
116  *
117  * @return Returns <b>0</b> if the initialization is successful; returns a negative value otherwise.
118  */
FrameLibStart(FILE * file,struct AudioSampleAttributes attrs,struct AudioHeadInfo wavHeadInfo,struct AudioHwRender * hwRender) const119 int32_t AudioAlsaLibRenderTest::FrameLibStart(FILE *file, struct AudioSampleAttributes attrs,
120     struct AudioHeadInfo wavHeadInfo, struct AudioHwRender *hwRender) const
121 {
122     if (hwRender == nullptr) {
123         return HDF_FAILURE;
124     }
125     size_t numRead = 0;
126     uint32_t remainingDataSize = wavHeadInfo.dataSize;
127     uint32_t bufferSize = PcmFramesToBytes(attrs);
128     if (bufferSize <= 0) {
129         return HDF_FAILURE;
130     }
131     hwRender->renderParam.frameRenderMode.buffer = static_cast<char *>(calloc(1, bufferSize));
132     if (hwRender->renderParam.frameRenderMode.buffer == nullptr) {
133         return HDF_FAILURE;
134     }
135 
136     uint32_t readSize = (remainingDataSize > bufferSize) ? bufferSize : remainingDataSize;
137     numRead = fread(hwRender->renderParam.frameRenderMode.buffer, readSize, 1, file);
138     if (numRead < 1) {
139         free(hwRender->renderParam.frameRenderMode.buffer);
140         hwRender->renderParam.frameRenderMode.buffer = nullptr;
141         return HDF_FAILURE;
142     }
143     hwRender->renderParam.frameRenderMode.bufferSize = readSize;
144     uint32_t bufferFrameSize = PcmBytesToFrames(hwRender->renderParam.frameRenderMode, readSize);
145     if (bufferFrameSize <= 0) {
146         return HDF_FAILURE;
147     }
148     hwRender->renderParam.frameRenderMode.bufferFrameSize = bufferFrameSize;
149     return HDF_SUCCESS;
150 }
151 
LibRenderStart(struct AudioHwRender * hwRender,struct DevHandle * handlerender) const152 int32_t AudioAlsaLibRenderTest::LibRenderStart(struct AudioHwRender *hwRender, struct DevHandle *handlerender) const
153 {
154     if (hwRender == nullptr) {
155         return HDF_FAILURE;
156     }
157 
158     if (InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam) ||
159         InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam) ||
160         InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam) ||
161         InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam)) {
162         return HDF_FAILURE;
163     }
164     return HDF_SUCCESS;
165 }
166 
CreatHwRender(struct AudioHwRender * & hwRender,const std::string adapterNameCase) const167 int32_t AudioAlsaLibRenderTest::CreatHwRender(struct AudioHwRender *&hwRender, const std::string adapterNameCase) const
168 {
169     int32_t ret = HDF_FAILURE;
170     hwRender = static_cast<struct AudioHwRender *>(calloc(1, sizeof(*hwRender)));
171     if (hwRender == nullptr) {
172         return HDF_FAILURE;
173     }
174     ret = InitHwRender(hwRender, adapterNameCase);
175     if (ret != HDF_SUCCESS) {
176         free(hwRender);
177         hwRender = nullptr;
178         return HDF_FAILURE;
179     }
180     return HDF_SUCCESS;
181 }
182 /**
183 * @tc.name  AudioInterfaceLibOutputRenderOpen_001
184 * @tc.desc  test Audio Alsalib Interface OutputRender.return 0 if the Interface call successful.
185 * @tc.type: FUNC
186 */
187 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderOpen_001, TestSize.Level1)
188 {
189     int32_t ret = HDF_FAILURE;
190     struct AudioHwRender *hwRender = nullptr;
191     ASSERT_NE(nullptr, handle);
192     ret = CreatHwRender(hwRender, ADAPTER_NAME);
193     ASSERT_EQ(HDF_SUCCESS, ret);
194     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
195     EXPECT_EQ(HDF_SUCCESS, ret);
196     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
197     EXPECT_EQ(HDF_SUCCESS, ret);
198     free(hwRender);
199     hwRender = nullptr;
200 }
201 /**
202 * @tc.name  AudioInterfaceLibOutputRenderOpen_002
203 * @tc.desc  test Audio lib Interface OutputRender.return -1 if stting cmdid is AUDIO_DRV_PCM_IOCTL_RENDER_OPEN twins.
204 * @tc.type: FUNC
205 */
206 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderOpen_002, TestSize.Level1)
207 {
208     int32_t ret = HDF_FAILURE;
209     struct AudioHwRender *hwRender = nullptr;
210     ASSERT_NE(nullptr, handle);
211     ret = CreatHwRender(hwRender, ADAPTER_NAME);
212     ASSERT_EQ(HDF_SUCCESS, ret);
213     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
214     EXPECT_EQ(HDF_SUCCESS, ret);
215     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
216     EXPECT_EQ(HDF_ERR_DEVICE_BUSY, ret);
217     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
218     EXPECT_EQ(HDF_SUCCESS, ret);
219     free(hwRender);
220     hwRender = nullptr;
221 }
222 /**
223 * @tc.name  AudioInterfaceLibOutputRenderClose_001
224 * @tc.desc  test Audio lib Interface OutputRender.return -1 if without opning.
225 * @tc.type: FUNC
226 */
227 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderClose_001, TestSize.Level1)
228 {
229     int32_t ret = HDF_FAILURE;
230     struct AudioHwRender *hwRender = nullptr;
231     ASSERT_NE(nullptr, handle);
232     ret = CreatHwRender(hwRender, ADAPTER_NAME);
233     ASSERT_EQ(HDF_SUCCESS, ret);
234     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
235     EXPECT_EQ(HDF_FAILURE, ret);
236     free(hwRender);
237     hwRender = nullptr;
238 }
239 /**
240 * @tc.name  AudioInterfaceLibOutputRenderClose_002
241 * @tc.desc  test Audio lib Interface OutputRender.return -1 if stting cmdid is AUDIO_DRV_PCM_IOCTL_RENDER_CLOSE twins.
242 * @tc.type: FUNC
243 */
244 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderClose_002, TestSize.Level1)
245 {
246     int32_t ret = HDF_FAILURE;
247     struct AudioHwRender *hwRender = nullptr;
248     ASSERT_NE(nullptr, handle);
249     ret = CreatHwRender(hwRender, ADAPTER_NAME);
250     ASSERT_EQ(HDF_SUCCESS, ret);
251     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
252     EXPECT_EQ(HDF_SUCCESS, ret);
253 
254     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
255     EXPECT_EQ(HDF_SUCCESS, ret);
256     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
257     EXPECT_EQ(HDF_FAILURE, ret);
258 
259     free(hwRender);
260     hwRender = nullptr;
261 }
262 /**
263 * @tc.name  AudioInterfaceLibOutputRenderHwParams_001
264 * @tc.desc  test Audio lib Interface OutputRender.return 0 if the Interface call successful.
265 * @tc.type: FUNC
266 */
267 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderHwParams_001, TestSize.Level1)
268 {
269     int32_t ret = HDF_FAILURE;
270     struct AudioHwRender *hwRender = nullptr;
271     ASSERT_NE(nullptr, handle);
272     ret = CreatHwRender(hwRender, ADAPTER_NAME);
273     ASSERT_EQ(HDF_SUCCESS, ret);
274     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
275     EXPECT_EQ(HDF_SUCCESS, ret);
276 
277     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam);
278     EXPECT_EQ(HDF_SUCCESS, ret);
279     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
280     EXPECT_EQ(HDF_SUCCESS, ret);
281     free(hwRender);
282     hwRender = nullptr;
283 }
284 /**
285 * @tc.name  AudioInterfaceLibOutputRenderHwParams_002
286 * @tc.desc  test Audio lib Interface OutputRender.return -1 if without opening.
287 * @tc.type: FUNC
288 */
289 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderHwParams_002, TestSize.Level1)
290 {
291     int32_t ret = HDF_FAILURE;
292     struct AudioHwRender *hwRender = nullptr;
293     ASSERT_NE(nullptr, handle);
294     ret = CreatHwRender(hwRender, ADAPTER_NAME);
295     ASSERT_EQ(HDF_SUCCESS, ret);
296     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam);
297     EXPECT_EQ(HDF_FAILURE, ret);
298 
299     free(hwRender);
300     hwRender = nullptr;
301 }
302 /**
303 * @tc.name  AudioInterfaceLibOutputRenderHwParams_003
304 * @tc.desc  test Audio lib Interface OutputRender.return 0 if the Interface call successful.
305 * @tc.type: FUNC
306 */
307 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderHwParams_003, TestSize.Level1)
308 {
309     int32_t ret = HDF_FAILURE;
310     struct AudioHwRender *hwRender = nullptr;
311     ASSERT_NE(nullptr, handle);
312     ret = CreatHwRender(hwRender, ADAPTER_NAME);
313     ASSERT_EQ(HDF_SUCCESS, ret);
314     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
315     EXPECT_EQ(HDF_SUCCESS, ret);
316 
317     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam);
318     EXPECT_EQ(HDF_SUCCESS, ret);
319     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam);
320     EXPECT_EQ(HDF_SUCCESS, ret);
321     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
322     EXPECT_EQ(HDF_SUCCESS, ret);
323     free(hwRender);
324     hwRender = nullptr;
325 }
326 /**
327 * @tc.name  AudioInterfaceLibOutputRenderPrepare_001
328 * @tc.desc  test Audio lib Interface OutputRender.return 0 if the Interface call successful.
329 * @tc.type: FUNC
330 */
331 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderPrepare_001, TestSize.Level1)
332 {
333     int32_t ret = HDF_FAILURE;
334     struct AudioHwRender *hwRender = nullptr;
335     ASSERT_NE(nullptr, handle);
336     ret = CreatHwRender(hwRender, ADAPTER_NAME);
337     ASSERT_EQ(HDF_SUCCESS, ret);
338 
339     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
340     EXPECT_EQ(HDF_SUCCESS, ret);
341     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam);
342     EXPECT_EQ(HDF_SUCCESS, ret);
343     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam);
344     EXPECT_EQ(HDF_SUCCESS, ret);
345     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
346     EXPECT_EQ(HDF_SUCCESS, ret);
347     free(hwRender);
348     hwRender = nullptr;
349 }
350 /**
351 * @tc.name  AudioInterfaceLibOutputRenderPrepare_002
352 * @tc.desc  test Audio lib Interface OutputRender.return -1 if without setting params.
353 * @tc.type: FUNC
354 */
355 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderPrepare_002, TestSize.Level1)
356 {
357     int32_t ret = HDF_FAILURE;
358     struct AudioHwRender *hwRender = nullptr;
359     ASSERT_NE(nullptr, handle);
360     ret = CreatHwRender(hwRender, ADAPTER_NAME);
361     ASSERT_EQ(HDF_SUCCESS, ret);
362 
363     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
364     EXPECT_EQ(HDF_SUCCESS, ret);
365     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam);
366     EXPECT_EQ(HDF_FAILURE, ret);
367     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
368     EXPECT_EQ(HDF_SUCCESS, ret);
369     free(hwRender);
370     hwRender = nullptr;
371 }
372 /**
373 * @tc.name  AudioInterfaceLibOutputRenderPrepare_003
374 * @tc.desc  test Audio lib Interface OutputRender.return -1 if the Interface call twice.
375 * @tc.type: FUNC
376 */
377 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderPrepare_003, TestSize.Level1)
378 {
379     int32_t ret = HDF_FAILURE;
380     struct AudioHwRender *hwRender = nullptr;
381     ASSERT_NE(nullptr, handle);
382     ret = CreatHwRender(hwRender, ADAPTER_NAME);
383     ASSERT_EQ(HDF_SUCCESS, ret);
384 
385     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
386     EXPECT_EQ(HDF_SUCCESS, ret);
387     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam);
388     EXPECT_EQ(HDF_SUCCESS, ret);
389     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam);
390     EXPECT_EQ(HDF_SUCCESS, ret);
391     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam);
392     EXPECT_EQ(HDF_SUCCESS, ret);
393 
394     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
395     EXPECT_EQ(HDF_SUCCESS, ret);
396     free(hwRender);
397     hwRender = nullptr;
398 }
399 
400 /**
401 * @tc.name  AudioInterfaceLibOutputRenderStart_Stop_001
402 * @tc.desc  test Audio lib Interface OutputRender.return 0 if the Interface call successful.
403 * @tc.type: FUNC
404 */
405 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderStart_001, TestSize.Level1)
406 {
407     int32_t ret = HDF_FAILURE;
408     struct AudioHwRender *hwRender = nullptr;
409     ASSERT_NE(nullptr, handle);
410     ret = CreatHwRender(hwRender, ADAPTER_NAME);
411     ASSERT_EQ(HDF_SUCCESS, ret);
412 
413     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam);
414     EXPECT_EQ(HDF_SUCCESS, ret);
415 
416     free(hwRender);
417     hwRender = nullptr;
418 }
419 
420 /**
421 * @tc.name  AudioInterfaceLibOutputRenderStart_Stop_001
422 * @tc.desc  test Audio lib Interface OutputRender.return 0 if without opening.
423 * @tc.type: FUNC
424 */
425 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderStop_001, TestSize.Level1)
426 {
427     int32_t ret = HDF_FAILURE;
428     struct AudioHwRender *hwRender = nullptr;
429     ASSERT_NE(nullptr, handle);
430     ret = CreatHwRender(hwRender, ADAPTER_NAME);
431     ASSERT_EQ(HDF_SUCCESS, ret);
432 
433     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
434     EXPECT_EQ(HDF_SUCCESS, ret);
435     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam);
436     EXPECT_EQ(HDF_SUCCESS, ret);
437     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam);
438     EXPECT_EQ(HDF_SUCCESS, ret);
439 
440     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam);
441     EXPECT_EQ(HDF_SUCCESS, ret);
442     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
443     EXPECT_EQ(HDF_SUCCESS, ret);
444     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
445     EXPECT_EQ(HDF_SUCCESS, ret);
446 
447     free(hwRender);
448     hwRender = nullptr;
449 }
450 /**
451 * @tc.name  AudioInterfaceLibOutputCaptureStop_002
452 * @tc.desc  test Audio lib Interface OutputCapture.return -1 if the Interface call unsuccessful.
453 * @tc.type: FUNC
454 */
455 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderStop_002, TestSize.Level1)
456 {
457     int32_t ret = HDF_FAILURE;
458     struct AudioHwRender *hwRender = nullptr;
459     ASSERT_NE(nullptr, handle);
460     ret = CreatHwRender(hwRender, ADAPTER_NAME);
461     ASSERT_EQ(HDF_SUCCESS, ret);
462 
463     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
464     EXPECT_EQ(HDF_FAILURE, ret);
465 
466     free(hwRender);
467     hwRender = nullptr;
468 }
469 /**
470 * @tc.name  AudioInterfaceLibOutputRenderStart_Stop_001
471 * @tc.desc  test Audio lib Interface OutputRender.return -1 if the Interface call twice.
472 * @tc.type: FUNC
473 */
474 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderStop_003, TestSize.Level1)
475 {
476     int32_t ret = HDF_FAILURE;
477     struct AudioHwRender *hwRender = nullptr;
478     ASSERT_NE(nullptr, handle);
479     ret = CreatHwRender(hwRender, ADAPTER_NAME);
480     ASSERT_EQ(HDF_SUCCESS, ret);
481 
482     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
483     EXPECT_EQ(HDF_SUCCESS, ret);
484     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam);
485     EXPECT_EQ(HDF_SUCCESS, ret);
486     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam);
487     EXPECT_EQ(HDF_SUCCESS, ret);
488 
489     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam);
490     EXPECT_EQ(HDF_SUCCESS, ret);
491     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
492     EXPECT_EQ(HDF_SUCCESS, ret);
493     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
494     EXPECT_EQ(HDF_SUCCESS, ret);
495 
496     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
497     EXPECT_EQ(HDF_SUCCESS, ret);
498 
499     free(hwRender);
500     hwRender = nullptr;
501 }
502 
503 /**
504 * @tc.name  AudioInterfaceLibOutputRenderWrite_001
505 * @tc.desc  test Audio lib Interface OutputRender and Normal data flow distribution.
506 * @tc.type: FUNC
507 */
508 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderWrite_001, TestSize.Level1)
509 {
510     int32_t ret = HDF_FAILURE;
511     struct AudioHeadInfo wavHeadInfo = {};
512     struct AudioHwRender *hwRender = nullptr;
513     ASSERT_NE(nullptr, handle);
514     ret = CreatHwRender(hwRender, ADAPTER_NAME);
515     ASSERT_EQ(HDF_SUCCESS, ret);
516     char absPath[PATH_MAX] = {0};
517     if (realpath(AUDIO_FILE.c_str(), absPath) == nullptr) {
518         free(hwRender);
519         ASSERT_NE(nullptr, realpath(AUDIO_FILE.c_str(), absPath));
520     }
521     FILE *file = fopen(absPath, "rb");
522     if (file == nullptr) {
523         free(hwRender);
524         ASSERT_NE(nullptr, file);
525     }
526     ret = LibRenderStart(hwRender, handle);
527     EXPECT_EQ(HDF_SUCCESS, ret);
528     ret = WavHeadAnalysis(wavHeadInfo, file, hwRender->renderParam.frameRenderMode.attrs);
529     EXPECT_EQ(HDF_SUCCESS, ret);
530     ret = FrameLibStart(file, hwRender->renderParam.frameRenderMode.attrs, wavHeadInfo, hwRender);
531     EXPECT_EQ(HDF_SUCCESS, ret);
532     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_WRITE, &hwRender->renderParam);
533     EXPECT_EQ(HDF_SUCCESS, ret);
534     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
535     EXPECT_EQ(HDF_SUCCESS, ret);
536     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
537     EXPECT_EQ(HDF_SUCCESS, ret);
538     if (hwRender->renderParam.frameRenderMode.buffer != nullptr) {
539         free(hwRender->renderParam.frameRenderMode.buffer);
540     }
541     free(hwRender);
542     fclose(file);
543 }
544 /**
545 * @tc.name  AudioInterfaceLibOutputRenderWrite_002
546 * @tc.desc  test Audio lib Interface OutputRender ，return -1 if without starting.
547 * @tc.type: FUNC
548 */
549 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderWrite_002, TestSize.Level1)
550 {
551     int32_t ret = HDF_FAILURE;
552     struct AudioHeadInfo wavHeadInfo = {};
553     struct AudioHwRender *hwRender = nullptr;
554     ASSERT_NE(nullptr, handle);
555     ret = CreatHwRender(hwRender, ADAPTER_NAME);
556     ASSERT_EQ(HDF_SUCCESS, ret);
557     char absPath[PATH_MAX] = {0};
558     if (realpath(AUDIO_FILE.c_str(), absPath) == nullptr) {
559         free(hwRender);
560         ASSERT_NE(nullptr, realpath(AUDIO_FILE.c_str(), absPath));
561     }
562     FILE *file = fopen(absPath, "rb");
563     if (file == nullptr) {
564         free(hwRender);
565         ASSERT_NE(nullptr, file);
566     }
567     ret = WavHeadAnalysis(wavHeadInfo, file, hwRender->renderParam.frameRenderMode.attrs);
568     EXPECT_EQ(HDF_SUCCESS, ret);
569     ret = FrameLibStart(file, hwRender->renderParam.frameRenderMode.attrs, wavHeadInfo, hwRender);
570     EXPECT_EQ(HDF_SUCCESS, ret);
571     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_WRITE, &hwRender->renderParam);
572     EXPECT_EQ(HDF_FAILURE, ret);
573     if (hwRender->renderParam.frameRenderMode.buffer != nullptr) {
574         free(hwRender->renderParam.frameRenderMode.buffer);
575     }
576     free(hwRender);
577     fclose(file);
578 }
579 
580 /**
581 * @tc.name  AudioInterfaceLibOutputRender_Abnormal_001
582 * @tc.desc  test Audio lib Interface OutputRender via cmdid is invalid and cmdid is 30,so Interface return -1.
583 * @tc.type: FUNC
584 */
585 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderAbnormal_001, TestSize.Level1)
586 {
587     int32_t ret = HDF_FAILURE;
588     struct AudioHwRender *hwRender = nullptr;
589     ASSERT_NE(nullptr, handle);
590     ret = CreatHwRender(hwRender, ADAPTER_NAME);
591     ASSERT_EQ(HDF_SUCCESS, ret);
592 
593     ret = InterfaceLibOutputRender(handle, 30, &hwRender->renderParam);
594     EXPECT_EQ(HDF_FAILURE, ret);
595     free(hwRender);
596     hwRender = nullptr;
597 }
598 /**
599 * @tc.name  AudioInterfaceLibOutputRenderAbnormal_002
600 * @tc.desc  test Audio lib Interface OutputRender, handleData is nullptr.
601 * @tc.type: FUNC
602 */
603 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderAbnormal_002, TestSize.Level1)
604 {
605     int32_t ret = HDF_FAILURE;
606     ASSERT_NE(nullptr, handle);
607     struct AudioHwRenderParam *handleData = nullptr;
608     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_WRITE, handleData);
609     EXPECT_EQ(HDF_FAILURE, ret);
610 }
611 /**
612 * @tc.name  AudioInterfaceLibCtlRenderGetVolthresholdRead_001
613 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ.
614 * @tc.type: FUNC
615 */
616 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibCtlRenderGetVolthresholdRead_001, TestSize.Level1)
617 {
618     int32_t ret = HDF_FAILURE;
619     float volumeThresholdValueMax = 0;
620     float volumeThresholdValueMin = 0;
621     float expMax = 100;
622     float expMin = 0;
623     struct AudioHwRender *hwRender = nullptr;
624     ASSERT_NE(nullptr, handle);
625     ret = CreatHwRender(hwRender, ADAPTER_NAME);
626     ASSERT_EQ(HDF_SUCCESS, ret);
627     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
628     EXPECT_EQ(HDF_SUCCESS, ret);
629     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam);
630     EXPECT_EQ(HDF_SUCCESS, ret);
631 
632     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
633     EXPECT_EQ(HDF_SUCCESS, ret);
634     volumeThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
635     volumeThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
636     EXPECT_EQ(expMax, volumeThresholdValueMax);
637     EXPECT_EQ(expMin, volumeThresholdValueMin);
638     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
639     EXPECT_EQ(HDF_SUCCESS, ret);
640 
641     free(hwRender);
642     hwRender = nullptr;
643 }
644 /**
645 * @tc.name  AudioInterfaceLibCtlRenderVolumeWriteRead_001
646 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
647 * @tc.type: FUNC
648 */
649 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibCtlRenderVolumeWriteRead_001, TestSize.Level1)
650 {
651     int32_t ret = HDF_FAILURE;
652     float volumeValue = 0;
653     float volumeThresholdValueMax = 0;
654     float volumeThresholdValueMin = 0;
655     float volumeBoundaryValue = 99.9;
656     float expectVolumeValue = 99;
657     ASSERT_NE(nullptr, handle);
658     struct AudioHwRender *hwRender = nullptr;
659     ret = CreatHwRender(hwRender, ADAPTER_NAME);
660     ASSERT_EQ(HDF_SUCCESS, ret);
661     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
662     EXPECT_EQ(HDF_SUCCESS, ret);
663 
664     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
665     EXPECT_EQ(HDF_SUCCESS, ret);
666     volumeThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
667     volumeThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
668 
669     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMax - 1;
670     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
671     EXPECT_EQ(HDF_SUCCESS, ret);
672     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
673     EXPECT_EQ(HDF_SUCCESS, ret);
674     volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
675     EXPECT_EQ(volumeThresholdValueMax - 1, volumeValue);
676 
677     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMin + 1;
678     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
679     EXPECT_EQ(HDF_SUCCESS, ret);
680     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
681     EXPECT_EQ(HDF_SUCCESS, ret);
682     volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
683     EXPECT_EQ(volumeThresholdValueMin + 1, volumeValue);
684     hwRender->renderParam.renderMode.ctlParam.volume = volumeBoundaryValue;
685     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
686     EXPECT_EQ(HDF_SUCCESS, ret);
687     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
688     EXPECT_EQ(HDF_SUCCESS, ret);
689     volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
690     EXPECT_EQ(expectVolumeValue, volumeValue);
691     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
692     EXPECT_EQ(HDF_SUCCESS, ret);
693     free(hwRender);
694     hwRender = nullptr;
695 }
696 /**
697 * @tc.name  AudioInterfaceLibCtlRenderVolumeWriteRead_002
698 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
699 * @tc.type: FUNC
700 */
701 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibCtlRenderVolumeWriteRead_002, TestSize.Level1)
702 {
703     int32_t ret = HDF_FAILURE;
704     struct AudioHwRender *hwRender = nullptr;
705     float volumeThresholdValueMax = 0;
706     float volumeThresholdValueMin = 0;
707     float volumeValue = 0;
708 
709     ASSERT_NE(nullptr, handle);
710     ret = CreatHwRender(hwRender, ADAPTER_NAME);
711     ASSERT_EQ(HDF_SUCCESS, ret);
712     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
713     EXPECT_EQ(HDF_SUCCESS, ret);
714 
715     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
716     EXPECT_EQ(HDF_SUCCESS, ret);
717     volumeThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
718     volumeThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
719 
720     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMin;
721     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
722     EXPECT_EQ(HDF_SUCCESS, ret);
723     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
724     EXPECT_EQ(HDF_SUCCESS, ret);
725     volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
726     EXPECT_EQ(volumeThresholdValueMin, volumeValue);
727 
728     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMax;
729     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
730     EXPECT_EQ(HDF_SUCCESS, ret);
731     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
732     EXPECT_EQ(HDF_SUCCESS, ret);
733     volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
734     EXPECT_EQ(volumeThresholdValueMax, volumeValue);
735     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
736     EXPECT_EQ(HDF_SUCCESS, ret);
737 
738     free(hwRender);
739     hwRender = nullptr;
740 }
741 /**
742 * @tc.name  AudioInterfaceLibCtlRenderVolumeWriteRead_003
743 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
744 * @tc.type: FUNC
745 */
746 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibCtlRenderVolumeWriteRead_003, TestSize.Level1)
747 {
748     int32_t ret = HDF_FAILURE;
749     struct AudioHwRender *hwRender = nullptr;
750     float volumeThresholdValueMax = 0;
751     float volumeThresholdValueMin = 0;
752 
753     ASSERT_NE(nullptr, handle);
754     ret = CreatHwRender(hwRender, ADAPTER_NAME);
755     ASSERT_EQ(HDF_SUCCESS, ret);
756     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
757     EXPECT_EQ(HDF_SUCCESS, ret);
758 
759     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
760     EXPECT_EQ(HDF_SUCCESS, ret);
761     volumeThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
762     volumeThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
763 
764     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMax + 1;
765     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
766     EXPECT_EQ(HDF_SUCCESS, ret);
767 
768     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMin - 1;
769     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
770     EXPECT_EQ(HDF_SUCCESS, ret);
771     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
772     EXPECT_EQ(HDF_SUCCESS, ret);
773 
774     free(hwRender);
775     hwRender = nullptr;
776 }
777 /**
778 * @tc.name  AudioInterfaceLibCtlRenderMuteWriteRead_001
779 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_MUTE_WRITE and AUDIODRV_CTL_IOCTL_MUTE_READ.
780 * @tc.type: FUNC
781 */
782 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibCtlRenderMuteWriteRead_001, TestSize.Level1)
783 {
784     int32_t ret = HDF_FAILURE;
785     bool muteValue = 1;
786     bool wishValue = 0;
787     bool expectedValue = 1;
788 
789     ASSERT_NE(nullptr, handle);
790     struct AudioHwRender *hwRender = nullptr;
791     ret = CreatHwRender(hwRender, ADAPTER_NAME);
792     ASSERT_EQ(HDF_SUCCESS, ret);
793     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
794     EXPECT_EQ(HDF_SUCCESS, ret);
795 
796     hwRender->renderParam.renderMode.ctlParam.mute = 1;
797     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam);
798     EXPECT_EQ(HDF_SUCCESS, ret);
799     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, &hwRender->renderParam);
800     EXPECT_EQ(HDF_SUCCESS, ret);
801     muteValue = hwRender->renderParam.renderMode.ctlParam.mute;
802     EXPECT_EQ(expectedValue, muteValue);
803 
804     hwRender->renderParam.renderMode.ctlParam.mute = 0;
805     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam);
806     EXPECT_EQ(HDF_SUCCESS, ret);
807     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, &hwRender->renderParam);
808     EXPECT_EQ(HDF_SUCCESS, ret);
809     muteValue = hwRender->renderParam.renderMode.ctlParam.mute;
810     EXPECT_EQ(wishValue, muteValue);
811     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
812     EXPECT_EQ(HDF_SUCCESS, ret);
813 
814     free(hwRender);
815     hwRender = nullptr;
816 }
817 /**
818 * @tc.name  AudioInterfaceLibCtlRenderPause_001
819 * @tc.desc  test InterfaceLibOutputRender,cmdId is AUDIODRV_CTL_IOCTL_PAUSE_WRITE.
820 * @tc.type: FUNC
821 */
822 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderPause_001, TestSize.Level1)
823 {
824     int32_t ret = HDF_FAILURE;
825 
826     ASSERT_NE(nullptr, handle);
827     struct AudioHwRender *hwRender = nullptr;
828     ret = CreatHwRender(hwRender, ADAPTER_NAME);
829     ASSERT_EQ(HDF_SUCCESS, ret);
830 
831     ret = LibRenderStart(hwRender, handle);
832     EXPECT_EQ(HDF_SUCCESS, ret);
833     hwRender->renderParam.renderMode.ctlParam.pause = 1;
834     ret = InterfaceLibOutputRender(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE, &hwRender->renderParam);
835     EXPECT_EQ(HDF_SUCCESS, ret);
836     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
837     EXPECT_EQ(HDF_SUCCESS, ret);
838     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
839     EXPECT_EQ(HDF_SUCCESS, ret);
840 
841     free(hwRender);
842     hwRender = nullptr;
843 }
844 
845 /**
846 * @tc.name  AudioInterfaceLibOutputRenderResume_001
847 * @tc.desc  test InterfaceLibOutputRender,cmdId is AUDIODRV_CTL_IOCTL_PAUSE_WRITE.
848 * @tc.type: FUNC
849 */
850 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibOutputRenderResume_001, TestSize.Level1)
851 {
852     int32_t ret = HDF_FAILURE;
853     ASSERT_NE(nullptr, handle);
854     struct AudioHwRender *hwRender = nullptr;
855     ret = CreatHwRender(hwRender, ADAPTER_NAME);
856     ASSERT_EQ(HDF_SUCCESS, ret);
857 
858     ret = LibRenderStart(hwRender, handle);
859     EXPECT_EQ(HDF_SUCCESS, ret);
860     hwRender->renderParam.renderMode.ctlParam.pause = 0;
861     ret = InterfaceLibOutputRender(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE, &hwRender->renderParam);
862     EXPECT_EQ(HDF_SUCCESS, ret);
863     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
864     EXPECT_EQ(HDF_SUCCESS, ret);
865     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
866     EXPECT_EQ(HDF_SUCCESS, ret);
867 
868     free(hwRender);
869     hwRender = nullptr;
870 }
871 /**
872 * @tc.name  AudioInterfaceLibCtlRenderGainThresholdRead_001
873 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE and AUDIODRV_CTL_IOCTL_GAIN_READ.
874 * @tc.type: FUNC
875 */
876 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibCtlRenderGainThresholdRead_001, TestSize.Level1)
877 {
878     int32_t ret = HDF_FAILURE;
879     struct AudioHwRender *hwRender = nullptr;
880     ASSERT_NE(nullptr, handle);
881     ret = CreatHwRender(hwRender, ADAPTER_NAME);
882     ASSERT_EQ(HDF_SUCCESS, ret);
883 
884     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam);
885     EXPECT_EQ(HDF_SUCCESS, ret);
886 
887     free(hwRender);
888     hwRender = nullptr;
889 }
890 /**
891 * @tc.name  AudioInterfaceLibCtlRenderGainWriteRead_001
892 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE and AUDIODRV_CTL_IOCTL_GAIN_READ.
893 * @tc.type: FUNC
894 */
895 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibCtlRenderGainWriteRead_001, TestSize.Level1)
896 {
897     int32_t ret = HDF_FAILURE;
898     ASSERT_NE(nullptr, handle);
899     struct AudioHwRender *hwRender = nullptr;
900     ret = CreatHwRender(hwRender, ADAPTER_NAME);
901     ASSERT_EQ(HDF_SUCCESS, ret);
902 
903     hwRender->renderParam.renderMode.ctlParam.audioGain.gain = 1;
904     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
905     EXPECT_EQ(HDF_SUCCESS, ret);
906     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
907     EXPECT_EQ(HDF_SUCCESS, ret);
908     free(hwRender);
909     hwRender = nullptr;
910 }
911 /**
912 * @tc.name  AudioInterfaceLibCtlRenderChannelModeWriteRead_001
913 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE
914 *    and AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ.
915 * @tc.type: FUNC
916 */
917 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibCtlRenderChannelModeWriteRead_001, TestSize.Level1)
918 {
919     int32_t ret = HDF_FAILURE;
920     ASSERT_NE(nullptr, handle);
921     struct AudioHwRender *hwRender = nullptr;
922     ret = CreatHwRender(hwRender, ADAPTER_NAME);
923     ASSERT_EQ(HDF_SUCCESS, ret);
924 
925     hwRender->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_BOTH_RIGHT;
926     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &hwRender->renderParam);
927     EXPECT_EQ(HDF_SUCCESS, ret);
928     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &hwRender->renderParam);
929     EXPECT_EQ(HDF_SUCCESS, ret);
930 
931     free(hwRender);
932     hwRender = nullptr;
933 }
934 /**
935 * @tc.name  AudioInterfaceLibCtlRenderSelectScene_001
936 * @tc.desc  test InterfaceLibCtlRender,cmdId is AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE.
937 * @tc.type: FUNC
938 */
939 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibCtlRenderSelectScene_001, TestSize.Level1)
940 {
941     int32_t ret = HDF_FAILURE;
942     ASSERT_NE(nullptr, handle);
943     struct AudioHwRender *hwRender = nullptr;
944     ret = CreatHwRender(hwRender, ADAPTER_NAME);
945     ASSERT_EQ(HDF_SUCCESS, ret);
946     ret = LibRenderStart(hwRender, handle);
947     EXPECT_EQ(HDF_SUCCESS, ret);
948 
949     struct AudioSceneDescriptor scene = {};
950     scene.scene.id = 0;
951     scene.desc.pins = PIN_OUT_HEADSET;
952 
953     hwRender->renderParam.renderMode.hwInfo.pathSelect.deviceInfo.deviceNum = 1;
954     ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[0].deviceSwitch,
955         PATHPLAN_COUNT, "Dacl enable");
956     hwRender->renderParam.renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[0].value = 0;
957     hwRender->renderParam.frameRenderMode.attrs.type = (enum AudioCategory)(scene.scene.id);
958     hwRender->renderParam.renderMode.hwInfo.deviceDescript.pins = scene.desc.pins;
959 
960     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE, &hwRender->renderParam);
961     EXPECT_EQ(HDF_SUCCESS, ret);
962     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
963     EXPECT_EQ(HDF_SUCCESS, ret);
964     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
965     EXPECT_EQ(HDF_SUCCESS, ret);
966 
967     free(hwRender);
968     hwRender = nullptr;
969 }
970 
971 /**
972 * @tc.name  AudioInterfaceLibCtlRenderReqMmpbuffer_001
973 * @tc.desc  test InterfaceLibCtlRender ,return 0 if the Interface call successful.
974 * @tc.type: FUNC
975 */
976 HWTEST_F(AudioAlsaLibRenderTest, AudioInterfaceLibCtlRenderReqMmpbuffer_001, TestSize.Level1)
977 {
978     int32_t ret = HDF_FAILURE;
979     int64_t fileSize = 0;
980 
981     ASSERT_NE(nullptr, handle);
982     struct AudioHwRender *hwRender = nullptr;
983     ret = CreatHwRender(hwRender, ADAPTER_NAME);
984     ASSERT_EQ(HDF_SUCCESS, ret);
985     ret = LibRenderStart(hwRender, handle);
986     EXPECT_EQ(HDF_SUCCESS, ret);
987     ret = RenderReqMmapBufferInit(hwRender->renderParam.frameRenderMode, LOW_LATENCY_AUDIO_FILE, fileSize);
988     EXPECT_EQ(HDF_SUCCESS, ret);
989     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER, &hwRender->renderParam);
990     EXPECT_EQ(HDF_SUCCESS, ret);
991 
992     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
993     EXPECT_EQ(HDF_SUCCESS, ret);
994     ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
995     EXPECT_EQ(HDF_SUCCESS, ret);
996     munmap(hwRender->renderParam.frameRenderMode.mmapBufDesc.memoryAddress, fileSize);
997     free(hwRender);
998     hwRender = nullptr;
999 }
1000 }