1 /*
2 * Copyright (c) 2021-2022 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 Defines audio-related APIs, including custom data types and functions for loading drivers,
21 * accessing a driver adapter, and rendering audios.
22 *
23 * @since 1.0
24 * @version 1.0
25 */
26
27 /**
28 * @file audio_hdi_common.h
29 *
30 * @brief Declares APIs for operations related to the audio render adapter.
31 *
32 * @since 1.0
33 * @version 1.0
34 */
35
36 #include "audio_hdi_common.h"
37 #include "audio_hdirender_attr_test.h"
38
39 using namespace std;
40 using namespace testing::ext;
41 using namespace OHOS::Audio;
42
43 namespace {
44 const int32_t AUDIO_SAMPLERATE_INVALID = 0xFFFFFFFFu;
45 const int32_t AUDIO_CHANNELCOUNT_INVALID = -1;
46 class AudioHdiRenderAttrTest : public testing::Test {
47 public:
48 static void SetUpTestCase(void);
49 static void TearDownTestCase(void);
50 void SetUp();
51 void TearDown();
52 };
53
54 using THREAD_FUNC = void *(*)(void *);
55
SetUpTestCase(void)56 void AudioHdiRenderAttrTest::SetUpTestCase(void) {}
TearDownTestCase(void)57 void AudioHdiRenderAttrTest::TearDownTestCase(void) {}
SetUp(void)58 void AudioHdiRenderAttrTest::SetUp(void) {}
TearDown(void)59 void AudioHdiRenderAttrTest::TearDown(void) {}
60
61 /**
62 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
63 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0002
64 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
65 * attrs.type = AUDIO_IN_MEDIA;
66 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
67 * attrs.sampleRate = 11025;
68 * attrs.channelCount = 2;
69 */
70 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0002, Function | MediumTest | Level1)
71 {
72 int32_t ret = -1;
73 struct AudioAdapter *adapter = nullptr;
74 struct AudioRender *render = nullptr;
75 struct AudioSampleAttributes attrs = {};
76 struct AudioSampleAttributes attrsValue = {};
77
78 TestAudioManager* manager = GetAudioManagerFuncs();
79 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
80 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
81 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 11025);
82
83 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
84 if(ret != AUDIO_HAL_SUCCESS){
85 EXPECT_TRUE(true);
86 }
87 if(ret == AUDIO_HAL_SUCCESS)
88 {
89 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
90 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
91 EXPECT_NE(AUDIO_SAMPLERATE_INVALID, attrsValue.sampleRate);
92 EXPECT_NE(AUDIO_CHANNELCOUNT_INVALID, attrsValue.channelCount);
93 }
94
95 adapter->DestroyRender(adapter, render);
96 manager->UnloadAdapter(manager, adapter);
97 }
98 /**
99 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
100 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0003
101 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
102 * attrs.type = AUDIO_IN_MEDIA;
103 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
104 * attrs.sampleRate = 22050;
105 * attrs.channelCount = 1;
106 */
107 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0003, Function | MediumTest | Level1)
108 {
109 int32_t ret = -1;
110 struct AudioAdapter *adapter = nullptr;
111 struct AudioRender *render = nullptr;
112 struct AudioSampleAttributes attrs = {};
113 struct AudioSampleAttributes attrsValue = {};
114
115 TestAudioManager* manager = GetAudioManagerFuncs();
116 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
117 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
118 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 22050);
119
120 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
121 if(ret != AUDIO_HAL_SUCCESS){
122 EXPECT_TRUE(true);
123 }
124 if(ret == AUDIO_HAL_SUCCESS)
125 {
126 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
127 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
128 EXPECT_NE(AUDIO_SAMPLERATE_INVALID, attrsValue.sampleRate);
129 EXPECT_NE(AUDIO_CHANNELCOUNT_INVALID, attrsValue.channelCount);
130 }
131 adapter->DestroyRender(adapter, render);
132 manager->UnloadAdapter(manager, adapter);
133 }
134 /**
135 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
136 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0004
137 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
138 * attrs.type = AUDIO_IN_MEDIA;
139 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
140 * attrs.sampleRate = 32000;
141 * attrs.channelCount = 2;
142 */
143 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0004, Function | MediumTest | Level1)
144 {
145 int32_t ret = -1;
146 struct AudioAdapter *adapter = nullptr;
147 struct AudioRender *render = nullptr;
148 struct AudioSampleAttributes attrs = {};
149 struct AudioSampleAttributes attrsValue = {};
150
151 TestAudioManager* manager = GetAudioManagerFuncs();
152 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
153 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
154 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 32000);
155
156 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
157 if(ret != AUDIO_HAL_SUCCESS){
158 EXPECT_TRUE(true);
159 }
160 if(ret == AUDIO_HAL_SUCCESS)
161 {
162 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
163 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
164 EXPECT_NE(AUDIO_SAMPLERATE_INVALID, attrsValue.sampleRate);
165 EXPECT_NE(AUDIO_CHANNELCOUNT_INVALID, attrsValue.channelCount);
166 }
167 adapter->DestroyRender(adapter, render);
168 manager->UnloadAdapter(manager, adapter);
169 }
170 /**
171 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
172 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
173 * attrs.type = AUDIO_IN_COMMUNICATION;
174 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
175 * attrs.sampleRate = 48000;
176 * attrs.channelCount = 2;
177 */
178 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0006, Function | MediumTest | Level1)
179 {
180 int32_t ret = -1;
181 struct AudioAdapter *adapter = nullptr;
182 struct AudioRender *render = nullptr;
183 struct AudioSampleAttributes attrs = {};
184 struct AudioSampleAttributes attrsValue = {};
185
186 TestAudioManager* manager = GetAudioManagerFuncs();
187 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
188 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
189 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 48000);
190
191 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
192 if(ret != AUDIO_HAL_SUCCESS){
193 EXPECT_TRUE(true);
194 }
195 if(ret == AUDIO_HAL_SUCCESS)
196 {
197 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
198 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
199 EXPECT_NE(AUDIO_SAMPLERATE_INVALID, attrsValue.sampleRate);
200 EXPECT_NE(AUDIO_CHANNELCOUNT_INVALID, attrsValue.channelCount);
201 }
202 adapter->DestroyRender(adapter, render);
203 manager->UnloadAdapter(manager, adapter);
204 }
205 /**
206 * @tc.name Test AudioRenderSetSampleAttributes API via setting the render is empty .
207 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0007
208 * @tc.desc Test AudioRenderSetSampleAttributes interface, return -1 if the render is empty.
209 */
210 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0007, Function | MediumTest | Level1)
211 {
212 int32_t ret = -1;
213 struct AudioAdapter *adapter = nullptr;
214 struct AudioRender *render = nullptr;
215 struct AudioRender *renderNull = nullptr;
216 struct AudioSampleAttributes attrs = {};
217
218 TestAudioManager* manager = GetAudioManagerFuncs();
219 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
220 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
221 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 8000);
222
223 ret = render->attr.SetSampleAttributes(renderNull, &attrs);
224 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
225 ret = render->attr.SetSampleAttributes(render, nullptr);
226 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
227
228 adapter->DestroyRender(adapter, render);
229 manager->UnloadAdapter(manager, adapter);
230 }
231 /**
232 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
233 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0010
234 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
235 * attrs.type = AUDIO_IN_MEDIA;
236 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
237 * attrs.sampleRate = 24000;
238 * attrs.channelCount = 2;
239 */
240 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0010, Function | MediumTest | Level1)
241 {
242 int32_t ret = -1;
243 struct AudioAdapter *adapter = nullptr;
244 struct AudioRender *render = nullptr;
245 struct AudioSampleAttributes attrs = {};
246 struct AudioSampleAttributes attrsValue = {};
247
248 TestAudioManager* manager = GetAudioManagerFuncs();
249 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
250 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
251
252 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 24000);
253 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
254 if(ret != AUDIO_HAL_SUCCESS){
255 EXPECT_TRUE(true);
256 }
257 if(ret == AUDIO_HAL_SUCCESS)
258 {
259 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
260 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
261 EXPECT_NE(AUDIO_SAMPLERATE_INVALID, attrsValue.sampleRate);
262 EXPECT_NE(AUDIO_CHANNELCOUNT_INVALID, attrsValue.channelCount);
263 }
264 adapter->DestroyRender(adapter, render);
265 manager->UnloadAdapter(manager, adapter);
266 }
267 /**
268 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
269 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0011
270 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
271 * attrs.type = AUDIO_IN_MEDIA;
272 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
273 * attrs.sampleRate = 64000;
274 * attrs.channelCount = 2;
275 */
276 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0011, Function | MediumTest | Level1)
277 {
278 int32_t ret = -1;
279 struct AudioAdapter *adapter = nullptr;
280 struct AudioRender *render = nullptr;
281 struct AudioSampleAttributes attrs = {};
282 struct AudioSampleAttributes attrsValue = {};
283
284 TestAudioManager* manager = GetAudioManagerFuncs();
285 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
286 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
287 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 64000);
288
289 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
290 if(ret != AUDIO_HAL_SUCCESS){
291 EXPECT_TRUE(true);
292 }
293 if(ret == AUDIO_HAL_SUCCESS)
294 {
295 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
296 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
297 EXPECT_NE(AUDIO_SAMPLERATE_INVALID, attrsValue.sampleRate);
298 EXPECT_NE(AUDIO_CHANNELCOUNT_INVALID, attrsValue.channelCount);
299 }
300 adapter->DestroyRender(adapter, render);
301 manager->UnloadAdapter(manager, adapter);
302 }
303 /**
304 * @tc.name Test AudioRenderSetSampleAttributes API via illegal input.
305 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0013
306 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
307 * attrs.type = AUDIO_IN_MEDIA;
308 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
309 * attrs.sampleRate = 0xFFFFFFFFu;
310 * attrs.channelCount = 2;
311 */
312 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0013, Function | MediumTest | Level1)
313 {
314 int32_t ret = -1;
315 struct AudioAdapter *adapter = nullptr;
316 struct AudioRender *render = nullptr;
317 struct AudioSampleAttributes attrs = {};
318
319 TestAudioManager* manager = GetAudioManagerFuncs();
320 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
321 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
322 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 0xFFFFFFFFu);
323
324 ret = render->attr.SetSampleAttributes(render, &attrs);
325 EXPECT_NE(AUDIO_HAL_SUCCESS, ret);
326
327 adapter->DestroyRender(adapter, render);
328 manager->UnloadAdapter(manager, adapter);
329 }
330 /**
331 * @tc.name Test AudioRenderSetSampleAttributes API via illegal input.
332 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0015
333 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
334 * attrs.type = AUDIO_IN_MEDIA;
335 * attrs.format = AUDIO_FORMAT_AAC_LC/LD/ELD;
336 * attrs.sampleRate = 32000/44100/48000;
337 * attrs.channelCount = 1/2;
338 */
339 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0015, Function | MediumTest | Level1)
340 {
341 int32_t ret = -1;
342 struct AudioAdapter *adapter = nullptr;
343 struct AudioRender *render = nullptr;
344 struct AudioSampleAttributes attrs1 = {};
345 struct AudioSampleAttributes attrs2 = {};
346 struct AudioSampleAttributes attrs3 = {};
347
348 TestAudioManager* manager = GetAudioManagerFuncs();
349
350 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
351 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
352 InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_LC, 2, 32000);
353 ret = render->attr.SetSampleAttributes(render, &attrs1);
354 EXPECT_NE(AUDIO_HAL_SUCCESS, ret);
355
356 InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_LD, 1, 44100);
357 ret = render->attr.SetSampleAttributes(render, &attrs2);
358 EXPECT_NE(AUDIO_HAL_SUCCESS, ret);
359
360 InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_ELD, 2, 48000);
361 ret = render->attr.SetSampleAttributes(render, &attrs3);
362 EXPECT_NE(AUDIO_HAL_SUCCESS, ret);
363
364 adapter->DestroyRender(adapter, render);
365 manager->UnloadAdapter(manager, adapter);
366 }
367 /**
368 * @tc.name Test AudioRenderSetSampleAttributes API via illegal input.
369 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0016
370 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
371 * attrs.type = AUDIO_IN_MEDIA;
372 * attrs.format = AUDIO_FORMAT_AAC_HE_V1/V2
373 * attrs.sampleRate = 8000/44100;
374 * attrs.channelCount = 1/2;
375 */
376 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0016, Function | MediumTest | Level1)
377 {
378 int32_t ret = -1;
379 struct AudioAdapter *adapter = nullptr;
380 struct AudioRender *render = nullptr;
381 struct AudioSampleAttributes attrs1 = {};
382 struct AudioSampleAttributes attrs2 = {};
383
384 TestAudioManager* manager = GetAudioManagerFuncs();
385 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
386 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
387
388 InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_HE_V1, 1, 8000);
389 ret = render->attr.SetSampleAttributes(render, &attrs1);
390 EXPECT_NE(AUDIO_HAL_SUCCESS, ret);
391
392 InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_HE_V2, 2, 44100);
393 ret = render->attr.SetSampleAttributes(render, &attrs2);
394 EXPECT_NE(AUDIO_HAL_SUCCESS, ret);
395
396 adapter->DestroyRender(adapter, render);
397 manager->UnloadAdapter(manager, adapter);
398 }
399
400 /**
401 * @tc.name Test AudioRendereGetSampleAttributes API via setting the render is empty .
402 * @tc.number SUB_Audio_HDI_AudioRenderGetSampleAttributes_0002
403 * @tc.desc Test AudioRendereGetSampleAttributes interface, return -1 if the render is empty.
404 */
405 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderGetSampleAttributes_0002, Function | MediumTest | Level1)
406 {
407 int32_t ret = -1;
408 struct AudioAdapter *adapter = nullptr;
409 struct AudioRender *render = nullptr;
410 struct AudioRender *renderNull = nullptr;
411 struct AudioSampleAttributes attrs = {};
412 struct AudioSampleAttributes *attrsValue = nullptr;
413
414 TestAudioManager* manager = GetAudioManagerFuncs();
415 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
416 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
417 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 44100);
418
419 ret = render->attr.GetSampleAttributes(renderNull, &attrs);
420 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
421 ret = render->attr.GetSampleAttributes(render, attrsValue);
422 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
423
424 adapter->DestroyRender(adapter, render);
425 manager->UnloadAdapter(manager, adapter);
426 }
427 /**
428 * @tc.name Test RenderGetFrameSize API via legal input
429 * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0001
430 * @tc.desc Test RenderGetFrameSize interface,return 0 if the FrameSize was obtained successfully
431 */
432 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0001, Function | MediumTest | Level1)
433 {
434 int32_t ret = -1;
435 uint64_t size = 0;
436 uint64_t zero = 0;
437 struct AudioAdapter *adapter = nullptr;
438 struct AudioRender *render = nullptr;
439
440 TestAudioManager* manager = GetAudioManagerFuncs();
441 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
442 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
443
444 ret = render->attr.GetFrameSize(render, &size);
445 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
446 EXPECT_GT(size, zero);
447
448 adapter->DestroyRender(adapter, render);
449 manager->UnloadAdapter(manager, adapter);
450 }
451 /**
452 * @tc.name Test AudioCaptureGetFrameSize API via setting the incoming parameter handle is nullptr
453 * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0002
454 * @tc.desc Test RenderGetFrameSize interface,return -1 if failed to get the FrameSize when handle is nullptr
455 */
456 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0002, Function | MediumTest | Level1)
457 {
458 int32_t ret = -1;
459 uint64_t size = 0;
460 struct AudioAdapter *adapter = nullptr;
461 struct AudioRender *render = nullptr;
462 struct AudioRender *renderNull = nullptr;
463
464 TestAudioManager* manager = GetAudioManagerFuncs();
465 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
466 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
467
468 ret = render->attr.GetFrameSize(renderNull, &size);
469 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
470
471 adapter->DestroyRender(adapter, render);
472 manager->UnloadAdapter(manager, adapter);
473 }
474 /**
475 * @tc.name Test RenderGetFrameSize API setting the incoming parameter FrameSize is nullptr
476 * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0003
477 * @tc.desc Test RenderGetFrameSize interface,return -1 if failed to get the FrameSize when size is nullptr
478 */
479 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0003, Function | MediumTest | Level1)
480 {
481 int32_t ret = -1;
482 uint64_t *sizeNull = nullptr;
483 struct AudioAdapter *adapter = nullptr;
484 struct AudioRender *render = nullptr;
485
486 TestAudioManager* manager = GetAudioManagerFuncs();
487 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
488 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
489
490 ret = render->attr.GetFrameSize(render, sizeNull);
491 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
492
493 adapter->DestroyRender(adapter, render);
494 manager->UnloadAdapter(manager, adapter);
495 }
496 /**
497 * @tc.name Test RenderGetFrameSize API via define format to different values
498 * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0004
499 * @tc.desc Test RenderGetFrameSize interface,return 0 if get framesize define format as different values
500 */
501 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0004, Function | MediumTest | Level1)
502 {
503 int32_t ret = -1;
504 uint64_t size = 0;
505 struct AudioSampleAttributes attrs = {};
506 struct AudioSampleAttributes attrsValue = {};
507 struct AudioAdapter *adapter = nullptr;
508 struct AudioRender *render = nullptr;
509
510 TestAudioManager* manager = GetAudioManagerFuncs();
511 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
512 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
513 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 48000);
514
515 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
516 if(ret != AUDIO_HAL_SUCCESS){
517 EXPECT_TRUE(true);
518 }
519 if(ret == AUDIO_HAL_SUCCESS)
520 {
521 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
522 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
523 EXPECT_NE(AUDIO_SAMPLERATE_INVALID, attrsValue.sampleRate);
524 EXPECT_NE(AUDIO_CHANNELCOUNT_INVALID, attrsValue.channelCount);
525 ret = render->attr.GetFrameSize(render, &size);
526 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
527 }
528 adapter->DestroyRender(adapter, render);
529 manager->UnloadAdapter(manager, adapter);
530 }
531
532 /**
533 * @tc.name Test RenderGetFrameSize API via define channelCount to different values
534 * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0006
535 * @tc.desc Test RenderGetFrameSize interface,return 0 if get framesize define channelCount as different values
536 */
537 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0006, Function | MediumTest | Level1)
538 {
539 int32_t ret = -1;
540 uint64_t size = 0;
541 struct AudioSampleAttributes attrs = {};
542 struct AudioSampleAttributes attrsValue = {};
543 struct AudioAdapter *adapter = nullptr;
544 struct AudioRender *render = nullptr;
545
546 TestAudioManager* manager = GetAudioManagerFuncs();
547 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
548 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
549 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 44100);
550
551 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
552 if(ret != AUDIO_HAL_SUCCESS){
553 EXPECT_TRUE(true);
554 }
555 if(ret == AUDIO_HAL_SUCCESS)
556 {
557 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
558 EXPECT_NE(AUDIO_SAMPLERATE_INVALID, attrsValue.sampleRate);
559 EXPECT_NE(AUDIO_CHANNELCOUNT_INVALID, attrsValue.channelCount);
560
561 ret = render->attr.GetFrameSize(render, &size);
562 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
563 }
564 adapter->DestroyRender(adapter, render);
565 manager->UnloadAdapter(manager, adapter);
566 }
567 /**
568 * @tc.name Test RenderGetFrameCount API via legal
569 * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0001
570 * @tc.desc Test RenderGetFrameCount interface, return 0 if the FrameSize was obtained successfully
571 */
572 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0001, Function | MediumTest | Level1)
573 {
574 int32_t ret = -1;
575 uint64_t count = 0;
576 uint64_t zero = 0;
577 TestAudioManager* manager = {};
578 struct AudioAdapter *adapter = nullptr;
579 struct AudioRender *render = nullptr;
580
581 manager = GetAudioManagerFuncs();
582 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
583 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
584
585 ret = render->attr.GetFrameCount(render, &count);
586 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
587 EXPECT_GT(count, zero);
588
589 render->control.Stop((AudioHandle)render);
590 adapter->DestroyRender(adapter, render);
591 manager->UnloadAdapter(manager, adapter);
592 }
593 /**
594 * @tc.name Test RenderGetFrameCount API via setting the incoming parameter handle is nullptr
595 * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0002
596 * @tc.desc Test RenderGetFrameCount interface,return -1 if the incoming parameter handle is nullptr
597 */
598 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0002, Function | MediumTest | Level1)
599 {
600 int32_t ret = -1;
601 uint64_t count = 0;
602 TestAudioManager* manager = {};
603 struct AudioAdapter *adapter = nullptr;
604 struct AudioRender *render = nullptr;
605 struct AudioRender *renderNull = nullptr;
606
607 manager = GetAudioManagerFuncs();
608 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
609 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
610
611 ret = render->attr.GetFrameCount(renderNull, &count);
612 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
613
614 render->control.Stop((AudioHandle)render);
615 adapter->DestroyRender(adapter, render);
616 manager->UnloadAdapter(manager, adapter);
617 }
618 /**
619 * @tc.name Test RenderGetFrameCount API setting the incoming parameter count is nullptr
620 * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0003
621 * @tc.desc Test RenderGetFrameCount interface,return -1 if the incoming parameter count is nullptr
622 */
623 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0003, Function | MediumTest | Level1)
624 {
625 int32_t ret = -1;
626 uint64_t *countNull = nullptr;
627 TestAudioManager* manager = {};
628 struct AudioAdapter *adapter = nullptr;
629 struct AudioRender *render = nullptr;
630
631 manager = GetAudioManagerFuncs();
632 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
633 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
634
635 ret = render->attr.GetFrameCount(render, countNull);
636 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
637
638 render->control.Stop((AudioHandle)render);
639 adapter->DestroyRender(adapter, render);
640 manager->UnloadAdapter(manager, adapter);
641 }
642 /**
643 * @tc.name Test RenderGetFrameCount API via define channelCount to different values
644 * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0004
645 * @tc.desc Test RenderGetFrameCount interface,return 0 if get framesize define channelCount as different values
646 */
647 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0004, Function | MediumTest | Level1)
648 {
649 int32_t ret = -1;
650 uint64_t count = 0;
651 struct AudioAdapter *adapter = nullptr;
652 struct AudioRender *render = nullptr;
653 struct AudioSampleAttributes attrs = {};
654 struct AudioSampleAttributes attrsValue = {};
655
656 TestAudioManager* manager = GetAudioManagerFuncs();
657 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
658 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
659 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 8000);
660
661 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
662 if(ret != AUDIO_HAL_SUCCESS){
663 EXPECT_TRUE(true);
664 }
665 if(ret == AUDIO_HAL_SUCCESS)
666 {
667 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
668 EXPECT_NE(AUDIO_SAMPLERATE_INVALID, attrsValue.sampleRate);
669 EXPECT_NE(AUDIO_CHANNELCOUNT_INVALID, attrsValue.channelCount);
670
671 ret = AudioRenderStartAndOneFrame(render);
672 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
673 ret = render->attr.GetFrameCount(render, &count);
674 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
675
676 ret = render->control.Stop((AudioHandle)render);
677 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
678 }
679 adapter->DestroyRender(adapter, render);
680 manager->UnloadAdapter(manager, adapter);
681 }
682 /**
683 * @tc.name Test RenderGetFrameCount API via define format to different values
684 * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0005
685 * @tc.desc Test RenderGetFrameCount interface,return 0 if get framesize define format as different values
686 */
687 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0005, Function | MediumTest | Level1)
688 {
689 int32_t ret = -1;
690 uint64_t count = 0;
691 struct AudioAdapter *adapter = nullptr;
692 struct AudioRender *render = nullptr;
693 struct AudioSampleAttributes attrs = {};
694 struct AudioSampleAttributes attrsValue = {};
695
696 TestAudioManager* manager = GetAudioManagerFuncs();
697 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
698 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
699 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 8000);
700
701 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
702 if(ret != AUDIO_HAL_SUCCESS){
703 EXPECT_TRUE(true);
704 }
705 if(ret == AUDIO_HAL_SUCCESS)
706 {
707 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
708 EXPECT_NE(AUDIO_SAMPLERATE_INVALID, attrsValue.sampleRate);
709 EXPECT_NE(AUDIO_CHANNELCOUNT_INVALID, attrsValue.channelCount);
710
711 ret = AudioRenderStartAndOneFrame(render);
712 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
713 ret = render->attr.GetFrameCount(render, &count);
714 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
715
716 ret = render->control.Stop((AudioHandle)render);
717 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
718 }
719 adapter->DestroyRender(adapter, render);
720 manager->UnloadAdapter(manager, adapter);
721 }
722 /**
723 * @tc.name Test RenderGetCurrentChannelId API via legal input
724 * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0001
725 * @tc.desc Test RenderGetCurrentChannelId, return 0 if the default CurrentChannelId is obtained successfully
726 */
727 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0001, Function | MediumTest | Level1)
728 {
729 int32_t ret = -1;
730 uint32_t channelId = 0;
731 struct AudioAdapter *adapter = nullptr;
732 struct AudioRender *render = nullptr;
733
734 TestAudioManager* manager = GetAudioManagerFuncs();
735 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
736 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
737
738 ret = render->attr.GetCurrentChannelId(render, &channelId);
739 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
740
741 adapter->DestroyRender(adapter, render);
742 manager->UnloadAdapter(manager, adapter);
743 }
744 /**
745 * @tc.name Test RenderGetCurrentChannelId API via CurrentChannelId is obtained after created
746 * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0003
747 * @tc.desc Test RenderGetCurrentChannelId interface, return 0 if CurrentChannelId is obtained after created
748 */
749 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0003, Function | MediumTest | Level1)
750 {
751 int32_t ret = -1;
752 uint32_t channelId = 0;
753 struct AudioAdapter *adapter = nullptr;
754 struct AudioRender *render = nullptr;
755
756 TestAudioManager* manager = GetAudioManagerFuncs();
757 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
758 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
759
760 ret = render->attr.GetCurrentChannelId(render, &channelId);
761 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
762
763 adapter->DestroyRender(adapter, render);
764 manager->UnloadAdapter(manager, adapter);
765 }
766 /**
767 * @tc.name Test GetCurrentChannelId API via setting the parameter render is nullptr
768 * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0004
769 * @tc.desc Test GetCurrentChannelId interface,return -1 if set the parameter render is nullptr
770 */
771 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0004, Function | MediumTest | Level1)
772 {
773 int32_t ret = -1;
774 uint32_t channelId = 0;
775 struct AudioAdapter *adapter = nullptr;
776 struct AudioRender *render = nullptr;
777 struct AudioRender *renderNull = nullptr;
778
779 TestAudioManager* manager = GetAudioManagerFuncs();
780 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
781 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
782
783 ret = render->attr.GetCurrentChannelId(renderNull, &channelId);
784 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
785
786 adapter->DestroyRender(adapter, render);
787 manager->UnloadAdapter(manager, adapter);
788 }
789 /**
790 * @tc.name Test RenderGetCurrentChannelId API via setting the parameter channelId is nullptr
791 * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0005
792 * @tc.desc Test RenderGetCurrentChannelId interface, return -1 if setting the parameter channelId is nullptr
793 */
794 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0005, Function | MediumTest | Level1)
795 {
796 int32_t ret = -1;
797 uint32_t *channelIdNull = nullptr;
798 struct AudioAdapter *adapter = nullptr;
799 struct AudioRender *render = nullptr;
800
801 TestAudioManager* manager = GetAudioManagerFuncs();
802 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
803 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
804
805 ret = render->attr.GetCurrentChannelId(render, channelIdNull);
806 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
807
808 adapter->DestroyRender(adapter, render);
809 manager->UnloadAdapter(manager, adapter);
810 }
811 /**
812 * @tc.name Test RenderSetExtraParams API via setting ExtraParams during playback
813 * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0001
814 * @tc.desc Test RenderSetExtraParams interface,return 0 if the ExtraParams is set during playback
815 */
816 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0001, Function | MediumTest | Level1)
817 {
818 int32_t ret = -1;
819 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
820 char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-sampling-rate=48000";
821 size_t index = 1;
822 char keyValueListValue[256] = {};
823 int32_t listLenth = 256;
824 struct PrepareAudioPara audiopara = {
825 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
826 .path = AUDIO_FILE.c_str()
827 };
828
829 audiopara.manager = GetAudioManagerFuncs();
830 ASSERT_NE(nullptr, audiopara.manager);
831
832 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
833 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
834 sleep(1);
835 if (audiopara.render != nullptr) {
836 ret = audiopara.render->attr.SetExtraParams((AudioHandle)audiopara.render, keyValueList);
837 if(ret != AUDIO_HAL_SUCCESS){
838 EXPECT_TRUE(true);
839 }
840 if(ret == AUDIO_HAL_SUCCESS)
841 {
842 ret = audiopara.render->attr.GetExtraParams((AudioHandle)audiopara.render, keyValueListValue, listLenth);
843 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
844 string strGetValue = keyValueListValue;
845 size_t indexAttr = strGetValue.find("attr-frame-count");
846 size_t indexFlag = strGetValue.rfind(";");
847 if (indexAttr != string::npos && indexFlag != string::npos) {
848 strGetValue.replace(indexAttr, indexFlag - indexAttr + index, "");
849 }
850 EXPECT_STREQ(keyValueListExp, strGetValue.c_str());
851 }
852 }
853
854 ret = ThreadRelease(audiopara);
855 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
856 }
857 /**
858 * @tc.name Test RenderSetExtraParams API via setting some parameters after playing
859 * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0002
860 * @tc.desc Test RenderSetExtraParams interface,return 0 if some parameters is set after playing
861 */
862 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0002, Function | MediumTest | Level1)
863 {
864 int32_t ret = -1;
865 struct AudioAdapter *adapter = {};
866 struct AudioRender *render = nullptr;
867 char keyValueListOne[] = "attr-frame-count=1024;";
868 char keyValueListOneExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=1024;\
869 attr-sampling-rate=48000";
870 char keyValueListTwo[] = "attr-format=16;attr-frame-count=1024;";
871 char keyValueListTwoExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=1024;\
872 attr-sampling-rate=48000";
873 char keyValueListThr[] = "attr-route=1;attr-channels=1;attr-frame-count=1024;";
874 char keyValueListThrExp[] = "attr-route=1;attr-format=16;attr-channels=1;attr-frame-count=1024;\
875 attr-sampling-rate=48000";
876 char keyValueListFour[] = "attr-format=32;attr-channels=2;attr-frame-count=4096;attr-sampling-rate=48000";
877 char keyValueListFourExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=4096;\
878 attr-sampling-rate=48000";
879 char keyValueListValueOne[256] = {};
880 char keyValueListValueTwo[256] = {};
881 char keyValueListValueThr[256] = {};
882 char keyValueListValueFour[256] = {};
883 int32_t listLenth = 256;
884
885 TestAudioManager* manager = GetAudioManagerFuncs();
886 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
887 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
888 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListOne);
889 if(ret != AUDIO_HAL_SUCCESS){
890 EXPECT_TRUE(true);
891 }
892 if(ret == AUDIO_HAL_SUCCESS)
893 {
894 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueOne, listLenth);
895 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
896 EXPECT_STREQ(keyValueListOneExp, keyValueListValueOne);
897 }
898 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListTwo);
899 if(ret != AUDIO_HAL_SUCCESS){
900 EXPECT_TRUE(true);
901 }
902 if(ret == AUDIO_HAL_SUCCESS)
903 {
904 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueTwo, listLenth);
905 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
906 EXPECT_STREQ(keyValueListTwoExp, keyValueListValueTwo);
907 }
908 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListThr);
909 if(ret != AUDIO_HAL_SUCCESS){
910 EXPECT_TRUE(true);
911 }
912 if(ret == AUDIO_HAL_SUCCESS)
913 {
914 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueThr, listLenth);
915 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
916 EXPECT_STREQ(keyValueListThrExp, keyValueListValueThr);
917 }
918 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListFour);
919 if(ret != AUDIO_HAL_SUCCESS){
920 EXPECT_TRUE(true);
921 }
922 if(ret == AUDIO_HAL_SUCCESS)
923 {
924 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueFour, listLenth);
925 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
926 EXPECT_STREQ(keyValueListFourExp, keyValueListValueFour);
927 }
928 ret = render->control.Stop((AudioHandle)render);
929 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
930 adapter->DestroyRender(adapter, render);
931 manager->UnloadAdapter(manager, adapter);
932 }
933 /**
934 * @tc.name Test RenderSetExtraParams API via setting keyvaluelist to a value outside the range
935 * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0003
936 * @tc.desc Test RenderSetExtraParams interface,return -1 if the Keyvaluelist is a value out of range
937 */
938 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0003, Function | MediumTest | Level1)
939 {
940 int32_t ret = -1;
941 struct AudioAdapter *adapter = {};
942 struct AudioRender *render = nullptr;
943 char keyValueList[] = "attr-para=abc;";
944
945
946 TestAudioManager* manager = GetAudioManagerFuncs();
947 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
948 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
949 ret = ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList);
950 EXPECT_NE(AUDIO_HAL_SUCCESS, ret);
951
952 adapter->DestroyRender(adapter, render);
953 manager->UnloadAdapter(manager, adapter);
954 }
955 /**
956 * @tc.name Test RenderSetExtraParams API via adding parameters to keyvaluelist
957 * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0004
958 * @tc.desc Test RenderSetExtraParams interface,return -1 if adding parameters to keyvaluelist
959 */
960 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0004, Function | MediumTest | Level1)
961 {
962 int32_t ret = -1;
963 struct AudioAdapter *adapter = {};
964 struct AudioRender *render = nullptr;
965 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000;\
966 attr-para=123";
967
968
969 TestAudioManager* manager = GetAudioManagerFuncs();
970 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
971 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
972 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList);
973 EXPECT_NE(AUDIO_HAL_SUCCESS, ret);
974
975 adapter->DestroyRender(adapter, render);
976 manager->UnloadAdapter(manager, adapter);
977 }
978 /**
979 * @tc.name Test RenderSetExtraParams API via setting ExtraParams When the key is the same and the value is
980 different
981 * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0005
982 * @tc.desc Test RenderSetExtraParams interface,return 0 if set ExtraParams When the key is the same and the value
983 is different
984 */
985 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0005, Function | MediumTest | Level1)
986 {
987 int32_t ret = -1;
988 struct AudioAdapter *adapter = {};
989 struct AudioRender *render = nullptr;
990
991 TestAudioManager* manager = GetAudioManagerFuncs();
992 char keyValueList[] = "attr-sampling-rate=48000;attr-sampling-rate=96000;attr-frame-count=4096;";
993 char keyValueListExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=4096;\
994 attr-sampling-rate=96000";
995 char keyValueListValue[256] = {};
996 int32_t listLenth = 256;
997
998 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
999 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1000 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList);
1001 if(ret != AUDIO_HAL_SUCCESS){
1002 EXPECT_TRUE(true);
1003 }
1004 if(ret == AUDIO_HAL_SUCCESS)
1005 {
1006 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValue, listLenth);
1007 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1008 EXPECT_STREQ(keyValueListExp, keyValueListValue);
1009 }
1010 ret = render->control.Stop((AudioHandle)render);
1011 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1012 adapter->DestroyRender(adapter, render);
1013 manager->UnloadAdapter(manager, adapter);
1014 }
1015 /**
1016 * @tc.name Test RenderSetExtraParams API via setting the parameter render is nullptr
1017 * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0007
1018 * @tc.desc Test RenderSetExtraParams interface,return -1 if set the parameter render is nullptr
1019 */
1020 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0007, Function | MediumTest | Level1)
1021 {
1022 int32_t ret = -1;
1023 struct AudioAdapter *adapter = {};
1024 struct AudioRender *render = nullptr;
1025 struct AudioRender *renderNull = nullptr;
1026 char keyValueList[] = "attr-format=2;";
1027
1028
1029 TestAudioManager* manager = GetAudioManagerFuncs();
1030 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
1031 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1032 ret = render->attr.SetExtraParams((AudioHandle)renderNull, keyValueList);
1033 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1034
1035 adapter->DestroyRender(adapter, render);
1036 manager->UnloadAdapter(manager, adapter);
1037 }
1038 /**
1039 * @tc.name Test RenderSetExtraParams API via setting the format of ExtraParams is nullptr
1040 * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0008
1041 * @tc.desc Test RenderSetExtraParams interface,return -1 if set the format of ExtraParams is nullptr
1042 */
1043 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0008, Function | MediumTest | Level1)
1044 {
1045 int32_t ret = -1;
1046 struct AudioAdapter *adapter = {};
1047 struct AudioRender *render = nullptr;
1048 char keyValueListNull[] = "attr-format=;";
1049
1050
1051 TestAudioManager* manager = GetAudioManagerFuncs();
1052 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
1053 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1054 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListNull);
1055 EXPECT_NE(AUDIO_HAL_SUCCESS, ret);
1056
1057 adapter->DestroyRender(adapter, render);
1058 manager->UnloadAdapter(manager, adapter);
1059 }
1060 /**
1061 * @tc.name Test RenderGetExtraParams API via legal input
1062 * @tc.number SUB_Audio_HDI_RenderGetExtraParams_0001
1063 * @tc.desc Test RenderGetExtraParams interface,return 0 if the RenderGetExtraParams was obtained successfully
1064 */
1065 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetExtraParams_0001, Function | MediumTest | Level1)
1066 {
1067 int32_t ret = -1;
1068 uint64_t count = 0;
1069 struct AudioAdapter *adapter = {};
1070 struct AudioRender *render = nullptr;
1071 struct AudioSampleAttributes attrsValue = {};
1072 char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
1073 char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\
1074 attr-sampling-rate=48000";
1075 char keyValueListValue[256] = {};
1076 int32_t listLenth = 256;
1077 int32_t formatExp = 3;
1078 uint32_t sampleRateExp = 48000;
1079 uint32_t channelCountExp = 2;
1080 uint32_t frameCountExp = 4096;
1081
1082
1083 TestAudioManager* manager = GetAudioManagerFuncs();
1084 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
1085 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1086 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList);
1087 if(ret != AUDIO_HAL_SUCCESS){
1088 EXPECT_TRUE(true);
1089 }
1090 if(ret == AUDIO_HAL_SUCCESS)
1091 {
1092 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValue, listLenth);
1093 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1094 EXPECT_STREQ(keyValueListExp, keyValueListValue);
1095
1096 ret = render->attr.GetSampleAttributes(render, &attrsValue);
1097 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1098 EXPECT_EQ(formatExp, attrsValue.format);
1099 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1100 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1101 ret = render->attr.GetFrameCount(render, &count);
1102 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1103 EXPECT_EQ(count, frameCountExp);
1104 }
1105 ret = render->control.Stop((AudioHandle)render);
1106 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1107 adapter->DestroyRender(adapter, render);
1108 manager->UnloadAdapter(manager, adapter);
1109 }
1110 /**
1111 * @tc.name Test RenderGetExtraParams API via setting the parameter render is nullptr
1112 * @tc.number SUB_Audio_HDI_RenderGetExtraParams_0002
1113 * @tc.desc Test RenderGetExtraParams interface,return -1 if set the parameter render is nullptr
1114 */
1115 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetExtraParams_0002, Function | MediumTest | Level1)
1116 {
1117 int32_t ret = -1;
1118 struct AudioAdapter *adapter = {};
1119 struct AudioRender *render = nullptr;
1120 struct AudioRender *renderNull = nullptr;
1121 char keyValueList[] = "attr-format=32;";
1122 char keyValueListValue[256] = {};
1123 int32_t listLenth = 256;
1124
1125
1126 TestAudioManager* manager = GetAudioManagerFuncs();
1127 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
1128 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1129 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList);
1130 if(ret != AUDIO_HAL_SUCCESS){
1131 EXPECT_TRUE(true);
1132 }
1133 if(ret == AUDIO_HAL_SUCCESS)
1134 {
1135 ret = render->attr.GetExtraParams((AudioHandle)renderNull, keyValueListValue, listLenth);
1136 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1137 }
1138 adapter->DestroyRender(adapter, render);
1139 manager->UnloadAdapter(manager, adapter);
1140 }
1141 /**
1142 * @tc.name Test RenderGetExtraParams API via setting listlength to be less than the actual length
1143 * @tc.number SUB_Audio_HDI_RenderGetExtraParams_0003
1144 * @tc.desc Test RenderGetExtraParams interface,return -1 if set listlength to be less than the actual length
1145 */
1146 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetExtraParams_0003, Function | MediumTest | Level1)
1147 {
1148 int32_t ret = -1;
1149 struct AudioAdapter *adapter = {};
1150 struct AudioRender *render = nullptr;
1151 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000;";
1152 char keyValueListValue[256] = {};
1153 int32_t listLenth = 8;
1154
1155
1156 TestAudioManager* manager = GetAudioManagerFuncs();
1157 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
1158 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1159 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList);
1160 if(ret != AUDIO_HAL_SUCCESS){
1161 EXPECT_TRUE(true);
1162 }
1163 if(ret == AUDIO_HAL_SUCCESS)
1164 {
1165 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValue, listLenth);
1166 EXPECT_NE(AUDIO_HAL_SUCCESS, ret);
1167 }
1168 adapter->DestroyRender(adapter, render);
1169 manager->UnloadAdapter(manager, adapter);
1170 }
1171 /**
1172 * @tc.name Test RenderGetExtraParams API via setting listlenth equal to the actual length
1173 * @tc.number SUB_Audio_HDI_RenderGetExtraParams_0004
1174 * @tc.desc Test RenderGetExtraParams interface,return 0 if set listlenth equal to the actual length
1175 */
1176 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetExtraParams_0004, Function | MediumTest | Level1)
1177 {
1178 int32_t ret = -1;
1179 struct AudioAdapter *adapter = {};
1180 struct AudioRender *render = nullptr;
1181 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=11111111111111111111;\
1182 attr-sampling-rate=48000";
1183 char keyValueListValue[256] = {};
1184 int32_t listLenth = 107;
1185
1186
1187 TestAudioManager* manager = GetAudioManagerFuncs();
1188 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
1189 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1190 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList);
1191 if(ret != AUDIO_HAL_SUCCESS){
1192 EXPECT_TRUE(true);
1193 }
1194 if(ret == AUDIO_HAL_SUCCESS)
1195 {
1196 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValue, listLenth);
1197 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1198 EXPECT_STREQ(keyValueList, keyValueListValue);
1199 }
1200 ret = render->control.Stop((AudioHandle)render);
1201 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1202 adapter->DestroyRender(adapter, render);
1203 manager->UnloadAdapter(manager, adapter);
1204 }
1205 /**
1206 * @tc.name Test RenderAddAudioEffect API via legal input
1207 * @tc.number SUB_Audio_HDI_RenderAddAudioEffect_0001
1208 * @tc.desc Test RenderAddAudioEffect interface,return 0 if set the legal parameter
1209 */
1210 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderAddAudioEffect_0001, TestSize.Level1)
1211 {
1212 int32_t ret = -1;
1213 struct AudioAdapter *adapter = nullptr;
1214 struct AudioRender *render = nullptr;
1215 uint64_t effectid = 14;
1216
1217 TestAudioManager* manager = GetAudioManagerFuncs();
1218 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
1219 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1220 ret = render->attr.AddAudioEffect((AudioHandle)render, effectid);
1221 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT) ||
1222 (ret == AUDIO_HAL_ERR_INVALID_PARAM) || (ret == AUDIO_HAL_ERR_INTERNAL)){
1223 EXPECT_TRUE(true);
1224 }else{
1225 EXPECT_TRUE(false);
1226 }
1227
1228 adapter->DestroyRender(adapter, render);
1229 manager->UnloadAdapter(manager, adapter);
1230 }
1231 /**
1232 * @tc.name Test RenderAddAudioEffect API via setting the parameter render is nullptr
1233 * @tc.number SUB_Audio_HDI_RenderAddAudioEffect_0001
1234 * @tc.desc Test RenderAddAudioEffect interface,return -3 if set the parameter render is nullptr
1235 */
1236 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderAddAudioEffect_0002, TestSize.Level1)
1237 {
1238 int32_t ret = -1;
1239 struct AudioAdapter *adapter = nullptr;
1240 struct AudioRender *render = nullptr;
1241 struct AudioRender *renderNull = nullptr;
1242 uint64_t effectid = 14;
1243
1244 TestAudioManager* manager = GetAudioManagerFuncs();
1245 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
1246 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1247 ret = render->attr.AddAudioEffect((AudioHandle)renderNull, effectid);
1248 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT) || (ret == AUDIO_HAL_ERR_INVALID_PARAM)){
1249 EXPECT_TRUE(true);
1250 }else{
1251 EXPECT_TRUE(false);
1252 }
1253 adapter->DestroyRender(adapter, render);
1254 manager->UnloadAdapter(manager, adapter);
1255 }
1256 /**
1257 * @tc.name Test RenderAddAudioEffect API via legal input
1258 * @tc.number SUB_Audio_HDI_RenderRemoveAudioEffect_0001
1259 * @tc.desc Test RenderAddAudioEffect interface,return -3 if set the legal parameter
1260 */
1261 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderRemoveAudioEffect_0001, TestSize.Level1)
1262 {
1263 int32_t ret = -1;
1264 struct AudioAdapter *adapter = nullptr;
1265 struct AudioRender *render = nullptr;
1266 uint64_t effectid = 14;
1267
1268 TestAudioManager* manager = GetAudioManagerFuncs();
1269 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
1270 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1271 ret = render->attr.AddAudioEffect((AudioHandle)render, effectid);
1272 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT) ||
1273 (ret == AUDIO_HAL_ERR_INVALID_PARAM) || (ret == AUDIO_HAL_ERR_INTERNAL)){
1274 EXPECT_TRUE(true);
1275 }else{
1276 EXPECT_TRUE(false);
1277 }
1278 ret = render->attr.RemoveAudioEffect((AudioHandle)render, effectid);
1279 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT) ||
1280 (ret == AUDIO_HAL_ERR_INVALID_PARAM) || (ret == AUDIO_HAL_ERR_INTERNAL)){
1281 EXPECT_TRUE(true);
1282 }else{
1283 EXPECT_TRUE(false);
1284 }
1285
1286 adapter->DestroyRender(adapter, render);
1287 manager->UnloadAdapter(manager, adapter);
1288 }
1289 /**
1290 * @tc.name Test RenderAddAudioEffect API via setting the parameter render is nullptr
1291 * @tc.number SUB_Audio_HDI_RenderAddAudioEffect_0002
1292 * @tc.desc Test RenderAddAudioEffect interface,return -3 if setting the parameter render is nullptr
1293 */
1294 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderRemoveAudioEffect_0002, TestSize.Level1)
1295 {
1296 int32_t ret = -1;
1297 struct AudioAdapter *adapter = nullptr;
1298 struct AudioRender *render = nullptr;
1299 struct AudioRender *renderNull = nullptr;
1300 uint64_t effectid = 14;
1301
1302 TestAudioManager* manager = GetAudioManagerFuncs();
1303 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
1304 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1305 ret = render->attr.RemoveAudioEffect((AudioHandle)renderNull, effectid);
1306 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT) ||
1307 (ret == AUDIO_HAL_ERR_INVALID_PARAM) || (ret == AUDIO_HAL_ERR_INTERNAL)){
1308 EXPECT_TRUE(true);
1309 }else{
1310 EXPECT_TRUE(false);
1311 }
1312
1313 adapter->DestroyRender(adapter, render);
1314 manager->UnloadAdapter(manager, adapter);
1315 }
1316 }