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