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 AudioIdlHdiRenderTest : 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 static TestAudioManager *manager;
32 struct IAudioAdapter *adapter = nullptr;
33 };
34
35 TestAudioManager *AudioIdlHdiRenderTest::manager = nullptr;
36 using THREAD_FUNC = void *(*)(void *);
37
SetUpTestCase(void)38 void AudioIdlHdiRenderTest::SetUpTestCase(void)
39 {
40 manager = IAudioManagerGet(IS_STUB);
41 ASSERT_NE(nullptr, manager);
42 }
43
TearDownTestCase(void)44 void AudioIdlHdiRenderTest::TearDownTestCase(void)
45 {
46 if (manager != nullptr) {
47 (void)IAudioManagerRelease(manager, IS_STUB);
48 }
49 }
50
SetUp(void)51 void AudioIdlHdiRenderTest::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 AudioIdlHdiRenderTest::TearDown(void)
59 {
60 int32_t ret = ReleaseRenderSource(manager, adapter, render);
61 ASSERT_EQ(HDF_SUCCESS, ret);
62 }
63
64 /**
65 * @tc.name AudioRenderetLatency_001
66 * @tc.desc test RenderGetLatency interface, return 0 if GetLatency successful
67 * @tc.type: FUNC
68 */
69 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetLatency_001, TestSize.Level1)
70 {
71 int32_t ret;
72 uint32_t latencyTime = 0;
73 uint32_t expectLatency = 0;
74 ASSERT_NE(nullptr, render);
75 ret = AudioRenderStartAndOneFrame(render);
76 EXPECT_EQ(HDF_SUCCESS, ret);
77
78 ret = render->GetLatency(render, &latencyTime);
79 EXPECT_EQ(HDF_SUCCESS, ret);
80 EXPECT_LT(expectLatency, latencyTime);
81 ret = render->Stop(render);
82 EXPECT_EQ(HDF_SUCCESS, ret);
83 }
84 /**
85 * @tc.name AudioRenderGetLatencyNull_002
86 * @tc.desc test RenderGetLatency interface, return -3/-4 if Setting parameters render is nullptr
87 * @tc.type: FUNC
88 */
89 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetLatencyNull_002, TestSize.Level1)
90 {
91 int32_t ret;
92 uint32_t latencyTime = 0;
93 struct IAudioRender *renderNull = nullptr;
94 ASSERT_NE(nullptr, render);
95 ret = AudioRenderStartAndOneFrame(render);
96 EXPECT_EQ(HDF_SUCCESS, ret);
97
98 ret = render->GetLatency(renderNull, &latencyTime);
99 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
100 ret = render->Stop(render);
101 EXPECT_EQ(HDF_SUCCESS, ret);
102 }
103 /**
104 * @tc.name AudioRenderGetLatencyNull_003
105 * @tc.desc test RenderGetLatency interface,return -3 if Setting parameters ms is nullptr
106 * @tc.type: FUNC
107 */
108 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetLatencyNull_003, TestSize.Level1)
109 {
110 int32_t ret;
111 uint32_t *latencyTime = nullptr;
112 ASSERT_NE(nullptr, render);
113 ret = AudioRenderStartAndOneFrame(render);
114 EXPECT_EQ(HDF_SUCCESS, ret);
115
116 ret = render->GetLatency(render, latencyTime);
117 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
118 ret = render->Stop(render);
119 EXPECT_EQ(HDF_SUCCESS, ret);
120 }
121 /**
122 * @tc.name AudioAudioRenderFrame_001
123 * @tc.desc test RenderFrame interface,Returns 0 if the data is written successfully
124 * @tc.type: FUNC
125 */
126 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderFrame_001, TestSize.Level1)
127 {
128 int32_t ret;
129 uint64_t requestBytes = 0;
130 uint64_t replyBytes = 0;
131 char *frame = nullptr;
132 ASSERT_NE(nullptr, render);
133 ret = render->Start(render);
134 EXPECT_EQ(HDF_SUCCESS, ret);
135
136 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
137 EXPECT_EQ(HDF_SUCCESS, ret);
138 ret = render->RenderFrame(render, (int8_t *)frame, requestBytes, &replyBytes);
139 EXPECT_EQ(HDF_SUCCESS, ret);
140
141 render->Stop(render);
142 if (frame != nullptr) {
143 free(frame);
144 frame = nullptr;
145 }
146 }
147 /**
148 * @tc.name AudioRenderFrameNull_002
149 * @tc.desc Test RenderFrame interface,Returns -3/-4 if the incoming parameter render is nullptr
150 * @tc.type: FUNC
151 */
152 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderFrameNull_002, TestSize.Level1)
153 {
154 int32_t ret;
155 uint64_t requestBytes = 0;
156 uint64_t replyBytes = 0;
157 struct IAudioRender *renderNull = nullptr;
158 char *frame = nullptr;
159
160 ASSERT_NE(nullptr, render);
161 ret = render->Start(render);
162 EXPECT_EQ(HDF_SUCCESS, ret);
163
164 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
165 EXPECT_EQ(HDF_SUCCESS, ret);
166 ret = render->RenderFrame(renderNull, (int8_t *)frame, requestBytes, &replyBytes);
167 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
168
169 render->Stop(render);
170 if (frame != nullptr) {
171 free(frame);
172 frame = nullptr;
173 }
174 }
175 /**
176 * @tc.name AudioAudioRenderFrameNull_003
177 * @tc.desc Test RenderFrame interface,Returns -3 if the incoming parameter frame is nullptr
178 * @tc.type: FUNC
179 */
180 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderFrameNull_003, TestSize.Level1)
181 {
182 int32_t ret;
183 uint64_t requestBytes = 0;
184 uint64_t replyBytes = 0;
185 char *frame = nullptr;
186
187 ASSERT_NE(nullptr, render);
188 ret = render->Start(render);
189 EXPECT_EQ(HDF_SUCCESS, ret);
190
191 ret = render->RenderFrame(render, (int8_t *)frame, requestBytes, &replyBytes);
192 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
193 render->Stop(render);
194 }
195 /**
196 * @tc.name AudioAudioRenderFrameNull_004
197 * @tc.desc Test RenderFrame interface,Returns -3 if the incoming parameter replyBytes is nullptr
198 * @tc.type: FUNC
199 */
200 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderFrameNull_004, TestSize.Level1)
201 {
202 int32_t ret;
203 uint64_t requestBytes = 0;
204 char *frame = nullptr;
205 uint64_t *replyBytes = nullptr;
206
207 ASSERT_NE(nullptr, render);
208 ret = render->Start(render);
209 EXPECT_EQ(HDF_SUCCESS, ret);
210
211 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
212 EXPECT_EQ(HDF_SUCCESS, ret);
213 ret = render->RenderFrame(render, (int8_t *)frame, requestBytes, replyBytes);
214 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
215
216 render->Stop(render);
217 if (frame != nullptr) {
218 free(frame);
219 frame = nullptr;
220 }
221 }
222 /**
223 * @tc.name AudioAudioRenderFrame_005
224 * @tc.desc Test RenderFrame interface,Returns -3 if without calling interface renderstart
225 * @tc.type: FUNC
226 */
227 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderFrame_005, TestSize.Level1)
228 {
229 int32_t ret;
230 uint64_t replyBytes = 0;
231 uint64_t requestBytes = 0;
232 char *frame = nullptr;
233
234 ASSERT_NE(nullptr, render);
235 ret = RenderFramePrepare(AUDIO_FILE, frame, requestBytes);
236 EXPECT_EQ(HDF_SUCCESS, ret);
237 ret = render->RenderFrame(render, (int8_t *)frame, requestBytes, &replyBytes);
238 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
239
240 if (frame != nullptr) {
241 free(frame);
242 frame = nullptr;
243 }
244 }
245
246 /**
247 * @tc.name AudioRenderGetRenderPosition_001
248 * @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition during playing.
249 * @tc.type: FUNC
250 */
251 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetRenderPosition_001, TestSize.Level1)
252 {
253 int32_t ret;
254 uint64_t frames = 0;
255 int64_t timeExp = 0;
256 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
257 ASSERT_NE(nullptr, render);
258 struct PrepareAudioPara audiopara = {
259 .path = AUDIO_FILE.c_str(), .render = render
260 };
261
262 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
263 ASSERT_EQ(HDF_SUCCESS, ret);
264 sleep(1);
265 if (audiopara.render != nullptr) {
266 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
267 EXPECT_EQ(HDF_SUCCESS, ret);
268 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
269 EXPECT_GT(frames, INITIAL_VALUE);
270 }
271
272 ret = ThreadRelease(audiopara);
273 EXPECT_EQ(HDF_SUCCESS, ret);
274 }
275 /**
276 * @tc.name AudioRenderGetRenderPosition_002
277 * @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition after Pause and resume during playing
278 * @tc.type: FUNC
279 */
280 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetRenderPosition_002, TestSize.Level1)
281 {
282 int32_t ret;
283 int64_t timeExp = 0;
284 uint64_t frames = 0;
285 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
286 ASSERT_NE(nullptr, render);
287 struct PrepareAudioPara audiopara = {
288 .path = AUDIO_FILE.c_str(), .render = render
289 };
290
291 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
292 ASSERT_EQ(HDF_SUCCESS, ret);
293 sleep(1);
294 if (audiopara.render != nullptr) {
295 FrameStatus(0);
296 usleep(1000);
297 ret = audiopara.render->Pause(audiopara.render);
298 EXPECT_EQ(HDF_SUCCESS, ret);
299 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
300 EXPECT_EQ(HDF_SUCCESS, ret);
301 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
302 EXPECT_GT(frames, INITIAL_VALUE);
303 usleep(1000);
304 ret = audiopara.render->Resume(audiopara.render);
305 EXPECT_EQ(HDF_SUCCESS, ret);
306 FrameStatus(1);
307 ret = audiopara.render->GetRenderPosition(audiopara.render, &frames, &time);
308 EXPECT_EQ(HDF_SUCCESS, ret);
309 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
310 EXPECT_GT(frames, INITIAL_VALUE);
311 }
312
313 ret = ThreadRelease(audiopara);
314 EXPECT_EQ(HDF_SUCCESS, ret);
315 }
316 /**
317 * @tc.name AudioRenderGetRenderPosition_003
318 * @tc.desc Test GetRenderPosition interface,Returns 0 if get RenderPosition after stop
319 * @tc.type: FUNC
320 */
321 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetRenderPosition_003, TestSize.Level1)
322 {
323 int32_t ret;
324 int64_t timeExp = 0;
325 uint64_t frames = 0;
326 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
327 ASSERT_NE(nullptr, render);
328 ret = AudioRenderStartAndOneFrame(render);
329 ASSERT_EQ(HDF_SUCCESS, ret);
330 ret = render->Stop(render);
331 EXPECT_EQ(HDF_SUCCESS, ret);
332
333 ret = render->GetRenderPosition(render, &frames, &time);
334 EXPECT_EQ(HDF_SUCCESS, ret);
335 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
336 EXPECT_GT(frames, INITIAL_VALUE);
337 }
338 /**
339 * @tc.name AudioRenderGetRenderPosition_004
340 * @tc.desc Test RenderGetRenderPosition interface, return 0 if setting the parameter render is legal
341 * @tc.type: FUNC
342 */
343 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetRenderPosition_004, TestSize.Level1)
344 {
345 int32_t ret;
346 uint64_t frames = 0;
347 int64_t timeExp = 0;
348 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
349
350 ASSERT_NE(nullptr, render);
351 ret = render->GetRenderPosition(render, &frames, &time);
352 EXPECT_EQ(HDF_SUCCESS, ret);
353 EXPECT_EQ((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
354 }
355 /**
356 * @tc.name AudioRenderGetRenderPositionNull_005
357 * @tc.desc Test RenderGetRenderPosition interface, return -3/-4 if setting the parameter render is nullptr
358 * @tc.type: FUNC
359 */
360 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetRenderPositionNull_005, TestSize.Level1)
361 {
362 int32_t ret;
363 uint64_t frames = 0;
364 struct AudioTimeStamp time = {};
365 struct IAudioRender *renderNull = nullptr;
366
367 ASSERT_NE(nullptr, render);
368 ret = render->GetRenderPosition(renderNull, &frames, &time);
369 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
370 }
371 /**
372 * @tc.name AudioRenderGetRenderPositionNull_006
373 * @tc.desc Test RenderGetRenderPosition interface, return -3 if setting the parameter frames is nullptr
374 * @tc.type: FUNC
375 */
376 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetRenderPositionNull_006, TestSize.Level1)
377 {
378 int32_t ret;
379 uint64_t *framesNull = nullptr;
380 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
381
382 ASSERT_NE(nullptr, render);
383 ret = render->GetRenderPosition(render, framesNull, &time);
384 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
385 }
386 /**
387 * @tc.name AudioRenderGetRenderPositionNull_007
388 * @tc.desc Test RenderGetRenderPosition interface, return -3 if setting the parameter time is nullptr
389 * @tc.type: FUNC
390 */
391 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetRenderPositionNull_007, TestSize.Level1)
392 {
393 int32_t ret;
394 uint64_t frames = 0;
395 struct AudioTimeStamp *timeNull = nullptr;
396
397 ASSERT_NE(nullptr, render);
398 ret = render->GetRenderPosition(render, &frames, timeNull);
399 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
400 }
401 /**
402 * @tc.name AudioRenderGetRenderPosition_008
403 * @tc.desc Test RenderGetRenderPosition interface, return 0 if the GetRenderPosition was called twice
404 * @tc.type: FUNC
405 */
406 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetRenderPosition_008, TestSize.Level1)
407 {
408 int32_t ret;
409 int64_t timeExp = 0;
410 uint64_t frames = 0;
411 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
412
413 ASSERT_NE(nullptr, render);
414 ret = AudioRenderStartAndOneFrame(render);
415 EXPECT_EQ(HDF_SUCCESS, ret);
416 ret = render->GetRenderPosition(render, &frames, &time);
417 EXPECT_EQ(HDF_SUCCESS, ret);
418 ret = render->GetRenderPosition(render, &frames, &time);
419 EXPECT_EQ(HDF_SUCCESS, ret);
420 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
421 EXPECT_GT(frames, INITIAL_VALUE);
422 }
423 /**
424 * @tc.name AudioRenderSetRenderSpeed_001
425 * @tc.desc Test SetRenderSpeed interface,return -2 if setting RenderSpeed
426 * @tc.type: FUNC
427 */
428 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderSetRenderSpeed_001, TestSize.Level1)
429 {
430 int32_t ret;
431 float speed = 100;
432 ASSERT_NE(nullptr, render);
433 ret = AudioRenderStartAndOneFrame(render);
434 EXPECT_EQ(HDF_SUCCESS, ret);
435
436 ret = render->SetRenderSpeed(render, speed);
437 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
438 render->Stop(render);
439 }
440 /**
441 * @tc.name AudioRenderSetRenderSpeedNull_002
442 * @tc.desc Test SetRenderSpeed interface,return -3/-4 if the incoming parameter handle is nullptr
443 * @tc.type: FUNC
444 */
445 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderSetRenderSpeedNull_002, TestSize.Level1)
446 {
447 int32_t ret;
448 float speed = 0;
449 struct IAudioRender *renderNull = nullptr;
450 ASSERT_NE(nullptr, render);
451 ret = AudioRenderStartAndOneFrame(render);
452 EXPECT_EQ(HDF_SUCCESS, ret);
453
454 ret = render->SetRenderSpeed(renderNull, speed);
455 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
456 render->Stop(render);
457 }
458 /**
459 * @tc.name AudioRenderGetRenderSpeed_001
460 * @tc.desc Test GetRenderSpeed interface,return -2 if getting RenderSpeed
461 * @tc.type: FUNC
462 */
463 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetRenderSpeed_001, TestSize.Level1)
464 {
465 int32_t ret;
466 float speed = 0;
467 ASSERT_NE(nullptr, render);
468 ret = AudioRenderStartAndOneFrame(render);
469 EXPECT_EQ(HDF_SUCCESS, ret);
470 ret = render->GetRenderSpeed(render, &speed);
471 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
472 render->Stop(render);
473 }
474 /**
475 * @tc.name AudioRenderGetRenderSpeedNull_002
476 * @tc.desc Test GetRenderSpeed interface,return -3/-4 if the incoming parameter handle is nullptr
477 * @tc.type: FUNC
478 */
479 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetRenderSpeedNull_002, TestSize.Level1)
480 {
481 int32_t ret;
482 struct IAudioRender *renderNull = nullptr;
483 float speed = 0;
484 ASSERT_NE(nullptr, render);
485 ret = AudioRenderStartAndOneFrame(render);
486 EXPECT_EQ(HDF_SUCCESS, ret);
487
488 ret = render->GetRenderSpeed(renderNull, &speed);
489 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
490 render->Stop(render);
491 }
492 #ifdef AUDIO_ADM_PASSTHROUGH
493 /**
494 * @tc.name AudioRenderGetRenderSpeedNull_003
495 * @tc.desc Test GetRenderSpeed interface,return -3/-4 if the incoming parameter speed is nullptr
496 * @tc.type: FUNC
497 */
498 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetRenderSpeedNull_003, TestSize.Level1)
499 {
500 int32_t ret;
501 float *speedNull = nullptr;
502 ASSERT_NE(nullptr, render);
503 ret = AudioRenderStartAndOneFrame(render);
504 EXPECT_EQ(HDF_SUCCESS, ret);
505
506 ret = render->GetRenderSpeed(render, speedNull);
507 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
508 render->Stop(render);
509 }
510 #endif
511 #ifdef AUDIO_ADM_PASSTHROUGH
512 /**
513 * @tc.name AudioRenderRegCallback_001
514 * @tc.desc Test AudioRenderTurnStandbyMode interface,return 0 if the interface use correctly.
515 * @tc.type: FUNC
516 */
517 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderRegCallback_001, TestSize.Level1)
518 {
519 int32_t ret;
520
521 ASSERT_NE(nullptr, render);
522 struct IAudioCallback audioCallBack;
523 audioCallBack.RenderCallback = AudioRenderCallback;
524 ret = render->RegCallback(render, &audioCallBack, 1);
525 EXPECT_EQ(HDF_SUCCESS, ret);
526
527 ret = render->Flush(render);
528 EXPECT_EQ(HDF_SUCCESS, ret);
529
530 ret = CheckFlushValue();
531 EXPECT_EQ(HDF_SUCCESS, ret);
532 }
533 #ifndef ALSA_LIB_MODE
534 /**
535 * @tc.name AudioRenderRegCallback_002
536 * @tc.desc Test AudioRenderRegCallback interface,return 0 if the interface use correctly.
537 * @tc.type: FUNC
538 */
539 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderRegCallback_002, TestSize.Level1)
540 {
541 int32_t ret;
542 struct AudioSampleAttributes attrs;
543 struct AudioHeadInfo headInfo;
544 ASSERT_NE(nullptr, render);
545 char absPath[PATH_MAX] = {0};
546 realpath(AUDIO_FILE.c_str(), absPath);
547 ASSERT_NE(realpath(AUDIO_FILE.c_str(), absPath), nullptr);
548
549 FILE *file = fopen(absPath, "rb");
550 ASSERT_NE(file, nullptr);
551 ret = WavHeadAnalysis(headInfo, file, attrs);
552 if (ret < 0) {
553 fclose(file);
554 ASSERT_EQ(HDF_SUCCESS, ret);
555 }
556 struct IAudioCallback audioCallBack;
557 audioCallBack.RenderCallback = AudioRenderCallback;
558 ret = render->RegCallback(render, &audioCallBack, 1);
559 EXPECT_EQ(HDF_SUCCESS, ret);
560
561 ret = FrameStart(headInfo, render, file, attrs);
562 if (ret < 0) {
563 fclose(file);
564 ASSERT_EQ(HDF_SUCCESS, ret);
565 }
566
567 ret = CheckWriteCompleteValue();
568 EXPECT_EQ(HDF_SUCCESS, ret);
569 ret = CheckRenderFullValue();
570 EXPECT_EQ(HDF_SUCCESS, ret);
571 fclose(file);
572 }
573 #endif
574 /**
575 * @tc.name AudioRenderRegCallback_003
576 * @tc.desc Test AudioRenderRegCallback interface,return 0 if setting input paramter self is nullptr
577 * @tc.type: FUNC
578 */
579 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderRegCallback_003, TestSize.Level1)
580 {
581 int32_t ret;
582 struct IAudioRender *renderNull = nullptr;
583 ASSERT_NE(nullptr, render);
584 struct IAudioCallback audioCallBack;
585 audioCallBack.RenderCallback = AudioRenderCallback;
586
587 ret = render->RegCallback(renderNull, &audioCallBack, 1);
588 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
589 }
590 /**
591 * @tc.name AudioRenderRegCallback_004
592 * @tc.desc Test AudioRenderRegCallback interface,return -3 if setting input paramter IAudioCallback is nullptr
593 * @tc.type: FUNC
594 */
595 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderRegCallback_004, TestSize.Level1)
596 {
597 int32_t ret;
598 struct IAudioCallback *AudioRenderCallbackNull = nullptr;
599 ASSERT_NE(nullptr, render);
600
601 ret = render->RegCallback(render, AudioRenderCallbackNull, 1);
602 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
603 }
604 /**
605 * @tc.name AudioRenderRegCallback_005
606 * @tc.desc Test AudioRenderRegCallback interface,return -3 if setting input paramter callback function is nullptr
607 * @tc.type: FUNC
608 */
609 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderRegCallback_005, TestSize.Level1)
610 {
611 int32_t ret;
612 ASSERT_NE(nullptr, render);
613 struct IAudioCallback audioCallBack;
614 audioCallBack.RenderCallback = nullptr;
615 ret = render->RegCallback(render, &audioCallBack, 1);
616 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
617 }
618 #endif
619 /**
620 * @tc.name AudioRenderSetChannelMode_003
621 * @tc.desc Test SetChannelMode interface,return 0 if set channel mode after render object is created
622 * @tc.type: FUNC
623 */
624 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderSetChannelMode_003, TestSize.Level1)
625 {
626 int32_t ret;
627 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
628 ASSERT_NE(nullptr, render);
629
630 ret = render->SetChannelMode(render, mode);
631 EXPECT_EQ(HDF_SUCCESS, ret);
632 ret = render->GetChannelMode(render, &mode);
633 EXPECT_EQ(HDF_SUCCESS, ret);
634 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
635 }
636
637 /**
638 * @tc.name AudioRenderSetChannelModeNull_004
639 * @tc.desc Test SetChannelMode interface,return -3/-4 if set the parameter render is nullptr
640 * @tc.type: FUNC
641 */
642 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderSetChannelModeNull_004, TestSize.Level1)
643 {
644 int32_t ret;
645 struct IAudioRender *renderNull = nullptr;
646 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
647 ASSERT_NE(nullptr, render);
648
649 ret = render->SetChannelMode(renderNull, mode);
650 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
651 }
652 /**
653 * @tc.name AudioRenderGetChannelMode_001
654 * @tc.desc Test GetChannelMode interface,return 0 if getting the channel mode after setting
655 * @tc.type: FUNC
656 */
657 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetChannelMode_001, TestSize.Level1)
658 {
659 int32_t ret;
660 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
661 ASSERT_NE(nullptr, render);
662 ret = AudioRenderStartAndOneFrame(render);
663 EXPECT_EQ(HDF_SUCCESS, ret);
664
665 ret = render->GetChannelMode(render, &mode);
666 EXPECT_EQ(HDF_SUCCESS, ret);
667 ret = render->SetChannelMode(render, mode);
668 EXPECT_EQ(HDF_SUCCESS, ret);
669 ret = render->GetChannelMode(render, &mode);
670 EXPECT_EQ(HDF_SUCCESS, ret);
671 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
672 render->Stop(render);
673 }
674 /**
675 * @tc.name AudioRenderGetChannelModeNull_002
676 * @tc.desc Test GetChannelMode interface,return -3/-4 if getting the parameter render is nullptr
677 * @tc.type: FUNC
678 */
679 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetChannelModeNull_002, TestSize.Level1)
680 {
681 int32_t ret;
682 struct IAudioRender *renderNull = nullptr;
683 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
684 AudioChannelMode *modeNull = nullptr;
685
686 ASSERT_NE(nullptr, render);
687 ret = AudioRenderStartAndOneFrame(render);
688 EXPECT_EQ(HDF_SUCCESS, ret);
689
690 ret = render->GetChannelMode(renderNull, &mode);
691 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
692 ret = render->GetChannelMode(render, modeNull);
693 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
694 render->Stop(render);
695 }
696 /**
697 * @tc.name AudioenderGetChannelMode_003
698 * @tc.desc Test GetChannelMode interface,return 0 if getting the channel mode after the object is created
699 * @tc.type: FUNC
700 */
701 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetChannelMode_003, TestSize.Level1)
702 {
703 int32_t ret;
704 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
705 ASSERT_NE(nullptr, render);
706
707 ret = render->GetChannelMode(render, &mode);
708 EXPECT_EQ(HDF_SUCCESS, ret);
709 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
710 }
711 }