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