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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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 *sBufT = nullptr;
1176 struct HdfSBuf *sBufTStop = nullptr;
1177 struct HdfSBuf *reply = nullptr;
1178 struct AudioPcmHwParams hwParams {
1179 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1180 .periodCount = 4, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1181 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1182 };
1183
1184 ret = WriteFrameToSBuf(sBufT, AUDIO_FILE);
1185 EXPECT_EQ(HDF_SUCCESS, ret);
1186 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1187 if (ret < 0) {
1188 HdfSbufRecycle(sBufT);
1189 ASSERT_EQ(HDF_SUCCESS, ret);
1190 }
1191 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, nullptr, nullptr);
1192 EXPECT_EQ(HDF_SUCCESS, ret);
1193 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_WRITE, sBufT, reply);
1194 EXPECT_EQ(HDF_SUCCESS, ret);
1195 ret = WriteToSBuf(sBufTStop);
1196 if (ret < 0) {
1197 HdfIoServiceRecycle(service);
1198 ASSERT_EQ(HDF_SUCCESS, ret);
1199 }
1200 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, sBufTStop, nullptr);
1201 EXPECT_EQ(HDF_SUCCESS, ret);
1202 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, nullptr, nullptr);
1203 EXPECT_EQ(HDF_SUCCESS, ret);
1204 HdfSbufRecycle(sBufT);
1205 HdfSbufRecycle(sBufTStop);
1206 HdfIoServiceRecycle(service);
1207 }
1208 /**
1209 * @tc.name AudioStreamHostRead_001
1210 * @tc.desc Test the ADM control data,cmdid is AUDIO_DRV_PCM_IOCTRL_READ.
1211 * @tc.type: FUNC
1212 */
1213 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostRead_001, TestSize.Level1)
1214 {
1215 int32_t tryNumReply = 100;
1216 uint32_t buffStatus = 0;
1217 uint32_t readSize = 0;
1218 struct HdfIoService *service = nullptr;
1219 struct HdfSBuf *sBufTStop = nullptr;
1220 struct AudioXferi transfer;
1221 struct AudioPcmHwParams hwParams {
1222 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1223 .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1224 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1225 };
1226 int32_t ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams);
1227 ASSERT_EQ(HDF_SUCCESS, ret);
1228 struct HdfSBuf *reply = HdfSbufTypedObtainCapacity(SBUF_RAW, (AUDIO_SIZE_FRAME + AUDIO_REPLY_EXTEND));
1229 ASSERT_NE(nullptr, reply);
1230 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, nullptr, nullptr);
1231 EXPECT_EQ(HDF_SUCCESS, ret);
1232 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, nullptr, nullptr);
1233 EXPECT_EQ(HDF_SUCCESS, ret);
1234 do {
1235 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_READ, nullptr, reply);
1236 EXPECT_EQ(HDF_SUCCESS, ret);
1237 EXPECT_GE(HdfSbufReadUint32(reply, &buffStatus), HDF_SUCCESS);
1238 if ((int32_t)buffStatus != CIR_BUFF_NORMAL) {
1239 int32_t ms = buffStatus >= 0 ? buffStatus : WAITE_TIME;
1240 tryNumReply--;
1241 HdfSbufFlush(reply);
1242 usleep(ms*US_TO_MS);
1243 continue;
1244 }
1245 break;
1246 } while (tryNumReply > 0);
1247 EXPECT_GE(tryNumReply, 0);
1248 ret = HdfSbufReadBuffer(reply, (const void **) & (transfer.buf), &readSize);
1249 EXPECT_NE(transfer.buf, nullptr);
1250 EXPECT_NE(readSize, (uint32_t)0);
1251 if ((ret = WriteToSBuf(sBufTStop)) < 0) {
1252 HdfSbufRecycle(reply);
1253 HdfIoServiceRecycle(service);
1254 ASSERT_EQ(HDF_SUCCESS, ret);
1255 }
1256 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, sBufTStop, nullptr);
1257 EXPECT_EQ(HDF_SUCCESS, ret);
1258 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, nullptr, nullptr);
1259 EXPECT_EQ(HDF_SUCCESS, ret);
1260 HdfSbufRecycle(reply);
1261 HdfSbufRecycle(sBufTStop);
1262 HdfIoServiceRecycle(service);
1263 }
1264
1265 /**
1266 * @tc.name AudioStreamHostRenderPrepare_001
1267 * @tc.desc Test the ADM stream function,return 0 when calling prepare function(render service)
1268 * @tc.type: FUNC
1269 */
1270 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostRenderPrepare_001, TestSize.Level1)
1271 {
1272 int32_t ret = -1;
1273 struct HdfIoService *service = nullptr;
1274 struct HdfSBuf *sBufTStop = nullptr;
1275 struct AudioPcmHwParams hwParams {
1276 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1277 .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1278 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1279 };
1280 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1281 ASSERT_EQ(HDF_SUCCESS, ret);
1282 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, nullptr, nullptr);
1283 EXPECT_EQ(HDF_SUCCESS, ret);
1284 ret = WriteToSBuf(sBufTStop);
1285 if (ret < 0) {
1286 HdfIoServiceRecycle(service);
1287 ASSERT_EQ(HDF_SUCCESS, ret);
1288 }
1289 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, sBufTStop, nullptr);
1290 EXPECT_EQ(HDF_SUCCESS, ret);
1291 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, nullptr, nullptr);
1292 EXPECT_EQ(HDF_SUCCESS, ret);
1293 HdfSbufRecycle(sBufTStop);
1294 HdfIoServiceRecycle(service);
1295 }
1296
1297 /**
1298 * @tc.name AudioStreamHostCapturePrepare_001
1299 * @tc.desc Test the ADM stream function,return 0 when calling prepare function(capture service)
1300 * @tc.type: FUNC
1301 */
1302 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostCapturePrepare_001, TestSize.Level1)
1303 {
1304 int32_t ret = -1;
1305 struct HdfIoService *service = nullptr;
1306 struct HdfSBuf *sBufTStop = nullptr;
1307 struct AudioPcmHwParams hwParams {
1308 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1309 .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1310 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1311 };
1312 ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams);
1313 ASSERT_EQ(HDF_SUCCESS, ret);
1314
1315 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, nullptr, nullptr);
1316 EXPECT_EQ(HDF_SUCCESS, ret);
1317 ret = WriteToSBuf(sBufTStop);
1318 if (ret < 0) {
1319 HdfIoServiceRecycle(service);
1320 ASSERT_EQ(HDF_SUCCESS, ret);
1321 }
1322 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, sBufTStop, nullptr);
1323 EXPECT_EQ(HDF_SUCCESS, ret);
1324 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, nullptr, nullptr);
1325 EXPECT_EQ(HDF_SUCCESS, ret);
1326 HdfSbufRecycle(sBufTStop);
1327 HdfIoServiceRecycle(service);
1328 }
1329 /**
1330 * @tc.name StreamHostRenderStart_001
1331 * @tc.desc Test the ADM stream function,return 0 when calling start function(render service)
1332 * @tc.type: FUNC
1333 */
1334 HWTEST_F(AudioAdmInterfaceTest, StreamHostRenderStart_001, TestSize.Level1)
1335 {
1336 int32_t ret = -1;
1337 struct HdfIoService *service = nullptr;
1338 struct HdfSBuf *sBufTStop = nullptr;
1339 struct AudioPcmHwParams hwParams {
1340 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1341 .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1342 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1343 };
1344 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1345 ASSERT_EQ(HDF_SUCCESS, ret);
1346 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, nullptr, nullptr);
1347 EXPECT_EQ(HDF_SUCCESS, ret);
1348 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_START, nullptr, nullptr);
1349 EXPECT_EQ(HDF_SUCCESS, ret);
1350 ret = WriteToSBuf(sBufTStop);
1351 if (ret < 0) {
1352 HdfIoServiceRecycle(service);
1353 ASSERT_EQ(HDF_SUCCESS, ret);
1354 }
1355 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, sBufTStop, nullptr);
1356 EXPECT_EQ(HDF_SUCCESS, ret);
1357 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, nullptr, nullptr);
1358 EXPECT_EQ(HDF_SUCCESS, ret);
1359 HdfSbufRecycle(sBufTStop);
1360 HdfIoServiceRecycle(service);
1361 }
1362 /**
1363 * @tc.name StreamHostCaptureStart_001
1364 * @tc.desc Test the ADM stream function,return 0 when calling start function(capture service)
1365 * @tc.type: FUNC
1366 */
1367 HWTEST_F(AudioAdmInterfaceTest, StreamHostCaptureStart_001, TestSize.Level1)
1368 {
1369 int32_t ret = -1;
1370 struct HdfIoService *service = nullptr;
1371 struct HdfSBuf *sBufTStop = nullptr;
1372 struct AudioPcmHwParams hwParams {
1373 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1374 .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1375 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1376 };
1377 ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams);
1378 ASSERT_EQ(HDF_SUCCESS, ret);
1379 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, nullptr, nullptr);
1380 EXPECT_EQ(HDF_SUCCESS, ret);
1381 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, nullptr, nullptr);
1382 EXPECT_EQ(HDF_SUCCESS, ret);
1383 ret = WriteToSBuf(sBufTStop);
1384 if (ret < 0) {
1385 HdfIoServiceRecycle(service);
1386 ASSERT_EQ(HDF_SUCCESS, ret);
1387 }
1388 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, sBufTStop, nullptr);
1389 EXPECT_EQ(HDF_SUCCESS, ret);
1390 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, nullptr, nullptr);
1391 EXPECT_EQ(HDF_SUCCESS, ret);
1392 HdfSbufRecycle(sBufTStop);
1393 HdfIoServiceRecycle(service);
1394 }
1395 /**
1396 * @tc.name AudioStreamHostRenderStop_001
1397 * @tc.desc Test the ADM ctrl function,return 0 when calling stop function(render service)
1398 * @tc.type: FUNC
1399 */
1400 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostRenderStop_001, TestSize.Level1)
1401 {
1402 int32_t ret = -1;
1403 struct HdfIoService *service = nullptr;
1404 struct HdfSBuf *sBufTStop = nullptr;
1405 struct AudioPcmHwParams hwParams {
1406 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 4096, .rate = 44100,
1407 .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1408 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1409 };
1410 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1411 ASSERT_EQ(HDF_SUCCESS, ret);
1412 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, nullptr, nullptr);
1413 EXPECT_EQ(HDF_SUCCESS, ret);
1414 ret = WriteToSBuf(sBufTStop);
1415 if (ret < 0) {
1416 HdfIoServiceRecycle(service);
1417 ASSERT_EQ(HDF_SUCCESS, ret);
1418 }
1419 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, sBufTStop, nullptr);
1420 EXPECT_EQ(HDF_SUCCESS, ret);
1421 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_CLOSE, nullptr, nullptr);
1422 EXPECT_EQ(HDF_SUCCESS, ret);
1423 HdfSbufRecycle(sBufTStop);
1424 HdfIoServiceRecycle(service);
1425 }
1426 /**
1427 * @tc.name AudioStreamHostCaptureStop_001
1428 * @tc.desc Test the ADM ctrl function,return 0 when calling stop function(capture service)
1429 * @tc.type: FUNC
1430 */
1431 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostCaptureStop_001, TestSize.Level1)
1432 {
1433 int32_t ret = -1;
1434 struct HdfIoService *service = nullptr;
1435 struct HdfSBuf *sBufTStop = nullptr;
1436 struct AudioPcmHwParams hwParams {
1437 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 4096, .rate = 44100,
1438 .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1439 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1440 };
1441 ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams);
1442 ASSERT_EQ(HDF_SUCCESS, ret);
1443 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, nullptr, nullptr);
1444 EXPECT_EQ(HDF_SUCCESS, ret);
1445 ret = WriteToSBuf(sBufTStop);
1446 if (ret < 0) {
1447 HdfIoServiceRecycle(service);
1448 ASSERT_EQ(HDF_SUCCESS, ret);
1449 }
1450 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, sBufTStop, nullptr);
1451 EXPECT_EQ(HDF_SUCCESS, ret);
1452 HdfSbufRecycle(sBufTStop);
1453 HdfIoServiceRecycle(service);
1454 }
1455 /**
1456 * @tc.name AudioStreamHostRenderPause_001
1457 * @tc.desc Test the ADM ctrl function,return 0 when calling pause function(render service)
1458 * @tc.type: FUNC
1459 */
1460 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostRenderPause_001, TestSize.Level1)
1461 {
1462 int32_t ret = -1;
1463 struct HdfIoService *service = nullptr;
1464 struct HdfSBuf *sBufTStop = nullptr;
1465 struct AudioPcmHwParams hwParams {
1466 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1467 .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1468 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1469 };
1470 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1471 ASSERT_EQ(HDF_SUCCESS, ret);
1472 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, nullptr, nullptr);
1473 EXPECT_EQ(HDF_SUCCESS, ret);
1474 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_START, nullptr, nullptr);
1475 EXPECT_EQ(HDF_SUCCESS, ret);
1476 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PAUSE, nullptr, nullptr);
1477 EXPECT_EQ(HDF_SUCCESS, ret);
1478 ret = WriteToSBuf(sBufTStop);
1479 if (ret < 0) {
1480 HdfIoServiceRecycle(service);
1481 ASSERT_EQ(HDF_SUCCESS, ret);
1482 }
1483 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, sBufTStop, nullptr);
1484 EXPECT_EQ(HDF_SUCCESS, ret);
1485 HdfSbufRecycle(sBufTStop);
1486 HdfIoServiceRecycle(service);
1487 }
1488 /**
1489 * @tc.name AudioStreamHostCapturePause_001
1490 * @tc.desc Test the ADM ctrl function,return 0 when calling pause function(capture service)
1491 * @tc.type: FUNC
1492 */
1493 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostCapturePause_001, TestSize.Level1)
1494 {
1495 int32_t ret = -1;
1496 struct HdfIoService *service = nullptr;
1497 struct HdfSBuf *sBufTStop = nullptr;
1498 struct AudioPcmHwParams hwParams {
1499 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1500 .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1501 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1502 };
1503 ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams);
1504 ASSERT_EQ(HDF_SUCCESS, ret);
1505 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, nullptr, nullptr);
1506 EXPECT_EQ(HDF_SUCCESS, ret);
1507 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, nullptr, nullptr);
1508 EXPECT_EQ(HDF_SUCCESS, ret);
1509 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PAUSE, nullptr, nullptr);
1510 EXPECT_EQ(HDF_SUCCESS, ret);
1511 ret = WriteToSBuf(sBufTStop);
1512 if (ret < 0) {
1513 HdfIoServiceRecycle(service);
1514 ASSERT_EQ(HDF_SUCCESS, ret);
1515 }
1516 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, sBufTStop, nullptr);
1517 EXPECT_EQ(HDF_SUCCESS, ret);
1518 HdfSbufRecycle(sBufTStop);
1519 HdfIoServiceRecycle(service);
1520 }
1521 /**
1522 * @tc.name AudioStreamHostRenderResume_001
1523 * @tc.desc Test the ADM ctrl function,return 0 when calling resume function(render service)
1524 * @tc.type: FUNC
1525 */
1526 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostRenderResume_001, TestSize.Level1)
1527 {
1528 int32_t ret = -1;
1529 struct HdfIoService *service = nullptr;
1530 struct HdfSBuf *sBufTStop = nullptr;
1531 struct AudioPcmHwParams hwParams {
1532 .streamType = AUDIO_RENDER_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1533 .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1534 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1535 };
1536 ret = WriteHwParams(HDF_RENDER_SERVICE, service, hwParams);
1537 ASSERT_EQ(HDF_SUCCESS, ret);
1538 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, nullptr, nullptr);
1539 EXPECT_EQ(HDF_SUCCESS, ret);
1540 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_START, nullptr, nullptr);
1541 EXPECT_EQ(HDF_SUCCESS, ret);
1542 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_PAUSE, nullptr, nullptr);
1543 EXPECT_EQ(HDF_SUCCESS, ret);
1544 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_RESUME, nullptr, nullptr);
1545 EXPECT_EQ(HDF_SUCCESS, ret);
1546 ret = WriteToSBuf(sBufTStop);
1547 if (ret < 0) {
1548 HdfIoServiceRecycle(service);
1549 ASSERT_EQ(HDF_SUCCESS, ret);
1550 }
1551 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, sBufTStop, nullptr);
1552 EXPECT_EQ(HDF_SUCCESS, ret);
1553 HdfSbufRecycle(sBufTStop);
1554 HdfIoServiceRecycle(service);
1555 }
1556 /**
1557 * @tc.name AudioStreamHostCaptureResume_001
1558 * @tc.desc Test the ADM ctrl function,return 0 when calling resume function(capture service)
1559 * @tc.type: FUNC
1560 */
1561 HWTEST_F(AudioAdmInterfaceTest, AudioStreamHostCaptureResume_001, TestSize.Level1)
1562 {
1563 int32_t ret = -1;
1564 struct HdfIoService *service = nullptr;
1565 struct HdfSBuf *sBufTStop = nullptr;
1566 struct AudioPcmHwParams hwParams {
1567 .streamType = AUDIO_CAPTURE_STREAM, .channels = 2, .period = 4096, .rate = 11025,
1568 .periodCount = 8, .format = AUDIO_FORMAT_PCM_24_BIT, .cardServiceName = CARD_SEVICE_NAME.c_str(),
1569 .isBigEndian = 0, .isSignedData = 1, .silenceThreshold = 16384
1570 };
1571 ret = WriteHwParams(HDF_CAPTURE_SERVICE, service, hwParams);
1572 ASSERT_EQ(HDF_SUCCESS, ret);
1573 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, nullptr, nullptr);
1574 EXPECT_EQ(HDF_SUCCESS, ret);
1575 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, nullptr, nullptr);
1576 EXPECT_EQ(HDF_SUCCESS, ret);
1577 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_PAUSE, nullptr, nullptr);
1578 EXPECT_EQ(HDF_SUCCESS, ret);
1579 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_RESUME, nullptr, nullptr);
1580 EXPECT_EQ(HDF_SUCCESS, ret);
1581 ret = WriteToSBuf(sBufTStop);
1582 if (ret < 0) {
1583 HdfIoServiceRecycle(service);
1584 ASSERT_EQ(HDF_SUCCESS, ret);
1585 }
1586 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, sBufTStop, nullptr);
1587 EXPECT_EQ(HDF_SUCCESS, ret);
1588 ret = service->dispatcher->Dispatch(&service->object, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, nullptr, nullptr);
1589 EXPECT_EQ(HDF_SUCCESS, ret);
1590 HdfSbufRecycle(sBufTStop);
1591 HdfIoServiceRecycle(service);
1592 }
1593 }
1594