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 }
426 /**
427 * @tc.name AudioRenderSetRenderSpeed_001
428 * @tc.desc Test SetRenderSpeed interface,return -2 if setting RenderSpeed
429 * @tc.type: FUNC
430 */
431 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderSetRenderSpeed_001, TestSize.Level1)
432 {
433 int32_t ret;
434 float speed = 100;
435 ASSERT_NE(nullptr, render);
436 ret = AudioRenderStartAndOneFrame(render);
437 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_FAILURE);
438
439 ret = render->SetRenderSpeed(render, speed);
440 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
441 render->Stop(render);
442 }
443 /**
444 * @tc.name AudioRenderSetRenderSpeedNull_002
445 * @tc.desc Test SetRenderSpeed interface,return -3/-4 if the incoming parameter handle is nullptr
446 * @tc.type: FUNC
447 */
448 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderSetRenderSpeedNull_002, TestSize.Level1)
449 {
450 int32_t ret;
451 float speed = 0;
452 struct IAudioRender *renderNull = nullptr;
453 ASSERT_NE(nullptr, render);
454 ret = AudioRenderStartAndOneFrame(render);
455 EXPECT_EQ(HDF_SUCCESS, ret);
456
457 ret = render->SetRenderSpeed(renderNull, speed);
458 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
459 render->Stop(render);
460 }
461 /**
462 * @tc.name AudioRenderGetRenderSpeed_001
463 * @tc.desc Test GetRenderSpeed interface,return -2 if getting RenderSpeed
464 * @tc.type: FUNC
465 */
466 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetRenderSpeed_001, TestSize.Level1)
467 {
468 int32_t ret;
469 float speed = 0;
470 ASSERT_NE(nullptr, render);
471 ret = AudioRenderStartAndOneFrame(render);
472 EXPECT_EQ(HDF_SUCCESS, ret);
473 ret = render->GetRenderSpeed(render, &speed);
474 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
475 render->Stop(render);
476 }
477 /**
478 * @tc.name AudioRenderGetRenderSpeedNull_002
479 * @tc.desc Test GetRenderSpeed interface,return -3/-4 if the incoming parameter handle is nullptr
480 * @tc.type: FUNC
481 */
482 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetRenderSpeedNull_002, TestSize.Level1)
483 {
484 int32_t ret;
485 struct IAudioRender *renderNull = nullptr;
486 float speed = 0;
487 ASSERT_NE(nullptr, render);
488 ret = AudioRenderStartAndOneFrame(render);
489 EXPECT_EQ(HDF_SUCCESS, ret);
490
491 ret = render->GetRenderSpeed(renderNull, &speed);
492 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
493 render->Stop(render);
494 }
495 #ifdef AUDIO_ADM_PASSTHROUGH
496 /**
497 * @tc.name AudioRenderGetRenderSpeedNull_003
498 * @tc.desc Test GetRenderSpeed interface,return -3/-4 if the incoming parameter speed is nullptr
499 * @tc.type: FUNC
500 */
501 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetRenderSpeedNull_003, TestSize.Level1)
502 {
503 int32_t ret;
504 float *speedNull = nullptr;
505 ASSERT_NE(nullptr, render);
506 ret = AudioRenderStartAndOneFrame(render);
507 EXPECT_EQ(HDF_SUCCESS, ret);
508
509 ret = render->GetRenderSpeed(render, speedNull);
510 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
511 render->Stop(render);
512 }
513 #endif
514 #ifdef AUDIO_ADM_PASSTHROUGH
515 /**
516 * @tc.name AudioRenderRegCallback_001
517 * @tc.desc Test AudioRenderTurnStandbyMode interface,return 0 if the interface use correctly.
518 * @tc.type: FUNC
519 */
520 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderRegCallback_001, TestSize.Level1)
521 {
522 int32_t ret;
523
524 ASSERT_NE(nullptr, render);
525 struct IAudioCallback audioCallBack;
526 audioCallBack.RenderCallback = AudioRenderCallback;
527 ret = render->RegCallback(render, &audioCallBack, 1);
528 EXPECT_EQ(HDF_SUCCESS, ret);
529
530 ret = render->Flush(render);
531 EXPECT_EQ(HDF_SUCCESS, ret);
532
533 ret = CheckFlushValue();
534 EXPECT_EQ(HDF_SUCCESS, ret);
535 }
536 #ifndef ALSA_LIB_MODE
537 /**
538 * @tc.name AudioRenderRegCallback_002
539 * @tc.desc Test AudioRenderRegCallback interface,return 0 if the interface use correctly.
540 * @tc.type: FUNC
541 */
542 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderRegCallback_002, TestSize.Level1)
543 {
544 int32_t ret;
545 struct AudioSampleAttributes attrs;
546 struct AudioHeadInfo headInfo;
547 ASSERT_NE(nullptr, render);
548 char absPath[PATH_MAX] = {0};
549 realpath(AUDIO_FILE.c_str(), absPath);
550 ASSERT_NE(realpath(AUDIO_FILE.c_str(), absPath), nullptr);
551
552 FILE *file = fopen(absPath, "rb");
553 ASSERT_NE(file, nullptr);
554 ret = WavHeadAnalysis(headInfo, file, attrs);
555 if (ret < 0) {
556 fclose(file);
557 ASSERT_EQ(HDF_SUCCESS, ret);
558 }
559 struct IAudioCallback audioCallBack;
560 audioCallBack.RenderCallback = AudioRenderCallback;
561 ret = render->RegCallback(render, &audioCallBack, 1);
562 EXPECT_EQ(HDF_SUCCESS, ret);
563
564 ret = FrameStart(headInfo, render, file, attrs);
565 if (ret < 0) {
566 fclose(file);
567 ASSERT_EQ(HDF_SUCCESS, ret);
568 }
569
570 ret = CheckWriteCompleteValue();
571 EXPECT_EQ(HDF_SUCCESS, ret);
572 ret = CheckRenderFullValue();
573 EXPECT_EQ(HDF_SUCCESS, ret);
574 fclose(file);
575 }
576 #endif
577 /**
578 * @tc.name AudioRenderRegCallback_003
579 * @tc.desc Test AudioRenderRegCallback interface,return 0 if setting input paramter self is nullptr
580 * @tc.type: FUNC
581 */
582 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderRegCallback_003, TestSize.Level1)
583 {
584 int32_t ret;
585 struct IAudioRender *renderNull = nullptr;
586 ASSERT_NE(nullptr, render);
587 struct IAudioCallback audioCallBack;
588 audioCallBack.RenderCallback = AudioRenderCallback;
589
590 ret = render->RegCallback(renderNull, &audioCallBack, 1);
591 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
592 }
593 /**
594 * @tc.name AudioRenderRegCallback_004
595 * @tc.desc Test AudioRenderRegCallback interface,return -3 if setting input paramter IAudioCallback is nullptr
596 * @tc.type: FUNC
597 */
598 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderRegCallback_004, TestSize.Level1)
599 {
600 int32_t ret;
601 struct IAudioCallback *AudioRenderCallbackNull = nullptr;
602 ASSERT_NE(nullptr, render);
603
604 ret = render->RegCallback(render, AudioRenderCallbackNull, 1);
605 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
606 }
607 /**
608 * @tc.name AudioRenderRegCallback_005
609 * @tc.desc Test AudioRenderRegCallback interface,return -3 if setting input paramter callback function is nullptr
610 * @tc.type: FUNC
611 */
612 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderRegCallback_005, TestSize.Level1)
613 {
614 int32_t ret;
615 ASSERT_NE(nullptr, render);
616 struct IAudioCallback audioCallBack;
617 audioCallBack.RenderCallback = nullptr;
618 ret = render->RegCallback(render, &audioCallBack, 1);
619 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
620 }
621 #endif
622 /**
623 * @tc.name AudioRenderSetChannelMode_003
624 * @tc.desc Test SetChannelMode interface,return 0 if set channel mode after render object is created
625 * @tc.type: FUNC
626 */
627 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderSetChannelMode_003, TestSize.Level1)
628 {
629 int32_t ret;
630 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
631 ASSERT_NE(nullptr, render);
632
633 ret = render->SetChannelMode(render, mode);
634 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
635 ret = render->GetChannelMode(render, &mode);
636 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
637 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
638 }
639
640 /**
641 * @tc.name AudioRenderSetChannelModeNull_004
642 * @tc.desc Test SetChannelMode interface,return -3/-4 if set the parameter render is nullptr
643 * @tc.type: FUNC
644 */
645 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderSetChannelModeNull_004, TestSize.Level1)
646 {
647 int32_t ret;
648 struct IAudioRender *renderNull = nullptr;
649 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
650 ASSERT_NE(nullptr, render);
651
652 ret = render->SetChannelMode(renderNull, mode);
653 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
654 }
655 /**
656 * @tc.name AudioRenderGetChannelMode_001
657 * @tc.desc Test GetChannelMode interface,return 0 if getting the channel mode after setting
658 * @tc.type: FUNC
659 */
660 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetChannelMode_001, TestSize.Level1)
661 {
662 int32_t ret;
663 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
664 ASSERT_NE(nullptr, render);
665 ret = AudioRenderStartAndOneFrame(render);
666 EXPECT_EQ(HDF_SUCCESS, ret);
667
668 ret = render->GetChannelMode(render, &mode);
669 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
670 ret = render->SetChannelMode(render, mode);
671 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
672 ret = render->GetChannelMode(render, &mode);
673 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
674 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
675 render->Stop(render);
676 }
677 /**
678 * @tc.name AudioRenderGetChannelModeNull_002
679 * @tc.desc Test GetChannelMode interface,return -3/-4 if getting the parameter render is nullptr
680 * @tc.type: FUNC
681 */
682 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetChannelModeNull_002, TestSize.Level1)
683 {
684 int32_t ret;
685 struct IAudioRender *renderNull = nullptr;
686 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
687 AudioChannelMode *modeNull = nullptr;
688
689 ASSERT_NE(nullptr, render);
690 ret = AudioRenderStartAndOneFrame(render);
691 EXPECT_EQ(HDF_SUCCESS, ret);
692
693 ret = render->GetChannelMode(renderNull, &mode);
694 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
695 ret = render->GetChannelMode(render, modeNull);
696 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
697 render->Stop(render);
698 }
699 /**
700 * @tc.name AudioenderGetChannelMode_003
701 * @tc.desc Test GetChannelMode interface,return 0 if getting the channel mode after the object is created
702 * @tc.type: FUNC
703 */
704 HWTEST_F(AudioIdlHdiRenderTest, AudioRenderGetChannelMode_003, TestSize.Level1)
705 {
706 int32_t ret;
707 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
708 ASSERT_NE(nullptr, render);
709
710 ret = render->GetChannelMode(render, &mode);
711 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
712 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, mode);
713 }
714 }