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