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_control_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 AudioHdiRenderControlTest : 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 TestAudioManager *(*AudioHdiRenderControlTest::GetAudioManager)() = nullptr;
63 void *AudioHdiRenderControlTest::handleSo = nullptr;
64 #ifdef AUDIO_MPI_SO
65 int32_t (*AudioHdiRenderControlTest::SdkInit)() = nullptr;
66 void (*AudioHdiRenderControlTest::SdkExit)() = nullptr;
67 void *AudioHdiRenderControlTest::sdkSo = nullptr;
68 #endif
69
SetUpTestCase(void)70 void AudioHdiRenderControlTest::SetUpTestCase(void)
71 {
72 #ifdef AUDIO_MPI_SO
73 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
74 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
75 if (sdkSo == nullptr) {
76 return;
77 }
78 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
79 if (SdkInit == nullptr) {
80 return;
81 }
82 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
83 if (SdkExit == nullptr) {
84 return;
85 }
86 SdkInit();
87 #endif
88 char absPath[PATH_MAX] = {0};
89 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
90 return;
91 }
92 handleSo = dlopen(absPath, RTLD_LAZY);
93 if (handleSo == nullptr) {
94 return;
95 }
96 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
97 if (GetAudioManager == nullptr) {
98 return;
99 }
100 }
101
TearDownTestCase(void)102 void AudioHdiRenderControlTest::TearDownTestCase(void)
103 {
104 #ifdef AUDIO_MPI_SO
105 SdkExit();
106 if (sdkSo != nullptr) {
107 dlclose(sdkSo);
108 sdkSo = nullptr;
109 }
110 if (SdkInit != nullptr) {
111 SdkInit = nullptr;
112 }
113 if (SdkExit != nullptr) {
114 SdkExit = nullptr;
115 }
116 #endif
117 if (handleSo != nullptr) {
118 dlclose(handleSo);
119 handleSo = nullptr;
120 }
121 if (GetAudioManager != nullptr) {
122 GetAudioManager = nullptr;
123 }
124 }
125
SetUp(void)126 void AudioHdiRenderControlTest::SetUp(void) {}
127
TearDown(void)128 void AudioHdiRenderControlTest::TearDown(void) {}
129
130 /**
131 * @tc.name Test AudioRenderStart API via legal input
132 * @tc.number SUB_Audio_HDI_RenderStart_0001
133 * @tc.desc Test AudioRenderStart interface,return 0 if the audiorender object is created successfully.
134 * @tc.author: wangqian
135 */
136 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStart_0001, TestSize.Level1)
137 {
138 int32_t ret = -1;
139 TestAudioManager* manager = {};
140 struct AudioAdapter *adapter = nullptr;
141 struct AudioRender *render = nullptr;
142 enum AudioPortPin pins = PIN_OUT_SPEAKER;
143
144 ASSERT_NE(nullptr, GetAudioManager);
145 manager = GetAudioManager();
146 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
147 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
148 ret = render->control.Start((AudioHandle)render);
149 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
150
151 ret = render->control.Stop((AudioHandle)render);
152 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
153 adapter->DestroyRender(adapter, render);
154 manager->UnloadAdapter(manager, adapter);
155 }
156 /**
157 * @tc.name Test AudioRenderStart API via setting the incoming parameter handle is nullptr
158 * @tc.number SUB_Audio_HDI_RenderStart_0002
159 * @tc.desc Test AudioRenderStart interface, return -1 if the incoming parameter handle is nullptr
160 * @tc.author: wangqian
161 */
162 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStart_0002, TestSize.Level1)
163 {
164 int32_t ret = -1;
165 TestAudioManager* manager = {};
166 struct AudioAdapter *adapter = nullptr;
167 enum AudioPortPin pins = PIN_OUT_SPEAKER;
168 struct AudioRender *render = nullptr;
169 struct AudioRender *renderNull = nullptr;
170
171 ASSERT_NE(nullptr, GetAudioManager);
172 manager = GetAudioManager();
173 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
174 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
175 ret = render->control.Start((AudioHandle)renderNull);
176 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
177
178 adapter->DestroyRender(adapter, render);
179 manager->UnloadAdapter(manager, adapter);
180 }
181 /**
182 * @tc.name Test AudioRenderStart API via the interface is called twice in a row
183 * @tc.number SUB_Audio_HDI_RenderStart_0003
184 * @tc.desc Test AudioRenderStart interface,return -1 the second time if the RenderStart is called twice
185 * @tc.author: Xuhuandi
186 */
187 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStart_0003, TestSize.Level1)
188 {
189 int32_t ret = -1;
190 TestAudioManager* manager = {};
191 struct AudioAdapter *adapter = nullptr;
192 enum AudioPortPin pins = PIN_OUT_SPEAKER;
193 struct AudioRender *render = nullptr;
194
195 manager = GetAudioManager();
196 ASSERT_NE(nullptr, GetAudioManager);
197 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
198 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
199 ret = render->control.Start((AudioHandle)render);
200 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
201 ret = render->control.Start((AudioHandle)render);
202 EXPECT_EQ(AUDIO_HAL_ERR_AO_BUSY, ret);
203
204 ret = render->control.Stop((AudioHandle)render);
205 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
206 adapter->DestroyRender(adapter, render);
207 manager->UnloadAdapter(manager, adapter);
208 }
209 /**
210 * @tc.name Test AudioRenderStop API via legal input
211 * @tc.number SUB_Audio_HDI_RenderStop_0001
212 * @tc.desc test AudioRenderStop interface. return 0 if the rendering is successfully stopped.
213 * @tc.author: Xuhuandi
214 */
215 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0001, TestSize.Level1)
216 {
217 int32_t ret = -1;
218 TestAudioManager* manager = {};
219 struct AudioAdapter *adapter = nullptr;
220 enum AudioPortPin pins = PIN_OUT_SPEAKER;
221 struct AudioRender *render = nullptr;
222
223 manager = GetAudioManager();
224 ASSERT_NE(nullptr, GetAudioManager);
225 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
226 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
227 ret = render->control.Start((AudioHandle)render);
228 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
229 ret = render->control.Stop((AudioHandle)render);
230 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
231
232 adapter->DestroyRender(adapter, render);
233 manager->UnloadAdapter(manager, adapter);
234 }
235 /**
236 * @tc.name Test AudioRenderStop API via the render does not start and stop only
237 * @tc.number SUB_Audio_HDI_RenderStop_0002
238 * @tc.desc test AudioRenderStop interface. return -4 if the render does not start and stop only
239 * @tc.author: Xuhuandi
240 */
241 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0002, TestSize.Level1)
242 {
243 int32_t ret = -1;
244 TestAudioManager* manager = {};
245 struct AudioAdapter *adapter = nullptr;
246 struct AudioRender *render = nullptr;
247 enum AudioPortPin pins = PIN_OUT_SPEAKER;
248
249 manager = GetAudioManager();
250 ASSERT_NE(nullptr, GetAudioManager);
251 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
252 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
253 ret = render->control.Stop((AudioHandle)render);
254 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
255
256 adapter->DestroyRender(adapter, render);
257 manager->UnloadAdapter(manager, adapter);
258 }
259 /**
260 * @tc.name Test RenderStop API via the interface is called twice in a row
261 * @tc.number SUB_Audio_HDI_RenderStop_0003
262 * @tc.desc Test RenderStop interface,return -4 the second time if the RenderStop is called twice
263 * @tc.author: Xuhuandi
264 */
265 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0003, TestSize.Level1)
266 {
267 int32_t ret = -1;
268 TestAudioManager* manager = {};
269 struct AudioAdapter *adapter = nullptr;
270 struct AudioRender *render = nullptr;
271 enum AudioPortPin pins = PIN_OUT_SPEAKER;
272
273 manager = GetAudioManager();
274 ASSERT_NE(nullptr, GetAudioManager);
275 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
276 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
277 ret = render->control.Start((AudioHandle)render);
278 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
279 ret = render->control.Stop((AudioHandle)render);
280 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
281 ret = render->control.Stop((AudioHandle)render);
282 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
283
284 adapter->DestroyRender(adapter, render);
285 manager->UnloadAdapter(manager, adapter);
286 }
287 /**
288 * @tc.name Test RenderStop API via setting the incoming parameter handle is nullptr
289 * @tc.number SUB_Audio_HDI_RenderStop_0004
290 * @tc.desc Test RenderStop interface, return -1 if the incoming parameter handle is nullptr
291 * @tc.author: Xuhuandi
292 */
293 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0004, TestSize.Level1)
294 {
295 int32_t ret = -1;
296 enum AudioPortPin pins = PIN_OUT_SPEAKER;
297 TestAudioManager* manager = {};
298 struct AudioAdapter *adapter = nullptr;
299 struct AudioRender *render = nullptr;
300 struct AudioRender *renderNull = nullptr;
301
302 manager = GetAudioManager();
303 ASSERT_NE(nullptr, GetAudioManager);
304 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
305 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
306 ret = render->control.Start((AudioHandle)render);
307 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
308 ret = render->control.Stop((AudioHandle)renderNull);
309 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
310
311 ret = render->control.Stop((AudioHandle)render);
312 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
313 adapter->DestroyRender(adapter, render);
314 manager->UnloadAdapter(manager, adapter);
315 }
316 /**
317 * @tc.name Test RenderPause API via legal input
318 * @tc.number SUB_Audio_HDI_RenderPause_001
319 * @tc.desc test HDI RenderPause interface，return 0 if the render is paused after start
320 * @tc.author: Xuhuandi
321 */
322 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0001, TestSize.Level1)
323 {
324 int32_t ret = -1;
325 TestAudioManager* manager = {};
326 struct AudioAdapter *adapter = nullptr;
327 struct AudioRender *render = nullptr;
328
329 manager = GetAudioManager();
330 ASSERT_NE(nullptr, GetAudioManager);
331 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
332 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
333 ret = render->control.Pause((AudioHandle)render);
334 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
335
336 ret = render->control.Stop((AudioHandle)render);
337 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
338 adapter->DestroyRender(adapter, render);
339 manager->UnloadAdapter(manager, adapter);
340 }
341 /**
342 * @tc.name Test AudioRenderPause API via the interface is called twice in a row
343 * @tc.number SUB_Audio_HDI_RenderPause_0002
344 * @tc.desc Test AudioRenderPause interface, return -1 the second time if RenderPause is called twice
345 * @tc.author: Xuhuandi
346 */
347 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0002, TestSize.Level1)
348 {
349 int32_t ret = -1;
350 struct AudioAdapter *adapter = nullptr;
351 struct AudioRender *render = nullptr;
352 TestAudioManager* manager = {};
353
354 manager = GetAudioManager();
355 ASSERT_NE(nullptr, GetAudioManager);
356 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
357 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
358 ret = render->control.Pause((AudioHandle)render);
359 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
360 ret = render->control.Pause((AudioHandle)render);
361 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
362
363 render->control.Stop((AudioHandle)render);
364 adapter->DestroyRender(adapter, render);
365 manager->UnloadAdapter(manager, adapter);
366 }
367 /**
368 * @tc.name Test AudioRenderPause API via the render is paused after created.
369 * @tc.number SUB_Audio_HDI_RenderPause_0003
370 * @tc.desc Test AudioRenderPause interface,return -1 if the render is paused after created.
371 * @tc.author: Xuhuandi
372 */
373 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0003, TestSize.Level1)
374 {
375 int32_t ret = -1;
376 TestAudioManager* manager = {};
377 struct AudioAdapter *adapter = nullptr;
378 struct AudioRender *render = nullptr;
379 enum AudioPortPin pins = PIN_OUT_SPEAKER;
380
381 manager = GetAudioManager();
382 ASSERT_NE(nullptr, GetAudioManager);
383 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
384 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
385 ret = render->control.Pause((AudioHandle)render);
386 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
387 adapter->DestroyRender(adapter, render);
388 manager->UnloadAdapter(manager, adapter);
389 }
390 /**
391 * @tc.name Test AudioRenderPause API via the render is paused after resumed.
392 * @tc.number SUB_Audio_HDI_RenderPause_0004
393 * @tc.desc Test AudioRenderPause interface,return 0 if the render is paused after resumed.
394 * @tc.author: Xuhuandi
395 */
396 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0004, TestSize.Level1)
397 {
398 int32_t ret = -1;
399 TestAudioManager* manager = {};
400 struct AudioAdapter *adapter = nullptr;
401 struct AudioRender *render = nullptr;
402
403 manager = GetAudioManager();
404 ASSERT_NE(nullptr, GetAudioManager);
405 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
406 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
407 ret = render->control.Pause((AudioHandle)render);
408 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
409 ret = render->control.Resume((AudioHandle)render);
410 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
411 ret = render->control.Pause((AudioHandle)render);
412 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
413
414 ret = render->control.Stop((AudioHandle)render);
415 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
416 adapter->DestroyRender(adapter, render);
417 manager->UnloadAdapter(manager, adapter);
418 }
419 /**
420 * @tc.name Test AudioRenderPause API via the render is paused after stoped.
421 * @tc.number SUB_Audio_HDI_RenderPause_0005
422 * @tc.desc Test AudioRenderPause interface, return -1 the render is paused after stoped.
423 * @tc.author: Xuhuandi
424 */
425 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0005, TestSize.Level1)
426 {
427 int32_t ret = -1;
428 struct AudioAdapter *adapter = nullptr;
429 struct AudioRender *render = nullptr;
430 TestAudioManager* manager = {};
431
432 manager = GetAudioManager();
433 ASSERT_NE(nullptr, GetAudioManager);
434 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
435 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
436 ret = render->control.Stop((AudioHandle)render);
437 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
438 ret = render->control.Pause((AudioHandle)render);
439 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
440
441 adapter->DestroyRender(adapter, render);
442 manager->UnloadAdapter(manager, adapter);
443 }
444 /**
445 * @tc.name Test RenderPause API via setting the incoming parameter handle is nullptr
446 * @tc.number SUB_Audio_HDI_RenderPause_0006
447 * @tc.desc Test RenderPause interface, return -1 if the incoming parameter handle is nullptr
448 * @tc.author: Xuhuandi
449 */
450 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0006, TestSize.Level1)
451 {
452 int32_t ret = -1;
453 struct AudioAdapter *adapter = nullptr;
454 struct AudioRender *render = nullptr;
455 struct AudioRender *renderNull = nullptr;
456 TestAudioManager* manager = {};
457
458 manager = GetAudioManager();
459 ASSERT_NE(nullptr, GetAudioManager);
460 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
461 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
462 ret = render->control.Pause((AudioHandle)renderNull);
463 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
464
465 ret = render->control.Stop((AudioHandle)render);
466 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
467 adapter->DestroyRender(adapter, render);
468 manager->UnloadAdapter(manager, adapter);
469 }
470 /**
471 * @tc.name Test RenderResume API via the render is resumed after started
472 * @tc.number SUB_Audio_HDI_RenderResume_0001
473 * @tc.desc test HDI RenderResume interface,return -1 if the render is resumed after started
474 * @tc.author: Xuhuandi
475 */
476 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0001, TestSize.Level1)
477 {
478 int32_t ret = -1;
479 struct AudioAdapter *adapter = nullptr;
480 struct AudioRender *render = nullptr;
481
482 TestAudioManager* manager = GetAudioManager();
483 ASSERT_NE(nullptr, GetAudioManager);
484 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
485 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
486 ret = render->control.Resume((AudioHandle)render);
487 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
488
489 ret = render->control.Stop((AudioHandle)render);
490 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
491 adapter->DestroyRender(adapter, render);
492 manager->UnloadAdapter(manager, adapter);
493 }
494 /**
495 * @tc.name Test RenderResume API via the render is resumed after stopped
496 * @tc.number SUB_Audio_HDI_RenderResume_0002
497 * @tc.desc test HDI RenderResume interface,return -1 if the render is resumed after stopped
498 * @tc.author: Xuhuandi
499 */
500 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0002, TestSize.Level1)
501 {
502 int32_t ret = -1;
503 struct AudioAdapter *adapter = nullptr;
504 struct AudioRender *render = nullptr;
505
506 TestAudioManager* manager = GetAudioManager();
507 ASSERT_NE(nullptr, GetAudioManager);
508 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
509 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
510 ret = render->control.Stop((AudioHandle)render);
511 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
512 ret = render->control.Resume((AudioHandle)render);
513 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
514
515 adapter->DestroyRender(adapter, render);
516 manager->UnloadAdapter(manager, adapter);
517 }
518 /**
519 * @tc.name Test RenderResume API via legal input
520 * @tc.number SUB_Audio_HDI_RenderResume_0003
521 * @tc.desc Test AudioRenderResume interface,return 0 if the render is resumed after paused
522 * @tc.author: Xuhuandi
523 */
524 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0003, TestSize.Level1)
525 {
526 int32_t ret = -1;
527 struct AudioAdapter *adapter = nullptr;
528 struct AudioRender *render = nullptr;
529
530 TestAudioManager* manager = GetAudioManager();
531 ASSERT_NE(nullptr, GetAudioManager);
532 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
533 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
534 ret = render->control.Pause((AudioHandle)render);
535 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
536 ret = render->control.Resume((AudioHandle)render);
537 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
538
539 ret = render->control.Stop((AudioHandle)render);
540 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
541 adapter->DestroyRender(adapter, render);
542 manager->UnloadAdapter(manager, adapter);
543 }
544 /**
545 * @tc.name Test RenderResume API via the interface is called twice in a row
546 * @tc.number SUB_Audio_HDI_RenderResume_0004
547 * @tc.desc Test RenderResume interface,return -1 the second time if the RenderResume is called twice
548 * @tc.author: Xuhuandi
549 */
550 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0004, TestSize.Level1)
551 {
552 int32_t ret = -1;
553 struct AudioAdapter *adapter = nullptr;
554 struct AudioRender *render = nullptr;
555
556 TestAudioManager* manager = GetAudioManager();
557 ASSERT_NE(nullptr, GetAudioManager);
558 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
559 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
560 ret = render->control.Pause((AudioHandle)render);
561 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
562 ret = render->control.Resume((AudioHandle)render);
563 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
564 ret = render->control.Resume((AudioHandle)render);
565 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
566
567 ret = render->control.Stop((AudioHandle)render);
568 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
569 adapter->DestroyRender(adapter, render);
570 manager->UnloadAdapter(manager, adapter);
571 }
572 /**
573 * @tc.name Test RenderResume API via the render Continue to start after resume
574 * @tc.number SUB_Audio_HDI_RenderResume_0005
575 * @tc.desc test HDI RenderResume interface,return -1 if the render Continue to start after resume
576 * @tc.author: Xuhuandi
577 */
578 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0005, TestSize.Level1)
579 {
580 int32_t ret = -1;
581 struct AudioAdapter *adapter = nullptr;
582 struct AudioRender *render = nullptr;
583
584 TestAudioManager* manager = GetAudioManager();
585 ASSERT_NE(nullptr, GetAudioManager);
586 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
587 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
588 ret = render->control.Pause((AudioHandle)render);
589 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
590 ret = render->control.Resume((AudioHandle)render);
591 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
592 ret = render->control.Start((AudioHandle)render);
593 EXPECT_EQ(AUDIO_HAL_ERR_AO_BUSY, ret);
594
595 ret = render->control.Stop((AudioHandle)render);
596 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
597 adapter->DestroyRender(adapter, render);
598 manager->UnloadAdapter(manager, adapter);
599 }
600 /**
601 * @tc.name Test RenderResume API via setting the incoming parameter handle is nullptr
602 * @tc.number SUB_Audio_HDI_RenderResume_0007
603 * @tc.desc Test RenderResume interface, return -1 if the incoming parameter handle is nullptr
604 * @tc.author: Xuhuandi
605 */
606 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0006, TestSize.Level1)
607 {
608 int32_t ret = -1;
609 struct AudioAdapter *adapter = nullptr;
610 struct AudioRender *render = nullptr;
611 struct AudioRender *renderNull = nullptr;
612
613 TestAudioManager* manager = GetAudioManager();
614 ASSERT_NE(nullptr, GetAudioManager);
615 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
616 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
617 ret = render->control.Pause((AudioHandle)render);
618 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
619 ret = render->control.Resume((AudioHandle)renderNull);
620 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
621
622 ret = render->control.Stop((AudioHandle)render);
623 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
624 adapter->DestroyRender(adapter, render);
625 manager->UnloadAdapter(manager, adapter);
626 }
627 /**
628 * @tc.name Test AudioCreateRender API via legal input.
629 * @tc.number SUB_Audio_HDI_CreateRender_0001
630 * @tc.desc test AudioCreateRender interface,return 0 if render is created successful.
631 * @tc.author: ZHANGHAILIN
632 */
633 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0001, TestSize.Level1)
634 {
635 int32_t ret = -1;
636 struct AudioAdapter *adapter = nullptr;
637 struct AudioRender *render = nullptr;
638 enum AudioPortPin pins = PIN_OUT_SPEAKER;
639 ASSERT_NE(nullptr, GetAudioManager);
640 TestAudioManager* manager = GetAudioManager();
641 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
642 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
643
644 adapter->DestroyRender(adapter, render);
645 manager->UnloadAdapter(manager, adapter);
646 }
647 /**
648 * @tc.name Test AudioCreateRender API when two renders is created successful.
649 * @tc.number SUB_Audio_HDI_AudioCreateRender_0002
650 * @tc.desc Test AudioCreateRender interface,return 0 when two renders is created successful.
651 * @tc.author: ZHANGHAILIN
652 */
653 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_AudioCreateRender_0002, TestSize.Level1)
654 {
655 int32_t ret = -1;
656 enum AudioPortPin pins = PIN_OUT_SPEAKER;
657 struct AudioAdapter *adapter = nullptr;
658 struct AudioAdapter *adapter2 = nullptr;
659 struct AudioRender *render = nullptr;
660 struct AudioRender *render2 = nullptr;
661 ASSERT_NE(nullptr, GetAudioManager);
662 TestAudioManager* manager = GetAudioManager();
663
664 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
665 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
666 adapter->DestroyRender(adapter, render);
667 manager->UnloadAdapter(manager, adapter);
668
669 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter2, &render2);
670 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
671 adapter2->DestroyRender(adapter2, render2);
672 manager->UnloadAdapter(manager, adapter2);
673 }
674 /**
675 * @tc.name Test AudioCreateRender API via setting the incoming parameter pins is PIN_IN_MIC.
676 * @tc.number SUB_Audio_HDI_CreateRender_0003
677 * @tc.desc test AudioCreateRender interface,return -1 if the incoming parameter pins is PIN_IN_MIC.
678 * @tc.author: ZHANGHAILIN
679 */
680 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0003, TestSize.Level1)
681 {
682 int32_t ret = -1;
683 struct AudioAdapter *adapter = nullptr;
684 struct AudioRender *render = nullptr;
685 struct AudioPort* renderPort = nullptr;
686 struct AudioSampleAttributes attrs = {};
687 struct AudioDeviceDescriptor devDesc = {};
688 ASSERT_NE(nullptr, GetAudioManager);
689 TestAudioManager* manager = GetAudioManager();
690 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort);
691 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
692
693 InitAttrs(attrs);
694 InitDevDesc(devDesc, renderPort->portId, PIN_IN_MIC);
695
696 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
697 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
698 manager->UnloadAdapter(manager, adapter);
699 }
700
701 /**
702 * @tc.name Test AudioCreateRender API via setting the incoming parameter attr is error.
703 * @tc.number SUB_Audio_HDI_CreateRender_0004
704 * @tc.desc test AudioCreateRender interface,return -1 if the incoming parameter attr is error.
705 * @tc.author: ZHANGHAILIN
706 */
707 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0004, TestSize.Level1)
708 {
709 int32_t ret = -1;
710 struct AudioAdapter *adapter = nullptr;
711 struct AudioRender *render = nullptr;
712 struct AudioSampleAttributes attrs = {};
713 struct AudioDeviceDescriptor devDesc = {};
714 struct AudioPort* renderPort = nullptr;
715 uint32_t channelCountErr = 5;
716 ASSERT_NE(nullptr, GetAudioManager);
717 TestAudioManager* manager = GetAudioManager();
718 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort);
719 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
720
721 InitAttrs(attrs);
722 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
723 attrs.format = AUDIO_FORMAT_AAC_MAIN;
724 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
725 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
726 attrs.channelCount = channelCountErr;
727 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
728 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
729 attrs.type = AUDIO_IN_COMMUNICATION;
730 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
731 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
732
733 manager->UnloadAdapter(manager, adapter);
734 }
735 /**
736 * @tc.name Test AudioCreateRender API via setting the incoming parameter adapter is nullptr
737 * @tc.number SUB_Audio_HDI_CreateRender_0005
738 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter adapter is nullptr.
739 * @tc.author: ZHANGHAILIN
740 */
741 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0005, TestSize.Level1)
742 {
743 int32_t ret = -1;
744 struct AudioAdapter *adapter = nullptr;
745 struct AudioRender *render = nullptr;
746 struct AudioAdapter *adapterNull = nullptr;
747 struct AudioPort* renderPort = nullptr;
748 struct AudioSampleAttributes attrs = {};
749 struct AudioDeviceDescriptor devDesc = {};
750 ASSERT_NE(nullptr, GetAudioManager);
751 TestAudioManager* manager = GetAudioManager();
752 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort);
753 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
754
755 InitAttrs(attrs);
756 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
757
758 ret = adapter->CreateRender(adapterNull, &devDesc, &attrs, &render);
759 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
760
761 manager->UnloadAdapter(manager, adapter);
762 }
763
764 /**
765 * @tc.name Test AudioCreateRender API via setting the incoming parameter devDesc is nullptr
766 * @tc.number SUB_Audio_HDI_CreateRender_0006
767 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter devDesc is nullptr.
768 * @tc.author: ZHANGHAILIN
769 */
770 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0006, TestSize.Level1)
771 {
772 int32_t ret = -1;
773 struct AudioRender *render = nullptr;
774 struct AudioAdapter *adapter = nullptr;
775 struct AudioPort* renderPort = nullptr;
776 struct AudioSampleAttributes attrs = {};
777 struct AudioDeviceDescriptor *devDescNull = nullptr;
778 ASSERT_NE(nullptr, GetAudioManager);
779 TestAudioManager* manager = GetAudioManager();
780 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort);
781 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
782
783 InitAttrs(attrs);
784
785 ret = adapter->CreateRender(adapter, devDescNull, &attrs, &render);
786 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
787
788 manager->UnloadAdapter(manager, adapter);
789 }
790
791 /**
792 * @tc.name Test AudioCreateRender API via setting the incoming parameter attrs is nullptr
793 * @tc.number SUB_Audio_HDI_CreateRender_0007
794 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter attrs is nullptr.
795 * @tc.author: ZHANGHAILIN
796 */
797 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0007, TestSize.Level1)
798 {
799 int32_t ret = -1;
800 struct AudioPort* renderPort = nullptr;
801 struct AudioAdapter *adapter = nullptr;
802 struct AudioRender *render = nullptr;
803 struct AudioSampleAttributes *attrsNull = nullptr;
804 struct AudioDeviceDescriptor devDesc = {};
805 ASSERT_NE(nullptr, GetAudioManager);
806 TestAudioManager* manager = GetAudioManager();
807 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort);
808 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
809
810 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
811
812 ret = adapter->CreateRender(adapter, &devDesc, attrsNull, &render);
813 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
814
815 manager->UnloadAdapter(manager, adapter);
816 }
817
818 /**
819 * @tc.name Test AudioCreateRender API via setting the incoming parameter render is nullptr
820 * @tc.number SUB_Audio_HDI_CreateRender_0008
821 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter render is nullptr.
822 * @tc.author: ZHANGHAILIN
823 */
824 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0008, TestSize.Level1)
825 {
826 int32_t ret = -1;
827 struct AudioAdapter *adapter = nullptr;
828 struct AudioRender **renderNull = nullptr;
829 struct AudioPort* renderPort = nullptr;
830 struct AudioSampleAttributes attrs = {};
831 struct AudioDeviceDescriptor devDesc = {};
832 ASSERT_NE(nullptr, GetAudioManager);
833 TestAudioManager* manager = GetAudioManager();
834 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort);
835 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
836
837 InitAttrs(attrs);
838 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
839
840 ret = adapter->CreateRender(adapter, &devDesc, &attrs, renderNull);
841 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
842
843 manager->UnloadAdapter(manager, adapter);
844 }
845
846 /**
847 * @tc.name Test AudioCreateRender API via setting the incoming parameter devDesc is error
848 * @tc.number SUB_Audio_HDI_CreateRender_0009
849 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter devDesc is error.
850 * @tc.author: ZHANGHAILIN
851 */
852 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0009, TestSize.Level1)
853 {
854 int32_t ret = -1;
855 struct AudioAdapter *adapter = nullptr;
856 struct AudioRender *render = nullptr;
857 struct AudioSampleAttributes attrs = {};
858 struct AudioDeviceDescriptor devDesc = {};
859 struct AudioPort* renderPort = nullptr;
860 ASSERT_NE(nullptr, GetAudioManager);
861 TestAudioManager* manager = GetAudioManager();
862 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_USB, &adapter, renderPort);
863 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
864
865 ret = InitAttrs(attrs);
866 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
867
868 devDesc.portId = -5;
869 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
870 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
871 devDesc.pins = PIN_NONE;
872 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
873 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
874 devDesc.desc = "devtestname";
875 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
876 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
877
878 manager->UnloadAdapter(manager, adapter);
879 }
880 /**
881 * @tc.name Test AudioDestroyRender API via legal input.
882 * @tc.number SUB_Audio_HDI_DestroyRender_0001
883 * @tc.desc Test AudioDestroyRender interface, return 0 if render is destroyed successful.
884 * @tc.author: ZHANGHAILIN
885 */
886 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_DestroyRender_0001, TestSize.Level1)
887 {
888 int32_t ret = -1;
889 struct AudioAdapter *adapter = nullptr;
890 struct AudioRender *render = nullptr;
891 enum AudioPortPin pins = PIN_OUT_SPEAKER;
892 TestAudioManager* manager = GetAudioManager();
893 ASSERT_NE(nullptr, GetAudioManager);
894 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
895 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
896
897 ret = adapter->DestroyRender(adapter, render);
898 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
899 manager->UnloadAdapter(manager, adapter);
900 }
901 /**
902 * @tc.name Test AudioDestroyRender API,where the parameter render is empty.
903 * @tc.number SUB_Audio_HDI_DestroyRender_0002
904 * @tc.desc Test AudioDestroyRender interface, return -1 if the parameter render is empty.
905 * @tc.author: ZHANGHAILIN
906 */
907 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_DestroyRender_0002, TestSize.Level1)
908 {
909 int32_t ret = -1;
910 enum AudioPortPin pins = PIN_OUT_SPEAKER;
911 struct AudioAdapter *adapter = nullptr;
912 struct AudioRender *render = nullptr;
913 struct AudioRender *renderNull = nullptr;
914 TestAudioManager* manager = GetAudioManager();
915 ASSERT_NE(nullptr, GetAudioManager);
916 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
917 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
918
919 ret = adapter->DestroyRender(adapter, renderNull);
920 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
921 manager->UnloadAdapter(manager, adapter);
922 }
923
924 /**
925 * @tc.name Test RenderFlush API via legal input Verify that the data in the buffer is flushed after stop
926 * @tc.number SUB_Audio_HDI_RenderFlush_0001
927 * @tc.desc Test RenderFlush interface,return -2 if the data in the buffer is flushed successfully after stop
928 * @tc.author: tiansuli
929 */
930 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderFlush_0001, TestSize.Level1)
931 {
932 int32_t ret = -1;
933 TestAudioManager* manager = {};
934 struct AudioAdapter *adapter = nullptr;
935 struct AudioRender *render = nullptr;
936
937 manager = GetAudioManager();
938 ASSERT_NE(nullptr, GetAudioManager);
939 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
940 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
941 ret = render->control.Stop((AudioHandle)render);
942 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
943 ret = render->control.Flush((AudioHandle)render);
944 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
945
946 adapter->DestroyRender(adapter, render);
947 manager->UnloadAdapter(manager, adapter);
948 }
949 /**
950 * @tc.name Test RenderFlush that the data in the buffer is flushed when handle is nullptr after paused
951 * @tc.number SUB_Audio_HDI_RenderFlush_0002
952 * @tc.desc Test RenderFlush, return -1 if the data in the buffer is flushed when handle is nullptr after paused
953 * @tc.author: tiansuli
954 */
955 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderFlush_0002, TestSize.Level1)
956 {
957 int32_t ret = -1;
958 TestAudioManager* manager = {};
959 struct AudioAdapter *adapter = nullptr;
960 struct AudioRender *render = nullptr;
961 struct AudioRender *renderNull = nullptr;
962
963 manager = GetAudioManager();
964 ASSERT_NE(nullptr, GetAudioManager);
965 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
966 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
967 ret = render->control.Pause((AudioHandle)render);
968 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
969 ret = render->control.Flush((AudioHandle)renderNull);
970 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
971
972 ret = render->control.Stop((AudioHandle)render);
973 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
974 adapter->DestroyRender(adapter, render);
975 manager->UnloadAdapter(manager, adapter);
976 }
977 }