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 /**
17 * @addtogroup Audio
18 * @{
19 *
20 * @brief Test audio adm interface
21 *
22 * @since 1.0
23 * @version 1.0
24 */
25 #include "audio_adm_common.h"
26 #include "audio_adm_interface_test.h"
27
28 using namespace std;
29 using namespace testing::ext;
30 using namespace OHOS::Audio;
31
32 namespace {
33 const int CONTROL_DISP_METHOD_CMD_ILLEGAL = 6;
34 const int STREAM_DISP_METHOD_CMD_ILLEGAL = 30;
35 const int CHANEL_MODE_ILLEGAL = 9;
36 const int MAX_GAIN_VALUE = 15;
37 const int MIN_GAIN_VALUE = 0;
38 const int ERROR_GAIN_VALUE = MAX_GAIN_VALUE + 1;
39 const int WAITE_TIME = 5;
40 const int US_TO_MS = 1000;
41 constexpr int MIDDLE_VOLUME = 100;
42 #ifdef PRODUCT_RK3568
43 constexpr int MAX_VOLUME = 255;
44 constexpr int MIN_VOLUME = 0;
45 constexpr int OVER_MAX_VOLUME = 256;
46 constexpr int BELOW_MIN_VOLUME = -1;
47 #else
48 constexpr int MAX_VOLUME = 127;
49 constexpr int MIN_VOLUME = 40;
50 constexpr int OVER_MAX_VOLUME = 128;
51 constexpr int BELOW_MIN_VOLUME = 39;
52 #endif
53
54 class AudioAdmInterfaceTest : public testing::Test {
55 public:
56 static void SetUpTestCase(void);
57 static void TearDownTestCase(void);
58 void SetUp();
59 void TearDown();
60 };
61
SetUpTestCase(void)62 void AudioAdmInterfaceTest::SetUpTestCase(void) {}
63
TearDownTestCase(void)64 void AudioAdmInterfaceTest::TearDownTestCase(void) {}
65
SetUp(void)66 void AudioAdmInterfaceTest::SetUp(void) {}
67
TearDown(void)68 void AudioAdmInterfaceTest::TearDown(void) {}
69
70 /**
71 * @tc.name AudioControlDispatch_001
72 * @tc.desc Test the ADM ctrl data analysis function,return -1 when setting the incoming parameter cmdid is illegal
73 * @tc.type: FUNC
74 */
75 HWTEST_F(AudioAdmInterfaceTest, AudioControlDispatch_001, TestSize.Level1)
76 {
77 int32_t ret = -1;
78 struct HdfIoService *service = nullptr;
79 struct HdfSBuf *writeBuf = nullptr;
80 struct HdfSBuf *writeReply = nullptr;
81
82 struct AudioCtlElemValue writeElemValue = {
83 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
84 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
85 .id.itemName = "Mic Left Gain",
86 .value[0] = 5,
87 };
88
89 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
90 ASSERT_NE(nullptr, service);
91 ASSERT_NE(nullptr, service->dispatcher);
92
93 writeBuf = HdfSbufObtainDefaultSize();
94 if (writeBuf == nullptr) {
95 HdfIoServiceRecycle(service);
96 ASSERT_NE(nullptr, writeBuf);
97 }
98 ret = WriteEleValueToBuf(writeBuf, writeElemValue);
99 EXPECT_EQ(HDF_SUCCESS, ret);
100
101 ret = service->dispatcher->Dispatch(&service->object, CONTROL_DISP_METHOD_CMD_ILLEGAL, writeBuf, writeReply);
102 EXPECT_EQ(HDF_FAILURE, ret);
103 HdfSbufRecycle(writeBuf);
104 HdfIoServiceRecycle(service);
105 }
106 /**
107 * @tc.name AudioControlDispatch_002
108 * @tc.desc Test the ADM ctrl data analysis function,return -1 when setting the incoming parameter object is nullptr
109 * @tc.type: FUNC
110 */
111 HWTEST_F(AudioAdmInterfaceTest, AudioControlDispatch_002, TestSize.Level1)
112 {
113 int32_t ret = -1;
114 struct HdfIoService *service = nullptr;
115 struct HdfSBuf *writeBuf = nullptr;
116 struct HdfSBuf *writeReply = nullptr;
117 struct HdfObject *objectNull = nullptr;
118 struct AudioCtlElemValue writeElemValue = {
119 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
120 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
121 .id.itemName = "Mic Left Gain",
122 .value[0] = 6,
123 };
124
125 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
126 ASSERT_NE(nullptr, service);
127 ASSERT_NE(nullptr, service->dispatcher);
128
129 writeBuf = HdfSbufObtainDefaultSize();
130 if (writeBuf == nullptr) {
131 HdfIoServiceRecycle(service);
132 ASSERT_NE(nullptr, writeBuf);
133 }
134
135 ret = WriteEleValueToBuf(writeBuf, writeElemValue);
136 EXPECT_EQ(HDF_SUCCESS, ret);
137
138 ret = service->dispatcher->Dispatch(objectNull, AUDIODRV_CTRL_IOCTRL_ELEM_WRITE, writeBuf, writeReply);
139 EXPECT_EQ(HDF_FAILURE, ret);
140 HdfSbufRecycle(writeBuf);
141 HdfIoServiceRecycle(service);
142 }
143 /**
144 * @tc.name AudioStreamDispatch_001
145 * @tc.desc Test the ADM stream data analysis function,return -1 when setting the incoming parameter cmdid is illegal
146 * @tc.type: FUNC
147 */
148 HWTEST_F(AudioAdmInterfaceTest, AudioStreamDispatch_001, TestSize.Level1)
149 {
150 int32_t ret = -1;
151 struct HdfIoService *service = nullptr;
152 struct HdfSBuf *sBuf = nullptr;
153 struct HdfSBuf *reply = nullptr;
154 struct AudioPcmHwParams hwParams {
155 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 2048, .rate = 11025,
156 .periodCount = 32, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
157 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16385
158 };
159
160 service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str());
161 ASSERT_NE(nullptr, service);
162 ASSERT_NE(nullptr, service->dispatcher);
163
164 sBuf = HdfSbufObtainDefaultSize();
165 if (sBuf == nullptr) {
166 HdfIoServiceRecycle(service);
167 ASSERT_NE(nullptr, sBuf);
168 }
169 ret = WriteHwParamsToBuf(sBuf, hwParams);
170 EXPECT_EQ(HDF_SUCCESS, ret);
171
172 ret = service->dispatcher->Dispatch(&service->object, STREAM_DISP_METHOD_CMD_ILLEGAL, sBuf, reply);
173 EXPECT_EQ(HDF_FAILURE, ret);
174 HdfSbufRecycle(sBuf);
175 HdfIoServiceRecycle(service);
176 }
177 /**
178 * @tc.name AudioStreamDispatch_002
179 * @tc.desc Test the ADM stream data analysis function,return -1 when setting the incoming parameter object is nullptr
180 * @tc.type: FUNC
181 */
182 HWTEST_F(AudioAdmInterfaceTest, AudioStreamDispatch_002, TestSize.Level1)
183 {
184 int32_t ret = -1;
185 struct HdfIoService *service = nullptr;
186 struct HdfSBuf *sBuf = nullptr;
187 struct HdfSBuf *reply = nullptr;
188 struct HdfObject *objectNull = nullptr;
189 struct AudioPcmHwParams hwParams {
190 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 2048, .rate = 11025,
191 .periodCount = 32, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
192 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16385
193 };
194
195 service = HdfIoServiceBind(HDF_RENDER_SERVICE.c_str());
196 ASSERT_NE(nullptr, service);
197 ASSERT_NE(nullptr, service->dispatcher);
198
199 sBuf = HdfSbufObtainDefaultSize();
200 if (sBuf == nullptr) {
201 HdfIoServiceRecycle(service);
202 ASSERT_NE(nullptr, sBuf);
203 }
204 ret = WriteHwParamsToBuf(sBuf, hwParams);
205 EXPECT_EQ(HDF_SUCCESS, ret);
206
207 ret = service->dispatcher->Dispatch(objectNull, AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, sBuf, reply);
208 EXPECT_EQ(HDF_FAILURE, ret);
209 HdfSbufRecycle(sBuf);
210 HdfIoServiceRecycle(service);
211 }
212 /**
213 * @tc.name AudioControlHostElemWriteRead001
214 * @tc.desc Test the ADM ctrl function,return 0 when setting gain's value is in the range(value=5)
215 * @tc.type: FUNC
216 */
217 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteRead001, TestSize.Level1)
218 {
219 int32_t ret = -1;
220 int32_t expectValue = 5;
221 struct HdfIoService *service = nullptr;
222 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
223 ASSERT_NE(nullptr, service);
224 ASSERT_NE(nullptr, service->dispatcher);
225 struct AudioCtlElemValue elemValue = {
226 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
227 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
228 .id.itemName = "Mic Left Gain",
229 .value[0] = 5,
230 };
231 ret = WriteCtrlInfo(service, elemValue);
232 EXPECT_EQ(HDF_SUCCESS, ret);
233 ret = ReadCtrlInfo(service, elemValue.id, expectValue);
234 EXPECT_EQ(HDF_SUCCESS, ret);
235 HdfIoServiceRecycle(service);
236 }
237 /**
238 * @tc.name AudioControlHostElemWriteRead002
239 * @tc.desc Test the ADM ctrl function,return 0 when setting gain's value is min value
240 * @tc.type: FUNC
241 */
242 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteRead002, TestSize.Level1)
243 {
244 int32_t ret = -1;
245 int32_t expectValue = MIN_GAIN_VALUE;
246 struct HdfIoService *service = nullptr;
247 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
248 ASSERT_NE(nullptr, service);
249 ASSERT_NE(nullptr, service->dispatcher);
250 struct AudioCtlElemValue elemValue = {
251 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
252 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
253 .id.itemName = "Mic Left Gain",
254 .value[0] = MIN_GAIN_VALUE,
255 };
256 ret = WriteCtrlInfo(service, elemValue);
257 EXPECT_EQ(HDF_SUCCESS, ret);
258 ret = ReadCtrlInfo(service, elemValue.id, expectValue);
259 EXPECT_EQ(HDF_SUCCESS, ret);
260 HdfIoServiceRecycle(service);
261 }
262 /**
263 * @tc.name AudioControlHostElemWriteRead003
264 * @tc.desc Test the ADM ctrl function,return 0 when setting gain's value is max value
265 * @tc.type: FUNC
266 */
267 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteRead003, TestSize.Level1)
268 {
269 int32_t ret = -1;
270 struct HdfIoService *service = nullptr;
271 int32_t expectValue = MAX_GAIN_VALUE;
272 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
273 ASSERT_NE(nullptr, service);
274 ASSERT_NE(nullptr, service->dispatcher);
275 struct AudioCtlElemValue elemValue = {
276 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
277 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
278 .id.itemName = "Mic Left Gain",
279 .value[0] = MAX_GAIN_VALUE,
280 };
281 ret = WriteCtrlInfo(service, elemValue);
282 EXPECT_EQ(HDF_SUCCESS, ret);
283 ret = ReadCtrlInfo(service, elemValue.id, expectValue);
284 EXPECT_EQ(HDF_SUCCESS, ret);
285 HdfIoServiceRecycle(service);
286 }
287 /**
288 * @tc.name AudioControlHostElemWriteRead004
289 * @tc.desc Test the ADM ctrl function,return -1 when setting gain's value is out of the range(value=16)
290 * @tc.type: FUNC
291 */
292 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteRead004, TestSize.Level1)
293 {
294 int32_t ret = -1;
295 struct HdfIoService *service = nullptr;
296 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
297 ASSERT_NE(nullptr, service);
298 ASSERT_NE(nullptr, service->dispatcher);
299 struct AudioCtlElemValue elemValue = {
300 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
301 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
302 .id.itemName = "Mic Left Gain",
303 .value[0] = ERROR_GAIN_VALUE,
304 };
305 ret = WriteCtrlInfo(service, elemValue);
306 EXPECT_EQ(HDF_FAILURE, ret);
307 HdfIoServiceRecycle(service);
308 }
309 /**
310 * @tc.name AudioControlHostElemWriteread005
311 * @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_NORMAL"
312 * @tc.type: FUNC
313 */
314 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread005, TestSize.Level1)
315 {
316 int32_t ret = -1;
317 int32_t expectValue = AUDIO_CHANNEL_NORMAL;
318 struct HdfIoService *service = nullptr;
319 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
320 ASSERT_NE(nullptr, service);
321 ASSERT_NE(nullptr, service->dispatcher);
322 struct AudioCtlElemValue elemValue = {
323 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
324 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
325 .id.itemName = "Render Channel Mode",
326 .value[0] = AUDIO_CHANNEL_NORMAL,
327 };
328 ret = WriteCtrlInfo(service, elemValue);
329 EXPECT_EQ(HDF_SUCCESS, ret);
330 ret = ReadCtrlInfo(service, elemValue.id, expectValue);
331 EXPECT_EQ(HDF_SUCCESS, ret);
332 HdfIoServiceRecycle(service);
333 }
334 /**
335 * @tc.name AudioControlHostElemWriteread006
336 * @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_BOTH_LEFT"
337 * @tc.type: FUNC
338 */
339 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread006, TestSize.Level1)
340 {
341 int32_t ret = -1;
342 int32_t expectValue = AUDIO_CHANNEL_BOTH_LEFT;
343 struct HdfIoService *service = nullptr;
344 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
345 ASSERT_NE(nullptr, service);
346 ASSERT_NE(nullptr, service->dispatcher);
347 struct AudioCtlElemValue elemValue = {
348 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
349 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
350 .id.itemName = "Render Channel Mode",
351 .value[0] = AUDIO_CHANNEL_BOTH_LEFT,
352 };
353 ret = WriteCtrlInfo(service, elemValue);
354 EXPECT_EQ(HDF_SUCCESS, ret);
355 ret = ReadCtrlInfo(service, elemValue.id, expectValue);
356 EXPECT_EQ(HDF_SUCCESS, ret);
357 HdfIoServiceRecycle(service);
358 }
359 /**
360 * @tc.name AudioControlHostElemWriteread007
361 * @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_BOTH_RIGHT"
362 * @tc.type: FUNC
363 */
364 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread007, TestSize.Level1)
365 {
366 int32_t ret = -1;
367 int32_t expectValue = AUDIO_CHANNEL_BOTH_RIGHT;
368 struct HdfIoService *service = nullptr;
369 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
370 ASSERT_NE(nullptr, service);
371 ASSERT_NE(nullptr, service->dispatcher);
372 struct AudioCtlElemValue elemValue = {
373 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
374 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
375 .id.itemName = "Render Channel Mode",
376 .value[0] = AUDIO_CHANNEL_BOTH_RIGHT,
377 };
378 ret = WriteCtrlInfo(service, elemValue);
379 EXPECT_EQ(HDF_SUCCESS, ret);
380 ret = ReadCtrlInfo(service, elemValue.id, expectValue);
381 EXPECT_EQ(HDF_SUCCESS, ret);
382 HdfIoServiceRecycle(service);
383 }
384 /**
385 * @tc.name AudioControlHostElemWriteread008
386 * @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_EXCHANGE"
387 * @tc.type: FUNC
388 */
389 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread008, TestSize.Level1)
390 {
391 int32_t ret = -1;
392 struct HdfIoService *service = nullptr;
393 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
394 ASSERT_NE(nullptr, service);
395 ASSERT_NE(nullptr, service->dispatcher);
396 struct AudioCtlElemValue elemValue = {
397 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
398 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
399 .id.itemName = "Render Channel Mode",
400 .value[0] = AUDIO_CHANNEL_EXCHANGE,
401 };
402 ret = WriteCtrlInfo(service, elemValue);
403 #ifdef PRODUCT_RK3568
404 EXPECT_EQ(HDF_FAILURE, ret);
405 #else
406 EXPECT_EQ(HDF_SUCCESS, ret);
407 ret = ReadCtrlInfo(service, elemValue.id, AUDIO_CHANNEL_EXCHANGE);
408 EXPECT_EQ(HDF_SUCCESS, ret);
409 #endif
410 HdfIoServiceRecycle(service);
411 }
412 /**
413 * @tc.name AudioControlHostElemWriteread009
414 * @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_MIX"
415 * @tc.type: FUNC
416 */
417 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread009, TestSize.Level1)
418 {
419 int32_t ret = -1;
420 struct HdfIoService *service = nullptr;
421 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
422 ASSERT_NE(nullptr, service);
423 ASSERT_NE(nullptr, service->dispatcher);
424 struct AudioCtlElemValue elemValue = {
425 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
426 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
427 .id.itemName = "Render Channel Mode",
428 .value[0] = AUDIO_CHANNEL_MIX,
429 };
430 ret = WriteCtrlInfo(service, elemValue);
431 #ifdef PRODUCT_RK3568
432 EXPECT_EQ(HDF_FAILURE, ret);
433 #else
434 EXPECT_EQ(HDF_SUCCESS, ret);
435 ret = ReadCtrlInfo(service, elemValue.id, AUDIO_CHANNEL_MIX);
436 EXPECT_EQ(HDF_SUCCESS, ret);
437 #endif
438 HdfIoServiceRecycle(service);
439 }
440 /**
441 * @tc.name AudioControlHostElemWriteread010
442 * @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_LEFT_MUTE"
443 * @tc.type: FUNC
444 */
445 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread010, TestSize.Level1)
446 {
447 int32_t ret = -1;
448 struct HdfIoService *service = nullptr;
449 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
450 ASSERT_NE(nullptr, service);
451 ASSERT_NE(nullptr, service->dispatcher);
452 struct AudioCtlElemValue elemValue = {
453 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
454 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
455 .id.itemName = "Render Channel Mode",
456 .value[0] = AUDIO_CHANNEL_LEFT_MUTE,
457 };
458 ret = WriteCtrlInfo(service, elemValue);
459 #ifdef PRODUCT_RK3568
460 EXPECT_EQ(HDF_FAILURE, ret);
461 #else
462 EXPECT_EQ(HDF_SUCCESS, ret);
463 ret = ReadCtrlInfo(service, elemValue.id, AUDIO_CHANNEL_LEFT_MUTE);
464 EXPECT_EQ(HDF_SUCCESS, ret);
465 #endif
466 HdfIoServiceRecycle(service);
467 }
468 /**
469 * @tc.name AudioControlHostElemWriteread011
470 * @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_RIGHT_MUTE"
471 * @tc.type: FUNC
472 */
473 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread011, TestSize.Level1)
474 {
475 int32_t ret = -1;
476 struct HdfIoService *service = nullptr;
477 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
478 ASSERT_NE(nullptr, service);
479 ASSERT_NE(nullptr, service->dispatcher);
480 struct AudioCtlElemValue elemValue = {
481 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
482 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
483 .id.itemName = "Render Channel Mode",
484 .value[0] = AUDIO_CHANNEL_RIGHT_MUTE,
485 };
486 ret = WriteCtrlInfo(service, elemValue);
487 #ifdef PRODUCT_RK3568
488 EXPECT_EQ(HDF_FAILURE, ret);
489 #else
490 EXPECT_EQ(HDF_SUCCESS, ret);
491 ret = ReadCtrlInfo(service, elemValue.id, AUDIO_CHANNEL_RIGHT_MUTE);
492 EXPECT_EQ(HDF_SUCCESS, ret);
493 #endif
494 HdfIoServiceRecycle(service);
495 }
496 /**
497 * @tc.name AudioControlHostElemWriteread012
498 * @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "AUDIO_CHANNEL_BOTH_MUTE"
499 * @tc.type: FUNC
500 */
501 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread012, TestSize.Level1)
502 {
503 int32_t ret = -1;
504 struct HdfIoService *service = nullptr;
505 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
506 ASSERT_NE(nullptr, service);
507 ASSERT_NE(nullptr, service->dispatcher);
508 struct AudioCtlElemValue elemValue = {
509 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
510 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
511 .id.itemName = "Render Channel Mode",
512 .value[0] = AUDIO_CHANNEL_BOTH_MUTE,
513 };
514 ret = WriteCtrlInfo(service, elemValue);
515 #ifdef PRODUCT_RK3568
516 EXPECT_EQ(HDF_FAILURE, ret);
517 #else
518 EXPECT_EQ(HDF_SUCCESS, ret);
519 ret = ReadCtrlInfo(service, elemValue.id, AUDIO_CHANNEL_BOTH_MUTE);
520 EXPECT_EQ(HDF_SUCCESS, ret);
521 #endif
522 HdfIoServiceRecycle(service);
523 }
524 /**
525 * @tc.name AudioControlHostElemWriteread013
526 * @tc.desc Test the ADM ctrl function,return 0 when setting channelmode is "CHANEL_MODE_ILLEGAL"
527 * @tc.type: FUNC
528 */
529 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread013, TestSize.Level1)
530 {
531 int32_t ret = -1;
532 struct HdfIoService *service = nullptr;
533 struct AudioCtlElemValue elemValue = {
534 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
535 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
536 .id.itemName = "Render Channel Mode",
537 .value[0] = CHANEL_MODE_ILLEGAL,
538 };
539 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
540 ASSERT_NE(nullptr, service);
541 ASSERT_NE(nullptr, service->dispatcher);
542 ret = WriteCtrlInfo(service, elemValue);
543 EXPECT_EQ(HDF_FAILURE, ret);
544 HdfIoServiceRecycle(service);
545 }
546 /**
547 * @tc.name AudioControlHostElemWriteRead014
548 * @tc.desc Test the ADM ctrl function,return 0 when getting gainthreshold
549 * @tc.type: FUNC
550 */
551 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteRead014, TestSize.Level1)
552 {
553 int32_t ret = -1;
554 int32_t expectMinValue = MIN_GAIN_VALUE;
555 int32_t expectMaxValue = MAX_GAIN_VALUE;
556 struct HdfIoService *service = nullptr;
557 struct HdfSBuf *readBuf = nullptr;
558 struct HdfSBuf *readReply = nullptr;
559 struct AudioCtlElemId id = {
560 .cardServiceName = CARD_SEVICE_NAME.c_str(),
561 .iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
562 .itemName = "Mic Left Gain",
563 };
564 struct AudioCtlElemValue readElemValue = {};
565 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
566 ASSERT_NE(nullptr, service);
567 ASSERT_NE(nullptr, service->dispatcher);
568
569 readReply = HdfSbufObtainDefaultSize();
570 if (readReply == nullptr) {
571 HdfIoServiceRecycle(service);
572 ASSERT_NE(nullptr, readReply);
573 }
574 readBuf = HdfSbufObtainDefaultSize();
575 if (readBuf == nullptr) {
576 HdfSbufRecycle(readReply);
577 HdfIoServiceRecycle(service);
578 ASSERT_NE(nullptr, readBuf);
579 }
580 ret = WriteIdToBuf(readBuf, id);
581 EXPECT_EQ(HDF_SUCCESS, ret);
582
583 ret = service->dispatcher->Dispatch(&service->object, AUDIODRV_CTRL_IOCTRL_ELEM_READ, readBuf, readReply);
584 EXPECT_EQ(HDF_SUCCESS, ret);
585 HdfSbufReadInt32(readReply, &readElemValue.value[0]);
586 EXPECT_EQ(expectMaxValue, readElemValue.value[0]);
587 HdfSbufReadInt32(readReply, &readElemValue.value[1]);
588 EXPECT_EQ(expectMinValue, readElemValue.value[1]);
589
590 HdfSbufRecycle(readBuf);
591 HdfSbufRecycle(readReply);
592 HdfIoServiceRecycle(service);
593 }
594 /**
595 * @tc.name AudioControlHostElemWriteread_015
596 * @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTRL_IOCTRL_ELEM_WRITE and AUDIODRV_CTRL_IOCTRL_ELEM_READ.
597 * @tc.type: FUNC
598 */
599 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread_015, TestSize.Level1)
600 {
601 int32_t ret = -1;
602 int32_t expectValue = MIDDLE_VOLUME;
603 struct HdfIoService *service = nullptr;
604 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
605 ASSERT_NE(nullptr, service);
606 ASSERT_NE(nullptr, service->dispatcher);
607 struct AudioCtlElemValue elemValue = {
608 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
609 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
610 .id.itemName = "Main Playback Volume",
611 .value[0] = MIDDLE_VOLUME,
612 };
613 ret = WriteCtrlInfo(service, elemValue);
614 EXPECT_EQ(HDF_SUCCESS, ret);
615 ret = ReadCtrlInfo(service, elemValue.id, expectValue);
616 EXPECT_EQ(HDF_SUCCESS, ret);
617 HdfIoServiceRecycle(service);
618 }
619
620 /**
621 * @tc.name AudioControlHostElemWriteread_016
622 * @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTRL_IOCTRL_ELEM_WRITE and AUDIODRV_CTRL_IOCTRL_ELEM_READ.
623 * @tc.type: FUNC
624 */
625 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread_016, TestSize.Level1)
626 {
627 int32_t ret = -1;
628 int32_t expectValue = MIN_VOLUME;
629 struct HdfIoService *service = nullptr;
630 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
631 ASSERT_NE(nullptr, service);
632 ASSERT_NE(nullptr, service->dispatcher);
633 struct AudioCtlElemValue elemValue = {
634 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
635 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
636 .id.itemName = "Main Playback Volume",
637 .value[0] = MIN_VOLUME,
638 };
639 ret = WriteCtrlInfo(service, elemValue);
640 EXPECT_EQ(HDF_SUCCESS, ret);
641 ret = ReadCtrlInfo(service, elemValue.id, expectValue);
642 EXPECT_EQ(HDF_SUCCESS, ret);
643 HdfIoServiceRecycle(service);
644 }
645 /**
646 * @tc.name AudioControlHostElemWriteread_017
647 * @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTRL_IOCTRL_ELEM_WRITE and AUDIODRV_CTRL_IOCTRL_ELEM_READ.
648 * @tc.type: FUNC
649 */
650 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread_017, TestSize.Level1)
651 {
652 int32_t ret = -1;
653 int32_t expectValue = MAX_VOLUME;
654 struct HdfIoService *service = nullptr;
655 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
656 ASSERT_NE(nullptr, service);
657 ASSERT_NE(nullptr, service->dispatcher);
658 struct AudioCtlElemValue elemValue = {
659 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
660 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
661 .id.itemName = "Main Playback Volume",
662 .value[0] = MAX_VOLUME,
663 };
664 ret = WriteCtrlInfo(service, elemValue);
665 EXPECT_EQ(HDF_SUCCESS, ret);
666 ret = ReadCtrlInfo(service, elemValue.id, expectValue);
667 EXPECT_EQ(HDF_SUCCESS, ret);
668 HdfIoServiceRecycle(service);
669 }
670 /**
671 * @tc.name AudioControlHostElemWriteread_018
672 * @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTRL_IOCTRL_ELEM_WRITE and AUDIODRV_CTRL_IOCTRL_ELEM_READ.
673 * @tc.type: FUNC
674 */
675 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread_018, TestSize.Level1)
676 {
677 int32_t ret = -1;
678 struct HdfIoService *service = nullptr;
679 struct AudioCtlElemValue elemValue = {
680 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
681 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
682 .id.itemName = "Main Playback Volume",
683 .value[0] = OVER_MAX_VOLUME,
684 };
685 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
686 ASSERT_NE(nullptr, service);
687 ASSERT_NE(nullptr, service->dispatcher);
688 ret = WriteCtrlInfo(service, elemValue);
689 EXPECT_EQ(HDF_FAILURE, ret);
690 HdfIoServiceRecycle(service);
691 }
692 /**
693 * @tc.name AudioControlHostElemWriteread_019
694 * @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTRL_IOCTRL_ELEM_WRITE and AUDIODRV_CTRL_IOCTRL_ELEM_READ.
695 * @tc.type: FUNC
696 */
697 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread_019, TestSize.Level1)
698 {
699 int32_t ret = -1;
700 struct HdfIoService *service = nullptr;
701 struct AudioCtlElemValue elemValue = {
702 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
703 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
704 .id.itemName = "Main Playback Volume",
705 .value[0] = BELOW_MIN_VOLUME,
706 };
707 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
708 ASSERT_NE(nullptr, service);
709 ASSERT_NE(nullptr, service->dispatcher);
710 ret = WriteCtrlInfo(service, elemValue);
711 EXPECT_EQ(HDF_FAILURE, ret);
712 HdfIoServiceRecycle(service);
713 }
714 /**
715 * @tc.name AudioControlHostElemWriteread_020
716 * @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTRL_IOCTRL_ELEM_WRITE and AUDIODRV_CTRL_IOCTRL_ELEM_READ.
717 * @tc.type: FUNC
718 */
719 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread_020, TestSize.Level1)
720 {
721 int32_t ret = -1;
722 int32_t expectValue = 0;
723 struct HdfIoService *service = nullptr;
724 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
725 ASSERT_NE(nullptr, service);
726 ASSERT_NE(nullptr, service->dispatcher);
727 struct AudioCtlElemValue elemValue = {
728 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
729 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
730 .id.itemName = "Playback Mute",
731 .value[0] = 0,
732 };
733 ret = WriteCtrlInfo(service, elemValue);
734 EXPECT_EQ(HDF_SUCCESS, ret);
735 ret = ReadCtrlInfo(service, elemValue.id, expectValue);
736 EXPECT_EQ(HDF_SUCCESS, ret);
737 HdfIoServiceRecycle(service);
738 }
739 /**
740 * @tc.name AudioControlHostElemWriteread_021
741 * @tc.desc Test the ADM control data,cmdid is AUDIODRV_CTRL_IOCTRL_ELEM_WRITE and AUDIODRV_CTRL_IOCTRL_ELEM_READ.
742 * @tc.type: FUNC
743 */
744 HWTEST_F(AudioAdmInterfaceTest, AudioControlHostElemWriteread_021, TestSize.Level1)
745 {
746 int32_t ret = -1;
747 struct HdfIoService *service = nullptr;
748 struct AudioCtlElemValue elemValue = {
749 .id.cardServiceName = CARD_SEVICE_NAME.c_str(),
750 .id.iface = AUDIODRV_CTL_ELEM_IFACE_MIXER,
751 .id.itemName = "Playback Mute",
752 .value[0] = 2,
753 };
754 service = HdfIoServiceBind(HDF_CONTROL_SERVICE.c_str());
755 ASSERT_NE(nullptr, service);
756 ASSERT_NE(nullptr, service->dispatcher);
757 ret = WriteCtrlInfo(service, elemValue);
758 EXPECT_EQ(HDF_FAILURE, ret);
759 HdfIoServiceRecycle(service);
760 }
761 /**
762 * @tc.name AudioStreamHostHwParams_001
763 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
764 * format is AUDIO_FORMAT_TYPE_PCM_8_BIT、channels is 2、cardServiceName is hdf_audio_codec_dev0.
765 * @tc.type: FUNC
766 */
767 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_001, TestSize.Level1)
768 {
769 int32_t ret = -1;
770 struct HdfIoService *service = nullptr;
771 struct AudioPcmHwParams hwParams {
772 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 2048, .rate = 11025,
773 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_8_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
774 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190
775 };
776 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
777 EXPECT_EQ(HDF_FAILURE, ret);
778 HdfIoServiceRecycle(service);
779 }
780 /**
781 * @tc.name AudioStreamHostHwParams_002
782 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
783 * format is AUDIO_FORMAT_TYPE_PCM_16_BIT、channels is 2、cardServiceName is hdf_audio_codec_dev0.
784 * @tc.type: FUNC
785 */
786 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_002, TestSize.Level1)
787 {
788 int32_t ret = -1;
789 struct HdfIoService *service = nullptr;
790 struct AudioPcmHwParams hwParams {
791 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 2048, .rate = 22050,
792 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_16_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
793 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190
794 };
795 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
796 EXPECT_EQ(HDF_SUCCESS, ret);
797 HdfIoServiceRecycle(service);
798 }
799 /**
800 * @tc.name AudioStreamHostHwParams_003
801 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
802 * format is AUDIO_FORMAT_TYPE_PCM_24_BIT、channels is 2、cardServiceName is hdf_audio_codec_dev0.
803 * @tc.type: FUNC
804 */
805 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_003, TestSize.Level1)
806 {
807 int32_t ret = -1;
808 struct HdfIoService *service = nullptr;
809 struct AudioPcmHwParams hwParams {
810 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 4096, .rate = 24000,
811 .periodCount = 4, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
812 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 162140
813 };
814 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
815 EXPECT_EQ(HDF_SUCCESS, ret);
816 HdfIoServiceRecycle(service);
817 }
818 /**
819 * @tc.name AudioStreamHostHwParams_004
820 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
821 * format is AUDIO_FORMAT_TYPE_PCM_32_BIT 、channels is 2、cardServiceName is hdf_audio_codec_dev0.
822 * @tc.type: FUNC
823 */
824 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_004, TestSize.Level1)
825 {
826 int32_t ret = -1;
827 struct HdfIoService *service = nullptr;
828 struct AudioPcmHwParams hwParams {
829 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 2048, .rate = 48190,
830 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_32_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
831 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190
832 };
833 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
834 EXPECT_EQ(HDF_FAILURE, ret);
835 HdfIoServiceRecycle(service);
836 }
837 /**
838 * @tc.name AudioStreamHostHwParams_005
839 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
840 * format is AUDIO_FORMAT_TYPE_AAC_MAIN 、channels is 2、cardServiceName is hdf_audio_codec_dev0.
841 * @tc.type: FUNC
842 */
843 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_005, TestSize.Level1)
844 {
845 int32_t ret = -1;
846 struct HdfIoService *service = nullptr;
847 struct AudioPcmHwParams hwParams {
848 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 2048, .rate = 44100,
849 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_AAC_MAIN, .cardServiceName = CARD_SEVICE_NAME.c_str(),
850 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190
851 };
852 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
853 EXPECT_EQ(HDF_FAILURE, ret);
854 HdfIoServiceRecycle(service);
855 }
856 /**
857 * @tc.name AudioStreamHostHwParams_006
858 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
859 * format is AUDIO_FORMAT_TYPE_AAC_LC 、channels is 2、cardServiceName is hdf_audio_codec_dev0.
860 * @tc.type: FUNC
861 */
862 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_006, TestSize.Level1)
863 {
864 int32_t ret = -1;
865 struct HdfIoService *service = nullptr;
866 struct AudioPcmHwParams hwParams {
867 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 2048, .rate = 8190,
868 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_AAC_LC, .cardServiceName = CARD_SEVICE_NAME.c_str(),
869 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190
870 };
871 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
872 EXPECT_EQ(HDF_FAILURE, ret);
873 HdfIoServiceRecycle(service);
874 }
875 /**
876 * @tc.name AudioStreamHostHwParams_007
877 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
878 * format is AUDIO_FORMAT_TYPE_AAC_LD 、channels is 2、cardServiceName is hdf_audio_codec_dev0.
879 * @tc.type: FUNC
880 */
881 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_007, TestSize.Level1)
882 {
883 int32_t ret = -1;
884 struct HdfIoService *service = nullptr;
885 struct AudioPcmHwParams hwParams {
886 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 2048, .rate = 32000,
887 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_AAC_LD, .cardServiceName = CARD_SEVICE_NAME.c_str(),
888 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190
889 };
890 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
891 EXPECT_EQ(HDF_FAILURE, ret);
892 HdfIoServiceRecycle(service);
893 }
894 /**
895 * @tc.name AudioStreamHostHwParams_008
896 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
897 * format is AUDIO_FORMAT_TYPE_AAC_ELD 、channels is 2、cardServiceName is hdf_audio_codec_dev0.
898 * @tc.type: FUNC
899 */
900 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_008, TestSize.Level1)
901 {
902 int32_t ret = -1;
903 struct HdfIoService *service = nullptr;
904 struct AudioPcmHwParams hwParams {
905 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 2048, .rate = 50000,
906 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_AAC_ELD, .cardServiceName = CARD_SEVICE_NAME.c_str(),
907 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190
908 };
909 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
910 EXPECT_EQ(HDF_FAILURE, ret);
911 HdfIoServiceRecycle(service);
912 }
913 /**
914 * @tc.name AudioStreamHostHwParams_009
915 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
916 * format is AUDIO_FORMAT_TYPE_AAC_HE_V1 、channels is 2、cardServiceName is hdf_audio_codec_dev0.
917 * @tc.type: FUNC
918 */
919 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_009, TestSize.Level1)
920 {
921 int32_t ret = -1;
922 struct HdfIoService *service = nullptr;
923 struct AudioPcmHwParams hwParams {
924 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 2048, .rate = 47250,
925 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_AAC_HE_V1, .cardServiceName = CARD_SEVICE_NAME.c_str(),
926 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190
927 };
928 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
929 EXPECT_EQ(HDF_FAILURE, ret);
930 HdfIoServiceRecycle(service);
931 }
932 /**
933 * @tc.name AudioStreamHostHwParams_010
934 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
935 * format is AUDIO_FORMAT_TYPE_AAC_HE_V2 、channels is 2、cardServiceName is hdf_audio_codec_dev0.
936 * @tc.type: FUNC
937 */
938 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_010, TestSize.Level1)
939 {
940 int32_t ret = -1;
941 struct HdfIoService *service = nullptr;
942 struct AudioPcmHwParams hwParams {
943 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 2048, .rate = 47250,
944 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_AAC_HE_V2, .cardServiceName = CARD_SEVICE_NAME.c_str(),
945 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8190
946 };
947 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
948 EXPECT_EQ(HDF_FAILURE, ret);
949 HdfIoServiceRecycle(service);
950 }
951 /**
952 * @tc.name AudioStreamHostHwParams_011
953 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
954 * format is AUDIO_FORMAT_TYPE_PCM_24_BIT 、channels is 2、cardServiceName is hdf_audio_codec_dev0.
955 * @tc.type: FUNC
956 */
957 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_011, TestSize.Level1)
958 {
959 int32_t ret = -1;
960 struct HdfIoService *service = nullptr;
961 struct AudioPcmHwParams hwParams {
962 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 4096, .rate = 11025,
963 .periodCount = 4, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
964 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
965 };
966 ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams);
967 EXPECT_EQ(HDF_SUCCESS, ret);
968 HdfIoServiceRecycle(service);
969 }
970 /**
971 * @tc.name AudioStreamHostHwParams_012
972 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
973 * format is AUDIO_FORMAT_TYPE_PCM_24_BIT 、channels is 1、cardServiceName is hdf_audio_codec_dev0.
974 * @tc.type: FUNC
975 */
976 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_012, TestSize.Level1)
977 {
978 int32_t ret = -1;
979 struct HdfIoService *service = nullptr;
980 struct AudioPcmHwParams hwParams {
981 .streamType = AUDIO_RENDER_STREAM, .channels = 1, .period = 2048, .rate = 24000,
982 .periodCount = 4, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
983 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 16384
984 };
985 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
986 #ifdef PRODUCT_RK3568
987 EXPECT_EQ(HDF_FAILURE, ret);
988 #else
989 EXPECT_EQ(HDF_SUCCESS, ret);
990 #endif
991 HdfIoServiceRecycle(service);
992 }
993 /**
994 * @tc.name AudioStreamHostHwParams_013
995 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
996 * format is AUDIO_FORMAT_TYPE_PCM_8_BIT 、channels is 8、cardServiceName is hdf_audio_codec_dev0.
997 * @tc.type: FUNC
998 */
999 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_013, TestSize.Level1)
1000 {
1001 int32_t ret = -1;
1002 struct HdfIoService *service = nullptr;
1003 struct AudioPcmHwParams hwParams {
1004 .streamType = AUDIO_RENDER_STREAM, .channels = 8, .period = 2048, .rate = 48000,
1005 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_8_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1006 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 32766
1007 };
1008 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1009 EXPECT_EQ(HDF_FAILURE, ret);
1010 HdfIoServiceRecycle(service);
1011 }
1012 /**
1013 * @tc.name AudioStreamHostHwParams_014
1014 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
1015 * format is AUDIO_FORMAT_TYPE_PCM_8_BIT 、channels is 8、cardServiceName is hdf_audio_codec_dev0.
1016 * @tc.type: FUNC
1017 */
1018 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_014, TestSize.Level1)
1019 {
1020 int32_t ret = -1;
1021 struct HdfIoService *service = nullptr;
1022 struct AudioPcmHwParams hwParams {
1023 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 2047, .rate = 48000,
1024 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_8_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1025 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 32766
1026 };
1027 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1028 EXPECT_EQ(HDF_FAILURE, ret);
1029 HdfIoServiceRecycle(service);
1030 }
1031 /**
1032 * @tc.name AudioStreamHostHwParams_015
1033 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
1034 * format is AUDIO_FORMAT_TYPE_PCM_8_BIT 、channels is 8、cardServiceName is hdf_audio_codec_dev0.
1035 * @tc.type: FUNC
1036 */
1037 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_015, TestSize.Level1)
1038 {
1039 int32_t ret = -1;
1040 struct HdfIoService *service = nullptr;
1041 struct AudioPcmHwParams hwParams {
1042 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 8192, .rate = 48000,
1043 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_8_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1044 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 32766
1045 };
1046 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1047 EXPECT_EQ(HDF_FAILURE, ret);
1048 HdfIoServiceRecycle(service);
1049 }
1050 /**
1051 * @tc.name AudioStreamHostHwParams_016
1052 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
1053 * format is AUDIO_FORMAT_TYPE_PCM_8_BIT 、channels is 8、cardServiceName is hdf_audio_codec_dev0.
1054 * @tc.type: FUNC
1055 */
1056 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_016, TestSize.Level1)
1057 {
1058 int32_t ret = -1;
1059 struct HdfIoService *service = nullptr;
1060 struct AudioPcmHwParams hwParams {
1061 .streamType = AUDIO_RENDER_STREAM, .channels = 8, .period = 2048, .rate = 24000,
1062 .periodCount = 7, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1063 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 16384
1064 };
1065 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1066 EXPECT_EQ(HDF_FAILURE, ret);
1067 HdfIoServiceRecycle(service);
1068 }
1069 /**
1070 * @tc.name AudioStreamHostHwParams_017
1071 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
1072 * format is AUDIO_FORMAT_TYPE_PCM_8_BIT 、channels is 8、cardServiceName is hdf_audio_codec_dev0.
1073 * @tc.type: FUNC
1074 */
1075 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_017, TestSize.Level1)
1076 {
1077 int32_t ret = -1;
1078 struct HdfIoService *service = nullptr;
1079 struct AudioPcmHwParams hwParams {
1080 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 8193, .rate = 24000,
1081 .periodCount = 33, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1082 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 16384
1083 };
1084 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1085 EXPECT_EQ(HDF_FAILURE, ret);
1086 HdfIoServiceRecycle(service);
1087 }
1088 /**
1089 * @tc.name AudioStreamHostHwParams_018
1090 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
1091 * format is AUDIO_FORMAT_TYPE_PCM_8_BIT 、channels is 8、cardServiceName is hdf_audio_codec_dev0.
1092 * @tc.type: FUNC
1093 */
1094 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_018, TestSize.Level1)
1095 {
1096 int32_t ret = -1;
1097 struct HdfIoService *service = nullptr;
1098 struct AudioPcmHwParams hwParams {
1099 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 2048, .rate = 24000,
1100 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1101 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 8193
1102 };
1103 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1104 EXPECT_EQ(HDF_SUCCESS, ret);
1105 HdfIoServiceRecycle(service);
1106 }
1107 /**
1108 * @tc.name AudioStreamHostHwParams_019
1109 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
1110 * format is AUDIO_FORMAT_TYPE_PCM_8_BIT 、channels is 8、cardServiceName is hdf_audio_codec_dev0.
1111 * @tc.type: FUNC
1112 */
1113 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_019, TestSize.Level1)
1114 {
1115 int32_t ret = -1;
1116 struct HdfIoService *service = nullptr;
1117 struct AudioPcmHwParams hwParams {
1118 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 2048, .rate = 24000,
1119 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1120 .isBigEndian = 0, .isSignedData = 1, .startThreshold = 0
1121 };
1122 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1123 EXPECT_EQ(HDF_SUCCESS, ret);
1124 HdfIoServiceRecycle(service);
1125 }
1126 /**
1127 * @tc.name AudioStreamHostHwParams_020
1128 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
1129 * format is AUDIO_FORMAT_TYPE_PCM_24_BIT 、channels is 2、cardServiceName is hdf_audio_codec_dev0.
1130 * silenceThreshold is Less than minimum.
1131 * @tc.type: FUNC
1132 */
1133 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_020, TestSize.Level1)
1134 {
1135 int32_t ret = -1;
1136 struct HdfIoService *service = nullptr;
1137 struct AudioPcmHwParams hwParams {
1138 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1139 .periodCount = 4, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1140 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 4095
1141 };
1142 ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams);
1143 EXPECT_EQ(HDF_FAILURE, ret);
1144 HdfIoServiceRecycle(service);
1145 }
1146 /**
1147 * @tc.name AudioStreamHostHwParams_021
1148 * @tc.desc Test the ADM render stream data which is issuing hardware parameters that
1149 * format is AUDIO_FORMAT_TYPE_PCM_24_BIT 、channels is 2、cardServiceName is hdf_audio_codec_dev0.
1150 * silenceThreshold is Greater than maximum.
1151 * @tc.type: FUNC
1152 */
1153 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostHwParams_021, TestSize.Level1)
1154 {
1155 int32_t ret = -1;
1156 struct HdfIoService *service = nullptr;
1157 struct AudioPcmHwParams hwParams {
1158 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1159 .periodCount = 32, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1160 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16385
1161 };
1162 ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams);
1163 EXPECT_EQ(HDF_FAILURE, ret);
1164 HdfIoServiceRecycle(service);
1165 }
1166 /**
1167 * @tc.name AudioStreamHostWrite_001
1168 * @tc.desc Test the ADM control data,cmdid is AUDIO_DRV_PCM_IOCTRL_WRITE.
1169 * @tc.type: FUNC
1170 */
1171 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostWrite_001, TestSize.Level1)
1172 {
1173 int32_t ret = -1;
1174 struct HdfIoService *service = nullptr;
1175 struct HdfSBuf *cardNameBuf = nullptr;
1176 struct HdfSBuf *sBufT = nullptr;
1177 struct HdfSBuf *sBufTStop = nullptr;
1178 struct HdfSBuf *reply = nullptr;
1179 struct AudioPcmHwParams hwParams {
1180 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1181 .periodCount = 4, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1182 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1183 };
1184
1185 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1186 ASSERT_EQ(HDF_SUCCESS, ret);
1187
1188 ret = WriteCardSeviceNameToSBuf(cardNameBuf);
1189 EXPECT_EQ(HDF_SUCCESS, ret);
1190
1191 ret = WriteFrameToSBuf(sBufT, AUDIO_FILE);
1192 EXPECT_EQ(HDF_SUCCESS, ret);
1193
1194 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, cardNameBuf, nullptr);
1195 EXPECT_EQ(HDF_SUCCESS, ret);
1196 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_WRITE, sBufT, reply);
1197 EXPECT_EQ(HDF_SUCCESS, ret);
1198 ret = WriteToSBuf(sBufTStop);
1199 EXPECT_EQ(HDF_SUCCESS, ret);
1200
1201 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, sBufTStop, nullptr);
1202 EXPECT_EQ(HDF_SUCCESS, ret);
1203 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, cardNameBuf, nullptr);
1204 EXPECT_EQ(HDF_SUCCESS, ret);
1205 HdfSbufRecycle(sBufT);
1206 HdfSbufRecycle(sBufTStop);
1207 HdfSbufRecycle(cardNameBuf);
1208 HdfIoServiceRecycle(service);
1209 }
1210 /**
1211 * @tc.name AudioStreamHostRead_001
1212 * @tc.desc Test the ADM control data,cmdid is AUDIO_DRV_PCM_IOCTRL_READ.
1213 * @tc.type: FUNC
1214 */
1215 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostRead_001, TestSize.Level1)
1216 {
1217 int32_t ret = HDF_FAILURE;
1218 int32_t tryNumReply = 100;
1219 uint32_t buffStatus = 0;
1220 uint32_t readSize = 0;
1221 struct HdfIoService *service = nullptr;
1222 struct HdfSBuf *cardNameBuf = nullptr;
1223 struct HdfSBuf *sBufTStop = nullptr;
1224 struct AudioXferi transfer;
1225 struct AudioPcmHwParams hwParams {
1226 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1227 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1228 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1229 };
1230 ASSERT_EQ(HDF_SUCCESS, WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams));
1231 EXPECT_EQ(HDF_SUCCESS, WriteCardSeviceNameToSBuf(cardNameBuf));
1232
1233 struct HdfSBuf *reply = HdfSbufTypedObtainCapacity(SBUF_RAW, (AUDIO_SIZE_FRAME + AUDIO_REPLY_EXTEND));
1234 ASSERT_NE(nullptr, reply);
1235 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, cardNameBuf, nullptr);
1236 EXPECT_EQ(HDF_SUCCESS, ret);
1237 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, cardNameBuf, nullptr);
1238 EXPECT_EQ(HDF_SUCCESS, ret);
1239 do {
1240 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_READ, cardNameBuf, reply);
1241 EXPECT_EQ(HDF_SUCCESS, ret);
1242 EXPECT_GE(HdfSbufReadUint32(reply, &buffStatus), HDF_SUCCESS);
1243 if ((int32_t)buffStatus != CIR_BUFF_NORMAL) {
1244 int32_t ms = buffStatus >= 0 ? buffStatus : WAITE_TIME;
1245 tryNumReply--;
1246 HdfSbufFlush(reply);
1247 usleep(ms*US_TO_MS);
1248 continue;
1249 }
1250 break;
1251 } while (tryNumReply > 0);
1252 EXPECT_GE(tryNumReply, 0);
1253 ret = HdfSbufReadBuffer(reply, (const void **) & (transfer.buf), &readSize);
1254 EXPECT_NE(transfer.buf, nullptr);
1255 EXPECT_NE(readSize, (uint32_t)0);
1256 ret = WriteToSBuf(sBufTStop);
1257 EXPECT_EQ(HDF_SUCCESS, ret);
1258
1259 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, sBufTStop, nullptr);
1260 EXPECT_EQ(HDF_SUCCESS, ret);
1261 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, cardNameBuf, nullptr);
1262 EXPECT_EQ(HDF_SUCCESS, ret);
1263 HdfSbufRecycle(reply);
1264 HdfSbufRecycle(sBufTStop);
1265 HdfSbufRecycle(cardNameBuf);
1266 HdfIoServiceRecycle(service);
1267 }
1268
1269 /**
1270 * @tc.name AudioStreamHostRenderPrepare_001
1271 * @tc.desc Test the ADM stream function,return 0 when calling prepare function(render service)
1272 * @tc.type: FUNC
1273 */
1274 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostRenderPrepare_001, TestSize.Level1)
1275 {
1276 int32_t ret = -1;
1277 struct HdfIoService *service = nullptr;
1278 struct HdfSBuf *sBufTStop = nullptr;
1279 struct HdfSBuf *cardNameBuf = nullptr;
1280 struct AudioPcmHwParams hwParams {
1281 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1282 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1283 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1284 };
1285 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1286 ASSERT_EQ(HDF_SUCCESS, ret);
1287
1288 ret = WriteCardSeviceNameToSBuf(cardNameBuf);
1289 EXPECT_EQ(HDF_SUCCESS, ret);
1290
1291 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, cardNameBuf, nullptr);
1292 EXPECT_EQ(HDF_SUCCESS, ret);
1293
1294 ret = WriteToSBuf(sBufTStop);
1295 EXPECT_EQ(HDF_SUCCESS, ret);
1296 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, sBufTStop, nullptr);
1297 EXPECT_EQ(HDF_SUCCESS, ret);
1298 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, cardNameBuf, nullptr);
1299 EXPECT_EQ(HDF_SUCCESS, ret);
1300
1301 HdfSbufRecycle(sBufTStop);
1302 HdfSbufRecycle(cardNameBuf);
1303 HdfIoServiceRecycle(service);
1304 }
1305
1306 /**
1307 * @tc.name AudioStreamHostCapturePrepare_001
1308 * @tc.desc Test the ADM stream function,return 0 when calling prepare function(capture service)
1309 * @tc.type: FUNC
1310 */
1311 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostCapturePrepare_001, TestSize.Level1)
1312 {
1313 int32_t ret = -1;
1314 struct HdfIoService *service = nullptr;
1315 struct HdfSBuf *cardNameBuf = nullptr;
1316 struct HdfSBuf *sBufTStop = nullptr;
1317 struct AudioPcmHwParams hwParams {
1318 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1319 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1320 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1321 };
1322 ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams);
1323 ASSERT_EQ(HDF_SUCCESS, ret);
1324
1325 ret = WriteCardSeviceNameToSBuf(cardNameBuf);
1326 EXPECT_EQ(HDF_SUCCESS, ret);
1327
1328 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, cardNameBuf, nullptr);
1329 EXPECT_EQ(HDF_SUCCESS, ret);
1330 ret = WriteToSBuf(sBufTStop);
1331 if (ret < 0) {
1332 HdfIoServiceRecycle(service);
1333 ASSERT_EQ(HDF_SUCCESS, ret);
1334 }
1335 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, sBufTStop, nullptr);
1336 EXPECT_EQ(HDF_SUCCESS, ret);
1337 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, cardNameBuf, nullptr);
1338 EXPECT_EQ(HDF_SUCCESS, ret);
1339 HdfSbufRecycle(sBufTStop);
1340 HdfSbufRecycle(cardNameBuf);
1341 HdfIoServiceRecycle(service);
1342 }
1343 /**
1344 * @tc.name StreamHostRenderStart_001
1345 * @tc.desc Test the ADM stream function,return 0 when calling start function(render service)
1346 * @tc.type: FUNC
1347 */
1348 HWTEST_F(AudioAdmInterfaceTest, StreamHostRenderStart_001, TestSize.Level1)
1349 {
1350 int32_t ret = -1;
1351 struct HdfIoService *service = nullptr;
1352 struct HdfSBuf *cardNameBuf = nullptr;
1353 struct HdfSBuf *sBufTStop = nullptr;
1354 struct AudioPcmHwParams hwParams {
1355 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1356 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1357 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1358 };
1359
1360 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1361 ASSERT_EQ(HDF_SUCCESS, ret);
1362
1363 ret = WriteCardSeviceNameToSBuf(cardNameBuf);
1364 EXPECT_EQ(HDF_SUCCESS, ret);
1365
1366 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, cardNameBuf, nullptr);
1367 EXPECT_EQ(HDF_SUCCESS, ret);
1368 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_START, cardNameBuf, nullptr);
1369 EXPECT_EQ(HDF_SUCCESS, ret);
1370 ret = WriteToSBuf(sBufTStop);
1371 EXPECT_EQ(HDF_SUCCESS, ret);
1372
1373 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, sBufTStop, nullptr);
1374 EXPECT_EQ(HDF_SUCCESS, ret);
1375 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, cardNameBuf, nullptr);
1376 EXPECT_EQ(HDF_SUCCESS, ret);
1377 HdfSbufRecycle(sBufTStop);
1378 HdfSbufRecycle(cardNameBuf);
1379 HdfIoServiceRecycle(service);
1380 }
1381 /**
1382 * @tc.name StreamHostCaptureStart_001
1383 * @tc.desc Test the ADM stream function,return 0 when calling start function(capture service)
1384 * @tc.type: FUNC
1385 */
1386 HWTEST_F(AudioAdmInterfaceTest, StreamHostCaptureStart_001, TestSize.Level1)
1387 {
1388 int32_t ret = -1;
1389 struct HdfIoService *service = nullptr;
1390 struct HdfSBuf *cardNameBuf = nullptr;
1391 struct HdfSBuf *sBufTStop = nullptr;
1392 struct AudioPcmHwParams hwParams {
1393 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1394 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1395 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1396 };
1397 ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams);
1398 ASSERT_EQ(HDF_SUCCESS, ret);
1399
1400 ret = WriteCardSeviceNameToSBuf(cardNameBuf);
1401 EXPECT_EQ(HDF_SUCCESS, ret);
1402
1403 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, cardNameBuf, nullptr);
1404 EXPECT_EQ(HDF_SUCCESS, ret);
1405 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, cardNameBuf, nullptr);
1406 EXPECT_EQ(HDF_SUCCESS, ret);
1407
1408 ret = WriteToSBuf(sBufTStop);
1409 EXPECT_EQ(HDF_SUCCESS, ret);
1410 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, sBufTStop, nullptr);
1411 EXPECT_EQ(HDF_SUCCESS, ret);
1412 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, cardNameBuf, nullptr);
1413 EXPECT_EQ(HDF_SUCCESS, ret);
1414 HdfSbufRecycle(sBufTStop);
1415 HdfSbufRecycle(cardNameBuf);
1416 HdfIoServiceRecycle(service);
1417 }
1418 /**
1419 * @tc.name AudioStreamHostRenderStop_001
1420 * @tc.desc Test the ADM ctrl function,return 0 when calling stop function(render service)
1421 * @tc.type: FUNC
1422 */
1423 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostRenderStop_001, TestSize.Level1)
1424 {
1425 int32_t ret = -1;
1426 struct HdfIoService *service = nullptr;
1427 struct HdfSBuf *cardNameBuf = nullptr;
1428 struct HdfSBuf *sBufTStop = nullptr;
1429 struct AudioPcmHwParams hwParams {
1430 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 4096, .rate = 44100,
1431 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1432 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1433 };
1434 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1435 ASSERT_EQ(HDF_SUCCESS, ret);
1436
1437 ret = WriteCardSeviceNameToSBuf(cardNameBuf);
1438 EXPECT_EQ(HDF_SUCCESS, ret);
1439
1440 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, cardNameBuf, nullptr);
1441 EXPECT_EQ(HDF_SUCCESS, ret);
1442
1443 ret = WriteToSBuf(sBufTStop);
1444 EXPECT_EQ(HDF_SUCCESS, ret);
1445
1446 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, sBufTStop, nullptr);
1447 EXPECT_EQ(HDF_SUCCESS, ret);
1448 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, cardNameBuf, nullptr);
1449 EXPECT_EQ(HDF_SUCCESS, ret);
1450 HdfSbufRecycle(sBufTStop);
1451 HdfSbufRecycle(cardNameBuf);
1452 HdfIoServiceRecycle(service);
1453 }
1454 /**
1455 * @tc.name AudioStreamHostCaptureStop_001
1456 * @tc.desc Test the ADM ctrl function,return 0 when calling stop function(capture service)
1457 * @tc.type: FUNC
1458 */
1459 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostCaptureStop_001, TestSize.Level1)
1460 {
1461 int32_t ret = -1;
1462 struct HdfIoService *service = nullptr;
1463 struct HdfSBuf *cardNameBuf = nullptr;
1464 struct HdfSBuf *sBufTStop = nullptr;
1465 struct AudioPcmHwParams hwParams {
1466 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 4096, .rate = 44100,
1467 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1468 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1469 };
1470 ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams);
1471 ASSERT_EQ(HDF_SUCCESS, ret);
1472
1473 ret = WriteCardSeviceNameToSBuf(cardNameBuf);
1474 EXPECT_EQ(HDF_SUCCESS, ret);
1475
1476 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, cardNameBuf, nullptr);
1477 EXPECT_EQ(HDF_SUCCESS, ret);
1478 ret = WriteToSBuf(sBufTStop);
1479 EXPECT_EQ(HDF_SUCCESS, ret);
1480
1481 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, sBufTStop, nullptr);
1482 EXPECT_EQ(HDF_SUCCESS, ret);
1483 HdfSbufRecycle(sBufTStop);
1484 HdfSbufRecycle(cardNameBuf);
1485 HdfIoServiceRecycle(service);
1486 }
1487 /**
1488 * @tc.name AudioStreamHostRenderPause_001
1489 * @tc.desc Test the ADM ctrl function,return 0 when calling pause function(render service)
1490 * @tc.type: FUNC
1491 */
1492 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostRenderPause_001, TestSize.Level1)
1493 {
1494 int32_t ret = -1;
1495 struct HdfIoService *service = nullptr;
1496 struct HdfSBuf *cardNameBuf = nullptr;
1497 struct HdfSBuf *sBufTStop = nullptr;
1498 struct AudioPcmHwParams hwParams {
1499 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1500 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1501 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1502 };
1503 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1504 ASSERT_EQ(HDF_SUCCESS, ret);
1505
1506 ret = WriteCardSeviceNameToSBuf(cardNameBuf);
1507 EXPECT_EQ(HDF_SUCCESS, ret);
1508
1509 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, cardNameBuf, nullptr);
1510 EXPECT_EQ(HDF_SUCCESS, ret);
1511 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_START, cardNameBuf, nullptr);
1512 EXPECT_EQ(HDF_SUCCESS, ret);
1513 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PAUSE, cardNameBuf, nullptr);
1514 EXPECT_EQ(HDF_SUCCESS, ret);
1515 ret = WriteToSBuf(sBufTStop);
1516 EXPECT_EQ(HDF_SUCCESS, ret);
1517
1518 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, sBufTStop, nullptr);
1519 EXPECT_EQ(HDF_SUCCESS, ret);
1520 HdfSbufRecycle(sBufTStop);
1521 HdfSbufRecycle(cardNameBuf);
1522 HdfIoServiceRecycle(service);
1523 }
1524 /**
1525 * @tc.name AudioStreamHostCapturePause_001
1526 * @tc.desc Test the ADM ctrl function,return 0 when calling pause function(capture service)
1527 * @tc.type: FUNC
1528 */
1529 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostCapturePause_001, TestSize.Level1)
1530 {
1531 int32_t ret = -1;
1532 struct HdfIoService *service = nullptr;
1533 struct HdfSBuf *cardNameBuf = nullptr;
1534 struct HdfSBuf *sBufTStop = nullptr;
1535 struct AudioPcmHwParams hwParams {
1536 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1537 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1538 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1539 };
1540 ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams);
1541 ASSERT_EQ(HDF_SUCCESS, ret);
1542
1543 ret = WriteCardSeviceNameToSBuf(cardNameBuf);
1544 EXPECT_EQ(HDF_SUCCESS, ret);
1545
1546 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, cardNameBuf, nullptr);
1547 EXPECT_EQ(HDF_SUCCESS, ret);
1548 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, cardNameBuf, nullptr);
1549 EXPECT_EQ(HDF_SUCCESS, ret);
1550 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PAUSE, cardNameBuf, nullptr);
1551 EXPECT_EQ(HDF_SUCCESS, ret);
1552 ret = WriteToSBuf(sBufTStop);
1553 EXPECT_EQ(HDF_SUCCESS, ret);
1554
1555 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, sBufTStop, nullptr);
1556 EXPECT_EQ(HDF_SUCCESS, ret);
1557 HdfSbufRecycle(sBufTStop);
1558 HdfSbufRecycle(cardNameBuf);
1559 HdfIoServiceRecycle(service);
1560 }
1561 /**
1562 * @tc.name AudioStreamHostRenderResume_001
1563 * @tc.desc Test the ADM ctrl function,return 0 when calling resume function(render service)
1564 * @tc.type: FUNC
1565 */
1566 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostRenderResume_001, TestSize.Level1)
1567 {
1568 int32_t ret = -1;
1569 struct HdfIoService *service = nullptr;
1570 struct HdfSBuf *cardNameBuf = nullptr;
1571 struct HdfSBuf *sBufTStop = nullptr;
1572 struct AudioPcmHwParams hwParams {
1573 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1574 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1575 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1576 };
1577 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1578 ASSERT_EQ(HDF_SUCCESS, ret);
1579
1580 ret = WriteCardSeviceNameToSBuf(cardNameBuf);
1581 EXPECT_EQ(HDF_SUCCESS, ret);
1582
1583 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, cardNameBuf, nullptr);
1584 EXPECT_EQ(HDF_SUCCESS, ret);
1585 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_START, cardNameBuf, nullptr);
1586 EXPECT_EQ(HDF_SUCCESS, ret);
1587 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PAUSE, cardNameBuf, nullptr);
1588 EXPECT_EQ(HDF_SUCCESS, ret);
1589 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_RESUME, cardNameBuf, nullptr);
1590 EXPECT_EQ(HDF_SUCCESS, ret);
1591 ret = WriteToSBuf(sBufTStop);
1592 EXPECT_EQ(HDF_SUCCESS, ret);
1593 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, sBufTStop, nullptr);
1594 EXPECT_EQ(HDF_SUCCESS, ret);
1595 HdfSbufRecycle(sBufTStop);
1596 HdfSbufRecycle(cardNameBuf);
1597 HdfIoServiceRecycle(service);
1598 }
1599 /**
1600 * @tc.name AudioStreamHostCaptureResume_001
1601 * @tc.desc Test the ADM ctrl function,return 0 when calling resume function(capture service)
1602 * @tc.type: FUNC
1603 */
1604 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostCaptureResume_001, TestSize.Level1)
1605 {
1606 int32_t ret = -1;
1607 struct HdfIoService *service = nullptr;
1608 struct HdfSBuf *cardNameBuf = nullptr;
1609 struct HdfSBuf *sBufTStop = nullptr;
1610 struct AudioPcmHwParams hwParams {
1611 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1612 .periodCount = 8, .format = AUDIO_FORMAT_TYPE_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1613 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1614 };
1615 ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams);
1616 ASSERT_EQ(HDF_SUCCESS, ret);
1617
1618 ret = WriteCardSeviceNameToSBuf(cardNameBuf);
1619 EXPECT_EQ(HDF_SUCCESS, ret);
1620
1621 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, cardNameBuf, nullptr);
1622 EXPECT_EQ(HDF_SUCCESS, ret);
1623 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, cardNameBuf, nullptr);
1624 EXPECT_EQ(HDF_SUCCESS, ret);
1625 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PAUSE, cardNameBuf, nullptr);
1626 EXPECT_EQ(HDF_SUCCESS, ret);
1627 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_RESUME, cardNameBuf, nullptr);
1628 EXPECT_EQ(HDF_SUCCESS, ret);
1629
1630 ret = WriteToSBuf(sBufTStop);
1631 EXPECT_EQ(HDF_SUCCESS, ret);
1632 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, sBufTStop, nullptr);
1633 EXPECT_EQ(HDF_SUCCESS, ret);
1634 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, cardNameBuf, nullptr);
1635 EXPECT_EQ(HDF_SUCCESS, ret);
1636 HdfSbufRecycle(sBufTStop);
1637 HdfSbufRecycle(cardNameBuf);
1638 HdfIoServiceRecycle(service);
1639 }
1640 }
1641