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