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_interface_lib_render.h"
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19
20 using namespace std;
21 using namespace testing::ext;
22 namespace {
23 extern "C" {
24 struct HdfSBuf *AudioRenderObtainHdfSBuf();
25 int32_t IoctlWrite(const struct AudioHwRenderParam *handleData);
26 int32_t AudioServiceRenderDispatch(struct HdfIoService *service,
27 int cmdId,
28 struct HdfSBuf *sBuf,
29 struct HdfSBuf *reply);
30 int32_t SetHwParams(const struct AudioHwRenderParam *handleData);
31 int32_t AudioCtlRenderSetVolumeSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
32 int32_t AudioCtlRenderGetVolumeSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
33 int32_t AudioCtlRenderSetVolume(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
34 int32_t AudioCtlRenderGetVolume(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
35 int32_t AudioOutputRenderSetSpeedSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
36 int32_t AudioOutputRenderSetSpeed(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
37 int32_t AudioCtlRenderSetPauseBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
38 int32_t AudioCtlRenderSetPauseStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
39 int32_t AudioCtlRenderSetMuteBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
40 int32_t AudioCtlRenderSetMuteStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
41 int32_t AudioCtlRenderGetMuteSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
42 int32_t AudioCtlRenderGetMuteStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
43 int32_t AudioCtlRenderSetGainBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
44 int32_t AudioCtlRenderSetGainStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
45 int32_t AudioCtlRenderGetGainSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
46 int32_t AudioCtlRenderGetGainStu(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
47 int32_t AudioCtlRenderSceneSelectSBuf(struct HdfSBuf *sBuf,
48 struct AudioHwRenderParam *handleData,
49 int32_t deviceIndex);
50 int32_t AudioCtlRenderSceneSelect(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
51 int32_t AudioCtlRenderSceneGetGainThresholdSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
52 int32_t AudioCtlRenderSceneGetGainThreshold(struct DevHandle *handle,
53 int cmdId,
54 struct AudioHwRenderParam *handleData);
55 int32_t AudioCtlRenderSetChannelModeBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
56 int32_t AudioCtlRenderSetChannelMode(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
57 int32_t AudioCtlRenderGetChannelModeSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
58 int32_t AudioCtlRenderGetChannelMode(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
59 int32_t AudioInterfaceLibCtlRender(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
60 int32_t ParamsSbufWriteBuffer(struct HdfSBuf *sBuf);
61 int32_t FrameSbufWriteBuffer(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData);
62 int32_t AudioOutputRenderHwParams(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
63 int32_t AudioOutputRenderWrite(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
64 int32_t AudioOutputRenderStop(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
65 int32_t AudioInterfaceLibOutputRender(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
66 struct HdfIoService *HdfIoServiceBindName(const char *serviceName);
67 }
68
69 class AudioInterfaceLibRenderTest : public testing::Test {
70 public:
71 static void SetUpTestCase();
72 static void TearDownTestCase();
73 };
74
SetUpTestCase()75 void AudioInterfaceLibRenderTest::SetUpTestCase()
76 {
77 }
78
TearDownTestCase()79 void AudioInterfaceLibRenderTest::TearDownTestCase()
80 {
81 }
82
83 HWTEST_F(AudioInterfaceLibRenderTest, IoctlWriteWhenHandleIsNull, TestSize.Level0)
84 {
85 const struct AudioHwRenderParam *handleData = nullptr;
86 int32_t ret = IoctlWrite(handleData);
87 EXPECT_EQ(HDF_FAILURE, ret);
88 }
89
90 HWTEST_F(AudioInterfaceLibRenderTest, IoctlWriteWhenParamIsVaild, TestSize.Level0)
91 {
92 const struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
93 int32_t ret = IoctlWrite(handleData);
94 EXPECT_EQ(HDF_SUCCESS, ret);
95 delete(handleData);
96 handleData = nullptr;
97 }
98
99 HWTEST_F(AudioInterfaceLibRenderTest, SetHwParamsWhenHandleIsNull, TestSize.Level0)
100 {
101 const struct AudioHwRenderParam *handleData = nullptr;
102 int32_t ret = SetHwParams(handleData);
103 EXPECT_EQ(HDF_FAILURE, ret);
104 }
105
106 HWTEST_F(AudioInterfaceLibRenderTest, SetHwParamsWhenHandleIsVaild, TestSize.Level0)
107 {
108 const struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
109 int32_t ret = SetHwParams(handleData);
110 EXPECT_EQ(HDF_SUCCESS, ret);
111 delete(handleData);
112 handleData = nullptr;
113 }
114
115 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetVolumeSBufWhenSbuffIsNull, TestSize.Level0)
116 {
117 struct HdfSBuf *sBuf = nullptr;
118 AudioHwRenderParam *handleData = new AudioHwRenderParam;
119 int32_t ret = AudioCtlRenderSetVolumeSBuf(sBuf, handleData);
120 EXPECT_EQ(HDF_FAILURE, ret);
121 delete(handleData);
122 handleData = nullptr;
123 }
124
125 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetVolumeSBufWhenHandleDataIsNull, TestSize.Level0)
126 {
127 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
128 AudioHwRenderParam *handleData = nullptr;
129 int32_t ret = AudioCtlRenderSetVolumeSBuf(sBuf, handleData);
130 EXPECT_EQ(HDF_FAILURE, ret);
131 HdfSBufRecycle(sBuf);
132 }
133
134 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetVolumeSBufWhenParamIsVaild, TestSize.Level0)
135 {
136 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
137 AudioHwRenderParam *handleData = new AudioHwRenderParam;
138 int32_t ret = AudioCtlRenderSetVolumeSBuf(sBuf, handleData);
139 EXPECT_EQ(HDF_SUCCESS, ret);
140 HdfSBufRecycle(sBuf);
141 delete(handleData);
142 handleData = nullptr;
143 }
144
145 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetVolumeSBufWhenSbuffIsNull, TestSize.Level0)
146 {
147 struct HdfSBuf *sBuf = nullptr;
148 AudioHwRenderParam *handleData = new AudioHwRenderParam;
149 int32_t ret = AudioCtlRenderGetVolumeSBuf(sBuf, handleData);
150 EXPECT_EQ(HDF_FAILURE, ret);
151 delete(handleData);
152 handleData = nullptr;
153 }
154
155 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetVolumeSBufWhenHandleDataIsNull, TestSize.Level0)
156 {
157 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
158 AudioHwRenderParam *handleData = nullptr;
159 int32_t ret = AudioCtlRenderGetVolumeSBuf(sBuf, handleData);
160 EXPECT_EQ(HDF_FAILURE, ret);
161 HdfSBufRecycle(sBuf);
162 }
163
164 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetVolumeSBufWhenParamIsVaild, TestSize.Level0)
165 {
166 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
167 AudioHwRenderParam *handleData = new AudioHwRenderParam;
168 int32_t ret = AudioCtlRenderGetVolumeSBuf(sBuf, handleData);
169 EXPECT_EQ(HDF_SUCCESS, ret);
170 HdfSBufRecycle(sBuf);
171 delete(handleData);
172 handleData = nullptr;
173 }
174
175 HWTEST_F(AudioInterfaceLibRenderTest, AudioOutputRenderSetSpeedSBufWhenSbuffIsNull, TestSize.Level0)
176 {
177 struct HdfSBuf *sBuf = nullptr;
178 AudioHwRenderParam *handleData = new AudioHwRenderParam;
179 int32_t ret = AudioOutputRenderSetSpeedSBuf(sBuf, handleData);
180 EXPECT_EQ(HDF_FAILURE, ret);
181 delete(handleData);
182 handleData = nullptr;
183 }
184
185 HWTEST_F(AudioInterfaceLibRenderTest, AudioOutputRenderSetSpeedSBufWhenHandleDataIsNull, TestSize.Level0)
186 {
187 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
188 AudioHwRenderParam *handleData = nullptr;
189 int32_t ret = AudioOutputRenderSetSpeedSBuf(sBuf, handleData);
190 EXPECT_EQ(HDF_FAILURE, ret);
191 HdfSBufRecycle(sBuf);
192 }
193
194 HWTEST_F(AudioInterfaceLibRenderTest, AudioOutputRenderSetSpeedSBufWhenParamIsVaild, TestSize.Level0)
195 {
196 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
197 AudioHwRenderParam *handleData = new AudioHwRenderParam;
198 int32_t ret = AudioOutputRenderSetSpeedSBuf(sBuf, handleData);
199 EXPECT_EQ(HDF_SUCCESS, ret);
200 HdfSBufRecycle(sBuf);
201 delete(handleData);
202 handleData = nullptr;
203 }
204
205 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetPauseBufWhenSbufIsNull, TestSize.Level0)
206 {
207 struct HdfSBuf *sBuf = nullptr;
208 AudioHwRenderParam *handleData = new AudioHwRenderParam;
209 int32_t ret = AudioCtlRenderSetPauseBuf(sBuf, handleData);
210 EXPECT_EQ(HDF_FAILURE, ret);
211 delete(handleData);
212 handleData = nullptr;
213 }
214
215 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetPauseBufWhenHandleDataIsNull, TestSize.Level0)
216 {
217 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
218 AudioHwRenderParam *handleData = nullptr;
219 int32_t ret = AudioCtlRenderSetPauseBuf(sBuf, handleData);
220 EXPECT_EQ(HDF_FAILURE, ret);
221 HdfSBufRecycle(sBuf);
222 }
223
224 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetPauseBufWhenParamIsVaild, TestSize.Level0)
225 {
226 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
227 AudioHwRenderParam *handleData = new AudioHwRenderParam;
228 int32_t ret = AudioCtlRenderSetPauseBuf(sBuf, handleData);
229 EXPECT_EQ(HDF_SUCCESS, ret);
230 HdfSBufRecycle(sBuf);
231 delete(handleData);
232 handleData = nullptr;
233 }
234
235 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetMuteBufWhenSbufIsNull, TestSize.Level0)
236 {
237 struct HdfSBuf *sBuf = nullptr;
238 AudioHwRenderParam *handleData = new AudioHwRenderParam;
239 int32_t ret = AudioCtlRenderSetMuteBuf(sBuf, handleData);
240 EXPECT_EQ(HDF_FAILURE, ret);
241 delete(handleData);
242 handleData = nullptr;
243 }
244
245 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetMuteBufWhenHandleDataIsNull, TestSize.Level0)
246 {
247 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
248 AudioHwRenderParam *handleData = nullptr;
249 int32_t ret = AudioCtlRenderSetMuteBuf(sBuf, handleData);
250 EXPECT_EQ(HDF_FAILURE, ret);
251 HdfSBufRecycle(sBuf);
252 }
253
254 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetMuteBufWhenParamIsVaild, TestSize.Level0)
255 {
256 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
257 AudioHwRenderParam *handleData = new AudioHwRenderParam;
258 int32_t ret = AudioCtlRenderSetMuteBuf(sBuf, handleData);
259 EXPECT_EQ(HDF_SUCCESS, ret);
260 HdfSBufRecycle(sBuf);
261 delete(handleData);
262 handleData = nullptr;
263 }
264
265 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetMuteSBufWhenSbufIsNull, TestSize.Level0)
266 {
267 struct HdfSBuf *sBuf = nullptr;
268 AudioHwRenderParam *handleData = new AudioHwRenderParam;
269 int32_t ret = AudioCtlRenderGetMuteSBuf(sBuf, handleData);
270 EXPECT_EQ(HDF_FAILURE, ret);
271 delete(handleData);
272 handleData = nullptr;
273 }
274
275 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetMuteSBufWhenHandleDataIsNull, TestSize.Level0)
276 {
277 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
278 AudioHwRenderParam *handleData = nullptr;
279 int32_t ret = AudioCtlRenderGetMuteSBuf(sBuf, handleData);
280 EXPECT_EQ(HDF_FAILURE, ret);
281 HdfSBufRecycle(sBuf);
282 }
283
284 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetMuteSBufWhenParamIsVaild, TestSize.Level0)
285 {
286 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
287 AudioHwRenderParam *handleData = new AudioHwRenderParam;
288 int32_t ret = AudioCtlRenderGetMuteSBuf(sBuf, handleData);
289 EXPECT_EQ(HDF_SUCCESS, ret);
290 HdfSBufRecycle(sBuf);
291 delete(handleData);
292 handleData = nullptr;
293 }
294
295 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetGainBufWhenSbufIsNull, TestSize.Level0)
296 {
297 struct HdfSBuf *sBuf = nullptr;
298 AudioHwRenderParam *handleData = new AudioHwRenderParam;
299 int32_t ret = AudioCtlRenderSetGainBuf(sBuf, handleData);
300 EXPECT_EQ(HDF_FAILURE, ret);
301 delete(handleData);
302 handleData = nullptr;
303 }
304
305 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetGainBufWhenHandleDataIsNull, TestSize.Level0)
306 {
307 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
308 AudioHwRenderParam *handleData = nullptr;
309 int32_t ret = AudioCtlRenderSetGainBuf(sBuf, handleData);
310 EXPECT_EQ(HDF_FAILURE, ret);
311 HdfSBufRecycle(sBuf);
312 }
313
314 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetGainBufWhenParamIsVaild, TestSize.Level0)
315 {
316 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
317 AudioHwRenderParam *handleData = new AudioHwRenderParam;
318 int32_t ret = AudioCtlRenderSetGainBuf(sBuf, handleData);
319 EXPECT_EQ(HDF_SUCCESS, ret);
320 HdfSBufRecycle(sBuf);
321 delete(handleData);
322 handleData = nullptr;
323 }
324
325 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetGainSBufWhenSbufIsNull, TestSize.Level0)
326 {
327 struct HdfSBuf *sBuf = nullptr;
328 AudioHwRenderParam *handleData = new AudioHwRenderParam;
329 int32_t ret = AudioCtlRenderGetGainSBuf(sBuf, handleData);
330 EXPECT_EQ(HDF_FAILURE, ret);
331 delete(handleData);
332 handleData = nullptr;
333 }
334
335 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetGainSBufWhenHandleDataIsNull, TestSize.Level0)
336 {
337 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
338 AudioHwRenderParam *handleData = nullptr;
339 int32_t ret = AudioCtlRenderGetGainSBuf(sBuf, handleData);
340 EXPECT_EQ(HDF_FAILURE, ret);
341 HdfSBufRecycle(sBuf);
342 }
343
344 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetGainSBufWhenParamIsVaild, TestSize.Level0)
345 {
346 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
347 AudioHwRenderParam *handleData = new AudioHwRenderParam;
348 int32_t ret = AudioCtlRenderGetGainSBuf(sBuf, handleData);
349 EXPECT_EQ(HDF_SUCCESS, ret);
350 HdfSBufRecycle(sBuf);
351 delete(handleData);
352 handleData = nullptr;
353 }
354
355 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSceneSelectSBufWhenSbufIsNull, TestSize.Level0)
356 {
357 struct HdfSBuf *sBuf = nullptr;
358 AudioHwRenderParam *handleData = new AudioHwRenderParam;
359 int32_t deviceIndex = 0;
360 int32_t ret = AudioCtlRenderSceneSelectSBuf(sBuf, handleData, deviceIndex);
361 EXPECT_EQ(HDF_FAILURE, ret);
362 delete(handleData);
363 handleData = nullptr;
364 }
365
366 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSceneSelectSBufWhenHandleDataIsNull, TestSize.Level0)
367 {
368 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
369 AudioHwRenderParam *handleData = nullptr;
370 int32_t deviceIndex = 0;
371 int32_t ret = AudioCtlRenderSceneSelectSBuf(sBuf, handleData, deviceIndex);
372 EXPECT_EQ(HDF_FAILURE, ret);
373 HdfSBufRecycle(sBuf);
374 }
375
376 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSceneSelectSBufWhenParamIsVaild, TestSize.Level0)
377 {
378 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
379 AudioHwRenderParam *handleData = new AudioHwRenderParam;
380 int32_t deviceIndex = 0;
381 int32_t ret = AudioCtlRenderSceneSelectSBuf(sBuf, handleData, deviceIndex);
382 EXPECT_EQ(HDF_SUCCESS, ret);
383 HdfSBufRecycle(sBuf);
384 delete(handleData);
385 handleData = nullptr;
386 }
387
388 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSceneGetGainThresholdSBufWhenSbufIsNull, TestSize.Level0)
389 {
390 struct HdfSBuf *sBuf = nullptr;
391 AudioHwRenderParam *handleData = new AudioHwRenderParam;
392 int32_t ret = AudioCtlRenderSceneGetGainThresholdSBuf(sBuf, handleData);
393 EXPECT_EQ(HDF_FAILURE, ret);
394 delete(handleData);
395 handleData = nullptr;
396 }
397
398 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSceneGetGainThresholdSBufWhenHandleDataIsNull, TestSize.Level0)
399 {
400 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
401 AudioHwRenderParam *handleData = nullptr;
402 int32_t ret = AudioCtlRenderSceneGetGainThresholdSBuf(sBuf, handleData);
403 EXPECT_EQ(HDF_FAILURE, ret);
404 HdfSBufRecycle(sBuf);
405 }
406
407 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSceneGetGainThresholdSBufWhenParamIsVaild, TestSize.Level0)
408 {
409 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
410 AudioHwRenderParam *handleData = new AudioHwRenderParam;
411 int32_t ret = AudioCtlRenderSceneGetGainThresholdSBuf(sBuf, handleData);
412 EXPECT_EQ(HDF_SUCCESS, ret);
413 HdfSBufRecycle(sBuf);
414 delete(handleData);
415 handleData = nullptr;
416 }
417
418 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetChannelModeBufWhenSbufIsNull, TestSize.Level0)
419 {
420 struct HdfSBuf *sBuf = nullptr;
421 AudioHwRenderParam *handleData = new AudioHwRenderParam;
422 int32_t ret = AudioCtlRenderSetChannelModeBuf(sBuf, handleData);
423 EXPECT_EQ(HDF_FAILURE, ret);
424 delete(handleData);
425 handleData = nullptr;
426 }
427
428 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetChannelModeBufWhenHandleDataIsNull, TestSize.Level0)
429 {
430 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
431 AudioHwRenderParam *handleData = nullptr;
432 int32_t ret = AudioCtlRenderSetChannelModeBuf(sBuf, handleData);
433 EXPECT_EQ(HDF_FAILURE, ret);
434 HdfSBufRecycle(sBuf);
435 }
436
437 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderSetChannelModeBufWhenParamIsVaild, TestSize.Level0)
438 {
439 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
440 AudioHwRenderParam *handleData = new AudioHwRenderParam;
441 int32_t ret = AudioCtlRenderSetChannelModeBuf(sBuf, handleData);
442 EXPECT_EQ(HDF_SUCCESS, ret);
443 HdfSBufRecycle(sBuf);
444 delete(handleData);
445 handleData = nullptr;
446 }
447
448 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetChannelModeSBufWhenSbufIsNull, TestSize.Level0)
449 {
450 struct HdfSBuf *sBuf = nullptr;
451 AudioHwRenderParam *handleData = new AudioHwRenderParam;
452 int32_t ret = AudioCtlRenderGetChannelModeSBuf(sBuf, handleData);
453 EXPECT_EQ(HDF_FAILURE, ret);
454 delete(handleData);
455 handleData = nullptr;
456 }
457
458 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetChannelModeSBufWhenHandleDataIsNull, TestSize.Level0)
459 {
460 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
461 AudioHwRenderParam *handleData = nullptr;
462 int32_t ret = AudioCtlRenderGetChannelModeSBuf(sBuf, handleData);
463 EXPECT_EQ(HDF_FAILURE, ret);
464 HdfSBufRecycle(sBuf);
465 }
466
467 HWTEST_F(AudioInterfaceLibRenderTest, AudioCtlRenderGetChannelModeSBufWhenParamIsVaild, TestSize.Level0)
468 {
469 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
470 AudioHwRenderParam *handleData = new AudioHwRenderParam;
471 int32_t ret = AudioCtlRenderGetChannelModeSBuf(sBuf, handleData);
472 EXPECT_EQ(HDF_SUCCESS, ret);
473 HdfSBufRecycle(sBuf);
474 delete(handleData);
475 handleData = nullptr;
476 }
477
478 HWTEST_F(AudioInterfaceLibRenderTest, ParamsSbufWriteBufferWhenSbufIsNull, TestSize.Level0)
479 {
480 struct HdfSBuf *sBuf = nullptr;
481 int32_t ret = ParamsSbufWriteBuffer(sBuf);
482 EXPECT_EQ(HDF_FAILURE, ret);
483 }
484
485 HWTEST_F(AudioInterfaceLibRenderTest, ParamsSbufWriteBufferWhenParamIsVaild, TestSize.Level0)
486 {
487 struct HdfSBuf *sBuf = AudioRenderObtainHdfSBuf();
488 int32_t ret = ParamsSbufWriteBuffer(sBuf);
489 EXPECT_EQ(HDF_SUCCESS, ret);
490 HdfSBufRecycle(sBuf);
491 }
492 }
493