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 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_AO_BUSY)){
380 EXPECT_TRUE(true);
381 }else{
382 EXPECT_TRUE(false);
383 }
384
385 ret = render->control.Stop((AudioHandle)render);
386 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
387 adapter->DestroyRender(adapter, render);
388 manager->UnloadAdapter(manager, adapter);
389 }
390 /**
391 * @tc.name Test RenderResume API via setting the incoming parameter handle is nullptr
392 * @tc.number SUB_Audio_HDI_RenderResume_0007
393 * @tc.desc Test RenderResume interface, return -1 if the incoming parameter handle is nullptr
394 */
395 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderResume_0006, Function | MediumTest | Level1)
396 {
397 int32_t ret = -1;
398 struct AudioAdapter *adapter = nullptr;
399 struct AudioRender *render = nullptr;
400 struct AudioRender *renderNull = nullptr;
401
402 TestAudioManager* manager = GetAudioManagerFuncs();
403 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
404 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
405 ret = render->control.Pause((AudioHandle)render);
406 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
407 ret = render->control.Resume((AudioHandle)renderNull);
408 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
409
410 ret = render->control.Stop((AudioHandle)render);
411 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
412 adapter->DestroyRender(adapter, render);
413 manager->UnloadAdapter(manager, adapter);
414 }
415 /**
416 * @tc.name Test AudioCreateRender API via legal input.
417 * @tc.number SUB_Audio_HDI_CreateRender_0001
418 * @tc.desc test AudioCreateRender interface,return 0 if render is created successful.
419 */
420 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0001, Function | MediumTest | Level1)
421 {
422 int32_t ret = -1;
423 struct AudioAdapter *adapter = nullptr;
424 struct AudioRender *render = nullptr;
425 TestAudioManager* manager = GetAudioManagerFuncs();
426 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
427 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
428 adapter->DestroyRender(adapter, render);
429 manager->UnloadAdapter(manager, adapter);
430 }
431 /**
432 * @tc.name Test AudioCreateRender API via setting the incoming parameter pins is PIN_IN_MIC.
433 * @tc.number SUB_Audio_HDI_CreateRender_0003
434 * @tc.desc test AudioCreateRender interface,return -1 if the incoming parameter pins is PIN_IN_MIC.
435 */
436 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0003, Function | MediumTest | Level1)
437 {
438 int32_t ret = -1;
439 struct AudioAdapter *adapter = nullptr;
440 struct AudioRender *render = nullptr;
441 struct AudioPort* renderPort = nullptr;
442 struct AudioSampleAttributes attrs = {};
443 struct AudioDeviceDescriptor devDesc = {};
444
445 TestAudioManager* manager = GetAudioManagerFuncs();
446 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
447 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
448 InitAttrs(attrs);
449 InitDevDesc(devDesc, renderPort->portId, PIN_IN_MIC);
450 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
451 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
452 manager->UnloadAdapter(manager, adapter);
453 }
454
455 /**
456 * @tc.name Test AudioCreateRender API via setting the incoming parameter attr is error.
457 * @tc.number SUB_Audio_HDI_CreateRender_0004
458 * @tc.desc test AudioCreateRender interface,return -1 if the incoming parameter attr is error.
459 */
460 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0004, Function | MediumTest | Level1)
461 {
462 int32_t ret = -1;
463 struct AudioAdapter *adapter = nullptr;
464 struct AudioRender *render = nullptr;
465 struct AudioSampleAttributes attrs = {};
466 struct AudioDeviceDescriptor devDesc = {};
467 struct AudioPort* renderPort = nullptr;
468 uint32_t channelCountErr = 5;
469 TestAudioManager* manager = GetAudioManagerFuncs();
470 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
471 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
472 InitAttrs(attrs);
473 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
474 attrs.format = AUDIO_FORMAT_AAC_MAIN;
475 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
476 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
477 attrs.channelCount = channelCountErr;
478 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
479 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
480 attrs.type = AUDIO_IN_COMMUNICATION;
481 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
482 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
483
484 manager->UnloadAdapter(manager, adapter);
485 }
486 /**
487 * @tc.name Test AudioCreateRender API via setting the incoming parameter adapter is nullptr
488 * @tc.number SUB_Audio_HDI_CreateRender_0005
489 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter adapter is nullptr.
490 */
491 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0005, Function | MediumTest | Level1)
492 {
493 int32_t ret = -1;
494 struct AudioAdapter *adapter = nullptr;
495 struct AudioRender *render = nullptr;
496 struct AudioAdapter *adapterNull = nullptr;
497 struct AudioPort* renderPort = nullptr;
498 struct AudioSampleAttributes attrs = {};
499 struct AudioDeviceDescriptor devDesc = {};
500 TestAudioManager* manager = GetAudioManagerFuncs();
501 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
502 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
503 InitAttrs(attrs);
504 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
505 ret = adapter->CreateRender(adapterNull, &devDesc, &attrs, &render);
506 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
507 manager->UnloadAdapter(manager, adapter);
508 }
509
510 /**
511 * @tc.name Test AudioCreateRender API via setting the incoming parameter devDesc is nullptr
512 * @tc.number SUB_Audio_HDI_CreateRender_0006
513 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter devDesc is nullptr.
514 */
515 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0006, Function | MediumTest | Level1)
516 {
517 int32_t ret = -1;
518 struct AudioRender *render = nullptr;
519 struct AudioAdapter *adapter = nullptr;
520 struct AudioPort* renderPort = nullptr;
521 struct AudioSampleAttributes attrs = {};
522 struct AudioDeviceDescriptor *devDescNull = nullptr;
523 TestAudioManager* manager = GetAudioManagerFuncs();
524 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
525 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
526 InitAttrs(attrs);
527 ret = adapter->CreateRender(adapter, devDescNull, &attrs, &render);
528 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
529 manager->UnloadAdapter(manager, adapter);
530 }
531
532 /**
533 * @tc.name Test AudioCreateRender API via setting the incoming parameter attrs is nullptr
534 * @tc.number SUB_Audio_HDI_CreateRender_0007
535 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter attrs is nullptr.
536 */
537 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0007, Function | MediumTest | Level1)
538 {
539 int32_t ret = -1;
540 struct AudioPort* renderPort = nullptr;
541 struct AudioAdapter *adapter = nullptr;
542 struct AudioRender *render = nullptr;
543 struct AudioSampleAttributes *attrsNull = nullptr;
544 struct AudioDeviceDescriptor devDesc = {};
545
546 TestAudioManager* manager = GetAudioManagerFuncs();
547 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
548 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
549 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
550 ret = adapter->CreateRender(adapter, &devDesc, attrsNull, &render);
551 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
552 manager->UnloadAdapter(manager, adapter);
553 }
554
555 /**
556 * @tc.name Test AudioCreateRender API via setting the incoming parameter render is nullptr
557 * @tc.number SUB_Audio_HDI_CreateRender_0008
558 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter render is nullptr.
559 */
560 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0008, Function | MediumTest | Level1)
561 {
562 int32_t ret = -1;
563 struct AudioAdapter *adapter = nullptr;
564 struct AudioRender **renderNull = nullptr;
565 struct AudioPort* renderPort = nullptr;
566 struct AudioSampleAttributes attrs = {};
567 struct AudioDeviceDescriptor devDesc = {};
568
569 TestAudioManager* manager = GetAudioManagerFuncs();
570 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
571 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
572 InitAttrs(attrs);
573 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
574 ret = adapter->CreateRender(adapter, &devDesc, &attrs, renderNull);
575 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
576 manager->UnloadAdapter(manager, adapter);
577 }
578
579 /**
580 * @tc.name Test AudioCreateRender API via setting the incoming parameter devDesc is error
581 * @tc.number SUB_Audio_HDI_CreateRender_0009
582 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter devDesc is error.
583 */
584 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0009, Function | MediumTest | Level1)
585 {
586 int32_t ret = -1;
587 struct AudioAdapter *adapter = nullptr;
588 struct AudioRender *render = nullptr;
589 struct AudioSampleAttributes attrs = {};
590 struct AudioDeviceDescriptor devDesc = {};
591 struct AudioPort* renderPort = nullptr;
592
593 TestAudioManager* manager = GetAudioManagerFuncs();
594 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
595 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
596
597 ret = InitAttrs(attrs);
598 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
599 devDesc.portId = -5;
600 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
601 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
602 devDesc.pins = PIN_NONE;
603 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
604 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
605 devDesc.desc = "devtestname";
606 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
607 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
608
609 manager->UnloadAdapter(manager, adapter);
610 }
611 /**
612 * @tc.name Test AudioCreateRender API via setting the incoming parameter desc which portID is not configed
613 * @tc.number SUB_Audio_HDI_CreateRender_0010
614 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming desc which portID is not configed
615 */
616 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_CreateRender_0010, TestSize.Level1)
617 {
618 int32_t ret = -1;
619 struct AudioAdapter *adapter = nullptr;
620 struct AudioRender *render = nullptr;
621 struct AudioSampleAttributes attrs = {};
622 struct AudioDeviceDescriptor devDesc = {};
623 struct AudioPort* renderPort = nullptr;
624 uint32_t portID = 10;
625
626 TestAudioManager* manager = GetAudioManagerFuncs();
627 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
628 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
629
630 ret = InitAttrs(attrs);
631 InitDevDesc(devDesc, portID, PIN_OUT_SPEAKER);
632
633 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
634 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
635 ret = adapter->DestroyRender(adapter, render);
636 manager->UnloadAdapter(manager, adapter);
637 }
638 /**
639 * @tc.name Test AudioDestroyRender API via legal input.
640 * @tc.number SUB_Audio_HDI_DestroyRender_0001
641 * @tc.desc Test AudioDestroyRender interface, return 0 if render is destroyed successful.
642 */
643 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_DestroyRender_0001, Function | MediumTest | Level1)
644 {
645 int32_t ret = -1;
646 struct AudioAdapter *adapter = nullptr;
647 struct AudioRender *render = nullptr;
648 TestAudioManager* manager = GetAudioManagerFuncs();
649
650 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
651 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
652
653 ret = adapter->DestroyRender(adapter, render);
654 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
655 manager->UnloadAdapter(manager, adapter);
656 }
657 /**
658 * @tc.name Test AudioDestroyRender API,where the parameter render is empty.
659 * @tc.number SUB_Audio_HDI_DestroyRender_0002
660 * @tc.desc Test AudioDestroyRender interface, return -1 if the parameter render is empty.
661 */
662 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_DestroyRender_0002, Function | MediumTest | Level1)
663 {
664 int32_t ret = -1;
665 struct AudioAdapter *adapter = nullptr;
666 struct AudioRender *render = nullptr;
667 struct AudioRender *renderNull = nullptr;
668 TestAudioManager* manager = GetAudioManagerFuncs();
669
670 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
671 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
672
673 ret = adapter->DestroyRender(adapter, renderNull);
674 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
675 manager->UnloadAdapter(manager, adapter);
676 }
677
678 /**
679 * @tc.name Test RenderFlush API via legal input Verify that the data in the buffer is flushed after stop
680 * @tc.number SUB_Audio_HDI_RenderFlush_0001
681 * @tc.desc Test RenderFlush interface,return -2 if the data in the buffer is flushed successfully after stop
682 */
683 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderFlush_0001, Function | MediumTest | Level1)
684 {
685 int32_t ret = -1;
686 TestAudioManager* manager = {};
687 struct AudioAdapter *adapter = nullptr;
688 struct AudioRender *render = nullptr;
689
690 manager = GetAudioManagerFuncs();
691
692 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
693 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
694 ret = render->control.Stop((AudioHandle)render);
695 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
696 ret = render->control.Flush((AudioHandle)render);
697 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
698
699 adapter->DestroyRender(adapter, render);
700 manager->UnloadAdapter(manager, adapter);
701 }
702 /**
703 * @tc.name Test RenderFlush that the data in the buffer is flushed when handle is nullptr after paused
704 * @tc.number SUB_Audio_HDI_RenderFlush_0002
705 * @tc.desc Test RenderFlush, return -1 if the data in the buffer is flushed when handle is nullptr after paused
706 */
707 HWTEST_F(AudioHdiRenderControlTest, SUB_Audio_HDI_RenderFlush_0002, Function | MediumTest | Level1)
708 {
709 int32_t ret = -1;
710 TestAudioManager* manager = {};
711 struct AudioAdapter *adapter = nullptr;
712 struct AudioRender *render = nullptr;
713 struct AudioRender *renderNull = nullptr;
714
715 manager = GetAudioManagerFuncs();
716
717 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
718 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
719 ret = render->control.Pause((AudioHandle)render);
720 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
721 ret = render->control.Flush((AudioHandle)renderNull);
722 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
723
724 ret = render->control.Stop((AudioHandle)render);
725 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
726 adapter->DestroyRender(adapter, render);
727 manager->UnloadAdapter(manager, adapter);
728 }
729 }
730