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_scene_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 AudioHdiRenderSceneTest : 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 GetManager(struct PrepareAudioPara& audiopara);
61 };
62
63 using THREAD_FUNC = void *(*)(void *);
64
65 TestAudioManager *(*AudioHdiRenderSceneTest::GetAudioManager)() = nullptr;
66 void *AudioHdiRenderSceneTest::handleSo = nullptr;
67 #ifdef AUDIO_MPI_SO
68 int32_t (*AudioHdiRenderSceneTest::SdkInit)() = nullptr;
69 void (*AudioHdiRenderSceneTest::SdkExit)() = nullptr;
70 void *AudioHdiRenderSceneTest::sdkSo = nullptr;
71 #endif
72
SetUpTestCase(void)73 void AudioHdiRenderSceneTest::SetUpTestCase(void)
74 {
75 #ifdef AUDIO_MPI_SO
76 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
77 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
78 if (sdkSo == nullptr) {
79 return;
80 }
81 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
82 if (SdkInit == nullptr) {
83 return;
84 }
85 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
86 if (SdkExit == nullptr) {
87 return;
88 }
89 SdkInit();
90 #endif
91 char absPath[PATH_MAX] = {0};
92 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
93 return;
94 }
95 handleSo = dlopen(absPath, RTLD_LAZY);
96 if (handleSo == nullptr) {
97 return;
98 }
99 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
100 if (GetAudioManager == nullptr) {
101 return;
102 }
103 }
104
TearDownTestCase(void)105 void AudioHdiRenderSceneTest::TearDownTestCase(void)
106 {
107 #ifdef AUDIO_MPI_SO
108 SdkExit();
109 if (sdkSo != nullptr) {
110 dlclose(sdkSo);
111 sdkSo = nullptr;
112 }
113 if (SdkInit != nullptr) {
114 SdkInit = nullptr;
115 }
116 if (SdkExit != nullptr) {
117 SdkExit = nullptr;
118 }
119 #endif
120 if (handleSo != nullptr) {
121 dlclose(handleSo);
122 handleSo = nullptr;
123 }
124 if (GetAudioManager != nullptr) {
125 GetAudioManager = nullptr;
126 }
127 }
128
SetUp(void)129 void AudioHdiRenderSceneTest::SetUp(void) {}
130
TearDown(void)131 void AudioHdiRenderSceneTest::TearDown(void) {}
132
GetManager(struct PrepareAudioPara & audiopara)133 int32_t AudioHdiRenderSceneTest::GetManager(struct PrepareAudioPara& audiopara)
134 {
135 auto *inst = (AudioHdiRenderSceneTest *)audiopara.self;
136 if (inst != nullptr && inst->GetAudioManager != nullptr) {
137 audiopara.manager = inst->GetAudioManager();
138 }
139 if (audiopara.manager == nullptr) {
140 return HDF_FAILURE;
141 }
142 return HDF_SUCCESS;
143 }
144 /**
145 * @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability
146 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0001
147 * @tc.desc Test AudioRenderCheckSceneCapability interface,return 0 if check scene's capability successful.
148 * @tc.author: ZHANGHAILIN
149 */
150 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0001, TestSize.Level1)
151 {
152 int32_t ret = -1;
153 bool supported = false;
154 struct AudioSceneDescriptor scenes = {};
155 struct AudioAdapter *adapter = nullptr;
156 struct AudioRender *render = nullptr;
157 ASSERT_NE(nullptr, GetAudioManager);
158 TestAudioManager* manager = GetAudioManager();
159 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
160 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
161
162 scenes.scene.id = 0;
163 scenes.desc.pins = PIN_OUT_SPEAKER;
164 ret = render->scene.CheckSceneCapability(render, &scenes, &supported);
165 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
166 EXPECT_TRUE(supported);
167
168 adapter->DestroyRender(adapter, render);
169 manager->UnloadAdapter(manager, adapter);
170 }
171 /**
172 * @tc.name Test checking scene's capability where the scene is not configed in the josn.
173 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0002
174 * @tc.desc Test RenderCheckSceneCapability interface,return -1 if the scene is not configed in the josn.
175 * @tc.author: ZHANGHAILIN
176 */
177 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0002, TestSize.Level1)
178 {
179 int32_t ret = -1;
180 bool supported = true;
181 struct AudioSceneDescriptor scenes = {};
182 struct AudioAdapter *adapter = nullptr;
183 struct AudioRender *render = nullptr;
184 ASSERT_NE(nullptr, GetAudioManager);
185 TestAudioManager* manager = GetAudioManager();
186 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
187 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
188
189 scenes.scene.id = 5;
190 scenes.desc.pins = PIN_OUT_SPEAKER;
191 ret = render->scene.CheckSceneCapability(render, &scenes, &supported);
192 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
193
194 adapter->DestroyRender(adapter, render);
195 manager->UnloadAdapter(manager, adapter);
196 }
197 /**
198 * @tc.name Test checking scene's capability where the render is empty
199 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0003
200 * @tc.desc Test AudioRenderCheckSceneCapability,return -1 if the render is empty.
201 * @tc.author: ZHANGHAILIN
202 */
203 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0003, TestSize.Level1)
204 {
205 int32_t ret = -1;
206 bool supported = true;
207 struct AudioSceneDescriptor scenes = {};
208 struct AudioAdapter *adapter = nullptr;
209 struct AudioRender *render = nullptr;
210 struct AudioRender *renderNull = nullptr;
211 ASSERT_NE(nullptr, GetAudioManager);
212 TestAudioManager* manager = GetAudioManager();
213 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
214 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
215
216 scenes.scene.id = 0;
217 scenes.desc.pins = PIN_OUT_SPEAKER;
218 ret = render->scene.CheckSceneCapability(renderNull, &scenes, &supported);
219 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
220
221 adapter->DestroyRender(adapter, render);
222 manager->UnloadAdapter(manager, adapter);
223 }
224 /**
225 * @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability
226 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0004
227 * @tc.desc Test AudioRenderCheckSceneCapability interface,return -1 if the scene is empty.
228 * @tc.author: ZHANGHAILIN
229 */
230 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0004, TestSize.Level1)
231 {
232 int32_t ret = -1;
233 bool supported = true;
234 struct AudioSceneDescriptor *scenes = nullptr;
235 struct AudioAdapter *adapter = nullptr;
236 struct AudioRender *render = nullptr;
237 ASSERT_NE(nullptr, GetAudioManager);
238 TestAudioManager* manager = GetAudioManager();
239 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
240 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
241
242 ret = render->scene.CheckSceneCapability(render, scenes, &supported);
243 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
244
245 adapter->DestroyRender(adapter, render);
246 manager->UnloadAdapter(manager, adapter);
247 }
248 /**
249 * @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability
250 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0005
251 * @tc.desc Test AudioRenderCheckSceneCapability interface,return -1 if the supported is empty.
252 * @tc.author: ZHANGHAILIN
253 */
254 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0005, TestSize.Level1)
255 {
256 int32_t ret = -1;
257 struct AudioSceneDescriptor scenes = {};
258 struct AudioAdapter *adapter = nullptr;
259 struct AudioRender *render = nullptr;
260 ASSERT_NE(nullptr, GetAudioManager);
261 TestAudioManager* manager = GetAudioManager();
262 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
263 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
264
265 scenes.scene.id = 0;
266 scenes.desc.pins = PIN_OUT_SPEAKER;
267 ret = render->scene.CheckSceneCapability(render, &scenes, nullptr);
268 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
269
270 adapter->DestroyRender(adapter, render);
271 manager->UnloadAdapter(manager, adapter);
272 }
273 /**
274 * @tc.name Test AudioRenderSelectScene API via legal input
275 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0001
276 * @tc.desc Test AudioRenderSelectScene interface,return 0 if select Render's scene successful.
277 * @tc.author: ZHANGHAILIN
278 */
279 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0001, TestSize.Level1)
280 {
281 int32_t ret = -1;
282 struct AudioSceneDescriptor scenes = {};
283 struct AudioAdapter *adapter = nullptr;
284 struct AudioRender *render = nullptr;
285 ASSERT_NE(nullptr, GetAudioManager);
286 TestAudioManager* manager = GetAudioManager();
287 scenes.scene.id = 0;
288 scenes.desc.pins = PIN_OUT_SPEAKER;
289
290 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
291 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
292
293 ret = render->scene.SelectScene(render, &scenes);
294 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
295
296 ret = AudioRenderStartAndOneFrame(render);
297 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
298
299 ret = render->control.Stop((AudioHandle)render);
300 adapter->DestroyRender(adapter, render);
301 manager->UnloadAdapter(manager, adapter);
302 }
303 /**
304 * @tc.name Test AudioRenderSelectScene API after Render start.
305 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0002
306 * @tc.desc Test AudioRenderSelectScene, return 0 if select Render's scene successful after Render start.
307 * @tc.author: ZHANGHAILIN
308 */
309 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0002, TestSize.Level1)
310 {
311 int32_t ret = -1;
312 struct AudioSceneDescriptor scenes = {};
313 TestAudioManager* manager = {};
314 struct AudioAdapter *adapter =nullptr;
315 struct AudioRender *render = nullptr;
316 ASSERT_NE(nullptr, GetAudioManager);
317 manager = GetAudioManager();
318 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
319 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
320
321 scenes.scene.id = 0;
322 scenes.desc.pins = PIN_OUT_SPEAKER;
323 ret = render->scene.SelectScene(render, &scenes);
324 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
325
326 ret = render->control.Stop((AudioHandle)render);
327 adapter->DestroyRender(adapter, render);
328 manager->UnloadAdapter(manager, adapter);
329 }
330 /**
331 * @tc.name Test AudioRenderSelectScene API where the parameter handle is empty.
332 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0003
333 * @tc.desc Test AudioRenderSelectScene, return -1 if the parameter handle is empty.
334 * @tc.author: ZHANGHAILIN
335 */
336 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0003, TestSize.Level1)
337 {
338 int32_t ret = -1;
339 struct AudioSceneDescriptor scenes = {};
340 struct AudioAdapter *adapter = nullptr;
341 struct AudioRender *render = nullptr;
342 struct AudioRender *renderNull = nullptr;
343 ASSERT_NE(nullptr, GetAudioManager);
344 TestAudioManager* manager = GetAudioManager();
345 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
346 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
347
348 scenes.scene.id = 0;
349 scenes.desc.pins = PIN_IN_MIC;
350 ret = render->scene.SelectScene(renderNull, &scenes);
351 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
352
353 adapter->DestroyRender(adapter, render);
354 manager->UnloadAdapter(manager, adapter);
355 }
356 /**
357 * @tc.name Test AudioRenderSelectScene API where the parameter scene is empty.
358 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0004
359 * @tc.desc Test AudioRenderSelectScene, return -1 if the parameter scene is empty.
360 * @tc.author: ZHANGHAILIN
361 */
362 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0004, TestSize.Level1)
363 {
364 int32_t ret = -1;
365 struct AudioSceneDescriptor *scenes = nullptr;
366 struct AudioAdapter *adapter = nullptr;
367 struct AudioRender *render = nullptr;
368 ASSERT_NE(nullptr, GetAudioManager);
369 TestAudioManager* manager = GetAudioManager();
370 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
371 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
372
373 ret = render->scene.SelectScene(render, scenes);
374 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
375
376 adapter->DestroyRender(adapter, render);
377 manager->UnloadAdapter(manager, adapter);
378 }
379 /**
380 * @tc.name Test AudioRenderSelectScene API where the scene is not configed in the josn.
381 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0005
382 * @tc.desc Test AudioRenderSelectScene, return -1 if the scene is not configed in the josn.
383 * @tc.author: ZHANGHAILIN
384 */
385 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0005, TestSize.Level1)
386 {
387 int32_t ret = -1;
388 struct AudioSceneDescriptor scenes = {};
389 struct AudioAdapter *adapter = nullptr;
390 struct AudioRender *render = nullptr;
391 ASSERT_NE(nullptr, GetAudioManager);
392 TestAudioManager* manager = GetAudioManager();
393 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
394 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
395
396 scenes.scene.id = 5;
397 scenes.desc.pins = PIN_OUT_HDMI;
398 ret = render->scene.SelectScene(render, &scenes);
399 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
400
401 adapter->DestroyRender(adapter, render);
402 manager->UnloadAdapter(manager, adapter);
403 }
404 #ifdef AUDIO_ADM_SO
405 /**
406 * @tc.name Test AudioRenderTurnStandbyMode API via input "AUDIO_FLUSH_COMPLETED"
407 * @tc.number SUB_Audio_HDI_AudioRenderRegCallback_0001
408 * @tc.desc Test AudioRenderTurnStandbyMode interface,return 0 if the interface use correctly.
409 * @tc.author: ZHANGHAILIN
410 */
411 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderRegCallback_0001, TestSize.Level1)
412 {
413 int32_t ret = -1;
414 struct AudioAdapter *adapter = nullptr;
415 struct AudioRender *render = nullptr;
416
417 ASSERT_NE(GetAudioManager, nullptr);
418 TestAudioManager* manager = GetAudioManager();
419 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
420 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
421
422 ret = render->RegCallback(render, AudioRenderCallback, nullptr);
423 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
424
425 ret = render->control.Flush((AudioHandle)render);
426 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
427
428 ret = CheckFlushValue();
429 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
430
431 adapter->DestroyRender(adapter, render);
432 manager->UnloadAdapter(manager, adapter);
433 }
434
435 /**
436 * @tc.name Test AudioRenderRegCallback API via input "AUDIO_NONBLOCK_WRITE_COMPELETED"
437 * @tc.number SUB_Audio_HDI_AudioRenderRegCallback_0002
438 * @tc.desc Test AudioRenderRegCallback interface,return 0 if the interface use correctly.
439 * @tc.author: ZHANGHAILIN
440 */
441 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderRegCallback_0002, TestSize.Level1)
442 {
443 int32_t ret = -1;
444 struct AudioAdapter *adapter = nullptr;
445 struct AudioRender *render = nullptr;
446 struct AudioSampleAttributes attrs;
447 struct AudioHeadInfo headInfo;
448 char absPath[PATH_MAX] = {0};
449 realpath(AUDIO_FILE.c_str(), absPath);
450 ASSERT_NE(realpath(AUDIO_FILE.c_str(), absPath), nullptr);
451
452 FILE *file = fopen(absPath, "rb");
453 ASSERT_NE(file, nullptr);
454 ASSERT_NE(GetAudioManager, nullptr);
455 TestAudioManager* manager = GetAudioManager();
456 ret = WavHeadAnalysis(headInfo, file, attrs);
457 if (ret < 0) {
458 fclose(file);
459 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
460 }
461 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
462 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
463
464 ret = render->RegCallback(render, AudioRenderCallback, nullptr);
465 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
466
467 ret = FrameStart(headInfo, render, file, attrs);
468 if (ret < 0) {
469 adapter->DestroyRender(adapter, render);
470 manager->UnloadAdapter(manager, adapter);
471 fclose(file);
472 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
473 }
474
475 ret = CheckWriteCompleteValue();
476 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
477 ret = CheckRenderFullValue();
478 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
479
480 adapter->DestroyRender(adapter, render);
481 manager->UnloadAdapter(manager, adapter);
482 fclose(file);
483 }
484 /**
485 * @tc.name Test AudioRenderTurnStandbyMode API via
486 * @tc.number SUB_Audio_HDI_AudioRenderTurnStandbyMode_0001
487 * @tc.desc Test AudioRenderTurnStandbyMode interface,return 0 if the interface use correctly.
488 * @tc.author: ZHANGHAILIN
489 */
490 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderTurnStandbyMode_0001, TestSize.Level1)
491 {
492 int32_t ret = -1;
493 struct AudioAdapter *adapter = nullptr;
494 struct AudioRender *render = nullptr;
495 ASSERT_NE(GetAudioManager, nullptr);
496 TestAudioManager* manager = GetAudioManager();
497 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
498 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
499
500 ret = render->control.TurnStandbyMode((AudioHandle)render);
501 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
502
503 sleep(3);
504
505 ret = render->control.Stop((AudioHandle)render);
506 adapter->DestroyRender(adapter, render);
507 manager->UnloadAdapter(manager, adapter);
508 }
509 /**
510 * @tc.name Test AudioRenderAudioDevDump API via
511 * @tc.number SUB_Audio_HDI_AudioRenderAudioDevDump_0001
512 * @tc.desc Test AudioRenderAudioDevDump interface,return 0 if the interface use correctly.
513 * @tc.author: ZHANGHAILIN
514 */
515 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderAudioDevDump_0001, TestSize.Level1)
516 {
517 int32_t ret = -1;
518 char pathBuf[] = "./DevDump.log";
519 FILE *fp = fopen(pathBuf, "wb+");
520 ASSERT_NE(nullptr, fp);
521 int fd = fileno(fp);
522 if (fd == -1) {
523 fclose(fp);
524 ASSERT_NE(fd, -1);
525 }
526 struct PrepareAudioPara audiopara = {
527 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
528 .path = AUDIO_FILE.c_str()
529 };
530 ret = GetManager(audiopara);
531 if (ret < 0) {
532 fclose(fp);
533 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
534 }
535 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
536 if (ret < 0) {
537 fclose(fp);
538 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
539 }
540 sleep(1);
541 ret = audiopara.render->control.Pause((AudioHandle)audiopara.render);
542 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
543 sleep(1);
544 ret = audiopara.render->control.Resume((AudioHandle)audiopara.render);
545 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
546 ret = audiopara.render->control.AudioDevDump((AudioHandle)audiopara.render, RANGE, fd);
547 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
548 fclose(fp);
549 ret = ThreadRelease(audiopara);
550 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
551 }
552 #endif
553 }