1 /*
2 * Copyright (c) 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 #include <gtest/gtest.h>
17 #include "hdi_service_common.h"
18
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Audio;
22
23 namespace {
24 class AudioIdlHdiRenderControlTest : public testing::Test {
25 public:
26 static void SetUpTestCase(void);
27 static void TearDownTestCase(void);
28 void SetUp();
29 void TearDown();
30 struct IAudioRender *render = nullptr;
31 struct IAudioAdapter *adapter = nullptr;
32 static TestAudioManager *manager;
33 };
34
35 TestAudioManager *AudioIdlHdiRenderControlTest::manager = nullptr;
36 using THREAD_FUNC = void *(*)(void *);
37
SetUpTestCase(void)38 void AudioIdlHdiRenderControlTest::SetUpTestCase(void)
39 {
40 manager = IAudioManagerGet(IS_STUB);
41 ASSERT_NE(nullptr, manager);
42 }
43
TearDownTestCase(void)44 void AudioIdlHdiRenderControlTest::TearDownTestCase(void)
45 {
46 if (manager != nullptr) {
47 (void)IAudioManagerRelease(manager, IS_STUB);
48 }
49 }
50
SetUp(void)51 void AudioIdlHdiRenderControlTest::SetUp(void)
52 {
53 ASSERT_NE(nullptr, manager);
54 int32_t ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
55 ASSERT_EQ(HDF_SUCCESS, ret);
56 }
57
TearDown(void)58 void AudioIdlHdiRenderControlTest::TearDown(void)
59 {
60 int32_t ret = ReleaseRenderSource(manager, adapter, render);
61 ASSERT_EQ(HDF_SUCCESS, ret);
62 }
63
64 /**
65 * @tc.name AudioRenderStart_001
66 * @tc.desc Test AudioRenderStart interface,return 0 if the audiorender object is created successfully.
67 * @tc.type: FUNC
68 */
69 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderStart_001, TestSize.Level1)
70 {
71 int32_t ret = -1;
72
73 ASSERT_NE(nullptr, render);
74 ret = render->Start(render);
75 EXPECT_EQ(HDF_SUCCESS, ret);
76
77 ret = render->Stop(render);
78 EXPECT_EQ(HDF_SUCCESS, ret);
79 }
80 /**
81 * @tc.name AudioRenderStartNull_002
82 * @tc.desc Test AudioRenderStart interface, return -3/-4 if the incoming parameter handle is nullptr
83 * @tc.type: FUNC
84 */
85 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderStartNull_002, TestSize.Level1)
86 {
87 int32_t ret = -1;
88 struct IAudioRender *renderNull = nullptr;
89
90 ASSERT_NE(nullptr, render);
91 ret = render->Start(renderNull);
92 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
93 }
94 /**
95 * @tc.name AudioRenderStart_003
96 * @tc.desc Test AudioRenderStart interface,return -7003 the second time if the RenderStart is called twice
97 * @tc.type: FUNC
98 */
99 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderStart_003, TestSize.Level1)
100 {
101 int32_t ret = -1;
102
103 ASSERT_NE(nullptr, render);
104 ret = render->Start(render);
105 EXPECT_EQ(HDF_SUCCESS, ret);
106 ret = render->Start(render);
107 EXPECT_EQ(AUDIO_HAL_ERR_AO_BUSY, ret);
108
109 ret = render->Stop(render);
110 EXPECT_EQ(HDF_SUCCESS, ret);
111 }
112 /**
113 * @tc.name AudioRenderStop_001
114 * @tc.desc test AudioRenderStop interface. return 0 if the rendering is successfully stopped.
115 * @tc.type: FUNC
116 */
117 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderStop_001, TestSize.Level1)
118 {
119 int32_t ret = -1;
120
121 ASSERT_NE(nullptr, render);
122 ret = render->Start(render);
123 EXPECT_EQ(HDF_SUCCESS, ret);
124 ret = render->Stop(render);
125 EXPECT_EQ(HDF_SUCCESS, ret);
126 }
127 /**
128 * @tc.name AudioRenderStop_002
129 * @tc.desc test AudioRenderStop interface. return -4 if the render does not start and stop only
130 * @tc.type: FUNC
131 */
132 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderStop_002, TestSize.Level1)
133 {
134 int32_t ret = -1;
135
136 ASSERT_NE(nullptr, render);
137 ret = render->Stop(render);
138 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
139 }
140 /**
141 * @tc.name AudioRenderStop_003
142 * @tc.desc Test RenderStop interface,return -4 the second time if the RenderStop is called twice
143 * @tc.type: FUNC
144 */
145 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderStop_003, TestSize.Level1)
146 {
147 int32_t ret = -1;
148
149 ASSERT_NE(nullptr, render);
150 ret = render->Start(render);
151 EXPECT_EQ(HDF_SUCCESS, ret);
152 ret = render->Stop(render);
153 EXPECT_EQ(HDF_SUCCESS, ret);
154 ret = render->Stop(render);
155 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
156 }
157 /**
158 * @tc.name AudioRenderStopNull_004
159 * @tc.desc Test RenderStop interface, return -3/-4 if the incoming parameter handle is nullptr
160 * @tc.type: FUNC
161 */
162 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderStopNull_004, TestSize.Level1)
163 {
164 int32_t ret = -1;
165 struct IAudioRender *renderNull = nullptr;
166
167 ASSERT_NE(nullptr, render);
168 ret = render->Start(render);
169 EXPECT_EQ(HDF_SUCCESS, ret);
170 ret = render->Stop(renderNull);
171 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
172
173 ret = render->Stop(render);
174 EXPECT_EQ(HDF_SUCCESS, ret);
175 }
176 /**
177 * @tc.name AudioRenderPause_01
178 * @tc.desc test HDI RenderPause interface，return 0 if the render is paused after start
179 * @tc.type: FUNC
180 */
181 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderPause_001, TestSize.Level1)
182 {
183 int32_t ret = -1;
184
185 ASSERT_NE(nullptr, render);
186 ret = AudioRenderStartAndOneFrame(render);
187 EXPECT_EQ(HDF_SUCCESS, ret);
188
189 ret = render->Pause(render);
190 EXPECT_EQ(HDF_SUCCESS, ret);
191
192 ret = render->Stop(render);
193 EXPECT_EQ(HDF_SUCCESS, ret);
194 }
195 /**
196 * @tc.name AudioRenderPause_002
197 * @tc.desc Test AudioRenderPause interface, return -1 the second time if RenderPause is called twice
198 * @tc.type: FUNC
199 */
200 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderPause_002, TestSize.Level1)
201 {
202 int32_t ret = -1;
203
204 ASSERT_NE(nullptr, render);
205 ret = AudioRenderStartAndOneFrame(render);
206 EXPECT_EQ(HDF_SUCCESS, ret);
207
208 ret = render->Pause(render);
209 EXPECT_EQ(HDF_SUCCESS, ret);
210 ret = render->Pause(render);
211 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
212 render->Stop(render);
213 }
214 /**
215 * @tc.name AudioRenderPause_003
216 * @tc.desc Test AudioRenderPause interface,return -1 if the render is paused after created.
217 * @tc.type: FUNC
218 */
219 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderPause_003, TestSize.Level1)
220 {
221 int32_t ret = -1;
222
223 ASSERT_NE(nullptr, render);
224 ret = render->Pause(render);
225 EXPECT_EQ(HDF_FAILURE, ret);
226 }
227 /**
228 * @tc.name AudioRenderPause_004
229 * @tc.desc Test AudioRenderPause interface,return 0 if the render is paused after resumed.
230 * @tc.type: FUNC
231 */
232 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderPause_004, TestSize.Level1)
233 {
234 int32_t ret = -1;
235
236 ASSERT_NE(nullptr, render);
237 ret = AudioRenderStartAndOneFrame(render);
238 EXPECT_EQ(HDF_SUCCESS, ret);
239
240 ret = render->Pause(render);
241 EXPECT_EQ(HDF_SUCCESS, ret);
242 ret = render->Resume(render);
243 EXPECT_EQ(HDF_SUCCESS, ret);
244 ret = render->Pause(render);
245 EXPECT_EQ(HDF_SUCCESS, ret);
246
247 ret = render->Stop(render);
248 EXPECT_EQ(HDF_SUCCESS, ret);
249 }
250 /**
251 * @tc.name AudioRenderPause_005
252 * @tc.desc Test AudioRenderPause interface, return -1 the render is paused after stopped.
253 * @tc.type: FUNC
254 */
255 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderPause_005, TestSize.Level1)
256 {
257 int32_t ret = -1;
258
259 ASSERT_NE(nullptr, render);
260 ret = AudioRenderStartAndOneFrame(render);
261 EXPECT_EQ(HDF_SUCCESS, ret);
262
263 ret = render->Stop(render);
264 ASSERT_EQ(HDF_SUCCESS, ret);
265 ret = render->Pause(render);
266 EXPECT_EQ(HDF_FAILURE, ret);
267 }
268 /**
269 * @tc.name AudioRenderPauseNull_006
270 * @tc.desc Test RenderPause interface, return -3/-4 if the incoming parameter handle is nullptr
271 * @tc.type: FUNC
272 */
273 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderPauseNull_006, TestSize.Level1)
274 {
275 int32_t ret = -1;
276 struct IAudioRender *renderNull = nullptr;
277
278 ASSERT_NE(nullptr, render);
279 ret = AudioRenderStartAndOneFrame(render);
280 EXPECT_EQ(HDF_SUCCESS, ret);
281
282 ret = render->Pause(renderNull);
283 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
284
285 ret = render->Stop(render);
286 EXPECT_EQ(HDF_SUCCESS, ret);
287 }
288 /**
289 * @tc.name AudioRenderResume_001
290 * @tc.desc test HDI RenderResume interface,return -1 if the render is resumed after started
291 * @tc.type: FUNC
292 */
293 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderResume_001, TestSize.Level1)
294 {
295 int32_t ret = -1;
296
297 ASSERT_NE(nullptr, render);
298 ret = AudioRenderStartAndOneFrame(render);
299 EXPECT_EQ(HDF_SUCCESS, ret);
300
301 ret = render->Resume(render);
302 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
303
304 ret = render->Stop(render);
305 EXPECT_EQ(HDF_SUCCESS, ret);
306 }
307 /**
308 * @tc.name AudioRenderResume_002
309 * @tc.desc test HDI RenderResume interface,return -1 if the render is resumed after stopped
310 * @tc.type: FUNC
311 */
312 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderResume_002, TestSize.Level1)
313 {
314 int32_t ret = -1;
315
316 ASSERT_NE(nullptr, render);
317 ret = AudioRenderStartAndOneFrame(render);
318 EXPECT_EQ(HDF_SUCCESS, ret);
319
320 ret = render->Stop(render);
321 EXPECT_EQ(HDF_SUCCESS, ret);
322 ret = render->Resume(render);
323 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
324 }
325 /**
326 * @tc.name AudioRenderResume_003
327 * @tc.desc Test AudioRenderResume interface,return 0 if the render is resumed after paused
328 * @tc.type: FUNC
329 */
330 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderResume_003, TestSize.Level1)
331 {
332 int32_t ret = -1;
333
334 ASSERT_NE(nullptr, render);
335 ret = AudioRenderStartAndOneFrame(render);
336 EXPECT_EQ(HDF_SUCCESS, ret);
337
338 ret = render->Pause(render);
339 EXPECT_EQ(HDF_SUCCESS, ret);
340 ret = render->Resume(render);
341 EXPECT_EQ(HDF_SUCCESS, ret);
342
343 ret = render->Stop(render);
344 EXPECT_EQ(HDF_SUCCESS, ret);
345 }
346 /**
347 * @tc.name AudioRenderResume_004
348 * @tc.desc Test RenderResume interface,return -1 the second time if the RenderResume is called twice
349 * @tc.type: FUNC
350 */
351 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderResume_004, TestSize.Level1)
352 {
353 int32_t ret = -1;
354
355 ASSERT_NE(nullptr, render);
356 ret = AudioRenderStartAndOneFrame(render);
357 EXPECT_EQ(HDF_SUCCESS, ret);
358
359 ret = render->Pause(render);
360 EXPECT_EQ(HDF_SUCCESS, ret);
361 ret = render->Resume(render);
362 EXPECT_EQ(HDF_SUCCESS, ret);
363 ret = render->Resume(render);
364 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
365
366 ret = render->Stop(render);
367 EXPECT_EQ(HDF_SUCCESS, ret);
368 }
369 /**
370 * @tc.name AudioRenderResume_005
371 * @tc.desc test HDI RenderResume interface,return -1 if the render Continue to start after resume
372 * @tc.type: FUNC
373 */
374 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderResume_005, TestSize.Level1)
375 {
376 int32_t ret = -1;
377
378 ASSERT_NE(nullptr, render);
379 ret = AudioRenderStartAndOneFrame(render);
380 EXPECT_EQ(HDF_SUCCESS, ret);
381
382 ret = render->Pause(render);
383 EXPECT_EQ(HDF_SUCCESS, ret);
384 ret = render->Resume(render);
385 EXPECT_EQ(HDF_SUCCESS, ret);
386 ret = render->Start(render);
387 EXPECT_EQ(AUDIO_HAL_ERR_AO_BUSY, ret);
388
389 ret = render->Stop(render);
390 EXPECT_EQ(HDF_SUCCESS, ret);
391 }
392 /**
393 * @tc.name AudioRenderResumeNull_006
394 * @tc.desc Test RenderResume interface, return -3/-4 if the incoming parameter handle is nullptr
395 * @tc.type: FUNC
396 */
397 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderResumeNull_006, TestSize.Level1)
398 {
399 int32_t ret = -1;
400 struct IAudioRender *renderNull = nullptr;
401
402 ASSERT_NE(nullptr, render);
403 ret = AudioRenderStartAndOneFrame(render);
404 EXPECT_EQ(HDF_SUCCESS, ret);
405
406 ret = render->Pause(render);
407 EXPECT_EQ(HDF_SUCCESS, ret);
408 ret = render->Resume(renderNull);
409 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
410
411 ret = render->Stop(render);
412 EXPECT_EQ(HDF_SUCCESS, ret);
413 }
414 /**
415 * @tc.name AudioRenderFlush_001
416 * @tc.desc Test RenderFlush interface,return -2 if the data in the buffer is flushed successfully after stop
417 * @tc.type: FUNC
418 */
419 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderFlush_001, TestSize.Level1)
420 {
421 int32_t ret = -1;
422
423 ASSERT_NE(nullptr, render);
424 ret = AudioRenderStartAndOneFrame(render);
425 EXPECT_EQ(HDF_SUCCESS, ret);
426
427 ret = render->Stop(render);
428 EXPECT_EQ(HDF_SUCCESS, ret);
429 ret = render->Flush(render);
430 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
431 }
432 /**
433 * @tc.name AudioRenderFlushNull_002
434 * @tc.desc Test RenderFlush, return -3/-4 if the data in the buffer is flushed
435 when handle is nullptr after paused
436 * @tc.type: FUNC
437 */
438 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderFlushNull_002, TestSize.Level1)
439 {
440 int32_t ret = -1;
441 struct IAudioRender *renderNull = nullptr;
442
443 ASSERT_NE(nullptr, render);
444 ret = AudioRenderStartAndOneFrame(render);
445 EXPECT_EQ(HDF_SUCCESS, ret);
446
447 ret = render->Pause(render);
448 EXPECT_EQ(HDF_SUCCESS, ret);
449 ret = render->Flush(renderNull);
450 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
451
452 ret = render->Stop(render);
453 EXPECT_EQ(HDF_SUCCESS, ret);
454 }
455 /**
456 * @tc.name AudioAudioRenderTurnStandbyMode_001
457 * @tc.desc Test RenderTurnStandbyMode interface,return 0 if the interface use correctly.
458 * @tc.type: FUNC
459 */
460 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderTurnStandbyMode_001, TestSize.Level1)
461 {
462 int32_t ret = -1;
463
464 ASSERT_NE(nullptr, render);
465 ret = AudioRenderStartAndOneFrame(render);
466 EXPECT_EQ(HDF_SUCCESS, ret);
467
468 ret = render->TurnStandbyMode(render);
469 EXPECT_EQ(HDF_SUCCESS, ret);
470 }
471 /**
472 * @tc.name AudioRenderTurnStandbyModeNull_002
473 * @tc.desc Test RenderTurnStandbyMode interface,return -3/-4 setting the incoming parameter self is nullptr.
474 * @tc.type: FUNC
475 */
476 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderTurnStandbyModeNull_002, TestSize.Level1)
477 {
478 int32_t ret = -1;
479 struct IAudioRender *renderNull = nullptr;
480
481 ASSERT_NE(nullptr, render);
482 ret = AudioRenderStartAndOneFrame(render);
483 EXPECT_EQ(HDF_SUCCESS, ret);
484
485 ret = render->TurnStandbyMode(renderNull);
486 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
487 render->Stop(render);
488 }
489
490 /**
491 * @tc.name AudioAudioRenderAudioDevDump_001
492 * @tc.desc Test RenderAudioDevDump interface,return 0 if the interface use correctly.
493 * @tc.type: FUNC
494 */
495 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderAudioDevDump_001, TestSize.Level1)
496 {
497 char pathBuf[] = "./DevDump.log";
498 ASSERT_NE(nullptr, render);
499 FILE *file = fopen(pathBuf, "wb+");
500 ASSERT_NE(nullptr, file);
501 int fd = fileno(file);
502 if (fd == -1) {
503 fclose(file);
504 ASSERT_NE(fd, -1);
505 }
506 struct PrepareAudioPara audiopara = {
507 .render = render, .path = AUDIO_FILE.c_str()
508 };
509 int32_t ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
510 if (ret < 0) {
511 fclose(file);
512 ASSERT_EQ(HDF_SUCCESS, ret);
513 }
514 sleep(1);
515 FrameStatus(0);
516 ret = audiopara.render->Pause(audiopara.render);
517 EXPECT_EQ(HDF_SUCCESS, ret);
518 ret = audiopara.render->AudioDevDump(audiopara.render, RANGE, fd);
519 EXPECT_EQ(HDF_SUCCESS, ret);
520 sleep(1);
521 FrameStatus(1);
522 ret = audiopara.render->Resume(audiopara.render);
523 EXPECT_EQ(HDF_SUCCESS, ret);
524 fclose(file);
525 ret = ThreadRelease(audiopara);
526 EXPECT_EQ(HDF_SUCCESS, ret);
527 }
528 /**
529 * @tc.name AudioAudioRenderAudioDevDump_002
530 * @tc.desc Test RenderAudioDevDump interface,return 0 if the interface use correctly.
531 * @tc.type: FUNC
532 */
533 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderAudioDevDump_002, TestSize.Level1)
534 {
535 int32_t ret = -1;
536 char path[] = "./DevDump.log";
537 ASSERT_NE(nullptr, render);
538 FILE *fp = fopen(path, "wb+");
539 ASSERT_NE(nullptr, fp);
540 int fd = fileno(fp);
541 if (fd == -1) {
542 fclose(fp);
543 ASSERT_NE(fd, -1);
544 }
545 struct PrepareAudioPara audiopara = {
546 .render = render, .path = AUDIO_FILE.c_str()
547 };
548 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
549 if (ret < 0) {
550 fclose(fp);
551 ASSERT_EQ(HDF_SUCCESS, ret);
552 }
553 sleep(1);
554 FrameStatus(0);
555 ret = audiopara.render->Pause(audiopara.render);
556 EXPECT_EQ(HDF_SUCCESS, ret);
557 ret = audiopara.render->AudioDevDump(audiopara.render, OUT_OF_RANGE-1, fd);
558 EXPECT_EQ(HDF_SUCCESS, ret);
559 sleep(1);
560 FrameStatus(1);
561 ret = audiopara.render->Resume(audiopara.render);
562 EXPECT_EQ(HDF_SUCCESS, ret);
563 fclose(fp);
564 ret = ThreadRelease(audiopara);
565 EXPECT_EQ(HDF_SUCCESS, ret);
566 }
567
568 /**
569 * @tc.name AudioAudioRenderAudioDevDump_003
570 * @tc.desc Test RenderAudioDevDump interface,return -3 if setting the incoming parameter range is out of range
571 * @tc.type: FUNC
572 */
573 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderAudioDevDump_003, TestSize.Level1)
574 {
575 char pathBuf[] = "./DevDump.log";
576 ASSERT_NE(nullptr, render);
577 FILE *fp = fopen(pathBuf, "wb+");
578 ASSERT_NE(nullptr, fp);
579 int fd = fileno(fp);
580 if (fd == -1) {
581 fclose(fp);
582 ASSERT_NE(fd, -1);
583 }
584 int32_t ret = render->AudioDevDump(render, RANGE-1, fd);
585 EXPECT_EQ(HDF_SUCCESS, ret);
586 ret = render->AudioDevDump(render, OUT_OF_RANGE, fd);
587 EXPECT_EQ(HDF_SUCCESS, ret);
588 fclose(fp);
589 }
590 /**
591 * @tc.name AudioRenderAudioDevDumpNull_004
592 * @tc.desc Test RenderAudioDevDump interface,return -3/-4 if setting the incoming parameter self is nullptr
593 * @tc.type: FUNC
594 */
595 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderAudioDevDumpNull_004, TestSize.Level1)
596 {
597 int32_t ret = -1;
598 struct IAudioRender *renderNull = nullptr;
599 char pathBuf[] = "./DevDump.log";
600 ASSERT_NE(nullptr, render);
601 FILE *fp = fopen(pathBuf, "wb+");
602 ASSERT_NE(nullptr, fp);
603 int fd = fileno(fp);
604 if (fd == -1) {
605 fclose(fp);
606 ASSERT_NE(fd, -1);
607 }
608 ret = render->AudioDevDump(renderNull, RANGE, fd);
609 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
610 fclose(fp);
611 }
612 /**
613 * @tc.name AudioAudioRenderAudioDevDump_005
614 * @tc.desc Test RenderAudioDevDump interface,return -3 if setting the incoming parameter fd is illegal
615 * @tc.type: FUNC
616 */
617 HWTEST_F(AudioIdlHdiRenderControlTest, AudioRenderAudioDevDump_005, TestSize.Level1)
618 {
619 int32_t ret = -1;
620
621 ASSERT_NE(nullptr, render);
622 int fd = 3;
623 ret = render->AudioDevDump(render, RANGE, fd);
624 EXPECT_EQ(HDF_SUCCESS, ret);
625 }
626 }
627
628