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 AudioIdlHdiRenderAttrTest : public testing::Test {
25 public:
26 static void SetUpTestCase(void);
27 static void TearDownTestCase(void);
28 void SetUp();
29 void TearDown();
30 struct IAudioAdapter *adapter = nullptr;
31 struct IAudioRender *render = nullptr;
32 static TestAudioManager *manager;
33 };
34
35 TestAudioManager *AudioIdlHdiRenderAttrTest::manager = nullptr;
36 using THREAD_FUNC = void *(*)(void *);
37
SetUpTestCase(void)38 void AudioIdlHdiRenderAttrTest::SetUpTestCase(void)
39 {
40 manager = IAudioManagerGet(IS_STUB);
41 ASSERT_NE(nullptr, manager);
42 }
43
TearDownTestCase(void)44 void AudioIdlHdiRenderAttrTest::TearDownTestCase(void)
45 {
46 if (manager != nullptr) {
47 (void)IAudioManagerRelease(manager, IS_STUB);
48 }
49 }
50
SetUp(void)51 void AudioIdlHdiRenderAttrTest::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 AudioIdlHdiRenderAttrTest::TearDown(void)
59 {
60 int32_t ret = ReleaseRenderSource(manager, adapter, render);
61 ASSERT_EQ(HDF_SUCCESS, ret);
62 }
63
64
65 /**
66 * @tc.name AudioRenderGetFrameSize_001
67 * @tc.desc Test RenderGetFrameSize interface,return 0 if the FrameSize was obtained successfully
68 * @tc.type: FUNC
69 */
70 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetFrameSize_001, TestSize.Level1)
71 {
72 int32_t ret;
73 uint64_t size = 0;
74 uint64_t zero = 0;
75 ASSERT_NE(nullptr, render);
76
77 ret = render->GetFrameSize(render, &size);
78 EXPECT_EQ(HDF_SUCCESS, ret);
79 EXPECT_GT(size, zero);
80 }
81 /**
82 * @tc.name AudioRenderGetFrameSizeNull_002
83 * @tc.desc Test RenderGetFrameSize interface,return -3/-4 if failed to get the FrameSize when handle is nullptr
84 * @tc.type: FUNC
85 */
86 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetFrameSizeNull_002, TestSize.Level1)
87 {
88 int32_t ret;
89 uint64_t size = 0;
90 struct IAudioRender *renderNull = nullptr;
91 ASSERT_NE(nullptr, render);
92
93 ret = render->GetFrameSize(renderNull, &size);
94 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
95 }
96 /**
97 * @tc.name AudioRenderGetFrameCount_001
98 * @tc.desc Test RenderGetFrameCount interface, return 0 if the FrameSize was obtained successfully
99 * @tc.type: FUNC
100 */
101 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetFrameCount_001, TestSize.Level1)
102 {
103 int32_t ret;
104 uint64_t count = 0;
105 uint64_t zero = 0;
106 ASSERT_NE(nullptr, render);
107 ret = AudioRenderStartAndOneFrame(render);
108 EXPECT_EQ(HDF_SUCCESS, ret);
109
110 ret = render->GetFrameCount(render, &count);
111 EXPECT_EQ(HDF_SUCCESS, ret);
112 EXPECT_GT(count, zero);
113 render->Stop(render);
114 }
115 /**
116 * @tc.name AudioRenderGetFrameCountNull_002
117 * @tc.desc Test RenderGetFrameCount interface,return -3/-4 if the incoming parameter handle is nullptr
118 * @tc.type: FUNC
119 */
120 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetFrameCountNull_002, TestSize.Level1)
121 {
122 int32_t ret;
123 uint64_t count = 0;
124 struct IAudioRender *renderNull = nullptr;
125 ASSERT_NE(nullptr, render);
126 ret = AudioRenderStartAndOneFrame(render);
127 EXPECT_EQ(HDF_SUCCESS, ret);
128
129 ret = render->GetFrameCount(renderNull, &count);
130 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
131 render->Stop(render);
132 }
133 /**
134 * @tc.name AudioRenderGetFrameCountNull_003
135 * @tc.desc Test RenderGetFrameCount interface,return -3 if the incoming parameter count is nullptr
136 * @tc.type: FUNC
137 */
138 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetFrameCountNull_003, TestSize.Level1)
139 {
140 int32_t ret;
141 uint64_t *countNull = nullptr;
142 ASSERT_NE(nullptr, render);
143 ret = AudioRenderStartAndOneFrame(render);
144 EXPECT_EQ(HDF_SUCCESS, ret);
145
146 ret = render->GetFrameCount(render, countNull);
147 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
148
149 render->Stop(render);
150 }
151 /**
152 * @tc.name AudioRenderGetCurrentChannelId_001
153 * @tc.desc Test RenderGetCurrentChannelId, return 0 if the default CurrentChannelId is obtained successfully
154 * @tc.type: FUNC
155 */
156 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetCurrentChannelId_001, TestSize.Level1)
157 {
158 int32_t ret;
159 uint32_t channelId = 0;
160 uint32_t channelIdValue = CHANNELCOUNT;
161
162 ASSERT_NE(nullptr, render);
163 ret = render->GetCurrentChannelId(render, &channelId);
164 EXPECT_EQ(HDF_SUCCESS, ret);
165 EXPECT_EQ(channelIdValue, channelId);
166 }
167 /**
168 * @tc.name AudioRenderGetCurrentChannelIdNull_003
169 * @tc.desc Test GetCurrentChannelId interface,return -3/-4 if set the parameter render is nullptr
170 * @tc.type: FUNC
171 */
172 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetCurrentChannelIdNull_003, TestSize.Level1)
173 {
174 int32_t ret;
175 uint32_t channelId = 0;
176 struct IAudioRender *renderNull = nullptr;
177 ASSERT_NE(nullptr, render);
178
179 ret = render->GetCurrentChannelId(renderNull, &channelId);
180 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
181 }
182 /**
183 * @tc.name AudioRenderGetCurrentChannelIdNull_004
184 * @tc.desc Test RenderGetCurrentChannelId interface, return -3 if setting the parameter channelId is nullptr
185 * @tc.type: FUNC
186 */
187 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetCurrentChannelIdNull_004, TestSize.Level1)
188 {
189 int32_t ret;
190 uint32_t *channelIdNull = nullptr;
191
192 ASSERT_NE(nullptr, render);
193 ret = render->GetCurrentChannelId(render, channelIdNull);
194 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
195 }
196 /**
197 * @tc.name AudioRenderSetExtraParams_001
198 * @tc.desc Test RenderSetExtraParams interface,return 0 if the ExtraParams is set during playback
199 * @tc.type: FUNC
200 */
201 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParams_001, TestSize.Level1)
202 {
203 int32_t ret;
204 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
205 char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-sampling-rate=48000";
206 size_t index = 1;
207 char keyValueListValue[256] = {};
208 int32_t listLenth = 256;
209 ASSERT_NE(nullptr, render);
210 struct PrepareAudioPara audiopara = {
211 .path = AUDIO_FILE.c_str(), .render = render
212 };
213
214 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
215 ASSERT_EQ(HDF_SUCCESS, ret);
216 sleep(1);
217 if (audiopara.render != nullptr) {
218 ret = audiopara.render->SetExtraParams(audiopara.render, keyValueList);
219 EXPECT_EQ(HDF_SUCCESS, ret);
220 ret = audiopara.render->GetExtraParams(audiopara.render, keyValueListValue, listLenth);
221 EXPECT_EQ(HDF_SUCCESS, ret);
222 string strGetValue = keyValueListValue;
223 size_t indexAttr = strGetValue.find("attr-frame-count");
224 size_t indexFlag = strGetValue.rfind(";");
225 if (indexAttr != string::npos && indexFlag != string::npos) {
226 strGetValue.replace(indexAttr, indexFlag - indexAttr + index, "");
227 }
228 EXPECT_STREQ(keyValueListExp, strGetValue.c_str());
229 }
230
231 ret = ThreadRelease(audiopara);
232 EXPECT_EQ(HDF_SUCCESS, ret);
233 }
234 /**
235 * @tc.name AudioRenderSetExtraParams_002
236 * @tc.desc Test RenderSetExtraParams interface,return 0 if some parameters is set after playing
237 * @tc.type: FUNC
238 */
239 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParams_002, TestSize.Level1)
240 {
241 int32_t ret;
242 char keyValueListOne[] = "attr-frame-count=1024;";
243 char keyValueListOneExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=1024;\
244 attr-sampling-rate=48000";
245 char keyValueListTwo[] = "attr-format=16;attr-frame-count=1024;";
246 char keyValueListTwoExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=1024;\
247 attr-sampling-rate=48000";
248 char keyValueListThr[] = "attr-route=1;attr-channels=1;attr-frame-count=1024;";
249 char keyValueListThrExp[] = "attr-route=1;attr-format=16;attr-channels=1;attr-frame-count=1024;\
250 attr-sampling-rate=48000";
251 char keyValueListFour[] = "attr-format=32;attr-channels=2;attr-frame-count=4096;attr-sampling-rate=48000";
252 char keyValueListFourExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=4096;\
253 attr-sampling-rate=48000";
254 char keyValueListValueOne[256] = {};
255 char keyValueListValueTwo[256] = {};
256 char keyValueListValueThr[256] = {};
257 char keyValueListValueFour[256] = {};
258 int32_t listLenth = 256;
259 ASSERT_NE(nullptr, render);
260 ret = AudioRenderStartAndOneFrame(render);
261 EXPECT_EQ(HDF_SUCCESS, ret);
262 ret = render->SetExtraParams(render, keyValueListOne);
263 EXPECT_EQ(HDF_SUCCESS, ret);
264 ret = render->GetExtraParams(render, keyValueListValueOne, listLenth);
265 EXPECT_EQ(HDF_SUCCESS, ret);
266 EXPECT_STREQ(keyValueListOneExp, keyValueListValueOne);
267 ret = render->SetExtraParams(render, keyValueListTwo);
268 EXPECT_EQ(HDF_SUCCESS, ret);
269 ret = render->GetExtraParams(render, keyValueListValueTwo, listLenth);
270 EXPECT_EQ(HDF_SUCCESS, ret);
271 EXPECT_STREQ(keyValueListTwoExp, keyValueListValueTwo);
272 ret = render->SetExtraParams(render, keyValueListThr);
273 EXPECT_EQ(HDF_SUCCESS, ret);
274 ret = render->GetExtraParams(render, keyValueListValueThr, listLenth);
275 EXPECT_EQ(HDF_SUCCESS, ret);
276 EXPECT_STREQ(keyValueListThrExp, keyValueListValueThr);
277 ret = render->SetExtraParams(render, keyValueListFour);
278 EXPECT_EQ(HDF_SUCCESS, ret);
279 ret = render->GetExtraParams(render, keyValueListValueFour, listLenth);
280 EXPECT_EQ(HDF_SUCCESS, ret);
281 EXPECT_STREQ(keyValueListFourExp, keyValueListValueFour);
282 ret = render->Stop(render);
283 EXPECT_EQ(HDF_SUCCESS, ret);
284 }
285 /**
286 * @tc.name AudioRenderSetExtraParams_003
287 * @tc.desc Test RenderSetExtraParams interface,return -1 if the Keyvaluelist is a value out of range
288 * @tc.type: FUNC
289 */
290 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParams_003, TestSize.Level1)
291 {
292 int32_t ret;
293 char keyValueList[] = "attr-para=abc;";
294
295 ASSERT_NE(nullptr, render);
296 ret = ret = render->SetExtraParams(render, keyValueList);
297 EXPECT_EQ(HDF_FAILURE, ret);
298 }
299 /**
300 * @tc.name AudioRenderSetExtraParams_004
301 * @tc.desc Test RenderSetExtraParams interface,return -1 if adding parameters to keyvaluelist
302 * @tc.type: FUNC
303 */
304 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParams_004, TestSize.Level1)
305 {
306 int32_t ret;
307 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;\
308 attr-frame-count=82;attr-sampling-rate=48000;attr-para=123";
309
310 ASSERT_NE(nullptr, render);
311 ret = render->SetExtraParams(render, keyValueList);
312 EXPECT_EQ(HDF_FAILURE, ret);
313 }
314 /**
315 * @tc.name AudioRenderSetExtraParams_005
316 * @tc.desc Test RenderSetExtraParams interface,return 0 if set ExtraParams When the key is the same and the value
317 is different
318 * @tc.type: FUNC
319 */
320 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParams_005, TestSize.Level1)
321 {
322 int32_t ret;
323 char keyValueList[] = "attr-sampling-rate=48000;attr-sampling-rate=96000;attr-frame-count=4096;";
324 char keyValueListExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=4096;\
325 attr-sampling-rate=96000";
326 char keyValueListValue[256] = {};
327 int32_t listLenth = 256;
328
329 ASSERT_NE(nullptr, render);
330 ret = AudioRenderStartAndOneFrame(render);
331 EXPECT_EQ(HDF_SUCCESS, ret);
332 ret = render->SetExtraParams(render, keyValueList);
333 EXPECT_EQ(HDF_SUCCESS, ret);
334 ret = render->GetExtraParams(render, keyValueListValue, listLenth);
335 EXPECT_EQ(HDF_SUCCESS, ret);
336 EXPECT_STREQ(keyValueListExp, keyValueListValue);
337
338 ret = render->Stop(render);
339 EXPECT_EQ(HDF_SUCCESS, ret);
340 }
341 /**
342 * @tc.name AudioRenderSetExtraParams_006
343 * @tc.desc Test RenderSetExtraParams interface,return -1 if Set the parameter in keyvaluelist
344 as an abnormal value
345 * @tc.type: FUNC
346 */
347 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParams_006, TestSize.Level1)
348 {
349 int32_t ret;
350 char attrSamplingRateError[] = "attr-sampling-rate=1234567;";
351 char attrChannelsError[] = "attr-channels=3;";
352 char attrFrameCountError[] = "attr-frame-count=111111111111111111111;";
353 char attrRouteError[] = "attr-route=5;";
354 char attrFormateError[] = "attr-formate=12;";
355
356 ASSERT_NE(nullptr, render);
357 ret = render->SetExtraParams(render, attrSamplingRateError);
358 EXPECT_EQ(HDF_FAILURE, ret);
359 ret = render->SetExtraParams(render, attrChannelsError);
360 EXPECT_EQ(HDF_FAILURE, ret);
361 ret = render->SetExtraParams(render, attrFrameCountError);
362 EXPECT_EQ(HDF_FAILURE, ret);
363 ret = render->SetExtraParams(render, attrRouteError);
364 EXPECT_EQ(HDF_FAILURE, ret);
365 ret = render->SetExtraParams(render, attrFormateError);
366 EXPECT_EQ(HDF_FAILURE, ret);
367 }
368 /**
369 * @tc.name AudioRenderSetExtraParamsNull_007
370 * @tc.desc Test RenderSetExtraParams interface,return -3/-4 if set the parameter render is nullptr
371 * @tc.type: FUNC
372 */
373 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParamsNull_007, TestSize.Level1)
374 {
375 int32_t ret;
376 struct IAudioRender *renderNull = nullptr;
377 char keyValueList[] = "attr-format=2;";
378
379 ASSERT_NE(nullptr, render);
380 ret = render->SetExtraParams(renderNull, keyValueList);
381 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
382 }
383 /**
384 * @tc.name AudioRenderSetExtraParams_008
385 * @tc.desc Test RenderSetExtraParams interface,return -1 if set the format of ExtraParams is nullptr
386 * @tc.type: FUNC
387 */
388 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParams_008, TestSize.Level1)
389 {
390 int32_t ret;
391 char keyValueLnullptr[] = "attr-format=;";
392
393 ASSERT_NE(nullptr, render);
394 ret = render->SetExtraParams(render, keyValueLnullptr);
395 EXPECT_EQ(HDF_FAILURE, ret);
396 }
397 /**
398 * @tc.name AudioRenderSetExtraParamsNull_009
399 * @tc.desc Test RenderSetExtraParams interface,return -3 if set the format of ExtraParams is nullptr
400 * @tc.type: FUNC
401 */
402 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParamsNull_009, TestSize.Level1)
403 {
404 int32_t ret;
405 char *keyValueListNull = nullptr;
406
407 ASSERT_NE(nullptr, render);
408 ret = render->SetExtraParams(render, keyValueListNull);
409 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
410 }
411 /**
412
413 * @tc.name AudioRenderGetExtraParams_001
414 * @tc.desc Test RenderGetExtraParams interface,return 0 if the RenderGetExtraParams was obtained successfully
415 * @tc.type: FUNC
416 */
417 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetExtraParams_001, TestSize.Level1)
418 {
419 int32_t ret;
420 uint64_t count = 0;
421 struct AudioSampleAttributes attrsValue = {};
422 char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
423 char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\
424 attr-sampling-rate=48000";
425 char keyValueListValue[256] = {};
426 int32_t listLenth = 256;
427 int32_t formatExp = 3;
428 uint32_t sampleRateExp = 48000;
429 uint32_t channelCountExp = 2;
430 uint32_t frameCountExp = 4096;
431
432 ASSERT_NE(nullptr, render);
433 ret = AudioRenderStartAndOneFrame(render);
434 EXPECT_EQ(HDF_SUCCESS, ret);
435 ret = render->SetExtraParams(render, keyValueList);
436 EXPECT_EQ(HDF_SUCCESS, ret);
437 ret = render->GetExtraParams(render, keyValueListValue, listLenth);
438 EXPECT_EQ(HDF_SUCCESS, ret);
439 EXPECT_STREQ(keyValueListExp, keyValueListValue);
440
441 ret = render->GetSampleAttributes(render, &attrsValue);
442 EXPECT_EQ(HDF_SUCCESS, ret);
443 EXPECT_EQ(formatExp, attrsValue.format);
444 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
445 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
446 ret = render->GetFrameCount(render, &count);
447 EXPECT_EQ(HDF_SUCCESS, ret);
448 EXPECT_EQ(count, frameCountExp);
449
450 ret = render->Stop(render);
451 EXPECT_EQ(HDF_SUCCESS, ret);
452 }
453 /**
454 * @tc.name AudioRenderGetExtraParamsNull_002
455 * @tc.desc Test RenderGetExtraParams interface,return -3/-4 if set the parameter render is nullptr
456 * @tc.type: FUNC
457 */
458 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetExtraParamsNull_002, TestSize.Level1)
459 {
460 int32_t ret;
461 struct IAudioRender *renderNull = nullptr;
462 char keyValueList[] = "attr-format=32;";
463 char keyValueListValue[256] = {};
464 int32_t listLenth = 256;
465
466 ASSERT_NE(nullptr, render);
467 ret = render->SetExtraParams(render, keyValueList);
468 EXPECT_EQ(HDF_SUCCESS, ret);
469 ret = render->GetExtraParams(renderNull, keyValueListValue, listLenth);
470 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
471 }
472 /**
473 * @tc.name AudioRenderGetExtraParams_003
474 * @tc.desc Test RenderGetExtraParams interface,return -1 if set listlength to be less than the actual length
475 * @tc.type: FUNC
476 */
477 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetExtraParams_003, TestSize.Level1)
478 {
479 int32_t ret;
480 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000;";
481 char keyValueListValue[256] = {};
482 int32_t listLenth = 8;
483
484 ASSERT_NE(nullptr, render);
485 ret = render->SetExtraParams(render, keyValueList);
486 EXPECT_EQ(HDF_SUCCESS, ret);
487 ret = render->GetExtraParams(render, keyValueListValue, listLenth);
488 EXPECT_EQ(HDF_FAILURE, ret);
489 }
490 /**
491 * @tc.name AudioRenderGetExtraParams_004
492 * @tc.desc Test RenderGetExtraParams interface,return 0 if set listlenth equal to the actual length
493 * @tc.type: FUNC
494 */
495 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetExtraParams_004, TestSize.Level1)
496 {
497 int32_t ret;
498 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=11111111111111111111;\
499 attr-sampling-rate=48000";
500 char keyValueListValue[256] = {};
501 int32_t listLenth = 107;
502
503 ASSERT_NE(nullptr, render);
504 ret = AudioRenderStartAndOneFrame(render);
505 EXPECT_EQ(HDF_SUCCESS, ret);
506 ret = render->SetExtraParams(render, keyValueList);
507 EXPECT_EQ(HDF_SUCCESS, ret);
508 ret = render->GetExtraParams(render, keyValueListValue, listLenth);
509 EXPECT_EQ(HDF_SUCCESS, ret);
510 EXPECT_STREQ(keyValueList, keyValueListValue);
511
512 ret = render->Stop(render);
513 EXPECT_EQ(HDF_SUCCESS, ret);
514 }
515 /**
516 * @tc.name AudioRenderReqMmapBuffer_001
517 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully
518 * @tc.type: FUNC
519 */
520
521 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderReqMmapBuffer_001, TestSize.Level1)
522 {
523 int32_t ret;
524 bool isRender = true;
525 int32_t reqSize = 0;
526 struct AudioMmapBufferDescripter desc = {};
527 struct AudioSampleAttributes attrs = {};
528 ASSERT_NE(nullptr, render);
529
530 InitAttrs(attrs);
531 attrs.startThreshold = 0;
532 ret = render->SetSampleAttributes(render, &attrs);
533 EXPECT_EQ(HDF_SUCCESS, ret);
534 ret = InitMmapDesc(LOW_LATENCY_AUDIO_FILE, desc, reqSize, isRender);
535 EXPECT_EQ(HDF_SUCCESS, ret);
536 ret = render->Start(render);
537 EXPECT_EQ(HDF_SUCCESS, ret);
538 ret = render->ReqMmapBuffer(render, reqSize, &desc);
539 EXPECT_EQ(HDF_SUCCESS, ret);
540 if (ret == 0) {
541 munmap(desc.memoryAddress, reqSize);
542 }
543 render->Stop(render);
544 free(desc.filePath);
545 }
546 /**
547 * @tc.name AudioRenderReqMmapBuffer_002
548 * @tc.desc Test ReqMmapBuffer interface,return -1 if call ReqMmapBuffer interface unsuccessfully when setting the
549 incoming parameter reqSize is bigger than the size of actual audio file
550 * @tc.type: FUNC
551 */
552 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderReqMmapBuffer_002, TestSize.Level1)
553 {
554 int32_t ret;
555 bool isRender = true;
556 int32_t reqSize = 0;
557 struct AudioMmapBufferDescripter desc = {};
558 ASSERT_NE(nullptr, render);
559
560 ret = InitMmapDesc(LOW_LATENCY_AUDIO_FILE, desc, reqSize, isRender);
561 EXPECT_EQ(HDF_SUCCESS, ret);
562 reqSize = reqSize + BUFFER_LENTH;
563 ret = render->Start(render);
564 EXPECT_EQ(HDF_SUCCESS, ret);
565 ret = render->ReqMmapBuffer(render, reqSize, &desc);
566 EXPECT_EQ(HDF_FAILURE, ret);
567 render->Stop(render);
568 free(desc.filePath);
569 }
570 /**
571 * @tc.name AudioRenderReqMmapBuffer_003
572 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully when setting the
573 incoming parameter reqSize is smaller than the size of actual audio file
574 * @tc.type: FUNC
575 */
576 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderReqMmapBuffer_003, TestSize.Level1)
577 {
578 int32_t ret;
579 bool isRender = true;
580 int32_t reqSize = 0;
581 struct AudioMmapBufferDescripter desc = {};
582 ASSERT_NE(nullptr, render);
583
584 ret = InitMmapDesc(LOW_LATENCY_AUDIO_FILE, desc, reqSize, isRender);
585 EXPECT_EQ(HDF_SUCCESS, ret);
586 ret = render->Start(render);
587 EXPECT_EQ(HDF_SUCCESS, ret);
588 reqSize = reqSize / 2; // change reqSize less than the size of actual audio file
589 ret = render->ReqMmapBuffer(render, reqSize, &desc);
590 EXPECT_EQ(HDF_SUCCESS, ret);
591 if (ret == 0) {
592 munmap(desc.memoryAddress, reqSize);
593 }
594 render->Stop(render);
595 free(desc.filePath);
596 }
597 /**
598 * @tc.name AudioRenderReqMmapBuffer_004
599 * @tc.desc Test ReqMmapBuffer interface,return -1 if call ReqMmapBuffer interface unsuccessfully when setting the
600 incoming parameter reqSize is zero
601 * @tc.type: FUNC
602 */
603 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderReqMmapBuffer_004, TestSize.Level1)
604 {
605 int32_t ret;
606 bool isRender = true;
607 int32_t reqSize = 0;
608 struct AudioMmapBufferDescripter desc = {};
609 ASSERT_NE(nullptr, render);
610
611 ret = InitMmapDesc(LOW_LATENCY_AUDIO_FILE, desc, reqSize, isRender);
612 EXPECT_EQ(HDF_SUCCESS, ret);
613 reqSize = 0;
614 ret = render->Start(render);
615 EXPECT_EQ(HDF_SUCCESS, ret);
616 ret = render->ReqMmapBuffer(render, reqSize, &desc);
617 EXPECT_EQ(HDF_FAILURE, ret);
618 render->Stop(render);
619 free(desc.filePath);
620 }
621 /**
622 * @tc.name AudioRenderReqMmapBuffer_005
623 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessfully when setting the
624 incoming parameter memoryFd of desc is illegal
625 * @tc.type: FUNC
626 */
627 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderReqMmapBuffer_005, TestSize.Level1)
628 {
629 int32_t ret;
630 bool isRender = true;
631 int32_t reqSize = 0;
632 struct AudioMmapBufferDescripter desc = {};
633
634 ASSERT_NE(nullptr, render);
635 ret = InitMmapDesc(LOW_LATENCY_AUDIO_FILE, desc, reqSize, isRender);
636 EXPECT_EQ(HDF_SUCCESS, ret);
637 free(desc.filePath);
638 desc.filePath = strdup("/bin/audio.wav");
639 ret = render->Start(render);
640 EXPECT_EQ(HDF_SUCCESS, ret);
641 ret = render->ReqMmapBuffer(render, reqSize, &desc);
642 EXPECT_EQ(HDF_FAILURE, ret);
643 render->Stop(render);
644 free(desc.filePath);
645 }
646 /**
647 * @tc.name AudioRenderReqMmapBufferNull_006
648 * @tc.desc Test ReqMmapBuffer interface,return -3/-4 if call ReqMmapBuffer interface unsuccessfully when setting the
649 incoming parameter handle is nullptr
650 * @tc.type: FUNC
651 */
652 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderReqMmapBufferNull_006, TestSize.Level1)
653 {
654 int32_t ret;
655 bool isRender = true;
656 int32_t reqSize = 0;
657 struct AudioMmapBufferDescripter desc = {};
658 struct IAudioRender *renderNull = nullptr;
659
660 ASSERT_NE(nullptr, render);
661 ret = InitMmapDesc(LOW_LATENCY_AUDIO_FILE, desc, reqSize, isRender);
662 EXPECT_EQ(HDF_SUCCESS, ret);
663 ret = render->Start(render);
664 EXPECT_EQ(HDF_SUCCESS, ret);
665 ret = render->ReqMmapBuffer(renderNull, reqSize, &desc);
666 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
667 render->Stop(render);
668 free(desc.filePath);
669 }
670 /**
671 * @tc.name AudioRenderReqMmapBufferNull_007
672 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessfully when setting the
673 incoming parameter desc is nullptr
674 * @tc.type: FUNC
675 */
676 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderReqMmapBufferNull_007, TestSize.Level1)
677 {
678 int32_t ret;
679 bool isRender = true;
680 int32_t reqSize = 0;
681 struct AudioMmapBufferDescripter desc = {};
682 struct AudioMmapBufferDescripter *descNull = nullptr;
683 ASSERT_NE(nullptr, render);
684 ret = InitMmapDesc(LOW_LATENCY_AUDIO_FILE, desc, reqSize, isRender);
685 EXPECT_EQ(HDF_SUCCESS, ret);
686 ret = render->Start(render);
687 EXPECT_EQ(HDF_SUCCESS, ret);
688 ret = render->ReqMmapBuffer(render, reqSize, descNull);
689 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
690 render->Stop(render);
691 free(desc.filePath);
692 }
693 /**
694 * @tc.name AudioRenderGetMmapPosition_001
695 * @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully.
696 * @tc.type: FUNC
697 */
698 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetMmapPosition_001, TestSize.Level1)
699 {
700 int32_t ret;
701 uint64_t frames = 0;
702 uint64_t framesRendering = 0;
703 uint64_t framesexpRender = 0;
704 int64_t timeExp = 0;
705 ASSERT_NE(nullptr, render);
706 struct PrepareAudioPara audiopara = {
707 .path = LOW_LATENCY_AUDIO_FILE.c_str(), .render = render
708 };
709
710 InitAttrs(audiopara.attrs);
711 audiopara.attrs.startThreshold = 0;
712 ret = audiopara.render->SetSampleAttributes(audiopara.render, &(audiopara.attrs));
713 EXPECT_EQ(HDF_SUCCESS, ret);
714 ret = audiopara.render->GetMmapPosition(audiopara.render, &frames, &(audiopara.time));
715 EXPECT_EQ(HDF_SUCCESS, ret);
716 EXPECT_EQ((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
717 EXPECT_EQ(frames, INITIAL_VALUE);
718
719 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayMapAudioFile, &audiopara);
720 ASSERT_EQ(HDF_SUCCESS, ret);
721 sleep(1);
722 ret = audiopara.render->GetMmapPosition(audiopara.render, &framesRendering, &(audiopara.time));
723 EXPECT_EQ(HDF_SUCCESS, ret);
724 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
725 EXPECT_GT(framesRendering, INITIAL_VALUE);
726 int64_t timeExprendering = (audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec);
727 void *result = nullptr;
728 pthread_join(audiopara.tids, &result);
729 EXPECT_EQ(HDF_SUCCESS, (intptr_t)result);
730 ret = audiopara.render->GetMmapPosition(audiopara.render, &framesexpRender, &(audiopara.time));
731 EXPECT_EQ(HDF_SUCCESS, ret);
732 EXPECT_GE((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExprendering);
733 EXPECT_GE(framesexpRender, framesRendering);
734 audiopara.render->Stop(audiopara.render);
735 }
736
737 /**
738 * @tc.name AudioRenderGetMmapPositionNull_003
739 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
740 * @tc.type: FUNC
741 */
742 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetMmapPositionNull_003, TestSize.Level1)
743 {
744 int32_t ret;
745 uint64_t *frames = nullptr;
746 struct AudioTimeStamp time = {};
747
748 ASSERT_NE(nullptr, render);
749 ret = render->GetMmapPosition(render, frames, &time);
750 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
751 }
752 /**
753 * @tc.name AudioRenderGetMmapPositionNull_004
754 * @tc.desc Test GetMmapPosition interface,return -3/-4 if Error in incoming parameter.
755 * @tc.type: FUNC
756 */
757 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetMmapPositionNull_004, TestSize.Level1)
758 {
759 int32_t ret;
760 uint64_t frames = 0;
761 struct AudioTimeStamp *time = nullptr;
762
763 ASSERT_NE(nullptr, render);
764 ret = render->GetMmapPosition(render, &frames, time);
765 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
766 }
767 /**
768 * @tc.name AudioRenderGetMmapPositionNull_005
769 * @tc.desc Test GetMmapPosition interface,return -3/-4 if Error in incoming parameter.
770 * @tc.type: FUNC
771 */
772 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetMmapPositionNull_005, TestSize.Level1)
773 {
774 int32_t ret;
775 uint64_t frames = 0;
776 struct AudioTimeStamp time = {};
777 struct IAudioRender *renderNull = nullptr;
778
779 ASSERT_NE(nullptr, render);
780 ret = render->GetMmapPosition(renderNull, &frames, &time);
781 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
782 }
783 /**
784 * @tc.name AudioRenderSetSampleAttributesNull_007
785 * @tc.desc Test RenderSetSampleAttributes interface, return -3/-4 if the render is nullptr.
786 * @tc.type: FUNC
787 */
788 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetSampleAttributesNull_007, TestSize.Level1)
789 {
790 int32_t ret;
791 struct IAudioRender *renderNull = nullptr;
792 struct AudioSampleAttributes attrs = {};
793 ASSERT_NE(nullptr, render);
794 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_8000);
795
796 ret = render->SetSampleAttributes(renderNull, &attrs);
797 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
798 ret = render->SetSampleAttributes(render, nullptr);
799 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
800 }
801 /**
802 * @tc.name AudioRenderGetSampleAttributesNull_002
803 * @tc.desc Test AudioRendereGetSampleAttributes interface, return -3/-4 if the render is nullptr.
804 * @tc.type: FUNC
805 */
806 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetSampleAttributesNull_002, TestSize.Level1)
807 {
808 int32_t ret;
809 struct IAudioRender *renderNull = nullptr;
810 struct AudioSampleAttributes attrs = {};
811 struct AudioSampleAttributes *attrsValue = nullptr;
812 ASSERT_NE(nullptr, render);
813 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_44100);
814
815 ret = render->GetSampleAttributes(renderNull, &attrs);
816 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
817 ret = render->GetSampleAttributes(render, attrsValue);
818 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
819 }
820 }