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 uint32_t renderId_;
34 };
35
36 TestAudioManager *AudioIdlHdiRenderAttrTest::manager = nullptr;
37 using THREAD_FUNC = void *(*)(void *);
38
SetUpTestCase(void)39 void AudioIdlHdiRenderAttrTest::SetUpTestCase(void)
40 {
41 manager = IAudioManagerGet(IS_STUB);
42 ASSERT_NE(nullptr, manager);
43 }
44
TearDownTestCase(void)45 void AudioIdlHdiRenderAttrTest::TearDownTestCase(void)
46 {
47 if (manager != nullptr) {
48 (void)IAudioManagerRelease(manager, IS_STUB);
49 }
50 }
51
SetUp(void)52 void AudioIdlHdiRenderAttrTest::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 AudioIdlHdiRenderAttrTest::TearDown(void)
60 {
61 int32_t ret = ReleaseRenderSource(manager, adapter, render, renderId_);
62 ASSERT_EQ(HDF_SUCCESS, ret);
63 }
64
65
66 /**
67 * @tc.name AudioRenderGetFrameSize_001
68 * @tc.desc Test RenderGetFrameSize interface,return 0 if the FrameSize was obtained successfully
69 * @tc.type: FUNC
70 */
71 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetFrameSize_001, TestSize.Level1)
72 {
73 int32_t ret;
74 uint64_t size = 0;
75 uint64_t zero = 0;
76 ASSERT_NE(nullptr, render);
77
78 ret = render->GetFrameSize(render, &size);
79 EXPECT_EQ(HDF_SUCCESS, ret);
80 EXPECT_GT(size, zero);
81 }
82 /**
83 * @tc.name AudioRenderGetFrameSizeNull_002
84 * @tc.desc Test RenderGetFrameSize interface,return -3/-4 if failed to get the FrameSize when handle is nullptr
85 * @tc.type: FUNC
86 */
87 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetFrameSizeNull_002, TestSize.Level1)
88 {
89 int32_t ret;
90 uint64_t size = 0;
91 struct IAudioRender *renderNull = nullptr;
92 ASSERT_NE(nullptr, render);
93
94 ret = render->GetFrameSize(renderNull, &size);
95 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
96 }
97 /**
98 * @tc.name AudioRenderGetFrameCount_001
99 * @tc.desc Test RenderGetFrameCount interface, return 0 if the FrameSize was obtained successfully
100 * @tc.type: FUNC
101 */
102 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetFrameCount_001, TestSize.Level1)
103 {
104 int32_t ret;
105 uint64_t count = 0;
106 uint64_t zero = 0;
107 ASSERT_NE(nullptr, render);
108 ret = AudioRenderStartAndOneFrame(render);
109 EXPECT_EQ(HDF_SUCCESS, ret);
110
111 ret = render->GetFrameCount(render, &count);
112 EXPECT_EQ(HDF_SUCCESS, ret);
113 EXPECT_GT(count, zero);
114 render->Stop(render);
115 }
116 /**
117 * @tc.name AudioRenderGetFrameCountNull_002
118 * @tc.desc Test RenderGetFrameCount interface,return -3/-4 if the incoming parameter handle is nullptr
119 * @tc.type: FUNC
120 */
121 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetFrameCountNull_002, TestSize.Level1)
122 {
123 int32_t ret;
124 uint64_t count = 0;
125 struct IAudioRender *renderNull = nullptr;
126 ASSERT_NE(nullptr, render);
127 ret = AudioRenderStartAndOneFrame(render);
128 EXPECT_EQ(HDF_SUCCESS, ret);
129
130 ret = render->GetFrameCount(renderNull, &count);
131 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
132 render->Stop(render);
133 }
134 /**
135 * @tc.name AudioRenderGetFrameCountNull_003
136 * @tc.desc Test RenderGetFrameCount interface,return -3 if the incoming parameter count is nullptr
137 * @tc.type: FUNC
138 */
139 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetFrameCountNull_003, TestSize.Level1)
140 {
141 int32_t ret;
142 uint64_t *countNull = nullptr;
143 ASSERT_NE(nullptr, render);
144 ret = AudioRenderStartAndOneFrame(render);
145 EXPECT_EQ(HDF_SUCCESS, ret);
146
147 ret = render->GetFrameCount(render, countNull);
148 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
149
150 render->Stop(render);
151 }
152 /**
153 * @tc.name AudioRenderGetCurrentChannelId_001
154 * @tc.desc Test RenderGetCurrentChannelId, return 0 if the default CurrentChannelId is obtained successfully
155 * @tc.type: FUNC
156 */
157 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetCurrentChannelId_001, TestSize.Level1)
158 {
159 int32_t ret;
160 uint32_t channelId = 0;
161 uint32_t channelIdValue = CHANNELCOUNT;
162
163 ASSERT_NE(nullptr, render);
164 ret = render->GetCurrentChannelId(render, &channelId);
165 EXPECT_EQ(HDF_SUCCESS, ret);
166 EXPECT_EQ(channelIdValue, channelId);
167 }
168 /**
169 * @tc.name AudioRenderGetCurrentChannelIdNull_003
170 * @tc.desc Test GetCurrentChannelId interface,return -3/-4 if set the parameter render is nullptr
171 * @tc.type: FUNC
172 */
173 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetCurrentChannelIdNull_003, TestSize.Level1)
174 {
175 int32_t ret;
176 uint32_t channelId = 0;
177 struct IAudioRender *renderNull = nullptr;
178 ASSERT_NE(nullptr, render);
179
180 ret = render->GetCurrentChannelId(renderNull, &channelId);
181 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
182 }
183 /**
184 * @tc.name AudioRenderGetCurrentChannelIdNull_004
185 * @tc.desc Test RenderGetCurrentChannelId interface, return -3 if setting the parameter channelId is nullptr
186 * @tc.type: FUNC
187 */
188 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetCurrentChannelIdNull_004, TestSize.Level1)
189 {
190 int32_t ret;
191 uint32_t *channelIdNull = nullptr;
192
193 ASSERT_NE(nullptr, render);
194 ret = render->GetCurrentChannelId(render, channelIdNull);
195 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
196 }
197 /**
198 * @tc.name AudioRenderSetExtraParams_001
199 * @tc.desc Test RenderSetExtraParams interface,return 0 if the ExtraParams is set during playback
200 * @tc.type: FUNC
201 */
202 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParams_001, TestSize.Level1)
203 {
204 int32_t ret;
205 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
206 char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-sampling-rate=48000";
207 size_t index = 1;
208 char keyValueListValue[256] = {};
209 int32_t listLenth = 256;
210 ASSERT_NE(nullptr, render);
211 struct PrepareAudioPara audiopara = {
212 .path = AUDIO_FILE.c_str(), .render = render
213 };
214
215 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
216 ASSERT_EQ(HDF_SUCCESS, ret);
217 sleep(1);
218 if (audiopara.render != nullptr) {
219 ret = audiopara.render->SetExtraParams(audiopara.render, keyValueList);
220 EXPECT_EQ(HDF_SUCCESS, ret);
221 ret = audiopara.render->GetExtraParams(audiopara.render, keyValueListValue, listLenth);
222 if (ret == HDF_SUCCESS) {
223 string strGetValue = keyValueListValue;
224 size_t indexAttr = strGetValue.find("attr-frame-count");
225 size_t indexFlag = strGetValue.rfind(";");
226 if (indexAttr != string::npos && indexFlag != string::npos) {
227 strGetValue.replace(indexAttr, indexFlag - indexAttr + index, "");
228 }
229 EXPECT_STREQ(keyValueListExp, strGetValue.c_str());
230 }
231 }
232
233 ret = ThreadRelease(audiopara);
234 EXPECT_EQ(HDF_SUCCESS, ret);
235 }
236 /**
237 * @tc.name AudioRenderSetExtraParams_002
238 * @tc.desc Test RenderSetExtraParams interface,return 0 if some parameters is set after playing
239 * @tc.type: FUNC
240 */
241 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParams_002, TestSize.Level1)
242 {
243 int32_t ret;
244 char keyValueListOne[] = "attr-frame-count=1024;";
245 char keyValueListOneExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=1024;\
246 attr-sampling-rate=48000";
247 char keyValueListTwo[] = "attr-format=16;attr-frame-count=1024;";
248 char keyValueListTwoExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=1024;\
249 attr-sampling-rate=48000";
250 char keyValueListThr[] = "attr-route=1;attr-channels=1;attr-frame-count=1024;";
251 char keyValueListThrExp[] = "attr-route=1;attr-format=16;attr-channels=1;attr-frame-count=1024;\
252 attr-sampling-rate=48000";
253 char keyValueListFour[] = "attr-format=32;attr-channels=2;attr-frame-count=4096;attr-sampling-rate=48000";
254 char keyValueListFourExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=4096;\
255 attr-sampling-rate=48000";
256 char keyValueListValueOne[256] = {};
257 char keyValueListValueTwo[256] = {};
258 char keyValueListValueThr[256] = {};
259 char keyValueListValueFour[256] = {};
260 int32_t listLenth = 256;
261 ASSERT_NE(nullptr, render);
262 ret = AudioRenderStartAndOneFrame(render);
263 EXPECT_EQ(HDF_SUCCESS, ret);
264 ret = render->SetExtraParams(render, keyValueListOne);
265 EXPECT_EQ(HDF_SUCCESS, ret);
266 ret = render->GetExtraParams(render, keyValueListValueOne, listLenth);
267 if (ret == HDF_SUCCESS) {
268 EXPECT_STREQ(keyValueListOneExp, keyValueListValueOne);
269 }
270
271 ret = render->SetExtraParams(render, keyValueListTwo);
272 EXPECT_EQ(HDF_SUCCESS, ret);
273 ret = render->GetExtraParams(render, keyValueListValueTwo, listLenth);
274 if (ret == HDF_SUCCESS) {
275 EXPECT_STREQ(keyValueListTwoExp, keyValueListValueTwo);
276 }
277
278 ret = render->SetExtraParams(render, keyValueListThr);
279 EXPECT_EQ(HDF_SUCCESS, ret);
280 ret = render->GetExtraParams(render, keyValueListValueThr, listLenth);
281 if (ret == HDF_SUCCESS) {
282 EXPECT_STREQ(keyValueListThrExp, keyValueListValueThr);
283 }
284
285 ret = render->SetExtraParams(render, keyValueListFour);
286 EXPECT_EQ(HDF_SUCCESS, ret);
287 ret = render->GetExtraParams(render, keyValueListValueFour, listLenth);
288 if (ret == HDF_SUCCESS) {
289 EXPECT_STREQ(keyValueListFourExp, keyValueListValueFour);
290 }
291
292 ret = render->Stop(render);
293 EXPECT_EQ(HDF_SUCCESS, ret);
294 }
295 /**
296 * @tc.name AudioRenderSetExtraParams_003
297 * @tc.desc Test RenderSetExtraParams interface,return -1 if the Keyvaluelist is a value out of range
298 * @tc.type: FUNC
299 */
300 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParams_003, TestSize.Level1)
301 {
302 int32_t ret;
303 char keyValueList[] = "attr-para=abc;";
304
305 ASSERT_NE(nullptr, render);
306 ret = ret = render->SetExtraParams(render, keyValueList);
307 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_SUCCESS);
308 }
309 /**
310 * @tc.name AudioRenderSetExtraParams_004
311 * @tc.desc Test RenderSetExtraParams interface,return -1 if adding parameters to keyvaluelist
312 * @tc.type: FUNC
313 */
314 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParams_004, TestSize.Level1)
315 {
316 int32_t ret;
317 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;\
318 attr-frame-count=82;attr-sampling-rate=48000;attr-para=123";
319
320 ASSERT_NE(nullptr, render);
321 ret = render->SetExtraParams(render, keyValueList);
322 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_SUCCESS);
323 }
324 /**
325 * @tc.name AudioRenderSetExtraParams_005
326 * @tc.desc Test RenderSetExtraParams interface,return 0 if set ExtraParams When the key is the same and the value
327 is different
328 * @tc.type: FUNC
329 */
330 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParams_005, TestSize.Level1)
331 {
332 int32_t ret;
333 char keyValueList[] = "attr-sampling-rate=48000;attr-sampling-rate=96000;attr-frame-count=4096;";
334 char keyValueListExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=4096;\
335 attr-sampling-rate=96000";
336 char keyValueListValue[256] = {};
337 int32_t listLenth = 256;
338
339 ASSERT_NE(nullptr, render);
340 ret = AudioRenderStartAndOneFrame(render);
341 EXPECT_EQ(HDF_SUCCESS, ret);
342 ret = render->SetExtraParams(render, keyValueList);
343 EXPECT_EQ(HDF_SUCCESS, ret);
344 ret = render->GetExtraParams(render, keyValueListValue, listLenth);
345 if (ret == HDF_SUCCESS) {
346 EXPECT_STREQ(keyValueListExp, keyValueListValue);
347 }
348
349 ret = render->Stop(render);
350 EXPECT_EQ(HDF_SUCCESS, ret);
351 }
352 /**
353 * @tc.name AudioRenderSetExtraParams_006
354 * @tc.desc Test RenderSetExtraParams interface,return -1 if Set the parameter in keyvaluelist
355 as an abnormal value
356 * @tc.type: FUNC
357 */
358 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParams_006, TestSize.Level1)
359 {
360 int32_t ret;
361 char attrSamplingRateError[] = "attr-sampling-rate=1234567;";
362 char attrChannelsError[] = "attr-channels=3;";
363 char attrFrameCountError[] = "attr-frame-count=111111111111111111111;";
364 char attrRouteError[] = "attr-route=5;";
365 char attrFormateError[] = "attr-formate=12;";
366
367 ASSERT_NE(nullptr, render);
368 ret = render->SetExtraParams(render, attrSamplingRateError);
369 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_SUCCESS);
370 ret = render->SetExtraParams(render, attrChannelsError);
371 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_SUCCESS);
372 ret = render->SetExtraParams(render, attrFrameCountError);
373 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_SUCCESS);
374 ret = render->SetExtraParams(render, attrRouteError);
375 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_SUCCESS);
376 ret = render->SetExtraParams(render, attrFormateError);
377 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_SUCCESS);
378 }
379 /**
380 * @tc.name AudioRenderSetExtraParamsNull_007
381 * @tc.desc Test RenderSetExtraParams interface,return -3/-4 if set the parameter render is nullptr
382 * @tc.type: FUNC
383 */
384 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParamsNull_007, TestSize.Level1)
385 {
386 int32_t ret;
387 struct IAudioRender *renderNull = nullptr;
388 char keyValueList[] = "attr-format=2;";
389
390 ASSERT_NE(nullptr, render);
391 ret = render->SetExtraParams(renderNull, keyValueList);
392 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
393 }
394 /**
395 * @tc.name AudioRenderSetExtraParams_008
396 * @tc.desc Test RenderSetExtraParams interface,return -1 if set the format of ExtraParams is nullptr
397 * @tc.type: FUNC
398 */
399 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParams_008, TestSize.Level1)
400 {
401 int32_t ret;
402 char keyValueLnullptr[] = "attr-format=;";
403
404 ASSERT_NE(nullptr, render);
405 ret = render->SetExtraParams(render, keyValueLnullptr);
406 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_SUCCESS);
407 }
408 /**
409 * @tc.name AudioRenderSetExtraParamsNull_009
410 * @tc.desc Test RenderSetExtraParams interface,return -3 if set the format of ExtraParams is nullptr
411 * @tc.type: FUNC
412 */
413 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetExtraParamsNull_009, TestSize.Level1)
414 {
415 int32_t ret;
416 char *keyValueListNull = nullptr;
417
418 ASSERT_NE(nullptr, render);
419 ret = render->SetExtraParams(render, keyValueListNull);
420 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
421 }
422 /**
423
424 * @tc.name AudioRenderGetExtraParams_001
425 * @tc.desc Test RenderGetExtraParams interface,return 0 if the RenderGetExtraParams was obtained successfully
426 * @tc.type: FUNC
427 */
428 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetExtraParams_001, TestSize.Level1)
429 {
430 int32_t ret;
431 uint64_t count = 0;
432 struct AudioSampleAttributes attrsValue = {};
433 char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
434 char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\
435 attr-sampling-rate=48000";
436 char keyValueListValue[256] = {};
437 int32_t listLenth = 256;
438 int32_t formatExp = 3;
439 uint32_t sampleRateExp = 48000;
440 uint32_t channelCountExp = 2;
441 uint32_t frameCountExp = 4096;
442
443 ASSERT_NE(nullptr, render);
444 ret = AudioRenderStartAndOneFrame(render);
445 EXPECT_EQ(HDF_SUCCESS, ret);
446 ret = render->SetExtraParams(render, keyValueList);
447 EXPECT_EQ(HDF_SUCCESS, ret);
448 ret = render->GetExtraParams(render, keyValueListValue, listLenth);
449 if (ret == HDF_SUCCESS) {
450 EXPECT_STREQ(keyValueListExp, keyValueListValue);
451 ret = render->GetSampleAttributes(render, &attrsValue);
452 EXPECT_EQ(HDF_SUCCESS, ret);
453 EXPECT_EQ(formatExp, attrsValue.format);
454 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
455 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
456 ret = render->GetFrameCount(render, &count);
457 EXPECT_EQ(HDF_SUCCESS, ret);
458 EXPECT_EQ(count, frameCountExp);
459 }
460
461 ret = render->Stop(render);
462 EXPECT_EQ(HDF_SUCCESS, ret);
463 }
464 /**
465 * @tc.name AudioRenderGetExtraParamsNull_002
466 * @tc.desc Test RenderGetExtraParams interface,return -3/-4 if set the parameter render is nullptr
467 * @tc.type: FUNC
468 */
469 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetExtraParamsNull_002, TestSize.Level1)
470 {
471 int32_t ret;
472 struct IAudioRender *renderNull = nullptr;
473 char keyValueList[] = "attr-format=32;";
474 char keyValueListValue[256] = {};
475 int32_t listLenth = 256;
476
477 ASSERT_NE(nullptr, render);
478 ret = render->SetExtraParams(render, keyValueList);
479 EXPECT_EQ(HDF_SUCCESS, ret);
480 ret = render->GetExtraParams(renderNull, keyValueListValue, listLenth);
481 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
482 }
483 /**
484 * @tc.name AudioRenderGetExtraParams_003
485 * @tc.desc Test RenderGetExtraParams interface,return -1 if set listlength to be less than the actual length
486 * @tc.type: FUNC
487 */
488 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetExtraParams_003, TestSize.Level1)
489 {
490 int32_t ret;
491 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000;";
492 char keyValueListValue[256] = {};
493 int32_t listLenth = 8;
494
495 ASSERT_NE(nullptr, render);
496 ret = render->SetExtraParams(render, keyValueList);
497 EXPECT_EQ(HDF_SUCCESS, ret);
498 ret = render->GetExtraParams(render, keyValueListValue, listLenth);
499 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_INVALID_PARAM);
500 }
501 /**
502 * @tc.name AudioRenderGetExtraParams_004
503 * @tc.desc Test RenderGetExtraParams interface,return 0 if set listlenth equal to the actual length
504 * @tc.type: FUNC
505 */
506 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetExtraParams_004, TestSize.Level1)
507 {
508 int32_t ret;
509 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=11111111111111111111;\
510 attr-sampling-rate=48000";
511 char keyValueListValue[256] = {};
512 int32_t listLenth = 107;
513
514 ASSERT_NE(nullptr, render);
515 ret = AudioRenderStartAndOneFrame(render);
516 EXPECT_EQ(HDF_SUCCESS, ret);
517 ret = render->SetExtraParams(render, keyValueList);
518 EXPECT_EQ(HDF_SUCCESS, ret);
519 ret = render->GetExtraParams(render, keyValueListValue, listLenth);
520 if (ret == HDF_SUCCESS) {
521 EXPECT_STREQ(keyValueList, keyValueListValue);
522 }
523
524 ret = render->Stop(render);
525 EXPECT_EQ(HDF_SUCCESS, ret);
526 }
527
528 /**
529 * @tc.name AudioRenderGetMmapPositionNull_003
530 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
531 * @tc.type: FUNC
532 */
533 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetMmapPositionNull_003, TestSize.Level1)
534 {
535 int32_t ret;
536 uint64_t *frames = nullptr;
537 struct AudioTimeStamp time = {};
538
539 ASSERT_NE(nullptr, render);
540 ret = render->GetMmapPosition(render, frames, &time);
541 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
542 }
543 /**
544 * @tc.name AudioRenderGetMmapPositionNull_004
545 * @tc.desc Test GetMmapPosition interface,return -3/-4 if Error in incoming parameter.
546 * @tc.type: FUNC
547 */
548 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetMmapPositionNull_004, TestSize.Level1)
549 {
550 int32_t ret;
551 uint64_t frames = 0;
552 struct AudioTimeStamp *time = nullptr;
553
554 ASSERT_NE(nullptr, render);
555 ret = render->GetMmapPosition(render, &frames, time);
556 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
557 }
558 /**
559 * @tc.name AudioRenderGetMmapPositionNull_005
560 * @tc.desc Test GetMmapPosition interface,return -3/-4 if Error in incoming parameter.
561 * @tc.type: FUNC
562 */
563 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetMmapPositionNull_005, TestSize.Level1)
564 {
565 int32_t ret;
566 uint64_t frames = 0;
567 struct AudioTimeStamp time = {};
568 struct IAudioRender *renderNull = nullptr;
569
570 ASSERT_NE(nullptr, render);
571 ret = render->GetMmapPosition(renderNull, &frames, &time);
572 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
573 }
574 /**
575 * @tc.name AudioRenderSetSampleAttributesNull_007
576 * @tc.desc Test RenderSetSampleAttributes interface, return -3/-4 if the render is nullptr.
577 * @tc.type: FUNC
578 */
579 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderSetSampleAttributesNull_007, TestSize.Level1)
580 {
581 int32_t ret;
582 struct IAudioRender *renderNull = nullptr;
583 struct AudioSampleAttributes attrs = {};
584 ASSERT_NE(nullptr, render);
585 InitAttrsUpdate(attrs, AUDIO_FORMAT_TYPE_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_8000);
586
587 ret = render->SetSampleAttributes(renderNull, &attrs);
588 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
589 ret = render->SetSampleAttributes(render, nullptr);
590 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
591 }
592 /**
593 * @tc.name AudioRenderGetSampleAttributesNull_002
594 * @tc.desc Test AudioRendereGetSampleAttributes interface, return -3/-4 if the render is nullptr.
595 * @tc.type: FUNC
596 */
597 HWTEST_F(AudioIdlHdiRenderAttrTest, AudioRenderGetSampleAttributesNull_002, TestSize.Level1)
598 {
599 int32_t ret;
600 struct IAudioRender *renderNull = nullptr;
601 struct AudioSampleAttributes attrs = {};
602 struct AudioSampleAttributes *attrsValue = nullptr;
603 ASSERT_NE(nullptr, render);
604 InitAttrsUpdate(attrs, AUDIO_FORMAT_TYPE_PCM_16_BIT, SINGLE_CHANNEL_COUNT, SAMPLE_RATE_44100);
605
606 ret = render->GetSampleAttributes(renderNull, &attrs);
607 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
608 ret = render->GetSampleAttributes(render, attrsValue);
609 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
610 }
611 }