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_test.h"
38
39 using namespace std;
40 using namespace testing::ext;
41 using namespace OHOS::Audio;
42
43 namespace {
44 class AudioHdiRenderTest : public testing::Test {
45 public:
46 static void SetUpTestCase(void);
47 static void TearDownTestCase(void);
48 void SetUp();
49 void TearDown();
50 static int32_t GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara);
51 };
52
53 using THREAD_FUNC = void *(*)(void *);
54
SetUpTestCase(void)55 void AudioHdiRenderTest::SetUpTestCase(void) {}
56
TearDownTestCase(void)57 void AudioHdiRenderTest::TearDownTestCase(void) {}
58
SetUp(void)59 void AudioHdiRenderTest::SetUp(void) {}
60
TearDown(void)61 void AudioHdiRenderTest::TearDown(void) {}
62
GetLoadAdapterAudioPara(struct PrepareAudioPara & audiopara)63 int32_t AudioHdiRenderTest::GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara)
64 {
65 int32_t ret = -1;
66 int size = 0;
67
68 audiopara.manager = GetAudioManagerFuncs();
69
70 if (audiopara.manager == nullptr) {
71 return HDF_FAILURE;
72 }
73 ret = audiopara.manager->GetAllAdapters(audiopara.manager, &audiopara.descs, &size);
74 if (ret < 0) {
75 return ret;
76 }
77 if (audiopara.descs == nullptr || size == 0) {
78 return AUDIO_HAL_ERR_INTERNAL;
79 }
80 int index = SwitchAdapter(audiopara.descs, audiopara.adapterName,
81 audiopara.portType, audiopara.audioPort, size);
82 if (index < 0) {
83 return AUDIO_HAL_ERR_INTERNAL;
84 } else {
85 audiopara.desc = &audiopara.descs[index];
86 }
87 if (audiopara.desc == nullptr) {
88 return AUDIO_HAL_ERR_INVALID_PARAM;
89 } else {
90 ret = audiopara.manager->LoadAdapter(audiopara.manager, audiopara.desc, &audiopara.adapter);
91 }
92 if (ret < 0) {
93 return ret;
94 }
95 if (audiopara.adapter == nullptr) {
96 return AUDIO_HAL_ERR_INVALID_PARAM;
97 }
98 return HDF_SUCCESS;
99 }
100
101 /**
102 * @tc.name Test RenderGetLatency API via legal
103 * @tc.number SUB_Audio_HDI_RenderGetLatency_0001
104 * @tc.desc test RenderGetLatency interface, return 0 if GetLatency successful
105 */
106 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetLatency_0001, Function | MediumTest | Level1)
107 {
108 int32_t ret = -1;
109 uint32_t latencyTime = 0;
110 uint32_t expectLatency = 0;
111 struct AudioAdapter *adapter = nullptr;
112 struct AudioRender *render = nullptr;
113
114 TestAudioManager* manager = GetAudioManagerFuncs();
115 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
116 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
117
118 ret = render->GetLatency(render, &latencyTime);
119 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
120 EXPECT_LT(expectLatency, latencyTime);
121
122 ret = render->control.Stop((AudioHandle)render);
123 adapter->DestroyRender(adapter, render);
124 manager->UnloadAdapter(manager, adapter);
125 }
126 /**
127 * @tc.name Test RenderGetLatency API via Setting parameters render is empty
128 * @tc.number SUB_Audio_HDI_AudioRenderGetLatency_0002
129 * @tc.desc test RenderGetLatency interface, return -1 if Setting parameters render is empty
130 */
131 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetLatency_0002, Function | MediumTest | Level1)
132 {
133 int32_t ret = -1;
134 uint32_t latencyTime = 0;
135 struct AudioAdapter *adapter = nullptr;
136 struct AudioRender *render = nullptr;
137 struct AudioRender *renderNull = nullptr;
138
139 TestAudioManager* manager = GetAudioManagerFuncs();
140 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
141 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
142
143 ret = render->GetLatency(renderNull, &latencyTime);
144 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
145
146 ret = render->control.Stop((AudioHandle)render);
147 adapter->DestroyRender(adapter, render);
148 manager->UnloadAdapter(manager, adapter);
149 }
150 /**
151 * @tc.name Test RenderGetLatency API via Setting parameters ms is empty
152 * @tc.number SUB_Audio_HDI_AudioRenderGetLatency_0003
153 * @tc.desc test RenderGetLatency interface,return -1 if Setting parameters ms is empty
154 */
155 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetLatency_0003, Function | MediumTest | Level1)
156 {
157 int32_t ret = -1;
158 uint32_t *latencyTime = nullptr;
159 struct AudioRender *render = nullptr;
160 struct AudioAdapter *adapter = nullptr;
161
162 TestAudioManager* manager = GetAudioManagerFuncs();
163 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
164 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
165
166 ret = render->GetLatency(render, latencyTime);
167 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
168
169 ret = render->control.Stop((AudioHandle)render);
170 adapter->DestroyRender(adapter, render);
171 manager->UnloadAdapter(manager, adapter);
172 }
173 /**
174 * @tc.name Test SetRenderSpeed API via legal
175 * @tc.number SUB_Audio_HDI_AudioRenderSetRenderSpeed_0001
176 * @tc.desc Test SetRenderSpeed interface,return -2 if setting RenderSpeed
177 */
178 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetRenderSpeed_0001, Function | MediumTest | Level1)
179 {
180 int32_t ret = -1;
181 float speed = 100;
182 TestAudioManager* manager = {};
183 struct AudioAdapter *adapter = nullptr;
184 struct AudioRender *render = nullptr;
185
186 manager = GetAudioManagerFuncs();
187 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
188 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
189
190 ret = render->SetRenderSpeed(render, speed);
191 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
192
193 render->control.Stop((AudioHandle)render);
194 adapter->DestroyRender(adapter, render);
195 manager->UnloadAdapter(manager, adapter);
196 }
197 /**
198 * @tc.name Test SetRenderSpeed API via setting the incoming parameter handle is nullptr
199 * @tc.number SUB_Audio_HDI_AudioRenderSetRenderSpeed_0002
200 * @tc.desc Test SetRenderSpeed interface,return -2 if the incoming parameter handle is nullptr
201 */
202 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetRenderSpeed_0002, Function | MediumTest | Level1)
203 {
204 int32_t ret = -1;
205 float speed = 0;
206 TestAudioManager* manager = {};
207 struct AudioAdapter *adapter = nullptr;
208 struct AudioRender *render = nullptr;
209 struct AudioRender *renderNull = nullptr;
210
211 manager = GetAudioManagerFuncs();
212 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
213 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
214
215 ret = render->SetRenderSpeed(renderNull, speed);
216 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
217
218 render->control.Stop((AudioHandle)render);
219 adapter->DestroyRender(adapter, render);
220 manager->UnloadAdapter(manager, adapter);
221 }
222 /**
223 * @tc.name Test GetRenderSpeed API via legal
224 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderSpeed_0001
225 * @tc.desc Test GetRenderSpeed interface,return -2 if getting RenderSpeed
226 */
227 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderSpeed_0001, Function | MediumTest | Level1)
228 {
229 int32_t ret = -1;
230 float speed = 0;
231 TestAudioManager* manager = {};
232 struct AudioAdapter *adapter = nullptr;
233 struct AudioRender *render = nullptr;
234
235 manager = GetAudioManagerFuncs();
236 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
237 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
238 ret = render->GetRenderSpeed(render, &speed);
239 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
240
241 render->control.Stop((AudioHandle)render);
242 adapter->DestroyRender(adapter, render);
243 manager->UnloadAdapter(manager, adapter);
244 }
245 /**
246 * @tc.name Test GetRenderSpeed API via setting the incoming parameter handle is nullptr
247 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderSpeed_0002
248 * @tc.desc Test GetRenderSpeed interface,return -2 if the incoming parameter handle is nullptr
249 */
250 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderSpeed_0002, Function | MediumTest | Level1)
251 {
252 int32_t ret = -1;
253 TestAudioManager* manager = {};
254 struct AudioAdapter *adapter = nullptr;
255 struct AudioRender *render = nullptr;
256 struct AudioRender *renderNull = nullptr;
257 float speed = 0;
258
259 manager = GetAudioManagerFuncs();
260 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
261 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
262
263 ret = render->GetRenderSpeed(renderNull, &speed);
264 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
265
266 render->control.Stop((AudioHandle)render);
267 adapter->DestroyRender(adapter, render);
268 manager->UnloadAdapter(manager, adapter);
269 }
270 /**
271 * @tc.name Test GetRenderSpeed API via setting the incoming parameter speed is nullptr
272 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderSpeed_0002
273 * @tc.desc Test GetRenderSpeed interface,return -2 if the incoming parameter speed is nullptr
274 */
275 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderSpeed_0003, Function | MediumTest | Level1)
276 {
277 int32_t ret = -1;
278 TestAudioManager* manager = {};
279 struct AudioAdapter *adapter = nullptr;
280 struct AudioRender *render = nullptr;
281 float *speedNull = nullptr;
282
283 manager = GetAudioManagerFuncs();
284 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
285 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
286
287 ret = render->GetRenderSpeed(render, speedNull);
288 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
289
290 render->control.Stop((AudioHandle)render);
291 adapter->DestroyRender(adapter, render);
292 manager->UnloadAdapter(manager, adapter);
293 }
294 /**
295 * @tc.name Test AudioRenderFrame API via legal input
296 * @tc.number SUB_Audio_HDI_AudioRenderFrame_0001
297 * @tc.desc test AudioRenderFrame interface,Returns 0 if the data is written successfully
298 */
299 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0001, Function | MediumTest | Level1)
300 {
301 int32_t ret = -1;
302 uint64_t requestBytes = 0;
303 uint64_t replyBytes = 0;
304 struct AudioAdapter *adapter = nullptr;
305 struct AudioRender *render = nullptr;
306 char *frame = nullptr;
307
308 TestAudioManager* manager = GetAudioManagerFuncs();
309 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
310 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
311 ret = render->control.Start((AudioHandle)render);
312 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
313
314 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
315 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
316 ret = render->RenderFrame(render, frame, requestBytes, &replyBytes);
317 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
318
319 render->control.Stop((AudioHandle)render);
320 adapter->DestroyRender(adapter, render);
321 manager->UnloadAdapter(manager, adapter);
322 if (frame != nullptr) {
323 free(frame);
324 frame = nullptr;
325 }
326 }
327 /**
328 * @tc.name Test AudioRenderFrame API via setting the incoming parameter render is nullptr
329 * @tc.number SUB_Audio_HDI_AudioRenderFrame_0002
330 * @tc.desc Test AudioRenderFrame interface,Returns -1 if the incoming parameter render is nullptr
331 */
332 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0002, Function | MediumTest | Level1)
333 {
334 int32_t ret = -1;
335 uint64_t requestBytes = 0;
336 uint64_t replyBytes = 0;
337 struct AudioAdapter *adapter = nullptr;
338 struct AudioRender *render = nullptr;
339 struct AudioRender *renderNull = nullptr;
340 char *frame = nullptr;
341
342
343 TestAudioManager* manager = GetAudioManagerFuncs();
344 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
345 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
346 ret = render->control.Start((AudioHandle)render);
347 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
348
349 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
350 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
351 ret = render->RenderFrame(renderNull, frame, requestBytes, &replyBytes);
352 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
353
354 ret = render->control.Stop((AudioHandle)render);
355 adapter->DestroyRender(adapter, render);
356 manager->UnloadAdapter(manager, adapter);
357 if (frame != nullptr) {
358 free(frame);
359 frame = nullptr;
360 }
361 }
362 /**
363 * @tc.name Test AudioRenderFrame API via setting the incoming parameter frame is nullptr
364 * @tc.number SUB_Audio_HDI_AudioRenderFrame_0003
365 * @tc.desc Test AudioRenderFrame interface,Returns -1 if the incoming parameter frame is nullptr
366 */
367 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0003, Function | MediumTest | Level1)
368 {
369 int32_t ret = -1;
370 uint64_t requestBytes = 0;
371 uint64_t replyBytes = 0;
372 struct AudioAdapter *adapter = nullptr;
373 struct AudioRender *render = nullptr;
374 char *frame = nullptr;
375
376
377 TestAudioManager* manager = GetAudioManagerFuncs();
378 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
379 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
380 ret = render->control.Start((AudioHandle)render);
381 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
382
383 ret = render->RenderFrame(render, frame, requestBytes, &replyBytes);
384 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
385 ret = render->control.Stop((AudioHandle)render);
386 adapter->DestroyRender(adapter, render);
387 manager->UnloadAdapter(manager, adapter);
388 }
389 /**
390 * @tc.name Test AudioRenderFrame API via setting the incoming parameter replyBytes is nullptr
391 * @tc.number SUB_Audio_HDI_AudioRenderFrame_0004
392 * @tc.desc Test AudioRenderFrame interface,Returns -1 if the incoming parameter replyBytes is nullptr
393 */
394 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0004, Function | MediumTest | Level1)
395 {
396 int32_t ret = -1;
397 uint64_t requestBytes = 0;
398 struct AudioAdapter *adapter = nullptr;
399 struct AudioRender *render = nullptr;
400 char *frame = nullptr;
401 uint64_t *replyBytes = nullptr;
402
403
404 TestAudioManager* manager = GetAudioManagerFuncs();
405 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
406 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
407 ret = render->control.Start((AudioHandle)render);
408 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
409
410 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
411 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
412 ret = render->RenderFrame(render, frame, requestBytes, replyBytes);
413 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
414
415 ret = render->control.Stop((AudioHandle)render);
416 adapter->DestroyRender(adapter, render);
417 manager->UnloadAdapter(manager, adapter);
418 if (frame != nullptr) {
419 free(frame);
420 frame = nullptr;
421 }
422 }
423 /**
424 * @tc.name Test AudioRenderFrame API without calling interface renderstart
425 * @tc.number SUB_Audio_HDI_AudioRenderFrame_0005
426 * @tc.desc Test AudioRenderFrame interface,Returns -1 if without calling interface renderstart
427 */
428 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0005, Function | MediumTest | Level1)
429 {
430 int32_t ret = -1;
431 uint64_t replyBytes = 0;
432 uint64_t requestBytes = 0;
433 struct AudioAdapter *adapter = nullptr;
434 struct AudioRender *render = nullptr;
435 char *frame = nullptr;
436
437
438 TestAudioManager* manager = GetAudioManagerFuncs();
439 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
440 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
441 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
442 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
443 ret = render->RenderFrame(render, frame, requestBytes, &replyBytes);
444 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
445
446 adapter->DestroyRender(adapter, render);
447 manager->UnloadAdapter(manager, adapter);
448 if (frame != nullptr) {
449 free(frame);
450 frame = nullptr;
451 }
452 }
453 /**
454 * @tc.name Test SetChannelMode API via setting channel mode after render object is created
455 * @tc.number SUB_Audio_HDI_AudioRenderSetChannelMode_0003
456 * @tc.desc Test SetChannelMode interface,return 0 if set channel mode after render object is created
457 */
458 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0003, Function | MediumTest | Level1)
459 {
460 int32_t ret = -1;
461 TestAudioManager* manager = {};
462 struct AudioAdapter *adapter = nullptr;
463 struct AudioRender *render = nullptr;
464 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
465
466 manager = GetAudioManagerFuncs();
467 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
468 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
469 ret = render->SetChannelMode(render, mode);
470 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
471 ret = render->GetChannelMode(render, &mode);
472 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
473 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
474
475 adapter->DestroyRender(adapter, render);
476 manager->UnloadAdapter(manager, adapter);
477 }
478 /**
479 * @tc.name Test SetChannelMode API via setting the parameter render is nullptr
480 * @tc.number SUB_Audio_HDI_AudioRenderSetChannelMode_0004
481 * @tc.desc Test SetChannelMode interface,return -1 if set the parameter render is nullptr
482 */
483 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0004, Function | MediumTest | Level1)
484 {
485 int32_t ret = -1;
486 TestAudioManager* manager = {};
487 struct AudioRender *render = nullptr;
488 struct AudioAdapter *adapter = nullptr;
489 struct AudioRender *renderNull = nullptr;
490 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
491
492 manager = GetAudioManagerFuncs();
493 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
494 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
495
496 ret = render->SetChannelMode(renderNull, mode);
497 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
498
499 adapter->DestroyRender(adapter, render);
500 manager->UnloadAdapter(manager, adapter);
501 }
502 /**
503 * @tc.name Test GetChannelMode API via getting the channel mode after setting
504 * @tc.number SUB_Audio_HDI_AudioRenderGetChannelMode_0001
505 * @tc.desc Test GetChannelMode interface,return 0 if getting the channel mode after setting
506 */
507 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetChannelMode_0001, Function | MediumTest | Level1)
508 {
509 int32_t ret = -1;
510 TestAudioManager* manager = {};
511 struct AudioAdapter *adapter = nullptr;
512 struct AudioRender *render = nullptr;
513 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
514
515 manager = GetAudioManagerFuncs();
516 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
517 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
518
519 ret = render->GetChannelMode(render, &mode);
520 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
521 ret = render->SetChannelMode(render, mode);
522 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
523 ret = render->GetChannelMode(render, &mode);
524 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
525 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
526
527 render->control.Stop((AudioHandle)render);
528 adapter->DestroyRender(adapter, render);
529 manager->UnloadAdapter(manager, adapter);
530 }
531 /**
532 * @tc.name Test GetChannelMode API via getting the parameter render is nullptr
533 * @tc.number SUB_Audio_HDI_AudioRenderGetChannelMode_0002
534 * @tc.desc Test GetChannelMode interface,return -1 if getting the parameter render is nullptr
535 */
536 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetChannelMode_0002, Function | MediumTest | Level1)
537 {
538 int32_t ret = -1;
539 TestAudioManager* manager = {};
540 struct AudioAdapter *adapter = nullptr;
541 struct AudioRender *renderNull = nullptr;
542 struct AudioRender *render = nullptr;
543 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
544
545
546 manager = GetAudioManagerFuncs();
547 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
548 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
549
550 ret = render->GetChannelMode(renderNull, &mode);
551 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
552
553 render->control.Stop((AudioHandle)render);
554 adapter->DestroyRender(adapter, render);
555 manager->UnloadAdapter(manager, adapter);
556 }
557 /**
558 * @tc.name Test GetChannelMode API via getting the channel mode after the render object is created
559 * @tc.number SUB_Audio_HDI_AudioRenderGetChannelMode_0003
560 * @tc.desc Test GetChannelMode interface,return 0 if getting the channel mode after the object is created
561 */
562 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetChannelMode_0003, Function | MediumTest | Level1)
563 {
564 int32_t ret = -1;
565 struct AudioAdapter *adapter = nullptr;
566 struct AudioRender *render = nullptr;
567 TestAudioManager* manager = {};
568 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
569
570 manager = GetAudioManagerFuncs();
571 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
572 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
573 ret = render->GetChannelMode(render, &mode);
574 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
575 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
576
577 adapter->DestroyRender(adapter, render);
578 manager->UnloadAdapter(manager, adapter);
579 }
580 /**
581 * @tc.name Test GetRenderPosition API via legal input
582 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0001
583 * @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition during playing.
584 */
585 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0001, Function | MediumTest | Level1)
586 {
587 int32_t ret = -1;
588 uint64_t frames = 0;
589 int64_t timeExp = 0;
590 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
591 struct PrepareAudioPara audiopara = {
592 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
593 .path = AUDIO_FILE.c_str()
594 };
595
596 audiopara.manager = GetAudioManagerFuncs();
597 ASSERT_NE(audiopara.manager, nullptr);
598
599 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
600 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
601 sleep(1);
602 if (audiopara.render != nullptr) {
603 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
604 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
605 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
606 EXPECT_GT(frames, INITIAL_VALUE);
607 }
608
609 ret = ThreadRelease(audiopara);
610 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
611 }
612 /**
613 * @tc.name Test AudioRenderGetRenderPosition API via get RenderPosition after the audio file is Paused and resumed
614 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0002
615 * @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition after Pause and resume during playing
616 */
617 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0002, Function | MediumTest | Level1)
618 {
619 int32_t ret = -1;
620 int64_t timeExp = 0;
621 uint64_t frames = 0;
622 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
623 struct PrepareAudioPara audiopara = {
624 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
625 .path = AUDIO_FILE.c_str()
626 };
627
628 audiopara.manager = GetAudioManagerFuncs();
629 ASSERT_NE(audiopara.manager, nullptr);
630
631 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
632 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
633 sleep(1);
634 if (audiopara.render != nullptr) {
635 FrameStatus(0);
636 usleep(1000);
637 ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render));
638 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
639 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
640 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
641 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
642 EXPECT_GT(frames, INITIAL_VALUE);
643 usleep(1000);
644 ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render));
645 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
646 FrameStatus(1);
647 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
648 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
649 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
650 EXPECT_GT(frames, INITIAL_VALUE);
651 }
652
653 ret = ThreadRelease(audiopara);
654 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
655 }
656 /**
657 * @tc.name Test GetRenderPosition API via get RenderPosition after the audio file is stopped
658 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0003
659 * @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition after stop
660 */
661 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0003, Function | MediumTest | Level1)
662 {
663 int32_t ret = -1;
664 int64_t timeExp = 0;
665 uint64_t frames = 0;
666 struct AudioAdapter *adapter = nullptr;
667 struct AudioRender *render = nullptr;
668 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
669
670 TestAudioManager* manager = GetAudioManagerFuncs();
671 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
672 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
673 ret = render->control.Stop((AudioHandle)render);
674 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
675
676 ret = render->GetRenderPosition(render, &frames, &time);
677 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
678 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
679 EXPECT_GT(frames, INITIAL_VALUE);
680
681 adapter->DestroyRender(adapter, render);
682 manager->UnloadAdapter(manager, adapter);
683 }
684 /**
685 * @tc.name Test AudioRenderGetRenderPosition API via setting the parameter render is nullptr
686 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0004
687 * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter render is nullptr
688 */
689 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0004, Function | MediumTest | Level1)
690 {
691 int32_t ret = -1;
692 uint64_t frames = 0;
693 int64_t timeExp = 0;
694 struct AudioRender *render = nullptr;
695 struct AudioAdapter *adapter = nullptr;
696 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
697
698
699 TestAudioManager* manager = GetAudioManagerFuncs();
700 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
701 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
702 ret = render->GetRenderPosition(render, &frames, &time);
703 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
704 EXPECT_EQ((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
705
706 adapter->DestroyRender(adapter, render);
707 manager->UnloadAdapter(manager, adapter);
708 }
709 /**
710 * @tc.name Test AudioRenderGetRenderPosition API via setting the parameter render is nullptr
711 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0005
712 * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter render is nullptr
713 */
714 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0005, Function | MediumTest | Level1)
715 {
716 int32_t ret = -1;
717 uint64_t frames = 0;
718 struct AudioTimeStamp time = {};
719 struct AudioAdapter *adapter = nullptr;
720 struct AudioRender *render = nullptr;
721 struct AudioRender *renderNull = nullptr;
722
723
724 TestAudioManager* manager = GetAudioManagerFuncs();
725 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
726 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
727 ret = render->GetRenderPosition(renderNull, &frames, &time);
728 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
729
730 render->control.Stop((AudioHandle)render);
731 adapter->DestroyRender(adapter, render);
732 manager->UnloadAdapter(manager, adapter);
733 }
734 /**
735 * @tc.name Test AudioRenderGetRenderPosition API via setting the parameter frames is nullptr
736 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0006
737 * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter frames is nullptr
738 */
739 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0006, Function | MediumTest | Level1)
740 {
741 int32_t ret = -1;
742 uint64_t *framesNull = nullptr;
743 TestAudioManager* manager = {};
744 struct AudioAdapter *adapter = nullptr;
745 struct AudioRender *render = nullptr;
746 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
747
748
749 manager = GetAudioManagerFuncs();
750 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
751 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
752 ret = render->GetRenderPosition(render, framesNull, &time);
753 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
754
755 render->control.Stop((AudioHandle)render);
756 adapter->DestroyRender(adapter, render);
757 manager->UnloadAdapter(manager, adapter);
758 }
759 /**
760 * @tc.name Test AudioRenderGetRenderPosition API via setting the parameter time is nullptr
761 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0007
762 * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter time is nullptr
763 */
764 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0007, Function | MediumTest | Level1)
765 {
766 int32_t ret = -1;
767 uint64_t frames = 0;
768 TestAudioManager* manager = {};
769 struct AudioAdapter *adapter = nullptr;
770 struct AudioRender *render = nullptr;
771 struct AudioTimeStamp *timeNull = nullptr;
772
773
774 manager = GetAudioManagerFuncs();
775 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
776 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
777
778 ret = render->GetRenderPosition(render, &frames, timeNull);
779 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
780
781 render->control.Stop((AudioHandle)render);
782 adapter->DestroyRender(adapter, render);
783 manager->UnloadAdapter(manager, adapter);
784 }
785 /**
786 * @tc.name Test AudioRenderGetRenderPosition API via get RenderPosition continuously
787 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0008
788 * @tc.desc Test AudioRenderGetRenderPosition interface, return 0 if the GetRenderPosition was called twice
789 */
790 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0008, Function | MediumTest | Level1)
791 {
792 int32_t ret = -1;
793 int64_t timeExp = 0;
794 uint64_t frames = 0;
795 TestAudioManager* manager = {};
796 struct AudioAdapter *adapter = nullptr;
797 struct AudioRender *render = nullptr;
798 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
799
800 manager = GetAudioManagerFuncs();
801 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
802 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
803
804 ret = render->GetRenderPosition(render, &frames, &time);
805 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
806 ret = render->GetRenderPosition(render, &frames, &time);
807 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
808 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
809 EXPECT_GT(frames, INITIAL_VALUE);
810
811 render->control.Stop((AudioHandle)render);
812 adapter->DestroyRender(adapter, render);
813 manager->UnloadAdapter(manager, adapter);
814 }
815 /**
816 * @tc.name Test GetRenderPosition API via define format to AUDIO_FORMAT_PCM_16_BIT
817 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0009
818 * @tc.desc Test GetRenderPosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_16_BIT
819 */
820 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0009, Function | MediumTest | Level1)
821 {
822 int32_t ret = -1;
823 struct AudioAdapter *adapter = nullptr;
824 struct AudioRender *render = nullptr;
825 struct AudioSampleAttributes attrs = {};
826 struct AudioSampleAttributes attrsValue = {};
827 uint64_t channelCountExp = 2;
828 uint32_t sampleRateExp = 48000;
829 uint64_t frames = 0;
830 int64_t timeExp = 0;
831 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
832 TestAudioManager* manager = GetAudioManagerFuncs();
833
834 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
835 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
836 InitAttrs(attrs);
837 attrs.type = AUDIO_IN_MEDIA;
838 attrs.interleaved = false;
839 attrs.format = AUDIO_FORMAT_PCM_16_BIT;
840 attrs.sampleRate = 48000;
841 attrs.channelCount = 2;
842 ret = render->attr.SetSampleAttributes(render, &attrs);
843 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
844 ret = render->attr.GetSampleAttributes(render, &attrsValue);
845 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
846 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
847 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
848 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
849 ret = AudioRenderStartAndOneFrame(render);
850 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
851 ret = render->GetRenderPosition(render, &frames, &time);
852 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
853 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
854 EXPECT_GT(frames, INITIAL_VALUE);
855 render->control.Stop((AudioHandle)render);
856 adapter->DestroyRender(adapter, render);
857 manager->UnloadAdapter(manager, adapter);
858 }
859 /**
860 * @tc.name Test GetRenderPosition API via define format to AUDIO_FORMAT_PCM_24_BIT
861 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0010
862 * @tc.desc Test GetRenderPosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_24_BIT
863 */
864 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0010, Function | MediumTest | Level1)
865 {
866 int32_t ret = -1;
867 uint64_t frames = 0;
868 int64_t timeExp = 0;
869 uint64_t channelCountExp = 2;
870 uint32_t sampleRateExp = 48000;
871 struct AudioAdapter *adapter = nullptr;
872 struct AudioRender *render = nullptr;
873 struct AudioSampleAttributes attrs = {};
874 struct AudioSampleAttributes attrsValue = {};
875 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
876
877 TestAudioManager* manager = GetAudioManagerFuncs();
878 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
879 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
880 InitAttrs(attrs);
881 attrs.type = AUDIO_IN_MEDIA;
882 attrs.interleaved = false;
883 attrs.format = AUDIO_FORMAT_PCM_24_BIT;
884 attrs.sampleRate = 48000;
885 attrs.channelCount = 2;
886 ret = render->attr.SetSampleAttributes(render, &attrs);
887 if(ret != AUDIO_HAL_SUCCESS){
888 EXPECT_TRUE(true);
889 }
890 if(ret == AUDIO_HAL_SUCCESS)
891 {
892 ret = render->attr.GetSampleAttributes(render, &attrsValue);
893 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
894 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
895 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
896 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
897 ret = AudioRenderStartAndOneFrame(render);
898 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
899 ret = render->GetRenderPosition(render, &frames, &time);
900 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
901 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
902 EXPECT_GT(frames, INITIAL_VALUE);
903 render->control.Stop((AudioHandle)render);
904 }
905 adapter->DestroyRender(adapter, render);
906 manager->UnloadAdapter(manager, adapter);
907 }
908 /**
909 * @tc.name Test ReqMmapBuffer API via legal input
910 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0001
911 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface sucessfully
912 */
913 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderReqMmapBuffer_0001, Function | MediumTest | Level1)
914 {
915 int32_t ret = -1;
916 bool isRender = true;
917 int32_t reqSize = 0;
918 struct AudioMmapBufferDescripter desc = {};
919 struct AudioRender *render = nullptr;
920 struct AudioAdapter *adapter = nullptr;
921 struct AudioSampleAttributes attrs = {};
922
923 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
924 ASSERT_NE(fp, nullptr);
925 TestAudioManager* manager = GetAudioManagerFuncs();
926 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
927 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
928 if (ret < 0 || render == nullptr) {
929 fclose(fp);
930 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
931 ASSERT_EQ(nullptr, render);
932 }
933 InitAttrs(attrs);
934 attrs.startThreshold = 0;
935 ret = render->attr.SetSampleAttributes(render, &attrs);
936 if(ret != AUDIO_HAL_SUCCESS){
937 EXPECT_TRUE(true);
938 }
939 if(ret == AUDIO_HAL_SUCCESS)
940 {
941 ret = InitMmapDesc(fp, desc, reqSize, isRender);
942 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
943 ret = render->control.Start((AudioHandle)render);
944 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
945 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc);
946 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
947 EXPECT_TRUE(true);
948 }else{
949 EXPECT_TRUE(false);
950 }
951 fclose(fp);
952 if (ret == 0) {
953 munmap(desc.memoryAddress, reqSize);
954 }
955 render->control.Stop((AudioHandle)render);
956 }
957 adapter->DestroyRender(adapter, render);
958 manager->UnloadAdapter(manager, adapter);
959 }
960
961 /**
962 * @tc.name Test ReqMmapBuffer API via setting the incoming parameter reqSize is smaller than
963 the size of actual audio file
964 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0003
965 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully when setting the
966 incoming parameter reqSize is smaller than the size of actual audio file
967 */
968 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderReqMmapBuffer_0003, Function | MediumTest | Level1)
969 {
970 int32_t ret = -1;
971 bool isRender = true;
972 int32_t reqSize = 0;
973 struct AudioMmapBufferDescripter desc = {};
974 struct AudioRender *render = nullptr;
975 struct AudioAdapter *adapter = nullptr;
976
977 TestAudioManager *manager = GetAudioManagerFuncs();
978 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
979 ASSERT_NE(fp, nullptr);
980 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
981 if (ret < 0 || render == nullptr) {
982 fclose(fp);
983 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
984 ASSERT_EQ(nullptr, render);
985 }
986 ret = InitMmapDesc(fp, desc, reqSize, isRender);
987 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
988 reqSize = reqSize / 2;
989 ret = render->control.Start((AudioHandle)render);
990 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
991 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc);
992 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
993 EXPECT_TRUE(true);
994 }else{
995 EXPECT_TRUE(false);
996 }
997 fclose(fp);
998 if (ret == 0) {
999 munmap(desc.memoryAddress, reqSize);
1000 }
1001 render->control.Stop((AudioHandle)render);
1002 adapter->DestroyRender(adapter, render);
1003 manager->UnloadAdapter(manager, adapter);
1004 }
1005 /**
1006 * @tc.name Test ReqMmapBuffer API via setting the incoming parameter reqSize is zero
1007 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0003
1008 * @tc.desc Test ReqMmapBuffer interface,return -1 if call ReqMmapBuffer interface unsucessfully when setting the
1009 incoming parameter reqSize is zero
1010 */
1011 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderReqMmapBuffer_0004, Function | MediumTest | Level1)
1012 {
1013 int32_t ret = -1;
1014 bool isRender = true;
1015 int32_t reqSize = 0;
1016 struct AudioMmapBufferDescripter desc = {};
1017 struct AudioRender *render = nullptr;
1018 struct AudioAdapter *adapter = nullptr;
1019
1020 TestAudioManager *manager = GetAudioManagerFuncs();
1021 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
1022 ASSERT_NE(fp, nullptr);
1023 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
1024 if (ret < 0 || render == nullptr) {
1025 fclose(fp);
1026 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1027 ASSERT_EQ(nullptr, render);
1028 }
1029 ret = InitMmapDesc(fp, desc, reqSize, isRender);
1030 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1031 reqSize = 0;
1032 ret = render->control.Start((AudioHandle)render);
1033 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1034 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc);
1035 EXPECT_NE(AUDIO_HAL_SUCCESS, ret);
1036 fclose(fp);
1037 render->control.Stop((AudioHandle)render);
1038 adapter->DestroyRender(adapter, render);
1039 manager->UnloadAdapter(manager, adapter);
1040 }
1041 /**
1042 * @tc.name Test ReqMmapBuffer API via setting the incoming parameter memoryFd of desc is illegal
1043 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0003
1044 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsucessfully when setting the
1045 incoming parameter memoryFd of desc is illegal
1046 */
1047 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderReqMmapBuffer_0005, Function | MediumTest | Level1)
1048 {
1049 int32_t ret = -1;
1050 bool isRender = true;
1051 int32_t reqSize = 0;
1052 struct AudioMmapBufferDescripter desc = {};
1053 struct AudioRender *render = nullptr;
1054 struct AudioAdapter *adapter = nullptr;
1055
1056 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
1057 ASSERT_NE(fp, nullptr);
1058 TestAudioManager *manager = GetAudioManagerFuncs();
1059 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
1060 if (ret < 0 || render == nullptr) {
1061 fclose(fp);
1062 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1063 ASSERT_EQ(nullptr, render);
1064 }
1065 ret = InitMmapDesc(fp, desc, reqSize, isRender);
1066 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1067 desc.memoryFd = 1;
1068 ret = render->control.Start((AudioHandle)render);
1069 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1070 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc);
1071 EXPECT_NE(AUDIO_HAL_SUCCESS, ret);
1072 fclose(fp);
1073 render->control.Stop((AudioHandle)render);
1074 adapter->DestroyRender(adapter, render);
1075 manager->UnloadAdapter(manager, adapter);
1076 }
1077 /**
1078 * @tc.name Test ReqMmapBuffer API via the incoming parameter handle is nullptr
1079 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0005
1080 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsucessfully when setting the
1081 incoming parameter handle is nullptr
1082 */
1083 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderReqMmapBuffer_0006, Function | MediumTest | Level1)
1084 {
1085 int32_t ret = -1;
1086 bool isRender = true;
1087 int32_t reqSize = 0;
1088 struct AudioMmapBufferDescripter desc = {};
1089 struct AudioRender *render = nullptr;
1090 struct AudioRender *renderNull = nullptr;
1091 struct AudioAdapter *adapter = nullptr;
1092
1093 TestAudioManager* manager = GetAudioManagerFuncs();
1094 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
1095 ASSERT_NE(fp, nullptr);
1096 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
1097 if (ret < 0 || render == nullptr) {
1098 fclose(fp);
1099 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1100 ASSERT_EQ(nullptr, render);
1101 }
1102 ret = InitMmapDesc(fp, desc, reqSize, isRender);
1103 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1104 ret = render->control.Start((AudioHandle)render);
1105 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1106 ret = render->attr.ReqMmapBuffer((AudioHandle)renderNull, reqSize, &desc);
1107 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1108 fclose(fp);
1109 render->control.Stop((AudioHandle)render);
1110 adapter->DestroyRender(adapter, render);
1111 manager->UnloadAdapter(manager, adapter);
1112 }
1113 /**
1114 * @tc.name Test ReqMmapBuffer API via the incoming parameter desc is nullptr
1115 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0006
1116 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsucessfully when setting the
1117 incoming parameter desc is nullptr
1118 */
1119 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderReqMmapBuffer_0007, Function | MediumTest | Level1)
1120 {
1121 int32_t ret = -1;
1122 bool isRender = true;
1123 int32_t reqSize = 0;
1124 struct AudioMmapBufferDescripter desc = {};
1125 struct AudioMmapBufferDescripter *descNull = nullptr;
1126 struct AudioRender *render = nullptr;
1127 struct AudioAdapter *adapter = nullptr;
1128
1129 TestAudioManager* manager = GetAudioManagerFuncs();
1130 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
1131 ASSERT_NE(fp, nullptr);
1132 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
1133 if (ret < 0 || render == nullptr) {
1134 fclose(fp);
1135 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1136 ASSERT_EQ(nullptr, render);
1137 }
1138 ret = InitMmapDesc(fp, desc, reqSize, isRender);
1139 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1140 ret = render->control.Start((AudioHandle)render);
1141 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1142 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, descNull);
1143 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1144 fclose(fp);
1145 render->control.Stop((AudioHandle)render);
1146 adapter->DestroyRender(adapter, render);
1147 manager->UnloadAdapter(manager, adapter);
1148 }
1149 /**
1150 * @tc.name Test GetMmapPosition API via Getting position is normal in Before playing and Playing.
1151 * @tc.number SUB_Audio_HDI_RenderGetMmapPosition_0001
1152 * @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully.
1153 */
1154 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderGetMmapPosition_0001, Function | MediumTest | Level1)
1155 {
1156 uint64_t frames = 0;
1157 uint64_t framesRendering = 0;
1158 uint64_t framesexpRender = 0;
1159 struct PrepareAudioPara audiopara = {
1160 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
1161 .path = LOW_LATENCY_AUDIO_FILE.c_str()
1162 };
1163
1164 audiopara.manager = GetAudioManagerFuncs();
1165 ASSERT_NE(audiopara.manager, nullptr);
1166 int32_t ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1167 &audiopara.render);
1168 if (ret < 0 || audiopara.render == nullptr) {
1169 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1170 ASSERT_EQ(nullptr, audiopara.render);
1171 }
1172 InitAttrs(audiopara.attrs);
1173 audiopara.attrs.startThreshold = 0;
1174 ret = audiopara.render->attr.SetSampleAttributes(audiopara.render, &(audiopara.attrs));
1175 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1176 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &frames, &(audiopara.time));
1177 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
1178 EXPECT_TRUE(true);
1179 }else{
1180 EXPECT_TRUE(false);
1181 }
1182 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayMapAudioFile, &audiopara);
1183 if (ret != 0) {
1184 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1185 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1186 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1187 }
1188 sleep(1);
1189 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &framesRendering, &(audiopara.time));
1190 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
1191 EXPECT_TRUE(true);
1192 }else{
1193 EXPECT_TRUE(false);
1194 }
1195 void *result = nullptr;
1196 pthread_join(audiopara.tids, &result);
1197 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &framesexpRender, &(audiopara.time));
1198 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
1199 EXPECT_TRUE(true);
1200 }else{
1201 EXPECT_TRUE(false);
1202 }
1203 audiopara.render->control.Stop((AudioHandle)audiopara.render);
1204 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1205 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1206 }
1207 /**
1208 * @tc.name Test ReqMmapBuffer API via inputtint frame is nullptr.
1209 * @tc.number SUB_Audio_HDI_RenderGetMmapPosition_0003
1210 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
1211 */
1212 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderGetMmapPosition_0003, Function | MediumTest | Level1)
1213 {
1214 int32_t ret = -1;
1215 uint64_t *frames = nullptr;
1216 struct PrepareAudioPara audiopara = {
1217 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
1218 .path = LOW_LATENCY_AUDIO_FILE.c_str()
1219 };
1220
1221 audiopara.manager = GetAudioManagerFuncs();
1222 ASSERT_NE(audiopara.manager, nullptr);
1223 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1224 &audiopara.render);
1225 if (ret < 0 || audiopara.render == nullptr) {
1226 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1227 ASSERT_EQ(nullptr, audiopara.render);
1228 }
1229
1230 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, frames, &(audiopara.time));
1231 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1232
1233 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1234 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1235 }
1236 /**
1237 * @tc.name Test ReqMmapBuffer API via inputtint time is nullptr.
1238 * @tc.number SUB_Audio_HDI_RenderGetMmapPosition_0004
1239 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
1240 */
1241 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderGetMmapPosition_0004, Function | MediumTest | Level1)
1242 {
1243 int32_t ret = -1;
1244 uint64_t frames = 0;
1245 struct AudioTimeStamp *time = nullptr;
1246 struct PrepareAudioPara audiopara = {
1247 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
1248 .path = LOW_LATENCY_AUDIO_FILE.c_str()
1249 };
1250
1251 audiopara.manager = GetAudioManagerFuncs();
1252 ASSERT_NE(audiopara.manager, nullptr);
1253 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1254 &audiopara.render);
1255 if (ret < 0 || audiopara.render == nullptr) {
1256 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1257 ASSERT_EQ(nullptr, audiopara.render);
1258 }
1259
1260 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &frames, time);
1261 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1262
1263 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1264 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1265 }
1266 /**
1267 * @tc.name Test ReqMmapBuffer API via inputtint render is nullptr.
1268 * @tc.number SUB_Audio_HDI_RenderGetMmapPosition_0005
1269 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
1270 */
1271 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderGetMmapPosition_0005, Function | MediumTest | Level1)
1272 {
1273 int32_t ret = -1;
1274 uint64_t frames = 0;
1275 struct AudioRender *renderNull = nullptr;
1276 struct PrepareAudioPara audiopara = {
1277 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
1278 .path = LOW_LATENCY_AUDIO_FILE.c_str()
1279 };
1280
1281 audiopara.manager = GetAudioManagerFuncs();
1282 ASSERT_NE(audiopara.manager, nullptr);
1283 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1284 &audiopara.render);
1285 if (ret < 0 || audiopara.render == nullptr) {
1286 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1287 ASSERT_EQ(nullptr, audiopara.render);
1288 }
1289
1290 ret = audiopara.render->attr.GetMmapPosition(renderNull, &frames, &(audiopara.time));
1291 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1292
1293 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1294 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1295 }
1296 /**
1297 * @tc.name Test DrainBuffer API via inputtint type is AUDIO_DRAIN_NORMAL_MODE.
1298 * @tc.number SUB_Audio_HDI_RenderDrainBuffer_0001
1299 * @tc.desc Test RenderDrainBuffer interface,return -2 if Error in incoming parameter.
1300 */
1301 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderDrainBuffer_0001, Function | MediumTest | Level1)
1302 {
1303 int32_t ret = -1;
1304 enum AudioDrainNotifyType type = AUDIO_DRAIN_NORMAL_MODE;
1305 struct PrepareAudioPara audiopara = {
1306 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
1307 .path = LOW_LATENCY_AUDIO_FILE.c_str()
1308 };
1309
1310 audiopara.manager = GetAudioManagerFuncs();
1311 ASSERT_NE(audiopara.manager, nullptr);
1312 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1313 &audiopara.render);
1314 if (ret < 0 || audiopara.render == nullptr) {
1315 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1316 ASSERT_EQ(nullptr, audiopara.render);
1317 }
1318
1319 ret = audiopara.render->DrainBuffer(audiopara.render, &type);
1320 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
1321 EXPECT_TRUE(true);
1322 }else{
1323 EXPECT_TRUE(false);
1324 }
1325 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1326 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1327 }
1328 /**
1329 * @tc.name Test DrainBuffer API via inputtint type is AUDIO_DRAIN_EARLY_MODE.
1330 * @tc.number SUB_Audio_HDI_RenderDrainBuffer_0002
1331 * @tc.desc Test RenderDrainBuffer interface,return -2 if Error in incoming parameter.
1332 */
1333 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderDrainBuffer_0002, Function | MediumTest | Level1)
1334 {
1335 int32_t ret = -1;
1336 enum AudioDrainNotifyType type = AUDIO_DRAIN_EARLY_MODE;
1337 struct PrepareAudioPara audiopara = {
1338 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
1339 .path = LOW_LATENCY_AUDIO_FILE.c_str()
1340 };
1341
1342 audiopara.manager = GetAudioManagerFuncs();
1343 ASSERT_NE(audiopara.manager, nullptr);
1344 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1345 &audiopara.render);
1346 if (ret < 0 || audiopara.render == nullptr) {
1347 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1348 ASSERT_EQ(nullptr, audiopara.render);
1349 }
1350
1351 ret = audiopara.render->DrainBuffer(audiopara.render, &type);
1352 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
1353 EXPECT_TRUE(true);
1354 }else{
1355 EXPECT_TRUE(false);
1356 }
1357 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1358 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1359 }
1360 }