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
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Audio;
22
23 namespace {
24 const string BIND_CONTROL = "control";
25 const string BIND_RENDER = "render";
26 const string BIND_NAME_ERROR = "rendor";
27 class AudioLibRenderTest : public testing::Test {
28 public:
29 static void SetUpTestCase(void);
30 static void TearDownTestCase(void);
31 void SetUp();
32 void TearDown();
33 static struct DevHandle *(*BindServiceRenderSo)(const char *serverName);
34 static int32_t (*InterfaceLibOutputRender)(struct DevHandle *handle, int cmdId,
35 struct AudioHwRenderParam *handleData);
36 static int32_t (*InterfaceLibCtlRender)(struct DevHandle *handle, int cmdId,
37 struct AudioHwRenderParam *handleData);
38 static void (*CloseServiceRenderSo)(struct DevHandle *handle);
39 static void *ptrHandle;
40 uint32_t PcmBytesToFrames(const struct AudioFrameRenderMode &frameRenderMode, uint64_t bytes) const;
41 int32_t FrameLibStart(FILE *file, struct AudioSampleAttributes attrs,
42 struct AudioHeadInfo wavHeadInfo, struct AudioHwRender *hwRender) const;
43 int32_t LibStartAndStream(const std::string path, struct AudioSampleAttributes attrs,
44 struct DevHandle *handle, struct AudioHwRender *hwRender, struct AudioHeadInfo wavHeadInfo) const;
45 int32_t LibHwOutputRender(struct AudioHwRender *hwRender, struct DevHandle *handlerender) const;
46 int32_t BindServiceAndHwRender(struct AudioHwRender *&hwRender,
47 const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const;
48 };
49
50 struct DevHandle *(*AudioLibRenderTest::BindServiceRenderSo)(const char *serverName) = nullptr;
51 int32_t (*AudioLibRenderTest::InterfaceLibOutputRender)(struct DevHandle *handle, int cmdId,
52 struct AudioHwRenderParam *handleData) = nullptr;
53 int32_t (*AudioLibRenderTest::InterfaceLibCtlRender)(struct DevHandle *handle, int cmdId,
54 struct AudioHwRenderParam *handleData) = nullptr;
55 void (*AudioLibRenderTest::CloseServiceRenderSo)(struct DevHandle *handle) = nullptr;
56 void *AudioLibRenderTest::ptrHandle = nullptr;
57
SetUpTestCase(void)58 void AudioLibRenderTest::SetUpTestCase(void)
59 {
60 char resolvedPath[] = HDF_LIBRARY_FULL_PATH("libaudio_render_adapter");
61 ptrHandle = dlopen(resolvedPath, RTLD_LAZY);
62 if (ptrHandle == nullptr) {
63 return;
64 }
65 BindServiceRenderSo = reinterpret_cast<struct DevHandle* (*)(const char *serverName)>(dlsym(ptrHandle,
66 "AudioBindServiceRender"));
67 InterfaceLibOutputRender = reinterpret_cast<int32_t (*)(struct DevHandle *, int cmdId,
68 struct AudioHwRenderParam *handleData)>(dlsym(ptrHandle, "AudioInterfaceLibOutputRender"));
69 InterfaceLibCtlRender = reinterpret_cast<int32_t (*)(struct DevHandle *, int cmdId,
70 struct AudioHwRenderParam *handleData)>(dlsym(ptrHandle, "AudioInterfaceLibCtlRender"));
71 CloseServiceRenderSo = reinterpret_cast<void (*)(struct DevHandle *)>(dlsym(ptrHandle, "AudioCloseServiceRender"));
72 if (BindServiceRenderSo == nullptr || CloseServiceRenderSo == nullptr ||
73 InterfaceLibCtlRender == nullptr || InterfaceLibOutputRender == nullptr) {
74 dlclose(ptrHandle);
75 return;
76 }
77 }
78
TearDownTestCase(void)79 void AudioLibRenderTest::TearDownTestCase(void)
80 {
81 if (BindServiceRenderSo != nullptr) {
82 BindServiceRenderSo = nullptr;
83 }
84 if (CloseServiceRenderSo != nullptr) {
85 CloseServiceRenderSo = nullptr;
86 }
87 if (InterfaceLibOutputRender != nullptr) {
88 InterfaceLibOutputRender = nullptr;
89 }
90 if (InterfaceLibCtlRender != nullptr) {
91 InterfaceLibCtlRender = nullptr;
92 }
93 if (ptrHandle != nullptr) {
94 dlclose(ptrHandle);
95 ptrHandle = nullptr;
96 }
97 }
98
SetUp(void)99 void AudioLibRenderTest::SetUp(void) {}
100
TearDown(void)101 void AudioLibRenderTest::TearDown(void) {}
102
PcmBytesToFrames(const struct AudioFrameRenderMode & frameRenderMode,uint64_t bytes) const103 uint32_t AudioLibRenderTest::PcmBytesToFrames(const struct AudioFrameRenderMode &frameRenderMode, uint64_t bytes) const
104 {
105 uint32_t replyByte = static_cast<uint32_t>(bytes);
106 return replyByte / (frameRenderMode.attrs.channelCount * (PcmFormatToBits(frameRenderMode.attrs.format) >>
107 MOVE_RIGHT_NUM));
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 AudioLibRenderTest::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 hwRender->renderParam.frameRenderMode.bufferFrameSize =
146 PcmBytesToFrames(hwRender->renderParam.frameRenderMode, readSize);
147 return HDF_SUCCESS;
148 }
149
LibStartAndStream(const std::string path,struct AudioSampleAttributes attrs,struct DevHandle * handle,struct AudioHwRender * hwRender,struct AudioHeadInfo wavHeadInfo) const150 int32_t AudioLibRenderTest::LibStartAndStream(const std::string path, struct AudioSampleAttributes attrs,
151 struct DevHandle *handle, struct AudioHwRender *hwRender, struct AudioHeadInfo wavHeadInfo) const
152 {
153 int ret = HDF_FAILURE;
154 if (handle == nullptr || hwRender == nullptr || InterfaceLibOutputRender == nullptr) {
155 return HDF_FAILURE;
156 }
157 if (InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam) ||
158 InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam) ||
159 InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam) ||
160 InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam)) {
161 return HDF_FAILURE;
162 }
163 char absPath[PATH_MAX] = {0};
164 if (realpath(path.c_str(), absPath) == nullptr) {
165 return HDF_FAILURE;
166 }
167 FILE *file = fopen(absPath, "rb");
168 if (file == nullptr) {
169 return HDF_FAILURE;
170 }
171 if (WavHeadAnalysis(wavHeadInfo, file, attrs)) {
172 (void)fclose(file);
173 return HDF_FAILURE;
174 }
175 ret = FrameLibStart(file, attrs, wavHeadInfo, hwRender);
176 if (ret < 0) {
177 (void)fclose(file);
178 return HDF_FAILURE;
179 }
180 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_WRITE, &hwRender->renderParam);
181 if (ret < 0) {
182 (void)fclose(file);
183 free(hwRender->renderParam.frameRenderMode.buffer);
184 hwRender->renderParam.frameRenderMode.buffer = nullptr;
185 return HDF_FAILURE;
186 }
187 (void)fclose(file);
188 free(hwRender->renderParam.frameRenderMode.buffer);
189 hwRender->renderParam.frameRenderMode.buffer = nullptr;
190 return HDF_SUCCESS;
191 }
192
LibHwOutputRender(struct AudioHwRender * hwRender,struct DevHandle * handlerender) const193 int32_t AudioLibRenderTest::LibHwOutputRender(struct AudioHwRender *hwRender, struct DevHandle *handlerender) const
194 {
195 if (hwRender == nullptr || handlerender == nullptr || InterfaceLibOutputRender == nullptr) {
196 return HDF_FAILURE;
197 }
198 if (InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam) ||
199 InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam) ||
200 InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam) ||
201 InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam)) {
202 return HDF_FAILURE;
203 }
204 return HDF_SUCCESS;
205 }
206
BindServiceAndHwRender(struct AudioHwRender * & hwRender,const std::string BindName,const std::string adapterNameCase,struct DevHandle * & handle) const207 int32_t AudioLibRenderTest::BindServiceAndHwRender(struct AudioHwRender *&hwRender,
208 const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const
209 {
210 if (BindServiceRenderSo == nullptr || CloseServiceRenderSo == nullptr) {
211 return HDF_FAILURE;
212 }
213 int32_t ret = HDF_FAILURE;
214 handle = BindServiceRenderSo(BindName.c_str());
215 if (handle == nullptr) {
216 return HDF_FAILURE;
217 }
218 hwRender = static_cast<struct AudioHwRender *>(calloc(1, sizeof(*hwRender)));
219 if (hwRender == nullptr) {
220 CloseServiceRenderSo(handle);
221 return HDF_FAILURE;
222 }
223 ret = InitHwRender(hwRender, adapterNameCase);
224 if (ret != HDF_SUCCESS) {
225 CloseServiceRenderSo(handle);
226 free(hwRender);
227 hwRender = nullptr;
228 return HDF_FAILURE;
229 }
230 return HDF_SUCCESS;
231 }
232 /**
233 * @tc.name AudioInterfaceLibBindServiceRender_001
234 * @tc.desc test Binding succeeded Service which service Name is control_service and close Service.
235 * @tc.type: FUNC
236 */
237 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibBindServiceRender_001, TestSize.Level1)
238 {
239 struct DevHandle *handle = nullptr;
240 ASSERT_TRUE((BindServiceRenderSo != nullptr && CloseServiceRenderSo != nullptr));
241 handle = BindServiceRenderSo(BIND_CONTROL.c_str());
242 ASSERT_NE(nullptr, handle);
243 CloseServiceRenderSo(handle);
244 }
245 /**
246 * @tc.name AudioInterfaceLibBindServiceRender_002
247 * @tc.desc test Binding failed service, where the service name is wrong.
248 * @tc.type: FUNC
249 */
250 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibBindServiceRender_002, TestSize.Level1)
251 {
252 struct DevHandle *handle = nullptr;
253 ASSERT_TRUE((BindServiceRenderSo != nullptr && CloseServiceRenderSo != nullptr));
254 handle = BindServiceRenderSo(BIND_NAME_ERROR.c_str());
255 if (handle != nullptr) {
256 CloseServiceRenderSo(handle);
257 ASSERT_EQ(nullptr, handle);
258 }
259 EXPECT_EQ(nullptr, handle);
260 }
261 /**
262 * @tc.name AudioInterfaceLibBindServiceRender_003
263 * @tc.desc test Binding failed Service, nullptr pointer passed in.
264 * @tc.type: FUNC
265 */
266 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibBindServiceRender_003, TestSize.Level1)
267 {
268 struct DevHandle *handle = nullptr;
269 char *bindNameNull = nullptr;
270 ASSERT_TRUE((BindServiceRenderSo != nullptr && CloseServiceRenderSo != nullptr));
271 handle = BindServiceRenderSo(bindNameNull);
272 if (handle != nullptr) {
273 CloseServiceRenderSo(handle);
274 ASSERT_EQ(nullptr, handle);
275 }
276 EXPECT_EQ(nullptr, handle);
277 }
278 /**
279 * @tc.name AudioInterfaceLibBindServiceRender_004
280 * @tc.desc test Binding failed Service, Log printing 'service name not support!' and 'Failed to get service!'.
281 * @tc.type: FUNC
282 */
283 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibBindServiceRender_004, TestSize.Level1)
284 {
285 struct DevHandle *handle = nullptr;
286 string bindNameOverLen = "renderrenderedededededede";
287 ASSERT_TRUE((BindServiceRenderSo != nullptr && CloseServiceRenderSo != nullptr));
288 handle = BindServiceRenderSo(bindNameOverLen.c_str());
289 if (handle != nullptr) {
290 CloseServiceRenderSo(handle);
291 ASSERT_EQ(nullptr, handle);
292 }
293 EXPECT_EQ(nullptr, handle);
294 }
295 /**
296 * @tc.name AudioInterfaceLibBindServiceRender_005
297 * @tc.desc test Binding failed Service, Log printing 'Failed to snprintf_s'.
298 * @tc.type: FUNC
299 */
300 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibBindServiceRender_005, TestSize.Level1)
301 {
302 struct DevHandle *handle = nullptr;
303 string bindNameOverLen = "renderrenderededededededer";
304 ASSERT_TRUE((BindServiceRenderSo != nullptr && CloseServiceRenderSo != nullptr));
305 handle = BindServiceRenderSo(bindNameOverLen.c_str());
306 if (handle != nullptr) {
307 CloseServiceRenderSo(handle);
308 ASSERT_EQ(nullptr, handle);
309 }
310 EXPECT_EQ(nullptr, handle);
311 }
312 /**
313 * @tc.name AudioInterfaceLibCtlRenderMuteWriteRead_001
314 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_MUTE_WRITE and AUDIODRV_CTL_IOCTL_MUTE_READ.
315 * @tc.type: FUNC
316 */
317 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibCtlRenderMuteWriteRead_001, TestSize.Level1)
318 {
319 int32_t ret = HDF_FAILURE;
320 bool muteValue = 1;
321 bool wishValue = 0;
322 bool expectedValue = 1;
323 struct DevHandle *handle = nullptr;
324 struct AudioHwRender *hwRender = nullptr;
325 ASSERT_TRUE((InterfaceLibCtlRender != nullptr && CloseServiceRenderSo != nullptr));
326 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
327 ASSERT_EQ(HDF_SUCCESS, ret);
328
329 hwRender->renderParam.renderMode.ctlParam.mute = 0;
330 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam);
331 EXPECT_EQ(HDF_SUCCESS, ret);
332 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, &hwRender->renderParam);
333 EXPECT_EQ(HDF_SUCCESS, ret);
334 muteValue = hwRender->renderParam.renderMode.ctlParam.mute;
335 EXPECT_EQ(wishValue, muteValue);
336 hwRender->renderParam.renderMode.ctlParam.mute = 1;
337 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam);
338 EXPECT_EQ(HDF_SUCCESS, ret);
339 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, &hwRender->renderParam);
340 EXPECT_EQ(HDF_SUCCESS, ret);
341 muteValue = hwRender->renderParam.renderMode.ctlParam.mute;
342 EXPECT_EQ(expectedValue, muteValue);
343 CloseServiceRenderSo(handle);
344 free(hwRender);
345 hwRender = nullptr;
346 }
347 /**
348 * @tc.name AudioInterfaceLibCtlRenderMuteWriteRead_002
349 * @tc.desc test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_MUTE_WRITE and AUDIODRV_CTL_IOCTL_MUTE_READ.
350 * @tc.type: FUNC
351 */
352 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibCtlRenderMuteWriteRead_002, TestSize.Level1)
353 {
354 int32_t ret = HDF_FAILURE;
355 bool muteValue = 0;
356 bool wishValue = 0;
357 bool expectedValue = 1;
358 struct DevHandle *handle = nullptr;
359 struct AudioHwRender *hwRender = nullptr;
360 ASSERT_TRUE((InterfaceLibCtlRender != nullptr && CloseServiceRenderSo != nullptr));
361 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
362 ASSERT_EQ(HDF_SUCCESS, ret);
363
364 hwRender->renderParam.renderMode.ctlParam.mute = 2;
365 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam);
366 EXPECT_EQ(HDF_SUCCESS, ret);
367 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, &hwRender->renderParam);
368 EXPECT_EQ(HDF_SUCCESS, ret);
369 muteValue = hwRender->renderParam.renderMode.ctlParam.mute;
370 EXPECT_EQ(expectedValue, muteValue);
371 hwRender->renderParam.renderMode.ctlParam.mute = 0;
372 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam);
373 EXPECT_EQ(HDF_SUCCESS, ret);
374 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, &hwRender->renderParam);
375 EXPECT_EQ(HDF_SUCCESS, ret);
376 muteValue = hwRender->renderParam.renderMode.ctlParam.mute;
377 EXPECT_EQ(wishValue, muteValue);
378 CloseServiceRenderSo(handle);
379 free(hwRender);
380 hwRender = nullptr;
381 }
382 /**
383 * @tc.name AudioInterfaceLibCtlRenderAbnormal_001
384 * @tc.desc test InterfaceLibCtlRender, cmdId is invalid eg 50,so return -1.
385 * @tc.type: FUNC
386 */
387 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibCtlRenderAbnormal_001, TestSize.Level1)
388 {
389 int32_t ret = HDF_FAILURE;
390 struct DevHandle *handle = nullptr;
391 struct AudioHwRender *hwRender = nullptr;
392 ASSERT_TRUE((InterfaceLibCtlRender != nullptr && CloseServiceRenderSo != nullptr));
393 ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
394 ASSERT_EQ(HDF_SUCCESS, ret);
395 ret = InterfaceLibCtlRender(handle, 50, &hwRender->renderParam);
396 if (ret == 0) {
397 CloseServiceRenderSo(handle);
398 free(hwRender);
399 hwRender = nullptr;
400 ASSERT_EQ(HDF_FAILURE, ret);
401 }
402 EXPECT_EQ(HDF_FAILURE, ret);
403 CloseServiceRenderSo(handle);
404 free(hwRender);
405 hwRender = nullptr;
406 }
407 /**
408 * @tc.name AudioInterfaceLibCtlRenderAbnormal_002
409 * @tc.desc test InterfaceLibCtlRender, handleData is nullptr,so return -1.
410 * @tc.type: FUNC
411 */
412 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibCtlRenderAbnormal_002, TestSize.Level1)
413 {
414 int32_t ret = HDF_FAILURE;
415 struct DevHandle *handle = nullptr;
416 struct AudioHwRenderParam *handleData = nullptr;
417 ASSERT_TRUE((InterfaceLibCtlRender != nullptr && BindServiceRenderSo != nullptr &&
418 CloseServiceRenderSo != nullptr));
419 handle = BindServiceRenderSo(BIND_CONTROL.c_str());
420 ASSERT_NE(nullptr, handle);
421 ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, handleData);
422 if (ret == 0) {
423 CloseServiceRenderSo(handle);
424 ASSERT_EQ(HDF_FAILURE, ret);
425 }
426 EXPECT_EQ(HDF_FAILURE, ret);
427 CloseServiceRenderSo(handle);
428 }
429
430 /**
431 * @tc.name AudioInterfaceLibOutputRenderHwParams_001
432 * @tc.desc test Audio lib Interface OutputRender.return 0 if the Interface call successful.
433 * @tc.type: FUNC
434 */
435 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibOutputRenderHwParams_001, TestSize.Level1)
436 {
437 int32_t ret = HDF_FAILURE;
438 struct DevHandle *handle = nullptr;
439 struct AudioHwRender *hwRender = nullptr;
440 ASSERT_TRUE((InterfaceLibOutputRender != nullptr && CloseServiceRenderSo != nullptr));
441 ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME, handle);
442 ASSERT_EQ(HDF_SUCCESS, ret);
443 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
444 EXPECT_EQ(HDF_SUCCESS, ret);
445 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam);
446 EXPECT_EQ(HDF_SUCCESS, ret);
447 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
448 EXPECT_EQ(HDF_SUCCESS, ret);
449 CloseServiceRenderSo(handle);
450 free(hwRender);
451 hwRender = nullptr;
452 }
453 /**
454 * @tc.name AudioInterfaceLibOutputRenderPrepare_001
455 * @tc.desc test Audio lib Interface OutputRender.return 0 if the Interface call successful.
456 * @tc.type: FUNC
457 */
458 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibOutputRenderPrepare_001, TestSize.Level1)
459 {
460 int32_t ret = HDF_FAILURE;
461 struct AudioHwRender *hwRender = nullptr;
462 struct DevHandle *handle = nullptr;
463 ASSERT_TRUE((InterfaceLibOutputRender != nullptr && CloseServiceRenderSo != nullptr));
464 ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME, handle);
465 ASSERT_EQ(HDF_SUCCESS, ret);
466 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
467 EXPECT_EQ(HDF_SUCCESS, ret);
468 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam);
469 EXPECT_EQ(HDF_SUCCESS, ret);
470 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam);
471 EXPECT_EQ(HDF_SUCCESS, ret);
472 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
473 EXPECT_EQ(HDF_SUCCESS, ret);
474 CloseServiceRenderSo(handle);
475 free(hwRender);
476 hwRender = nullptr;
477 }
478 /**
479 * @tc.name AudioInterfaceLibOutputRenderStart_001
480 * @tc.desc test Audio lib Interface OutputRender.return 0 if the Interface call successful.
481 * @tc.type: FUNC
482 */
483 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibOutputRenderStart_001, TestSize.Level1)
484 {
485 int32_t ret = HDF_FAILURE;
486 struct DevHandle *handle = nullptr;
487 struct AudioHwRender *hwRender = nullptr;
488 ASSERT_TRUE((InterfaceLibOutputRender != nullptr && CloseServiceRenderSo != nullptr));
489 ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME, handle);
490 ASSERT_EQ(HDF_SUCCESS, ret);
491 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam);
492 EXPECT_EQ(HDF_SUCCESS, ret);
493 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam);
494 EXPECT_EQ(HDF_SUCCESS, ret);
495 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam);
496 EXPECT_EQ(HDF_SUCCESS, ret);
497 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam);
498 EXPECT_EQ(HDF_SUCCESS, ret);
499 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
500 EXPECT_EQ(HDF_SUCCESS, ret);
501 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
502 EXPECT_EQ(HDF_SUCCESS, ret);
503 CloseServiceRenderSo(handle);
504 free(hwRender);
505 hwRender = nullptr;
506 }
507 /**
508 * @tc.name AudioInterfaceLibOutputRenderWriteStop_001
509 * @tc.desc test Audio lib Interface OutputRender and Normal data flow distribution.
510 * @tc.type: FUNC
511 */
512 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibOutputRenderWriteStop_001, TestSize.Level1)
513 {
514 struct DevHandle *handle = nullptr;
515 struct AudioHeadInfo wavHeadInfo = {};
516 struct AudioHwRender *hwRender = nullptr;
517 ASSERT_TRUE((InterfaceLibOutputRender != nullptr && CloseServiceRenderSo != nullptr));
518 int32_t ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME, handle);
519 ASSERT_EQ(HDF_SUCCESS, ret);
520 ret = LibHwOutputRender(hwRender, handle);
521 EXPECT_EQ(HDF_SUCCESS, ret);
522 char absPath[PATH_MAX] = {0};
523 if (realpath(AUDIO_FILE.c_str(), absPath) == nullptr) {
524 free(hwRender);
525 CloseServiceRenderSo(handle);
526 ASSERT_NE(nullptr, realpath(AUDIO_FILE.c_str(), absPath));
527 }
528 FILE *file = fopen(absPath, "rb");
529 if (file == nullptr) {
530 free(hwRender);
531 CloseServiceRenderSo(handle);
532 ASSERT_NE(nullptr, file);
533 }
534 if (hwRender != nullptr) {
535 ret = WavHeadAnalysis(wavHeadInfo, file, hwRender->renderParam.frameRenderMode.attrs);
536 if (ret < 0) {
537 free(hwRender);
538 fclose(file);
539 CloseServiceRenderSo(handle);
540 ASSERT_EQ(HDF_SUCCESS, ret);
541 }
542 ret = FrameLibStart(file, hwRender->renderParam.frameRenderMode.attrs, wavHeadInfo, hwRender);
543 EXPECT_EQ(HDF_SUCCESS, ret);
544 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_WRITE, &hwRender->renderParam);
545 EXPECT_EQ(HDF_SUCCESS, ret);
546 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
547 EXPECT_EQ(HDF_SUCCESS, ret);
548 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
549 EXPECT_EQ(HDF_SUCCESS, ret);
550 if (hwRender->renderParam.frameRenderMode.buffer != nullptr) {
551 free(hwRender->renderParam.frameRenderMode.buffer);
552 }
553 free(hwRender);
554 }
555 CloseServiceRenderSo(handle);
556 fclose(file);
557 }
558 /**
559 transmission of data flow and control flow.
560 * @tc.name AudioInterfaceLibOutputRenderWrite_001
561 * @tc.desc test Audio lib Interface CtlRender and OutputRender, Data stream and control stream send successful.
562 * @tc.type: FUNC
563 */
564 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibOutputRenderWrite_001, TestSize.Level1)
565 {
566 int32_t ret = HDF_FAILURE;
567 float muteValue = 0;
568 float expectedValue = 0;
569 struct DevHandle *handler = nullptr;
570 struct DevHandle *handlec = nullptr;
571 struct AudioHeadInfo wavHeadInfo = {};
572 struct AudioHwRender *hwRender = nullptr;
573 ASSERT_TRUE((InterfaceLibOutputRender != nullptr && CloseServiceRenderSo != nullptr &&
574 InterfaceLibCtlRender != nullptr));
575 ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME, handler);
576 ASSERT_EQ(HDF_SUCCESS, ret);
577 handlec = BindServiceRenderSo(BIND_CONTROL.c_str());
578 if (handlec == nullptr) {
579 CloseServiceRenderSo(handler);
580 free(hwRender);
581 hwRender = nullptr;
582 ASSERT_NE(nullptr, handlec);
583 }
584 if (hwRender != nullptr) {
585 hwRender->renderParam.renderMode.ctlParam.mute = muteValue;
586 ret = InterfaceLibCtlRender(handlec, AUDIODRV_CTL_IOCTL_MUTE_WRITE, &hwRender->renderParam);
587 EXPECT_EQ(HDF_SUCCESS, ret);
588 ret = InterfaceLibCtlRender(handlec, AUDIODRV_CTL_IOCTL_MUTE_READ, &hwRender->renderParam);
589 EXPECT_EQ(HDF_SUCCESS, ret);
590 expectedValue = hwRender->renderParam.renderMode.ctlParam.mute;
591 EXPECT_EQ(expectedValue, muteValue);
592
593 ret = LibStartAndStream(AUDIO_FILE, hwRender->renderParam.frameRenderMode.attrs,
594 handler, hwRender, wavHeadInfo);
595 if (ret < 0) {
596 CloseServiceRenderSo(handler);
597 CloseServiceRenderSo(handlec);
598 free(hwRender);
599 ASSERT_EQ(HDF_SUCCESS, ret);
600 }
601 ret = InterfaceLibOutputRender(handler, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
602 EXPECT_EQ(HDF_SUCCESS, ret);
603 ret = InterfaceLibOutputRender(handler, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
604 EXPECT_EQ(HDF_SUCCESS, ret);
605 }
606 CloseServiceRenderSo(handler);
607 CloseServiceRenderSo(handlec);
608 free(hwRender);
609 hwRender = nullptr;
610 }
611 /**
612 * @tc.name AudioInterfaceLibCtlRenderPause_001
613 * @tc.desc test InterfaceLibOutputRender,cmdId is AUDIODRV_CTL_IOCTL_PAUSE_WRITE.
614 * @tc.type: FUNC
615 */
616 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibOutputRenderPause_001, TestSize.Level1)
617 {
618 int32_t ret = HDF_FAILURE;
619 struct DevHandle *handle = nullptr;
620 struct AudioHwRender *hwRender = nullptr;
621 ASSERT_TRUE((InterfaceLibOutputRender != nullptr && CloseServiceRenderSo != nullptr));
622 ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME, handle);
623 ASSERT_EQ(HDF_SUCCESS, ret);
624 ret = LibHwOutputRender(hwRender, handle);
625 EXPECT_EQ(HDF_SUCCESS, ret);
626 hwRender->renderParam.renderMode.ctlParam.pause = 1;
627 ret = InterfaceLibOutputRender(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE, &hwRender->renderParam);
628 EXPECT_EQ(HDF_SUCCESS, ret);
629 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
630 EXPECT_EQ(HDF_SUCCESS, ret);
631 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
632 EXPECT_EQ(HDF_SUCCESS, ret);
633 CloseServiceRenderSo(handle);
634 free(hwRender);
635 hwRender = nullptr;
636 }
637 /**
638 * @tc.name Audio_InterfaceLib_CtlRender_Resume_001
639 * @tc.desc test InterfaceLibOutputRender,cmdId is AUDIODRV_CTL_IOCTL_PAUSE_WRITE.
640 * @tc.type: FUNC
641 */
642 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibOutputRenderResume_001, TestSize.Level1)
643 {
644 int32_t ret = HDF_FAILURE;
645 struct DevHandle *handle = nullptr;
646 struct AudioHwRender *hwRender = nullptr;
647 ASSERT_TRUE((InterfaceLibOutputRender != nullptr && CloseServiceRenderSo != nullptr));
648 ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME, handle);
649 ASSERT_EQ(HDF_SUCCESS, ret);
650 ret = LibHwOutputRender(hwRender, handle);
651 EXPECT_EQ(HDF_SUCCESS, ret);
652 hwRender->renderParam.renderMode.ctlParam.pause = 0;
653 ret = InterfaceLibOutputRender(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE, &hwRender->renderParam);
654 EXPECT_EQ(HDF_SUCCESS, ret);
655 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_STOP, &hwRender->renderParam);
656 EXPECT_EQ(HDF_SUCCESS, ret);
657 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, &hwRender->renderParam);
658 EXPECT_EQ(HDF_SUCCESS, ret);
659 CloseServiceRenderSo(handle);
660 free(hwRender);
661 hwRender = nullptr;
662 }
663 /**
664 * @tc.name AudioInterfaceLibOutputRender_Abnormal_001
665 * @tc.desc test Audio lib Interface OutputRender via cmdid is invalid and cmdid is 30,so Interface return -1.
666 * @tc.type: FUNC
667 */
668 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibOutputRenderAbnormal_001, TestSize.Level1)
669 {
670 int32_t ret = HDF_FAILURE;
671 struct DevHandle *handle = nullptr;
672 struct AudioHwRender *hwRender = nullptr;
673 ASSERT_TRUE((InterfaceLibOutputRender != nullptr && CloseServiceRenderSo != nullptr));
674 ret = BindServiceAndHwRender(hwRender, BIND_RENDER.c_str(), ADAPTER_NAME, handle);
675 ASSERT_EQ(HDF_SUCCESS, ret);
676
677 ret = InterfaceLibOutputRender(handle, 30, &hwRender->renderParam);
678 EXPECT_EQ(HDF_FAILURE, ret);
679 CloseServiceRenderSo(handle);
680 free(hwRender);
681 hwRender = nullptr;
682 }
683 /**
684 * @tc.name AudioInterfaceLibOutputRenderAbnormal_002
685 * @tc.desc test Audio lib Interface OutputRender, handleData is nullptr.
686 * @tc.type: FUNC
687 */
688 HWTEST_F(AudioLibRenderTest, AudioInterfaceLibOutputRenderAbnormal_002, TestSize.Level1)
689 {
690 int32_t ret = HDF_FAILURE;
691 struct DevHandle *handle = nullptr;
692 struct AudioHwRenderParam *handleData = nullptr;
693 ASSERT_TRUE((InterfaceLibOutputRender != nullptr && CloseServiceRenderSo != nullptr &&
694 InterfaceLibCtlRender != nullptr));
695 handle = BindServiceRenderSo(BIND_RENDER.c_str());
696 ASSERT_NE(nullptr, handle);
697 ret = InterfaceLibOutputRender(handle, AUDIO_DRV_PCM_IOCTL_WRITE, handleData);
698 EXPECT_EQ(HDF_FAILURE, ret);
699 CloseServiceRenderSo(handle);
700 }
701 }
702