1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 /**
17 * @addtogroup Audio
18 * @{
19 *
20 * @brief 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 OHOS::Audio;
42
43 namespace {
44 class AudioHdiRenderControlTest : public testing::Test {
45 public:
46 static void SetUpTestCase(void);
47 static void TearDownTestCase(void);
48 void SetUp();
49 void TearDown();
50 };
51
SetUpTestCase(void)52 void AudioHdiRenderControlTest::SetUpTestCase(void){}
53
TearDownTestCase(void)54 void AudioHdiRenderControlTest::TearDownTestCase(void) {}
55
SetUp(void)56 void AudioHdiRenderControlTest::SetUp(void) {}
57
TearDown(void)58 void AudioHdiRenderControlTest::TearDown(void) {}
59
60 /**
61 * @tc.name Test AudioRenderStart API via legal input
62 * @tc.number SUB_Audio_HDI_RenderStart_0001
63 * @tc.desc Test AudioRenderStart interface,return 0 if the audiorender object is created successfully.
64 */
65 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStart_0001, Function | MediumTest | Level1)
66 {
67 int32_t ret = -1;
68 TestAudioManager* manager = {};
69 struct AudioAdapter *adapter = nullptr;
70 struct AudioRender *render = nullptr;
71
72 manager = GetAudioManagerFuncs();
73 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
74 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
75 ret = render->control.Start((AudioHandle)render);
76 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
77
78 ret = render->control.Stop((AudioHandle)render);
79 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
80 adapter->DestroyRender(adapter, render);
81 manager->UnloadAdapter(manager, adapter);
82 }
83 /**
84 * @tc.name Test AudioRenderStart API via setting the incoming parameter handle is nullptr
85 * @tc.number SUB_Audio_HDI_RenderStart_0002
86 * @tc.desc Test AudioRenderStart interface, return -1 if the incoming parameter handle is nullptr
87 */
88 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStart_0002, Function | MediumTest | Level1)
89 {
90 int32_t ret = -1;
91 TestAudioManager* manager = {};
92 struct AudioAdapter *adapter = nullptr;
93 struct AudioRender *render = nullptr;
94 struct AudioRender *renderNull = nullptr;
95
96 manager = GetAudioManagerFuncs();
97 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
98 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
99 ret = render->control.Start((AudioHandle)renderNull);
100 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
101
102 adapter->DestroyRender(adapter, render);
103 manager->UnloadAdapter(manager, adapter);
104 }
105 /**
106 * @tc.name Test AudioRenderStop API via legal input
107 * @tc.number SUB_Audio_HDI_RenderStop_0001
108 * @tc.desc test AudioRenderStop interface. return 0 if the rendering is successfully stopped.
109 */
110 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0001, Function | MediumTest | Level1)
111 {
112 int32_t ret = -1;
113 TestAudioManager* manager = {};
114 struct AudioAdapter *adapter = nullptr;
115 struct AudioRender *render = nullptr;
116
117 manager = GetAudioManagerFuncs();
118 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
119 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
120 ret = render->control.Start((AudioHandle)render);
121 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
122 ret = render->control.Stop((AudioHandle)render);
123 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
124
125 adapter->DestroyRender(adapter, render);
126 manager->UnloadAdapter(manager, adapter);
127 }
128 /**
129 * @tc.name Test AudioRenderStop API via the render does not start and stop only
130 * @tc.number SUB_Audio_HDI_RenderStop_0002
131 * @tc.desc test AudioRenderStop interface. return -4 if the render does not start and stop only
132 */
133 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0002, Function | MediumTest | Level1)
134 {
135 int32_t ret = -1;
136 TestAudioManager* manager = {};
137 struct AudioAdapter *adapter = nullptr;
138 struct AudioRender *render = nullptr;
139
140 manager = GetAudioManagerFuncs();
141 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
142 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
143 ret = render->control.Stop((AudioHandle)render);
144 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
145
146 adapter->DestroyRender(adapter, render);
147 manager->UnloadAdapter(manager, adapter);
148 }
149 /**
150 * @tc.name Test RenderStop API via setting the incoming parameter handle is nullptr
151 * @tc.number SUB_Audio_HDI_RenderStop_0004
152 * @tc.desc Test RenderStop interface, return -1 if the incoming parameter handle is nullptr
153 */
154 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderStop_0004, Function | MediumTest | Level1)
155 {
156 int32_t ret = -1;
157 TestAudioManager* manager = {};
158 struct AudioAdapter *adapter = nullptr;
159 struct AudioRender *render = nullptr;
160 struct AudioRender *renderNull = nullptr;
161
162 manager = GetAudioManagerFuncs();
163 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
164 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
165 ret = render->control.Start((AudioHandle)render);
166 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
167 ret = render->control.Stop((AudioHandle)renderNull);
168 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
169
170 ret = render->control.Stop((AudioHandle)render);
171 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
172 adapter->DestroyRender(adapter, render);
173 manager->UnloadAdapter(manager, adapter);
174 }
175 /**
176 * @tc.name Test RenderPause API via legal input
177 * @tc.number SUB_Audio_HDI_RenderPause_001
178 * @tc.desc test HDI RenderPause interface，return 0 if the render is paused after start
179 */
180 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0001, Function | MediumTest | Level1)
181 {
182 int32_t ret = -1;
183 TestAudioManager* manager = {};
184 struct AudioAdapter *adapter = nullptr;
185 struct AudioRender *render = nullptr;
186
187 manager = GetAudioManagerFuncs();
188 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
189 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
190 ret = render->control.Pause((AudioHandle)render);
191 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
192
193 ret = render->control.Stop((AudioHandle)render);
194 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
195 adapter->DestroyRender(adapter, render);
196 manager->UnloadAdapter(manager, adapter);
197 }
198 /**
199 * @tc.name Test AudioRenderPause API via the render is paused after created.
200 * @tc.number SUB_Audio_HDI_RenderPause_0003
201 * @tc.desc Test AudioRenderPause interface,return -1 if the render is paused after created.
202 */
203 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0003, Function | MediumTest | Level1)
204 {
205 int32_t ret = -1;
206 TestAudioManager* manager = {};
207 struct AudioAdapter *adapter = nullptr;
208 struct AudioRender *render = nullptr;
209
210 manager = GetAudioManagerFuncs();
211 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
212 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
213 ret = render->control.Pause((AudioHandle)render);
214 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
215 adapter->DestroyRender(adapter, render);
216 manager->UnloadAdapter(manager, adapter);
217 }
218 /**
219 * @tc.name Test AudioRenderPause API via the render is paused after resumed.
220 * @tc.number SUB_Audio_HDI_RenderPause_0004
221 * @tc.desc Test AudioRenderPause interface,return 0 if the render is paused after resumed.
222 */
223 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0004, Function | MediumTest | Level1)
224 {
225 int32_t ret = -1;
226 TestAudioManager* manager = {};
227 struct AudioAdapter *adapter = nullptr;
228 struct AudioRender *render = nullptr;
229
230 manager = GetAudioManagerFuncs();
231 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
232 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
233 ret = render->control.Pause((AudioHandle)render);
234 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
235 ret = render->control.Resume((AudioHandle)render);
236 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
237 ret = render->control.Pause((AudioHandle)render);
238 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
239
240 ret = render->control.Stop((AudioHandle)render);
241 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
242 adapter->DestroyRender(adapter, render);
243 manager->UnloadAdapter(manager, adapter);
244 }
245 /**
246 * @tc.name Test AudioRenderPause API via the render is paused after stoped.
247 * @tc.number SUB_Audio_HDI_RenderPause_0005
248 * @tc.desc Test AudioRenderPause interface, return -1 the render is paused after stopped.
249 */
250 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0005, Function | MediumTest | Level1)
251 {
252 int32_t ret = -1;
253 struct AudioAdapter *adapter = nullptr;
254 struct AudioRender *render = nullptr;
255 TestAudioManager* manager = {};
256
257 manager = GetAudioManagerFuncs();
258 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
259 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
260 ret = render->control.Stop((AudioHandle)render);
261 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
262 ret = render->control.Pause((AudioHandle)render);
263 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
264
265 adapter->DestroyRender(adapter, render);
266 manager->UnloadAdapter(manager, adapter);
267 }
268 /**
269 * @tc.name Test RenderPause API via setting the incoming parameter handle is nullptr
270 * @tc.number SUB_Audio_HDI_RenderPause_0006
271 * @tc.desc Test RenderPause interface, return -1 if the incoming parameter handle is nullptr
272 */
273 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderPause_0006, Function | MediumTest | Level1)
274 {
275 int32_t ret = -1;
276 struct AudioAdapter *adapter = nullptr;
277 struct AudioRender *render = nullptr;
278 struct AudioRender *renderNull = nullptr;
279 TestAudioManager* manager = {};
280
281 manager = GetAudioManagerFuncs();
282 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
283 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
284 ret = render->control.Pause((AudioHandle)renderNull);
285 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
286
287 ret = render->control.Stop((AudioHandle)render);
288 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
289 adapter->DestroyRender(adapter, render);
290 manager->UnloadAdapter(manager, adapter);
291 }
292 /**
293 * @tc.name Test RenderResume API via the render is resumed after started
294 * @tc.number SUB_Audio_HDI_RenderResume_0001
295 * @tc.desc test HDI RenderResume interface,return -1 if the render is resumed after started
296 */
297 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0001, Function | MediumTest | Level1)
298 {
299 int32_t ret = -1;
300 struct AudioAdapter *adapter = nullptr;
301 struct AudioRender *render = nullptr;
302
303 TestAudioManager* manager = GetAudioManagerFuncs();
304 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
305 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
306 ret = render->control.Resume((AudioHandle)render);
307 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
308
309 ret = render->control.Stop((AudioHandle)render);
310 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
311 adapter->DestroyRender(adapter, render);
312 manager->UnloadAdapter(manager, adapter);
313 }
314 /**
315 * @tc.name Test RenderResume API via the render is resumed after stopped
316 * @tc.number SUB_Audio_HDI_RenderResume_0002
317 * @tc.desc test HDI RenderResume interface,return -1 if the render is resumed after stopped
318 */
319 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0002, Function | MediumTest | Level1)
320 {
321 int32_t ret = -1;
322 struct AudioAdapter *adapter = nullptr;
323 struct AudioRender *render = nullptr;
324
325 TestAudioManager* manager = GetAudioManagerFuncs();
326 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
327 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
328 ret = render->control.Stop((AudioHandle)render);
329 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
330 ret = render->control.Resume((AudioHandle)render);
331 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
332
333 adapter->DestroyRender(adapter, render);
334 manager->UnloadAdapter(manager, adapter);
335 }
336 /**
337 * @tc.name Test RenderResume API via legal input
338 * @tc.number SUB_Audio_HDI_RenderResume_0003
339 * @tc.desc Test AudioRenderResume interface,return 0 if the render is resumed after paused
340 */
341 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0003, Function | MediumTest | Level1)
342 {
343 int32_t ret = -1;
344 struct AudioAdapter *adapter = nullptr;
345 struct AudioRender *render = nullptr;
346
347 TestAudioManager* manager = GetAudioManagerFuncs();
348 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
349 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
350 ret = render->control.Pause((AudioHandle)render);
351 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
352 ret = render->control.Resume((AudioHandle)render);
353 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
354
355 ret = render->control.Stop((AudioHandle)render);
356 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
357 adapter->DestroyRender(adapter, render);
358 manager->UnloadAdapter(manager, adapter);
359 }
360 /**
361 * @tc.name Test RenderResume API via the render Continue to start after resume
362 * @tc.number SUB_Audio_HDI_RenderResume_0005
363 * @tc.desc test HDI RenderResume interface,return -1 if the render Continue to start after resume
364 */
365 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0005, Function | MediumTest | Level1)
366 {
367 int32_t ret = -1;
368 struct AudioAdapter *adapter = nullptr;
369 struct AudioRender *render = nullptr;
370
371 TestAudioManager* manager = GetAudioManagerFuncs();
372 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
373 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
374 ret = render->control.Pause((AudioHandle)render);
375 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
376 ret = render->control.Resume((AudioHandle)render);
377 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
378 ret = render->control.Start((AudioHandle)render);
379 EXPECT_EQ(AUDIO_HAL_ERR_AO_BUSY, ret);
380
381 ret = render->control.Stop((AudioHandle)render);
382 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
383 adapter->DestroyRender(adapter, render);
384 manager->UnloadAdapter(manager, adapter);
385 }
386 /**
387 * @tc.name Test RenderResume API via setting the incoming parameter handle is nullptr
388 * @tc.number SUB_Audio_HDI_RenderResume_0007
389 * @tc.desc Test RenderResume interface, return -1 if the incoming parameter handle is nullptr
390 */
391 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0006, Function | MediumTest | Level1)
392 {
393 int32_t ret = -1;
394 struct AudioAdapter *adapter = nullptr;
395 struct AudioRender *render = nullptr;
396 struct AudioRender *renderNull = nullptr;
397
398 TestAudioManager* manager = GetAudioManagerFuncs();
399 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
400 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
401 ret = render->control.Pause((AudioHandle)render);
402 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
403 ret = render->control.Resume((AudioHandle)renderNull);
404 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
405
406 ret = render->control.Stop((AudioHandle)render);
407 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
408 adapter->DestroyRender(adapter, render);
409 manager->UnloadAdapter(manager, adapter);
410 }
411 /**
412 * @tc.name Test AudioCreateRender API via legal input.
413 * @tc.number SUB_Audio_HDI_CreateRender_0001
414 * @tc.desc test AudioCreateRender interface,return 0 if render is created successful.
415 */
416 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0001, Function | MediumTest | Level1)
417 {
418 int32_t ret = -1;
419 struct AudioAdapter *adapter = nullptr;
420 struct AudioRender *render = nullptr;
421 TestAudioManager* manager = GetAudioManagerFuncs();
422 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
423 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
424 adapter->DestroyRender(adapter, render);
425 manager->UnloadAdapter(manager, adapter);
426 }
427 /**
428 * @tc.name Test AudioCreateRender API via setting the incoming parameter pins is PIN_IN_MIC.
429 * @tc.number SUB_Audio_HDI_CreateRender_0003
430 * @tc.desc test AudioCreateRender interface,return -1 if the incoming parameter pins is PIN_IN_MIC.
431 */
432 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0003, Function | MediumTest | Level1)
433 {
434 int32_t ret = -1;
435 struct AudioAdapter *adapter = nullptr;
436 struct AudioRender *render = nullptr;
437 struct AudioPort* renderPort = nullptr;
438 struct AudioSampleAttributes attrs = {};
439 struct AudioDeviceDescriptor devDesc = {};
440
441 TestAudioManager* manager = GetAudioManagerFuncs();
442 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
443 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
444 InitAttrs(attrs);
445 InitDevDesc(devDesc, renderPort->portId, PIN_IN_MIC);
446 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
447 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
448 manager->UnloadAdapter(manager, adapter);
449 }
450
451 /**
452 * @tc.name Test AudioCreateRender API via setting the incoming parameter attr is error.
453 * @tc.number SUB_Audio_HDI_CreateRender_0004
454 * @tc.desc test AudioCreateRender interface,return -1 if the incoming parameter attr is error.
455 */
456 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0004, Function | MediumTest | Level1)
457 {
458 int32_t ret = -1;
459 struct AudioAdapter *adapter = nullptr;
460 struct AudioRender *render = nullptr;
461 struct AudioSampleAttributes attrs = {};
462 struct AudioDeviceDescriptor devDesc = {};
463 struct AudioPort* renderPort = nullptr;
464 uint32_t channelCountErr = 5;
465 TestAudioManager* manager = GetAudioManagerFuncs();
466 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
467 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
468 InitAttrs(attrs);
469 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
470 attrs.format = AUDIO_FORMAT_AAC_MAIN;
471 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
472 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
473 attrs.channelCount = channelCountErr;
474 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
475 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
476 attrs.type = AUDIO_IN_COMMUNICATION;
477 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
478 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
479
480 manager->UnloadAdapter(manager, adapter);
481 }
482 /**
483 * @tc.name Test AudioCreateRender API via setting the incoming parameter adapter is nullptr
484 * @tc.number SUB_Audio_HDI_CreateRender_0005
485 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter adapter is nullptr.
486 */
487 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0005, Function | MediumTest | Level1)
488 {
489 int32_t ret = -1;
490 struct AudioAdapter *adapter = nullptr;
491 struct AudioRender *render = nullptr;
492 struct AudioAdapter *adapterNull = nullptr;
493 struct AudioPort* renderPort = nullptr;
494 struct AudioSampleAttributes attrs = {};
495 struct AudioDeviceDescriptor devDesc = {};
496 TestAudioManager* manager = GetAudioManagerFuncs();
497 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
498 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
499 InitAttrs(attrs);
500 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
501 ret = adapter->CreateRender(adapterNull, &devDesc, &attrs, &render);
502 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
503 manager->UnloadAdapter(manager, adapter);
504 }
505
506 /**
507 * @tc.name Test AudioCreateRender API via setting the incoming parameter devDesc is nullptr
508 * @tc.number SUB_Audio_HDI_CreateRender_0006
509 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter devDesc is nullptr.
510 */
511 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0006, Function | MediumTest | Level1)
512 {
513 int32_t ret = -1;
514 struct AudioRender *render = nullptr;
515 struct AudioAdapter *adapter = nullptr;
516 struct AudioPort* renderPort = nullptr;
517 struct AudioSampleAttributes attrs = {};
518 struct AudioDeviceDescriptor *devDescNull = nullptr;
519 TestAudioManager* manager = GetAudioManagerFuncs();
520 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
521 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
522 InitAttrs(attrs);
523 ret = adapter->CreateRender(adapter, devDescNull, &attrs, &render);
524 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
525 manager->UnloadAdapter(manager, adapter);
526 }
527
528 /**
529 * @tc.name Test AudioCreateRender API via setting the incoming parameter attrs is nullptr
530 * @tc.number SUB_Audio_HDI_CreateRender_0007
531 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter attrs is nullptr.
532 */
533 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0007, Function | MediumTest | Level1)
534 {
535 int32_t ret = -1;
536 struct AudioPort* renderPort = nullptr;
537 struct AudioAdapter *adapter = nullptr;
538 struct AudioRender *render = nullptr;
539 struct AudioSampleAttributes *attrsNull = nullptr;
540 struct AudioDeviceDescriptor devDesc = {};
541
542 TestAudioManager* manager = GetAudioManagerFuncs();
543 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
544 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
545 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
546 ret = adapter->CreateRender(adapter, &devDesc, attrsNull, &render);
547 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
548 manager->UnloadAdapter(manager, adapter);
549 }
550
551 /**
552 * @tc.name Test AudioCreateRender API via setting the incoming parameter render is nullptr
553 * @tc.number SUB_Audio_HDI_CreateRender_0008
554 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter render is nullptr.
555 */
556 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0008, Function | MediumTest | Level1)
557 {
558 int32_t ret = -1;
559 struct AudioAdapter *adapter = nullptr;
560 struct AudioRender **renderNull = nullptr;
561 struct AudioPort* renderPort = nullptr;
562 struct AudioSampleAttributes attrs = {};
563 struct AudioDeviceDescriptor devDesc = {};
564
565 TestAudioManager* manager = GetAudioManagerFuncs();
566 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
567 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
568 InitAttrs(attrs);
569 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
570 ret = adapter->CreateRender(adapter, &devDesc, &attrs, renderNull);
571 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
572 manager->UnloadAdapter(manager, adapter);
573 }
574
575 /**
576 * @tc.name Test AudioCreateRender API via setting the incoming parameter devDesc is error
577 * @tc.number SUB_Audio_HDI_CreateRender_0009
578 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter devDesc is error.
579 */
580 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0009, Function | MediumTest | Level1)
581 {
582 int32_t ret = -1;
583 struct AudioAdapter *adapter = nullptr;
584 struct AudioRender *render = nullptr;
585 struct AudioSampleAttributes attrs = {};
586 struct AudioDeviceDescriptor devDesc = {};
587 struct AudioPort* renderPort = nullptr;
588
589 TestAudioManager* manager = GetAudioManagerFuncs();
590 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
591 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
592
593 ret = InitAttrs(attrs);
594 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
595 devDesc.portId = -5;
596 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
597 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
598 devDesc.pins = PIN_NONE;
599 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
600 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
601 devDesc.desc = "devtestname";
602 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
603 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
604
605 manager->UnloadAdapter(manager, adapter);
606 }
607 /**
608 * @tc.name Test AudioCreateRender API via setting the incoming parameter desc which portID is not configed
609 * @tc.number SUB_Audio_HDI_CreateRender_0010
610 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming desc which portID is not configed
611 */
612 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0010, TestSize.Level1)
613 {
614 int32_t ret = -1;
615 struct AudioAdapter *adapter = nullptr;
616 struct AudioRender *render = nullptr;
617 struct AudioSampleAttributes attrs = {};
618 struct AudioDeviceDescriptor devDesc = {};
619 struct AudioPort* renderPort = nullptr;
620 uint32_t portID = 10;
621
622 TestAudioManager* manager = GetAudioManagerFuncs();
623 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
624 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
625
626 ret = InitAttrs(attrs);
627 InitDevDesc(devDesc, portID, PIN_OUT_SPEAKER);
628
629 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
630 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
631 ret = adapter->DestroyRender(adapter, render);
632 manager->UnloadAdapter(manager, adapter);
633 }
634 /**
635 * @tc.name Test AudioDestroyRender API via legal input.
636 * @tc.number SUB_Audio_HDI_DestroyRender_0001
637 * @tc.desc Test AudioDestroyRender interface, return 0 if render is destroyed successful.
638 */
639 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_DestroyRender_0001, Function | MediumTest | Level1)
640 {
641 int32_t ret = -1;
642 struct AudioAdapter *adapter = nullptr;
643 struct AudioRender *render = nullptr;
644 TestAudioManager* manager = GetAudioManagerFuncs();
645
646 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
647 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
648
649 ret = adapter->DestroyRender(adapter, render);
650 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
651 manager->UnloadAdapter(manager, adapter);
652 }
653 /**
654 * @tc.name Test AudioDestroyRender API,where the parameter render is empty.
655 * @tc.number SUB_Audio_HDI_DestroyRender_0002
656 * @tc.desc Test AudioDestroyRender interface, return -1 if the parameter render is empty.
657 */
658 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_DestroyRender_0002, Function | MediumTest | Level1)
659 {
660 int32_t ret = -1;
661 struct AudioAdapter *adapter = nullptr;
662 struct AudioRender *render = nullptr;
663 struct AudioRender *renderNull = nullptr;
664 TestAudioManager* manager = GetAudioManagerFuncs();
665
666 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
667 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
668
669 ret = adapter->DestroyRender(adapter, renderNull);
670 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
671 manager->UnloadAdapter(manager, adapter);
672 }
673
674 /**
675 * @tc.name Test RenderFlush API via legal input Verify that the data in the buffer is flushed after stop
676 * @tc.number SUB_Audio_HDI_RenderFlush_0001
677 * @tc.desc Test RenderFlush interface,return -2 if the data in the buffer is flushed successfully after stop
678 */
679 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderFlush_0001, Function | MediumTest | Level1)
680 {
681 int32_t ret = -1;
682 TestAudioManager* manager = {};
683 struct AudioAdapter *adapter = nullptr;
684 struct AudioRender *render = nullptr;
685
686 manager = GetAudioManagerFuncs();
687
688 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
689 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
690 ret = render->control.Stop((AudioHandle)render);
691 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
692 ret = render->control.Flush((AudioHandle)render);
693 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
694
695 adapter->DestroyRender(adapter, render);
696 manager->UnloadAdapter(manager, adapter);
697 }
698 /**
699 * @tc.name Test RenderFlush that the data in the buffer is flushed when handle is nullptr after paused
700 * @tc.number SUB_Audio_HDI_RenderFlush_0002
701 * @tc.desc Test RenderFlush, return -1 if the data in the buffer is flushed when handle is nullptr after paused
702 */
703 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderFlush_0002, Function | MediumTest | Level1)
704 {
705 int32_t ret = -1;
706 TestAudioManager* manager = {};
707 struct AudioAdapter *adapter = nullptr;
708 struct AudioRender *render = nullptr;
709 struct AudioRender *renderNull = nullptr;
710
711 manager = GetAudioManagerFuncs();
712
713 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
714 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
715 ret = render->control.Pause((AudioHandle)render);
716 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
717 ret = render->control.Flush((AudioHandle)renderNull);
718 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
719
720 ret = render->control.Stop((AudioHandle)render);
721 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
722 adapter->DestroyRender(adapter, render);
723 manager->UnloadAdapter(manager, adapter);
724 }
725 }