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 TestAudioManager *manager;
51 };
52
53 using THREAD_FUNC = void *(*)(void *);
54 TestAudioManager *AudioHdiRenderTest::manager = nullptr;
55
SetUpTestCase(void)56 void AudioHdiRenderTest::SetUpTestCase(void)
57 {
58 manager = GetAudioManagerFuncs();
59 ASSERT_NE(nullptr, manager);
60 }
61
TearDownTestCase(void)62 void AudioHdiRenderTest::TearDownTestCase(void) {}
63
SetUp(void)64 void AudioHdiRenderTest::SetUp(void) {}
65
TearDown(void)66 void AudioHdiRenderTest::TearDown(void) {}
67
68 /**
69 * @tc.name AudioRenderGetLatency_001
70 * @tc.desc test RenderGetLatency interface, return 0 if GetLatency successful
71 * @tc.type: FUNC
72 */
73 HWTEST_F(AudioHdiRenderTest, AudioRenderGetLatency_001, TestSize.Level1)
74 {
75 int32_t ret = -1;
76 uint32_t latencyTime = 0;
77 uint32_t expectLatency = 0;
78 struct AudioAdapter *adapter = nullptr;
79 struct AudioRender *render = nullptr;
80 ASSERT_NE(nullptr, manager);
81 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
82 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
83
84 ret = render->GetLatency(render, &latencyTime);
85 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
86 EXPECT_LT(expectLatency, latencyTime);
87
88 ret = render->control.Stop((AudioHandle)render);
89 adapter->DestroyRender(adapter, render);
90 manager->UnloadAdapter(manager, adapter);
91 }
92 /**
93 * @tc.name AudioRenderGetLatency_002
94 * @tc.desc test RenderGetLatency interface, return -1 if Setting parameters render is empty
95 * @tc.type: FUNC
96 */
97 HWTEST_F(AudioHdiRenderTest, AudioRenderGetLatency_002, TestSize.Level1)
98 {
99 int32_t ret = -1;
100 uint32_t latencyTime = 0;
101 struct AudioAdapter *adapter = nullptr;
102 struct AudioRender *render = nullptr;
103 struct AudioRender *renderNull = nullptr;
104 ASSERT_NE(nullptr, manager);
105 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
106 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
107
108 ret = render->GetLatency(renderNull, &latencyTime);
109 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
110
111 ret = render->control.Stop((AudioHandle)render);
112 adapter->DestroyRender(adapter, render);
113 manager->UnloadAdapter(manager, adapter);
114 }
115 /**
116 * @tc.name AudioRenderGetLatency_003
117 * @tc.desc test RenderGetLatency interface,return -1 if Setting parameters ms is empty
118 * @tc.type: FUNC
119 */
120 HWTEST_F(AudioHdiRenderTest, AudioRenderGetLatency_003, TestSize.Level1)
121 {
122 int32_t ret = -1;
123 uint32_t *latencyTime = nullptr;
124 struct AudioRender *render = nullptr;
125 struct AudioAdapter *adapter = nullptr;
126 ASSERT_NE(nullptr, manager);
127 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
128 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
129
130 ret = render->GetLatency(render, latencyTime);
131 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
132
133 ret = render->control.Stop((AudioHandle)render);
134 adapter->DestroyRender(adapter, render);
135 manager->UnloadAdapter(manager, adapter);
136 }
137 /**
138 * @tc.name AudioRenderSetRenderSpeed_001
139 * @tc.desc Test SetRenderSpeed interface,return -2 if setting RenderSpeed
140 * @tc.type: FUNC
141 */
142 HWTEST_F(AudioHdiRenderTest, AudioRenderSetRenderSpeed_001, TestSize.Level1)
143 {
144 int32_t ret = -1;
145 float speed = 100;
146 struct AudioAdapter *adapter = nullptr;
147 struct AudioRender *render = nullptr;
148 ASSERT_NE(nullptr, manager);
149 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
150 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
151
152 ret = render->SetRenderSpeed(render, speed);
153 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
154
155 render->control.Stop((AudioHandle)render);
156 adapter->DestroyRender(adapter, render);
157 manager->UnloadAdapter(manager, adapter);
158 }
159 /**
160 * @tc.name AudioRenderSetRenderSpeed_002
161 * @tc.desc Test SetRenderSpeed interface,return -2 if the incoming parameter handle is nullptr
162 * @tc.type: FUNC
163 */
164 HWTEST_F(AudioHdiRenderTest, AudioRenderSetRenderSpeed_002, TestSize.Level1)
165 {
166 int32_t ret = -1;
167 float speed = 0;
168 struct AudioAdapter *adapter = nullptr;
169 struct AudioRender *render = nullptr;
170 struct AudioRender *renderNull = nullptr;
171 ASSERT_NE(nullptr, manager);
172 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
173 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
174
175 ret = render->SetRenderSpeed(renderNull, speed);
176 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
177
178 render->control.Stop((AudioHandle)render);
179 adapter->DestroyRender(adapter, render);
180 manager->UnloadAdapter(manager, adapter);
181 }
182 /**
183 * @tc.name AudioRenderGetRenderSpeed_001
184 * @tc.desc Test GetRenderSpeed interface,return -2 if getting RenderSpeed
185 * @tc.type: FUNC
186 */
187 HWTEST_F(AudioHdiRenderTest, AudioRenderGetRenderSpeed_001, TestSize.Level1)
188 {
189 int32_t ret = -1;
190 float speed = 0;
191 struct AudioAdapter *adapter = nullptr;
192 struct AudioRender *render = nullptr;
193 ASSERT_NE(nullptr, manager);
194 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
195 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
196 ret = render->GetRenderSpeed(render, &speed);
197 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
198
199 render->control.Stop((AudioHandle)render);
200 adapter->DestroyRender(adapter, render);
201 manager->UnloadAdapter(manager, adapter);
202 }
203 /**
204 * @tc.name AudioRenderGetRenderSpeed_002
205 * @tc.desc Test GetRenderSpeed interface,return -2 if the incoming parameter handle is nullptr
206 * @tc.type: FUNC
207 */
208 HWTEST_F(AudioHdiRenderTest, AudioRenderGetRenderSpeed_002, TestSize.Level1)
209 {
210 int32_t ret = -1;
211 struct AudioAdapter *adapter = nullptr;
212 struct AudioRender *render = nullptr;
213 struct AudioRender *renderNull = nullptr;
214 float speed = 0;
215 ASSERT_NE(nullptr, manager);
216 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
217 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
218
219 ret = render->GetRenderSpeed(renderNull, &speed);
220 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
221
222 render->control.Stop((AudioHandle)render);
223 adapter->DestroyRender(adapter, render);
224 manager->UnloadAdapter(manager, adapter);
225 }
226 /**
227 * @tc.name AudioRenderGetRenderSpeed_002
228 * @tc.desc Test GetRenderSpeed interface,return -2 if the incoming parameter speed is nullptr
229 * @tc.type: FUNC
230 */
231 HWTEST_F(AudioHdiRenderTest, AudioRenderGetRenderSpeed_003, TestSize.Level1)
232 {
233 int32_t ret = -1;
234 struct AudioAdapter *adapter = nullptr;
235 struct AudioRender *render = nullptr;
236 float *speedNull = nullptr;
237 ASSERT_NE(nullptr, manager);
238 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
239 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
240
241 ret = render->GetRenderSpeed(render, speedNull);
242 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
243
244 render->control.Stop((AudioHandle)render);
245 adapter->DestroyRender(adapter, render);
246 manager->UnloadAdapter(manager, adapter);
247 }
248 /**
249 * @tc.name AudioRenderFrame_001
250 * @tc.desc test AudioRenderFrame interface,Returns 0 if the data is written successfully
251 * @tc.type: FUNC
252 */
253 HWTEST_F(AudioHdiRenderTest, AudioRenderFrame_001, TestSize.Level1)
254 {
255 int32_t ret = -1;
256 uint64_t requestBytes = 0;
257 uint64_t replyBytes = 0;
258 struct AudioAdapter *adapter = nullptr;
259 struct AudioRender *render = nullptr;
260 char *frame = nullptr;
261 ASSERT_NE(nullptr, manager);
262 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
263 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
264 ret = render->control.Start((AudioHandle)render);
265 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
266
267 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
268 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
269 ret = render->RenderFrame(render, frame, requestBytes, &replyBytes);
270 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
271
272 render->control.Stop((AudioHandle)render);
273 adapter->DestroyRender(adapter, render);
274 manager->UnloadAdapter(manager, adapter);
275 if (frame != nullptr) {
276 free(frame);
277 frame = nullptr;
278 }
279 }
280 /**
281 * @tc.name AudioRenderFrame_002
282 * @tc.desc Test AudioRenderFrame interface,Returns -1 if the incoming parameter render is nullptr
283 * @tc.type: FUNC
284 */
285 HWTEST_F(AudioHdiRenderTest, AudioRenderFrame_002, TestSize.Level1)
286 {
287 int32_t ret = -1;
288 uint64_t requestBytes = 0;
289 uint64_t replyBytes = 0;
290 struct AudioAdapter *adapter = nullptr;
291 struct AudioRender *render = nullptr;
292 struct AudioRender *renderNull = nullptr;
293 char *frame = nullptr;
294
295 ASSERT_NE(nullptr, manager);
296 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
297 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
298 ret = render->control.Start((AudioHandle)render);
299 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
300
301 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
302 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
303 ret = render->RenderFrame(renderNull, frame, requestBytes, &replyBytes);
304 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
305
306 ret = render->control.Stop((AudioHandle)render);
307 adapter->DestroyRender(adapter, render);
308 manager->UnloadAdapter(manager, adapter);
309 if (frame != nullptr) {
310 free(frame);
311 frame = nullptr;
312 }
313 }
314 /**
315 * @tc.name AudioRenderFrame_003
316 * @tc.desc Test AudioRenderFrame interface,Returns -1 if the incoming parameter frame is nullptr
317 * @tc.type: FUNC
318 */
319 HWTEST_F(AudioHdiRenderTest, AudioRenderFrame_003, TestSize.Level1)
320 {
321 int32_t ret = -1;
322 uint64_t requestBytes = 0;
323 uint64_t replyBytes = 0;
324 struct AudioAdapter *adapter = nullptr;
325 struct AudioRender *render = nullptr;
326 char *frame = nullptr;
327
328 ASSERT_NE(nullptr, manager);
329 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
330 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
331 ret = render->control.Start((AudioHandle)render);
332 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
333
334 ret = render->RenderFrame(render, frame, requestBytes, &replyBytes);
335 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
336 ret = render->control.Stop((AudioHandle)render);
337 adapter->DestroyRender(adapter, render);
338 manager->UnloadAdapter(manager, adapter);
339 }
340 /**
341 * @tc.name AudioRenderFrame_004
342 * @tc.desc Test AudioRenderFrame interface,Returns -1 if the incoming parameter replyBytes is nullptr
343 * @tc.type: FUNC
344 */
345 HWTEST_F(AudioHdiRenderTest, AudioRenderFrame_004, TestSize.Level1)
346 {
347 int32_t ret = -1;
348 uint64_t requestBytes = 0;
349 struct AudioAdapter *adapter = nullptr;
350 struct AudioRender *render = nullptr;
351 char *frame = nullptr;
352 uint64_t *replyBytes = nullptr;
353
354 ASSERT_NE(nullptr, manager);
355 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
356 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
357 ret = render->control.Start((AudioHandle)render);
358 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
359
360 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
361 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
362 ret = render->RenderFrame(render, frame, requestBytes, replyBytes);
363 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
364
365 ret = render->control.Stop((AudioHandle)render);
366 adapter->DestroyRender(adapter, render);
367 manager->UnloadAdapter(manager, adapter);
368 if (frame != nullptr) {
369 free(frame);
370 frame = nullptr;
371 }
372 }
373 /**
374 * @tc.name AudioRenderFrame_005
375 * @tc.desc Test AudioRenderFrame interface,Returns -1 if without calling interface renderstart
376 * @tc.type: FUNC
377 */
378 HWTEST_F(AudioHdiRenderTest, AudioRenderFrame_005, TestSize.Level1)
379 {
380 int32_t ret = -1;
381 uint64_t replyBytes = 0;
382 uint64_t requestBytes = 0;
383 struct AudioAdapter *adapter = nullptr;
384 struct AudioRender *render = nullptr;
385 char *frame = nullptr;
386
387 ASSERT_NE(nullptr, manager);
388 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
389 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
390 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
391 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
392 ret = render->RenderFrame(render, frame, requestBytes, &replyBytes);
393 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
394
395 adapter->DestroyRender(adapter, render);
396 manager->UnloadAdapter(manager, adapter);
397 if (frame != nullptr) {
398 free(frame);
399 frame = nullptr;
400 }
401 }
402 /**
403 * @tc.name AudioRenderGetRenderPosition_001
404 * @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition during playing.
405 * @tc.type: FUNC
406 */
407 HWTEST_F(AudioHdiRenderTest, AudioRenderGetRenderPosition_001, TestSize.Level1)
408 {
409 int32_t ret = -1;
410 uint64_t frames = 0;
411 int64_t timeExp = 0;
412 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
413 struct PrepareAudioPara audiopara = {
414 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
415 .path = AUDIO_FILE.c_str()
416 };
417 audiopara.manager = manager;
418 ASSERT_NE(audiopara.manager, nullptr);
419
420 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
421 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
422 sleep(1);
423 if (audiopara.render != nullptr) {
424 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
425 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
426 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
427 EXPECT_GT(frames, INITIAL_VALUE);
428 }
429
430 ret = ThreadRelease(audiopara);
431 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
432 }
433 /**
434 * @tc.name AudioRenderGetRenderPosition_002
435 * @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition after Pause and resume during playing
436 * @tc.type: FUNC
437 */
438 HWTEST_F(AudioHdiRenderTest, AudioRenderGetRenderPosition_002, TestSize.Level1)
439 {
440 int32_t ret = -1;
441 int64_t timeExp = 0;
442 uint64_t frames = 0;
443 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
444 struct PrepareAudioPara audiopara = {
445 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
446 .path = AUDIO_FILE.c_str()
447 };
448 audiopara.manager = manager;
449 ASSERT_NE(audiopara.manager, nullptr);
450
451 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
452 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
453 sleep(1);
454 if (audiopara.render != nullptr) {
455 FrameStatus(0);
456 usleep(1000);
457 ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render));
458 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
459 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
460 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
461 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
462 EXPECT_GT(frames, INITIAL_VALUE);
463 usleep(1000);
464 ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render));
465 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
466 FrameStatus(1);
467 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
468 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
469 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
470 EXPECT_GT(frames, INITIAL_VALUE);
471 }
472
473 ret = ThreadRelease(audiopara);
474 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
475 }
476 /**
477 * @tc.name AudioRenderGetRenderPosition_003
478 * @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition after stop
479 * @tc.type: FUNC
480 */
481 HWTEST_F(AudioHdiRenderTest, AudioRenderGetRenderPosition_003, TestSize.Level1)
482 {
483 int32_t ret = -1;
484 int64_t timeExp = 0;
485 uint64_t frames = 0;
486 struct AudioAdapter *adapter = nullptr;
487 struct AudioRender *render = nullptr;
488 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
489 ASSERT_NE(nullptr, manager);
490 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
491 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
492 ret = render->control.Stop((AudioHandle)render);
493 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
494
495 ret = render->GetRenderPosition(render, &frames, &time);
496 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
497 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
498 EXPECT_GT(frames, INITIAL_VALUE);
499
500 adapter->DestroyRender(adapter, render);
501 manager->UnloadAdapter(manager, adapter);
502 }
503 /**
504 * @tc.name AudioRenderGetRenderPosition_004
505 * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter render is nullptr
506 * @tc.type: FUNC
507 */
508 HWTEST_F(AudioHdiRenderTest, AudioRenderGetRenderPosition_004, TestSize.Level1)
509 {
510 int32_t ret = -1;
511 uint64_t frames = 0;
512 int64_t timeExp = 0;
513 struct AudioRender *render = nullptr;
514 struct AudioAdapter *adapter = nullptr;
515 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
516
517 ASSERT_NE(nullptr, manager);
518 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
519 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
520 ret = render->GetRenderPosition(render, &frames, &time);
521 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
522 EXPECT_EQ((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
523
524 adapter->DestroyRender(adapter, render);
525 manager->UnloadAdapter(manager, adapter);
526 }
527 /**
528 * @tc.name AudioRenderGetRenderPosition_005
529 * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter render is nullptr
530 * @tc.type: FUNC
531 */
532 HWTEST_F(AudioHdiRenderTest, AudioRenderGetRenderPosition_005, TestSize.Level1)
533 {
534 int32_t ret = -1;
535 uint64_t frames = 0;
536 struct AudioTimeStamp time = {};
537 struct AudioAdapter *adapter = nullptr;
538 struct AudioRender *render = nullptr;
539 struct AudioRender *renderNull = nullptr;
540
541 ASSERT_NE(nullptr, manager);
542 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
543 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
544 ret = render->GetRenderPosition(renderNull, &frames, &time);
545 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
546
547 render->control.Stop((AudioHandle)render);
548 adapter->DestroyRender(adapter, render);
549 manager->UnloadAdapter(manager, adapter);
550 }
551 /**
552 * @tc.name AudioRenderGetRenderPosition_006
553 * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter frames is nullptr
554 * @tc.type: FUNC
555 */
556 HWTEST_F(AudioHdiRenderTest, AudioRenderGetRenderPosition_006, TestSize.Level1)
557 {
558 int32_t ret = -1;
559 uint64_t *framesNull = nullptr;
560 struct AudioAdapter *adapter = nullptr;
561 struct AudioRender *render = nullptr;
562 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
563
564 ASSERT_NE(nullptr, manager);
565 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
566 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
567 ret = render->GetRenderPosition(render, framesNull, &time);
568 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
569
570 render->control.Stop((AudioHandle)render);
571 adapter->DestroyRender(adapter, render);
572 manager->UnloadAdapter(manager, adapter);
573 }
574 /**
575 * @tc.name AudioRenderGetRenderPosition_007
576 * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter time is nullptr
577 * @tc.type: FUNC
578 */
579 HWTEST_F(AudioHdiRenderTest, AudioRenderGetRenderPosition_007, TestSize.Level1)
580 {
581 int32_t ret = -1;
582 uint64_t frames = 0;
583 struct AudioAdapter *adapter = nullptr;
584 struct AudioRender *render = nullptr;
585 struct AudioTimeStamp *timeNull = nullptr;
586
587 ASSERT_NE(nullptr, manager);
588 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
589 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
590
591 ret = render->GetRenderPosition(render, &frames, timeNull);
592 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
593
594 render->control.Stop((AudioHandle)render);
595 adapter->DestroyRender(adapter, render);
596 manager->UnloadAdapter(manager, adapter);
597 }
598 /**
599 * @tc.name AudioRenderGetRenderPosition_008
600 * @tc.desc Test AudioRenderGetRenderPosition interface, return 0 if the GetRenderPosition was called twice
601 * @tc.type: FUNC
602 */
603 HWTEST_F(AudioHdiRenderTest, AudioRenderGetRenderPosition_008, TestSize.Level1)
604 {
605 int32_t ret = -1;
606 int64_t timeExp = 0;
607 uint64_t frames = 0;
608 struct AudioAdapter *adapter = nullptr;
609 struct AudioRender *render = nullptr;
610 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
611 ASSERT_NE(nullptr, manager);
612 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
613 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
614
615 ret = render->GetRenderPosition(render, &frames, &time);
616 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
617 ret = render->GetRenderPosition(render, &frames, &time);
618 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
619 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
620 EXPECT_GT(frames, INITIAL_VALUE);
621
622 render->control.Stop((AudioHandle)render);
623 adapter->DestroyRender(adapter, render);
624 manager->UnloadAdapter(manager, adapter);
625 }
626 /**
627 * @tc.name AudioRenderReqMmapBuffer_001
628 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully
629 * @tc.type: FUNC
630 */
631
632 HWTEST_F(AudioHdiRenderTest, AudioRenderReqMmapBuffer_001, TestSize.Level1)
633 {
634 int32_t ret = -1;
635 bool isRender = true;
636 int32_t reqSize = 0;
637 struct AudioMmapBufferDescripter desc = {};
638 struct AudioRender *render = nullptr;
639 struct AudioAdapter *adapter = nullptr;
640 ASSERT_NE(nullptr, manager);
641 struct AudioSampleAttributes attrs = {};
642 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
643 ASSERT_NE(fp, nullptr);
644 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
645 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
646 if (ret < 0 || render == nullptr) {
647 fclose(fp);
648 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
649 ASSERT_EQ(nullptr, render);
650 }
651 InitAttrs(attrs);
652 attrs.startThreshold = 0;
653 ret = render->attr.SetSampleAttributes(render, &attrs);
654 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
655 ret = InitMmapDesc(fp, desc, reqSize, isRender);
656 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
657 ret = render->control.Start((AudioHandle)render);
658 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
659 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc);
660 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
661 fclose(fp);
662 if (ret == 0) {
663 munmap(desc.memoryAddress, reqSize);
664 }
665 render->control.Stop((AudioHandle)render);
666 adapter->DestroyRender(adapter, render);
667 manager->UnloadAdapter(manager, adapter);
668 }
669 /**
670 * @tc.name AudioRenderReqMmapBuffer_002
671 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessfully when setting the
672 incoming parameter reqSize is bigger than the size of actual audio file
673 * @tc.type: FUNC
674 */
675 HWTEST_F(AudioHdiRenderTest, AudioRenderReqMmapBuffer_002, TestSize.Level1)
676 {
677 int32_t ret = -1;
678 bool isRender = true;
679 int32_t reqSize = 0;
680 struct AudioMmapBufferDescripter desc = {};
681 struct AudioRender *render = nullptr;
682 struct AudioAdapter *adapter = nullptr;
683 ASSERT_NE(nullptr, manager);
684 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
685 ASSERT_NE(fp, nullptr);
686 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
687 if (ret < 0 || render == nullptr) {
688 fclose(fp);
689 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
690 ASSERT_EQ(nullptr, render);
691 }
692 ret = InitMmapDesc(fp, desc, reqSize, isRender);
693 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
694 reqSize = reqSize + BUFFER_LENTH;
695 ret = render->control.Start((AudioHandle)render);
696 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
697 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc);
698 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
699 fclose(fp);
700 render->control.Stop((AudioHandle)render);
701 adapter->DestroyRender(adapter, render);
702 manager->UnloadAdapter(manager, adapter);
703 }
704 /**
705 * @tc.name AudioRenderReqMmapBuffer_003
706 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully when setting the
707 incoming parameter reqSize is smaller than the size of actual audio file
708 * @tc.type: FUNC
709 */
710 HWTEST_F(AudioHdiRenderTest, AudioRenderReqMmapBuffer_003, TestSize.Level1)
711 {
712 int32_t ret = -1;
713 bool isRender = true;
714 int32_t reqSize = 0;
715 struct AudioMmapBufferDescripter desc = {};
716 struct AudioRender *render = nullptr;
717 struct AudioAdapter *adapter = nullptr;
718 ASSERT_NE(nullptr, manager);
719 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
720 ASSERT_NE(fp, nullptr);
721 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
722 if (ret < 0 || render == nullptr) {
723 fclose(fp);
724 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
725 ASSERT_EQ(nullptr, render);
726 }
727 ret = InitMmapDesc(fp, desc, reqSize, isRender);
728 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
729 reqSize = reqSize / 2;
730 ret = render->control.Start((AudioHandle)render);
731 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
732 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc);
733 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
734 fclose(fp);
735 if (ret == 0) {
736 munmap(desc.memoryAddress, reqSize);
737 }
738 render->control.Stop((AudioHandle)render);
739 adapter->DestroyRender(adapter, render);
740 manager->UnloadAdapter(manager, adapter);
741 }
742 /**
743 * @tc.name AudioRenderReqMmapBuffer_003
744 * @tc.desc Test ReqMmapBuffer interface,return -1 if call ReqMmapBuffer interface unsuccessfully when setting the
745 incoming parameter reqSize is zero
746 * @tc.type: FUNC
747 */
748 HWTEST_F(AudioHdiRenderTest, AudioRenderReqMmapBuffer_004, TestSize.Level1)
749 {
750 int32_t ret = -1;
751 bool isRender = true;
752 int32_t reqSize = 0;
753 ASSERT_NE(nullptr, manager);
754 struct AudioMmapBufferDescripter desc = {};
755 struct AudioRender *render = nullptr;
756 struct AudioAdapter *adapter = nullptr;
757 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
758 ASSERT_NE(fp, nullptr);
759 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
760 if (ret < 0 || render == nullptr) {
761 fclose(fp);
762 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
763 ASSERT_EQ(nullptr, render);
764 }
765 ret = InitMmapDesc(fp, desc, reqSize, isRender);
766 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
767 reqSize = 0;
768 ret = render->control.Start((AudioHandle)render);
769 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
770 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc);
771 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
772 fclose(fp);
773 render->control.Stop((AudioHandle)render);
774 adapter->DestroyRender(adapter, render);
775 manager->UnloadAdapter(manager, adapter);
776 }
777 /**
778 * @tc.name AudioRenderReqMmapBuffer_003
779 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessfully when setting the
780 incoming parameter memoryFd of desc is illegal
781 * @tc.type: FUNC
782 */
783 HWTEST_F(AudioHdiRenderTest, AudioRenderReqMmapBuffer_005, TestSize.Level1)
784 {
785 int32_t ret = -1;
786 bool isRender = true;
787 int32_t reqSize = 0;
788 struct AudioMmapBufferDescripter desc = {};
789 struct AudioRender *render = nullptr;
790 struct AudioAdapter *adapter = nullptr;
791 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
792 ASSERT_NE(fp, nullptr);
793 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
794 if (ret < 0 || render == nullptr) {
795 fclose(fp);
796 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
797 ASSERT_EQ(nullptr, render);
798 }
799 ret = InitMmapDesc(fp, desc, reqSize, isRender);
800 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
801 desc.memoryFd = -1; // -1 is invalid fd
802 ret = render->control.Start((AudioHandle)render);
803 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
804 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc);
805 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
806 fclose(fp);
807 render->control.Stop((AudioHandle)render);
808 adapter->DestroyRender(adapter, render);
809 manager->UnloadAdapter(manager, adapter);
810 }
811 /**
812 * @tc.name AudioRenderReqMmapBuffer_005
813 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessfully when setting the
814 incoming parameter handle is nullptr
815 * @tc.type: FUNC
816 */
817 HWTEST_F(AudioHdiRenderTest, AudioRenderReqMmapBuffer_006, TestSize.Level1)
818 {
819 int32_t ret = -1;
820 bool isRender = true;
821 int32_t reqSize = 0;
822 struct AudioMmapBufferDescripter desc = {};
823 struct AudioRender *render = nullptr;
824 struct AudioRender *renderNull = nullptr;
825 ASSERT_NE(nullptr, manager);
826 struct AudioAdapter *adapter = nullptr;
827 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
828 ASSERT_NE(fp, nullptr);
829 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
830 if (ret < 0 || render == nullptr) {
831 fclose(fp);
832 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
833 ASSERT_EQ(nullptr, render);
834 }
835 ret = InitMmapDesc(fp, desc, reqSize, isRender);
836 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
837 ret = render->control.Start((AudioHandle)render);
838 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
839 ret = render->attr.ReqMmapBuffer((AudioHandle)renderNull, reqSize, &desc);
840 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
841 fclose(fp);
842 render->control.Stop((AudioHandle)render);
843 adapter->DestroyRender(adapter, render);
844 manager->UnloadAdapter(manager, adapter);
845 }
846 /**
847 * @tc.name AudioRenderReqMmapBuffer_006
848 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessfully when setting the
849 incoming parameter desc is nullptr
850 * @tc.type: FUNC
851 */
852 HWTEST_F(AudioHdiRenderTest, AudioRenderReqMmapBuffer_007, TestSize.Level1)
853 {
854 int32_t ret = -1;
855 bool isRender = true;
856 int32_t reqSize = 0;
857 struct AudioMmapBufferDescripter desc = {};
858 struct AudioMmapBufferDescripter *descNull = nullptr;
859 struct AudioRender *render = nullptr;
860 struct AudioAdapter *adapter = nullptr;
861 ASSERT_NE(nullptr, manager);
862 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
863 ASSERT_NE(fp, nullptr);
864 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
865 if (ret < 0 || render == nullptr) {
866 fclose(fp);
867 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
868 ASSERT_EQ(nullptr, render);
869 }
870 ret = InitMmapDesc(fp, desc, reqSize, isRender);
871 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
872 ret = render->control.Start((AudioHandle)render);
873 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
874 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, descNull);
875 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
876 fclose(fp);
877 render->control.Stop((AudioHandle)render);
878 adapter->DestroyRender(adapter, render);
879 manager->UnloadAdapter(manager, adapter);
880 }
881 /**
882 * @tc.name AudioRenderGetMmapPosition_001
883 * @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully.
884 * @tc.type: FUNC
885 */
886 HWTEST_F(AudioHdiRenderTest, AudioRenderGetMmapPosition_001, TestSize.Level1)
887 {
888 uint64_t frames = 0;
889 uint64_t framesRendering = 0;
890 uint64_t framesexpRender = 0;
891 int64_t timeExp = 0;
892 struct PrepareAudioPara audiopara = {
893 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
894 .path = LOW_LATENCY_AUDIO_FILE.c_str()
895 };
896 audiopara.manager = manager;
897 ASSERT_NE(audiopara.manager, nullptr);
898 int32_t ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
899 &audiopara.render);
900 if (ret < 0 || audiopara.render == nullptr) {
901 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
902 ASSERT_EQ(nullptr, audiopara.render);
903 }
904 InitAttrs(audiopara.attrs);
905 audiopara.attrs.startThreshold = 0;
906 ret = audiopara.render->attr.SetSampleAttributes(audiopara.render, &(audiopara.attrs));
907 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
908 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &frames, &(audiopara.time));
909 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
910 EXPECT_EQ((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
911 EXPECT_EQ(frames, INITIAL_VALUE);
912
913 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayMapAudioFile, &audiopara);
914 if (ret != 0) {
915 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
916 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
917 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
918 }
919 sleep(1);
920 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &framesRendering, &(audiopara.time));
921 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
922 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
923 EXPECT_GT(framesRendering, INITIAL_VALUE);
924 int64_t timeExprendering = (audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec);
925 void *result = nullptr;
926 pthread_join(audiopara.tids, &result);
927 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
928 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &framesexpRender, &(audiopara.time));
929 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
930 EXPECT_GE((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExprendering);
931 EXPECT_GE(framesexpRender, framesRendering);
932 audiopara.render->control.Stop((AudioHandle)audiopara.render);
933 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
934 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
935 }
936 /**
937 * @tc.name AudioRenderGetMmapPosition_003
938 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
939 * @tc.type: FUNC
940 */
941 HWTEST_F(AudioHdiRenderTest, AudioRenderGetMmapPosition_003, TestSize.Level1)
942 {
943 int32_t ret = -1;
944 uint64_t *frames = nullptr;
945 struct PrepareAudioPara audiopara = {
946 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
947 .path = LOW_LATENCY_AUDIO_FILE.c_str()
948 };
949 audiopara.manager = manager;
950 ASSERT_NE(audiopara.manager, nullptr);
951 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
952 &audiopara.render);
953 if (ret < 0 || audiopara.render == nullptr) {
954 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
955 ASSERT_EQ(nullptr, audiopara.render);
956 }
957
958 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, frames, &(audiopara.time));
959 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
960
961 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
962 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
963 }
964 /**
965 * @tc.name AudioRenderGetMmapPosition_004
966 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
967 * @tc.type: FUNC
968 */
969 HWTEST_F(AudioHdiRenderTest, AudioRenderGetMmapPosition_004, TestSize.Level1)
970 {
971 int32_t ret = -1;
972 uint64_t frames = 0;
973 struct AudioTimeStamp *time = nullptr;
974 struct PrepareAudioPara audiopara = {
975 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
976 .path = LOW_LATENCY_AUDIO_FILE.c_str()
977 };
978 audiopara.manager = manager;
979 ASSERT_NE(audiopara.manager, nullptr);
980 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
981 &audiopara.render);
982 if (ret < 0 || audiopara.render == nullptr) {
983 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
984 ASSERT_EQ(nullptr, audiopara.render);
985 }
986
987 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &frames, time);
988 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
989
990 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
991 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
992 }
993 /**
994 * @tc.name AudioRenderGetMmapPosition_005
995 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
996 * @tc.type: FUNC
997 */
998 HWTEST_F(AudioHdiRenderTest, AudioRenderGetMmapPosition_005, TestSize.Level1)
999 {
1000 int32_t ret = -1;
1001 uint64_t frames = 0;
1002 struct AudioRender *renderNull = nullptr;
1003 struct PrepareAudioPara audiopara = {
1004 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
1005 .path = LOW_LATENCY_AUDIO_FILE.c_str()
1006 };
1007 audiopara.manager = manager;
1008 ASSERT_NE(audiopara.manager, nullptr);
1009 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1010 &audiopara.render);
1011 if (ret < 0 || audiopara.render == nullptr) {
1012 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1013 ASSERT_EQ(nullptr, audiopara.render);
1014 }
1015
1016 ret = audiopara.render->attr.GetMmapPosition(renderNull, &frames, &(audiopara.time));
1017 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1018
1019 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1020 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1021 }
1022 }
1023