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