1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_render_test.h"
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 #include "audio_common_test.h"
20
21 using namespace std;
22 using namespace comfun;
23 using namespace testing::ext;
24 namespace {
25 class AudioRenderTest : public testing::Test {
26 public:
27 struct AudioManager *managerFuncs = nullptr;
28 struct AudioAdapterDescriptor *descs = nullptr;
29 struct AudioAdapterDescriptor *desc = nullptr;
30 struct AudioAdapter *adapter = nullptr;
31 struct AudioDeviceDescriptor devDesc = {};
32 struct AudioSampleAttributes attrs = {};
33 struct AudioRender *render = nullptr;
34
35 virtual void SetUp();
36 virtual void TearDown();
37 };
38
SetUp()39 void AudioRenderTest::SetUp()
40 {
41 managerFuncs = GetAudioManagerFuncs();
42 ASSERT_NE(managerFuncs, nullptr);
43 int32_t size = 0;
44 ASSERT_EQ(HDF_SUCCESS, managerFuncs->GetAllAdapters(managerFuncs, &descs, &size));
45
46 desc = &descs[0];
47 ASSERT_EQ(HDF_SUCCESS, managerFuncs->LoadAdapter(managerFuncs, desc, &adapter));
48 ASSERT_EQ(HDF_SUCCESS, InitDevDesc(devDesc));
49 ASSERT_EQ(HDF_SUCCESS, InitAttrs(attrs));
50 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioAdapterCreateRender(adapter, &devDesc, &attrs, &render));
51 }
52
TearDown()53 void AudioRenderTest::TearDown()
54 {
55 ASSERT_EQ(HDF_SUCCESS, AudioAdapterDestroyRender(adapter, render));
56 managerFuncs->UnloadAdapter(managerFuncs, adapter);
57 adapter = nullptr;
58 }
59
60 HWTEST_F(AudioRenderTest, PcmBytesToFramesWhenFrameRenderModeIsNull, TestSize.Level1)
61 {
62 const struct AudioFrameRenderMode *frameRenderMode = nullptr;
63 uint64_t bytes = FRAME_DATA;
64 uint32_t frameCount = 0;
65 EXPECT_EQ(HDF_FAILURE, PcmBytesToFrames(frameRenderMode, bytes, &frameCount));
66 }
67
68 HWTEST_F(AudioRenderTest, PcmBytesToFramesWhenFrameCountIsNull, TestSize.Level1)
69 {
70 const struct AudioFrameRenderMode *frameRenderMode = new struct AudioFrameRenderMode;
71 uint64_t bytes = FRAME_DATA;
72 uint32_t *frameCount = nullptr;
73 EXPECT_EQ(HDF_FAILURE, PcmBytesToFrames(frameRenderMode, bytes, frameCount));
74 delete(frameRenderMode);
75 frameRenderMode = nullptr;
76 }
77
78 HWTEST_F(AudioRenderTest, PcmBytesToFramesWhenParamIsNotSupport, TestSize.Level1)
79 {
80 struct AudioFrameRenderMode *frameRenderMode = new struct AudioFrameRenderMode;
81 frameRenderMode->attrs.format = AUDIO_FORMAT_AAC_MAIN;
82 uint64_t bytes = FRAME_DATA;
83 uint32_t frameCount = 0;
84 EXPECT_EQ(HDF_ERR_NOT_SUPPORT,
85 PcmBytesToFrames((const struct AudioFrameRenderMode *)frameRenderMode, bytes, &frameCount));
86 delete(frameRenderMode);
87 frameRenderMode = nullptr;
88 }
89
90 HWTEST_F(AudioRenderTest, PcmBytesToFramesWhenChannelCountIsZero, TestSize.Level1)
91 {
92 struct AudioFrameRenderMode *frameRenderMode = new struct AudioFrameRenderMode;
93 frameRenderMode->attrs.format = AUDIO_FORMAT_PCM_8_BIT;
94 frameRenderMode->attrs.channelCount = 0;
95 uint64_t bytes = FRAME_DATA;
96 uint32_t frameCount = 0;
97 EXPECT_EQ(HDF_FAILURE, PcmBytesToFrames((const struct AudioFrameRenderMode *)frameRenderMode, bytes, &frameCount));
98 delete(frameRenderMode);
99 frameRenderMode = nullptr;
100 }
101
102 HWTEST_F(AudioRenderTest, PcmBytesToFramesWhenParamIsVaild, TestSize.Level1)
103 {
104 struct AudioFrameRenderMode *frameRenderMode = new struct AudioFrameRenderMode;
105 frameRenderMode->attrs.format = AUDIO_FORMAT_PCM_8_BIT;
106 frameRenderMode->attrs.channelCount = 1;
107 uint64_t bytes = FRAME_DATA;
108 uint32_t frameCount = 0;
109 EXPECT_EQ(HDF_SUCCESS, PcmBytesToFrames((const struct AudioFrameRenderMode *)frameRenderMode, bytes, &frameCount));
110 delete(frameRenderMode);
111 frameRenderMode = nullptr;
112 }
113
114 HWTEST_F(AudioRenderTest, AudioRenderStartWhenHandleIsNull, TestSize.Level1)
115 {
116 AudioHwRender *hwRender = nullptr;
117 AudioHandle handle = (AudioHandle)hwRender;
118 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderStart(handle));
119 }
120
121 HWTEST_F(AudioRenderTest, AudioRenderStartWhenBufferIsNotNull, TestSize.Level1)
122 {
123 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
124 AudioHandle handle = (AudioHandle)hwRender;
125 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle));
126 EXPECT_EQ(AUDIO_HAL_ERR_AO_BUSY, AudioRenderStart(handle));
127 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStop(handle));
128 }
129
130 HWTEST_F(AudioRenderTest, AudioRenderStartWhenDevDataHandleIsNull, TestSize.Level1)
131 {
132 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
133 struct DevHandle *devDataHandle = hwRender->devDataHandle;
134 hwRender->devDataHandle = nullptr;
135 AudioHandle handle = (AudioHandle)hwRender;
136 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderStart(handle));
137 hwRender->devDataHandle = devDataHandle;
138 }
139
140 HWTEST_F(AudioRenderTest, AudioRenderStartWhenDevDataHandleIsError, TestSize.Level1)
141 {
142 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
143 struct DevHandle *devDataHandle = hwRender->devDataHandle;
144 struct HdfIoService *service = new HdfIoService;
145 hwRender->devDataHandle = (struct DevHandle *)service;
146 AudioHandle handle = (AudioHandle)hwRender;
147 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderStart(handle));
148 hwRender->devDataHandle = devDataHandle;
149 delete(service);
150 service = nullptr;
151 }
152
153 HWTEST_F(AudioRenderTest, AudioRenderStartWhenParamIsVaild, TestSize.Level1)
154 {
155 AudioHandle handle = (AudioHandle)render;
156 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle));
157 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStop(handle));
158 }
159
160 HWTEST_F(AudioRenderTest, AudioRenderStopWhenHandleIsNull, TestSize.Level1)
161 {
162 AudioHwRender *hwRender = nullptr;
163 AudioHandle handle = (AudioHandle)hwRender;
164 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderStop(handle));
165 }
166
167 HWTEST_F(AudioRenderTest, AudioRenderStopWhenBufferIsNull, TestSize.Level1)
168 {
169 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
170 hwRender->renderParam.frameRenderMode.buffer = nullptr;
171 AudioHandle handle = (AudioHandle)hwRender;
172 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioRenderStop(handle));
173 }
174
175 HWTEST_F(AudioRenderTest, AudioRenderStopWhenDevDataHandleIsNull, TestSize.Level1)
176 {
177 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
178 AudioHandle handle = (AudioHandle)hwRender;
179 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle));
180 struct DevHandle *devDataHandle = hwRender->devDataHandle;
181 hwRender->devDataHandle = nullptr;
182 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderStop(handle));
183 hwRender->devDataHandle = devDataHandle;
184 }
185
186 HWTEST_F(AudioRenderTest, AudioRenderStopWhenDevDataHandleIsError, TestSize.Level1)
187 {
188 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
189 AudioHandle handle = (AudioHandle)hwRender;
190 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle));
191 struct DevHandle *devDataHandle = hwRender->devDataHandle;
192 struct HdfIoService *service = new HdfIoService;
193 hwRender->devDataHandle = (struct DevHandle *)service;
194 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderStop(handle));
195 hwRender->devDataHandle = devDataHandle;
196 delete(service);
197 service = nullptr;
198 }
199
200 HWTEST_F(AudioRenderTest, AudioRenderStopWhenParamIsVaild, TestSize.Level1)
201 {
202 AudioHandle handle = (AudioHandle)render;
203 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle));
204 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStop(handle));
205 }
206
207 HWTEST_F(AudioRenderTest, AudioRenderPauseWhenHandleIsNull, TestSize.Level1)
208 {
209 AudioHwRender *hwRender = nullptr;
210 AudioHandle handle = (AudioHandle)hwRender;
211 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderPause(handle));
212 }
213
214 HWTEST_F(AudioRenderTest, AudioRenderPauseWhenBufferIsNull, TestSize.Level1)
215 {
216 AudioHwRender *hwRender = (AudioHwRender *)render;
217 hwRender->renderParam.frameRenderMode.buffer = nullptr;
218 AudioHandle handle = (AudioHandle)hwRender;
219 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderPause(handle));
220 }
221
222 HWTEST_F(AudioRenderTest, AudioRenderPauseWhenPauseIsTrue, TestSize.Level1)
223 {
224 AudioHwRender *hwRender = (AudioHwRender *)render;
225 hwRender->renderParam.renderMode.ctlParam.pause = true;
226 AudioHandle handle = (AudioHandle)hwRender;
227 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle));
228 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioRenderPause(handle));
229 }
230
231 HWTEST_F(AudioRenderTest, AudioRenderPauseWhenDevDataHandleIsNull, TestSize.Level1)
232 {
233 AudioHwRender *hwRender = (AudioHwRender *)render;
234 AudioHandle handle = (AudioHandle)hwRender;
235 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle));
236 struct DevHandle *devDataHandle = hwRender->devDataHandle;
237 hwRender->devDataHandle = nullptr;
238 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderPause(handle));
239 hwRender->devDataHandle = devDataHandle;
240 }
241
242 HWTEST_F(AudioRenderTest, AudioRenderPauseWhenDevDataHandleIsError, TestSize.Level1)
243 {
244 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
245 AudioHandle handle = (AudioHandle)hwRender;
246 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle));
247 struct DevHandle *devDataHandle = hwRender->devDataHandle;
248 struct HdfIoService *service = new HdfIoService;
249 hwRender->devDataHandle = (struct DevHandle *)service;
250 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderPause(handle));
251 hwRender->devDataHandle = devDataHandle;
252 delete(service);
253 service = nullptr;
254 }
255
256 HWTEST_F(AudioRenderTest, AudioRenderPauseWhenParamVaild, TestSize.Level1)
257 {
258 AudioHandle handle = (AudioHandle)render;
259 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle));
260 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderPause(handle));
261 }
262
263 HWTEST_F(AudioRenderTest, AudioRenderResumeWhenHandleIsNull, TestSize.Level1)
264 {
265 AudioHwRender *hwRender = nullptr;
266 AudioHandle handle = (AudioHandle)hwRender;
267 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderResume(handle));
268 }
269
270 HWTEST_F(AudioRenderTest, AudioRenderResumeWhenPauseIsFalse, TestSize.Level1)
271 {
272 AudioHandle handle = (AudioHandle)render;
273 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle));
274 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
275 hwRender->renderParam.renderMode.ctlParam.pause = false;
276 handle = (AudioHandle)hwRender;
277 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioRenderResume(handle));
278 }
279
280 HWTEST_F(AudioRenderTest, AudioRenderResumeWhenDevDataHandleIsNull, TestSize.Level1)
281 {
282 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
283 AudioHandle handle = (AudioHandle)hwRender;
284 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle));
285 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderPause(handle));
286 struct DevHandle *devDataHandle = hwRender->devDataHandle;
287 hwRender->devDataHandle = nullptr;
288 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderResume(handle));
289 hwRender->devDataHandle = devDataHandle;
290 }
291
292 HWTEST_F(AudioRenderTest, AudioRenderResumeWhenDevDataHandleIsError, TestSize.Level1)
293 {
294 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
295 AudioHandle handle = (AudioHandle)hwRender;
296 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle));
297 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderPause(handle));
298 struct DevHandle *devDataHandle = hwRender->devDataHandle;
299 struct HdfIoService *service = new HdfIoService;
300 hwRender->devDataHandle = (struct DevHandle *)service;
301 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderResume(handle));
302 hwRender->devDataHandle = devDataHandle;
303 delete(service);
304 service = nullptr;
305 }
306
307 HWTEST_F(AudioRenderTest, AudioRenderResumeWhenParamVaild, TestSize.Level1)
308 {
309 AudioHandle handle = (AudioHandle)render;
310 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle));
311 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderPause(handle));
312 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderResume(handle));
313 }
314
315 HWTEST_F(AudioRenderTest, AudioRenderFlushWhenHandleIsNull, TestSize.Level1)
316 {
317 AudioHwRender *hwRender = nullptr;
318 AudioHandle handle = (AudioHandle)hwRender;
319 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderFlush(handle));
320 }
321
322 HWTEST_F(AudioRenderTest, AudioRenderFlushWhenParamIsVaild, TestSize.Level1)
323 {
324 AudioHwRender *hwRender = new AudioHwRender;
325 AudioHandle handle = (AudioHandle)hwRender;
326 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioRenderFlush(handle));
327 delete(hwRender);
328 hwRender = nullptr;
329 }
330
331 HWTEST_F(AudioRenderTest, AudioRenderGetFrameSizeWhenHandleIsNull, TestSize.Level1)
332 {
333 AudioHwRender *hwRender = nullptr;
334 AudioHandle handle = (AudioHandle)hwRender;
335 uint64_t size = FRAME_DATA;
336 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetFrameSize(handle, &size));
337 }
338
339 HWTEST_F(AudioRenderTest, AudioRenderGetFrameSizeWhenSizeIsNull, TestSize.Level1)
340 {
341 AudioHandle handle = (AudioHandle)render;
342 uint64_t *frameSize = nullptr;
343 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetFrameSize(handle, frameSize));
344 }
345
346 HWTEST_F(AudioRenderTest, AudioRenderGetFrameSizeWhenParamIsNotSupport, TestSize.Level1)
347 {
348 AudioHwRender *hwRender = (AudioHwRender *)render;
349 hwRender->renderParam.frameRenderMode.attrs.format = AUDIO_FORMAT_AAC_MAIN;
350 AudioHandle handle = (AudioHandle)hwRender;
351 uint64_t frameSize = FRAME_DATA;
352 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioRenderGetFrameSize(handle, &frameSize));
353 }
354
355 HWTEST_F(AudioRenderTest, AudioRenderGetFrameSizeWhenParamVaild, TestSize.Level1)
356 {
357 AudioHandle handle = (AudioHandle)render;
358 uint64_t frameSize = FRAME_DATA;
359 EXPECT_EQ(HDF_SUCCESS, AudioRenderGetFrameSize(handle, &frameSize));
360 }
361
362 HWTEST_F(AudioRenderTest, AudioRenderGetFrameCountWhenHandleIsNull, TestSize.Level1)
363 {
364 AudioHwRender *hwRender = nullptr;
365 AudioHandle handle = (AudioHandle)hwRender;
366 uint64_t count = FRAME_DATA;
367 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetFrameCount(handle, &count));
368 }
369
370 HWTEST_F(AudioRenderTest, AudioRenderGetFrameCountWhenCountIsNull, TestSize.Level1)
371 {
372 AudioHandle handle = (AudioHandle)render;
373 uint64_t *count = nullptr;
374 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetFrameCount(handle, count));
375 }
376
377 HWTEST_F(AudioRenderTest, AudioRenderGetFrameCountWhenParamIsVaild, TestSize.Level1)
378 {
379 AudioHandle handle = (AudioHandle)render;
380 uint64_t count = FRAME_DATA;
381 EXPECT_EQ(HDF_SUCCESS, AudioRenderGetFrameCount(handle, &count));
382 }
383
384 HWTEST_F(AudioRenderTest, AudioRenderSetSampleAttributesWhenHandleIsNull, TestSize.Level1)
385 {
386 AudioHwRender *hwRender = nullptr;
387 AudioHandle handle = (AudioHandle)hwRender;
388 AudioSampleAttributes *attrs = new AudioSampleAttributes;
389 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSetSampleAttributes(handle, attrs));
390 delete(attrs);
391 attrs = nullptr;
392 }
393
394 HWTEST_F(AudioRenderTest, AudioRenderSetSampleAttributesWhenAttrsIsNull, TestSize.Level1)
395 {
396 AudioHandle handle = (AudioHandle)render;
397 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSetSampleAttributes(handle, nullptr));
398 }
399
400 HWTEST_F(AudioRenderTest, AudioRenderSetSampleAttributesWhenDevDataHandleIsNull, TestSize.Level1)
401 {
402 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
403 struct DevHandle *devDataHandle = hwRender->devDataHandle;
404 hwRender->devDataHandle = nullptr;
405 AudioHandle handle = (AudioHandle)hwRender;
406 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSetSampleAttributes(handle, &attrs));
407 hwRender->devDataHandle = devDataHandle;
408 }
409
410 HWTEST_F(AudioRenderTest, AudioRenderSetSampleAttributesWhenFormatIsError, TestSize.Level1)
411 {
412 AudioHandle handle = (AudioHandle)render;
413 attrs.format = AUDIO_FORMAT_G711A;
414 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioRenderSetSampleAttributes(handle, &attrs));
415 }
416
417 HWTEST_F(AudioRenderTest, AudioRenderSetSampleAttributesWhenDevDataHandleIsError, TestSize.Level1)
418 {
419 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
420 struct DevHandle *devDataHandle = hwRender->devDataHandle;
421 struct HdfIoService *service = new HdfIoService;
422 hwRender->devDataHandle = (struct DevHandle *)service;
423 AudioHandle handle = (AudioHandle)hwRender;
424 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetSampleAttributes(handle, &attrs));
425 hwRender->devDataHandle = devDataHandle;
426 delete(service);
427 service = nullptr;
428 }
429
430 HWTEST_F(AudioRenderTest, AudioRenderSetSampleAttributesWhenParamIsVaild, TestSize.Level1)
431 {
432 AudioHandle handle = (AudioHandle)render;
433 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetSampleAttributes(handle, &attrs));
434 }
435
436 HWTEST_F(AudioRenderTest, AudioRenderGetSampleAttributesWhenHandleIsNull, TestSize.Level1)
437 {
438 AudioSampleAttributes *attrs = new AudioSampleAttributes;
439 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetSampleAttributes(nullptr, attrs));
440 delete(attrs);
441 attrs = nullptr;
442 }
443
444 HWTEST_F(AudioRenderTest, AudioRenderGetSampleAttributesWhenAttrsIsNull, TestSize.Level1)
445 {
446 AudioHandle handle = (AudioHandle)render;
447 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetSampleAttributes(handle, nullptr));
448 }
449
450 HWTEST_F(AudioRenderTest, AudioRenderGetSampleAttributesWhenParamIsVaild, TestSize.Level1)
451 {
452 AudioHandle handle = (AudioHandle)render;
453 EXPECT_EQ(HDF_SUCCESS, AudioRenderGetSampleAttributes(handle, &attrs));
454 }
455
456 HWTEST_F(AudioRenderTest, AudioRenderGetCurrentChannelIdWhenHandleIsNull, TestSize.Level1)
457 {
458 AudioHwRender *hwRender = nullptr;
459 AudioHandle handle = (AudioHandle)hwRender;
460 uint32_t channelIdOne = 1;
461 uint32_t *channelId = &channelIdOne;
462 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetCurrentChannelId(handle, channelId));
463 }
464
465 HWTEST_F(AudioRenderTest, AudioRenderGetCurrentChannelIdWhenChannelIdIsNull, TestSize.Level1)
466 {
467 AudioHandle handle = (AudioHandle)render;
468 uint32_t *channelId = nullptr;
469 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetCurrentChannelId(handle, channelId));
470 }
471
472 HWTEST_F(AudioRenderTest, AudioRenderGetCurrentChannelIdWhenParamIsVaild, TestSize.Level1)
473 {
474 AudioHandle handle = (AudioHandle)render;
475 uint32_t channelId = 1;
476 EXPECT_EQ(HDF_SUCCESS, AudioRenderGetCurrentChannelId(handle, &channelId));
477 }
478
479 HWTEST_F(AudioRenderTest, AudioRenderCheckSceneCapabilityWhenHandleIsNull, TestSize.Level1)
480 {
481 AudioHwRender *hwRender = nullptr;
482 AudioHandle handle = (AudioHandle)hwRender;
483 const struct AudioSceneDescriptor *scene = new struct AudioSceneDescriptor;
484 bool supported = false;
485 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderCheckSceneCapability(handle, scene, &supported));
486 delete(scene);
487 scene = nullptr;
488 }
489
490 HWTEST_F(AudioRenderTest, AudioRenderCheckSceneCapabilityWhenSceneIsNull, TestSize.Level1)
491 {
492 AudioHandle handle = (AudioHandle)render;
493 const struct AudioSceneDescriptor *scene = nullptr;
494 bool supported = false;
495 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderCheckSceneCapability(handle, scene, &supported));
496 }
497
498 HWTEST_F(AudioRenderTest, AudioRenderCheckSceneCapabilityWhenSupportedIsNull, TestSize.Level1)
499 {
500 AudioHandle handle = (AudioHandle)render;
501 const struct AudioSceneDescriptor *scene = new struct AudioSceneDescriptor;
502 bool *supported = nullptr;
503 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderCheckSceneCapability(handle, scene, supported));
504 delete(scene);
505 scene = nullptr;
506 }
507
508 HWTEST_F(AudioRenderTest, AudioRenderCheckSceneCapabilityWhenPinsIsError, TestSize.Level1)
509 {
510 AudioHandle handle = (AudioHandle)render;
511 struct AudioSceneDescriptor scene;
512 scene.scene.id = AUDIO_IN_MEDIA;
513 scene.desc.pins = PIN_NONE;
514 bool supported = false;
515 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderCheckSceneCapability(handle, &scene, &supported));
516 }
517
518 HWTEST_F(AudioRenderTest, AudioRenderCheckSceneCapabilityWhenParamVaild, TestSize.Level1)
519 {
520 AudioHandle handle = (AudioHandle)render;
521 struct AudioSceneDescriptor scene;
522 scene.scene.id = AUDIO_IN_MEDIA;
523 scene.desc.pins = PIN_OUT_SPEAKER;
524 bool supported = false;
525 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderCheckSceneCapability(handle, &scene, &supported));
526 }
527
528 HWTEST_F(AudioRenderTest, AudioRenderSelectSceneWhenHandleIsNull, TestSize.Level1)
529 {
530 AudioHwRender *hwRender = nullptr;
531 AudioHandle handle = (AudioHandle)hwRender;
532 const struct AudioSceneDescriptor *scene = new struct AudioSceneDescriptor;
533 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSelectScene(handle, scene));
534 delete(scene);
535 scene = nullptr;
536 }
537
538 HWTEST_F(AudioRenderTest, AudioRenderSelectSceneWhenSceneIsNull, TestSize.Level1)
539 {
540 AudioHandle handle = (AudioHandle)render;
541 const struct AudioSceneDescriptor *scene = nullptr;
542 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSelectScene(handle, scene));
543 }
544
545 HWTEST_F(AudioRenderTest, AudioRenderSelectSceneWhenDevCtlHandleIsNull, TestSize.Level1)
546 {
547 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
548 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
549 hwRender->devCtlHandle = nullptr;
550 AudioHandle handle = (AudioHandle)hwRender;
551 struct AudioSceneDescriptor *scene = new AudioSceneDescriptor;
552 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSelectScene(handle, scene));
553 hwRender->devCtlHandle = devCtlHandle;
554 delete(scene);
555 scene = nullptr;
556 }
557
558 HWTEST_F(AudioRenderTest, AudioRenderSelectSceneWhenDevCtlHandleIsError, TestSize.Level1)
559 {
560 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
561 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
562 struct HdfIoService *service = new HdfIoService;
563 hwRender->devCtlHandle = (struct DevHandle *)service;
564 AudioHandle handle = (AudioHandle)hwRender;
565 struct AudioSceneDescriptor scene;
566 scene.scene.id = AUDIO_IN_MEDIA;
567 scene.desc.pins = PIN_OUT_SPEAKER;
568 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSelectScene(handle, &scene));
569 hwRender->devCtlHandle = devCtlHandle;
570 delete(service);
571 service = nullptr;
572 }
573
574 HWTEST_F(AudioRenderTest, AudioRenderSelectSceneWhenParamVaild, TestSize.Level1)
575 {
576 AudioHandle handle = (AudioHandle)render;
577 struct AudioSceneDescriptor scene;
578 scene.scene.id = AUDIO_IN_MEDIA;
579 scene.desc.pins = PIN_OUT_SPEAKER;
580 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSelectScene(handle, &scene));
581 }
582
583 HWTEST_F(AudioRenderTest, AudioRenderSetMuteWhenHandleIsNull, TestSize.Level1)
584 {
585 AudioHwRender *hwRender = nullptr;
586 AudioHandle handle = (AudioHandle)hwRender;
587 bool mute = true;
588 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSetMute(handle, mute));
589 }
590
591 HWTEST_F(AudioRenderTest, AudioRenderSetMuteWhenDevCtlHandleIsNull, TestSize.Level1)
592 {
593 AudioHwRender *hwRender = (AudioHwRender *)render;
594 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
595 hwRender->devCtlHandle = nullptr;
596 AudioHandle handle = (AudioHandle)hwRender;
597 bool mute = true;
598 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetMute(handle, mute));
599 hwRender->devCtlHandle = devCtlHandle;
600 }
601
602 HWTEST_F(AudioRenderTest, AudioRenderSetMuteWhenDevCtlHandleIsError, TestSize.Level1)
603 {
604 AudioHwRender *hwRender = (AudioHwRender *)render;
605 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
606 struct HdfIoService *service = new HdfIoService;
607 hwRender->devCtlHandle = (struct DevHandle *)service;
608 AudioHandle handle = (AudioHandle)hwRender;
609 bool mute = true;
610 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetMute(handle, mute));
611 hwRender->devCtlHandle = devCtlHandle;
612 delete(service);
613 service = nullptr;
614 }
615
616 HWTEST_F(AudioRenderTest, AudioRenderSetMuteWhenParamVaild, TestSize.Level1)
617 {
618 AudioHandle handle = (AudioHandle)render;
619 bool mute = true;
620 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetMute(handle, mute));
621 }
622
623 HWTEST_F(AudioRenderTest, AudioRenderGetMuteWhenHandleIsNull, TestSize.Level1)
624 {
625 AudioHwRender *hwRender = nullptr;
626 AudioHandle handle = (AudioHandle)hwRender;
627 bool mute = false;
628 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetMute(handle, &mute));
629 }
630
631 HWTEST_F(AudioRenderTest, AudioRenderGetMuteWhenMuteIsNull, TestSize.Level1)
632 {
633 AudioHandle handle = (AudioHandle)render;
634 bool *mute = nullptr;
635 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetMute(handle, mute));
636 }
637
638 HWTEST_F(AudioRenderTest, AudioRenderGetMuteWhenDevCtlHandleIsNull, TestSize.Level1)
639 {
640 AudioHwRender *hwRender = (AudioHwRender *)render;
641 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
642 hwRender->devCtlHandle = nullptr;
643 AudioHandle handle = (AudioHandle)hwRender;
644 bool mute = false;
645 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetMute(handle, &mute));
646 hwRender->devCtlHandle = devCtlHandle;
647 }
648
649 HWTEST_F(AudioRenderTest, AudioRenderGetMuteWhenDevCtlHandleIsError, TestSize.Level1)
650 {
651 AudioHwRender *hwRender = (AudioHwRender *)render;
652 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
653 struct HdfIoService *service = new HdfIoService;
654 hwRender->devCtlHandle = (struct DevHandle *)service;
655 AudioHandle handle = (AudioHandle)hwRender;
656 bool mute = true;
657 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetMute(handle, &mute));
658 hwRender->devCtlHandle = devCtlHandle;
659 delete(service);
660 service = nullptr;
661 }
662
663 HWTEST_F(AudioRenderTest, AudioRenderGetMuteWhenParamVaild, TestSize.Level1)
664 {
665 AudioHandle handle = (AudioHandle)render;
666 bool mute = false;
667 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderGetMute(handle, &mute));
668 }
669
670 HWTEST_F(AudioRenderTest, AudioRenderSetVolumeWhenHandleIsNull, TestSize.Level1)
671 {
672 AudioHwRender *hwRender = nullptr;
673 AudioHandle handle = (AudioHandle)hwRender;
674 float volume = 0;
675 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSetVolume(handle, volume));
676 }
677
678 HWTEST_F(AudioRenderTest, AudioRenderSetVolumeWhenVolumeLessThanZero, TestSize.Level1)
679 {
680 AudioHandle handle = (AudioHandle)render;
681 float volume = -1;
682 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSetVolume(handle, volume));
683 }
684
685 HWTEST_F(AudioRenderTest, AudioRenderSetVolumeWhenDevCtlHandleIsNull, TestSize.Level1)
686 {
687 AudioHwRender *hwRender = (AudioHwRender *)render;
688 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
689 hwRender->devCtlHandle = nullptr;
690 AudioHandle handle = (AudioHandle)hwRender;
691 float volume = 0;
692 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetVolume(handle, volume));
693 hwRender->devCtlHandle = devCtlHandle;
694 }
695
696 HWTEST_F(AudioRenderTest, AudioRenderSetVolumeWhenHandleIsError, TestSize.Level1)
697 {
698 AudioHwRender *hwRender = (AudioHwRender *)render;
699 hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax = 0;
700 hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin = 1;
701 AudioHandle handle = (AudioHandle)render;
702 float volume = 0;
703 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetVolume(handle, volume));
704 }
705
706 HWTEST_F(AudioRenderTest, AudioRenderSetVolumeWhenDevCtlHandleIsError, TestSize.Level1)
707 {
708 AudioHwRender *hwRender = (AudioHwRender *)render;
709 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
710 struct HdfIoService *service = new HdfIoService;
711 hwRender->devCtlHandle = (struct DevHandle *)service;
712 AudioHandle handle = (AudioHandle)hwRender;
713 float volume = 0;
714 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetVolume(handle, volume));
715 hwRender->devCtlHandle = devCtlHandle;
716 delete(service);
717 service = nullptr;
718 }
719
720 HWTEST_F(AudioRenderTest, AudioRenderSetVolumeWhenParamVaild, TestSize.Level1)
721 {
722 AudioHandle handle = (AudioHandle)render;
723 float volume = 0;
724 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetVolume(handle, volume));
725 }
726
727 HWTEST_F(AudioRenderTest, AudioRenderGetVolumeWhenHandleIsNull, TestSize.Level1)
728 {
729 AudioHwRender *hwRender = nullptr;
730 AudioHandle handle = (AudioHandle)hwRender;
731 float volume = 0;
732 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetVolume(handle, &volume));
733 }
734
735 HWTEST_F(AudioRenderTest, AudioRenderGetVolumeWhenVolumeIsNull, TestSize.Level1)
736 {
737 AudioHandle handle = (AudioHandle)render;
738 float *volume = nullptr;
739 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetVolume(handle, volume));
740 }
741
742 HWTEST_F(AudioRenderTest, AudioRenderGetVolumeWhenDevCtlHandleIsNull, TestSize.Level1)
743 {
744 AudioHwRender *hwRender = (AudioHwRender *)render;
745 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
746 hwRender->devCtlHandle = nullptr;
747 AudioHandle handle = (AudioHandle)hwRender;
748 float volume = 0;
749 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetVolume(handle, &volume));
750 hwRender->devCtlHandle = devCtlHandle;
751 }
752
753 HWTEST_F(AudioRenderTest, AudioRenderGetVolumeWhenDevCtlHandleIsError, TestSize.Level1)
754 {
755 AudioHwRender *hwRender = (AudioHwRender *)render;
756 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
757 struct HdfIoService *service = new HdfIoService;
758 hwRender->devCtlHandle = (struct DevHandle *)service;
759 AudioHandle handle = (AudioHandle)hwRender;
760 float volume = 0;
761 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetVolume(handle, &volume));
762 hwRender->devCtlHandle = devCtlHandle;
763 delete(service);
764 service = nullptr;
765 }
766
767 HWTEST_F(AudioRenderTest, AudioRenderGetVolumeWhenVolumeIsError, TestSize.Level1)
768 {
769 AudioHwRender *hwRender = (AudioHwRender *)render;
770 hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax = 1;
771 hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin = 1;
772 AudioHandle handle = (AudioHandle)render;
773 float volume = 0;
774 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetVolume(handle, &volume));
775 }
776
777 HWTEST_F(AudioRenderTest, AudioRenderGetVolumeWhenParamVaild, TestSize.Level1)
778 {
779 AudioHandle handle = (AudioHandle)render;
780 float volume = 0;
781 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderGetVolume(handle, &volume));
782 }
783
784 HWTEST_F(AudioRenderTest, AudioRenderGetGainThresholdWhenRenderIsNull, TestSize.Level1)
785 {
786 AudioHwRender *hwRender = nullptr;
787 AudioHandle handle = (AudioHandle)hwRender;
788 float min = GAIN_MIN;
789 float max = GAIN_MAX;
790 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetGainThreshold(handle, &min, &max));
791 }
792
793 HWTEST_F(AudioRenderTest, AudioRenderGetGainThresholdWhenMinIsNull, TestSize.Level1)
794 {
795 AudioHandle handle = (AudioHandle)render;
796 float *min = nullptr;
797 float max = GAIN_MAX;
798 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetGainThreshold(handle, min, &max));
799 }
800
801 HWTEST_F(AudioRenderTest, AudioRenderGetGainThresholdWhenMaxIsNull, TestSize.Level1)
802 {
803 AudioHandle handle = (AudioHandle)render;
804 float min = GAIN_MIN;
805 float *max = nullptr;
806 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetGainThreshold(handle, &min, max));
807 }
808
809 HWTEST_F(AudioRenderTest, AudioRenderGetGainThresholdWhenDevCtlHandleIsNull, TestSize.Level1)
810 {
811 AudioHwRender *hwRender = (AudioHwRender *)render;
812 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
813 hwRender->devCtlHandle = nullptr;
814 AudioHandle handle = (AudioHandle)hwRender;
815 float min = GAIN_MIN;
816 float max = GAIN_MAX;
817 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetGainThreshold(handle, &min, &max));
818 hwRender->devCtlHandle = devCtlHandle;
819 }
820
821 HWTEST_F(AudioRenderTest, AudioRenderGetGainThresholdWhenDevCtlHandleIsError, TestSize.Level1)
822 {
823 AudioHwRender *hwRender = (AudioHwRender *)render;
824 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
825 struct HdfIoService *service = new HdfIoService;
826 hwRender->devCtlHandle = (struct DevHandle *)service;
827 AudioHandle handle = (AudioHandle)hwRender;
828 float min = GAIN_MIN;
829 float max = GAIN_MAX;
830 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetGainThreshold(handle, &min, &max));
831 hwRender->devCtlHandle = devCtlHandle;
832 delete(service);
833 service = nullptr;
834 }
835
836 HWTEST_F(AudioRenderTest, AudioRenderGetGainThresholdWhenParamVaild, TestSize.Level1)
837 {
838 AudioHandle handle = (AudioHandle)render;
839 float min = GAIN_MIN;
840 float max = GAIN_MAX;
841 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderGetGainThreshold(handle, &min, &max));
842 }
843
844 HWTEST_F(AudioRenderTest, AudioRenderGetGainWhenHandleIsNull, TestSize.Level1)
845 {
846 AudioHwRender *hwRender = nullptr;
847 AudioHandle handle = (AudioHandle)hwRender;
848 float gain = 0;
849 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetGain(handle, &gain));
850 }
851
852 HWTEST_F(AudioRenderTest, AudioRenderGetGainWhenGainIsNull, TestSize.Level1)
853 {
854 AudioHandle handle = (AudioHandle)render;
855 float *gain = nullptr;
856 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetGain(handle, gain));
857 }
858
859 HWTEST_F(AudioRenderTest, AudioRenderGetGainWhenDevCtlHandleIsNull, TestSize.Level1)
860 {
861 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
862 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
863 hwRender->devCtlHandle = nullptr;
864 AudioHandle handle = (AudioHandle)hwRender;
865 float gain = 0;
866 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetGain(handle, &gain));
867 hwRender->devCtlHandle = devCtlHandle;
868 }
869
870 HWTEST_F(AudioRenderTest, AudioRenderGetGainWhenDevCtlHandleIsError, TestSize.Level1)
871 {
872 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
873 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
874 struct HdfIoService *service = new HdfIoService;
875 hwRender->devCtlHandle = (struct DevHandle *)service;
876 AudioHandle handle = (AudioHandle)hwRender;
877 float gain = 0;
878 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetGain(handle, &gain));
879 hwRender->devCtlHandle = devCtlHandle;
880 delete(service);
881 service = nullptr;
882 }
883
884 HWTEST_F(AudioRenderTest, AudioRenderGetGainWhenParamVaild, TestSize.Level1)
885 {
886 AudioHandle handle = (AudioHandle)render;
887 float gain = 0;
888 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderGetGain(handle, &gain));
889 }
890
891 HWTEST_F(AudioRenderTest, AudioRenderSetGainWhenHandleIsNull, TestSize.Level1)
892 {
893 AudioHwRender *hwRender = nullptr;
894 AudioHandle handle = (AudioHandle)hwRender;
895 float gain = 0;
896 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSetGain(handle, gain));
897 }
898
899 HWTEST_F(AudioRenderTest, AudioRenderSetGainWhenGainIsLessThanZero, TestSize.Level1)
900 {
901 AudioHandle handle = (AudioHandle)render;
902 float gain = -1;
903 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSetGain(handle, gain));
904 }
905
906 HWTEST_F(AudioRenderTest, AudioRenderSetGainWhenDevCtlHandleIsNull, TestSize.Level1)
907 {
908 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
909 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
910 hwRender->devCtlHandle = nullptr;
911 AudioHandle handle = (AudioHandle)hwRender;
912 float gain = 0;
913 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetGain(handle, gain));
914 hwRender->devCtlHandle = devCtlHandle;
915 }
916
917 HWTEST_F(AudioRenderTest, AudioRenderSetGainWhenDevCtlHandleIsError, TestSize.Level1)
918 {
919 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
920 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
921 struct HdfIoService *service = new HdfIoService;
922 hwRender->devCtlHandle = (struct DevHandle *)service;
923 AudioHandle handle = (AudioHandle)hwRender;
924 float gain = 0;
925 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetGain(handle, gain));
926 hwRender->devCtlHandle = devCtlHandle;
927 delete(service);
928 service = nullptr;
929 }
930
931 HWTEST_F(AudioRenderTest, AudioRenderSetGainWhenParamVaild, TestSize.Level1)
932 {
933 AudioHandle handle = (AudioHandle)render;
934 float gain = 0;
935 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetGain(handle, gain));
936 }
937
938 HWTEST_F(AudioRenderTest, AudioRenderGetLatencyWhenRenderIsNull, TestSize.Level1)
939 {
940 struct AudioRender *utRender = nullptr;
941 uint32_t ms = 96;
942 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetLatency(utRender, &ms));
943 }
944
945 HWTEST_F(AudioRenderTest, AudioRenderGetLatencyWhenMsIsNull, TestSize.Level1)
946 {
947 uint32_t *ms = nullptr;
948 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetLatency(render, ms));
949 }
950
951 HWTEST_F(AudioRenderTest, AudioRenderGetLatencyWhenByteRateIsZero, TestSize.Level1)
952 {
953 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
954 hwRender->renderParam.frameRenderMode.byteRate = 0;
955 uint32_t ms = 96;
956 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetLatency((struct AudioRender *)hwRender, &ms));
957 }
958
959 HWTEST_F(AudioRenderTest, AudioRenderGetLatencyWhenParamVaild, TestSize.Level1)
960 {
961 uint32_t ms = 96;
962 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderGetLatency(render, &ms));
963 }
964
965 HWTEST_F(AudioRenderTest, AudioRenderRenderFrameWhenRenderIsNull, TestSize.Level1)
966 {
967 struct AudioRender *utRender = nullptr;
968 void *frame = (void *)calloc(1, FRAME_DATA);
969 ASSERT_NE(nullptr, frame);
970 uint64_t requestBytes = FRAME_DATA;
971 uint64_t replyBytes;
972 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM,
973 AudioRenderRenderFrame(utRender, (const void*)frame, requestBytes, &replyBytes));
974 free(frame);
975 frame = nullptr;
976 }
977
978 HWTEST_F(AudioRenderTest, AudioRenderRenderFrameWhenFrameIsNull, TestSize.Level1)
979 {
980 void *frame = nullptr;
981 uint64_t requestBytes = FRAME_DATA;
982 uint64_t replyBytes;
983 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM,
984 AudioRenderRenderFrame(render, (const void*)frame, requestBytes, &replyBytes));
985 }
986
987 HWTEST_F(AudioRenderTest, AudioRenderRenderFrameWhenReplyBytesIsNull, TestSize.Level1)
988 {
989 void *frame = (void *)calloc(1, FRAME_DATA);
990 ASSERT_NE(nullptr, frame);
991 uint64_t requestBytes = FRAME_DATA;
992 uint64_t *replyBytes = nullptr;
993 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM,
994 AudioRenderRenderFrame(render, (const void*)frame, requestBytes, replyBytes));
995 free(frame);
996 frame = nullptr;
997 }
998
999 HWTEST_F(AudioRenderTest, AudioRenderRenderFrameWhenRequestBytesGreaterThan16K, TestSize.Level1)
1000 {
1001 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart((AudioHandle)render));
1002 void *frame = (void *)calloc(1, FRAME_DATA);
1003 ASSERT_NE(nullptr, frame);
1004 uint64_t requestBytes = FRAME_DATA + 1;
1005 uint64_t replyBytes;
1006 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL,
1007 AudioRenderRenderFrame(render, (const void*)frame, requestBytes, &replyBytes));
1008 free(frame);
1009 frame = nullptr;
1010 }
1011
1012 HWTEST_F(AudioRenderTest, AudioRenderRenderFrameWhenFormatIsNotSupport, TestSize.Level1)
1013 {
1014 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart((AudioHandle)render));
1015 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
1016 hwRender->renderParam.frameRenderMode.attrs.format = AUDIO_FORMAT_AAC_MAIN;
1017 void *frame = (void *)calloc(1, FRAME_DATA);
1018 ASSERT_NE(nullptr, frame);
1019 uint64_t requestBytes = FRAME_DATA;
1020 uint64_t replyBytes;
1021 EXPECT_EQ(HDF_ERR_NOT_SUPPORT,
1022 AudioRenderRenderFrame(render, (const void*)frame, requestBytes, &replyBytes));
1023 free(frame);
1024 frame = nullptr;
1025 }
1026
1027 HWTEST_F(AudioRenderTest, AudioRenderRenderFrameWhenDevDataHandleIsNull, TestSize.Level1)
1028 {
1029 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart((AudioHandle)render));
1030 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
1031 struct DevHandle *devDataHandle = hwRender->devDataHandle;
1032 hwRender->devDataHandle = nullptr;
1033 void *frame = (void *)calloc(1, FRAME_DATA);
1034 ASSERT_NE(nullptr, frame);
1035 uint64_t requestBytes = FRAME_DATA;
1036 uint64_t replyBytes;
1037 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL,
1038 AudioRenderRenderFrame(render, (const void*)frame, requestBytes, &replyBytes));
1039 hwRender->devDataHandle = devDataHandle;
1040 free(frame);
1041 frame = nullptr;
1042 }
1043
1044 HWTEST_F(AudioRenderTest, AudioRenderRenderFrameWhenSampleRateIsZero, TestSize.Level1)
1045 {
1046 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart((AudioHandle)render));
1047 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
1048 hwRender->renderParam.frameRenderMode.attrs.sampleRate = 0;
1049 void *frame = (void *)calloc(1, FRAME_DATA);
1050 ASSERT_NE(nullptr, frame);
1051 uint64_t requestBytes = FRAME_DATA;
1052 uint64_t replyBytes;
1053 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderRenderFrame(render, (const void*)frame, requestBytes, &replyBytes));
1054 free(frame);
1055 frame = nullptr;
1056 }
1057
1058 HWTEST_F(AudioRenderTest, AudioRenderRenderFrameWhenParamIsVaild, TestSize.Level1)
1059 {
1060 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart((AudioHandle)render));
1061 void *frame = (void *)calloc(1, FRAME_DATA);
1062 ASSERT_NE(nullptr, frame);
1063 uint64_t requestBytes = FRAME_DATA;
1064 uint64_t replyBytes;
1065 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderRenderFrame(render, (const void*)frame, requestBytes, &replyBytes));
1066 free(frame);
1067 frame = nullptr;
1068 }
1069
1070 HWTEST_F(AudioRenderTest, AudioRenderGetRenderPositionWhenRenderIsNull, TestSize.Level1)
1071 {
1072 struct AudioRender *utRender = nullptr;
1073 uint64_t frames = 1024;
1074 struct AudioTimeStamp *time = new AudioTimeStamp;
1075 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetRenderPosition(utRender, &frames, time));
1076 delete(time);
1077 time = nullptr;
1078 }
1079
1080 HWTEST_F(AudioRenderTest, AudioRenderGetRenderPositionWhenFramesIsNull, TestSize.Level1)
1081 {
1082 uint64_t *frames = nullptr;
1083 struct AudioTimeStamp *time = new AudioTimeStamp;
1084 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetRenderPosition(render, frames, time));
1085 delete(time);
1086 time = nullptr;
1087 }
1088
1089 HWTEST_F(AudioRenderTest, AudioRenderGetRenderPositionWhenTimeIsNull, TestSize.Level1)
1090 {
1091 uint64_t frames = 1024;
1092 struct AudioTimeStamp *time = nullptr;
1093 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetRenderPosition(render, &frames, time));
1094 }
1095
1096 HWTEST_F(AudioRenderTest, AudioRenderGetRenderPositionWhenParamIsVaild, TestSize.Level1)
1097 {
1098 uint64_t frames = 1024;
1099 struct AudioTimeStamp *time = new AudioTimeStamp;
1100 EXPECT_EQ(HDF_SUCCESS, AudioRenderGetRenderPosition(render, &frames, time));
1101 delete(time);
1102 time = nullptr;
1103 }
1104
1105 HWTEST_F(AudioRenderTest, AudioRenderSetRenderSpeedWhenRenderIsNull, TestSize.Level1)
1106 {
1107 struct AudioRender *utRender = nullptr;
1108 float speed = 1.0;
1109 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSetRenderSpeed(utRender, speed));
1110 }
1111
1112 HWTEST_F(AudioRenderTest, AudioRenderSetRenderSpeedWhenParamIsVaild, TestSize.Level1)
1113 {
1114 float speed = 1.0;
1115 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioRenderSetRenderSpeed(render, speed));
1116 }
1117
1118 HWTEST_F(AudioRenderTest, AudioRenderGetRenderSpeedWhenRenderIsNull, TestSize.Level1)
1119 {
1120 struct AudioRender *utRender = nullptr;
1121 float speed = 1.0;
1122 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetRenderSpeed(utRender, &speed));
1123 }
1124
1125 HWTEST_F(AudioRenderTest, AudioRenderGetRenderSpeedWhenSpeedIsNull, TestSize.Level1)
1126 {
1127 float *speed = nullptr;
1128 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetRenderSpeed(render, speed));
1129 }
1130
1131 HWTEST_F(AudioRenderTest, AudioRenderGetRenderSpeedWhenParamIsVaild, TestSize.Level1)
1132 {
1133 float speed = 1.0;
1134 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioRenderGetRenderSpeed(render, &speed));
1135 }
1136
1137 HWTEST_F(AudioRenderTest, AudioRenderSetChannelModeWhenRenderIsNull, TestSize.Level1)
1138 {
1139 struct AudioRender *utRender = nullptr;
1140 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
1141 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderSetChannelMode(utRender, mode));
1142 }
1143
1144 HWTEST_F(AudioRenderTest, AudioRenderSetChannelModeWhenDevCtlHandleIsNull, TestSize.Level1)
1145 {
1146 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
1147 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
1148 hwRender->devCtlHandle = nullptr;
1149 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
1150 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetChannelMode((struct AudioRender *)hwRender, mode));
1151 hwRender->devCtlHandle = devCtlHandle;
1152 }
1153
1154 HWTEST_F(AudioRenderTest, AudioRenderSetChannelModeWhenDevCtlHandleIsError, TestSize.Level1)
1155 {
1156 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
1157 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
1158 struct HdfIoService *service = new HdfIoService;
1159 hwRender->devCtlHandle = (struct DevHandle *)service;
1160 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
1161 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderSetChannelMode((struct AudioRender *)hwRender, mode));
1162 hwRender->devCtlHandle = devCtlHandle;
1163 delete(service);
1164 service = nullptr;
1165 }
1166
1167 HWTEST_F(AudioRenderTest, AudioRenderSetChannelModeWhenParamIsVaild, TestSize.Level1)
1168 {
1169 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
1170 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderSetChannelMode(render, mode));
1171 }
1172
1173 HWTEST_F(AudioRenderTest, AudioRenderGetChannelModeWhenRenderIsNull, TestSize.Level1)
1174 {
1175 struct AudioRender *utRender = nullptr;
1176 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
1177 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetChannelMode(utRender, &mode));
1178 }
1179
1180 HWTEST_F(AudioRenderTest, AudioRenderGetChannelModeWhenModeIsNull, TestSize.Level1)
1181 {
1182 enum AudioChannelMode *mode = nullptr;
1183 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetChannelMode(render, mode));
1184 }
1185
1186 HWTEST_F(AudioRenderTest, AudioRenderGetChannelModeWhenDevCtlHandleIsNull, TestSize.Level1)
1187 {
1188 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
1189 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
1190 hwRender->devCtlHandle = nullptr;
1191 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
1192 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderGetChannelMode((struct AudioRender *)hwRender, &mode));
1193 hwRender->devCtlHandle = devCtlHandle;
1194 }
1195
1196 HWTEST_F(AudioRenderTest, AudioRenderGetChannelModeWhenDevCtlHandleIsError, TestSize.Level1)
1197 {
1198 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
1199 struct DevHandle *devCtlHandle = hwRender->devCtlHandle;
1200 struct HdfIoService *service = new HdfIoService;
1201 hwRender->devCtlHandle = (struct DevHandle *)service;
1202 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
1203 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderGetChannelMode((struct AudioRender *)hwRender, &mode));
1204 hwRender->devCtlHandle = devCtlHandle;
1205 delete(service);
1206 service = nullptr;
1207 }
1208
1209 HWTEST_F(AudioRenderTest, AudioRenderGetChannelModeWhenParamIsVaild, TestSize.Level1)
1210 {
1211 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
1212 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderGetChannelMode(render, &mode));
1213 }
1214
1215 HWTEST_F(AudioRenderTest, AudioRenderDrainBufferWhenTypeIsNull, TestSize.Level1)
1216 {
1217 AudioDrainNotifyType *type = nullptr;
1218 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderDrainBuffer(render, type));
1219 }
1220
1221 HWTEST_F(AudioRenderTest, AudioRenderDrainBufferWhenParamIsNotSupport, TestSize.Level1)
1222 {
1223 AudioDrainNotifyType *type = new AudioDrainNotifyType;
1224 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioRenderDrainBuffer(render, type));
1225 delete(type);
1226 type = nullptr;
1227 }
1228
1229 HWTEST_F(AudioRenderTest, AudioRenderTurnStandbyModeWhenHandleIsNull, TestSize.Level1)
1230 {
1231 AudioHwRender *hwRender = nullptr;
1232 AudioHandle handle = (AudioHandle)hwRender;
1233 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderTurnStandbyMode(handle));
1234 }
1235
1236 HWTEST_F(AudioRenderTest, AudioRenderTurnStandbyModeWhenStopIsError, TestSize.Level1)
1237 {
1238 AudioHandle handle = (AudioHandle)render;
1239 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioRenderTurnStandbyMode(handle));
1240 }
1241
1242 HWTEST_F(AudioRenderTest, AudioRenderTurnStandbyModeWhenParamIsVaild, TestSize.Level1)
1243 {
1244 AudioHandle handle = (AudioHandle)render;
1245 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderStart(handle));
1246 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderTurnStandbyMode(handle));
1247 }
1248
1249 HWTEST_F(AudioRenderTest, AudioRenderRegCallbackWhenRenderIsNull, TestSize.Level1)
1250 {
1251 struct AudioRender *utRender = nullptr;
1252 RenderCallback callback = AudioRenderCallbackUtTest;
1253 void *cookie = nullptr;
1254 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioRenderRegCallback(utRender, callback, cookie));
1255 }
1256
1257 HWTEST_F(AudioRenderTest, AudioRenderRegCallbackWhenParamIsVaild, TestSize.Level1)
1258 {
1259 RenderCallback callback = AudioRenderCallbackUtTest;
1260 void *cookie = nullptr;
1261 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderRegCallback(render, callback, cookie));
1262 }
1263
1264 HWTEST_F(AudioRenderTest, CallbackProcessingWhenHandleIsNull, TestSize.Level1)
1265 {
1266 AudioHwRender *hwRender = nullptr;
1267 AudioHandle handle = (AudioHandle)hwRender;
1268 AudioCallbackType callBackType = AUDIO_ERROR_OCCUR;
1269 EXPECT_EQ(HDF_FAILURE, CallbackProcessing(handle, callBackType));
1270 }
1271
1272 HWTEST_F(AudioRenderTest, CallbackProcessingWhenCallbackIsNull, TestSize.Level1)
1273 {
1274 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
1275 hwRender->renderParam.frameRenderMode.callback = NULL;
1276 AudioHandle handle = (AudioHandle)hwRender;
1277 AudioCallbackType callBackType = AUDIO_ERROR_OCCUR;
1278 EXPECT_EQ(HDF_FAILURE, CallbackProcessing(handle, callBackType));
1279 }
1280
1281 HWTEST_F(AudioRenderTest, CallbackProcessingWhenCallbackIsError, TestSize.Level1)
1282 {
1283 RenderCallback callback = AudioRenderCallbackUtTest;
1284 void *cookie = nullptr;
1285 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderRegCallback(render, callback, cookie));
1286 AudioHandle handle = (AudioHandle)render;
1287 int32_t callBackType = AUDIO_ERROR_OCCUR + 1;
1288 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, CallbackProcessing(handle, (enum AudioCallbackType)callBackType));
1289 }
1290
1291 HWTEST_F(AudioRenderTest, CallbackProcessingWhenParamIsVaild, TestSize.Level1)
1292 {
1293 RenderCallback callback = AudioRenderCallbackUtTest;
1294 void *cookie = nullptr;
1295 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioRenderRegCallback(render, callback, cookie));
1296 AudioHandle handle = (AudioHandle)render;
1297 AudioCallbackType callBackType = AUDIO_ERROR_OCCUR;
1298 EXPECT_EQ(HDF_SUCCESS, CallbackProcessing(handle, callBackType));
1299 }
1300 }
1301