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 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 static TestAudioManager *manager;
51 };
52
53 TestAudioManager *AudioHdiRenderControlTest::manager = nullptr;
54
SetUpTestCase(void)55 void AudioHdiRenderControlTest::SetUpTestCase(void)
56 {
57 manager = GetAudioManagerFuncs();
58 ASSERT_NE(nullptr, manager);
59 }
60
TearDownTestCase(void)61 void AudioHdiRenderControlTest::TearDownTestCase(void) {}
62
SetUp(void)63 void AudioHdiRenderControlTest::SetUp(void) {}
64
TearDown(void)65 void AudioHdiRenderControlTest::TearDown(void) {}
66
67 /**
68 * @tc.name AudioRenderStart_001
69 * @tc.desc Test AudioRenderStart interface,return 0 if the audiorender object is created successfully.
70 * @tc.type: FUNC
71 */
72 HWTEST_F(AudioHdiRenderControlTest, AudioRenderStart_001, TestSize.Level1)
73 {
74 int32_t ret = -1;
75 struct AudioAdapter *adapter = nullptr;
76 struct AudioRender *render = nullptr;
77
78 ASSERT_NE(nullptr, manager);
79 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
80 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
81 ret = render->control.Start((AudioHandle)render);
82 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
83
84 ret = render->control.Stop((AudioHandle)render);
85 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
86 adapter->DestroyRender(adapter, render);
87 manager->UnloadAdapter(manager, adapter);
88 }
89 /**
90 * @tc.name AudioRenderStart_002
91 * @tc.desc Test AudioRenderStart interface, return -1 if the incoming parameter handle is nullptr
92 * @tc.type: FUNC
93 */
94 HWTEST_F(AudioHdiRenderControlTest, AudioRenderStart_002, TestSize.Level1)
95 {
96 int32_t ret = -1;
97 struct AudioAdapter *adapter = nullptr;
98 struct AudioRender *render = nullptr;
99 struct AudioRender *renderNull = nullptr;
100
101 ASSERT_NE(nullptr, manager);
102 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
103 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
104 ret = render->control.Start((AudioHandle)renderNull);
105 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
106
107 adapter->DestroyRender(adapter, render);
108 manager->UnloadAdapter(manager, adapter);
109 }
110 /**
111 * @tc.name AudioRenderStart_003
112 * @tc.desc Test AudioRenderStart interface,return -1 the second time if the RenderStart is called twice
113 * @tc.type: FUNC
114 */
115 HWTEST_F(AudioHdiRenderControlTest, AudioRenderStart_003, TestSize.Level1)
116 {
117 int32_t ret = -1;
118 struct AudioAdapter *adapter = nullptr;
119 struct AudioRender *render = nullptr;
120
121 ASSERT_NE(nullptr, manager);
122 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
123 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
124 ret = render->control.Start((AudioHandle)render);
125 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
126 ret = render->control.Start((AudioHandle)render);
127 EXPECT_EQ(AUDIO_HAL_ERR_AO_BUSY, ret);
128
129 ret = render->control.Stop((AudioHandle)render);
130 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
131 adapter->DestroyRender(adapter, render);
132 manager->UnloadAdapter(manager, adapter);
133 }
134 /**
135 * @tc.name AudioRenderStop_001
136 * @tc.desc test AudioRenderStop interface. return 0 if the rendering is successfully stopped.
137 * @tc.type: FUNC
138 */
139 HWTEST_F(AudioHdiRenderControlTest, AudioRenderStop_001, TestSize.Level1)
140 {
141 int32_t ret = -1;
142 struct AudioAdapter *adapter = nullptr;
143 struct AudioRender *render = nullptr;
144
145 ASSERT_NE(nullptr, manager);
146 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
147 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
148 ret = render->control.Start((AudioHandle)render);
149 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
150 ret = render->control.Stop((AudioHandle)render);
151 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
152
153 adapter->DestroyRender(adapter, render);
154 manager->UnloadAdapter(manager, adapter);
155 }
156 /**
157 * @tc.name AudioRenderStop_002
158 * @tc.desc test AudioRenderStop interface. return -4 if the render does not start and stop only
159 * @tc.type: FUNC
160 */
161 HWTEST_F(AudioHdiRenderControlTest, AudioRenderStop_002, TestSize.Level1)
162 {
163 int32_t ret = -1;
164 struct AudioAdapter *adapter = nullptr;
165 struct AudioRender *render = nullptr;
166
167 ASSERT_NE(nullptr, manager);
168 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
169 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
170 ret = render->control.Stop((AudioHandle)render);
171 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
172
173 adapter->DestroyRender(adapter, render);
174 manager->UnloadAdapter(manager, adapter);
175 }
176 /**
177 * @tc.name AudioRenderStop_003
178 * @tc.desc Test RenderStop interface,return -4 the second time if the RenderStop is called twice
179 * @tc.type: FUNC
180 */
181 HWTEST_F(AudioHdiRenderControlTest, AudioRenderStop_003, TestSize.Level1)
182 {
183 int32_t ret = -1;
184 struct AudioAdapter *adapter = nullptr;
185 struct AudioRender *render = nullptr;
186
187 ASSERT_NE(nullptr, manager);
188 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
189 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
190 ret = render->control.Start((AudioHandle)render);
191 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
192 ret = render->control.Stop((AudioHandle)render);
193 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
194 ret = render->control.Stop((AudioHandle)render);
195 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
196
197 adapter->DestroyRender(adapter, render);
198 manager->UnloadAdapter(manager, adapter);
199 }
200 /**
201 * @tc.name AudioRenderStop_004
202 * @tc.desc Test RenderStop interface, return -1 if the incoming parameter handle is nullptr
203 * @tc.type: FUNC
204 */
205 HWTEST_F(AudioHdiRenderControlTest, AudioRenderStop_004, TestSize.Level1)
206 {
207 int32_t ret = -1;
208 struct AudioAdapter *adapter = nullptr;
209 struct AudioRender *render = nullptr;
210 struct AudioRender *renderNull = nullptr;
211
212 ASSERT_NE(nullptr, manager);
213 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
214 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
215 ret = render->control.Start((AudioHandle)render);
216 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
217 ret = render->control.Stop((AudioHandle)renderNull);
218 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
219
220 ret = render->control.Stop((AudioHandle)render);
221 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
222 adapter->DestroyRender(adapter, render);
223 manager->UnloadAdapter(manager, adapter);
224 }
225 /**
226 * @tc.name AudioRenderPause_001
227 * @tc.desc test HDI RenderPause interface，return 0 if the render is paused after start
228 * @tc.type: FUNC
229 */
230 HWTEST_F(AudioHdiRenderControlTest, AudioRenderPause_001, TestSize.Level1)
231 {
232 int32_t ret = -1;
233 struct AudioAdapter *adapter = nullptr;
234 struct AudioRender *render = nullptr;
235
236 ASSERT_NE(nullptr, manager);
237 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
238 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
239 ret = render->control.Pause((AudioHandle)render);
240 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
241
242 ret = render->control.Stop((AudioHandle)render);
243 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
244 adapter->DestroyRender(adapter, render);
245 manager->UnloadAdapter(manager, adapter);
246 }
247 /**
248 * @tc.name AudioRenderPause_002
249 * @tc.desc Test AudioRenderPause interface, return -1 the second time if RenderPause is called twice
250 * @tc.type: FUNC
251 */
252 HWTEST_F(AudioHdiRenderControlTest, AudioRenderPause_002, TestSize.Level1)
253 {
254 int32_t ret = -1;
255 struct AudioAdapter *adapter = nullptr;
256 struct AudioRender *render = nullptr;
257
258 ASSERT_NE(nullptr, manager);
259 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
260 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
261 ret = render->control.Pause((AudioHandle)render);
262 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
263 ret = render->control.Pause((AudioHandle)render);
264 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
265
266 render->control.Stop((AudioHandle)render);
267 adapter->DestroyRender(adapter, render);
268 manager->UnloadAdapter(manager, adapter);
269 }
270 /**
271 * @tc.name AudioRenderPause_003
272 * @tc.desc Test AudioRenderPause interface,return -1 if the render is paused after created.
273 * @tc.type: FUNC
274 */
275 HWTEST_F(AudioHdiRenderControlTest, AudioRenderPause_003, TestSize.Level1)
276 {
277 int32_t ret = -1;
278 struct AudioAdapter *adapter = nullptr;
279 struct AudioRender *render = nullptr;
280
281 ASSERT_NE(nullptr, manager);
282 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
283 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
284 ret = render->control.Pause((AudioHandle)render);
285 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
286 adapter->DestroyRender(adapter, render);
287 manager->UnloadAdapter(manager, adapter);
288 }
289 /**
290 * @tc.name AudioRenderPause_004
291 * @tc.desc Test AudioRenderPause interface,return 0 if the render is paused after resumed.
292 * @tc.type: FUNC
293 */
294 HWTEST_F(AudioHdiRenderControlTest, AudioRenderPause_004, TestSize.Level1)
295 {
296 int32_t ret = -1;
297 struct AudioAdapter *adapter = nullptr;
298 struct AudioRender *render = nullptr;
299
300 ASSERT_NE(nullptr, manager);
301 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
302 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
303 ret = render->control.Pause((AudioHandle)render);
304 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
305 ret = render->control.Resume((AudioHandle)render);
306 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
307 ret = render->control.Pause((AudioHandle)render);
308 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
309
310 ret = render->control.Stop((AudioHandle)render);
311 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
312 adapter->DestroyRender(adapter, render);
313 manager->UnloadAdapter(manager, adapter);
314 }
315 /**
316 * @tc.name AudioRenderPause_005
317 * @tc.desc Test AudioRenderPause interface, return -1 the render is paused after stopped.
318 * @tc.type: FUNC
319 */
320 HWTEST_F(AudioHdiRenderControlTest, AudioRenderPause_005, TestSize.Level1)
321 {
322 int32_t ret = -1;
323 struct AudioAdapter *adapter = nullptr;
324 struct AudioRender *render = nullptr;
325
326 ASSERT_NE(nullptr, manager);
327 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
328 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
329 ret = render->control.Stop((AudioHandle)render);
330 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
331 ret = render->control.Pause((AudioHandle)render);
332 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
333
334 adapter->DestroyRender(adapter, render);
335 manager->UnloadAdapter(manager, adapter);
336 }
337 /**
338 * @tc.name AudioRenderPause_006
339 * @tc.desc Test RenderPause interface, return -1 if the incoming parameter handle is nullptr
340 * @tc.type: FUNC
341 */
342 HWTEST_F(AudioHdiRenderControlTest, AudioRenderPause_006, TestSize.Level1)
343 {
344 int32_t ret = -1;
345 struct AudioAdapter *adapter = nullptr;
346 struct AudioRender *render = nullptr;
347 struct AudioRender *renderNull = nullptr;
348
349 ASSERT_NE(nullptr, manager);
350 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
351 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
352 ret = render->control.Pause((AudioHandle)renderNull);
353 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, 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 AudioRenderResume_001
362 * @tc.desc test HDI RenderResume interface,return -1 if the render is resumed after started
363 * @tc.type: FUNC
364 */
365 HWTEST_F(AudioHdiRenderControlTest, AudioRenderResume_001, TestSize.Level1)
366 {
367 int32_t ret = -1;
368 struct AudioAdapter *adapter = nullptr;
369 struct AudioRender *render = nullptr;
370
371 ASSERT_NE(nullptr, manager);
372 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
373 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
374 ret = render->control.Resume((AudioHandle)render);
375 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
376
377 ret = render->control.Stop((AudioHandle)render);
378 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
379 adapter->DestroyRender(adapter, render);
380 manager->UnloadAdapter(manager, adapter);
381 }
382 /**
383 * @tc.name AudioRenderResume_002
384 * @tc.desc test HDI RenderResume interface,return -1 if the render is resumed after stopped
385 * @tc.type: FUNC
386 */
387 HWTEST_F(AudioHdiRenderControlTest, AudioRenderResume_002, TestSize.Level1)
388 {
389 int32_t ret = -1;
390 struct AudioAdapter *adapter = nullptr;
391 struct AudioRender *render = nullptr;
392
393 ASSERT_NE(nullptr, manager);
394 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
395 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
396 ret = render->control.Stop((AudioHandle)render);
397 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
398 ret = render->control.Resume((AudioHandle)render);
399 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
400
401 adapter->DestroyRender(adapter, render);
402 manager->UnloadAdapter(manager, adapter);
403 }
404 /**
405 * @tc.name AudioRenderResume_003
406 * @tc.desc Test AudioRenderResume interface,return 0 if the render is resumed after paused
407 * @tc.type: FUNC
408 */
409 HWTEST_F(AudioHdiRenderControlTest, AudioRenderResume_003, TestSize.Level1)
410 {
411 int32_t ret = -1;
412 struct AudioAdapter *adapter = nullptr;
413 struct AudioRender *render = nullptr;
414
415 ASSERT_NE(nullptr, manager);
416 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
417 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
418 ret = render->control.Pause((AudioHandle)render);
419 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
420 ret = render->control.Resume((AudioHandle)render);
421 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
422
423 ret = render->control.Stop((AudioHandle)render);
424 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
425 adapter->DestroyRender(adapter, render);
426 manager->UnloadAdapter(manager, adapter);
427 }
428 /**
429 * @tc.name AudioRenderResume_004
430 * @tc.desc Test RenderResume interface,return -1 the second time if the RenderResume is called twice
431 * @tc.type: FUNC
432 */
433 HWTEST_F(AudioHdiRenderControlTest, AudioRenderResume_004, TestSize.Level1)
434 {
435 int32_t ret = -1;
436 struct AudioAdapter *adapter = nullptr;
437 struct AudioRender *render = nullptr;
438
439 ASSERT_NE(nullptr, manager);
440 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
441 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
442 ret = render->control.Pause((AudioHandle)render);
443 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
444 ret = render->control.Resume((AudioHandle)render);
445 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
446 ret = render->control.Resume((AudioHandle)render);
447 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
448
449 ret = render->control.Stop((AudioHandle)render);
450 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
451 adapter->DestroyRender(adapter, render);
452 manager->UnloadAdapter(manager, adapter);
453 }
454 /**
455 * @tc.name AudioRenderResume_005
456 * @tc.desc test HDI RenderResume interface,return -1 if the render Continue to start after resume
457 * @tc.type: FUNC
458 */
459 HWTEST_F(AudioHdiRenderControlTest, AudioRenderResume_005, TestSize.Level1)
460 {
461 int32_t ret = -1;
462 struct AudioAdapter *adapter = nullptr;
463 struct AudioRender *render = nullptr;
464
465 ASSERT_NE(nullptr, manager);
466 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
467 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
468 ret = render->control.Pause((AudioHandle)render);
469 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
470 ret = render->control.Resume((AudioHandle)render);
471 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
472 ret = render->control.Start((AudioHandle)render);
473 EXPECT_EQ(AUDIO_HAL_ERR_AO_BUSY, ret);
474
475 ret = render->control.Stop((AudioHandle)render);
476 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
477 adapter->DestroyRender(adapter, render);
478 manager->UnloadAdapter(manager, adapter);
479 }
480 /**
481 * @tc.name AudioRenderResume_007
482 * @tc.desc Test RenderResume interface, return -1 if the incoming parameter handle is nullptr
483 * @tc.type: FUNC
484 */
485 HWTEST_F(AudioHdiRenderControlTest, AudioRenderResume_006, TestSize.Level1)
486 {
487 int32_t ret = -1;
488 struct AudioAdapter *adapter = nullptr;
489 struct AudioRender *render = nullptr;
490 struct AudioRender *renderNull = nullptr;
491
492 ASSERT_NE(nullptr, manager);
493 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
494 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
495 ret = render->control.Pause((AudioHandle)render);
496 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
497 ret = render->control.Resume((AudioHandle)renderNull);
498 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
499
500 ret = render->control.Stop((AudioHandle)render);
501 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
502 adapter->DestroyRender(adapter, render);
503 manager->UnloadAdapter(manager, adapter);
504 }
505 /**
506 * @tc.name AudioCreateRender_001
507 * @tc.desc test AudioCreateRender interface,return 0 if render is created successful.
508 * @tc.type: FUNC
509 */
510 HWTEST_F(AudioHdiRenderControlTest, AudioCreateRender_001, TestSize.Level1)
511 {
512 int32_t ret = -1;
513 struct AudioAdapter *adapter = nullptr;
514 struct AudioRender *render = nullptr;
515 ASSERT_NE(nullptr, manager);
516 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
517 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
518
519 adapter->DestroyRender(adapter, render);
520 manager->UnloadAdapter(manager, adapter);
521 }
522 /**
523 * @tc.name AudioCreateRender_003
524 * @tc.desc test AudioCreateRender interface,return -1 if the incoming parameter pins is PIN_IN_MIC.
525 * @tc.type: FUNC
526 */
527 HWTEST_F(AudioHdiRenderControlTest, AudioCreateRender_003, TestSize.Level1)
528 {
529 int32_t ret = -1;
530 struct AudioAdapter *adapter = nullptr;
531 struct AudioRender *render = nullptr;
532 struct AudioPort* renderPort = nullptr;
533 struct AudioSampleAttributes attrs = {};
534 struct AudioDeviceDescriptor devDesc = {};
535 ASSERT_NE(nullptr, manager);
536 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
537 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
538
539 InitAttrs(attrs);
540 InitDevDesc(devDesc, renderPort->portId, PIN_IN_MIC);
541
542 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
543 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
544 manager->UnloadAdapter(manager, adapter);
545 }
546
547 /**
548 * @tc.name AudioCreateRender_004
549 * @tc.desc test AudioCreateRender interface,return -1 if the incoming parameter attr is error.
550 * @tc.type: FUNC
551 */
552 HWTEST_F(AudioHdiRenderControlTest, AudioCreateRender_004, TestSize.Level1)
553 {
554 int32_t ret = -1;
555 struct AudioAdapter *adapter = nullptr;
556 struct AudioRender *render = nullptr;
557 struct AudioSampleAttributes attrs = {};
558 struct AudioDeviceDescriptor devDesc = {};
559 struct AudioPort* renderPort = nullptr;
560 uint32_t channelCountErr = 5;
561 ASSERT_NE(nullptr, manager);
562 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
563 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
564
565 InitAttrs(attrs);
566 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
567 attrs.format = AUDIO_FORMAT_AAC_MAIN;
568 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
569 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
570 attrs.channelCount = channelCountErr;
571 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
572 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
573 attrs.type = AUDIO_IN_COMMUNICATION;
574 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
575 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
576
577 manager->UnloadAdapter(manager, adapter);
578 }
579 /**
580 * @tc.name AudioCreateRender_005
581 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter adapter is nullptr.
582 * @tc.type: FUNC
583 */
584 HWTEST_F(AudioHdiRenderControlTest, AudioCreateRender_005, TestSize.Level1)
585 {
586 int32_t ret = -1;
587 struct AudioAdapter *adapter = nullptr;
588 struct AudioRender *render = nullptr;
589 struct AudioAdapter *adapterNull = nullptr;
590 struct AudioPort* renderPort = nullptr;
591 struct AudioSampleAttributes attrs = {};
592 struct AudioDeviceDescriptor devDesc = {};
593 ASSERT_NE(nullptr, manager);
594 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
595 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
596
597 InitAttrs(attrs);
598 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
599
600 ret = adapter->CreateRender(adapterNull, &devDesc, &attrs, &render);
601 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
602
603 manager->UnloadAdapter(manager, adapter);
604 }
605
606 /**
607 * @tc.name AudioCreateRender_006
608 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter devDesc is nullptr.
609 * @tc.type: FUNC
610 */
611 HWTEST_F(AudioHdiRenderControlTest, AudioCreateRender_006, TestSize.Level1)
612 {
613 int32_t ret = -1;
614 struct AudioRender *render = nullptr;
615 struct AudioAdapter *adapter = nullptr;
616 struct AudioPort* renderPort = nullptr;
617 struct AudioSampleAttributes attrs = {};
618 struct AudioDeviceDescriptor *devDescNull = nullptr;
619 ASSERT_NE(nullptr, manager);
620 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
621 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
622
623 InitAttrs(attrs);
624
625 ret = adapter->CreateRender(adapter, devDescNull, &attrs, &render);
626 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
627
628 manager->UnloadAdapter(manager, adapter);
629 }
630
631 /**
632 * @tc.name AudioCreateRender_007
633 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter attrs is nullptr.
634 * @tc.type: FUNC
635 */
636 HWTEST_F(AudioHdiRenderControlTest, AudioCreateRender_007, TestSize.Level1)
637 {
638 int32_t ret = -1;
639 struct AudioPort* renderPort = nullptr;
640 struct AudioAdapter *adapter = nullptr;
641 struct AudioRender *render = nullptr;
642 struct AudioSampleAttributes *attrsNull = nullptr;
643 struct AudioDeviceDescriptor devDesc = {};
644 ASSERT_NE(nullptr, manager);
645 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
646 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
647
648 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
649
650 ret = adapter->CreateRender(adapter, &devDesc, attrsNull, &render);
651 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
652
653 manager->UnloadAdapter(manager, adapter);
654 }
655
656 /**
657 * @tc.name AudioCreateRender_008
658 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter render is nullptr.
659 * @tc.type: FUNC
660 */
661 HWTEST_F(AudioHdiRenderControlTest, AudioCreateRender_008, TestSize.Level1)
662 {
663 int32_t ret = -1;
664 struct AudioAdapter *adapter = nullptr;
665 struct AudioRender **renderNull = nullptr;
666 struct AudioPort* renderPort = nullptr;
667 struct AudioSampleAttributes attrs = {};
668 struct AudioDeviceDescriptor devDesc = {};
669 ASSERT_NE(nullptr, manager);
670 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
671 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
672
673 InitAttrs(attrs);
674 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
675
676 ret = adapter->CreateRender(adapter, &devDesc, &attrs, renderNull);
677 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
678
679 manager->UnloadAdapter(manager, adapter);
680 }
681
682 /**
683 * @tc.name AudioCreateRender_009
684 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming parameter devDesc is error.
685 * @tc.type: FUNC
686 */
687 HWTEST_F(AudioHdiRenderControlTest, AudioCreateRender_009, TestSize.Level1)
688 {
689 int32_t ret = -1;
690 struct AudioAdapter *adapter = nullptr;
691 struct AudioRender *render = nullptr;
692 struct AudioSampleAttributes attrs = {};
693 struct AudioDeviceDescriptor devDesc = {};
694 struct AudioPort* renderPort = nullptr;
695 ASSERT_NE(nullptr, manager);
696 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
697 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
698
699 InitAttrs(attrs);
700 InitDevDesc(devDesc, renderPort->portId, PIN_OUT_SPEAKER);
701
702 devDesc.portId = -5;
703 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
704 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
705 devDesc.pins = PIN_NONE;
706 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
707 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
708 devDesc.desc = "devtestname";
709 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
710 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
711
712 manager->UnloadAdapter(manager, adapter);
713 }
714 /**
715 * @tc.name AudioCreateRender_010
716 * @tc.desc test AudioCreateRender interface,Returns -1 if the incoming desc which portID is not configured
717 * @tc.type: FUNC
718 */
719 HWTEST_F(AudioHdiRenderControlTest, AudioCreateRender_010, TestSize.Level1)
720 {
721 int32_t ret = -1;
722 struct AudioAdapter *adapter = nullptr;
723 struct AudioRender *render = nullptr;
724 struct AudioSampleAttributes attrs = {};
725 struct AudioDeviceDescriptor devDesc = {};
726 struct AudioPort* renderPort = nullptr;
727 uint32_t portID = 10;
728 ASSERT_NE(nullptr, manager);
729 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, renderPort);
730 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
731
732 InitAttrs(attrs);
733 InitDevDesc(devDesc, portID, PIN_OUT_SPEAKER);
734
735 ret = adapter->CreateRender(adapter, &devDesc, &attrs, &render);
736 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
737 ret = adapter->DestroyRender(adapter, render);
738 manager->UnloadAdapter(manager, adapter);
739 }
740 /**
741 * @tc.name AudioDestroyRender_001
742 * @tc.desc Test AudioDestroyRender interface, return 0 if render is destroyed successful.
743 * @tc.type: FUNC
744 */
745 HWTEST_F(AudioHdiRenderControlTest, AudioDestroyRender_001, TestSize.Level1)
746 {
747 int32_t ret = -1;
748 struct AudioAdapter *adapter = nullptr;
749 struct AudioRender *render = nullptr;
750 ASSERT_NE(nullptr, manager);
751 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
752 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
753
754 ret = adapter->DestroyRender(adapter, render);
755 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
756 manager->UnloadAdapter(manager, adapter);
757 }
758 /**
759 * @tc.name AudioDestroyRender_002
760 * @tc.desc Test AudioDestroyRender interface, return -1 if the parameter render is empty.
761 * @tc.type: FUNC
762 */
763 HWTEST_F(AudioHdiRenderControlTest, AudioDestroyRender_002, TestSize.Level1)
764 {
765 int32_t ret = -1;
766 struct AudioAdapter *adapter = nullptr;
767 struct AudioRender *render = nullptr;
768 struct AudioRender *renderNull = nullptr;
769 ASSERT_NE(nullptr, manager);
770 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
771 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
772
773 ret = adapter->DestroyRender(adapter, renderNull);
774 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
775 ret = adapter->DestroyRender(adapter, render);
776 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
777 manager->UnloadAdapter(manager, adapter);
778 }
779
780 /**
781 * @tc.name AudioRenderFlush_001
782 * @tc.desc Test RenderFlush interface,return -2 if the data in the buffer is flushed successfully after stop
783 * @tc.type: FUNC
784 */
785 HWTEST_F(AudioHdiRenderControlTest, AudioRenderFlush_001, TestSize.Level1)
786 {
787 int32_t ret = -1;
788 struct AudioAdapter *adapter = nullptr;
789 struct AudioRender *render = nullptr;
790
791 ASSERT_NE(nullptr, manager);
792 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
793 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
794 ret = render->control.Stop((AudioHandle)render);
795 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
796 ret = render->control.Flush((AudioHandle)render);
797 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
798
799 adapter->DestroyRender(adapter, render);
800 manager->UnloadAdapter(manager, adapter);
801 }
802 /**
803 * @tc.name AudioRenderFlush_002
804 * @tc.desc Test RenderFlush, return -1 if the data in the buffer is flushed when handle is nullptr after paused
805 * @tc.type: FUNC
806 */
807 HWTEST_F(AudioHdiRenderControlTest, AudioRenderFlush_002, TestSize.Level1)
808 {
809 int32_t ret = -1;
810 struct AudioAdapter *adapter = nullptr;
811 struct AudioRender *render = nullptr;
812 struct AudioRender *renderNull = nullptr;
813
814 ASSERT_NE(nullptr, manager);
815 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
816 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
817 ret = render->control.Pause((AudioHandle)render);
818 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
819 ret = render->control.Flush((AudioHandle)renderNull);
820 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
821
822 ret = render->control.Stop((AudioHandle)render);
823 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
824 adapter->DestroyRender(adapter, render);
825 manager->UnloadAdapter(manager, adapter);
826 }
827 }
828