1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 /**
17 * @addtogroup Audio
18 * @{
19 *
20 * @brief Defines audio-related APIs, including custom data types and functions for loading drivers,
21 * accessing a driver adapter, and rendering audios.
22 *
23 * @since 1.0
24 * @version 1.0
25 */
26
27 /**
28 * @file audio_hdi_common.h
29 *
30 * @brief Declares APIs for operations related to the audio render adapter.
31 *
32 * @since 1.0
33 * @version 1.0
34 */
35
36 #include "audio_hdi_common.h"
37 #include "audio_hdirender_test.h"
38
39 using namespace std;
40 using namespace testing::ext;
41 using namespace HMOS::Audio;
42
43 namespace {
44 const string ADAPTER_NAME_USB = "usb";
45 const string ADAPTER_NAME_INTERNAL = "internal";
46
47 class AudioHdiRenderTest : public testing::Test {
48 public:
49 static void SetUpTestCase(void);
50 static void TearDownTestCase(void);
51 void SetUp();
52 void TearDown();
53 static TestAudioManager *(*GetAudioManager)();
54 static void *handleSo;
55 #ifdef AUDIO_MPI_SO
56 static int32_t (*SdkInit)();
57 static void (*SdkExit)();
58 static void *sdkSo;
59 #endif
60 static int32_t GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara);
61 };
62
63 using THREAD_FUNC = void *(*)(void *);
64
65 TestAudioManager *(*AudioHdiRenderTest::GetAudioManager)() = nullptr;
66 void *AudioHdiRenderTest::handleSo = nullptr;
67 #ifdef AUDIO_MPI_SO
68 int32_t (*AudioHdiRenderTest::SdkInit)() = nullptr;
69 void (*AudioHdiRenderTest::SdkExit)() = nullptr;
70 void *AudioHdiRenderTest::sdkSo = nullptr;
71 #endif
SetUpTestCase(void)72 void AudioHdiRenderTest::SetUpTestCase(void)
73 {
74 #ifdef AUDIO_MPI_SO
75 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
76 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
77 if (sdkSo == nullptr) {
78 return;
79 }
80 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
81 if (SdkInit == nullptr) {
82 return;
83 }
84 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
85 if (SdkExit == nullptr) {
86 return;
87 }
88 SdkInit();
89 #endif
90 char absPath[PATH_MAX] = {0};
91 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
92 return;
93 }
94 handleSo = dlopen(absPath, RTLD_LAZY);
95 if (handleSo == nullptr) {
96 return;
97 }
98 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
99 if (GetAudioManager == nullptr) {
100 return;
101 }
102 }
103
TearDownTestCase(void)104 void AudioHdiRenderTest::TearDownTestCase(void)
105 {
106 #ifdef AUDIO_MPI_SO
107 SdkExit();
108 if (sdkSo != nullptr) {
109 dlclose(sdkSo);
110 sdkSo = nullptr;
111 }
112 if (SdkInit != nullptr) {
113 SdkInit = nullptr;
114 }
115 if (SdkExit != nullptr) {
116 SdkExit = nullptr;
117 }
118 #endif
119 if (handleSo != nullptr) {
120 dlclose(handleSo);
121 handleSo = nullptr;
122 }
123 if (GetAudioManager != nullptr) {
124 GetAudioManager = nullptr;
125 }
126 }
127
SetUp(void)128 void AudioHdiRenderTest::SetUp(void) {}
129
TearDown(void)130 void AudioHdiRenderTest::TearDown(void) {}
131
GetLoadAdapterAudioPara(struct PrepareAudioPara & audiopara)132 int32_t AudioHdiRenderTest::GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara)
133 {
134 int32_t ret = -1;
135 int size = 0;
136 auto *inst = (AudioHdiRenderTest *)audiopara.self;
137 if (inst != nullptr && inst->GetAudioManager != nullptr) {
138 audiopara.manager = inst->GetAudioManager();
139 }
140 if (audiopara.manager == nullptr) {
141 return HDF_FAILURE;
142 }
143 ret = audiopara.manager->GetAllAdapters(audiopara.manager, &audiopara.descs, &size);
144 if (ret < 0) {
145 return ret;
146 }
147 if (audiopara.descs == nullptr || size == 0) {
148 return AUDIO_HAL_ERR_INTERNAL;
149 }
150 int index = SwitchAdapter(audiopara.descs, audiopara.adapterName,
151 audiopara.portType, audiopara.audioPort, size);
152 if (index < 0) {
153 return AUDIO_HAL_ERR_INTERNAL;
154 } else {
155 audiopara.desc = &audiopara.descs[index];
156 }
157 if (audiopara.desc == nullptr) {
158 return AUDIO_HAL_ERR_INVALID_PARAM;
159 } else {
160 ret = audiopara.manager->LoadAdapter(audiopara.manager, audiopara.desc, &audiopara.adapter);
161 }
162 if (ret < 0) {
163 return ret;
164 }
165 if (audiopara.adapter == nullptr) {
166 return AUDIO_HAL_ERR_INVALID_PARAM;
167 }
168 return HDF_SUCCESS;
169 }
170
171 /**
172 * @tc.name Test RenderGetLatency API via legal
173 * @tc.number SUB_Audio_HDI_RenderGetLatency_0001
174 * @tc.desc test RenderGetLatency interface, return 0 if GetLatency successful
175 * @tc.author: wangkang
176 */
177 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetLatency_0001, TestSize.Level1)
178 {
179 int32_t ret = -1;
180 uint32_t latencyTime = 0;
181 uint32_t expectLatency = 0;
182 struct AudioAdapter *adapter = nullptr;
183 struct AudioRender *render = nullptr;
184 ASSERT_NE(GetAudioManager, nullptr);
185 TestAudioManager* manager = GetAudioManager();
186 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
187 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
188
189 ret = render->GetLatency(render, &latencyTime);
190 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
191 EXPECT_LT(expectLatency, latencyTime);
192
193 ret = render->control.Stop((AudioHandle)render);
194 adapter->DestroyRender(adapter, render);
195 manager->UnloadAdapter(manager, adapter);
196 }
197 /**
198 * @tc.name Test RenderGetLatency API via Setting parameters render is empty
199 * @tc.number SUB_Audio_HDI_AudioRenderGetLatency_0002
200 * @tc.desc test RenderGetLatency interface, return -1 if Setting parameters render is empty
201 * @tc.author: wangkang
202 */
203 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetLatency_0002, TestSize.Level1)
204 {
205 int32_t ret = -1;
206 uint32_t latencyTime = 0;
207 struct AudioAdapter *adapter = nullptr;
208 struct AudioRender *render = nullptr;
209 struct AudioRender *renderNull = nullptr;
210 ASSERT_NE(GetAudioManager, nullptr);
211 TestAudioManager* manager = GetAudioManager();
212 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
213 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
214
215 ret = render->GetLatency(renderNull, &latencyTime);
216 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
217
218 ret = render->control.Stop((AudioHandle)render);
219 adapter->DestroyRender(adapter, render);
220 manager->UnloadAdapter(manager, adapter);
221 }
222 /**
223 * @tc.name Test RenderGetLatency API via Setting parameters ms is empty
224 * @tc.number SUB_Audio_HDI_AudioRenderGetLatency_0003
225 * @tc.desc test RenderGetLatency interface,return -1 if Setting parameters ms is empty
226 * @tc.author: wangkang
227 */
228 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetLatency_0003, TestSize.Level1)
229 {
230 int32_t ret = -1;
231 uint32_t *latencyTime = nullptr;
232 struct AudioRender *render = nullptr;
233 struct AudioAdapter *adapter = nullptr;
234 ASSERT_NE(GetAudioManager, nullptr);
235 TestAudioManager* manager = GetAudioManager();
236 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
237 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
238
239 ret = render->GetLatency(render, latencyTime);
240 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
241
242 ret = render->control.Stop((AudioHandle)render);
243 adapter->DestroyRender(adapter, render);
244 manager->UnloadAdapter(manager, adapter);
245 }
246 /**
247 * @tc.name Test SetRenderSpeed API via legal
248 * @tc.number SUB_Audio_HDI_AudioRenderSetRenderSpeed_0001
249 * @tc.desc Test SetRenderSpeed interface,return -2 if setting RenderSpeed
250 * @tc.author: tiansuli
251 */
252 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetRenderSpeed_0001, TestSize.Level1)
253 {
254 int32_t ret = -1;
255 float speed = 100;
256 TestAudioManager* manager = {};
257 struct AudioAdapter *adapter =nullptr;
258 struct AudioRender *render = nullptr;
259 ASSERT_NE(GetAudioManager, nullptr);
260 manager = GetAudioManager();
261 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
262 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
263
264 ret = render->SetRenderSpeed(render, speed);
265 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
266
267 render->control.Stop((AudioHandle)render);
268 adapter->DestroyRender(adapter, render);
269 manager->UnloadAdapter(manager, adapter);
270 }
271 /**
272 * @tc.name Test SetRenderSpeed API via setting the incoming parameter handle is nullptr
273 * @tc.number SUB_Audio_HDI_AudioRenderSetRenderSpeed_0002
274 * @tc.desc Test SetRenderSpeed interface,return -2 if the incoming parameter handle is nullptr
275 * @tc.author: tiansuli
276 */
277 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetRenderSpeed_0002, TestSize.Level1)
278 {
279 int32_t ret = -1;
280 float speed = 0;
281 TestAudioManager* manager = {};
282 struct AudioAdapter *adapter =nullptr;
283 struct AudioRender *render = nullptr;
284 struct AudioRender *renderNull = nullptr;
285 ASSERT_NE(GetAudioManager, nullptr);
286 manager = GetAudioManager();
287 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
288 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
289
290 ret = render->SetRenderSpeed(renderNull, speed);
291 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
292
293 render->control.Stop((AudioHandle)render);
294 adapter->DestroyRender(adapter, render);
295 manager->UnloadAdapter(manager, adapter);
296 }
297 /**
298 * @tc.name Test GetRenderSpeed API via legal
299 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderSpeed_0001
300 * @tc.desc Test GetRenderSpeed interface,return -2 if getting RenderSpeed
301 * @tc.author: tiansuli
302 */
303 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderSpeed_0001, TestSize.Level1)
304 {
305 int32_t ret = -1;
306 float speed = 0;
307 TestAudioManager* manager = {};
308 struct AudioAdapter *adapter =nullptr;
309 struct AudioRender *render = nullptr;
310 ASSERT_NE(GetAudioManager, nullptr);
311 manager = GetAudioManager();
312 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
313 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
314 ret = render->GetRenderSpeed(render, &speed);
315 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
316
317 render->control.Stop((AudioHandle)render);
318 adapter->DestroyRender(adapter, render);
319 manager->UnloadAdapter(manager, adapter);
320 }
321 /**
322 * @tc.name Test GetRenderSpeed API via setting the incoming parameter handle is nullptr
323 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderSpeed_0002
324 * @tc.desc Test GetRenderSpeed interface,return -2 if the incoming parameter handle is nullptr
325 * @tc.author: tiansuli
326 */
327 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderSpeed_0002, TestSize.Level1)
328 {
329 int32_t ret = -1;
330 TestAudioManager* manager = {};
331 struct AudioAdapter *adapter =nullptr;
332 struct AudioRender *render = nullptr;
333 struct AudioRender *renderNull = nullptr;
334 float speed = 0;
335 ASSERT_NE(GetAudioManager, nullptr);
336 manager = GetAudioManager();
337 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
338 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
339
340 ret = render->GetRenderSpeed(renderNull, &speed);
341 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
342
343 render->control.Stop((AudioHandle)render);
344 adapter->DestroyRender(adapter, render);
345 manager->UnloadAdapter(manager, adapter);
346 }
347 /**
348 * @tc.name Test GetRenderSpeed API via setting the incoming parameter speed is nullptr
349 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderSpeed_0002
350 * @tc.desc Test GetRenderSpeed interface,return -2 if the incoming parameter speed is nullptr
351 * @tc.author: tiansuli
352 */
353 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderSpeed_0003, TestSize.Level1)
354 {
355 int32_t ret = -1;
356 TestAudioManager* manager = {};
357 struct AudioAdapter *adapter =nullptr;
358 struct AudioRender *render = nullptr;
359 float *speedNull = nullptr;
360 ASSERT_NE(GetAudioManager, nullptr);
361 manager = GetAudioManager();
362 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
363 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
364
365 ret = render->GetRenderSpeed(render, speedNull);
366 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
367
368 render->control.Stop((AudioHandle)render);
369 adapter->DestroyRender(adapter, render);
370 manager->UnloadAdapter(manager, adapter);
371 }
372 /**
373 * @tc.name Test AudioRenderFrame API via legal input
374 * @tc.number SUB_Audio_HDI_AudioRenderFrame_0001
375 * @tc.desc test AudioRenderFrame interface,Returns 0 if the data is written successfully
376 * @tc.author: liweiming
377 */
378 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0001, TestSize.Level1)
379 {
380 int32_t ret = -1;
381 uint64_t requestBytes = 0;
382 uint64_t replyBytes = 0;
383 enum AudioPortPin pins = PIN_OUT_SPEAKER;
384 struct AudioAdapter *adapter = nullptr;
385 struct AudioRender *render = nullptr;
386 char *frame = nullptr;
387 ASSERT_NE(GetAudioManager, nullptr);
388 TestAudioManager* manager = GetAudioManager();
389 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
390 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
391 ret = render->control.Start((AudioHandle)render);
392 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
393
394 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
395 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
396 ret = render->RenderFrame(render, frame, requestBytes, &replyBytes);
397 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
398
399 render->control.Stop((AudioHandle)render);
400 adapter->DestroyRender(adapter, render);
401 manager->UnloadAdapter(manager, adapter);
402 if (frame != nullptr) {
403 free(frame);
404 frame = nullptr;
405 }
406 }
407 /**
408 * @tc.name Test AudioRenderFrame API via setting the incoming parameter render is nullptr
409 * @tc.number SUB_Audio_HDI_AudioRenderFrame_0002
410 * @tc.desc Test AudioRenderFrame interface,Returns -1 if the incoming parameter render is nullptr
411 * @tc.author: liweiming
412 */
413 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0002, TestSize.Level1)
414 {
415 int32_t ret = -1;
416 uint64_t requestBytes = 0;
417 uint64_t replyBytes = 0;
418 struct AudioAdapter *adapter = nullptr;
419 struct AudioRender *render = nullptr;
420 struct AudioRender *renderNull = nullptr;
421 char *frame = nullptr;
422
423 ASSERT_NE(GetAudioManager, nullptr);
424 TestAudioManager* manager = GetAudioManager();
425 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
426 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
427 ret = render->control.Start((AudioHandle)render);
428 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
429
430 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
431 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
432 ret = render->RenderFrame(renderNull, frame, requestBytes, &replyBytes);
433 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
434
435 ret = render->control.Stop((AudioHandle)render);
436 adapter->DestroyRender(adapter, render);
437 manager->UnloadAdapter(manager, adapter);
438 if (frame != nullptr) {
439 free(frame);
440 frame = nullptr;
441 }
442 }
443 /**
444 * @tc.name Test AudioRenderFrame API via setting the incoming parameter frame is nullptr
445 * @tc.number SUB_Audio_HDI_AudioRenderFrame_0003
446 * @tc.desc Test AudioRenderFrame interface,Returns -1 if the incoming parameter frame is nullptr
447 * @tc.author: liweiming
448 */
449 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0003, TestSize.Level1)
450 {
451 int32_t ret = -1;
452 uint64_t requestBytes = 0;
453 uint64_t replyBytes = 0;
454 struct AudioAdapter *adapter = nullptr;
455 struct AudioRender *render = nullptr;
456 char *frame = nullptr;
457
458 ASSERT_NE(GetAudioManager, nullptr);
459 TestAudioManager* manager = GetAudioManager();
460 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
461 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
462 ret = render->control.Start((AudioHandle)render);
463 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
464
465 ret = render->RenderFrame(render, frame, requestBytes, &replyBytes);
466 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
467 ret = render->control.Stop((AudioHandle)render);
468 adapter->DestroyRender(adapter, render);
469 manager->UnloadAdapter(manager, adapter);
470 }
471 /**
472 * @tc.name Test AudioRenderFrame API via setting the incoming parameter replyBytes is nullptr
473 * @tc.number SUB_Audio_HDI_AudioRenderFrame_0004
474 * @tc.desc Test AudioRenderFrame interface,Returns -1 if the incoming parameter replyBytes is nullptr
475 * @tc.author: liweiming
476 */
477 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0004, TestSize.Level1)
478 {
479 int32_t ret = -1;
480 uint64_t requestBytes = 0;
481 struct AudioAdapter *adapter = nullptr;
482 struct AudioRender *render = nullptr;
483 char *frame = nullptr;
484 uint64_t *replyBytes = nullptr;
485
486 ASSERT_NE(GetAudioManager, nullptr);
487 TestAudioManager* manager = GetAudioManager();
488 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
489 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
490 ret = render->control.Start((AudioHandle)render);
491 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
492
493 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
494 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
495 ret = render->RenderFrame(render, frame, requestBytes, replyBytes);
496 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
497
498 ret = render->control.Stop((AudioHandle)render);
499 adapter->DestroyRender(adapter, render);
500 manager->UnloadAdapter(manager, adapter);
501 if (frame != nullptr) {
502 free(frame);
503 frame = nullptr;
504 }
505 }
506 /**
507 * @tc.name Test AudioRenderFrame API without calling interface renderstart
508 * @tc.number SUB_Audio_HDI_AudioRenderFrame_0005
509 * @tc.desc Test AudioRenderFrame interface,Returns -1 if without calling interface renderstart
510 * @tc.author: liweiming
511 */
512 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderFrame_0005, TestSize.Level1)
513 {
514 int32_t ret = -1;
515 uint64_t replyBytes = 0;
516 uint64_t requestBytes = 0;
517 struct AudioAdapter *adapter = nullptr;
518 struct AudioRender *render = nullptr;
519 char *frame = nullptr;
520
521 ASSERT_NE(GetAudioManager, nullptr);
522 TestAudioManager* manager = GetAudioManager();
523 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
524 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
525 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
526 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
527 ret = render->RenderFrame(render, frame, requestBytes, &replyBytes);
528 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
529
530 adapter->DestroyRender(adapter, render);
531 manager->UnloadAdapter(manager, adapter);
532 if (frame != nullptr) {
533 free(frame);
534 frame = nullptr;
535 }
536 }
537 /**
538 * @tc.name Test SetChannelMode API via setting channel mode to different enumeration values
539 * @tc.number SUB_Audio_HDI_AudioRenderSetChannelMode_0001
540 * @tc.desc Test SetChannelMode interface,return 0 if set channel mode to different enumeration values
541 * @tc.author: tiansuli
542 */
543 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0001, TestSize.Level1)
544 {
545 int32_t ret = -1;
546 TestAudioManager* manager = {};
547 struct AudioAdapter *adapter =nullptr;
548 struct AudioRender *render = nullptr;
549 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
550 enum AudioChannelMode modeOne = AUDIO_CHANNEL_BOTH_LEFT;
551 enum AudioChannelMode modeSec = AUDIO_CHANNEL_BOTH_RIGHT;
552 enum AudioChannelMode modeTrd = AUDIO_CHANNEL_EXCHANGE;
553 ASSERT_NE(GetAudioManager, nullptr);
554 manager = GetAudioManager();
555 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
556 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
557 ret = render->SetChannelMode(render, mode);
558 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
559 ret = render->GetChannelMode(render, &mode);
560 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
561 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
562 ret = render->SetChannelMode(render, modeOne);
563 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
564 ret = render->GetChannelMode(render, &modeOne);
565 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
566 EXPECT_EQ(AUDIO_CHANNEL_BOTH_LEFT, modeOne);
567 ret = render->SetChannelMode(render, modeSec);
568 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
569 ret = render->GetChannelMode(render, &modeSec);
570 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
571 EXPECT_EQ(AUDIO_CHANNEL_BOTH_RIGHT, modeSec);
572 ret = render->SetChannelMode(render, modeTrd);
573 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
574 ret = render->GetChannelMode(render, &modeTrd);
575 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
576 EXPECT_EQ(AUDIO_CHANNEL_EXCHANGE, modeTrd);
577 render->control.Stop((AudioHandle)render);
578 adapter->DestroyRender(adapter, render);
579 manager->UnloadAdapter(manager, adapter);
580 }
581 /**
582 * @tc.name Test SetChannelMode API via setting channel mode to different values
583 * @tc.number SUB_Audio_HDI_AudioRenderSetChannelMode_0002
584 * @tc.desc Test SetChannelMode interface,return 0 if set channel mode to different values
585 * @tc.author: tiansuli
586 */
587 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0002, TestSize.Level1)
588 {
589 int32_t ret = -1;
590 TestAudioManager* manager = {};
591 struct AudioAdapter *adapter =nullptr;
592 struct AudioRender *render = nullptr;
593 enum AudioChannelMode mode = AUDIO_CHANNEL_MIX;
594 enum AudioChannelMode modeOne = AUDIO_CHANNEL_LEFT_MUTE;
595 enum AudioChannelMode modeSec = AUDIO_CHANNEL_RIGHT_MUTE;
596 enum AudioChannelMode modeTrd = AUDIO_CHANNEL_BOTH_MUTE;
597 ASSERT_NE(GetAudioManager, nullptr);
598 manager = GetAudioManager();
599 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
600 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
601 ret = render->SetChannelMode(render, mode);
602 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
603 ret = render->GetChannelMode(render, &mode);
604 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
605 EXPECT_EQ(AUDIO_CHANNEL_MIX, mode);
606 ret = render->SetChannelMode(render, modeOne);
607 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
608 ret = render->GetChannelMode(render, &modeOne);
609 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
610 EXPECT_EQ(AUDIO_CHANNEL_LEFT_MUTE, modeOne);
611 ret = render->SetChannelMode(render, modeSec);
612 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
613 ret = render->GetChannelMode(render, &modeSec);
614 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
615 EXPECT_EQ(AUDIO_CHANNEL_RIGHT_MUTE, modeSec);
616 ret = render->SetChannelMode(render, modeTrd);
617 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
618 ret = render->GetChannelMode(render, &modeTrd);
619 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
620 EXPECT_EQ(AUDIO_CHANNEL_BOTH_MUTE, modeTrd);
621 render->control.Stop((AudioHandle)render);
622 adapter->DestroyRender(adapter, render);
623 manager->UnloadAdapter(manager, adapter);
624 }
625 /**
626 * @tc.name Test SetChannelMode API via setting channel mode after render object is created
627 * @tc.number SUB_Audio_HDI_AudioRenderSetChannelMode_0003
628 * @tc.desc Test SetChannelMode interface,return 0 if set channel mode after render object is created
629 * @tc.author: tiansuli
630 */
631 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0003, TestSize.Level1)
632 {
633 int32_t ret = -1;
634 TestAudioManager* manager = {};
635 struct AudioAdapter *adapter =nullptr;
636 struct AudioRender *render = nullptr;
637 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
638 enum AudioPortPin pins = PIN_OUT_SPEAKER;
639 ASSERT_NE(GetAudioManager, nullptr);
640 manager = GetAudioManager();
641 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
642 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
643 ret = render->SetChannelMode(render, mode);
644 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
645 ret = render->GetChannelMode(render, &mode);
646 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
647 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
648
649 adapter->DestroyRender(adapter, render);
650 manager->UnloadAdapter(manager, adapter);
651 }
652 /**
653 * @tc.name Test SetChannelMode API via setting the parameter render is nullptr
654 * @tc.number SUB_Audio_HDI_AudioRenderSetChannelMode_0004
655 * @tc.desc Test SetChannelMode interface,return -1 if set the parameter render is nullptr
656 * @tc.author: tiansuli
657 */
658 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderSetChannelMode_0004, TestSize.Level1)
659 {
660 int32_t ret = -1;
661 TestAudioManager* manager = {};
662 struct AudioRender *render = nullptr;
663 struct AudioAdapter *adapter =nullptr;
664 struct AudioRender *renderNull = nullptr;
665 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
666 enum AudioPortPin pins = PIN_OUT_SPEAKER;
667 ASSERT_NE(GetAudioManager, nullptr);
668 manager = GetAudioManager();
669 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
670 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
671
672 ret = render->SetChannelMode(renderNull, mode);
673 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
674
675 adapter->DestroyRender(adapter, render);
676 manager->UnloadAdapter(manager, adapter);
677 }
678 /**
679 * @tc.name Test GetChannelMode API via getting the channel mode after setting
680 * @tc.number SUB_Audio_HDI_AudioRenderGetChannelMode_0001
681 * @tc.desc Test GetChannelMode interface,return 0 if getting the channel mode after setting
682 * @tc.author: tiansuli
683 */
684 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetChannelMode_0001, TestSize.Level1)
685 {
686 int32_t ret = -1;
687 TestAudioManager* manager = {};
688 struct AudioAdapter *adapter =nullptr;
689 struct AudioRender *render = nullptr;
690 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
691 ASSERT_NE(GetAudioManager, nullptr);
692 manager = GetAudioManager();
693 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
694 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
695
696 ret = render->GetChannelMode(render, &mode);
697 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
698 ret = render->SetChannelMode(render, mode);
699 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
700 ret = render->GetChannelMode(render, &mode);
701 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
702 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
703
704 render->control.Stop((AudioHandle)render);
705 adapter->DestroyRender(adapter, render);
706 manager->UnloadAdapter(manager, adapter);
707 }
708 /**
709 * @tc.name Test GetChannelMode API via getting the parameter render is nullptr
710 * @tc.number SUB_Audio_HDI_AudioRenderGetChannelMode_0002
711 * @tc.desc Test GetChannelMode interface,return -1 if getting the parameter render is nullptr
712 * @tc.author: tiansuli
713 */
714 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetChannelMode_0002, TestSize.Level1)
715 {
716 int32_t ret = -1;
717 TestAudioManager* manager = {};
718 struct AudioAdapter *adapter =nullptr;
719 struct AudioRender *renderNull = nullptr;
720 struct AudioRender *render = nullptr;
721 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
722
723 ASSERT_NE(GetAudioManager, nullptr);
724 manager = GetAudioManager();
725 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
726 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
727
728 ret = render->GetChannelMode(renderNull, &mode);
729 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
730
731 render->control.Stop((AudioHandle)render);
732 adapter->DestroyRender(adapter, render);
733 manager->UnloadAdapter(manager, adapter);
734 }
735 /**
736 * @tc.name Test GetChannelMode API via getting the channel mode after the render object is created
737 * @tc.number SUB_Audio_HDI_AudioRenderGetChannelMode_0003
738 * @tc.desc Test GetChannelMode interface,return 0 if getting the channel mode after the object is created
739 * @tc.author: tiansuli
740 */
741 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetChannelMode_0003, TestSize.Level1)
742 {
743 int32_t ret = -1;
744 struct AudioAdapter *adapter = nullptr;
745 struct AudioRender *render = nullptr;
746 TestAudioManager* manager = {};
747 enum AudioPortPin pins = PIN_OUT_SPEAKER;
748 enum AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
749 ASSERT_NE(GetAudioManager, nullptr);
750 manager = GetAudioManager();
751 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
752 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
753 ret = render->GetChannelMode(render, &mode);
754 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
755 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
756
757 adapter->DestroyRender(adapter, render);
758 manager->UnloadAdapter(manager, adapter);
759 }
760 /**
761 * @tc.name Test GetRenderPosition API via legal input
762 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0001
763 * @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition during playing.
764 * @tc.author: tiansuli
765 */
766 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0001, TestSize.Level1)
767 {
768 int32_t ret = -1;
769 uint64_t frames = 0;
770 int64_t timeExp = 0;
771 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
772 struct PrepareAudioPara audiopara = {
773 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
774 .path = AUDIO_FILE.c_str()
775 };
776 ASSERT_NE(GetAudioManager, nullptr);
777 audiopara.manager = GetAudioManager();
778 ASSERT_NE(audiopara.manager, nullptr);
779
780 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
781 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
782 sleep(1);
783 if (audiopara.render != nullptr) {
784 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
785 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
786 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
787 EXPECT_GT(frames, INITIAL_VALUE);
788 }
789
790 ret = ThreadRelease(audiopara);
791 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
792 }
793 /**
794 * @tc.name Test AudioRenderGetRenderPosition API via get RenderPosition after the audio file is Paused and resumed
795 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0002
796 * @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition after Pause and resume during playing
797 * @tc.author: tiansuli
798 */
799 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0002, TestSize.Level1)
800 {
801 int32_t ret = -1;
802 int64_t timeExp = 0;
803 uint64_t frames = 0;
804 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
805 struct PrepareAudioPara audiopara = {
806 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
807 .path = AUDIO_FILE.c_str()
808 };
809 ASSERT_NE(GetAudioManager, nullptr);
810 audiopara.manager = GetAudioManager();
811 ASSERT_NE(audiopara.manager, nullptr);
812
813 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
814 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
815 sleep(1);
816 if (audiopara.render != nullptr) {
817 FrameStatus(0);
818 usleep(1000);
819 ret = audiopara.render->control.Pause((AudioHandle)(audiopara.render));
820 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
821 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
822 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
823 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
824 EXPECT_GT(frames, INITIAL_VALUE);
825 usleep(1000);
826 ret = audiopara.render->control.Resume((AudioHandle)(audiopara.render));
827 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
828 FrameStatus(1);
829 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
830 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
831 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
832 EXPECT_GT(frames, INITIAL_VALUE);
833 }
834
835 ret = ThreadRelease(audiopara);
836 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
837 }
838 /**
839 * @tc.name Test GetRenderPosition API via get RenderPosition after the audio file is stopped
840 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0003
841 * @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition after stop
842 * @tc.author: tiansuli
843 */
844 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0003, TestSize.Level1)
845 {
846 int32_t ret = -1;
847 int64_t timeExp = 0;
848 uint64_t frames = 0;
849 struct AudioAdapter *adapter =nullptr;
850 struct AudioRender *render = nullptr;
851 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
852 ASSERT_NE(GetAudioManager, nullptr);
853 TestAudioManager* manager = GetAudioManager();
854 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
855 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
856 ret = render->control.Stop((AudioHandle)render);
857 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
858
859 ret = render->GetRenderPosition(render, &frames, &time);
860 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
861 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
862 EXPECT_GT(frames, INITIAL_VALUE);
863
864 adapter->DestroyRender(adapter, render);
865 manager->UnloadAdapter(manager, adapter);
866 }
867 /**
868 * @tc.name Test AudioRenderGetRenderPosition API via setting the parameter render is nullptr
869 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0004
870 * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter render is nullptr
871 * @tc.author: tiansuli
872 */
873 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0004, TestSize.Level1)
874 {
875 int32_t ret = -1;
876 uint64_t frames = 0;
877 int64_t timeExp = 0;
878 struct AudioRender *render = nullptr;
879 struct AudioAdapter *adapter =nullptr;
880 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
881
882 ASSERT_NE(GetAudioManager, nullptr);
883 TestAudioManager* manager = GetAudioManager();
884 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
885 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
886 ret = render->GetRenderPosition(render, &frames, &time);
887 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
888 EXPECT_EQ((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
889
890 adapter->DestroyRender(adapter, render);
891 manager->UnloadAdapter(manager, adapter);
892 }
893 /**
894 * @tc.name Test AudioRenderGetRenderPosition API via setting the parameter render is nullptr
895 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0005
896 * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter render is nullptr
897 * @tc.author: tiansuli
898 */
899 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0005, TestSize.Level1)
900 {
901 int32_t ret = -1;
902 uint64_t frames = 0;
903 struct AudioTimeStamp time = {};
904 struct AudioAdapter *adapter =nullptr;
905 struct AudioRender *render = nullptr;
906 struct AudioRender *renderNull = nullptr;
907
908 ASSERT_NE(GetAudioManager, nullptr);
909 TestAudioManager* manager = GetAudioManager();
910 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
911 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
912 ret = render->GetRenderPosition(renderNull, &frames, &time);
913 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
914
915 render->control.Stop((AudioHandle)render);
916 adapter->DestroyRender(adapter, render);
917 manager->UnloadAdapter(manager, adapter);
918 }
919 /**
920 * @tc.name Test AudioRenderGetRenderPosition API via setting the parameter frames is nullptr
921 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0006
922 * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter frames is nullptr
923 * @tc.author: tiansuli
924 */
925 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0006, TestSize.Level1)
926 {
927 int32_t ret = -1;
928 uint64_t *framesNull = nullptr;
929 TestAudioManager* manager = {};
930 struct AudioAdapter *adapter =nullptr;
931 struct AudioRender *render = nullptr;
932 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
933
934 ASSERT_NE(GetAudioManager, nullptr);
935 manager = GetAudioManager();
936 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
937 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
938 ret = render->GetRenderPosition(render, framesNull, &time);
939 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
940
941 render->control.Stop((AudioHandle)render);
942 adapter->DestroyRender(adapter, render);
943 manager->UnloadAdapter(manager, adapter);
944 }
945 /**
946 * @tc.name Test AudioRenderGetRenderPosition API via setting the parameter time is nullptr
947 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0007
948 * @tc.desc Test AudioRenderGetRenderPosition interface, return -1 if setting the parameter time is nullptr
949 * @tc.author: tiansuli
950 */
951 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0007, TestSize.Level1)
952 {
953 int32_t ret = -1;
954 uint64_t frames = 0;
955 TestAudioManager* manager = {};
956 struct AudioAdapter *adapter =nullptr;
957 struct AudioRender *render = nullptr;
958 struct AudioTimeStamp *timeNull = nullptr;
959
960 ASSERT_NE(GetAudioManager, nullptr);
961 manager = GetAudioManager();
962 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
963 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
964
965 ret = render->GetRenderPosition(render, &frames, timeNull);
966 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
967
968 render->control.Stop((AudioHandle)render);
969 adapter->DestroyRender(adapter, render);
970 manager->UnloadAdapter(manager, adapter);
971 }
972 /**
973 * @tc.name Test AudioRenderGetRenderPosition API via get RenderPosition continuously
974 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0008
975 * @tc.desc Test AudioRenderGetRenderPosition interface, return 0 if the GetRenderPosition was called twice
976 * @tc.author: tiansuli
977 */
978 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0008, TestSize.Level1)
979 {
980 int32_t ret = -1;
981 int64_t timeExp = 0;
982 uint64_t frames = 0;
983 TestAudioManager* manager = {};
984 struct AudioAdapter *adapter =nullptr;
985 struct AudioRender *render = nullptr;
986 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
987 ASSERT_NE(GetAudioManager, nullptr);
988 manager = GetAudioManager();
989 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
990 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
991
992 ret = render->GetRenderPosition(render, &frames, &time);
993 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
994 ret = render->GetRenderPosition(render, &frames, &time);
995 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
996 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
997 EXPECT_GT(frames, INITIAL_VALUE);
998
999 render->control.Stop((AudioHandle)render);
1000 adapter->DestroyRender(adapter, render);
1001 manager->UnloadAdapter(manager, adapter);
1002 }
1003 /**
1004 * @tc.name Test GetRenderPosition API via define format to AUDIO_FORMAT_PCM_16_BIT
1005 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0009
1006 * @tc.desc Test GetRenderPosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_16_BIT
1007 * @tc.author: tiansuli
1008 */
1009 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0009, TestSize.Level1)
1010 {
1011 int32_t ret = -1;
1012 struct AudioAdapter *adapter = nullptr;
1013 struct AudioRender *render = nullptr;
1014 enum AudioPortPin pins = PIN_OUT_SPEAKER;
1015 struct AudioSampleAttributes attrs = {};
1016 struct AudioSampleAttributes attrsValue = {};
1017 uint64_t channelCountExp = 2;
1018 uint32_t sampleRateExp = 48000;
1019 uint64_t frames = 0;
1020 int64_t timeExp = 0;
1021 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
1022 TestAudioManager* manager = GetAudioManager();
1023 ASSERT_NE(GetAudioManager, nullptr);
1024 ret = AudioCreateRender(manager, pins, ADAPTER_NAME_USB, &adapter, &render);
1025 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1026 InitAttrs(attrs);
1027 attrs.type = AUDIO_IN_MEDIA;
1028 attrs.interleaved = false;
1029 attrs.format = AUDIO_FORMAT_PCM_16_BIT;
1030 attrs.sampleRate = 48000;
1031 attrs.channelCount = 2;
1032 ret = render->attr.SetSampleAttributes(render, &attrs);
1033 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1034 ret = render->attr.GetSampleAttributes(render, &attrsValue);
1035 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1036 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
1037 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1038 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1039 ret = AudioRenderStartAndOneFrame(render);
1040 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1041 ret = render->GetRenderPosition(render, &frames, &time);
1042 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1043 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
1044 EXPECT_GT(frames, INITIAL_VALUE);
1045 render->control.Stop((AudioHandle)render);
1046 adapter->DestroyRender(adapter, render);
1047 manager->UnloadAdapter(manager, adapter);
1048 }
1049 /**
1050 * @tc.name Test GetRenderPosition API via define format to AUDIO_FORMAT_PCM_24_BIT
1051 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0010
1052 * @tc.desc Test GetRenderPosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_24_BIT
1053 * @tc.author: tiansuli
1054 */
1055 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0010, TestSize.Level1)
1056 {
1057 int32_t ret = -1;
1058 uint64_t frames = 0;
1059 int64_t timeExp = 0;
1060 uint64_t channelCountExp = 2;
1061 uint32_t sampleRateExp = 48000;
1062 struct AudioAdapter *adapter = nullptr;
1063 struct AudioRender *render = nullptr;
1064 struct AudioSampleAttributes attrs = {};
1065 struct AudioSampleAttributes attrsValue = {};
1066 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
1067 ASSERT_NE(GetAudioManager, nullptr);
1068 TestAudioManager* manager = GetAudioManager();
1069 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1070 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1071 InitAttrs(attrs);
1072 attrs.type = AUDIO_IN_MEDIA;
1073 attrs.interleaved = false;
1074 attrs.format = AUDIO_FORMAT_PCM_24_BIT;
1075 attrs.sampleRate = 48000;
1076 attrs.channelCount = 2;
1077 ret = render->attr.SetSampleAttributes(render, &attrs);
1078 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1079 ret = render->attr.GetSampleAttributes(render, &attrsValue);
1080 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1081 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
1082 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1083 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1084 ret = AudioRenderStartAndOneFrame(render);
1085 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1086 ret = render->GetRenderPosition(render, &frames, &time);
1087 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1088 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
1089 EXPECT_GT(frames, INITIAL_VALUE);
1090 render->control.Stop((AudioHandle)render);
1091 adapter->DestroyRender(adapter, render);
1092 manager->UnloadAdapter(manager, adapter);
1093 }
1094 /**
1095 * @tc.name Test GetRenderPosition API via define sampleRate and channelCount to different value
1096 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0011
1097 * @tc.desc Test GetRenderPosition interface,return 0 if get framesize define channelCount as different values
1098 * @tc.author: tiansuli
1099 */
1100 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0011, TestSize.Level1)
1101 {
1102 int32_t ret = -1;
1103 uint64_t frames = 0;
1104 int64_t timeExp = 0;
1105 uint32_t sampleRateExp = 48000;
1106 uint64_t channelCountExp = 1;
1107 struct AudioAdapter *adapter = nullptr;
1108 struct AudioRender *render = nullptr;
1109 struct AudioSampleAttributes attrs = {};
1110 struct AudioSampleAttributes attrsValue = {};
1111 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
1112 ASSERT_NE(GetAudioManager, nullptr);
1113 TestAudioManager* manager = GetAudioManager();
1114 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1115 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1116 InitAttrs(attrs);
1117 attrs.type = AUDIO_IN_MEDIA;
1118 attrs.interleaved = false;
1119 attrs.format = AUDIO_FORMAT_PCM_16_BIT;
1120 attrs.sampleRate = 48000;
1121 attrs.channelCount = 1;
1122 ret = render->attr.SetSampleAttributes(render, &attrs);
1123 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1124 ret = render->attr.GetSampleAttributes(render, &attrsValue);
1125 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1126 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1127 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
1128 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1129 ret = AudioRenderStartAndOneFrame(render);
1130 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1131 ret = render->GetRenderPosition(render, &frames, &time);
1132 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1133 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
1134 EXPECT_GT(frames, INITIAL_VALUE);
1135 render->control.Stop((AudioHandle)render);
1136 adapter->DestroyRender(adapter, render);
1137 manager->UnloadAdapter(manager, adapter);
1138 }
1139 /**
1140 * @tc.name Test GetRenderPosition API via define sampleRate and channelCount to 1
1141 * @tc.number SUB_Audio_HDI_AudioRenderGetRenderPosition_0012
1142 * @tc.desc Test GetRenderPosition interface,return 0 if get framesize define channelCount to 1
1143 * @tc.author: tiansuli
1144 */
1145 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_0012, TestSize.Level1)
1146 {
1147 int32_t ret = -1;
1148 uint64_t frames = 0;
1149 int64_t timeExp = 0;
1150 struct AudioRender *render = nullptr;
1151 struct AudioAdapter *adapter = nullptr;
1152 struct AudioSampleAttributes attrs = {};
1153 struct AudioSampleAttributes attrsValue = {};
1154 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
1155 uint64_t channelCountExp = 1;
1156 uint32_t sampleRateExp = 48000;
1157 ASSERT_NE(GetAudioManager, nullptr);
1158 TestAudioManager* manager = GetAudioManager();
1159 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1160 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1161 InitAttrs(attrs);
1162 attrs.type = AUDIO_IN_MEDIA;
1163 attrs.interleaved = false;
1164 attrs.format = AUDIO_FORMAT_PCM_24_BIT;
1165 attrs.sampleRate = 48000;
1166 attrs.channelCount = 1;
1167 ret = render->attr.SetSampleAttributes(render, &attrs);
1168 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1169 ret = render->attr.GetSampleAttributes(render, &attrsValue);
1170 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1171 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
1172 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1173 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1174 ret = AudioRenderStartAndOneFrame(render);
1175 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1176 ret = render->GetRenderPosition(render, &frames, &time);
1177 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1178 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
1179 EXPECT_GT(frames, INITIAL_VALUE);
1180 render->control.Stop((AudioHandle)render);
1181 adapter->DestroyRender(adapter, render);
1182 manager->UnloadAdapter(manager, adapter);
1183 }
1184 /**
1185 * @tc.name Test ReqMmapBuffer API via legal input
1186 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0001
1187 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface sucessfully
1188 * @tc.author: liweiming
1189 */
1190
1191 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderReqMmapBuffer_0001, TestSize.Level1)
1192 {
1193 int32_t ret = -1;
1194 bool isRender = true;
1195 int32_t reqSize = 0;
1196 struct AudioMmapBufferDescripter desc = {};
1197 struct AudioRender *render = nullptr;
1198 struct AudioAdapter *adapter = nullptr;
1199 struct AudioSampleAttributes attrs = {};
1200 ASSERT_NE(GetAudioManager, nullptr);
1201 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
1202 ASSERT_NE(fp, nullptr);
1203 TestAudioManager* manager = GetAudioManager();
1204 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1205 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1206 if (ret < 0 || render == nullptr) {
1207 fclose(fp);
1208 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1209 ASSERT_EQ(nullptr, render);
1210 }
1211 InitAttrs(attrs);
1212 attrs.startThreshold = 0;
1213 ret = render->attr.SetSampleAttributes(render, &attrs);
1214 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1215 ret = InitMmapDesc(fp, desc, reqSize, isRender);
1216 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1217 ret = render->control.Start((AudioHandle)render);
1218 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1219 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc);
1220 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1221 fclose(fp);
1222 if (ret == 0) {
1223 munmap(desc.memoryAddress, reqSize);
1224 }
1225 render->control.Stop((AudioHandle)render);
1226 adapter->DestroyRender(adapter, render);
1227 manager->UnloadAdapter(manager, adapter);
1228 }
1229 /**
1230 * @tc.name Test ReqMmapBuffer API via setting the incoming parameter reqSize is bigger than
1231 the size of actual audio file
1232 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0002
1233 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsucessfully when setting the
1234 incoming parameter reqSize is bigger than the size of actual audio file
1235 * @tc.author: liweiming
1236 */
1237 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderReqMmapBuffer_0002, TestSize.Level1)
1238 {
1239 int32_t ret = -1;
1240 bool isRender = true;
1241 int32_t reqSize = 0;
1242 struct AudioMmapBufferDescripter desc = {};
1243 struct AudioRender *render = nullptr;
1244 struct AudioAdapter *adapter = nullptr;
1245 ASSERT_NE(GetAudioManager, nullptr);
1246 TestAudioManager *manager = GetAudioManager();
1247 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
1248 ASSERT_NE(fp, nullptr);
1249 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1250 if (ret < 0 || render == nullptr) {
1251 fclose(fp);
1252 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1253 ASSERT_EQ(nullptr, render);
1254 }
1255 ret = InitMmapDesc(fp, desc, reqSize, isRender);
1256 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1257 reqSize = reqSize + BUFFER_LENTH;
1258 ret = render->control.Start((AudioHandle)render);
1259 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1260 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc);
1261 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1262 fclose(fp);
1263 render->control.Stop((AudioHandle)render);
1264 adapter->DestroyRender(adapter, render);
1265 manager->UnloadAdapter(manager, adapter);
1266 }
1267 /**
1268 * @tc.name Test ReqMmapBuffer API via setting the incoming parameter reqSize is smaller than
1269 the size of actual audio file
1270 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0003
1271 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface sucessfully when setting the
1272 incoming parameter reqSize is smaller than the size of actual audio file
1273 * @tc.author: liweiming
1274 */
1275 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderReqMmapBuffer_0003, TestSize.Level1)
1276 {
1277 int32_t ret = -1;
1278 bool isRender = true;
1279 int32_t reqSize = 0;
1280 struct AudioMmapBufferDescripter desc = {};
1281 struct AudioRender *render = nullptr;
1282 struct AudioAdapter *adapter = nullptr;
1283 ASSERT_NE(GetAudioManager, nullptr);
1284 TestAudioManager *manager = GetAudioManager();
1285 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
1286 ASSERT_NE(fp, nullptr);
1287 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1288 if (ret < 0 || render == nullptr) {
1289 fclose(fp);
1290 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1291 ASSERT_EQ(nullptr, render);
1292 }
1293 ret = InitMmapDesc(fp, desc, reqSize, isRender);
1294 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1295 reqSize = reqSize / 2;
1296 ret = render->control.Start((AudioHandle)render);
1297 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1298 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc);
1299 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1300 fclose(fp);
1301 if (ret == 0) {
1302 munmap(desc.memoryAddress, reqSize);
1303 }
1304 render->control.Stop((AudioHandle)render);
1305 adapter->DestroyRender(adapter, render);
1306 manager->UnloadAdapter(manager, adapter);
1307 }
1308 /**
1309 * @tc.name Test ReqMmapBuffer API via setting the incoming parameter reqSize is zero
1310 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0003
1311 * @tc.desc Test ReqMmapBuffer interface,return -1 if call ReqMmapBuffer interface unsucessfully when setting the
1312 incoming parameter reqSize is zero
1313 * @tc.author: liweiming
1314 */
1315 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderReqMmapBuffer_0004, TestSize.Level1)
1316 {
1317 int32_t ret = -1;
1318 bool isRender = true;
1319 int32_t reqSize = 0;
1320 struct AudioMmapBufferDescripter desc = {};
1321 struct AudioRender *render = nullptr;
1322 struct AudioAdapter *adapter = nullptr;
1323 ASSERT_NE(GetAudioManager, nullptr);
1324 TestAudioManager *manager = GetAudioManager();
1325 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
1326 ASSERT_NE(fp, nullptr);
1327 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1328 if (ret < 0 || render == nullptr) {
1329 fclose(fp);
1330 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1331 ASSERT_EQ(nullptr, render);
1332 }
1333 ret = InitMmapDesc(fp, desc, reqSize, isRender);
1334 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1335 reqSize = 0;
1336 ret = render->control.Start((AudioHandle)render);
1337 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1338 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc);
1339 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1340 fclose(fp);
1341 render->control.Stop((AudioHandle)render);
1342 adapter->DestroyRender(adapter, render);
1343 manager->UnloadAdapter(manager, adapter);
1344 }
1345 /**
1346 * @tc.name Test ReqMmapBuffer API via setting the incoming parameter memoryFd of desc is illegal
1347 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0003
1348 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsucessfully when setting the
1349 incoming parameter memoryFd of desc is illegal
1350 * @tc.author: liweiming
1351 */
1352 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderReqMmapBuffer_0005, TestSize.Level1)
1353 {
1354 int32_t ret = -1;
1355 bool isRender = true;
1356 int32_t reqSize = 0;
1357 struct AudioMmapBufferDescripter desc = {};
1358 struct AudioRender *render = nullptr;
1359 struct AudioAdapter *adapter = nullptr;
1360 ASSERT_NE(GetAudioManager, nullptr);
1361 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
1362 ASSERT_NE(fp, nullptr);
1363 TestAudioManager *manager = GetAudioManager();
1364 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1365 if (ret < 0 || render == nullptr) {
1366 fclose(fp);
1367 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1368 ASSERT_EQ(nullptr, render);
1369 }
1370 ret = InitMmapDesc(fp, desc, reqSize, isRender);
1371 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1372 desc.memoryFd = 1;
1373 ret = render->control.Start((AudioHandle)render);
1374 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1375 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, &desc);
1376 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1377 fclose(fp);
1378 render->control.Stop((AudioHandle)render);
1379 adapter->DestroyRender(adapter, render);
1380 manager->UnloadAdapter(manager, adapter);
1381 }
1382 /**
1383 * @tc.name Test ReqMmapBuffer API via the incoming parameter handle is nullptr
1384 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0005
1385 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsucessfully when setting the
1386 incoming parameter handle is nullptr
1387 * @tc.author: liweiming
1388 */
1389 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderReqMmapBuffer_0006, TestSize.Level1)
1390 {
1391 int32_t ret = -1;
1392 bool isRender = true;
1393 int32_t reqSize = 0;
1394 struct AudioMmapBufferDescripter desc = {};
1395 struct AudioRender *render = nullptr;
1396 struct AudioRender *renderNull = nullptr;
1397 struct AudioAdapter *adapter = nullptr;
1398 ASSERT_NE(GetAudioManager, nullptr);
1399 TestAudioManager* manager = GetAudioManager();
1400 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
1401 ASSERT_NE(fp, nullptr);
1402 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1403 if (ret < 0 || render == nullptr) {
1404 fclose(fp);
1405 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1406 ASSERT_EQ(nullptr, render);
1407 }
1408 ret = InitMmapDesc(fp, desc, reqSize, isRender);
1409 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1410 ret = render->control.Start((AudioHandle)render);
1411 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1412 ret = render->attr.ReqMmapBuffer((AudioHandle)renderNull, reqSize, &desc);
1413 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1414 fclose(fp);
1415 render->control.Stop((AudioHandle)render);
1416 adapter->DestroyRender(adapter, render);
1417 manager->UnloadAdapter(manager, adapter);
1418 }
1419 /**
1420 * @tc.name Test ReqMmapBuffer API via the incoming parameter desc is nullptr
1421 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0006
1422 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsucessfully when setting the
1423 incoming parameter desc is nullptr
1424 * @tc.author: liweiming
1425 */
1426 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderReqMmapBuffer_0007, TestSize.Level1)
1427 {
1428 int32_t ret = -1;
1429 bool isRender = true;
1430 int32_t reqSize = 0;
1431 struct AudioMmapBufferDescripter desc = {};
1432 struct AudioMmapBufferDescripter *descNull = nullptr;
1433 struct AudioRender *render = nullptr;
1434 struct AudioAdapter *adapter = nullptr;
1435 ASSERT_NE(GetAudioManager, nullptr);
1436 TestAudioManager* manager = GetAudioManager();
1437 FILE *fp = fopen(LOW_LATENCY_AUDIO_FILE.c_str(), "rb+");
1438 ASSERT_NE(fp, nullptr);
1439 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
1440 if (ret < 0 || render == nullptr) {
1441 fclose(fp);
1442 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1443 ASSERT_EQ(nullptr, render);
1444 }
1445 ret = InitMmapDesc(fp, desc, reqSize, isRender);
1446 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1447 ret = render->control.Start((AudioHandle)render);
1448 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1449 ret = render->attr.ReqMmapBuffer((AudioHandle)render, reqSize, descNull);
1450 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1451 fclose(fp);
1452 render->control.Stop((AudioHandle)render);
1453 adapter->DestroyRender(adapter, render);
1454 manager->UnloadAdapter(manager, adapter);
1455 }
1456 /**
1457 * @tc.name Test GetMmapPosition API via Getting position is normal in Before playing and Playing.
1458 * @tc.number SUB_Audio_HDI_RenderGetMmapPosition_0001
1459 * @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully.
1460 * @tc.author: zhouyongxiao
1461 */
1462 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderGetMmapPosition_0001, TestSize.Level1)
1463 {
1464 uint64_t frames = 0;
1465 uint64_t framesRendering = 0;
1466 uint64_t framesexpRender = 0;
1467 int64_t timeExp = 0;
1468 struct PrepareAudioPara audiopara = {
1469 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER,
1470 .path = LOW_LATENCY_AUDIO_FILE.c_str()
1471 };
1472 ASSERT_NE(GetAudioManager, nullptr);
1473 audiopara.manager = GetAudioManager();
1474 ASSERT_NE(audiopara.manager, nullptr);
1475 int32_t ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1476 &audiopara.render);
1477 if (ret < 0 || audiopara.render == nullptr) {
1478 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1479 ASSERT_EQ(nullptr, audiopara.render);
1480 }
1481 InitAttrs(audiopara.attrs);
1482 audiopara.attrs.startThreshold = 0;
1483 ret = audiopara.render->attr.SetSampleAttributes(audiopara.render, &(audiopara.attrs));
1484 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1485 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &frames, &(audiopara.time));
1486 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1487 EXPECT_EQ((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1488 EXPECT_EQ(frames, INITIAL_VALUE);
1489
1490 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayMapAudioFile, &audiopara);
1491 if (ret != 0) {
1492 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1493 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1494 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1495 }
1496 sleep(1);
1497 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &framesRendering, &(audiopara.time));
1498 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1499 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1500 EXPECT_GT(framesRendering, INITIAL_VALUE);
1501 int64_t timeExprendering = (audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec);
1502 void *result = nullptr;
1503 pthread_join(audiopara.tids, &result);
1504 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
1505 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &framesexpRender, &(audiopara.time));
1506 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1507 EXPECT_GE((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExprendering);
1508 EXPECT_GE(framesexpRender, framesRendering);
1509 audiopara.render->control.Stop((AudioHandle)audiopara.render);
1510 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1511 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1512 }
1513 /**
1514 * @tc.name Test GetMmapPosition API via SetSampleAttributes and Getting position is normal.
1515 * @tc.number SUB_Audio_HDI_RenderGetMmapPosition_0002
1516 * @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully.
1517 * @tc.author: zhouyongxiao
1518 */
1519 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderGetMmapPosition_0002, TestSize.Level1)
1520 {
1521 int32_t ret = -1;
1522 uint64_t frames = 0;
1523 int64_t timeExp = 0;
1524 struct PrepareAudioPara audiopara = {
1525 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
1526 .path = LOW_LATENCY_AUDIO_FILE.c_str()
1527 };
1528 ASSERT_NE(GetAudioManager, nullptr);
1529 audiopara.manager = GetAudioManager();
1530 ASSERT_NE(audiopara.manager, nullptr);
1531 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1532 &audiopara.render);
1533 if (ret < 0 || audiopara.render == nullptr) {
1534 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1535 ASSERT_EQ(nullptr, audiopara.render);
1536 }
1537 InitAttrs(audiopara.attrs);
1538 audiopara.attrs.format = AUDIO_FORMAT_PCM_24_BIT;
1539 audiopara.attrs.channelCount = 1;
1540 ret = audiopara.render->attr.SetSampleAttributes(audiopara.render, &(audiopara.attrs));
1541 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1542
1543 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayMapAudioFile, &audiopara);
1544 if (ret != 0) {
1545 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1546 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1547 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1548 }
1549
1550 void *result = nullptr;
1551 pthread_join(audiopara.tids, &result);
1552 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
1553 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &frames, &(audiopara.time));
1554 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1555 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1556 EXPECT_GT(frames, INITIAL_VALUE);
1557 audiopara.render->control.Stop((AudioHandle)audiopara.render);
1558 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1559 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1560 }
1561 /**
1562 * @tc.name Test ReqMmapBuffer API via inputtint frame is nullptr.
1563 * @tc.number SUB_Audio_HDI_RenderGetMmapPosition_0003
1564 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
1565 * @tc.author: zhouyongxiao
1566 */
1567 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderGetMmapPosition_0003, TestSize.Level1)
1568 {
1569 int32_t ret = -1;
1570 uint64_t *frames = nullptr;
1571 struct PrepareAudioPara audiopara = {
1572 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
1573 .path = LOW_LATENCY_AUDIO_FILE.c_str()
1574 };
1575 ASSERT_NE(GetAudioManager, nullptr);
1576 audiopara.manager = GetAudioManager();
1577 ASSERT_NE(audiopara.manager, nullptr);
1578 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1579 &audiopara.render);
1580 if (ret < 0 || audiopara.render == nullptr) {
1581 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1582 ASSERT_EQ(nullptr, audiopara.render);
1583 }
1584
1585 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, frames, &(audiopara.time));
1586 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1587
1588 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1589 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1590 }
1591 /**
1592 * @tc.name Test ReqMmapBuffer API via inputtint time is nullptr.
1593 * @tc.number SUB_Audio_HDI_RenderGetMmapPosition_0004
1594 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
1595 * @tc.author: zhouyongxiao
1596 */
1597 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderGetMmapPosition_0004, TestSize.Level1)
1598 {
1599 int32_t ret = -1;
1600 uint64_t frames = 0;
1601 struct AudioTimeStamp *time = nullptr;
1602 struct PrepareAudioPara audiopara = {
1603 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
1604 .path = LOW_LATENCY_AUDIO_FILE.c_str()
1605 };
1606 ASSERT_NE(GetAudioManager, nullptr);
1607 audiopara.manager = GetAudioManager();
1608 ASSERT_NE(audiopara.manager, nullptr);
1609 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1610 &audiopara.render);
1611 if (ret < 0 || audiopara.render == nullptr) {
1612 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1613 ASSERT_EQ(nullptr, audiopara.render);
1614 }
1615
1616 ret = audiopara.render->attr.GetMmapPosition(audiopara.render, &frames, time);
1617 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1618
1619 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1620 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1621 }
1622 /**
1623 * @tc.name Test ReqMmapBuffer API via inputtint render is nullptr.
1624 * @tc.number SUB_Audio_HDI_RenderGetMmapPosition_0005
1625 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
1626 * @tc.author: zhouyongxiao
1627 */
1628 HWTEST_F(AudioHdiRenderTest, SUB_Audio_HDI_RenderGetMmapPosition_0005, TestSize.Level1)
1629 {
1630 int32_t ret = -1;
1631 uint64_t frames = 0;
1632 struct AudioRender *renderNull = nullptr;
1633 struct PrepareAudioPara audiopara = {
1634 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
1635 .path = LOW_LATENCY_AUDIO_FILE.c_str()
1636 };
1637 ASSERT_NE(GetAudioManager, nullptr);
1638 audiopara.manager = GetAudioManager();
1639 ASSERT_NE(audiopara.manager, nullptr);
1640 ret = AudioCreateRender(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1641 &audiopara.render);
1642 if (ret < 0 || audiopara.render == nullptr) {
1643 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1644 ASSERT_EQ(nullptr, audiopara.render);
1645 }
1646
1647 ret = audiopara.render->attr.GetMmapPosition(renderNull, &frames, &(audiopara.time));
1648 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1649
1650 audiopara.adapter->DestroyRender(audiopara.adapter, audiopara.render);
1651 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1652 }
1653 }