1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 /**
17 * @addtogroup Audio
18 * @{
19 *
20 * @brief Test audio-related APIs, including custom data types and functions for loading drivers,
21 * accessing a driver adapter.
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 adapter.
31 *
32 * @since 1.0
33 * @version 1.0
34 */
35
36 #include "audio_hdi_common.h"
37 #include "audio_usb_render_test.h"
38
39 using namespace std;
40 using namespace testing::ext;
41 using namespace OHOS::Audio;
42
43 namespace {
44 const string ADAPTER_NAME_USB = "usb";
45
46 class AudioUsbRenderTest : public testing::Test {
47 public:
48 static void SetUpTestCase(void);
49 static void TearDownTestCase(void);
50 void SetUp();
51 void TearDown();
52 static TestAudioManager *manager;
53 };
54
55 using THREAD_FUNC = void *(*)(void *);
56 TestAudioManager *AudioUsbRenderTest::manager = nullptr;
57
SetUpTestCase(void)58 void AudioUsbRenderTest::SetUpTestCase(void)
59 {
60 manager = GetAudioManagerFuncs();
61 ASSERT_NE(nullptr, manager);
62 }
63
TearDownTestCase(void)64 void AudioUsbRenderTest::TearDownTestCase(void) {}
65
SetUp(void)66 void AudioUsbRenderTest::SetUp(void) {}
67
TearDown(void)68 void AudioUsbRenderTest::TearDown(void) {}
69
70 /**
71 * @tc.name AudioRenderGetMute_001
72 * @tc.desc Test AudioRenderGetMute interface , return 0 if the audiocapture gets mute successfully.
73 * @tc.type: FUNC
74 */
75 HWTEST_F(AudioUsbRenderTest, AudioRenderGetMute_001, TestSize.Level1)
76 {
77 int32_t ret = -1;
78 bool muteTrue = true;
79 bool muteFalse = false;
80 bool defaultmute = false;
81 struct AudioAdapter *adapter = nullptr;
82 struct AudioRender *render = nullptr;
83 ASSERT_NE(nullptr, manager);
84 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
85 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
86
87 ret = render->volume.GetMute(render, &muteFalse);
88 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
89 EXPECT_EQ(muteFalse, defaultmute);
90
91 ret = render->volume.SetMute(render, muteTrue);
92 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
93
94 ret = render->volume.GetMute(render, &muteTrue);
95 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
96 EXPECT_TRUE(muteTrue);
97 adapter->DestroyRender(adapter, render);
98 manager->UnloadAdapter(manager, adapter);
99 }
100
101 /**
102 * @tc.name AudioRenderSetMute_001
103 * @tc.desc Test AudioRenderSetMute interface , return 0 if the audiorender object sets mute successfully.
104 * @tc.type: FUNC
105 */
106 HWTEST_F(AudioUsbRenderTest, AudioRenderSetMute_001, TestSize.Level1)
107 {
108 int32_t ret = -1;
109 bool muteFalse = false;
110 bool muteTrue = true;
111 struct AudioAdapter *adapter = nullptr;
112 struct AudioRender *render = nullptr;
113 ASSERT_NE(nullptr, manager);
114 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
115 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
116
117 ret = render->volume.SetMute(render, muteFalse);
118 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
119 ret = render->volume.GetMute(render, &muteFalse);
120 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
121 EXPECT_EQ(false, muteFalse);
122
123 ret = render->volume.SetMute(render, muteTrue);
124 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
125 ret = render->volume.GetMute(render, &muteTrue);
126 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
127 EXPECT_EQ(true, muteTrue);
128
129 muteTrue = false;
130 ret = render->volume.SetMute(render, muteTrue);
131 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
132 EXPECT_FALSE(muteTrue);
133
134 adapter->DestroyRender(adapter, render);
135 manager->UnloadAdapter(manager, adapter);
136 }
137 /**
138 * @tc.name AudioRenderSetVolume_001
139 * @tc.desc Test AudioRenderSetVolume interface , return 0 if the audiocapture sets volume successfully.
140 * @tc.type: FUNC
141 */
142 HWTEST_F(AudioUsbRenderTest, AudioRenderSetVolume_001, TestSize.Level1)
143 {
144 int32_t ret = -1;
145 float volumeInit = 0.20;
146 float volumeInitExpc = 0.20;
147 float volumeLow = 0.10;
148 float volumeLowExpc = 0.10;
149 float volumeMid = 0.50;
150 float volumeMidExpc = 0.50;
151 float volumeHigh = 0.80;
152 float volumeHighExpc = 0.80;
153 struct AudioAdapter *adapter = nullptr;
154 struct AudioRender *render = nullptr;
155 ASSERT_NE(nullptr, manager);
156 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
157 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
158
159 ret = render->volume.SetVolume(render, volumeInit);
160 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
161 ret = render->volume.GetVolume(render, &volumeInit);
162 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
163 EXPECT_EQ(volumeInitExpc, volumeInit);
164 ret = render->volume.SetVolume(render, volumeLow);
165 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
166 ret = render->volume.GetVolume(render, &volumeLow);
167 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
168 EXPECT_EQ(volumeLowExpc, volumeLow);
169 ret = render->volume.SetVolume(render, volumeMid);
170 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
171 ret = render->volume.GetVolume(render, &volumeMid);
172 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
173 EXPECT_EQ(volumeMidExpc, volumeMid);
174 ret = render->volume.SetVolume(render, volumeHigh);
175 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
176 ret = render->volume.GetVolume(render, &volumeHigh);
177 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
178 EXPECT_EQ(volumeHighExpc, volumeHigh);
179
180 adapter->DestroyRender(adapter, render);
181 manager->UnloadAdapter(manager, adapter);
182 }
183 /**
184 * @tc.name AudioRenderGetVolume_001
185 * @tc.desc Test AudioRenderGetVolume interface , return 0 if the audiocapture is get successful.
186 * @tc.type: FUNC
187 */
188 HWTEST_F(AudioUsbRenderTest, AudioRenderGetVolume_001, TestSize.Level1)
189 {
190 int32_t ret = -1;
191 float volume = 0.30;
192 float volumeDefault = 0.30;
193 struct AudioAdapter *adapter = nullptr;
194 struct AudioRender *render = nullptr;
195 ASSERT_NE(nullptr, manager);
196 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
197 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
198
199 ret = render->volume.SetVolume(render, volume);
200 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
201 ret = render->volume.GetVolume(render, &volume);
202 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
203 EXPECT_EQ(volumeDefault, volume);
204
205 adapter->DestroyRender(adapter, render);
206 manager->UnloadAdapter(manager, adapter);
207 }
208
209 /**
210 * @tc.name AudioRenderSetSampleAttributes_001
211 * @tc.desc Test AudioRenderSetSampleAttributes ,the setting parameters are as follows.
212 * attrs.type = AUDIO_IN_MEDIA;
213 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
214 * attrs.sampleRate = AUDIO_SAMPLE_RATE_MASK_8000;
215 * attrs.channelCount = 1;
216 * @tc.type: FUNC
217 */
218 HWTEST_F(AudioUsbRenderTest, AudioRenderSetSampleAttributes_001, TestSize.Level1)
219 {
220 int32_t ret = -1;
221 uint32_t ret1 = 1;
222 uint32_t ret2 = 8000;
223 struct AudioAdapter *adapter = nullptr;
224 struct AudioRender *render = nullptr;
225 struct AudioSampleAttributes attrs = {};
226 struct AudioSampleAttributes attrsValue = {};
227 ASSERT_NE(nullptr, manager);
228 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
229 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
230 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 8000);
231
232 ret = render->attr.SetSampleAttributes(render, &attrs);
233 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
234 ret = render->attr.GetSampleAttributes(render, &attrsValue);
235 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
236
237 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
238 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
239 EXPECT_EQ(ret2, attrsValue.sampleRate);
240 EXPECT_EQ(ret1, attrsValue.channelCount);
241
242 adapter->DestroyRender(adapter, render);
243 manager->UnloadAdapter(manager, adapter);
244 }
245 /**
246 * @tc.name AudioRenderGetSampleAttributes_001
247 * @tc.desc Test AudioRenderGetSampleAttributes ,the setting parameters are as follows.
248 * @tc.type: FUNC
249 * attrs.type = AUDIO_IN_MEDIA;
250 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
251 * attrs.sampleRate = 8000;
252 * attrs.channelCount = 1;
253 */
254 HWTEST_F(AudioUsbRenderTest, AudioRenderGetSampleAttributes_001, TestSize.Level1)
255 {
256 int32_t ret = -1;
257 uint32_t ret1 = 8000;
258 uint32_t ret2 = 1;
259 struct AudioAdapter *adapter = nullptr;
260 struct AudioRender *render = nullptr;
261 struct AudioSampleAttributes attrs = {};
262 struct AudioSampleAttributes attrsValue = {};
263 ASSERT_NE(nullptr, manager);
264 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
265 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
266
267 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 8000);
268 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
269 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
270
271 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
272 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
273 EXPECT_EQ(ret1, attrsValue.sampleRate);
274 EXPECT_EQ(ret2, attrsValue.channelCount);
275
276 adapter->DestroyRender(adapter, render);
277 manager->UnloadAdapter(manager, adapter);
278 }
279 /**
280 * @tc.name AudioRenderStart_001
281 * @tc.desc Test AudioRenderStart interface,return 0 if the audiorender object is created successfully.
282 * @tc.type: FUNC
283 */
284 HWTEST_F(AudioUsbRenderTest, AudioRenderStart_001, TestSize.Level1)
285 {
286 int32_t ret = -1;
287 struct AudioAdapter *adapter = nullptr;
288 struct AudioRender *render = nullptr;
289
290 ASSERT_NE(nullptr, manager);
291 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
292 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
293 ret = render->control.Start((AudioHandle)render);
294 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
295
296 ret = render->control.Stop((AudioHandle)render);
297 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
298 adapter->DestroyRender(adapter, render);
299 manager->UnloadAdapter(manager, adapter);
300 }
301 /**
302 * @tc.name AudioRenderStart_003
303 * @tc.desc Test AudioRenderStart interface,return -1 the second time if the RenderStart is called twice
304 * @tc.type: FUNC
305 */
306 HWTEST_F(AudioUsbRenderTest, AudioRenderStart_003, TestSize.Level1)
307 {
308 int32_t ret = -1;
309 struct AudioAdapter *adapter = nullptr;
310 struct AudioRender *render = nullptr;
311
312 ASSERT_NE(nullptr, manager);
313 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
314 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
315 ret = render->control.Start((AudioHandle)render);
316 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
317 ret = render->control.Start((AudioHandle)render);
318 EXPECT_EQ(AUDIO_HAL_ERR_AO_BUSY, ret);
319
320 ret = render->control.Stop((AudioHandle)render);
321 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
322 adapter->DestroyRender(adapter, render);
323 manager->UnloadAdapter(manager, adapter);
324 }
325 /**
326 * @tc.name AudioRenderStop_001
327 * @tc.desc test AudioRenderStop interface. return 0 if the rendering is successfully stopped.
328 * @tc.type: FUNC
329 */
330 HWTEST_F(AudioUsbRenderTest, AudioRenderStop_001, TestSize.Level1)
331 {
332 int32_t ret = -1;
333 struct AudioAdapter *adapter = nullptr;
334 struct AudioRender *render = nullptr;
335
336 ASSERT_NE(nullptr, manager);
337 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
338 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
339 ret = render->control.Start((AudioHandle)render);
340 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
341 ret = render->control.Stop((AudioHandle)render);
342 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
343
344 adapter->DestroyRender(adapter, render);
345 manager->UnloadAdapter(manager, adapter);
346 }
347 /**
348 * @tc.name AudioRenderStop_002
349 * @tc.desc test AudioRenderStop interface. return -4 if the render does not start and stop only
350 * @tc.type: FUNC
351 */
352 HWTEST_F(AudioUsbRenderTest, AudioRenderStop_002, TestSize.Level1)
353 {
354 int32_t ret = -1;
355 struct AudioAdapter *adapter = nullptr;
356 struct AudioRender *render = nullptr;
357
358 ASSERT_NE(nullptr, manager);
359 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
360 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
361 ret = render->control.Stop((AudioHandle)render);
362 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
363
364 adapter->DestroyRender(adapter, render);
365 manager->UnloadAdapter(manager, adapter);
366 }
367 /**
368 * @tc.name AudioRenderStop_003
369 * @tc.desc Test RenderStop interface,return -4 the second time if the RenderStop is called twice
370 * @tc.type: FUNC
371 */
372 HWTEST_F(AudioUsbRenderTest, AudioRenderStop_003, TestSize.Level1)
373 {
374 int32_t ret = -1;
375 struct AudioAdapter *adapter = nullptr;
376 struct AudioRender *render = nullptr;
377
378 ASSERT_NE(nullptr, manager);
379 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
380 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
381 ret = render->control.Start((AudioHandle)render);
382 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
383 ret = render->control.Stop((AudioHandle)render);
384 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
385 ret = render->control.Stop((AudioHandle)render);
386 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
387
388 adapter->DestroyRender(adapter, render);
389 manager->UnloadAdapter(manager, adapter);
390 }
391 /**
392 * @tc.name AudioRenderPause_01
393 * @tc.desc test HDI RenderPause interface，return 0 if the render is paused after start
394 * @tc.type: FUNC
395 */
396 HWTEST_F(AudioUsbRenderTest, AudioRenderPause_001, TestSize.Level1)
397 {
398 int32_t ret = -1;
399 struct AudioAdapter *adapter = nullptr;
400 struct AudioRender *render = nullptr;
401
402 ASSERT_NE(nullptr, manager);
403 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
404 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
405 ret = render->control.Pause((AudioHandle)render);
406 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
407
408 ret = render->control.Stop((AudioHandle)render);
409 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
410 adapter->DestroyRender(adapter, render);
411 manager->UnloadAdapter(manager, adapter);
412 }
413 /**
414 * @tc.name AudioRenderPause_002
415 * @tc.desc Test AudioRenderPause interface, return -1 the second time if RenderPause is called twice
416 * @tc.type: FUNC
417 */
418 HWTEST_F(AudioUsbRenderTest, AudioRenderPause_002, TestSize.Level1)
419 {
420 int32_t ret = -1;
421 struct AudioAdapter *adapter = nullptr;
422 struct AudioRender *render = nullptr;
423
424 ASSERT_NE(nullptr, manager);
425 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
426 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
427 ret = render->control.Pause((AudioHandle)render);
428 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
429 ret = render->control.Pause((AudioHandle)render);
430 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
431
432 render->control.Stop((AudioHandle)render);
433 adapter->DestroyRender(adapter, render);
434 manager->UnloadAdapter(manager, adapter);
435 }
436 /**
437 * @tc.name AudioRenderPause_003
438 * @tc.desc Test AudioRenderPause interface,return -1 if the render is paused after created.
439 * @tc.type: FUNC
440 */
441 HWTEST_F(AudioUsbRenderTest, AudioRenderPause_003, TestSize.Level1)
442 {
443 int32_t ret = -1;
444 struct AudioAdapter *adapter = nullptr;
445 struct AudioRender *render = nullptr;
446
447 ASSERT_NE(nullptr, manager);
448 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
449 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
450 ret = render->control.Pause((AudioHandle)render);
451 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
452 adapter->DestroyRender(adapter, render);
453 manager->UnloadAdapter(manager, adapter);
454 }
455 /**
456 * @tc.name AudioRenderPause_005
457 * @tc.desc Test AudioRenderPause interface, return -1 the render is paused after stopped.
458 * @tc.type: FUNC
459 */
460 HWTEST_F(AudioUsbRenderTest, AudioRenderPause_005, TestSize.Level1)
461 {
462 int32_t ret = -1;
463 struct AudioAdapter *adapter = nullptr;
464 struct AudioRender *render = nullptr;
465
466 ASSERT_NE(nullptr, manager);
467 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
468 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
469 ret = render->control.Stop((AudioHandle)render);
470 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
471 ret = render->control.Pause((AudioHandle)render);
472 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
473
474 adapter->DestroyRender(adapter, render);
475 manager->UnloadAdapter(manager, adapter);
476 }
477 /**
478 * @tc.name AudioRenderResume_001
479 * @tc.desc test HDI RenderResume interface,return -1 if the render is resumed after started
480 * @tc.type: FUNC
481 */
482 HWTEST_F(AudioUsbRenderTest, AudioRenderResume_001, TestSize.Level1)
483 {
484 int32_t ret = -1;
485 struct AudioAdapter *adapter = nullptr;
486 struct AudioRender *render = nullptr;
487
488 ASSERT_NE(nullptr, manager);
489 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
490 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
491 ret = render->control.Resume((AudioHandle)render);
492 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
493
494 ret = render->control.Stop((AudioHandle)render);
495 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
496 adapter->DestroyRender(adapter, render);
497 manager->UnloadAdapter(manager, adapter);
498 }
499 /**
500 * @tc.name AudioRenderResume_002
501 * @tc.desc test HDI RenderResume interface,return -1 if the render is resumed after stopped
502 * @tc.type: FUNC
503 */
504 HWTEST_F(AudioUsbRenderTest, AudioRenderResume_002, TestSize.Level1)
505 {
506 int32_t ret = -1;
507 struct AudioAdapter *adapter = nullptr;
508 struct AudioRender *render = nullptr;
509
510 ASSERT_NE(nullptr, manager);
511 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
512 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
513 ret = render->control.Stop((AudioHandle)render);
514 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
515 ret = render->control.Resume((AudioHandle)render);
516 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
517
518 adapter->DestroyRender(adapter, render);
519 manager->UnloadAdapter(manager, adapter);
520 }
521 /**
522 * @tc.name AudioRenderResume_003
523 * @tc.desc Test AudioRenderResume interface,return 0 if the render is resumed after paused
524 * @tc.type: FUNC
525 */
526 HWTEST_F(AudioUsbRenderTest, AudioRenderResume_003, TestSize.Level1)
527 {
528 int32_t ret = -1;
529 struct AudioAdapter *adapter = nullptr;
530 struct AudioRender *render = nullptr;
531
532 ASSERT_NE(nullptr, manager);
533 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
534 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
535 ret = render->control.Pause((AudioHandle)render);
536 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
537 ret = render->control.Resume((AudioHandle)render);
538 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
539
540 ret = render->control.Stop((AudioHandle)render);
541 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
542 adapter->DestroyRender(adapter, render);
543 manager->UnloadAdapter(manager, adapter);
544 }
545 /**
546 * @tc.name AudioRenderResume_004
547 * @tc.desc Test RenderResume interface,return -1 the second time if the RenderResume is called twice
548 * @tc.type: FUNC
549 */
550 HWTEST_F(AudioUsbRenderTest, AudioRenderResume_004, TestSize.Level1)
551 {
552 int32_t ret = -1;
553 struct AudioAdapter *adapter = nullptr;
554 struct AudioRender *render = nullptr;
555
556 ASSERT_NE(nullptr, manager);
557 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
558 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
559 ret = render->control.Pause((AudioHandle)render);
560 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
561 ret = render->control.Resume((AudioHandle)render);
562 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
563 ret = render->control.Resume((AudioHandle)render);
564 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
565
566 ret = render->control.Stop((AudioHandle)render);
567 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
568 adapter->DestroyRender(adapter, render);
569 manager->UnloadAdapter(manager, adapter);
570 }
571 /**
572 * @tc.name AudioRenderResume_005
573 * @tc.desc test HDI RenderResume interface,return -1 if the render Continue to start after resume
574 * @tc.type: FUNC
575 */
576 HWTEST_F(AudioUsbRenderTest, AudioRenderResume_005, TestSize.Level1)
577 {
578 int32_t ret = -1;
579 struct AudioAdapter *adapter = nullptr;
580 struct AudioRender *render = nullptr;
581
582 ASSERT_NE(nullptr, manager);
583 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
584 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
585 ret = render->control.Pause((AudioHandle)render);
586 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
587 ret = render->control.Resume((AudioHandle)render);
588 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
589 ret = render->control.Start((AudioHandle)render);
590 EXPECT_EQ(AUDIO_HAL_ERR_AO_BUSY, ret);
591
592 ret = render->control.Stop((AudioHandle)render);
593 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
594 adapter->DestroyRender(adapter, render);
595 manager->UnloadAdapter(manager, adapter);
596 }
597 /**
598 * @tc.name AudioRenderFrame_001
599 * @tc.desc test AudioRenderFrame interface,Returns 0 if the data is written successfully
600 * @tc.type: FUNC
601 */
602 HWTEST_F(AudioUsbRenderTest, AudioRenderFrame_001, TestSize.Level1)
603 {
604 int32_t ret = -1;
605 uint64_t requestBytes = 0;
606 uint64_t replyBytes = 0;
607 struct AudioAdapter *adapter = nullptr;
608 struct AudioRender *render = nullptr;
609 char *frame = nullptr;
610 ASSERT_NE(nullptr, manager);
611 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
612 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
613 ret = render->control.Start((AudioHandle)render);
614 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
615
616 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
617 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
618 ret = render->RenderFrame(render, frame, requestBytes, &replyBytes);
619 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
620
621 render->control.Stop((AudioHandle)render);
622 adapter->DestroyRender(adapter, render);
623 manager->UnloadAdapter(manager, adapter);
624 if (frame != nullptr) {
625 free(frame);
626 frame = nullptr;
627 }
628 }
629 /**
630 * @tc.name AudioRenderFrame_005
631 * @tc.desc Test AudioRenderFrame interface,Returns -1 if without calling interface renderstart
632 * @tc.type: FUNC
633 */
634 HWTEST_F(AudioUsbRenderTest, AudioRenderFrame_005, TestSize.Level1)
635 {
636 int32_t ret = -1;
637 uint64_t replyBytes = 0;
638 uint64_t requestBytes = 0;
639 struct AudioAdapter *adapter = nullptr;
640 struct AudioRender *render = nullptr;
641 char *frame = nullptr;
642
643 ASSERT_NE(nullptr, manager);
644 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
645 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
646 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
647 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
648 ret = render->RenderFrame(render, frame, requestBytes, &replyBytes);
649 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
650
651 adapter->DestroyRender(adapter, render);
652 manager->UnloadAdapter(manager, adapter);
653 if (frame != nullptr) {
654 free(frame);
655 frame = nullptr;
656 }
657 }
658 /**
659 * @tc.name AudioRenderSetChannelMode_001
660 * @tc.desc Test SetChannelMode interface,return 0 if set channel mode to different enumeration values
661 * @tc.type: FUNC
662 */
663 HWTEST_F(AudioUsbRenderTest, AudioRenderSetChannelMode_001, TestSize.Level1)
664 {
665 int32_t ret = -1;
666 struct AudioAdapter *adapter = nullptr;
667 struct AudioRender *render = nullptr;
668 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
669 AudioChannelMode modeOne = AUDIO_CHANNEL_BOTH_LEFT;
670 AudioChannelMode modeSec = AUDIO_CHANNEL_BOTH_RIGHT;
671 AudioChannelMode modeTrd = AUDIO_CHANNEL_EXCHANGE;
672 ASSERT_NE(nullptr, manager);
673 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
674 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
675 ret = render->SetChannelMode(render, mode);
676 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
677 ret = render->GetChannelMode(render, &mode);
678 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
679 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
680 ret = render->SetChannelMode(render, modeOne);
681 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
682 ret = render->GetChannelMode(render, &modeOne);
683 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
684 EXPECT_EQ(AUDIO_CHANNEL_BOTH_LEFT, modeOne);
685 ret = render->SetChannelMode(render, modeSec);
686 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
687 ret = render->GetChannelMode(render, &modeSec);
688 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
689 EXPECT_EQ(AUDIO_CHANNEL_BOTH_RIGHT, modeSec);
690 ret = render->SetChannelMode(render, modeTrd);
691 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
692 ret = render->GetChannelMode(render, &modeTrd);
693 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
694 EXPECT_EQ(AUDIO_CHANNEL_EXCHANGE, modeTrd);
695 render->control.Stop((AudioHandle)render);
696 adapter->DestroyRender(adapter, render);
697 manager->UnloadAdapter(manager, adapter);
698 }
699 /**
700 * @tc.name AudioRenderSetChannelMode_002
701 * @tc.desc Test SetChannelMode interface,return 0 if set channel mode to different values
702 * @tc.type: FUNC
703 */
704 HWTEST_F(AudioUsbRenderTest, AudioRenderSetChannelMode_002, TestSize.Level1)
705 {
706 int32_t ret = -1;
707 struct AudioAdapter *adapter = nullptr;
708 struct AudioRender *render = nullptr;
709 AudioChannelMode mode = AUDIO_CHANNEL_MIX;
710 AudioChannelMode modeOne = AUDIO_CHANNEL_LEFT_MUTE;
711 AudioChannelMode modeSec = AUDIO_CHANNEL_RIGHT_MUTE;
712 AudioChannelMode modeTrd = AUDIO_CHANNEL_BOTH_MUTE;
713 ASSERT_NE(nullptr, manager);
714 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
715 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
716 ret = render->SetChannelMode(render, mode);
717 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
718 ret = render->GetChannelMode(render, &mode);
719 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
720 EXPECT_EQ(AUDIO_CHANNEL_MIX, mode);
721 ret = render->SetChannelMode(render, modeOne);
722 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
723 ret = render->GetChannelMode(render, &modeOne);
724 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
725 EXPECT_EQ(AUDIO_CHANNEL_LEFT_MUTE, modeOne);
726 ret = render->SetChannelMode(render, modeSec);
727 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
728 ret = render->GetChannelMode(render, &modeSec);
729 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
730 EXPECT_EQ(AUDIO_CHANNEL_RIGHT_MUTE, modeSec);
731 ret = render->SetChannelMode(render, modeTrd);
732 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
733 ret = render->GetChannelMode(render, &modeTrd);
734 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
735 EXPECT_EQ(AUDIO_CHANNEL_BOTH_MUTE, modeTrd);
736 render->control.Stop((AudioHandle)render);
737 adapter->DestroyRender(adapter, render);
738 manager->UnloadAdapter(manager, adapter);
739 }
740 /**
741 * @tc.name AudioRenderSetChannelMode_003
742 * @tc.desc Test SetChannelMode interface,return 0 if set channel mode after render object is created
743 * @tc.type: FUNC
744 */
745 HWTEST_F(AudioUsbRenderTest, AudioRenderSetChannelMode_003, TestSize.Level1)
746 {
747 int32_t ret = -1;
748 struct AudioAdapter *adapter = nullptr;
749 struct AudioRender *render = nullptr;
750 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
751 ASSERT_NE(nullptr, manager);
752 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
753 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
754 ret = render->SetChannelMode(render, mode);
755 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
756 ret = render->GetChannelMode(render, &mode);
757 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
758 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
759
760 adapter->DestroyRender(adapter, render);
761 manager->UnloadAdapter(manager, adapter);
762 }
763 /**
764 * @tc.name AudioRenderGetChannelMode_001
765 * @tc.desc Test GetChannelMode interface,return 0 if getting the channel mode after setting
766 * @tc.type: FUNC
767 */
768 HWTEST_F(AudioUsbRenderTest, AudioRenderGetChannelMode_001, TestSize.Level1)
769 {
770 int32_t ret = -1;
771 struct AudioAdapter *adapter = nullptr;
772 struct AudioRender *render = nullptr;
773 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
774 ASSERT_NE(nullptr, manager);
775 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
776 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
777
778 ret = render->GetChannelMode(render, &mode);
779 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
780 ret = render->SetChannelMode(render, mode);
781 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
782 ret = render->GetChannelMode(render, &mode);
783 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
784 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
785
786 render->control.Stop((AudioHandle)render);
787 adapter->DestroyRender(adapter, render);
788 manager->UnloadAdapter(manager, adapter);
789 }
790 /**
791 * @tc.name AudioRenderGetChannelMode_003
792 * @tc.desc Test GetChannelMode interface,return 0 if getting the channel mode after the object is created
793 * @tc.type: FUNC
794 */
795 HWTEST_F(AudioUsbRenderTest, AudioRenderGetChannelMode_003, TestSize.Level1)
796 {
797 int32_t ret = -1;
798 struct AudioAdapter *adapter = nullptr;
799 struct AudioRender *render = nullptr;
800 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
801 ASSERT_NE(nullptr, manager);
802 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
803 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
804 ret = render->GetChannelMode(render, &mode);
805 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
806 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
807
808 adapter->DestroyRender(adapter, render);
809 manager->UnloadAdapter(manager, adapter);
810 }
811 /**
812 * @tc.name AudioRenderSetRenderSpeed_001
813 * @tc.desc Test SetRenderSpeed interface,return -2 if setting RenderSpeed
814 * @tc.type: FUNC
815 */
816 HWTEST_F(AudioUsbRenderTest, AudioRenderSetRenderSpeed_001, TestSize.Level1)
817 {
818 int32_t ret = -1;
819 float speed = 100;
820 struct AudioAdapter *adapter = nullptr;
821 struct AudioRender *render = nullptr;
822 ASSERT_NE(nullptr, manager);
823 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
824 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
825
826 ret = render->SetRenderSpeed(render, speed);
827 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
828
829 render->control.Stop((AudioHandle)render);
830 adapter->DestroyRender(adapter, render);
831 manager->UnloadAdapter(manager, adapter);
832 }
833 /**
834 * @tc.name AudioRenderGetRenderSpeed_001
835 * @tc.desc Test GetRenderSpeed interface,return -2 if getting RenderSpeed
836 * @tc.type: FUNC
837 */
838 HWTEST_F(AudioUsbRenderTest, AudioRenderGetRenderSpeed_001, TestSize.Level1)
839 {
840 int32_t ret = -1;
841 float speed = 0;
842 struct AudioAdapter *adapter = nullptr;
843 struct AudioRender *render = nullptr;
844 ASSERT_NE(nullptr, manager);
845 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
846 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
847 ret = render->GetRenderSpeed(render, &speed);
848 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
849
850 render->control.Stop((AudioHandle)render);
851 adapter->DestroyRender(adapter, render);
852 manager->UnloadAdapter(manager, adapter);
853 }
854 /**
855 * @tc.name AudioRenderGetLatency_001
856 * @tc.desc test RenderGetLatency interface, return 0 if GetLatency successful
857 * @tc.type: FUNC
858 */
859 HWTEST_F(AudioUsbRenderTest, AudioRenderGetLatency_001, TestSize.Level1)
860 {
861 int32_t ret = -1;
862 uint32_t latencyTime = 0;
863 uint32_t expectLatency = 0;
864 struct AudioAdapter *adapter = nullptr;
865 struct AudioRender *render = nullptr;
866 ASSERT_NE(nullptr, manager);
867 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
868 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
869
870 ret = render->GetLatency(render, &latencyTime);
871 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
872 EXPECT_LT(expectLatency, latencyTime);
873
874 ret = render->control.Stop((AudioHandle)render);
875 adapter->DestroyRender(adapter, render);
876 manager->UnloadAdapter(manager, adapter);
877 }
878 /**
879 * @tc.name AudioRenderFlush_001
880 * @tc.desc Test RenderFlush interface,return -2 if the data in the buffer is flushed successfully after stop
881 * @tc.type: FUNC
882 */
883 HWTEST_F(AudioUsbRenderTest, AudioRenderFlush_001, TestSize.Level1)
884 {
885 int32_t ret = -1;
886 struct AudioAdapter *adapter = nullptr;
887 struct AudioRender *render = nullptr;
888
889 ASSERT_NE(nullptr, manager);
890 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
891 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
892 ret = render->control.Stop((AudioHandle)render);
893 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
894 ret = render->control.Flush((AudioHandle)render);
895 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
896
897 adapter->DestroyRender(adapter, render);
898 manager->UnloadAdapter(manager, adapter);
899 }
900 /**
901 * @tc.name AudioRenderGetFrameSize_001
902 * @tc.desc Test RenderGetFrameSize interface,return 0 if the FrameSize was obtained successfully
903 * @tc.type: FUNC
904 */
905 HWTEST_F(AudioUsbRenderTest, AudioRenderGetFrameSize_001, TestSize.Level1)
906 {
907 int32_t ret = -1;
908 uint64_t size = 0;
909 uint64_t zero = 0;
910 struct AudioAdapter *adapter = nullptr;
911 struct AudioRender *render = nullptr;
912 ASSERT_NE(nullptr, manager);
913 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
914 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
915
916 ret = render->attr.GetFrameSize(render, &size);
917 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
918 EXPECT_GT(size, zero);
919
920 adapter->DestroyRender(adapter, render);
921 manager->UnloadAdapter(manager, adapter);
922 }
923 /**
924 * @tc.name AudioRenderGetFrameSize_004
925 * @tc.desc Test RenderGetFrameSize interface,return 0 if get framesize define format as different values
926 * @tc.type: FUNC
927 */
928 HWTEST_F(AudioUsbRenderTest, AudioRenderGetFrameSize_004, TestSize.Level1)
929 {
930 int32_t ret = -1;
931 uint64_t size = 0;
932 uint64_t channelCountExp = 2;
933 uint32_t sampleRateExp = 48000;
934 struct AudioSampleAttributes attrs = {};
935 struct AudioSampleAttributes attrsValue = {};
936 struct AudioAdapter *adapter = nullptr;
937 struct AudioRender *render = nullptr;
938 ASSERT_NE(nullptr, manager);
939 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
940 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
941 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 48000);
942
943 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
944 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
945 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
946 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
947 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
948
949 ret = render->attr.GetFrameSize(render, &size);
950 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
951 EXPECT_GT(size, INITIAL_VALUE);
952
953 adapter->DestroyRender(adapter, render);
954 manager->UnloadAdapter(manager, adapter);
955 }
956 /**
957 * @tc.name AudioRenderGetFrameCount_001
958 * @tc.desc Test RenderGetFrameCount interface, return 0 if the FrameSize was obtained successfully
959 * @tc.type: FUNC
960 */
961 HWTEST_F(AudioUsbRenderTest, AudioRenderGetFrameCount_001, TestSize.Level1)
962 {
963 int32_t ret = -1;
964 uint64_t count = 0;
965 uint64_t zero = 0;
966 struct AudioAdapter *adapter = nullptr;
967 struct AudioRender *render = nullptr;
968 ASSERT_NE(nullptr, manager);
969 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
970 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
971
972 ret = render->attr.GetFrameCount(render, &count);
973 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
974 EXPECT_GT(count, zero);
975
976 render->control.Stop((AudioHandle)render);
977 adapter->DestroyRender(adapter, render);
978 manager->UnloadAdapter(manager, adapter);
979 }
980 /**
981 * @tc.name AudioRenderGetFrameCount_004
982 * @tc.desc Test RenderGetFrameCount interface,return 0 if get framesize define channelCount as different values
983 * @tc.type: FUNC
984 */
985 HWTEST_F(AudioUsbRenderTest, AudioRenderGetFrameCount_004, TestSize.Level1)
986 {
987 int32_t ret = -1;
988 uint64_t count = 0;
989 uint64_t channelCountExp = 2;
990 uint32_t sampleRateExp = 8000;
991 struct AudioAdapter *adapter = nullptr;
992 struct AudioRender *render = nullptr;
993 struct AudioSampleAttributes attrs = {};
994 struct AudioSampleAttributes attrsValue = {};
995 ASSERT_NE(nullptr, manager);
996 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
997 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
998 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 8000);
999
1000 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
1001 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1002 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
1003 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1004 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1005
1006 ret = AudioRenderStartAndOneFrame(render);
1007 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1008 ret = render->attr.GetFrameCount(render, &count);
1009 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1010 EXPECT_GT(count, INITIAL_VALUE);
1011
1012 ret = render->control.Stop((AudioHandle)render);
1013 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1014 adapter->DestroyRender(adapter, render);
1015 manager->UnloadAdapter(manager, adapter);
1016 }
1017 /**
1018 * @tc.name AudioRenderGetCurrentChannelId_001
1019 * @tc.desc Test RenderGetCurrentChannelId, return 0 if the default CurrentChannelId is obtained successfully
1020 * @tc.type: FUNC
1021 */
1022 HWTEST_F(AudioUsbRenderTest, AudioRenderGetCurrentChannelId_001, TestSize.Level1)
1023 {
1024 int32_t ret = -1;
1025 uint32_t channelId = 0;
1026 uint32_t channelIdValue = CHANNELCOUNT;
1027 struct AudioAdapter *adapter = nullptr;
1028 struct AudioRender *render = nullptr;
1029 ASSERT_NE(nullptr, manager);
1030 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1031 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1032
1033 ret = render->attr.GetCurrentChannelId(render, &channelId);
1034 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1035 EXPECT_EQ(channelIdValue, channelId);
1036
1037 adapter->DestroyRender(adapter, render);
1038 manager->UnloadAdapter(manager, adapter);
1039 }
1040 /**
1041 * @tc.name AudioRenderGetCurrentChannelId_003
1042 * @tc.desc Test GetCurrentChannelId interface,return 0 if get channelId to 1 and set channelCount to 1
1043 * @tc.type: FUNC
1044 */
1045 HWTEST_F(AudioUsbRenderTest, AudioRenderGetCurrentChannelId_002, TestSize.Level1)
1046 {
1047 int32_t ret = -1;
1048 uint32_t channelId = 0;
1049 uint32_t channelIdExp = 1;
1050 uint32_t channelCountExp = 1;
1051 struct AudioSampleAttributes attrs = {};
1052 struct AudioSampleAttributes attrsValue = {};
1053 struct AudioAdapter *adapter = nullptr;
1054 struct AudioRender *render = nullptr;
1055 ASSERT_NE(nullptr, manager);
1056 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1057 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1058 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 32000);
1059
1060 ret = AudioRenderSetGetSampleAttributes(attrs, attrsValue, render);
1061 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1062 EXPECT_EQ(channelCountExp, attrs.channelCount);
1063
1064 ret = render->attr.GetCurrentChannelId(render, &channelId);
1065 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1066 EXPECT_EQ(channelIdExp, channelId);
1067
1068 adapter->DestroyRender(adapter, render);
1069 manager->UnloadAdapter(manager, adapter);
1070 }
1071 /**
1072 * @tc.name AudioRenderGetCurrentChannelId_003
1073 * @tc.desc Test RenderGetCurrentChannelId interface, return 0 if CurrentChannelId is obtained after created
1074 * @tc.type: FUNC
1075 */
1076 HWTEST_F(AudioUsbRenderTest, AudioRenderGetCurrentChannelId_003, TestSize.Level1)
1077 {
1078 int32_t ret = -1;
1079 uint32_t channelId = 0;
1080 uint32_t channelIdExp = 2;
1081 struct AudioAdapter *adapter = nullptr;
1082 struct AudioRender *render = nullptr;
1083 ASSERT_NE(nullptr, manager);
1084 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1085 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1086
1087 ret = render->attr.GetCurrentChannelId(render, &channelId);
1088 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1089 EXPECT_EQ(channelIdExp, channelId);
1090
1091 adapter->DestroyRender(adapter, render);
1092 manager->UnloadAdapter(manager, adapter);
1093 }
1094 /**
1095 * @tc.name AudioRenderCheckSceneCapability_001
1096 * @tc.desc Test AudioRenderCheckSceneCapability interface,return 0 if check scene's capability successful.
1097 * @tc.type: FUNC
1098 */
1099 HWTEST_F(AudioUsbRenderTest, AudioRenderCheckSceneCapability_001, TestSize.Level1)
1100 {
1101 int32_t ret = -1;
1102 bool supported = false;
1103 struct AudioSceneDescriptor scenes = {};
1104 struct AudioAdapter *adapter = nullptr;
1105 struct AudioRender *render = nullptr;
1106 ASSERT_NE(nullptr, manager);
1107 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1108 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1109
1110 scenes.scene.id = 0;
1111 scenes.desc.pins = PIN_OUT_SPEAKER;
1112 ret = render->scene.CheckSceneCapability(render, &scenes, &supported);
1113 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1114 EXPECT_TRUE(supported);
1115
1116 adapter->DestroyRender(adapter, render);
1117 manager->UnloadAdapter(manager, adapter);
1118 }
1119 /**
1120 * @tc.name AudioRenderCheckSceneCapability_002
1121 * @tc.desc Test RenderCheckSceneCapability interface,return -1 if the scene is not configured in the josn.
1122 * @tc.type: FUNC
1123 */
1124 HWTEST_F(AudioUsbRenderTest, AudioRenderCheckSceneCapability_002, TestSize.Level1)
1125 {
1126 int32_t ret = -1;
1127 bool supported = true;
1128 struct AudioSceneDescriptor scenes = {};
1129 struct AudioAdapter *adapter = nullptr;
1130 struct AudioRender *render = nullptr;
1131 ASSERT_NE(nullptr, manager);
1132 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1133 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1134
1135 scenes.scene.id = 5;
1136 scenes.desc.pins = PIN_OUT_SPEAKER;
1137 ret = render->scene.CheckSceneCapability(render, &scenes, &supported);
1138 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1139
1140 adapter->DestroyRender(adapter, render);
1141 manager->UnloadAdapter(manager, adapter);
1142 }
1143 /**
1144 * @tc.name AudioRenderSelectScene_001
1145 * @tc.desc Test AudioRenderSelectScene interface,return 0 if select Render's scene successful.
1146 * @tc.type: FUNC
1147 */
1148 HWTEST_F(AudioUsbRenderTest, AudioRenderSelectScene_001, TestSize.Level1)
1149 {
1150 int32_t ret = -1;
1151 struct AudioSceneDescriptor scenes = {};
1152 struct AudioAdapter *adapter = nullptr;
1153 struct AudioRender *render = nullptr;
1154 ASSERT_NE(nullptr, manager);
1155 scenes.scene.id = 0;
1156 scenes.desc.pins = PIN_OUT_SPEAKER;
1157
1158 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1159 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1160
1161 ret = render->scene.SelectScene(render, &scenes);
1162 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1163
1164 ret = AudioRenderStartAndOneFrame(render);
1165 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1166
1167 ret = render->control.Stop((AudioHandle)render);
1168 adapter->DestroyRender(adapter, render);
1169 manager->UnloadAdapter(manager, adapter);
1170 }
1171 /**
1172 * @tc.name AudioRenderSelectScene_002
1173 * @tc.desc Test AudioRenderSelectScene, return 0 if select Render's scene successful after Render start.
1174 * @tc.type: FUNC
1175 */
1176 HWTEST_F(AudioUsbRenderTest, AudioRenderSelectScene_002, TestSize.Level1)
1177 {
1178 int32_t ret = -1;
1179 struct AudioSceneDescriptor scenes = {};
1180 struct AudioAdapter *adapter = nullptr;
1181 struct AudioRender *render = nullptr;
1182 ASSERT_NE(nullptr, manager);
1183 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
1184 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1185
1186 scenes.scene.id = 0;
1187 scenes.desc.pins = PIN_OUT_SPEAKER;
1188 ret = render->scene.SelectScene(render, &scenes);
1189 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1190
1191 ret = render->control.Stop((AudioHandle)render);
1192 adapter->DestroyRender(adapter, render);
1193 manager->UnloadAdapter(manager, adapter);
1194 }
1195 /**
1196 * @tc.name AudioRenderSelectScene_003
1197 * @tc.desc Test AudioRenderSelectScene, return -1 if the parameter handle is empty.
1198 * @tc.type: FUNC
1199 */
1200 HWTEST_F(AudioUsbRenderTest, AudioRenderSelectScene_003, TestSize.Level1)
1201 {
1202 int32_t ret = -1;
1203 struct AudioSceneDescriptor scenes = {};
1204 struct AudioAdapter *adapter = nullptr;
1205 struct AudioRender *render = nullptr;
1206 struct AudioRender *renderNull = nullptr;
1207 ASSERT_NE(nullptr, manager);
1208 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1209 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1210
1211 scenes.scene.id = 0;
1212 scenes.desc.pins = PIN_IN_MIC;
1213 ret = render->scene.SelectScene(renderNull, &scenes);
1214 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1215
1216 adapter->DestroyRender(adapter, render);
1217 manager->UnloadAdapter(manager, adapter);
1218 }
1219 /**
1220 * @tc.name AudioRenderSelectScene_005
1221 * @tc.desc Test AudioRenderSelectScene, return -1 if the scene is not configured in the josn.
1222 * @tc.type: FUNC
1223 */
1224 HWTEST_F(AudioUsbRenderTest, AudioRenderSelectScene_005, TestSize.Level1)
1225 {
1226 int32_t ret = -1;
1227 struct AudioSceneDescriptor scenes = {};
1228 struct AudioAdapter *adapter = nullptr;
1229 struct AudioRender *render = nullptr;
1230 ASSERT_NE(nullptr, manager);
1231 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1232 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1233
1234 scenes.scene.id = 5;
1235 scenes.desc.pins = PIN_OUT_HDMI;
1236 ret = render->scene.SelectScene(render, &scenes);
1237 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1238
1239 adapter->DestroyRender(adapter, render);
1240 manager->UnloadAdapter(manager, adapter);
1241 }
1242 /**
1243 * @tc.name AudioRenderGetGainThreshold_001
1244 * @tc.desc Test RenderGetGainThreshold interface,return 0 if the GetGainThreshold is obtained successfully
1245 * @tc.type: FUNC
1246 */
1247 HWTEST_F(AudioUsbRenderTest, AudioRenderGetGainThreshold_001, TestSize.Level1)
1248 {
1249 int32_t ret = -1;
1250 float min = 0;
1251 float max = 0;
1252 struct AudioAdapter *adapter = nullptr;
1253 struct AudioRender *render = nullptr;
1254 ASSERT_NE(nullptr, manager);
1255 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1256 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1257
1258 ret = render->volume.GetGainThreshold((AudioHandle)render, &min, &max);
1259 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1260 EXPECT_EQ(min, GAIN_MIN);
1261 EXPECT_EQ(max, GAIN_MAX);
1262
1263 adapter->DestroyRender(adapter, render);
1264 manager->UnloadAdapter(manager, adapter);
1265 }
1266 /**
1267 * @tc.name AudioRenderSetGain_001
1268 * @tc.desc Test RenderSetGain interface,return 0 if Set gain to normal value, maximum or minimum and get success
1269 * @tc.type: FUNC
1270 */
1271 HWTEST_F(AudioUsbRenderTest, AudioRenderSetGain_001, TestSize.Level1)
1272 {
1273 int32_t ret = -1;
1274 float min = 0;
1275 float max = 0;
1276 struct AudioAdapter *adapter = nullptr;
1277 struct AudioRender *render = nullptr;
1278 ASSERT_NE(nullptr, manager);
1279 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1280 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1281 ret = render->volume.GetGainThreshold((AudioHandle)render, &min, &max);
1282 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1283 float gain = 10.8;
1284 float gainMax = max;
1285 float gainMin = min;
1286 float gainExpc = 10;
1287 float gainMaxExpc = max;
1288 float gainMinExpc = min;
1289 ret = render->volume.SetGain(render, gain);
1290 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1291 ret = render->volume.GetGain(render, &gain);
1292 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1293 EXPECT_EQ(gainExpc, gain);
1294
1295 ret = render->volume.SetGain(render, gainMax);
1296 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1297 ret = render->volume.GetGain(render, &gainMax);
1298 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1299 EXPECT_EQ(gainMaxExpc, gainMax);
1300
1301 ret = render->volume.SetGain(render, gainMin);
1302 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1303 ret = render->volume.GetGain(render, &gainMin);
1304 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1305 EXPECT_EQ(gainMinExpc, gainMin);
1306
1307 adapter->DestroyRender(adapter, render);
1308 manager->UnloadAdapter(manager, adapter);
1309 }
1310 /**
1311 * @tc.name AudioRenderGetGain_001
1312 * @tc.desc Test RenderGetGain interface,return 0 if the RenderGetGain was obtained successfully
1313 * @tc.type: FUNC
1314 */
1315 HWTEST_F(AudioUsbRenderTest, AudioRenderGetGain_001, TestSize.Level1)
1316 {
1317 int32_t ret = -1;
1318 float min = 0;
1319 float max = 0;
1320 struct AudioAdapter *adapter = nullptr;
1321 struct AudioRender *render = nullptr;
1322 ASSERT_NE(nullptr, manager);
1323 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1324 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1325 ret = render->volume.GetGainThreshold((AudioHandle)render, &min, &max);
1326 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1327
1328 float gain = min + 1;
1329 float gainValue = min + 1;
1330 ret = render->volume.SetGain(render, gain);
1331 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1332 ret = render->volume.GetGain(render, &gain);
1333 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1334 EXPECT_EQ(gainValue, gain);
1335
1336 render->control.Stop((AudioHandle)render);
1337 adapter->DestroyRender(adapter, render);
1338 manager->UnloadAdapter(manager, adapter);
1339 }
1340 /**
1341 * @tc.name AudioRenderGetRenderPosition_001
1342 * @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition during playing.
1343 * @tc.type: FUNC
1344 */
1345 HWTEST_F(AudioUsbRenderTest, AudioRenderGetRenderPosition_001, TestSize.Level1)
1346 {
1347 int32_t ret = -1;
1348 uint64_t frames = 0;
1349 int64_t timeExp = 0;
1350 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
1351 struct PrepareAudioPara audiopara = {
1352 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER,
1353 .path = AUDIO_FILE.c_str()
1354 };
1355 audiopara.manager = manager;
1356 ASSERT_NE(audiopara.manager, nullptr);
1357
1358 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
1359 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1360 sleep(1);
1361 if (audiopara.render != nullptr) {
1362 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
1363 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1364 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
1365 EXPECT_GT(frames, INITIAL_VALUE);
1366 }
1367
1368 ret = ThreadRelease(audiopara);
1369 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1370 }
1371 /**
1372 * @tc.name AudioRenderGetRenderPosition_002
1373 * @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition after Pause and resume during playing
1374 * @tc.type: FUNC
1375 */
1376 HWTEST_F(AudioUsbRenderTest, AudioRenderGetRenderPosition_002, TestSize.Level1)
1377 {
1378 int32_t ret = -1;
1379 int64_t timeExp = 0;
1380 uint64_t frames = 0;
1381 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
1382 struct PrepareAudioPara audiopara = {
1383 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER,
1384 .path = AUDIO_FILE.c_str()
1385 };
1386 audiopara.manager = manager;
1387 ASSERT_NE(audiopara.manager, nullptr);
1388
1389 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
1390 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1391 sleep(1);
1392 if (audiopara.render != nullptr) {
1393 FrameStatus(0);
1394 usleep(1000);
1395 ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render));
1396 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1397 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
1398 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1399 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
1400 EXPECT_GT(frames, INITIAL_VALUE);
1401 usleep(1000);
1402 ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render));
1403 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1404 FrameStatus(1);
1405 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
1406 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1407 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
1408 EXPECT_GT(frames, INITIAL_VALUE);
1409 }
1410
1411 ret = ThreadRelease(audiopara);
1412 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1413 }
1414 /**
1415 * @tc.name AudioRenderGetRenderPosition_003
1416 * @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition after stop
1417 * @tc.type: FUNC
1418 */
1419 HWTEST_F(AudioUsbRenderTest, AudioRenderGetRenderPosition_003, TestSize.Level1)
1420 {
1421 int32_t ret = -1;
1422 int64_t timeExp = 0;
1423 uint64_t frames = 0;
1424 struct AudioAdapter *adapter = nullptr;
1425 struct AudioRender *render = nullptr;
1426 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
1427 ASSERT_NE(nullptr, manager);
1428 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
1429 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1430 ret = render->control.Stop((AudioHandle)render);
1431 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1432
1433 ret = render->GetRenderPosition(render, &frames, &time);
1434 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1435 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
1436 EXPECT_GT(frames, INITIAL_VALUE);
1437
1438 adapter->DestroyRender(adapter, render);
1439 manager->UnloadAdapter(manager, adapter);
1440 }
1441 /**
1442 * @tc.name AudioRenderSetExtraParams_001
1443 * @tc.desc Test RenderSetExtraParams interface,return 0 if the ExtraParams is set during playback
1444 * @tc.type: FUNC
1445 */
1446 HWTEST_F(AudioUsbRenderTest, AudioRenderSetExtraParams_001, TestSize.Level1)
1447 {
1448 int32_t ret = -1;
1449 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
1450 char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-sampling-rate=48000";
1451 size_t index = 1;
1452 char keyValueListValue[256] = {};
1453 int32_t listLenth = 256;
1454 struct PrepareAudioPara audiopara = {
1455 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER,
1456 .path = AUDIO_FILE.c_str()
1457 };
1458 audiopara.manager = manager;
1459 ASSERT_NE(nullptr, audiopara.manager);
1460
1461 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
1462 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1463 sleep(1);
1464 if (audiopara.render != nullptr) {
1465 ret = audiopara.render->attr.SetExtraParams((AudioHandle)audiopara.render, keyValueList);
1466 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1467 ret = audiopara.render->attr.GetExtraParams((AudioHandle)audiopara.render, keyValueListValue, listLenth);
1468 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1469 string strGetValue = keyValueListValue;
1470 size_t indexAttr = strGetValue.find("attr-frame-count");
1471 size_t indexFlag = strGetValue.rfind(";");
1472 if (indexAttr != string::npos && indexFlag != string::npos) {
1473 strGetValue.replace(indexAttr, indexFlag - indexAttr + index, "");
1474 }
1475 EXPECT_STREQ(keyValueListExp, strGetValue.c_str());
1476 }
1477
1478 ret = ThreadRelease(audiopara);
1479 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1480 }
1481 /**
1482 * @tc.name AudioRenderSetExtraParams_002
1483 * @tc.desc Test RenderSetExtraParams interface,return 0 if some parameters is set after playing
1484 * @tc.type: FUNC
1485 */
1486 HWTEST_F(AudioUsbRenderTest, AudioRenderSetExtraParams_002, TestSize.Level1)
1487 {
1488 int32_t ret = -1;
1489 struct AudioAdapter *adapter = {};
1490 struct AudioRender *render = nullptr;
1491 char keyValueListOne[] = "attr-frame-count=1024;";
1492 char keyValueListOneExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=1024;\
1493 attr-sampling-rate=48000";
1494 char keyValueListTwo[] = "attr-format=16;attr-frame-count=1024;";
1495 char keyValueListTwoExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=1024;\
1496 attr-sampling-rate=48000";
1497 char keyValueListThr[] = "attr-route=1;attr-channels=1;attr-frame-count=1024;";
1498 char keyValueListThrExp[] = "attr-route=1;attr-format=16;attr-channels=1;attr-frame-count=1024;\
1499 attr-sampling-rate=48000";
1500 char keyValueListFour[] = "attr-format=32;attr-channels=2;attr-frame-count=4096;attr-sampling-rate=48000";
1501 char keyValueListFourExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=4096;\
1502 attr-sampling-rate=48000";
1503 char keyValueListValueOne[256] = {};
1504 char keyValueListValueTwo[256] = {};
1505 char keyValueListValueThr[256] = {};
1506 char keyValueListValueFour[256] = {};
1507 int32_t listLenth = 256;
1508 ASSERT_NE(nullptr, manager);
1509 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
1510 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1511 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListOne);
1512 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1513 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueOne, listLenth);
1514 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1515 EXPECT_STREQ(keyValueListOneExp, keyValueListValueOne);
1516 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListTwo);
1517 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1518 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueTwo, listLenth);
1519 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1520 EXPECT_STREQ(keyValueListTwoExp, keyValueListValueTwo);
1521 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListThr);
1522 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1523 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueThr, listLenth);
1524 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1525 EXPECT_STREQ(keyValueListThrExp, keyValueListValueThr);
1526 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueListFour);
1527 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1528 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValueFour, listLenth);
1529 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1530 EXPECT_STREQ(keyValueListFourExp, keyValueListValueFour);
1531 ret = render->control.Stop((AudioHandle)render);
1532 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1533 adapter->DestroyRender(adapter, render);
1534 manager->UnloadAdapter(manager, adapter);
1535 }
1536 /**
1537 * @tc.name AudioRenderGetExtraParams_001
1538 * @tc.desc Test RenderGetExtraParams interface,return 0 if the RenderGetExtraParams was obtained successfully
1539 * @tc.type: FUNC
1540 */
1541 HWTEST_F(AudioUsbRenderTest, AudioRenderGetExtraParams_001, TestSize.Level1)
1542 {
1543 int32_t ret = -1;
1544 uint64_t count = 0;
1545 struct AudioAdapter *adapter = {};
1546 struct AudioRender *render = nullptr;
1547 struct AudioSampleAttributes attrsValue = {};
1548 char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
1549 char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\
1550 attr-sampling-rate=48000";
1551 char keyValueListValue[256] = {};
1552 int32_t listLenth = 256;
1553 int32_t formatExp = 3;
1554 uint32_t sampleRateExp = 48000;
1555 uint32_t channelCountExp = 2;
1556 uint32_t frameCountExp = 4096;
1557
1558 ASSERT_NE(nullptr, manager);
1559 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
1560 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1561 ret = render->attr.SetExtraParams((AudioHandle)render, keyValueList);
1562 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1563 ret = render->attr.GetExtraParams((AudioHandle)render, keyValueListValue, listLenth);
1564 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1565 EXPECT_STREQ(keyValueListExp, keyValueListValue);
1566
1567 ret = render->attr.GetSampleAttributes(render, &attrsValue);
1568 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1569 EXPECT_EQ(formatExp, attrsValue.format);
1570 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1571 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1572 ret = render->attr.GetFrameCount(render, &count);
1573 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1574 EXPECT_EQ(count, frameCountExp);
1575
1576 ret = render->control.Stop((AudioHandle)render);
1577 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1578 adapter->DestroyRender(adapter, render);
1579 manager->UnloadAdapter(manager, adapter);
1580 }
1581
1582 /**
1583 * @tc.name AudioRenderTurnStandbyMode_001
1584 * @tc.desc Test AudioRenderTurnStandbyMode interface,return 0 if the interface use correctly.
1585 * @tc.type: FUNC
1586 */
1587 HWTEST_F(AudioUsbRenderTest, AudioRenderTurnStandbyMode_001, TestSize.Level1)
1588 {
1589 int32_t ret = -1;
1590 struct AudioAdapter *adapter = nullptr;
1591 struct AudioRender *render = nullptr;
1592 ASSERT_NE(nullptr, manager);
1593 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
1594 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1595
1596 ret = render->control.TurnStandbyMode((AudioHandle)render);
1597 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1598
1599 sleep(3);
1600
1601 ret = render->control.Stop((AudioHandle)render);
1602 adapter->DestroyRender(adapter, render);
1603 manager->UnloadAdapter(manager, adapter);
1604 }
1605
1606 /**
1607 * @tc.name AudioRenderAudioDevDump_001
1608 * @tc.desc Test AudioRenderAudioDevDump interface,return 0 if the interface use correctly.
1609 * @tc.type: FUNC
1610 */
1611 HWTEST_F(AudioUsbRenderTest, AudioRenderAudioDevDump_001, TestSize.Level1)
1612 {
1613 int32_t ret = -1;
1614 ASSERT_NE(nullptr, manager);
1615 char pathBuf[] = "./DevDump.log";
1616 FILE *fp = fopen(pathBuf, "wb+");
1617 ASSERT_NE(nullptr, fp);
1618 int fd = fileno(fp);
1619 if (fd == -1) {
1620 fclose(fp);
1621 ASSERT_NE(fd, -1);
1622 }
1623 struct PrepareAudioPara audiopara = {
1624 .manager = manager, .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER,
1625 .path = AUDIO_FILE.c_str()
1626 };
1627 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
1628 if (ret < 0) {
1629 fclose(fp);
1630 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1631 }
1632 sleep(1);
1633 ret = audiopara.render->control.Pause((AudioHandle)audiopara.render);
1634 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1635 sleep(1);
1636 ret = audiopara.render->control.Resume((AudioHandle)audiopara.render);
1637 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1638 ret = audiopara.render->control.AudioDevDump((AudioHandle)audiopara.render, RANGE, fd);
1639 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1640 fclose(fp);
1641 ret = ThreadRelease(audiopara);
1642 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1643 }
1644
1645 /**
1646 * @tc.name AudioRenderReqMmapBuffer_001
1647 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully
1648 * @tc.type: FUNC
1649 */
1650 HWTEST_F(AudioUsbRenderTest, AudioRenderReqMmapBuffer_001, TestSize.Level1)
1651 {
1652 int32_t ret = -1;
1653 bool isRender = true;
1654 int32_t reqSize = 0;
1655 struct AudioMmapBufferDescripter desc = {};
1656 struct AudioRender *render = nullptr;
1657 struct AudioAdapter *adapter = nullptr;
1658 struct AudioSampleAttributes attrs = {};
1659 ASSERT_NE(nullptr, manager);
1660 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
1661 ASSERT_NE(fp, nullptr);
1662 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1663 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1664 if (ret < 0 || render == nullptr) {
1665 fclose(fp);
1666 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1667 ASSERT_EQ(nullptr, render);
1668 }
1669 InitAttrs(attrs);
1670 attrs.startThreshold = 0;
1671 ret = render->attr.SetSampleAttributes(render, &attrs);
1672 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1673 ret = InitMmapDesc(fp, desc, reqSize, isRender);
1674 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1675 ret = render->control.Start((AudioHandle)render);
1676 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1677 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc);
1678 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1679 fclose(fp);
1680 if (ret == 0) {
1681 munmap(desc.memoryAddress, reqSize);
1682 }
1683 render->control.Stop((AudioHandle)render);
1684 adapter->DestroyRender(adapter, render);
1685 manager->UnloadAdapter(manager, adapter);
1686 }
1687 /**
1688 * @tc.name AudioRenderGetMmapPosition_001
1689 * @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully.
1690 * @tc.type: FUNC
1691 */
1692 HWTEST_F(AudioUsbRenderTest, AudioRenderGetMmapPosition_001, TestSize.Level1)
1693 {
1694 uint64_t frames = 0;
1695 uint64_t framesRendering = 0;
1696 uint64_t framesexpRender = 0;
1697 int64_t timeExp = 0;
1698 struct PrepareAudioPara audiopara = {
1699 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER,
1700 .path = LOW_LATENCY_AUDIO_FILE.c_str()
1701 };
1702 audiopara.manager = manager;
1703 ASSERT_NE(audiopara.manager, nullptr);
1704 int32_t ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1705 &audiopara.render);
1706 if (ret < 0 || audiopara.render == nullptr) {
1707 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1708 ASSERT_EQ(nullptr, audiopara.render);
1709 }
1710 InitAttrs(audiopara.attrs);
1711 audiopara.attrs.startThreshold = 0;
1712 ret = audiopara.render->attr.SetSampleAttributes(audiopara.render, &(audiopara.attrs));
1713 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1714 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &frames, &(audiopara.time));
1715 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1716 EXPECT_EQ((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1717 EXPECT_EQ(frames, INITIAL_VALUE);
1718
1719 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayMapAudioFile, &audiopara);
1720 if (ret != 0) {
1721 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1722 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1723 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1724 }
1725 sleep(1);
1726 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &framesRendering, &(audiopara.time));
1727 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1728 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1729 EXPECT_GT(framesRendering, INITIAL_VALUE);
1730 int64_t timeExprendering = (audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec);
1731 void *result = nullptr;
1732 pthread_join(audiopara.tids, &result);
1733 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
1734 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &framesexpRender, &(audiopara.time));
1735 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1736 EXPECT_GE((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExprendering);
1737 EXPECT_GE(framesexpRender, framesRendering);
1738 audiopara.render->control.Stop((AudioHandle)audiopara.render);
1739 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1740 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1741 }
1742 /**
1743 * @tc.name AudioRenderGetMmapPosition_002
1744 * @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully.
1745 * @tc.type: FUNC
1746 */
1747 HWTEST_F(AudioUsbRenderTest, AudioRenderGetMmapPosition_002, TestSize.Level1)
1748 {
1749 int32_t ret = -1;
1750 uint64_t frames = 0;
1751 int64_t timeExp = 0;
1752 struct PrepareAudioPara audiopara = {
1753 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER,
1754 .path = LOW_LATENCY_AUDIO_FILE.c_str()
1755 };
1756 audiopara.manager = manager;
1757 ASSERT_NE(audiopara.manager, nullptr);
1758 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1759 &audiopara.render);
1760 if (ret < 0 || audiopara.render == nullptr) {
1761 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1762 ASSERT_EQ(nullptr, audiopara.render);
1763 }
1764 InitAttrs(audiopara.attrs);
1765 audiopara.attrs.format = AUDIO_FORMAT_PCM_24_BIT;
1766 audiopara.attrs.channelCount = 1;
1767 ret = audiopara.render->attr.SetSampleAttributes(audiopara.render, &(audiopara.attrs));
1768 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1769
1770 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayMapAudioFile, &audiopara);
1771 if (ret != 0) {
1772 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1773 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1774 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1775 }
1776
1777 void *result = nullptr;
1778 pthread_join(audiopara.tids, &result);
1779 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
1780 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &frames, &(audiopara.time));
1781 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1782 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1783 EXPECT_GT(frames, INITIAL_VALUE);
1784 audiopara.render->control.Stop((AudioHandle)audiopara.render);
1785 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1786 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1787 }
1788
1789 #ifdef AUDIO_ADM_SO
1790 /**
1791 * @tc.name AudioRenderRegCallback_001
1792 * @tc.desc Test AudioRenderTurnStandbyMode interface,return 0 if the interface use correctly.
1793 * @tc.type: FUNC
1794 */
1795 HWTEST_F(AudioUsbRenderTest, AudioRenderRegCallback_001, TestSize.Level1)
1796 {
1797 int32_t ret = -1;
1798 struct AudioAdapter *adapter = nullptr;
1799 struct AudioRender *render = nullptr;
1800
1801 ASSERT_NE(nullptr, manager);
1802 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1803 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1804
1805 ret = render->RegCallback(render, AudioRenderCallback, nullptr);
1806 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1807
1808 ret = render->control.Flush((AudioHandle)render);
1809 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1810
1811 ret = CheckFlushValue();
1812 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1813
1814 adapter->DestroyRender(adapter, render);
1815 manager->UnloadAdapter(manager, adapter);
1816 }
1817
1818 /**
1819 * @tc.name AudioRenderRegCallback_002
1820 * @tc.desc Test AudioRenderRegCallback interface,return 0 if the interface use correctly.
1821 * @tc.type: FUNC
1822 */
1823 HWTEST_F(AudioUsbRenderTest, AudioRenderRegCallback_002, TestSize.Level1)
1824 {
1825 int32_t ret = -1;
1826 struct AudioAdapter *adapter = nullptr;
1827 struct AudioRender *render = nullptr;
1828 struct AudioSampleAttributes attrs;
1829 struct AudioHeadInfo headInfo;
1830 ASSERT_NE(nullptr, manager);
1831 char absPath[PATH_MAX] = {0};
1832 realpath(AUDIO_FILE.c_str(), absPath);
1833 ASSERT_NE(realpath(AUDIO_FILE.c_str(), absPath), nullptr);
1834
1835 FILE *file = fopen(absPath, "rb");
1836 ASSERT_NE(file, nullptr);
1837 ret = WavHeadAnalysis(headInfo, file, attrs);
1838 if (ret < 0) {
1839 fclose(file);
1840 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1841 }
1842 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1843 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1844
1845 ret = render->RegCallback(render, AudioRenderCallback, nullptr);
1846 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1847
1848 ret = FrameStart(headInfo, render, file, attrs);
1849 if (ret < 0) {
1850 adapter->DestroyRender(adapter, render);
1851 manager->UnloadAdapter(manager, adapter);
1852 fclose(file);
1853 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1854 }
1855
1856 ret = CheckWriteCompleteValue();
1857 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1858 ret = CheckRenderFullValue();
1859 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1860
1861 adapter->DestroyRender(adapter, render);
1862 manager->UnloadAdapter(manager, adapter);
1863 fclose(file);
1864 }
1865 #endif
1866 }
1867