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