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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include "audio_interface_lib_render.h"
19
20 using namespace std;
21 using namespace testing::ext;
22 namespace {
23 extern "C" {
24 struct HdfSBuf *HdfSbufObtainDefaultSize();
25 int32_t IoctlWrite(const struct AudioHwRenderParam *handleData);
26 int32_t AudioServiceRenderDispatch(struct HdfIoService *service, int cmdId,
27 struct HdfSBuf *sBuf, struct HdfSBuf *reply);
28 int32_t SetHwParams(const struct AudioHwRenderParam *handleData);
29 int32_t AudioCtlRenderSetVolumeSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
30 int32_t AudioCtlRenderGetVolumeSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
31 int32_t AudioCtlRenderSetVolume(const struct DevHandle *handle,
32 int cmdId, const struct AudioHwRenderParam *handleData);
33 int32_t AudioCtlRenderGetVolume(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
34 int32_t AudioOutputRenderSetSpeed(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
35 int32_t AudioCtlRenderSetPauseBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
36 int32_t AudioCtlRenderSetPauseStu(const struct DevHandle *handle,
37 int cmdId, const struct AudioHwRenderParam *handleData);
38 int32_t AudioCtlRenderSetMuteBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
39 int32_t AudioCtlRenderSetMuteStu(const struct DevHandle *handle,
40 int cmdId, const struct AudioHwRenderParam *handleData);
41 int32_t AudioCtlRenderGetMuteSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
42 int32_t AudioCtlRenderGetMuteStu(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
43 int32_t AudioCtlRenderSetGainBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
44 int32_t AudioCtlRenderSetGainStu(const struct DevHandle *handle,
45 int cmdId, const struct AudioHwRenderParam *handleData);
46 int32_t AudioCtlRenderGetGainSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
47 int32_t AudioCtlRenderGetGainStu(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
48 int32_t AudioCtlRenderSceneSelectSBuf(struct HdfSBuf *sBuf,
49 struct AudioHwRenderParam *handleData, int32_t deviceIndex);
50 int32_t AudioCtlRenderSceneSelect(const struct DevHandle *handle,
51 int cmdId, const struct AudioHwRenderParam *handleData);
52 int32_t AudioCtlRenderSceneGetGainThresholdSBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
53 int32_t AudioCtlRenderSceneGetGainThreshold(const struct DevHandle *handle,
54 int cmdId, struct AudioHwRenderParam *handleData);
55 int32_t AudioCtlRenderSetChannelModeBuf(struct HdfSBuf *sBuf, struct AudioHwRenderParam *handleData);
56 int32_t AudioCtlRenderSetChannelMode(const struct DevHandle *handle,
57 int cmdId, const struct AudioHwRenderParam *handleData);
58 int32_t AudioCtlRenderGetChannelModeSBuf(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData);
59 int32_t AudioCtlRenderGetChannelMode(const struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
60 int32_t AudioInterfaceLibCtlRender(const struct DevHandle *handle,
61 int cmdId, struct AudioHwRenderParam *handleData);
62 int32_t FrameSbufWriteBuffer(struct HdfSBuf *sBuf, const struct AudioHwRenderParam *handleData);
63 int32_t AudioOutputRenderHwParams(const struct DevHandle *handle,
64 int cmdId, const struct AudioHwRenderParam *handleData);
65 int32_t AudioOutputRenderWrite(const struct DevHandle *handle,
66 int cmdId, const struct AudioHwRenderParam *handleData);
67 int32_t AudioOutputRenderStop(const struct DevHandle *handle,
68 int cmdId, const struct AudioHwRenderParam *handleData);
69 int32_t AudioInterfaceLibOutputRender(const struct DevHandle *handle, int cmdId,
70 struct AudioHwRenderParam *handleData);
71 struct HdfIoService *HdfIoServiceBindName(const char *serviceName);
72 }
73
74 class AudioAdmIfLibRenderTest : public testing::Test {
75 public:
76 static void SetUpTestCase();
77 static void TearDownTestCase();
78 };
79
SetUpTestCase()80 void AudioAdmIfLibRenderTest::SetUpTestCase()
81 {
82 }
83
TearDownTestCase()84 void AudioAdmIfLibRenderTest::TearDownTestCase()
85 {
86 }
87
88 HWTEST_F(AudioAdmIfLibRenderTest, SetHwParams_001, TestSize.Level1)
89 {
90 const struct AudioHwRenderParam *handleData = nullptr;
91 int32_t ret = SetHwParams(handleData);
92 EXPECT_EQ(HDF_FAILURE, ret);
93 }
94
95 HWTEST_F(AudioAdmIfLibRenderTest, SetHwParams_002, TestSize.Level1)
96 {
97 struct AudioHwRenderParam *handleData = new AudioHwRenderParam;
98 handleData->renderMode.hwInfo.card = AUDIO_SERVICE_IN;
99 int32_t ret = SetHwParams((const struct AudioHwRenderParam *)handleData);
100 EXPECT_EQ(HDF_SUCCESS, ret);
101 delete(handleData);
102 handleData = nullptr;
103 }
104
105 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSetVolumeSBuf_001, TestSize.Level1)
106 {
107 struct HdfSBuf *sBuf = nullptr;
108 AudioHwRenderParam *handleData = new AudioHwRenderParam;
109 int32_t ret = AudioCtlRenderSetVolumeSBuf(sBuf, handleData);
110 EXPECT_EQ(HDF_FAILURE, ret);
111 delete(handleData);
112 handleData = nullptr;
113 }
114
115 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSetVolumeSBuf_002, TestSize.Level1)
116 {
117 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
118 AudioHwRenderParam *handleData = nullptr;
119 int32_t ret = AudioCtlRenderSetVolumeSBuf(sBuf, handleData);
120 EXPECT_EQ(HDF_FAILURE, ret);
121 HdfSbufRecycle(sBuf);
122 }
123
124 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSetVolumeSBuf_003, TestSize.Level1)
125 {
126 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
127 AudioHwRenderParam *handleData = new AudioHwRenderParam;
128 handleData->renderMode.hwInfo.card = AUDIO_SERVICE_IN;
129 int32_t ret = AudioCtlRenderSetVolumeSBuf(sBuf, handleData);
130 EXPECT_EQ(HDF_SUCCESS, ret);
131 HdfSbufRecycle(sBuf);
132 delete(handleData);
133 handleData = nullptr;
134 }
135
136 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderGetVolumeSBuf_001, TestSize.Level1)
137 {
138 struct HdfSBuf *sBuf = nullptr;
139 AudioHwRenderParam *handleData = new AudioHwRenderParam;
140 int32_t ret = AudioCtlRenderGetVolumeSBuf(sBuf, handleData);
141 EXPECT_EQ(HDF_FAILURE, ret);
142 delete(handleData);
143 handleData = nullptr;
144 }
145
146 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderGetVolumeSBuf_002, TestSize.Level1)
147 {
148 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
149 AudioHwRenderParam *handleData = nullptr;
150 int32_t ret = AudioCtlRenderGetVolumeSBuf(sBuf, handleData);
151 EXPECT_EQ(HDF_FAILURE, ret);
152 HdfSbufRecycle(sBuf);
153 }
154
155 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderGetVolumeSBuf_003, TestSize.Level1)
156 {
157 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
158 AudioHwRenderParam *handleData = new AudioHwRenderParam;
159 handleData->renderMode.hwInfo.card = AUDIO_SERVICE_IN;
160 int32_t ret = AudioCtlRenderGetVolumeSBuf(sBuf, handleData);
161 EXPECT_EQ(HDF_SUCCESS, ret);
162 HdfSbufRecycle(sBuf);
163 delete(handleData);
164 handleData = nullptr;
165 }
166
167 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSetPauseBuf_001, TestSize.Level1)
168 {
169 struct HdfSBuf *sBuf = nullptr;
170 AudioHwRenderParam *handleData = new AudioHwRenderParam;
171 int32_t ret = AudioCtlRenderSetPauseBuf(sBuf, handleData);
172 EXPECT_EQ(HDF_FAILURE, ret);
173 delete(handleData);
174 handleData = nullptr;
175 }
176
177 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSetPauseBuf_002, TestSize.Level1)
178 {
179 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
180 AudioHwRenderParam *handleData = nullptr;
181 int32_t ret = AudioCtlRenderSetPauseBuf(sBuf, handleData);
182 EXPECT_EQ(HDF_FAILURE, ret);
183 HdfSbufRecycle(sBuf);
184 }
185
186 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSetPauseBuf_003, TestSize.Level1)
187 {
188 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
189 AudioHwRenderParam *handleData = new AudioHwRenderParam;
190 handleData->renderMode.hwInfo.card = AUDIO_SERVICE_IN;
191 int32_t ret = AudioCtlRenderSetPauseBuf(sBuf, handleData);
192 EXPECT_EQ(HDF_SUCCESS, ret);
193 HdfSbufRecycle(sBuf);
194 delete(handleData);
195 handleData = nullptr;
196 }
197
198 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSetMuteBuf_001, TestSize.Level1)
199 {
200 struct HdfSBuf *sBuf = nullptr;
201 AudioHwRenderParam *handleData = new AudioHwRenderParam;
202 int32_t ret = AudioCtlRenderSetMuteBuf(sBuf, handleData);
203 EXPECT_EQ(HDF_FAILURE, ret);
204 delete(handleData);
205 handleData = nullptr;
206 }
207
208 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSetMuteBuf_002, TestSize.Level1)
209 {
210 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
211 AudioHwRenderParam *handleData = nullptr;
212 int32_t ret = AudioCtlRenderSetMuteBuf(sBuf, handleData);
213 EXPECT_EQ(HDF_FAILURE, ret);
214 HdfSbufRecycle(sBuf);
215 }
216
217 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSetMuteBuf_003, TestSize.Level1)
218 {
219 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
220 AudioHwRenderParam *handleData = new AudioHwRenderParam;
221 handleData->renderMode.hwInfo.card = AUDIO_SERVICE_IN;
222 int32_t ret = AudioCtlRenderSetMuteBuf(sBuf, handleData);
223 EXPECT_EQ(HDF_SUCCESS, ret);
224 HdfSbufRecycle(sBuf);
225 delete(handleData);
226 handleData = nullptr;
227 }
228
229 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderGetMuteSBuf_001, TestSize.Level1)
230 {
231 struct HdfSBuf *sBuf = nullptr;
232 AudioHwRenderParam *handleData = new AudioHwRenderParam;
233 int32_t ret = AudioCtlRenderGetMuteSBuf(sBuf, handleData);
234 EXPECT_EQ(HDF_FAILURE, ret);
235 delete(handleData);
236 handleData = nullptr;
237 }
238
239 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderGetMuteSBuf_002, TestSize.Level1)
240 {
241 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
242 AudioHwRenderParam *handleData = nullptr;
243 int32_t ret = AudioCtlRenderGetMuteSBuf(sBuf, handleData);
244 EXPECT_EQ(HDF_FAILURE, ret);
245 HdfSbufRecycle(sBuf);
246 }
247
248 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderGetMuteSBuf_003, TestSize.Level1)
249 {
250 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
251 AudioHwRenderParam *handleData = new AudioHwRenderParam;
252 handleData->renderMode.hwInfo.card = AUDIO_SERVICE_IN;
253 int32_t ret = AudioCtlRenderGetMuteSBuf(sBuf, handleData);
254 EXPECT_EQ(HDF_SUCCESS, ret);
255 HdfSbufRecycle(sBuf);
256 delete(handleData);
257 handleData = nullptr;
258 }
259
260 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSetGainBuf_001, TestSize.Level1)
261 {
262 struct HdfSBuf *sBuf = nullptr;
263 AudioHwRenderParam *handleData = new AudioHwRenderParam;
264 int32_t ret = AudioCtlRenderSetGainBuf(sBuf, handleData);
265 EXPECT_EQ(HDF_FAILURE, ret);
266 delete(handleData);
267 handleData = nullptr;
268 }
269
270 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSetGainBuf_002, TestSize.Level1)
271 {
272 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
273 AudioHwRenderParam *handleData = nullptr;
274 int32_t ret = AudioCtlRenderSetGainBuf(sBuf, handleData);
275 EXPECT_EQ(HDF_FAILURE, ret);
276 HdfSbufRecycle(sBuf);
277 }
278
279 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSetGainBuf_003, TestSize.Level1)
280 {
281 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
282 AudioHwRenderParam *handleData = new AudioHwRenderParam;
283 handleData->renderMode.hwInfo.card = AUDIO_SERVICE_IN;
284 int32_t ret = AudioCtlRenderSetGainBuf(sBuf, handleData);
285 EXPECT_EQ(HDF_SUCCESS, ret);
286 HdfSbufRecycle(sBuf);
287 delete(handleData);
288 handleData = nullptr;
289 }
290
291 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderGetGainSBuf_001, TestSize.Level1)
292 {
293 struct HdfSBuf *sBuf = nullptr;
294 AudioHwRenderParam *handleData = new AudioHwRenderParam;
295 int32_t ret = AudioCtlRenderGetGainSBuf(sBuf, handleData);
296 EXPECT_EQ(HDF_FAILURE, ret);
297 delete(handleData);
298 handleData = nullptr;
299 }
300
301 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderGetGainSBuf_002, TestSize.Level1)
302 {
303 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
304 AudioHwRenderParam *handleData = nullptr;
305 int32_t ret = AudioCtlRenderGetGainSBuf(sBuf, handleData);
306 EXPECT_EQ(HDF_FAILURE, ret);
307 HdfSbufRecycle(sBuf);
308 }
309
310 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderGetGainSBuf_003, TestSize.Level1)
311 {
312 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
313 AudioHwRenderParam *handleData = new AudioHwRenderParam;
314 handleData->renderMode.hwInfo.card = AUDIO_SERVICE_IN;
315 int32_t ret = AudioCtlRenderGetGainSBuf(sBuf, handleData);
316 EXPECT_EQ(HDF_SUCCESS, ret);
317 HdfSbufRecycle(sBuf);
318 delete(handleData);
319 handleData = nullptr;
320 }
321
322 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSceneSelectSBuf_001, TestSize.Level1)
323 {
324 struct HdfSBuf *sBuf = nullptr;
325 AudioHwRenderParam *handleData = new AudioHwRenderParam;
326 int32_t deviceIndex = 0;
327 int32_t ret = AudioCtlRenderSceneSelectSBuf(sBuf, handleData, deviceIndex);
328 EXPECT_EQ(HDF_FAILURE, ret);
329 delete(handleData);
330 handleData = nullptr;
331 }
332
333 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSceneSelectSBuf_002, TestSize.Level1)
334 {
335 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
336 AudioHwRenderParam *handleData = nullptr;
337 int32_t deviceIndex = 0;
338 int32_t ret = AudioCtlRenderSceneSelectSBuf(sBuf, handleData, deviceIndex);
339 EXPECT_EQ(HDF_FAILURE, ret);
340 HdfSbufRecycle(sBuf);
341 }
342
343 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSceneSelectSBuf_003, TestSize.Level1)
344 {
345 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
346 AudioHwRenderParam *handleData = new AudioHwRenderParam;
347 handleData->renderMode.hwInfo.card = AUDIO_SERVICE_IN;
348 int32_t deviceIndex = 0;
349 int32_t ret = AudioCtlRenderSceneSelectSBuf(sBuf, handleData, deviceIndex);
350 EXPECT_EQ(HDF_SUCCESS, ret);
351 HdfSbufRecycle(sBuf);
352 delete(handleData);
353 handleData = nullptr;
354 }
355
356 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSceneGetGainThreshold_001, TestSize.Level1)
357 {
358 struct HdfSBuf *sBuf = nullptr;
359 AudioHwRenderParam *handleData = new AudioHwRenderParam;
360 int32_t ret = AudioCtlRenderSceneGetGainThresholdSBuf(sBuf, handleData);
361 EXPECT_EQ(HDF_FAILURE, ret);
362 delete(handleData);
363 handleData = nullptr;
364 }
365
366 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSceneGetGainThreshold_002, TestSize.Level1)
367 {
368 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
369 AudioHwRenderParam *handleData = nullptr;
370 int32_t ret = AudioCtlRenderSceneGetGainThresholdSBuf(sBuf, handleData);
371 EXPECT_EQ(HDF_FAILURE, ret);
372 HdfSbufRecycle(sBuf);
373 }
374
375 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSceneGetGainThreshold_003, TestSize.Level1)
376 {
377 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
378 AudioHwRenderParam *handleData = new AudioHwRenderParam;
379 handleData->renderMode.hwInfo.card = AUDIO_SERVICE_IN;
380 int32_t ret = AudioCtlRenderSceneGetGainThresholdSBuf(sBuf, handleData);
381 EXPECT_EQ(HDF_SUCCESS, ret);
382 HdfSbufRecycle(sBuf);
383 delete(handleData);
384 handleData = nullptr;
385 }
386
387 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSetChannelMode_001, TestSize.Level1)
388 {
389 struct HdfSBuf *sBuf = nullptr;
390 AudioHwRenderParam *handleData = new AudioHwRenderParam;
391 int32_t ret = AudioCtlRenderSetChannelModeBuf(sBuf, handleData);
392 EXPECT_EQ(HDF_FAILURE, ret);
393 delete(handleData);
394 handleData = nullptr;
395 }
396
397 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSetChannelMode_002, TestSize.Level1)
398 {
399 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
400 AudioHwRenderParam *handleData = nullptr;
401 int32_t ret = AudioCtlRenderSetChannelModeBuf(sBuf, handleData);
402 EXPECT_EQ(HDF_FAILURE, ret);
403 HdfSbufRecycle(sBuf);
404 }
405
406 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderSetChannelMode_003, TestSize.Level1)
407 {
408 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
409 AudioHwRenderParam *handleData = new AudioHwRenderParam;
410 handleData->renderMode.hwInfo.card = AUDIO_SERVICE_IN;
411 int32_t ret = AudioCtlRenderSetChannelModeBuf(sBuf, handleData);
412 EXPECT_EQ(HDF_SUCCESS, ret);
413 HdfSbufRecycle(sBuf);
414 delete(handleData);
415 handleData = nullptr;
416 }
417
418 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderGetChannelMode_001, TestSize.Level1)
419 {
420 struct HdfSBuf *sBuf = nullptr;
421 AudioHwRenderParam *handleData = new AudioHwRenderParam;
422 int32_t ret = AudioCtlRenderGetChannelModeSBuf(sBuf, handleData);
423 EXPECT_EQ(HDF_FAILURE, ret);
424 delete(handleData);
425 handleData = nullptr;
426 }
427
428 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderGetChannelMode_002, TestSize.Level1)
429 {
430 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
431 AudioHwRenderParam *handleData = nullptr;
432 int32_t ret = AudioCtlRenderGetChannelModeSBuf(sBuf, handleData);
433 EXPECT_EQ(HDF_FAILURE, ret);
434 HdfSbufRecycle(sBuf);
435 }
436
437 HWTEST_F(AudioAdmIfLibRenderTest, AudioCtlRenderGetChannelMode_003, TestSize.Level1)
438 {
439 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
440 AudioHwRenderParam *handleData = new AudioHwRenderParam;
441 handleData->renderMode.hwInfo.card = AUDIO_SERVICE_IN;
442 int32_t ret = AudioCtlRenderGetChannelModeSBuf(sBuf, handleData);
443 EXPECT_EQ(HDF_SUCCESS, ret);
444 HdfSbufRecycle(sBuf);
445 delete(handleData);
446 handleData = nullptr;
447 }
448 }
449