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 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 HMOS::Audio;
42
43 namespace {
44 const string ADAPTER_NAME_USB = "usb";
45 const string ADAPTER_NAME_INTERNAL = "internal";
46
47 class AudioHdiRenderAttrTest : public testing::Test {
48 public:
49 static void SetUpTestCase(void);
50 static void TearDownTestCase(void);
51 void SetUp();
52 void TearDown();
53 static TestAudioManager *(*GetAudioManager)();
54 static void *handleSo;
55 #ifdef AUDIO_MPI_SO
56 static int32_t (*SdkInit)();
57 static void (*SdkExit)();
58 static void *sdkSo;
59 #endif
60 };
61
62 using THREAD_FUNC = void *(*)(void *);
63
64 TestAudioManager *(*AudioHdiRenderAttrTest::GetAudioManager)() = nullptr;
65 void *AudioHdiRenderAttrTest::handleSo = nullptr;
66 #ifdef AUDIO_MPI_SO
67 int32_t (*AudioHdiRenderAttrTest::SdkInit)() = nullptr;
68 void (*AudioHdiRenderAttrTest::SdkExit)() = nullptr;
69 void *AudioHdiRenderAttrTest::sdkSo = nullptr;
70 #endif
71
SetUpTestCase(void)72 void AudioHdiRenderAttrTest::SetUpTestCase(void)
73 {
74 #ifdef AUDIO_MPI_SO
75 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
76 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
77 if (sdkSo == nullptr) {
78 return;
79 }
80 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
81 if (SdkInit == nullptr) {
82 return;
83 }
84 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
85 if (SdkExit == nullptr) {
86 return;
87 }
88 SdkInit();
89 #endif
90 char absPath[PATH_MAX] = {0};
91 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
92 return;
93 }
94 handleSo = dlopen(absPath, RTLD_LAZY);
95 if (handleSo == nullptr) {
96 return;
97 }
98 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
99 if (GetAudioManager == nullptr) {
100 return;
101 }
102 }
103
TearDownTestCase(void)104 void AudioHdiRenderAttrTest::TearDownTestCase(void)
105 {
106 #ifdef AUDIO_MPI_SO
107 SdkExit();
108 if (sdkSo != nullptr) {
109 dlclose(sdkSo);
110 sdkSo = nullptr;
111 }
112 if (SdkInit != nullptr) {
113 SdkInit = nullptr;
114 }
115 if (SdkExit != nullptr) {
116 SdkExit = nullptr;
117 }
118 #endif
119 if (handleSo != nullptr) {
120 dlclose(handleSo);
121 handleSo = nullptr;
122 }
123 if (GetAudioManager != nullptr) {
124 GetAudioManager = nullptr;
125 }
126 }
SetUp(void)127 void AudioHdiRenderAttrTest::SetUp(void) {}
TearDown(void)128 void AudioHdiRenderAttrTest::TearDown(void) {}
129
130 /**
131 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
132 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0001
133 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
134 * attrs.type = AUDIO_IN_MEDIA;
135 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
136 * attrs.sampleRate = AUDIO_SAMPLE_RATE_MASK_8000;
137 * attrs.channelCount = 1;
138 * @tc.author: ZHANGHAILIN
139 */
140 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0001, TestSize.Level1)
141 {
142 int32_t ret = -1;
143 uint32_t ret1 = 1;
144 uint32_t ret2 = 8000;
145 struct AudioAdapter *adapter = nullptr;
146 struct AudioRender *render = nullptr;
147 struct AudioSampleAttributes attrs = {};
148 struct AudioSampleAttributes attrsValue = {};
149 ASSERT_NE(nullptr, GetAudioManager);
150 TestAudioManager* manager = GetAudioManager();
151 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
152 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
153 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 8000);
154
155 ret = render->attr.SetSampleAttributes(render, &attrs);
156 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
157 ret = render->attr.GetSampleAttributes(render, &attrsValue);
158 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
159
160 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
161 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
162 EXPECT_EQ(ret2, attrsValue.sampleRate);
163 EXPECT_EQ(ret1, attrsValue.channelCount);
164
165 adapter->DestroyRender(adapter, render);
166 manager->UnloadAdapter(manager, adapter);
167 }
168 /**
169 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
170 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0002
171 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
172 * attrs.type = AUDIO_IN_MEDIA;
173 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
174 * attrs.sampleRate = 11025;
175 * attrs.channelCount = 2;
176 * @tc.author: ZHANGHAILIN
177 */
178 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0002, TestSize.Level1)
179 {
180 int32_t ret = -1;
181 uint32_t ret1 = 11025;
182 uint32_t ret2 = 2;
183 struct AudioAdapter *adapter = nullptr;
184 struct AudioRender *render = nullptr;
185 struct AudioSampleAttributes attrs = {};
186 struct AudioSampleAttributes attrsValue = {};
187 ASSERT_NE(nullptr, GetAudioManager);
188 TestAudioManager* manager = GetAudioManager();
189 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
190 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
191 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 11025);
192
193 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
194 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
195
196 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
197 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
198 EXPECT_EQ(ret1, attrsValue.sampleRate);
199 EXPECT_EQ(ret2, attrsValue.channelCount);
200
201 adapter->DestroyRender(adapter, render);
202 manager->UnloadAdapter(manager, adapter);
203 }
204 /**
205 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
206 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0003
207 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
208 * attrs.type = AUDIO_IN_MEDIA;
209 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
210 * attrs.sampleRate = 22050;
211 * attrs.channelCount = 1;
212 * @tc.author: ZHANGHAILIN
213 */
214 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0003, TestSize.Level1)
215 {
216 int32_t ret = -1;
217 uint32_t ret1 = 22050;
218 uint32_t ret2 = 2;
219 struct AudioAdapter *adapter = nullptr;
220 struct AudioRender *render = nullptr;
221 struct AudioSampleAttributes attrs = {};
222 struct AudioSampleAttributes attrsValue = {};
223 ASSERT_NE(nullptr, GetAudioManager);
224 TestAudioManager* manager = GetAudioManager();
225 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
226 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
227 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 22050);
228
229 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
230 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
231
232 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
233 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
234 EXPECT_EQ(ret1, attrsValue.sampleRate);
235 EXPECT_EQ(ret2, attrsValue.channelCount);
236
237 adapter->DestroyRender(adapter, render);
238 manager->UnloadAdapter(manager, adapter);
239 }
240 /**
241 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
242 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0004
243 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
244 * attrs.type = AUDIO_IN_MEDIA;
245 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
246 * attrs.sampleRate = 32000;
247 * attrs.channelCount = 2;
248 * @tc.author: ZHANGHAILIN
249 */
250 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0004, TestSize.Level1)
251 {
252 int32_t ret = -1;
253 uint32_t ret1 = 32000;
254 uint32_t ret2 = 2;
255 struct AudioAdapter *adapter = nullptr;
256 struct AudioRender *render = nullptr;
257 struct AudioSampleAttributes attrs = {};
258 struct AudioSampleAttributes attrsValue = {};
259 ASSERT_NE(nullptr, GetAudioManager);
260 TestAudioManager* manager = GetAudioManager();
261 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
262 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
263 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 32000);
264
265 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
266 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
267
268 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
269 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
270 EXPECT_EQ(ret1, attrsValue.sampleRate);
271 EXPECT_EQ(ret2, attrsValue.channelCount);
272
273 adapter->DestroyRender(adapter, render);
274 manager->UnloadAdapter(manager, adapter);
275 }
276 /**
277 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
278 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0005
279 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
280 * attrs.type = AUDIO_IN_MEDIA;
281 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
282 * attrs.sampleRate = 44100;
283 * attrs.channelCount = 1;
284 * @tc.author: ZHANGHAILIN
285 */
286 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0005, TestSize.Level1)
287 {
288 int32_t ret = -1;
289 uint32_t ret1 = 44100;
290 uint32_t ret2 = 1;
291 struct AudioAdapter *adapter = nullptr;
292 struct AudioRender *render = nullptr;
293 struct AudioSampleAttributes attrs = {};
294 struct AudioSampleAttributes attrsValue = {};
295 ASSERT_NE(nullptr, GetAudioManager);
296 TestAudioManager* manager = GetAudioManager();
297 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
298 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
299 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 44100);
300
301 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
302 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
303
304 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
305 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
306 EXPECT_EQ(ret1, attrsValue.sampleRate);
307 EXPECT_EQ(ret2, attrsValue.channelCount);
308
309 adapter->DestroyRender(adapter, render);
310 manager->UnloadAdapter(manager, adapter);
311 }
312 /**
313 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
314 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
315 * attrs.type = AUDIO_IN_COMMUNICATION;
316 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
317 * attrs.sampleRate = 48000;
318 * attrs.channelCount = 2;
319 * @tc.author: ZHANGHAILIN
320 */
321 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0006, TestSize.Level1)
322 {
323 int32_t ret = -1;
324 uint32_t ret1 = 48000;
325 uint32_t ret2 = 2;
326 struct AudioAdapter *adapter = nullptr;
327 struct AudioRender *render = nullptr;
328 struct AudioSampleAttributes attrs = {};
329 struct AudioSampleAttributes attrsValue = {};
330 ASSERT_NE(nullptr, GetAudioManager);
331 TestAudioManager* manager = GetAudioManager();
332 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
333 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
334 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 48000);
335
336 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
337 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
338
339 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
340 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
341 EXPECT_EQ(ret1, attrsValue.sampleRate);
342 EXPECT_EQ(ret2, attrsValue.channelCount);
343
344 adapter->DestroyRender(adapter, render);
345 manager->UnloadAdapter(manager, adapter);
346 }
347 /**
348 * @tc.name Test AudioRenderSetSampleAttributes API via setting the render is empty .
349 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0007
350 * @tc.desc Test AudioRenderSetSampleAttributes interface, return -1 if the render is empty.
351 * @tc.author: ZHANGHAILIN
352 */
353 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0007, TestSize.Level1)
354 {
355 int32_t ret = -1;
356 struct AudioAdapter *adapter = nullptr;
357 struct AudioRender *render = nullptr;
358 struct AudioRender *renderNull = nullptr;
359 struct AudioSampleAttributes attrs = {};
360 ASSERT_NE(nullptr, GetAudioManager);
361 TestAudioManager* manager = GetAudioManager();
362 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
363 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
364 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 8000);
365
366 ret = render->attr.SetSampleAttributes(renderNull, &attrs);
367 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
368 ret = render->attr.SetSampleAttributes(render, nullptr);
369 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
370
371 adapter->DestroyRender(adapter, render);
372 manager->UnloadAdapter(manager, adapter);
373 }
374 /**
375 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
376 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0008
377 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
378 * attrs.type = AUDIO_IN_MEDIA;
379 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
380 * attrs.sampleRate = 12000;
381 * attrs.channelCount = 1;
382 * @tc.author: ZHANGHAILIN
383 */
384 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0008, TestSize.Level1)
385 {
386 int32_t ret = -1;
387 uint32_t ret1 = 1;
388 uint32_t ret2 = 12000;
389 struct AudioAdapter *adapter = nullptr;
390 struct AudioRender *render = nullptr;
391 struct AudioSampleAttributes attrs = {};
392 struct AudioSampleAttributes attrsValue = {};
393 ASSERT_NE(nullptr, GetAudioManager);
394 TestAudioManager* manager = GetAudioManager();
395 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
396 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
397 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 12000);
398
399 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
400 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
401
402 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
403 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
404 EXPECT_EQ(ret2, attrsValue.sampleRate);
405 EXPECT_EQ(ret1, attrsValue.channelCount);
406
407 adapter->DestroyRender(adapter, render);
408 manager->UnloadAdapter(manager, adapter);
409 }
410 /**
411 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
412 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0009
413 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
414 * attrs.type = AUDIO_IN_MEDIA;
415 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
416 * attrs.sampleRate = 16000;
417 * attrs.channelCount = 1;
418 * @tc.author: ZHANGHAILIN
419 */
420 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0009, TestSize.Level1)
421 {
422 int32_t ret = -1;
423 uint32_t ret1 = 1;
424 uint32_t ret2 = 16000;
425 struct AudioAdapter *adapter = nullptr;
426 struct AudioRender *render = nullptr;
427 struct AudioSampleAttributes attrs = {};
428 struct AudioSampleAttributes attrsValue = {};
429 ASSERT_NE(nullptr, GetAudioManager);
430 TestAudioManager* manager = GetAudioManager();
431 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
432 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
433 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 16000);
434 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
435 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
436
437 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
438 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
439 EXPECT_EQ(ret2, attrsValue.sampleRate);
440 EXPECT_EQ(ret1, attrsValue.channelCount);
441
442 adapter->DestroyRender(adapter, render);
443 manager->UnloadAdapter(manager, adapter);
444 }
445 /**
446 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
447 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0010
448 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
449 * attrs.type = AUDIO_IN_MEDIA;
450 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
451 * attrs.sampleRate = 24000;
452 * attrs.channelCount = 2;
453 * @tc.author: ZHANGHAILIN
454 */
455 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0010, TestSize.Level1)
456 {
457 int32_t ret = -1;
458 uint32_t ret1 = 2;
459 uint32_t ret2 = 24000;
460 struct AudioAdapter *adapter = nullptr;
461 struct AudioRender *render = nullptr;
462 struct AudioSampleAttributes attrs = {};
463 struct AudioSampleAttributes attrsValue = {};
464 ASSERT_NE(nullptr, GetAudioManager);
465 TestAudioManager* manager = GetAudioManager();
466 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
467 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
468
469 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 24000);
470 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
471 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
472
473 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
474 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
475 EXPECT_EQ(ret2, attrsValue.sampleRate);
476 EXPECT_EQ(ret1, attrsValue.channelCount);
477
478 adapter->DestroyRender(adapter, render);
479 manager->UnloadAdapter(manager, adapter);
480 }
481 /**
482 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
483 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0011
484 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
485 * attrs.type = AUDIO_IN_MEDIA;
486 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
487 * attrs.sampleRate = 64000;
488 * attrs.channelCount = 2;
489 * @tc.author: ZHANGHAILIN
490 */
491 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0011, TestSize.Level1)
492 {
493 int32_t ret = -1;
494 uint32_t ret1 = 2;
495 uint32_t ret2 = 64000;
496 struct AudioAdapter *adapter = nullptr;
497 struct AudioRender *render = nullptr;
498 struct AudioSampleAttributes attrs = {};
499 struct AudioSampleAttributes attrsValue = {};
500 ASSERT_NE(nullptr, GetAudioManager);
501 TestAudioManager* manager = GetAudioManager();
502 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
503 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
504 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 64000);
505
506 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
507 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
508
509 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
510 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
511 EXPECT_EQ(ret2, attrsValue.sampleRate);
512 EXPECT_EQ(ret1, attrsValue.channelCount);
513
514 adapter->DestroyRender(adapter, render);
515 manager->UnloadAdapter(manager, adapter);
516 }
517 /**
518 * @tc.name Test AudioRenderSetSampleAttributes API via legal input.
519 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0012
520 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
521 * attrs.type = AUDIO_IN_MEDIA;
522 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
523 * attrs.sampleRate = 96000;
524 * attrs.channelCount = 1;
525 * @tc.author: ZHANGHAILIN
526 */
527 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0012, TestSize.Level1)
528 {
529 int32_t ret = -1;
530 uint32_t ret1 = 1;
531 uint32_t ret2 = 96000;
532 struct AudioAdapter *adapter = nullptr;
533 struct AudioRender *render = nullptr;
534 struct AudioSampleAttributes attrs = {};
535 struct AudioSampleAttributes attrsValue = {};
536 ASSERT_NE(nullptr, GetAudioManager);
537 TestAudioManager* manager = GetAudioManager();
538 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
539 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
540 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 96000);
541
542 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
543 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
544
545 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
546 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
547 EXPECT_EQ(ret2, attrsValue.sampleRate);
548 EXPECT_EQ(ret1, attrsValue.channelCount);
549
550 adapter->DestroyRender(adapter, render);
551 manager->UnloadAdapter(manager, adapter);
552 }
553 /**
554 * @tc.name Test AudioRenderSetSampleAttributes API via illegal input.
555 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0013
556 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
557 * attrs.type = AUDIO_IN_MEDIA;
558 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
559 * attrs.sampleRate = 0xFFFFFFFFu;
560 * attrs.channelCount = 2;
561 * @tc.author: ZHANGHAILIN
562 */
563 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0013, TestSize.Level1)
564 {
565 int32_t ret = -1;
566 struct AudioAdapter *adapter = nullptr;
567 struct AudioRender *render = nullptr;
568 struct AudioSampleAttributes attrs = {};
569 ASSERT_NE(nullptr, GetAudioManager);
570 TestAudioManager* manager = GetAudioManager();
571 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
572 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
573 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 0xFFFFFFFFu);
574
575 ret = render->attr.SetSampleAttributes(render, &attrs);
576 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
577
578 adapter->DestroyRender(adapter, render);
579 manager->UnloadAdapter(manager, adapter);
580 }
581 /**
582 * @tc.name Test AudioRenderSetSampleAttributes API via illegal input.
583 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0014
584 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
585 * attrs.type = AUDIO_IN_MEDIA;
586 * attrs.format = AUDIO_FORMAT_PCM_8/32_BIT/AAC_MAIN;
587 * attrs.sampleRate = 8000/11025/22050;
588 * attrs.channelCount = 1/2;
589 * @tc.author: ZHANGHAILIN
590 */
591 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0014, TestSize.Level1)
592 {
593 int32_t ret = -1;
594 struct AudioAdapter *adapter = nullptr;
595 struct AudioRender *render = nullptr;
596 struct AudioSampleAttributes attrs1 = {};
597 struct AudioSampleAttributes attrs2 = {};
598 struct AudioSampleAttributes attrs3 = {};
599 ASSERT_NE(nullptr, GetAudioManager);
600 TestAudioManager* manager = GetAudioManager();
601
602 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
603 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
604
605 InitAttrsUpdate(attrs1, AUDIO_FORMAT_PCM_8_BIT, 1, 8000);
606 ret = render->attr.SetSampleAttributes(render, &attrs1);
607 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
608
609 InitAttrsUpdate(attrs2, AUDIO_FORMAT_PCM_32_BIT, 2, 11025);
610 ret = render->attr.SetSampleAttributes(render, &attrs2);
611 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
612
613 InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_MAIN, 1, 22050);
614 ret = render->attr.SetSampleAttributes(render, &attrs3);
615 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
616
617 adapter->DestroyRender(adapter, render);
618 manager->UnloadAdapter(manager, adapter);
619 }
620 /**
621 * @tc.name Test AudioRenderSetSampleAttributes API via illegal input.
622 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0015
623 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
624 * attrs.type = AUDIO_IN_MEDIA;
625 * attrs.format = AUDIO_FORMAT_AAC_LC/LD/ELD;
626 * attrs.sampleRate = 32000/44100/48000;
627 * attrs.channelCount = 1/2;
628 * @tc.author: ZHANGHAILIN
629 */
630 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0015, TestSize.Level1)
631 {
632 int32_t ret = -1;
633 struct AudioAdapter *adapter = nullptr;
634 struct AudioRender *render = nullptr;
635 struct AudioSampleAttributes attrs1 = {};
636 struct AudioSampleAttributes attrs2 = {};
637 struct AudioSampleAttributes attrs3 = {};
638 ASSERT_NE(nullptr, GetAudioManager);
639 TestAudioManager* manager = GetAudioManager();
640
641 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
642 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
643 InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_LC, 2, 32000);
644 ret = render->attr.SetSampleAttributes(render, &attrs1);
645 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
646
647 InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_LD, 1, 44100);
648 ret = render->attr.SetSampleAttributes(render, &attrs2);
649 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
650
651 InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_ELD, 2, 48000);
652 ret = render->attr.SetSampleAttributes(render, &attrs3);
653 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
654
655 adapter->DestroyRender(adapter, render);
656 manager->UnloadAdapter(manager, adapter);
657 }
658 /**
659 * @tc.name Test AudioRenderSetSampleAttributes API via illegal input.
660 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0016
661 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
662 * attrs.type = AUDIO_IN_MEDIA;
663 * attrs.format = AUDIO_FORMAT_AAC_HE_V1/V2
664 * attrs.sampleRate = 8000/44100;
665 * attrs.channelCount = 1/2;
666 * @tc.author: ZHANGHAILIN
667 */
668 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0016, TestSize.Level1)
669 {
670 int32_t ret = -1;
671 struct AudioAdapter *adapter = nullptr;
672 struct AudioRender *render = nullptr;
673 struct AudioSampleAttributes attrs1 = {};
674 struct AudioSampleAttributes attrs2 = {};
675 ASSERT_NE(nullptr, GetAudioManager);
676 TestAudioManager* manager = GetAudioManager();
677 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
678 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
679
680 InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_HE_V1, 1, 8000);
681 ret = render->attr.SetSampleAttributes(render, &attrs1);
682 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
683
684 InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_HE_V2, 2, 44100);
685 ret = render->attr.SetSampleAttributes(render, &attrs2);
686 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
687
688 adapter->DestroyRender(adapter, render);
689 manager->UnloadAdapter(manager, adapter);
690 }
691 /**
692 * @tc.name Test AudioRenderSetSampleAttributes API via illegal input.
693 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_0017
694 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
695 * attrs.type = AUDIO_IN_MEDIA;
696 * attrs.format = AUDIO_FORMAT_PCM_16_BIT
697 * attrs.sampleRate = 8000;
698 * attrs.channelCount = 5;
699 * @tc.author: ZHANGHAILIN
700 */
701 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_0017, TestSize.Level1)
702 {
703 int32_t ret = -1;
704 struct AudioAdapter *adapter = nullptr;
705 struct AudioRender *render = nullptr;
706 struct AudioSampleAttributes attrs = {};
707 ASSERT_NE(nullptr, GetAudioManager);
708 TestAudioManager* manager = GetAudioManager();
709 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
710 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
711
712 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 5, 8000);
713 ret = render->attr.SetSampleAttributes(render, &attrs);
714 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
715
716 adapter->DestroyRender(adapter, render);
717 manager->UnloadAdapter(manager, adapter);
718 }
719 /**
720 * @tc.name Test AudioRenderGetSampleAttributes API via legal input.
721 * @tc.number SUB_Audio_HDI_AudioRenderGetSampleAttributes_0001
722 * @tc.desc Test AudioRenderGetSampleAttributes ,the setting parameters are as follows.
723 * attrs.type = AUDIO_IN_MEDIA;
724 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
725 * attrs.sampleRate = 8000;
726 * attrs.channelCount = 1;
727 * @tc.author: ZHANGHAILIN
728 */
729 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderGetSampleAttributes_0001, TestSize.Level1)
730 {
731 int32_t ret = -1;
732 uint32_t ret1 = 8000;
733 uint32_t ret2 = 1;
734 struct AudioAdapter *adapter = nullptr;
735 struct AudioRender *render = nullptr;
736 struct AudioSampleAttributes attrs = {};
737 struct AudioSampleAttributes attrsValue = {};
738 ASSERT_NE(nullptr, GetAudioManager);
739 TestAudioManager* manager = GetAudioManager();
740 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
741 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
742
743 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 8000);
744 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
745 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
746
747 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
748 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
749 EXPECT_EQ(ret1, attrsValue.sampleRate);
750 EXPECT_EQ(ret2, attrsValue.channelCount);
751
752 adapter->DestroyRender(adapter, render);
753 manager->UnloadAdapter(manager, adapter);
754 }
755 /**
756 * @tc.name Test AudioRendereGetSampleAttributes API via setting the render is empty .
757 * @tc.number SUB_Audio_HDI_AudioRenderGetSampleAttributes_0002
758 * @tc.desc Test AudioRendereGetSampleAttributes interface, return -1 if the render is empty.
759 * @tc.author: ZHANGHAILIN
760 */
761 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_AudioRenderGetSampleAttributes_0002, TestSize.Level1)
762 {
763 int32_t ret = -1;
764 struct AudioAdapter *adapter = nullptr;
765 struct AudioRender *render = nullptr;
766 struct AudioRender *renderNull = nullptr;
767 struct AudioSampleAttributes attrs = {};
768 struct AudioSampleAttributes *attrsValue = nullptr;
769 ASSERT_NE(nullptr, GetAudioManager);
770 TestAudioManager* manager = GetAudioManager();
771 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
772 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
773 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 44100);
774
775 ret = render->attr.GetSampleAttributes(renderNull, &attrs);
776 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
777 ret = render->attr.GetSampleAttributes(render, attrsValue);
778 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
779
780 adapter->DestroyRender(adapter, render);
781 manager->UnloadAdapter(manager, adapter);
782 }
783 /**
784 * @tc.name Test RenderGetFrameSize API via legal input
785 * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0001
786 * @tc.desc Test RenderGetFrameSize interface,return 0 if the FrameSize was obtained successfully
787 * @tc.author: tiansuli
788 */
789 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0001, TestSize.Level1)
790 {
791 int32_t ret = -1;
792 uint64_t size = 0;
793 uint64_t zero = 0;
794 struct AudioAdapter *adapter = nullptr;
795 struct AudioRender *render = nullptr;
796 ASSERT_NE(nullptr, GetAudioManager);
797 TestAudioManager* manager = GetAudioManager();
798 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
799 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
800
801 ret = render->attr.GetFrameSize(render, &size);
802 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
803 EXPECT_GT(size, zero);
804
805 adapter->DestroyRender(adapter, render);
806 manager->UnloadAdapter(manager, adapter);
807 }
808 /**
809 * @tc.name Test AudioCaptureGetFrameSize API via setting the incoming parameter handle is nullptr
810 * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0002
811 * @tc.desc Test RenderGetFrameSize interface,return -1 if failed to get the FrameSize when handle is nullptr
812 * @tc.author: tiansuli
813 */
814 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0002, TestSize.Level1)
815 {
816 int32_t ret = -1;
817 uint64_t size = 0;
818 struct AudioAdapter *adapter = nullptr;
819 struct AudioRender *render = nullptr;
820 struct AudioRender *renderNull = nullptr;
821 ASSERT_NE(nullptr, GetAudioManager);
822 TestAudioManager* manager = GetAudioManager();
823 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
824 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
825
826 ret = render->attr.GetFrameSize(renderNull, &size);
827 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
828
829 adapter->DestroyRender(adapter, render);
830 manager->UnloadAdapter(manager, adapter);
831 }
832 /**
833 * @tc.name Test RenderGetFrameSize API setting the incoming parameter FrameSize is nullptr
834 * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0003
835 * @tc.desc Test RenderGetFrameSize interface,return -1 if failed to get the FrameSize when size is nullptr
836 * @tc.author: tiansuli
837 */
838 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0003, TestSize.Level1)
839 {
840 int32_t ret = -1;
841 uint64_t *sizeNull = nullptr;
842 struct AudioAdapter *adapter = nullptr;
843 struct AudioRender *render = nullptr;
844 ASSERT_NE(nullptr, GetAudioManager);
845 TestAudioManager* manager = GetAudioManager();
846 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
847 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
848
849 ret = render->attr.GetFrameSize(render, sizeNull);
850 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
851
852 adapter->DestroyRender(adapter, render);
853 manager->UnloadAdapter(manager, adapter);
854 }
855 /**
856 * @tc.name Test RenderGetFrameSize API via define format to different values
857 * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0004
858 * @tc.desc Test RenderGetFrameSize interface,return 0 if get framesize define format as different values
859 * @tc.author: tiansuli
860 */
861 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0004, TestSize.Level1)
862 {
863 int32_t ret = -1;
864 uint64_t size = 0;
865 uint64_t channelCountExp = 2;
866 uint32_t sampleRateExp = 48000;
867 struct AudioSampleAttributes attrs = {};
868 struct AudioSampleAttributes attrsValue = {};
869 struct AudioAdapter *adapter = nullptr;
870 struct AudioRender *render = nullptr;
871 ASSERT_NE(nullptr, GetAudioManager);
872 TestAudioManager* manager = GetAudioManager();
873 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
874 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
875 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 48000);
876
877 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
878 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
879 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
880 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
881 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
882
883 ret = render->attr.GetFrameSize(render, &size);
884 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
885 EXPECT_GT(size, INITIAL_VALUE);
886
887 adapter->DestroyRender(adapter, render);
888 manager->UnloadAdapter(manager, adapter);
889 }
890 /**
891 * @tc.name Test RenderGetFrameSize API via define sampleRate to different values
892 * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0005
893 * @tc.desc Test RenderGetFrameSize interface,return 0 if get framesize define sampleRate as different values
894 * @tc.author: tiansuli
895 */
896 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0005, TestSize.Level1)
897 {
898 int32_t ret = -1;
899 uint64_t size = 0;
900 uint64_t channelCountExp = 1;
901 uint32_t sampleRateExp = 48000;
902 struct AudioSampleAttributes attrs = {};
903 struct AudioSampleAttributes attrsValue = {};
904 struct AudioAdapter *adapter = nullptr;
905 struct AudioRender *render = nullptr;
906 ASSERT_NE(nullptr, GetAudioManager);
907 TestAudioManager* manager = GetAudioManager();
908 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
909 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
910 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 48000);
911
912 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
913 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
914 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
915 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
916 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
917
918 ret = render->attr.GetFrameSize(render, &size);
919 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
920 EXPECT_GT(size, INITIAL_VALUE);
921
922 adapter->DestroyRender(adapter, render);
923 manager->UnloadAdapter(manager, adapter);
924 }
925 /**
926 * @tc.name Test RenderGetFrameSize API via define channelCount to different values
927 * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0006
928 * @tc.desc Test RenderGetFrameSize interface,return 0 if get framesize define channelCount as different values
929 * @tc.author: tiansuli
930 */
931 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0006, TestSize.Level1)
932 {
933 int32_t ret = -1;
934 uint64_t size = 0;
935 uint64_t channelCountExp = 2;
936 uint32_t sampleRateExp = 44100;
937 struct AudioSampleAttributes attrs = {};
938 struct AudioSampleAttributes attrsValue = {};
939 struct AudioAdapter *adapter = nullptr;
940 struct AudioRender *render = nullptr;
941 ASSERT_NE(nullptr, GetAudioManager);
942 TestAudioManager* manager = GetAudioManager();
943 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
944 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
945 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 44100);
946
947 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
948 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
949 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
950 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
951 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
952
953 ret = render->attr.GetFrameSize(render, &size);
954 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
955 EXPECT_GT(size, INITIAL_VALUE);
956
957 adapter->DestroyRender(adapter, render);
958 manager->UnloadAdapter(manager, adapter);
959 }
960 /**
961 * @tc.name Test RenderGetFrameSize API via define sampleRate to different value
962 * @tc.number SUB_Audio_HDI_RenderGetFrameSize_0007
963 * @tc.desc Test RenderGetFrameSize interface,return 0 if get framesize define sampleRate as different values
964 * @tc.author: tiansuli
965 */
966 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameSize_0007, TestSize.Level1)
967 {
968 int32_t ret = -1;
969 uint64_t size = 0;
970 uint64_t channelCountExp = 1;
971 uint32_t sampleRateExp = 48000;
972 struct AudioSampleAttributes attrs = {};
973 struct AudioSampleAttributes attrsValue = {};
974 struct AudioAdapter *adapter = nullptr;
975 struct AudioRender *render = nullptr;
976 ASSERT_NE(nullptr, GetAudioManager);
977 TestAudioManager* manager = GetAudioManager();
978 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
979 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
980 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 48000);
981
982 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
983 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
984 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
985 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
986 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
987
988 ret = render->attr.GetFrameSize(render, &size);
989 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
990 EXPECT_GT(size, INITIAL_VALUE);
991
992 adapter->DestroyRender(adapter, render);
993 manager->UnloadAdapter(manager, adapter);
994 }
995 /**
996 * @tc.name Test RenderGetFrameCount API via legal
997 * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0001
998 * @tc.desc Test RenderGetFrameCount interface, return 0 if the FrameSize was obtained successfully
999 * @tc.author: tiansuli
1000 */
1001 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0001, TestSize.Level1)
1002 {
1003 int32_t ret = -1;
1004 uint64_t count = 0;
1005 uint64_t zero = 0;
1006 TestAudioManager* manager = {};
1007 struct AudioAdapter *adapter =nullptr;
1008 struct AudioRender *render = nullptr;
1009 ASSERT_NE(nullptr, GetAudioManager);
1010 manager = GetAudioManager();
1011 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
1012 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1013
1014 ret = render->attr.GetFrameCount(render, &count);
1015 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1016 EXPECT_GT(count, zero);
1017
1018 render->control.Stop((AudioHandle)render);
1019 adapter->DestroyRender(adapter, render);
1020 manager->UnloadAdapter(manager, adapter);
1021 }
1022 /**
1023 * @tc.name Test RenderGetFrameCount API via setting the incoming parameter handle is nullptr
1024 * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0002
1025 * @tc.desc Test RenderGetFrameCount interface,return -1 if the incoming parameter handle is nullptr
1026 * @tc.author: tiansuli
1027 */
1028 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0002, TestSize.Level1)
1029 {
1030 int32_t ret = -1;
1031 uint64_t count = 0;
1032 TestAudioManager* manager = {};
1033 struct AudioAdapter *adapter =nullptr;
1034 struct AudioRender *render = nullptr;
1035 struct AudioRender *renderNull = nullptr;
1036 ASSERT_NE(nullptr, GetAudioManager);
1037 manager = GetAudioManager();
1038 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
1039 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1040
1041 ret = render->attr.GetFrameCount(renderNull, &count);
1042 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1043
1044 render->control.Stop((AudioHandle)render);
1045 adapter->DestroyRender(adapter, render);
1046 manager->UnloadAdapter(manager, adapter);
1047 }
1048 /**
1049 * @tc.name Test RenderGetFrameCount API setting the incoming parameter count is nullptr
1050 * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0003
1051 * @tc.desc Test RenderGetFrameCount interface,return -1 if the incoming parameter count is nullptr
1052 * @tc.author: tiansuli
1053 */
1054 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0003, TestSize.Level1)
1055 {
1056 int32_t ret = -1;
1057 uint64_t *countNull = nullptr;
1058 TestAudioManager* manager = {};
1059 struct AudioAdapter *adapter =nullptr;
1060 struct AudioRender *render = nullptr;
1061 ASSERT_NE(nullptr, GetAudioManager);
1062 manager = GetAudioManager();
1063 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
1064 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1065
1066 ret = render->attr.GetFrameCount(render, countNull);
1067 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1068
1069 render->control.Stop((AudioHandle)render);
1070 adapter->DestroyRender(adapter, render);
1071 manager->UnloadAdapter(manager, adapter);
1072 }
1073 /**
1074 * @tc.name Test RenderGetFrameCount API via define channelCount to different value
1075 * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0004
1076 * @tc.desc Test RenderGetFrameCount interface,return 0 if get framesize define channelCount as different values
1077 * @tc.author: tiansuli
1078 */
1079 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0004, TestSize.Level1)
1080 {
1081 int32_t ret = -1;
1082 uint64_t count = 0;
1083 uint64_t channelCountExp = 2;
1084 uint32_t sampleRateExp = 8000;
1085 struct AudioAdapter *adapter = nullptr;
1086 struct AudioRender *render = nullptr;
1087 struct AudioSampleAttributes attrs = {};
1088 struct AudioSampleAttributes attrsValue = {};
1089 ASSERT_NE(nullptr, GetAudioManager);
1090 TestAudioManager* manager = GetAudioManager();
1091 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1092 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1093 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 8000);
1094
1095 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
1096 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1097 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
1098 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1099 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1100
1101 ret = AudioRenderStartAndOneFrame(render);
1102 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1103 ret = render->attr.GetFrameCount(render, &count);
1104 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1105 EXPECT_GT(count, INITIAL_VALUE);
1106
1107 ret = render->control.Stop((AudioHandle)render);
1108 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1109 adapter->DestroyRender(adapter, render);
1110 manager->UnloadAdapter(manager, adapter);
1111 }
1112 /**
1113 * @tc.name Test RenderGetFrameCount API via define format to different value
1114 * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0005
1115 * @tc.desc Test RenderGetFrameCount interface,return 0 if get framesize define format as different values
1116 * @tc.author: tiansuli
1117 */
1118 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0005, TestSize.Level1)
1119 {
1120 int32_t ret = -1;
1121 uint64_t count = 0;
1122 uint64_t channelCountExp = 2;
1123 uint32_t sampleRateExp = 8000;
1124 struct AudioAdapter *adapter = nullptr;
1125 struct AudioRender *render = nullptr;
1126 struct AudioSampleAttributes attrs = {};
1127 struct AudioSampleAttributes attrsValue = {};
1128 ASSERT_NE(nullptr, GetAudioManager);
1129 TestAudioManager* manager = GetAudioManager();
1130 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1131 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1132 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 8000);
1133
1134 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
1135 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1136 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
1137 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1138 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1139
1140 ret = AudioRenderStartAndOneFrame(render);
1141 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1142 ret = render->attr.GetFrameCount(render, &count);
1143 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1144 EXPECT_GT(count, INITIAL_VALUE);
1145
1146 ret = render->control.Stop((AudioHandle)render);
1147 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1148 adapter->DestroyRender(adapter, render);
1149 manager->UnloadAdapter(manager, adapter);
1150 }
1151 /**
1152 * @tc.name Test RenderGetFrameCount API via define channelCount to different value
1153 * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0006
1154 * @tc.desc Test RenderGetFrameCount interface,return 0 if get framesize define channelCount to different values
1155 * @tc.author: tiansuli
1156 */
1157 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0006, TestSize.Level1)
1158 {
1159 int32_t ret = -1;
1160 uint64_t count = 0;
1161 uint64_t channelCountExp = 1;
1162 uint32_t sampleRateExp = 44100;
1163 struct AudioAdapter *adapter = nullptr;
1164 struct AudioRender *render = nullptr;
1165 struct AudioSampleAttributes attrs = {};
1166 struct AudioSampleAttributes attrsValue = {};
1167 ASSERT_NE(nullptr, GetAudioManager);
1168 TestAudioManager* manager = GetAudioManager();
1169 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1170 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1171 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 44100);
1172
1173 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
1174 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1175 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
1176 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1177 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1178
1179 ret = AudioRenderStartAndOneFrame(render);
1180 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1181 ret = render->attr.GetFrameCount(render, &count);
1182 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1183 EXPECT_GT(count, INITIAL_VALUE);
1184
1185 render->control.Stop((AudioHandle)render);
1186 adapter->DestroyRender(adapter, render);
1187 manager->UnloadAdapter(manager, adapter);
1188 }
1189 /**
1190 * @tc.name Test RenderGetFrameCount API via define format to different value
1191 * @tc.number SUB_Audio_HDI_RenderGetFrameCount_0007
1192 * @tc.desc Test RenderGetFrameCount interface,return 0 if get framesize define format as different values
1193 * @tc.author: tiansuli
1194 */
1195 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetFrameCount_0007, TestSize.Level1)
1196 {
1197 int32_t ret = -1;
1198 uint64_t count = 0;
1199 uint64_t channelCountExp = 1;
1200 uint32_t sampleRateExp = 32000;
1201 struct AudioAdapter *adapter = nullptr;
1202 struct AudioRender *render = nullptr;
1203 struct AudioSampleAttributes attrs = {};
1204 struct AudioSampleAttributes attrsValue = {};
1205 ASSERT_NE(nullptr, GetAudioManager);
1206 TestAudioManager* manager = GetAudioManager();
1207 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1208 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1209 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 32000);
1210
1211 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
1212 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1213 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
1214 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1215 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1216
1217 ret = AudioRenderStartAndOneFrame(render);
1218 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1219 ret = render->attr.GetFrameCount(render, &count);
1220 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1221 EXPECT_GT(count, INITIAL_VALUE);
1222
1223 render->control.Stop((AudioHandle)render);
1224 adapter->DestroyRender(adapter, render);
1225 manager->UnloadAdapter(manager, adapter);
1226 }
1227 /**
1228 * @tc.name Test RenderGetCurrentChannelId API via legal input
1229 * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0001
1230 * @tc.desc Test RenderGetCurrentChannelId, return 0 if the default CurrentChannelId is obtained successfully
1231 * @tc.author: tiansuli
1232 */
1233 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0001, TestSize.Level1)
1234 {
1235 int32_t ret = -1;
1236 uint32_t channelId = 0;
1237 uint32_t channelIdValue = CHANNELCOUNT;
1238 struct AudioAdapter *adapter = nullptr;
1239 struct AudioRender *render = nullptr;
1240 ASSERT_NE(nullptr, GetAudioManager);
1241 TestAudioManager* manager = GetAudioManager();
1242 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1243 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1244
1245 ret = render->attr.GetCurrentChannelId(render, &channelId);
1246 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1247 EXPECT_EQ(channelIdValue, channelId);
1248
1249 adapter->DestroyRender(adapter, render);
1250 manager->UnloadAdapter(manager, adapter);
1251 }
1252 /**
1253 * @tc.name Test GetCurrentChannelId API via get channelId to 1 and set channelCount to 1
1254 * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0003
1255 * @tc.desc Test GetCurrentChannelId interface,return 0 if get channelId to 1 and set channelCount to 1
1256 * @tc.author: tiansuli
1257 */
1258 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0002, TestSize.Level1)
1259 {
1260 int32_t ret = -1;
1261 uint32_t channelId = 0;
1262 uint32_t channelIdExp = 1;
1263 uint32_t channelCountExp = 1;
1264 struct AudioSampleAttributes attrs = {};
1265 struct AudioSampleAttributes attrsValue = {};
1266 struct AudioAdapter *adapter = nullptr;
1267 struct AudioRender *render = nullptr;
1268 ASSERT_NE(nullptr, GetAudioManager);
1269 TestAudioManager* manager = GetAudioManager();
1270 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1271 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1272 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 32000);
1273
1274 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
1275 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1276 EXPECT_EQ(channelCountExp, attrs.channelCount);
1277
1278 ret = render->attr.GetCurrentChannelId(render, &channelId);
1279 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1280 EXPECT_EQ(channelIdExp, channelId);
1281
1282 adapter->DestroyRender(adapter, render);
1283 manager->UnloadAdapter(manager, adapter);
1284 }
1285 /**
1286 * @tc.name Test RenderGetCurrentChannelId API via CurrentChannelId is obtained after created
1287 * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0003
1288 * @tc.desc Test RenderGetCurrentChannelId interface, return 0 if CurrentChannelId is obtained after created
1289 * @tc.author: tiansuli
1290 */
1291 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0003, TestSize.Level1)
1292 {
1293 int32_t ret = -1;
1294 uint32_t channelId = 0;
1295 uint32_t channelIdExp = 2;
1296 struct AudioAdapter *adapter = nullptr;
1297 struct AudioRender *render = nullptr;
1298 ASSERT_NE(nullptr, GetAudioManager);
1299 TestAudioManager* manager = GetAudioManager();
1300 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1301 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1302
1303 ret = render->attr.GetCurrentChannelId(render, &channelId);
1304 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1305 EXPECT_EQ(channelIdExp, channelId);
1306
1307 adapter->DestroyRender(adapter, render);
1308 manager->UnloadAdapter(manager, adapter);
1309 }
1310 /**
1311 * @tc.name Test GetCurrentChannelId API via setting the parameter render is nullptr
1312 * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0004
1313 * @tc.desc Test GetCurrentChannelId interface,return -1 if set the parameter render is nullptr
1314 * @tc.author: tiansuli
1315 */
1316 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0004, TestSize.Level1)
1317 {
1318 int32_t ret = -1;
1319 uint32_t channelId = 0;
1320 struct AudioAdapter *adapter = nullptr;
1321 struct AudioRender *render = nullptr;
1322 struct AudioRender *renderNull = nullptr;
1323 ASSERT_NE(nullptr, GetAudioManager);
1324 TestAudioManager* manager = GetAudioManager();
1325 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1326 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1327
1328 ret = render->attr.GetCurrentChannelId(renderNull, &channelId);
1329 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1330
1331 adapter->DestroyRender(adapter, render);
1332 manager->UnloadAdapter(manager, adapter);
1333 }
1334 /**
1335 * @tc.name Test RenderGetCurrentChannelId API via setting the parameter channelId is nullptr
1336 * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0005
1337 * @tc.desc Test RenderGetCurrentChannelId interface, return -1 if setting the parameter channelId is nullptr
1338 * @tc.author: tiansuli
1339 */
1340 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetCurrentChannelId_0005, TestSize.Level1)
1341 {
1342 int32_t ret = -1;
1343 uint32_t *channelIdNull = nullptr;
1344 struct AudioAdapter *adapter = nullptr;
1345 struct AudioRender *render = nullptr;
1346 ASSERT_NE(nullptr, GetAudioManager);
1347 TestAudioManager* manager = GetAudioManager();
1348 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1349 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1350
1351 ret = render->attr.GetCurrentChannelId(render, channelIdNull);
1352 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1353
1354 adapter->DestroyRender(adapter, render);
1355 manager->UnloadAdapter(manager, adapter);
1356 }
1357 #if defined (AUDIO_ADM_SERVICE) || defined (AUDIO_ADM_SO) || defined (__LITEOS__)
1358 /**
1359 * @tc.name Test RenderSetExtraParams API via setting ExtraParams during playback
1360 * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0001
1361 * @tc.desc Test RenderSetExtraParams interface,return 0 if the ExtraParams is set during playback
1362 * @tc.author: tiansuli
1363 */
1364 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0001, TestSize.Level1)
1365 {
1366 int32_t ret = -1;
1367 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
1368 char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-sampling-rate=48000";
1369 size_t index = 1;
1370 char keyValueListValue[256] = {};
1371 int32_t listLenth = 256;
1372 struct PrepareAudioPara audiopara = {
1373 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
1374 .path = AUDIO_FILE.c_str()
1375 };
1376 ASSERT_NE(nullptr, GetAudioManager);
1377 audiopara.manager = GetAudioManager();
1378 ASSERT_NE(nullptr, audiopara.manager);
1379
1380 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
1381 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1382 sleep(1);
1383 if (audiopara.render != nullptr) {
1384 ret = audiopara.render->attr.SetExtraParams((AudioHandle)audiopara.render, keyValueList);
1385 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1386 ret = audiopara.render->attr.GetExtraParams((AudioHandle)audiopara.render, keyValueListValue, listLenth);
1387 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1388 string strGetValue = keyValueListValue;
1389 size_t indexAttr = strGetValue.find("attr-frame-count");
1390 size_t indexFlag = strGetValue.rfind(";");
1391 if (indexAttr != string::npos && indexFlag != string::npos) {
1392 strGetValue.replace(indexAttr, indexFlag - indexAttr + index, "");
1393 }
1394 EXPECT_STREQ(keyValueListExp, strGetValue.c_str());
1395 }
1396
1397 ret = ThreadRelease(audiopara);
1398 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1399 }
1400 /**
1401 * @tc.name Test RenderSetExtraParams API via setting some parameters after playing
1402 * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0002
1403 * @tc.desc Test RenderSetExtraParams interface,return 0 if some parameters is set after playing
1404 * @tc.author: tiansuli
1405 */
1406 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0002, TestSize.Level1)
1407 {
1408 int32_t ret = -1;
1409 struct AudioAdapter *adapter = {};
1410 struct AudioRender *render = nullptr;
1411 char keyValueListOne[] = "attr-frame-count=1024;";
1412 char keyValueListOneExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=1024;\
1413 attr-sampling-rate=48000";
1414 char keyValueListTwo[] = "attr-format=16;attr-frame-count=1024;";
1415 char keyValueListTwoExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=1024;\
1416 attr-sampling-rate=48000";
1417 char keyValueListThr[] = "attr-route=1;attr-channels=1;attr-frame-count=1024;";
1418 char keyValueListThrExp[] = "attr-route=1;attr-format=16;attr-channels=1;attr-frame-count=1024;\
1419 attr-sampling-rate=48000";
1420 char keyValueListFour[] = "attr-format=32;attr-channels=2;attr-frame-count=4096;attr-sampling-rate=48000";
1421 char keyValueListFourExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=4096;\
1422 attr-sampling-rate=48000";
1423 char keyValueListValueOne[256] = {};
1424 char keyValueListValueTwo[256] = {};
1425 char keyValueListValueThr[256] = {};
1426 char keyValueListValueFour[256] = {};
1427 int32_t listLenth = 256;
1428 ASSERT_NE(nullptr, GetAudioManager);
1429 TestAudioManager* manager = GetAudioManager();
1430 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
1431 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1432 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListOne);
1433 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1434 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueOne, listLenth);
1435 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1436 EXPECT_STREQ(keyValueListOneExp, keyValueListValueOne);
1437 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListTwo);
1438 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1439 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueTwo, listLenth);
1440 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1441 EXPECT_STREQ(keyValueListTwoExp, keyValueListValueTwo);
1442 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListThr);
1443 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1444 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueThr, listLenth);
1445 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1446 EXPECT_STREQ(keyValueListThrExp, keyValueListValueThr);
1447 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListFour);
1448 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1449 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueFour, listLenth);
1450 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1451 EXPECT_STREQ(keyValueListFourExp, keyValueListValueFour);
1452 ret = render->control.Stop((AudioHandle)render);
1453 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1454 adapter->DestroyRender(adapter, render);
1455 manager->UnloadAdapter(manager, adapter);
1456 }
1457 /**
1458 * @tc.name Test RenderSetExtraParams API via setting keyvaluelist to a value outside the range
1459 * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0003
1460 * @tc.desc Test RenderSetExtraParams interface,return -1 if the Keyvaluelist is a value out of range
1461 * @tc.author: tiansuli
1462 */
1463 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0003, TestSize.Level1)
1464 {
1465 int32_t ret = -1;
1466 struct AudioAdapter *adapter = {};
1467 struct AudioRender *render = nullptr;
1468 char keyValueList[] = "attr-para=abc;";
1469
1470 ASSERT_NE(nullptr, GetAudioManager);
1471 TestAudioManager* manager = GetAudioManager();
1472 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1473 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1474 ret = ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList);
1475 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1476
1477 adapter->DestroyRender(adapter, render);
1478 manager->UnloadAdapter(manager, adapter);
1479 }
1480 /**
1481 * @tc.name Test RenderSetExtraParams API via adding parameters to keyvaluelist
1482 * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0004
1483 * @tc.desc Test RenderSetExtraParams interface,return -1 if adding parameters to keyvaluelist
1484 * @tc.author: tiansuli
1485 */
1486 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0004, TestSize.Level1)
1487 {
1488 int32_t ret = -1;
1489 struct AudioAdapter *adapter = {};
1490 struct AudioRender *render = nullptr;
1491 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000;\
1492 attr-para=123";
1493
1494 ASSERT_NE(nullptr, GetAudioManager);
1495 TestAudioManager* manager = GetAudioManager();
1496 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1497 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1498 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList);
1499 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1500
1501 adapter->DestroyRender(adapter, render);
1502 manager->UnloadAdapter(manager, adapter);
1503 }
1504 /**
1505 * @tc.name Test RenderSetExtraParams API via setting ExtraParams When the key is the same and the value is
1506 different
1507 * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0005
1508 * @tc.desc Test RenderSetExtraParams interface,return 0 if set ExtraParams When the key is the same and the value
1509 is different
1510 * @tc.author: tiansuli
1511 */
1512 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0005, TestSize.Level1)
1513 {
1514 int32_t ret = -1;
1515 struct AudioAdapter *adapter = {};
1516 struct AudioRender *render = nullptr;
1517 ASSERT_NE(nullptr, GetAudioManager);
1518 TestAudioManager* manager = GetAudioManager();
1519 char keyValueList[] = "attr-sampling-rate=48000;attr-sampling-rate=96000;attr-frame-count=4096;";
1520 char keyValueListExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=4096;\
1521 attr-sampling-rate=96000";
1522 char keyValueListValue[256] = {};
1523 int32_t listLenth = 256;
1524
1525 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
1526 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1527 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList);
1528 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1529 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValue, listLenth);
1530 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1531 EXPECT_STREQ(keyValueListExp, keyValueListValue);
1532
1533 ret = render->control.Stop((AudioHandle)render);
1534 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1535 adapter->DestroyRender(adapter, render);
1536 manager->UnloadAdapter(manager, adapter);
1537 }
1538 /**
1539 * @tc.name Test RenderSetExtraParams API via setting the parameter in keyvaluelist as an abnormal value
1540 * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0006
1541 * @tc.desc Test RenderSetExtraParams interface,return -1 if Set the parameter in keyvaluelist as an abnormal value
1542 * @tc.author: tiansuli
1543 */
1544 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0006, TestSize.Level1)
1545 {
1546 int32_t ret = -1;
1547 struct AudioAdapter *adapter = {};
1548 struct AudioRender *render = nullptr;
1549 char attrSamplingRateError[] = "attr-sampling-rate=1234567;";
1550 char attrChannelsError[] = "attr-channels=3;";
1551 char attrFrameCountError[] = "attr-frame-count=111111111111111111111;";
1552 char attrRouteError[] = "attr-route=5;";
1553 char attrFormateError[] = "attr-formate=12;";
1554
1555 ASSERT_NE(nullptr, GetAudioManager);
1556 TestAudioManager* manager = GetAudioManager();
1557 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1558 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1559 ret = render->attr.SetExtraParams((AudioHandle)render, attrSamplingRateError);
1560 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1561 ret = render->attr.SetExtraParams((AudioHandle)render, attrChannelsError);
1562 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1563 ret = render->attr.SetExtraParams((AudioHandle)render, attrFrameCountError);
1564 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1565 ret = render->attr.SetExtraParams((AudioHandle)render, attrRouteError);
1566 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1567 ret = render->attr.SetExtraParams((AudioHandle)render, attrFormateError);
1568 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1569
1570 adapter->DestroyRender(adapter, render);
1571 manager->UnloadAdapter(manager, adapter);
1572 }
1573 /**
1574 * @tc.name Test RenderSetExtraParams API via setting the parameter render is nullptr
1575 * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0007
1576 * @tc.desc Test RenderSetExtraParams interface,return -1 if set the parameter render is nullptr
1577 * @tc.author: tiansuli
1578 */
1579 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0007, TestSize.Level1)
1580 {
1581 int32_t ret = -1;
1582 struct AudioAdapter *adapter = {};
1583 struct AudioRender *render = nullptr;
1584 struct AudioRender *renderNull = nullptr;
1585 char keyValueList[] = "attr-format=2;";
1586
1587 ASSERT_NE(nullptr, GetAudioManager);
1588 TestAudioManager* manager = GetAudioManager();
1589 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1590 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1591 ret = render->attr.SetExtraParams((AudioHandle)renderNull, keyValueList);
1592 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1593
1594 adapter->DestroyRender(adapter, render);
1595 manager->UnloadAdapter(manager, adapter);
1596 }
1597 /**
1598 * @tc.name Test RenderSetExtraParams API via setting the format of ExtraParams is nullptr
1599 * @tc.number SUB_Audio_HDI_RenderSetExtraParams_0008
1600 * @tc.desc Test RenderSetExtraParams interface,return -1 if set the format of ExtraParams is nullptr
1601 * @tc.author: tiansuli
1602 */
1603 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderSetExtraParams_0008, TestSize.Level1)
1604 {
1605 int32_t ret = -1;
1606 struct AudioAdapter *adapter = {};
1607 struct AudioRender *render = nullptr;
1608 char keyValueListNull[] = "attr-format=;";
1609
1610 ASSERT_NE(nullptr, GetAudioManager);
1611 TestAudioManager* manager = GetAudioManager();
1612 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1613 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1614 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListNull);
1615 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1616
1617 adapter->DestroyRender(adapter, render);
1618 manager->UnloadAdapter(manager, adapter);
1619 }
1620 /**
1621 * @tc.name Test RenderGetExtraParams API via legal input
1622 * @tc.number SUB_Audio_HDI_RenderGetExtraParams_0001
1623 * @tc.desc Test RenderGetExtraParams interface,return 0 if the RenderGetExtraParams was obtained successfully
1624 * @tc.author: tiansuli
1625 */
1626 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetExtraParams_0001, TestSize.Level1)
1627 {
1628 int32_t ret = -1;
1629 uint64_t count = 0;
1630 struct AudioAdapter *adapter = {};
1631 struct AudioRender *render = nullptr;
1632 struct AudioSampleAttributes attrsValue = {};
1633 char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
1634 char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\
1635 attr-sampling-rate=48000";
1636 char keyValueListValue[256] = {};
1637 int32_t listLenth = 256;
1638 int32_t formatExp = 3;
1639 uint32_t sampleRateExp = 48000;
1640 uint32_t channelCountExp = 2;
1641 uint32_t frameCountExp = 4096;
1642
1643 ASSERT_NE(nullptr, GetAudioManager);
1644 TestAudioManager* manager = GetAudioManager();
1645 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
1646 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1647 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList);
1648 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1649 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValue, listLenth);
1650 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1651 EXPECT_STREQ(keyValueListExp, keyValueListValue);
1652
1653 ret = render->attr.GetSampleAttributes(render, &attrsValue);
1654 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1655 EXPECT_EQ(formatExp, attrsValue.format);
1656 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1657 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1658 ret = render->attr.GetFrameCount(render, &count);
1659 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1660 EXPECT_EQ(count, frameCountExp);
1661
1662 ret = render->control.Stop((AudioHandle)render);
1663 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1664 adapter->DestroyRender(adapter, render);
1665 manager->UnloadAdapter(manager, adapter);
1666 }
1667 /**
1668 * @tc.name Test RenderGetExtraParams API via setting the parameter render is nullptr
1669 * @tc.number SUB_Audio_HDI_RenderGetExtraParams_0002
1670 * @tc.desc Test RenderGetExtraParams interface,return -1 if set the parameter render is nullptr
1671 * @tc.author: tiansuli
1672 */
1673 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetExtraParams_0002, TestSize.Level1)
1674 {
1675 int32_t ret = -1;
1676 struct AudioAdapter *adapter = {};
1677 struct AudioRender *render = nullptr;
1678 struct AudioRender *renderNull = nullptr;
1679 char keyValueList[] = "attr-format=32;";
1680 char keyValueListValue[256] = {};
1681 int32_t listLenth = 256;
1682
1683 ASSERT_NE(nullptr, GetAudioManager);
1684 TestAudioManager* manager = GetAudioManager();
1685 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1686 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1687 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList);
1688 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1689 ret = render->attr.GetExtraParams((AudioHandle)renderNull, keyValueListValue, listLenth);
1690 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1691
1692 adapter->DestroyRender(adapter, render);
1693 manager->UnloadAdapter(manager, adapter);
1694 }
1695 /**
1696 * @tc.name Test RenderGetExtraParams API via setting listlength to be less than the actual length
1697 * @tc.number SUB_Audio_HDI_RenderGetExtraParams_0003
1698 * @tc.desc Test RenderGetExtraParams interface,return -1 if set listlength to be less than the actual length
1699 * @tc.author: tiansuli
1700 */
1701 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetExtraParams_0003, TestSize.Level1)
1702 {
1703 int32_t ret = -1;
1704 struct AudioAdapter *adapter = {};
1705 struct AudioRender *render = nullptr;
1706 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000;";
1707 char keyValueListValue[256] = {};
1708 int32_t listLenth = 8;
1709
1710 ASSERT_NE(nullptr, GetAudioManager);
1711 TestAudioManager* manager = GetAudioManager();
1712 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1713 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1714 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList);
1715 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1716 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValue, listLenth);
1717 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1718
1719 adapter->DestroyRender(adapter, render);
1720 manager->UnloadAdapter(manager, adapter);
1721 }
1722 /**
1723 * @tc.name Test RenderGetExtraParams API via setting listlenth equal to the actual length
1724 * @tc.number SUB_Audio_HDI_RenderGetExtraParams_0004
1725 * @tc.desc Test RenderGetExtraParams interface,return 0 if set listlenth equal to the actual length
1726 * @tc.author: tiansuli
1727 */
1728 HWTEST_F(AudioHdiRenderAttrTest, SUB_Audio_HDI_RenderGetExtraParams_0004, TestSize.Level1)
1729 {
1730 int32_t ret = -1;
1731 struct AudioAdapter *adapter = {};
1732 struct AudioRender *render = nullptr;
1733 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=11111111111111111111;\
1734 attr-sampling-rate=48000";
1735 char keyValueListValue[256] = {};
1736 int32_t listLenth = 107;
1737
1738 ASSERT_NE(nullptr, GetAudioManager);
1739 TestAudioManager* manager = GetAudioManager();
1740 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
1741 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1742 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList);
1743 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1744 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValue, listLenth);
1745 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1746 EXPECT_STREQ(keyValueList, keyValueListValue);
1747
1748 ret = render->control.Stop((AudioHandle)render);
1749 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1750 adapter->DestroyRender(adapter, render);
1751 manager->UnloadAdapter(manager, adapter);
1752 }
1753 #endif
1754 }