1 /*
2 * Copyright (c) 2022-2023 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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include "audio_internal.h"
19 #include "alsa_lib_render.h"
20
21 using namespace std;
22 using namespace testing::ext;
23 namespace {
24 constexpr int32_t channel = 2;
25 constexpr int32_t sampleRate = 48000;
26 constexpr int32_t volMin = 0;
27 constexpr int32_t volMax = 100;
28 constexpr int32_t frameData = 16 * 1024;
29 constexpr int32_t mmapFrameData = 256 * 1024;
30
31 const string BIND_CONTROL = "control";
32 const string BIND_RENDER = "render";
33
34 class AudioAlsaIfLibRenderTest : public testing::Test {
35 public:
36 static struct DevHandle *handle;
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp();
40 void TearDown();
41 int32_t AudioInterfaceRenderInit(struct AudioHwRenderParam *&handleData);
42 int32_t AudioInitHwParams(struct AudioHwRenderParam *&handleData);
43 int32_t AudioResourceRelease(struct AudioHwRenderParam *&handleData);
44 };
45
46 struct DevHandle *AudioAlsaIfLibRenderTest::handle = nullptr;
47
SetUpTestCase()48 void AudioAlsaIfLibRenderTest::SetUpTestCase()
49 {
50 }
51
TearDownTestCase()52 void AudioAlsaIfLibRenderTest::TearDownTestCase()
53 {
54 }
55
SetUp()56 void AudioAlsaIfLibRenderTest::SetUp()
57 {
58 handle = AudioBindService(BIND_RENDER.c_str());
59 }
60
TearDown()61 void AudioAlsaIfLibRenderTest::TearDown()
62 {
63 AudioCloseService(handle);
64 }
65
AudioInterfaceRenderInit(struct AudioHwRenderParam * & handleData)66 int32_t AudioAlsaIfLibRenderTest::AudioInterfaceRenderInit(struct AudioHwRenderParam *&handleData)
67 {
68 int32_t ret;
69 if (handleData == nullptr) {
70 return HDF_FAILURE;
71 }
72 ret = AudioOutputRenderOpen(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, handleData);
73 if (ret != HDF_SUCCESS) {
74 return HDF_FAILURE;
75 }
76 ret = AudioOutputRenderHwParams(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, handleData);
77 if (ret != HDF_SUCCESS) {
78 return HDF_FAILURE;
79 }
80 ret = AudioOutputRenderPrepare(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, handleData);
81 if (ret != HDF_SUCCESS) {
82 return HDF_FAILURE;
83 }
84 return HDF_SUCCESS;
85 }
86
87
AudioInitHwParams(struct AudioHwRenderParam * & handleData)88 int32_t AudioAlsaIfLibRenderTest::AudioInitHwParams(struct AudioHwRenderParam * &handleData)
89 {
90 if (handleData == nullptr) {
91 return HDF_FAILURE;
92 }
93 (void)memcpy_s(handleData->renderMode.hwInfo.adapterName, NAME_LEN, "primary", strlen("primary"));
94 handleData->frameRenderMode.attrs.channelCount = channel;
95 handleData->frameRenderMode.attrs.sampleRate = sampleRate;
96 handleData->frameRenderMode.attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
97 handleData->frameRenderMode.attrs.isBigEndian = false;
98 handleData->frameRenderMode.attrs.isSignedData = true;
99 return HDF_SUCCESS;
100 }
101
AudioResourceRelease(struct AudioHwRenderParam * & handleData)102 int32_t AudioAlsaIfLibRenderTest::AudioResourceRelease(struct AudioHwRenderParam *&handleData)
103 {
104 if (handleData == nullptr) {
105 return HDF_FAILURE;
106 }
107
108 int32_t ret = AudioOutputRenderClose(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, handleData);
109 EXPECT_EQ(HDF_SUCCESS, ret);
110 delete(handleData);
111 handleData = nullptr;
112 return HDF_SUCCESS;
113 }
114
115 HWTEST_F(AudioAlsaIfLibRenderTest, AudioOutputRenderOpen_001, TestSize.Level1)
116 {
117 struct AudioHwRenderParam *handleData = nullptr;
118 int32_t ret = AudioOutputRenderOpen(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, handleData);
119 EXPECT_EQ(HDF_FAILURE, ret);
120 }
121
122 HWTEST_F(AudioAlsaIfLibRenderTest, AudioOutputRenderOpen_002, TestSize.Level1)
123 {
124 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
125 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
126 (void)memcpy_s(handleData->renderMode.hwInfo.adapterName, NAME_LEN, "primary", strlen("primary"));
127 int32_t ret = AudioOutputRenderOpen(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, handleData);
128 EXPECT_EQ(HDF_SUCCESS, ret);
129 ret = AudioResourceRelease(handleData);
130 EXPECT_EQ(HDF_SUCCESS, ret);
131 }
132
133 HWTEST_F(AudioAlsaIfLibRenderTest, SetHwParams_001, TestSize.Level1)
134 {
135 struct AudioHwRenderParam *handleData = nullptr;
136 int32_t ret = AudioOutputRenderHwParams(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, handleData);
137 EXPECT_EQ(HDF_FAILURE, ret);
138 }
139
140 HWTEST_F(AudioAlsaIfLibRenderTest, SetHwParams_002, TestSize.Level1)
141 {
142 int32_t ret;
143 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
144 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
145 ret = AudioInitHwParams(handleData);
146 EXPECT_EQ(HDF_SUCCESS, ret);
147 ret = AudioOutputRenderOpen(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, handleData);
148 EXPECT_EQ(HDF_SUCCESS, ret);
149 ret = AudioOutputRenderHwParams(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, handleData);
150 EXPECT_EQ(HDF_SUCCESS, ret);
151 ret = AudioResourceRelease(handleData);
152 EXPECT_EQ(HDF_SUCCESS, ret);
153 }
154
155 HWTEST_F(AudioAlsaIfLibRenderTest, AudioOutputRenderPrepare_001, TestSize.Level1)
156 {
157 struct AudioHwRenderParam *handleData = nullptr;
158 int32_t ret = AudioOutputRenderPrepare(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, handleData);
159 EXPECT_EQ(HDF_FAILURE, ret);
160 }
161
162 HWTEST_F(AudioAlsaIfLibRenderTest, AudioOutputRenderPrepare_002, TestSize.Level1)
163 {
164 int32_t ret;
165 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
166 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
167 ret = AudioInitHwParams(handleData);
168 EXPECT_EQ(HDF_SUCCESS, ret);
169 ret = AudioOutputRenderOpen(handle, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, handleData);
170 EXPECT_EQ(HDF_SUCCESS, ret);
171 ret = AudioOutputRenderHwParams(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, handleData);
172 EXPECT_EQ(HDF_SUCCESS, ret);
173 ret = AudioOutputRenderPrepare(handle, AUDIO_DRV_PCM_IOCTL_PREPARE, handleData);
174 EXPECT_EQ(HDF_SUCCESS, ret);
175 ret = AudioResourceRelease(handleData);
176 EXPECT_EQ(HDF_SUCCESS, ret);
177 }
178
179 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderGetVolThreshold_001, TestSize.Level1)
180 {
181 struct AudioHwRenderParam *handleData = nullptr;
182 int32_t ret = AudioCtlRenderGetVolThreshold(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, handleData);
183 EXPECT_EQ(HDF_FAILURE, ret);
184 }
185
186 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderGetVolThreshold_002, TestSize.Level1)
187 {
188 int32_t ret;
189 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
190 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
191 ret = AudioInitHwParams(handleData);
192 EXPECT_EQ(HDF_SUCCESS, ret);
193 ret = AudioInterfaceRenderInit(handleData);
194 EXPECT_EQ(HDF_SUCCESS, ret);
195 ret = AudioCtlRenderGetVolThreshold(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, handleData);
196 EXPECT_EQ(HDF_SUCCESS, ret);
197 int32_t volumeMin = handleData->renderMode.ctlParam.volThreshold.volMin;
198 int32_t volumeMax = handleData->renderMode.ctlParam.volThreshold.volMax;
199 EXPECT_EQ(volMin, volumeMin);
200 EXPECT_EQ(volMax, volumeMax);
201 ret = AudioResourceRelease(handleData);
202 EXPECT_EQ(HDF_SUCCESS, ret);
203 }
204
205 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderGetVolume_001, TestSize.Level1)
206 {
207 struct AudioHwRenderParam *handleData = nullptr;
208 int32_t ret = AudioCtlRenderGetVolume(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, handleData);
209 EXPECT_EQ(HDF_FAILURE, ret);
210 }
211
212 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderGetVolume_002, TestSize.Level1)
213 {
214 int32_t ret;
215 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
216 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
217 ret = AudioInitHwParams(handleData);
218 EXPECT_EQ(HDF_SUCCESS, ret);
219 ret = AudioInterfaceRenderInit(handleData);
220 EXPECT_EQ(HDF_SUCCESS, ret);
221 ret = AudioCtlRenderGetVolume(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, handleData);
222 EXPECT_EQ(HDF_SUCCESS, ret);
223 int32_t vol = (int32_t)handleData->renderMode.ctlParam.volume;
224 EXPECT_GE(vol, volMin);
225 EXPECT_LE(vol, volMax);
226 ret = AudioResourceRelease(handleData);
227 EXPECT_EQ(HDF_SUCCESS, ret);
228 }
229
230 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderSetVolume_001, TestSize.Level1)
231 {
232 struct AudioHwRenderParam *handleData = nullptr;
233 int32_t ret = AudioCtlRenderSetVolume(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, handleData);
234 EXPECT_EQ(HDF_FAILURE, ret);
235 }
236
237 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderSetVolume_002, TestSize.Level1)
238 {
239 int32_t ret;
240 float setVol = 0.0;
241 float getVol = 0.0;
242 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
243 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
244 setVol = 80.0;
245 handleData->renderMode.ctlParam.volume = setVol;
246 ret = AudioInitHwParams(handleData);
247 EXPECT_EQ(HDF_SUCCESS, ret);
248 ret = AudioInterfaceRenderInit(handleData);
249 EXPECT_EQ(HDF_SUCCESS, ret);
250 ret = AudioCtlRenderSetVolume(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, handleData);
251 EXPECT_EQ(HDF_SUCCESS, ret);
252 ret = AudioCtlRenderGetVolume(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, handleData);
253 EXPECT_EQ(HDF_SUCCESS, ret);
254 getVol = handleData->renderMode.ctlParam.volume;
255 EXPECT_EQ(setVol, getVol);
256 ret = AudioResourceRelease(handleData);
257 EXPECT_EQ(HDF_SUCCESS, ret);
258 }
259
260 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderGetMuteStu_001, TestSize.Level1)
261 {
262 struct AudioHwRenderParam *handleData = nullptr;
263 int32_t ret = AudioCtlRenderGetMuteStu(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, handleData);
264 EXPECT_EQ(HDF_FAILURE, ret);
265 }
266
267 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderGetMuteStu_002, TestSize.Level1)
268 {
269 int32_t ret;
270 bool mute = true;
271 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
272 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
273 ret = AudioInitHwParams(handleData);
274 EXPECT_EQ(HDF_SUCCESS, ret);
275 ret = AudioInterfaceRenderInit(handleData);
276 EXPECT_EQ(HDF_SUCCESS, ret);
277 ret = AudioCtlRenderGetMuteStu(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, handleData);
278 EXPECT_EQ(HDF_SUCCESS, ret);
279 mute = handleData->renderMode.ctlParam.mute;
280 EXPECT_EQ(false, mute);
281 ret = AudioResourceRelease(handleData);
282 EXPECT_EQ(HDF_SUCCESS, ret);
283 }
284
285 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderSetMuteStu_001, TestSize.Level1)
286 {
287 struct AudioHwRenderParam *handleData = nullptr;
288 int32_t ret = AudioCtlRenderSetMuteStu(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, handleData);
289 EXPECT_EQ(HDF_FAILURE, ret);
290 }
291
292 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderSetMuteStu_002, TestSize.Level1)
293 {
294 int32_t ret;
295 bool mute = false;
296 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
297 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
298 handleData->renderMode.ctlParam.mute = true;
299 ret = AudioInitHwParams(handleData);
300 EXPECT_EQ(HDF_SUCCESS, ret);
301 ret = AudioInterfaceRenderInit(handleData);
302 EXPECT_EQ(HDF_SUCCESS, ret);
303 ret = AudioCtlRenderSetMuteStu(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, handleData);
304 EXPECT_EQ(HDF_SUCCESS, ret);
305 ret = AudioCtlRenderGetMuteStu(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, handleData);
306 EXPECT_EQ(HDF_SUCCESS, ret);
307 mute = handleData->renderMode.ctlParam.mute;
308 EXPECT_EQ(true, mute);
309 handleData->renderMode.ctlParam.mute = false;
310 ret = AudioCtlRenderSetMuteStu(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE, handleData);
311 EXPECT_EQ(HDF_SUCCESS, ret);
312 ret = AudioCtlRenderGetMuteStu(handle, AUDIODRV_CTL_IOCTL_MUTE_READ, handleData);
313 EXPECT_EQ(HDF_SUCCESS, ret);
314 mute = handleData->renderMode.ctlParam.mute;
315 EXPECT_EQ(false, mute);
316 ret = AudioResourceRelease(handleData);
317 EXPECT_EQ(HDF_SUCCESS, ret);
318 }
319
320 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderSetPauseStu_001, TestSize.Level1)
321 {
322 struct AudioHwRenderParam *handleData = nullptr;
323 int32_t ret = AudioCtlRenderSetPauseStu(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE, handleData);
324 EXPECT_EQ(HDF_FAILURE, ret);
325 }
326
327 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderSetPauseStu_002, TestSize.Level1)
328 {
329 int32_t ret;
330 bool pause = true;
331 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
332 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
333 handleData->renderMode.ctlParam.pause = false;
334 ret = AudioInitHwParams(handleData);
335 EXPECT_EQ(HDF_SUCCESS, ret);
336 ret = AudioInterfaceRenderInit(handleData);
337 EXPECT_EQ(HDF_SUCCESS, ret);
338 AudioCtlRenderSetPauseStu(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE, handleData);
339 EXPECT_EQ(HDF_SUCCESS, ret);
340 pause = handleData->renderMode.ctlParam.pause;
341 EXPECT_EQ(false, pause);
342 ret = AudioResourceRelease(handleData);
343 EXPECT_EQ(HDF_SUCCESS, ret);
344 }
345
346 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderSetPauseStu_003, TestSize.Level1)
347 {
348 int32_t ret;
349 bool pause = false;
350 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
351 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
352 handleData->renderMode.ctlParam.pause = true;
353 ret = AudioInitHwParams(handleData);
354 EXPECT_EQ(HDF_SUCCESS, ret);
355 ret = AudioInterfaceRenderInit(handleData);
356 EXPECT_EQ(HDF_SUCCESS, ret);
357 AudioCtlRenderSetPauseStu(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE, handleData);
358 EXPECT_EQ(HDF_SUCCESS, ret);
359 pause = handleData->renderMode.ctlParam.pause;
360 EXPECT_EQ(true, pause);
361 ret = AudioResourceRelease(handleData);
362 EXPECT_EQ(HDF_SUCCESS, ret);
363 }
364
365 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderSetChannelMode_001, TestSize.Level1)
366 {
367 struct AudioHwRenderParam *handleData = nullptr;
368 int32_t ret = AudioCtlRenderSetChannelMode(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, handleData);
369 EXPECT_EQ(HDF_FAILURE, ret);
370 }
371
372 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderSetChannelMode_002, TestSize.Level1)
373 {
374 struct AudioHwRenderParam handleData;
375 int32_t ret = AudioCtlRenderSetChannelMode(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &handleData);
376 /* alsa_lib not support AudioCtlRenderSetChannelMode, Therefore, success is returned directly */
377 EXPECT_EQ(HDF_SUCCESS, ret);
378 }
379
380 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderGetChannelMode_001, TestSize.Level1)
381 {
382 struct AudioHwRenderParam *handleData = nullptr;
383 int32_t ret = AudioCtlRenderGetChannelMode(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, handleData);
384 EXPECT_EQ(HDF_FAILURE, ret);
385 }
386
387 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderGetChannelMode_002, TestSize.Level1)
388 {
389 struct AudioHwRenderParam handleData;
390 int32_t ret = AudioCtlRenderGetChannelMode(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &handleData);
391 /* alsa_lib not support AudioCtlRenderGetChannelMode, Therefore, success is returned directly */
392 EXPECT_EQ(HDF_SUCCESS, ret);
393 }
394
395 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderSetGainStu_001, TestSize.Level1)
396 {
397 struct AudioHwRenderParam *handleData = nullptr;
398 int32_t ret = AudioCtlRenderSetGainStu(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, handleData);
399 EXPECT_EQ(HDF_FAILURE, ret);
400 }
401
402 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderSetGainStu_002, TestSize.Level1)
403 {
404 struct AudioHwRenderParam handleData;
405 int32_t ret = AudioCtlRenderSetGainStu(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &handleData);
406 /* alsa_lib not support AudioCtlRenderSetGainStu, Therefore, success is returned directly */
407 EXPECT_EQ(HDF_SUCCESS, ret);
408 }
409
410 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderGetGainStu_001, TestSize.Level1)
411 {
412 struct AudioHwRenderParam *handleData = nullptr;
413 int32_t ret = AudioCtlRenderGetGainStu(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, handleData);
414 EXPECT_EQ(HDF_FAILURE, ret);
415 }
416
417 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderGetGainStu_002, TestSize.Level1)
418 {
419 struct AudioHwRenderParam handleData;
420 int32_t ret = AudioCtlRenderGetGainStu(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &handleData);
421 /* alsa_lib not support AudioCtlRenderGetGainStu, Therefore, success is returned directly */
422 EXPECT_EQ(HDF_SUCCESS, ret);
423 }
424
425 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderSceneSelect_001, TestSize.Level1)
426 {
427 struct AudioHwRenderParam *handleData = nullptr;
428 int32_t ret = AudioCtlRenderSceneSelect(handle, AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE, handleData);
429 EXPECT_EQ(HDF_FAILURE, ret);
430 }
431
432 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderSceneSelect_002, TestSize.Level1)
433 {
434 int32_t ret;
435 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
436 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
437 handleData->renderMode.hwInfo.deviceDescript.pins = PIN_OUT_SPEAKER;
438 handleData->frameRenderMode.attrs.type = AUDIO_IN_MEDIA;
439 ret = AudioInitHwParams(handleData);
440 EXPECT_EQ(HDF_SUCCESS, ret);
441 ret = AudioInterfaceRenderInit(handleData);
442 EXPECT_EQ(HDF_SUCCESS, ret);
443 ret = AudioCtlRenderSceneSelect(handle, AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE, handleData);
444 EXPECT_EQ(HDF_SUCCESS, ret);
445 ret = AudioResourceRelease(handleData);
446 EXPECT_EQ(HDF_SUCCESS, ret);
447 }
448
449 HWTEST_F(AudioAlsaIfLibRenderTest, AudioCtlRenderSceneSelect_003, TestSize.Level1)
450 {
451 int32_t ret;
452 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
453 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
454 handleData->renderMode.hwInfo.deviceDescript.pins = PIN_OUT_HEADSET;
455 handleData->frameRenderMode.attrs.type = AUDIO_IN_MEDIA;
456 ret = AudioInitHwParams(handleData);
457 EXPECT_EQ(HDF_SUCCESS, ret);
458 ret = AudioInterfaceRenderInit(handleData);
459 EXPECT_EQ(HDF_SUCCESS, ret);
460 ret = AudioCtlRenderSceneSelect(handle, AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE, handleData);
461 EXPECT_EQ(HDF_SUCCESS, ret);
462 ret = AudioResourceRelease(handleData);
463 EXPECT_EQ(HDF_SUCCESS, ret);
464 }
465
466 HWTEST_F(AudioAlsaIfLibRenderTest, AudioOutputRenderStart_001, TestSize.Level1)
467 {
468 struct AudioHwRenderParam *handleData = nullptr;
469 int32_t ret = AudioOutputRenderStart(handle, AUDIO_DRV_PCM_IOCTRL_START, handleData);
470 EXPECT_EQ(HDF_FAILURE, ret);
471 }
472
473 HWTEST_F(AudioAlsaIfLibRenderTest, AudioOutputRenderStart_002, TestSize.Level1)
474 {
475 int32_t ret;
476 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
477 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
478 ret = AudioInitHwParams(handleData);
479 EXPECT_EQ(HDF_SUCCESS, ret);
480 ret = AudioInterfaceRenderInit(handleData);
481 EXPECT_EQ(HDF_SUCCESS, ret);
482 ret = AudioOutputRenderStart(handle, AUDIO_DRV_PCM_IOCTRL_START, handleData);
483 EXPECT_EQ(HDF_SUCCESS, ret);
484 ret = AudioResourceRelease(handleData);
485 EXPECT_EQ(HDF_SUCCESS, ret);
486 }
487
488 HWTEST_F(AudioAlsaIfLibRenderTest, AudioOutputRenderStop_001, TestSize.Level1)
489 {
490 struct AudioHwRenderParam *handleData = nullptr;
491 int32_t ret = AudioOutputRenderStop(handle, AUDIO_DRV_PCM_IOCTRL_STOP, handleData);
492 EXPECT_EQ(HDF_FAILURE, ret);
493 }
494
495 HWTEST_F(AudioAlsaIfLibRenderTest, AudioOutputRenderStop_002, TestSize.Level1)
496 {
497 int32_t ret;
498 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
499 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
500 ret = AudioInitHwParams(handleData);
501 EXPECT_EQ(HDF_SUCCESS, ret);
502 ret = AudioInterfaceRenderInit(handleData);
503 EXPECT_EQ(HDF_SUCCESS, ret);
504 ret = AudioOutputRenderStop(handle, AUDIO_DRV_PCM_IOCTRL_STOP, handleData);
505 EXPECT_EQ(HDF_SUCCESS, ret);
506 ret = AudioResourceRelease(handleData);
507 EXPECT_EQ(HDF_SUCCESS, ret);
508 }
509
510 HWTEST_F(AudioAlsaIfLibRenderTest, AudioOutputRenderWrite_001, TestSize.Level1)
511 {
512 struct AudioHwRenderParam *handleData = nullptr;
513 int32_t ret = AudioOutputRenderWrite(handle, AUDIO_DRV_PCM_IOCTL_WRITE, handleData);
514 EXPECT_EQ(HDF_FAILURE, ret);
515 }
516
517 HWTEST_F(AudioAlsaIfLibRenderTest, AudioOutputRenderWrite_002, TestSize.Level1)
518 {
519 int32_t ret;
520 char buffer[frameData];
521 for (int i = 0; i < sizeof(buffer); i++) {
522 buffer[i] = random() & 0xff;
523 }
524 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
525 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
526 ret = AudioInitHwParams(handleData);
527 EXPECT_EQ(HDF_SUCCESS, ret);
528 int32_t frameSize = channel * 2; /* 2 is for AUDIO_FORMAT_TYPE_PCM_16_BIT to byte */
529 ASSERT_NE(frameSize, 0);
530 handleData->frameRenderMode.bufferFrameSize = frameData / frameSize;
531 char *bufferFrame = new char[frameData];
532 handleData->frameRenderMode.buffer = bufferFrame;
533 ret = AudioInterfaceRenderInit(handleData);
534 EXPECT_EQ(HDF_SUCCESS, ret);
535 (void)memcpy_s(handleData->frameRenderMode.buffer, frameData, buffer, frameData);
536 ret = AudioOutputRenderWrite(handle, AUDIO_DRV_PCM_IOCTL_WRITE, handleData);
537 EXPECT_EQ(HDF_SUCCESS, ret);
538 delete[] bufferFrame;
539 bufferFrame = NULL;
540 ret = AudioResourceRelease(handleData);
541 EXPECT_EQ(HDF_SUCCESS, ret);
542 }
543
544 HWTEST_F(AudioAlsaIfLibRenderTest, AudioOutputRenderReqMmapBuffer_001, TestSize.Level1)
545 {
546 struct AudioHwRenderParam *handleData = nullptr;
547 int32_t ret = AudioOutputRenderReqMmapBuffer(handle, AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER, handleData);
548 EXPECT_EQ(HDF_FAILURE, ret);
549 }
550
551 HWTEST_F(AudioAlsaIfLibRenderTest, AudioOutputRenderReqMmapBuffer_002, TestSize.Level1)
552 {
553 int32_t ret;
554 char mmapBuffer[mmapFrameData];
555 for (int i = 0; i < sizeof(mmapBuffer); i++) {
556 mmapBuffer[i] = random() & 0xff;
557 }
558 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
559 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
560 ret = AudioInitHwParams(handleData);
561 EXPECT_EQ(HDF_SUCCESS, ret);
562 int32_t frameSize = channel * 2; /* 2 is for AUDIO_FORMAT_TYPE_PCM_16_BIT to byte */
563 ASSERT_NE(frameSize, 0);
564 handleData->frameRenderMode.mmapBufDesc.totalBufferFrames = mmapFrameData / frameSize;
565 char *mmapBufferFrames = new char[mmapFrameData];
566 handleData->frameRenderMode.mmapBufDesc.memoryAddress = mmapBufferFrames ;
567 ret = AudioInterfaceRenderInit(handleData);
568 EXPECT_EQ(HDF_SUCCESS, ret);
569 (void)memcpy_s(handleData->frameRenderMode.mmapBufDesc.memoryAddress, mmapFrameData, mmapBuffer, mmapFrameData);
570 ret = AudioOutputRenderReqMmapBuffer(handle, AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER, handleData);
571 EXPECT_EQ(HDF_SUCCESS, ret);
572 delete[] mmapBufferFrames;
573 mmapBufferFrames = NULL;
574 ret = AudioResourceRelease(handleData);
575 EXPECT_EQ(HDF_SUCCESS, ret);
576 }
577
578 HWTEST_F(AudioAlsaIfLibRenderTest, AudioOutputRenderGetMmapPosition_001, TestSize.Level1)
579 {
580 struct AudioHwRenderParam *handleData = nullptr;
581 int32_t ret = AudioOutputRenderGetMmapPosition(handle, AUDIO_DRV_PCM_IOCTL_MMAP_POSITION, handleData);
582 EXPECT_EQ(HDF_FAILURE, ret);
583 }
584
585 HWTEST_F(AudioAlsaIfLibRenderTest, AudioOutputRenderGetMmapPosition_002, TestSize.Level1)
586 {
587 int32_t ret;
588 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
589 memset_s(handleData, sizeof(AudioHwRenderParam), 0, sizeof(AudioHwRenderParam));
590 ret = AudioInitHwParams(handleData);
591 EXPECT_EQ(HDF_SUCCESS, ret);
592 int32_t mmapFrameSize = channel * 2; /* 2 is for AUDIO_FORMAT_TYPE_PCM_16_BIT to byte */
593 ASSERT_NE(mmapFrameSize, 0);
594 handleData->frameRenderMode.mmapBufDesc.totalBufferFrames = mmapFrameData / mmapFrameSize;
595 char mmapBuffer[mmapFrameData];
596 for (int i = 0; i < sizeof(mmapBuffer); i++) {
597 mmapBuffer[i] = random() & 0xff;
598 }
599 handleData->frameRenderMode.mmapBufDesc.memoryAddress = mmapBuffer ;
600 ret = AudioInterfaceRenderInit(handleData);
601 EXPECT_EQ(HDF_SUCCESS, ret);
602 (void)memcpy_s(handleData->frameRenderMode.mmapBufDesc.memoryAddress, mmapFrameData, mmapBuffer, mmapFrameData);
603 ret = AudioOutputRenderReqMmapBuffer(handle, AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER, handleData);
604 EXPECT_EQ(HDF_SUCCESS, ret);
605 ret = AudioOutputRenderGetMmapPosition(handle, AUDIO_DRV_PCM_IOCTL_MMAP_POSITION, handleData);
606 EXPECT_EQ(HDF_SUCCESS, ret);
607 EXPECT_EQ(handleData->frameRenderMode.frames, mmapFrameData / mmapFrameSize);
608 ret = AudioResourceRelease(handleData);
609 EXPECT_EQ(HDF_SUCCESS, ret);
610 }
611 }
612