1 /*
2 * Copyright (c) 2023 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 "osal_mem.h"
18
19 #include "v2_0/audio_types.h"
20 #include "v2_0/iaudio_manager.h"
21 #include "v2_0/iaudio_render.h"
22
23 using namespace std;
24 using namespace testing::ext;
25
26 namespace {
27 const float MAX_GAINTHRESHOLD = 15.0;
28 const float MIN_GAINTHRESHOLD = 0.0;
29 const int BUFFER_LENTH = 1024 * 16;
30 const int DEEP_BUFFER_RENDER_PERIOD_SIZE = 4 * 1024;
31 const int32_t AUDIO_RENDER_BUF_TEST = 1024;
32 const int32_t AUDIO_RENDER_CHANNELCOUNT = 2;
33 const int32_t AUDIO_SAMPLE_RATE_48K = 48000;
34 const int32_t MAX_AUDIO_ADAPTER_DESC = 5;
35 const uint32_t INVALID_SCENE_ID = -1;
36 const uint64_t DEFAULT_BUFFER_SIZE = 16384;
37
38 class AudioUtRenderTest : public testing::Test {
39 public:
40 struct IAudioManager *manager_ = nullptr;
41 struct AudioAdapterDescriptor descs_[MAX_AUDIO_ADAPTER_DESC];
42 struct AudioAdapterDescriptor *desc_;
43 struct IAudioAdapter *adapter_ = nullptr;
44 struct IAudioRender *render_ = nullptr;
45 struct AudioDeviceDescriptor devDescRender_ = {};
46 struct AudioSampleAttributes attrsRender_ = {};
47 uint32_t renderId_ = 0;
48 char *devDescriptorName_ = nullptr;
49 uint32_t size_ = MAX_AUDIO_ADAPTER_DESC;
50 virtual void SetUp();
51 virtual void TearDown();
52 uint64_t GetRenderBufferSize();
53 void InitRenderAttrs(struct AudioSampleAttributes &attrs);
54 void InitRenderDevDesc(struct AudioDeviceDescriptor &devDesc);
55 void FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf);
56 void ReleaseAllAdapterDescs(struct AudioAdapterDescriptor *descs, uint32_t descsLen);
57 };
58
GetRenderBufferSize()59 uint64_t AudioUtRenderTest::GetRenderBufferSize()
60 {
61 int32_t ret = HDF_SUCCESS;
62 uint64_t frameSize = 0;
63 uint64_t frameCount = 0;
64 uint64_t bufferSize = 0;
65
66 if (render_ == nullptr) {
67 return DEFAULT_BUFFER_SIZE;
68 }
69
70 ret = render_->GetFrameSize(render_, &frameSize);
71 if (ret != HDF_SUCCESS) {
72 return DEFAULT_BUFFER_SIZE;
73 }
74
75 ret = render_->GetFrameCount(render_, &frameCount);
76 if (ret != HDF_SUCCESS) {
77 return DEFAULT_BUFFER_SIZE;
78 }
79
80 bufferSize = frameCount * frameSize;
81 if (bufferSize == 0) {
82 bufferSize = DEFAULT_BUFFER_SIZE;
83 }
84
85 return bufferSize;
86 }
87
InitRenderAttrs(struct AudioSampleAttributes & attrs)88 void AudioUtRenderTest::InitRenderAttrs(struct AudioSampleAttributes &attrs)
89 {
90 attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
91 attrs.channelCount = AUDIO_RENDER_CHANNELCOUNT;
92 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
93 attrs.interleaved = 0;
94 attrs.type = AUDIO_IN_MEDIA;
95 attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
96 attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * AUDIO_RENDER_CHANNELCOUNT;
97 attrs.isBigEndian = false;
98 attrs.isSignedData = true;
99 attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.channelCount);
100 attrs.stopThreshold = INT_MAX;
101 attrs.silenceThreshold = BUFFER_LENTH;
102 }
103
InitRenderDevDesc(struct AudioDeviceDescriptor & devDesc)104 void AudioUtRenderTest::InitRenderDevDesc(struct AudioDeviceDescriptor &devDesc)
105 {
106 devDesc.pins = PIN_OUT_SPEAKER;
107 devDescriptorName_ = strdup("cardname");
108 devDesc.desc = devDescriptorName_;
109
110 ASSERT_NE(desc_, nullptr);
111 ASSERT_NE(desc_->ports, nullptr);
112 for (uint32_t index = 0; index < desc_->portsLen; index++) {
113 if (desc_->ports[index].dir == PORT_OUT) {
114 devDesc.portId = desc_->ports[index].portId;
115 return;
116 }
117 }
118 }
119
FreeAdapterElements(struct AudioAdapterDescriptor * dataBlock,bool freeSelf)120 void AudioUtRenderTest::FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)
121 {
122 if (dataBlock == nullptr) {
123 return;
124 }
125
126 OsalMemFree(dataBlock->adapterName);
127
128 OsalMemFree(dataBlock->ports);
129
130 if (freeSelf) {
131 OsalMemFree(dataBlock);
132 }
133 }
134
ReleaseAllAdapterDescs(struct AudioAdapterDescriptor * descs,uint32_t descsLen)135 void AudioUtRenderTest::ReleaseAllAdapterDescs(struct AudioAdapterDescriptor *descs, uint32_t descsLen)
136 {
137 if (descs == nullptr || descsLen == 0) {
138 return;
139 }
140
141 for (uint32_t i = 0; i < descsLen; i++) {
142 FreeAdapterElements(&descs[i], false);
143 }
144 }
145
SetUp()146 void AudioUtRenderTest::SetUp()
147 {
148 manager_ = IAudioManagerGet(false);
149 ASSERT_NE(manager_, nullptr);
150
151 ASSERT_EQ(HDF_SUCCESS, manager_->GetAllAdapters(manager_, descs_, &size_));
152 ASSERT_NE(descs_, nullptr);
153 EXPECT_GE(MAX_AUDIO_ADAPTER_DESC, size_);
154 desc_ = &descs_[0];
155 ASSERT_EQ(HDF_SUCCESS, manager_->LoadAdapter(manager_, desc_, &adapter_));
156 ASSERT_NE(adapter_, nullptr);
157 InitRenderDevDesc(devDescRender_);
158 InitRenderAttrs(attrsRender_);
159
160 int32_t ret = adapter_->CreateRender(adapter_, &devDescRender_, &attrsRender_, &render_, &renderId_);
161 if (ret != HDF_SUCCESS) {
162 attrsRender_.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
163 ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devDescRender_, &attrsRender_, &render_, &renderId_));
164 }
165 ASSERT_NE(render_, nullptr);
166 }
167
TearDown()168 void AudioUtRenderTest::TearDown()
169 {
170 ASSERT_NE(devDescriptorName_, nullptr);
171 free(devDescriptorName_);
172 devDescriptorName_ = nullptr;
173
174 if (adapter_ != nullptr) {
175 adapter_->DestroyRender(adapter_, renderId_);
176 render_ = nullptr;
177 }
178 if (manager_ != nullptr) {
179 manager_->UnloadAdapter(manager_, desc_->adapterName);
180 adapter_ = nullptr;
181 ReleaseAllAdapterDescs(descs_, size_);
182
183 IAudioManagerRelease(manager_, false);
184 }
185 }
186
187 HWTEST_F(AudioUtRenderTest, RenderStartNull001, TestSize.Level1)
188 {
189 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Start(nullptr));
190 render_->Stop(render_);
191 }
192
193 HWTEST_F(AudioUtRenderTest, RenderStartNull002, TestSize.Level1)
194 {
195 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
196 EXPECT_NE(HDF_SUCCESS, render_->Start(render_));
197 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
198 render_->Stop(render_);
199 }
200
201 HWTEST_F(AudioUtRenderTest, RenderStartStopIsValid001, TestSize.Level1)
202 {
203 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
204 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
205 }
206
207 HWTEST_F(AudioUtRenderTest, RenderFlushNull001, TestSize.Level1)
208 {
209 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Flush(nullptr));
210 }
211
212 HWTEST_F(AudioUtRenderTest, RenderFlushIsValid001, TestSize.Level1)
213 {
214 EXPECT_NE(HDF_SUCCESS, render_->Flush(render_));
215 }
216
217 HWTEST_F(AudioUtRenderTest, RenderStopNull001, TestSize.Level1)
218 {
219 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Stop(nullptr));
220 }
221
222 HWTEST_F(AudioUtRenderTest, RenderStopInvalid001, TestSize.Level1)
223 {
224 int32_t ret = render_->Stop(render_);
225 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT || ret == HDF_FAILURE);
226 }
227
228 HWTEST_F(AudioUtRenderTest, RenderGetFrameSizeNull001, TestSize.Level1)
229 {
230 uint64_t frameSize = 0;
231 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetFrameSize(nullptr, &frameSize));
232 }
233
234 HWTEST_F(AudioUtRenderTest, RenderGetFrameSizeNull002, TestSize.Level1)
235 {
236 EXPECT_EQ(HDF_ERR_INVALID_PARAM, render_->GetFrameSize(render_, nullptr));
237 }
238
239 HWTEST_F(AudioUtRenderTest, RenderGetFrameSizeIsValid001, TestSize.Level1)
240 {
241 uint64_t frameSize = 0;
242 EXPECT_EQ(HDF_SUCCESS, render_->GetFrameSize(render_, &frameSize));
243 }
244
245 HWTEST_F(AudioUtRenderTest, RenderGetFrameCountNull001, TestSize.Level1)
246 {
247 uint64_t frameCount = 0;
248 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetFrameCount(nullptr, &frameCount));
249 }
250
251 HWTEST_F(AudioUtRenderTest, RenderGetFrameCountNull002, TestSize.Level1)
252 {
253 EXPECT_EQ(HDF_ERR_INVALID_PARAM, render_->GetFrameCount(render_, nullptr));
254 }
255
256 HWTEST_F(AudioUtRenderTest, RenderGetFrameCountIsValid001, TestSize.Level1)
257 {
258 uint64_t frameCount = 0;
259 EXPECT_EQ(HDF_SUCCESS, render_->GetFrameCount(render_, &frameCount));
260 }
261
262 HWTEST_F(AudioUtRenderTest, RenderSetSampleAttributesNull001, TestSize.Level1)
263 {
264 struct AudioSampleAttributes attrs;
265 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->SetSampleAttributes(nullptr, &attrs));
266 }
267
268 HWTEST_F(AudioUtRenderTest, RenderSetSampleAttributesNull002, TestSize.Level1)
269 {
270 EXPECT_EQ(HDF_ERR_INVALID_PARAM, render_->SetSampleAttributes(render_, nullptr));
271 }
272
273 HWTEST_F(AudioUtRenderTest, RenderSetSampleAttributesIsValid001, TestSize.Level1)
274 {
275 struct AudioSampleAttributes attrs = attrsRender_;
276 EXPECT_EQ(HDF_SUCCESS, render_->SetSampleAttributes(render_, &attrs));
277 }
278
279 HWTEST_F(AudioUtRenderTest, RenderGetSampleAttributesNull001, TestSize.Level1)
280 {
281 struct AudioSampleAttributes attrs;
282 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetSampleAttributes(nullptr, &attrs));
283 }
284
285 HWTEST_F(AudioUtRenderTest, RenderGetSampleAttributesNull002, TestSize.Level1)
286 {
287 EXPECT_EQ(HDF_ERR_INVALID_PARAM, render_->GetSampleAttributes(render_, nullptr));
288 }
289
290 HWTEST_F(AudioUtRenderTest, RenderGetSampleAttributesIsValid001, TestSize.Level1)
291 {
292 struct AudioSampleAttributes attrs;
293 EXPECT_EQ(HDF_SUCCESS, render_->GetSampleAttributes(render_, &attrs));
294 }
295
296 HWTEST_F(AudioUtRenderTest, RenderGetCurrentChannelIdNull001, TestSize.Level1)
297 {
298 uint32_t channelId;
299 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetCurrentChannelId(nullptr, &channelId));
300 }
301
302 HWTEST_F(AudioUtRenderTest, RenderGetCurrentChannelIdNull002, TestSize.Level1)
303 {
304 EXPECT_EQ(HDF_ERR_INVALID_PARAM, render_->GetCurrentChannelId(render_, nullptr));
305 }
306
307 HWTEST_F(AudioUtRenderTest, RenderGetCurrentChannelIdIsValid001, TestSize.Level1)
308 {
309 uint32_t channelId;
310 EXPECT_EQ(HDF_SUCCESS, render_->GetCurrentChannelId(render_, &channelId));
311 }
312
313 HWTEST_F(AudioUtRenderTest, RenderCheckSceneCapabilityNull001, TestSize.Level1)
314 {
315 struct AudioSceneDescriptor scene;
316 bool supported = false;
317 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->CheckSceneCapability(nullptr, &scene, &supported));
318 }
319
320 HWTEST_F(AudioUtRenderTest, RenderCheckSceneCapabilityNull002, TestSize.Level1)
321 {
322 bool supported = false;
323 EXPECT_EQ(HDF_ERR_INVALID_PARAM, render_->CheckSceneCapability(render_, nullptr, &supported));
324 }
325
326 HWTEST_F(AudioUtRenderTest, RenderCheckSceneCapabilityNull003, TestSize.Level1)
327 {
328 struct AudioSceneDescriptor scene;
329 EXPECT_EQ(HDF_ERR_INVALID_PARAM, render_->CheckSceneCapability(render_, &scene, nullptr));
330 }
331
332 HWTEST_F(AudioUtRenderTest, RenderCheckSceneCapabilityInValid001, TestSize.Level1)
333 {
334 struct AudioSceneDescriptor scene;
335 bool supported = false;
336 scene.scene.id = INVALID_SCENE_ID;
337 scene.desc = devDescRender_;
338 int32_t ret = render_->CheckSceneCapability(render_, &scene, &supported);
339 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_NOT_SUPPORT);
340 }
341
342 HWTEST_F(AudioUtRenderTest, RenderCheckSceneCapabilityIsValid001, TestSize.Level1)
343 {
344 struct AudioSceneDescriptor scene;
345 bool supported = false;
346 scene.scene.id = AUDIO_IN_MEDIA;
347 scene.desc = devDescRender_;
348 EXPECT_EQ(HDF_SUCCESS, render_->CheckSceneCapability(render_, &scene, &supported));
349 }
350
351 HWTEST_F(AudioUtRenderTest, RenderSelectSceneNull001, TestSize.Level1)
352 {
353 struct AudioSceneDescriptor scene;
354 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->SelectScene(nullptr, &scene));
355 }
356
357 HWTEST_F(AudioUtRenderTest, RenderSelectSceneNull002, TestSize.Level1)
358 {
359 EXPECT_EQ(HDF_ERR_INVALID_PARAM, render_->SelectScene(render_, nullptr));
360 }
361
362 HWTEST_F(AudioUtRenderTest, RenderSelectSceneInValid001, TestSize.Level1)
363 {
364 struct AudioSceneDescriptor scene;
365 scene.scene.id = INVALID_SCENE_ID;
366 scene.desc.pins = PIN_OUT_HEADSET;
367 scene.desc.desc = strdup("mic");
368 int32_t ret = render_->SelectScene(render_, &scene);
369 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_NOT_SUPPORT);
370 free(scene.desc.desc);
371 }
372
373 HWTEST_F(AudioUtRenderTest, RenderSelectSceneIsValid001, TestSize.Level1)
374 {
375 struct AudioSceneDescriptor scene;
376 scene.scene.id = AUDIO_IN_MEDIA;
377 scene.desc.pins = PIN_OUT_HEADSET;
378 scene.desc.desc = strdup("mic");
379 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
380 scene.desc.pins = PIN_OUT_SPEAKER;
381 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
382 free(scene.desc.desc);
383 }
384
385 HWTEST_F(AudioUtRenderTest, RenderGetLatencyNull001, TestSize.Level1)
386 {
387 uint32_t ms = 0;
388 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetLatency(nullptr, &ms));
389 }
390
391 HWTEST_F(AudioUtRenderTest, RenderGetLatencyNull002, TestSize.Level1)
392 {
393 EXPECT_EQ(HDF_ERR_INVALID_PARAM, render_->GetLatency(render_, nullptr));
394 }
395
396 HWTEST_F(AudioUtRenderTest, RenderGetLatencyIsValid001, TestSize.Level1)
397 {
398 uint32_t ms = 0;
399 EXPECT_EQ(HDF_SUCCESS, render_->GetLatency(render_, &ms));
400 }
401
402 HWTEST_F(AudioUtRenderTest, RenderGetRenderPositionNull001, TestSize.Level1)
403 {
404 uint64_t frames = 0;
405 struct AudioTimeStamp time;
406 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetRenderPosition(nullptr, &frames, &time));
407 }
408
409 HWTEST_F(AudioUtRenderTest, RenderGetRenderPositionNull002, TestSize.Level1)
410 {
411 struct AudioTimeStamp time;
412 EXPECT_EQ(HDF_ERR_INVALID_PARAM, render_->GetRenderPosition(render_, nullptr, &time));
413 }
414
415 HWTEST_F(AudioUtRenderTest, RenderGetRenderPositionNull003, TestSize.Level1)
416 {
417 uint64_t frames = 0;
418 EXPECT_EQ(HDF_ERR_INVALID_PARAM, render_->GetRenderPosition(render_, &frames, nullptr));
419 }
420
421 HWTEST_F(AudioUtRenderTest, RenderGetRenderPositionIsValid001, TestSize.Level1)
422 {
423 uint64_t frames = 0;
424 struct AudioTimeStamp time;
425 time.tvSec = 0;
426 time.tvNSec = 0;
427 int32_t ret = render_->GetRenderPosition(render_, &frames, &time);
428
429 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
430 }
431
432 HWTEST_F(AudioUtRenderTest, RenderGetRenderPositionIsValid002, TestSize.Level1)
433 {
434 uint64_t frames;
435 struct AudioTimeStamp time;
436 uint32_t frameLen = (uint64_t)GetRenderBufferSize();
437 uint64_t requestBytes = frameLen;
438
439 int32_t ret = render_->Start(render_);
440 EXPECT_EQ(ret, HDF_SUCCESS);
441
442 int8_t *frame = (int8_t *)calloc(1, frameLen);
443 EXPECT_NE(nullptr, frame);
444
445 ret = render_->RenderFrame(render_, frame, frameLen, &requestBytes);
446 EXPECT_EQ(ret, HDF_SUCCESS);
447
448 ret = render_->GetRenderPosition(render_, &frames, &time);
449 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
450
451 render_->Stop(render_);
452 if (frame != nullptr) {
453 free(frame);
454 frame = nullptr;
455 }
456 }
457
458 HWTEST_F(AudioUtRenderTest, RenderSetExtraParamsNull001, TestSize.Level1)
459 {
460 char keyValueList[AUDIO_RENDER_BUF_TEST];
461 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->SetExtraParams(nullptr, keyValueList));
462 }
463
464 HWTEST_F(AudioUtRenderTest, RenderSetExtraParamsNull002, TestSize.Level1)
465 {
466 EXPECT_EQ(HDF_ERR_INVALID_PARAM, render_->SetExtraParams(render_, nullptr));
467 }
468
469 HWTEST_F(AudioUtRenderTest, RenderSetExtraParamsIsValid001, TestSize.Level1)
470 {
471 char keyValueList[AUDIO_RENDER_BUF_TEST] =
472 "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
473 EXPECT_EQ(HDF_SUCCESS, render_->SetExtraParams(render_, keyValueList));
474 }
475
476 HWTEST_F(AudioUtRenderTest, RenderGetExtraParamsNull001, TestSize.Level1)
477 {
478 char keyValueList[AUDIO_RENDER_BUF_TEST];
479 uint32_t keyValueListLen = 0;
480 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetExtraParams(nullptr, keyValueList, keyValueListLen));
481 }
482
483 HWTEST_F(AudioUtRenderTest, RenderGetExtraParamsNull002, TestSize.Level1)
484 {
485 uint32_t keyValueListLen = 0;
486 EXPECT_EQ(HDF_ERR_INVALID_PARAM, render_->GetExtraParams(render_, nullptr, keyValueListLen));
487 }
488
489 HWTEST_F(AudioUtRenderTest, RenderGetExtraParamsIsValid001, TestSize.Level1)
490 {
491 char keyValueList[AUDIO_RENDER_BUF_TEST] = {};
492 uint32_t keyValueListLen = BUFFER_LENTH;
493 int32_t ret = render_->GetExtraParams(render_, keyValueList, keyValueListLen);
494 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
495 }
496
497 HWTEST_F(AudioUtRenderTest, RenderTurnStandbyModeNull001, TestSize.Level1)
498 {
499 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->TurnStandbyMode(nullptr));
500 }
501
502 HWTEST_F(AudioUtRenderTest, RenderTurnStandbyModeIsValid001, TestSize.Level1)
503 {
504 int32_t ret = render_->Start(render_);
505 EXPECT_EQ(HDF_SUCCESS, ret);
506
507 ret = render_->TurnStandbyMode(render_);
508 EXPECT_EQ(HDF_SUCCESS, ret);
509
510 ret = render_->Stop(render_);
511 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT || ret == HDF_SUCCESS);
512 }
513
514 HWTEST_F(AudioUtRenderTest, RenderAudioDevDumpNull001, TestSize.Level1)
515 {
516 int32_t range = 4;
517 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AudioDevDump(nullptr, range, -1));
518 }
519
520 HWTEST_F(AudioUtRenderTest, RenderAudioDevDumpIsValid001, TestSize.Level1)
521 {
522 int32_t range = 4;
523 char pathBuf[] = "/data/RenderDump.log";
524
525 FILE *file = fopen(pathBuf, "wb+");
526 ASSERT_NE(nullptr, file);
527 int fd = fileno(file);
528 if (fd == -1) {
529 fclose(file);
530 ASSERT_NE(fd, -1);
531 }
532
533 int32_t ret = render_->AudioDevDump(render_, range, fd);
534
535 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
536 fclose(file);
537 }
538
539 HWTEST_F(AudioUtRenderTest, RenderGetGainNull001, TestSize.Level1)
540 {
541 float gain;
542 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetGain(nullptr, &gain));
543 }
544
545 HWTEST_F(AudioUtRenderTest, RenderGetGainIsValid001, TestSize.Level1)
546 {
547 float gain;
548 int32_t ret = render_->GetGain(render_, &gain);
549
550 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
551 }
552
553 HWTEST_F(AudioUtRenderTest, RenderGetGainThresholdNull001, TestSize.Level1)
554 {
555 float min = 0.0;
556 float max = 1.0;
557 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetGainThreshold(nullptr, &min, &max));
558 }
559
560 HWTEST_F(AudioUtRenderTest, RenderGetGainThresholdIsValid001, TestSize.Level1)
561 {
562 float min = 0.0;
563 float max = 1.0;
564 int32_t ret = render_->GetGainThreshold(render_, &min, &max);
565
566 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
567 EXPECT_GE(min, MIN_GAINTHRESHOLD);
568 EXPECT_LE(max, MAX_GAINTHRESHOLD);
569 }
570
571 HWTEST_F(AudioUtRenderTest, RenderGetMuteNull001, TestSize.Level1)
572 {
573 bool isMute = false;
574 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetMute(nullptr, &isMute));
575 }
576
577 HWTEST_F(AudioUtRenderTest, RenderGetMuteIsValid001, TestSize.Level1)
578 {
579 bool isMute = false;
580 int32_t ret = render_->GetMute(render_, &isMute);
581
582 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
583 }
584
585 HWTEST_F(AudioUtRenderTest, RenderGetVersionNull001, TestSize.Level1)
586 {
587 uint32_t majorVer;
588 uint32_t minorVer;
589 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetVersion(nullptr, &majorVer, &minorVer));
590 }
591
592 HWTEST_F(AudioUtRenderTest, RenderGetVersionIsValid001, TestSize.Level1)
593 {
594 uint32_t majorVer;
595 uint32_t minorVer;
596 ASSERT_EQ(HDF_SUCCESS, render_->GetVersion(render_, &majorVer, &minorVer));
597 EXPECT_EQ(IAUDIO_MANAGER_MAJOR_VERSION, majorVer);
598 EXPECT_EQ(IAUDIO_MANAGER_MINOR_VERSION, minorVer);
599 }
600
601 HWTEST_F(AudioUtRenderTest, RenderGetVolumeNull001, TestSize.Level1)
602 {
603 float val = 0.0;
604 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetVolume(nullptr, &val));
605 }
606
607 HWTEST_F(AudioUtRenderTest, RenderGetVolumeIsValid001, TestSize.Level1)
608 {
609 float val = 0.0;
610 int32_t ret = render_->GetVolume(render_, &val);
611
612 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
613 }
614
615 HWTEST_F(AudioUtRenderTest, RenderPauseNull001, TestSize.Level1)
616 {
617 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Pause(nullptr));
618 }
619
620 HWTEST_F(AudioUtRenderTest, RenderResumeNull001, TestSize.Level1)
621 {
622 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Resume(nullptr));
623 }
624
625 HWTEST_F(AudioUtRenderTest, RenderResumeInvalid001, TestSize.Level1)
626 {
627 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Resume(render_));
628 }
629
630 HWTEST_F(AudioUtRenderTest, RenderPauseResumeIsValid001, TestSize.Level1)
631 {
632 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
633 int32_t ret = render_->Pause(render_);
634
635 if (ret == HDF_SUCCESS) {
636 EXPECT_EQ(HDF_SUCCESS, render_->Resume(render_));
637 } else if (ret == HDF_ERR_NOT_SUPPORT) {
638 ASSERT_TRUE(true);
639 } else {
640 ASSERT_TRUE(false);
641 }
642
643 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
644 }
645
646 HWTEST_F(AudioUtRenderTest, RenderRenderFrameNull001, TestSize.Level1)
647 {
648 uint32_t frameLen = DEFAULT_BUFFER_SIZE;
649 uint64_t requestBytes = frameLen;
650 int8_t *frame = (int8_t *)calloc(1, frameLen);
651 ASSERT_NE(nullptr, frame);
652 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->RenderFrame(nullptr, frame, frameLen, &requestBytes));
653 if (frame != nullptr) {
654 free(frame);
655 frame = nullptr;
656 }
657 }
658
659 HWTEST_F(AudioUtRenderTest, RenderRenderFrameIsValid001, TestSize.Level1)
660 {
661 uint32_t frameLen = (uint64_t)GetRenderBufferSize();
662 uint64_t requestBytes = frameLen;
663 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
664
665 int8_t *frame = (int8_t *)calloc(1, frameLen);
666 ASSERT_NE(nullptr, frame);
667 EXPECT_EQ(HDF_SUCCESS, render_->RenderFrame(render_, frame, frameLen, &requestBytes));
668
669 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
670
671 if (frame != nullptr) {
672 free(frame);
673 frame = nullptr;
674 }
675 }
676
677 HWTEST_F(AudioUtRenderTest, RenderSetChannelModeNull001, TestSize.Level1)
678 {
679 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
680 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->SetChannelMode(nullptr, mode));
681 }
682
683 HWTEST_F(AudioUtRenderTest, RenderSetChannelModeIsValid001, TestSize.Level1)
684 {
685 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
686 int32_t ret = render_->SetChannelMode(render_, mode);
687
688 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
689 }
690
691 HWTEST_F(AudioUtRenderTest, RenderSetGainNull001, TestSize.Level1)
692 {
693 float gain = 1.0;
694 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->SetGain(nullptr, gain));
695 }
696
697 HWTEST_F(AudioUtRenderTest, RenderSetGainIsValid001, TestSize.Level1)
698 {
699 float gain = 1.0;
700 int32_t ret = render_->SetGain(render_, gain);
701
702 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
703 }
704
705 HWTEST_F(AudioUtRenderTest, RenderSetMuteNull001, TestSize.Level1)
706 {
707 bool mute = false;
708 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->SetMute(nullptr, mute));
709 }
710
711 HWTEST_F(AudioUtRenderTest, RenderSetMuteIsValid001, TestSize.Level1)
712 {
713 bool mute = false;
714 int32_t ret = render_->SetMute(render_, mute);
715
716 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
717 }
718
719 HWTEST_F(AudioUtRenderTest, RenderSetRenderSpeedNull001, TestSize.Level1)
720 {
721 float speed = 2.0;
722 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->SetRenderSpeed(nullptr, speed));
723 }
724
725 HWTEST_F(AudioUtRenderTest, RenderSetRenderSpeedIsValid001, TestSize.Level1)
726 {
727 float speed = 2.0;
728 EXPECT_NE(HDF_SUCCESS, render_->SetRenderSpeed(render_, speed));
729 }
730
731 HWTEST_F(AudioUtRenderTest, RenderSetVolumeNull001, TestSize.Level1)
732 {
733 float volume = 0.2;
734 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->SetVolume(nullptr, volume));
735 }
736
737 HWTEST_F(AudioUtRenderTest, RenderSetVolumeIsInValid001, TestSize.Level1)
738 {
739 float volume = -1.0;
740 EXPECT_NE(HDF_SUCCESS, render_->SetVolume(render_, volume));
741 }
742
743 HWTEST_F(AudioUtRenderTest, RenderSetVolumeIsInValid002, TestSize.Level1)
744 {
745 float volume = 2.0;
746 EXPECT_NE(HDF_SUCCESS, render_->SetVolume(render_, volume));
747 }
748
749 HWTEST_F(AudioUtRenderTest, RenderSetVolumeIsValid001, TestSize.Level1)
750 {
751 float volume = 0.2;
752 int32_t ret = render_->SetVolume(render_, volume);
753
754 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
755 }
756
757 HWTEST_F(AudioUtRenderTest, RenderGetRenderSpeedIsInValid001, TestSize.Level1)
758 {
759 float speed = 0.0;
760 ASSERT_EQ(HDF_SUCCESS, render_->Start(render_));
761 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetRenderSpeed(nullptr, &speed));
762 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->GetRenderSpeed(render_, nullptr));
763 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
764 }
765
766 HWTEST_F(AudioUtRenderTest, RenderGetRenderSpeedIsValid001, TestSize.Level1)
767 {
768 float speed = 0.0;
769 ASSERT_EQ(HDF_SUCCESS, render_->Start(render_));
770 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->GetRenderSpeed(render_, &speed));
771 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
772 }
773
774 HWTEST_F(AudioUtRenderTest, RenderGetChannelModeIsInValid001, TestSize.Level1)
775 {
776 enum AudioChannelMode channelMode = AUDIO_CHANNEL_NORMAL;
777 int32_t ret = render_->GetChannelMode(nullptr, &channelMode);
778 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
779
780 ret = render_->GetChannelMode(render_, nullptr);
781 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
782 }
783
784 HWTEST_F(AudioUtRenderTest, RenderGetChannelModeIsValid001, TestSize.Level1)
785 {
786 enum AudioChannelMode channelMode = AUDIO_CHANNEL_NORMAL;
787 int32_t ret = render_->GetChannelMode(render_, &channelMode);
788 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
789 }
790
791 HWTEST_F(AudioUtRenderTest, RenderRegCallbackIsInValid001, TestSize.Level1)
792 {
793 int8_t cookie = 0;
794 struct IAudioCallback *audioCallback = nullptr;
795 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->RegCallback(nullptr, audioCallback, cookie));
796 EXPECT_EQ(HDF_ERR_INVALID_PARAM, render_->RegCallback(render_, nullptr, cookie));
797 }
798
799 HWTEST_F(AudioUtRenderTest, RenderRegCallbackIsValid001, TestSize.Level1)
800 {
801 int8_t cookie = 0;
802 struct IAudioCallback *audioCallback = nullptr;
803 int32_t ret = render_->RegCallback(render_, audioCallback, cookie);
804 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
805 }
806
807 HWTEST_F(AudioUtRenderTest, RenderDrainBufferIsInValid001, TestSize.Level1)
808 {
809 enum AudioDrainNotifyType type = AUDIO_DRAIN_NORMAL_MODE;
810 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->DrainBuffer(nullptr, &type));
811 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->DrainBuffer(render_, nullptr));
812 }
813
814 HWTEST_F(AudioUtRenderTest, RenderDrainBufferIsValid001, TestSize.Level1)
815 {
816 enum AudioDrainNotifyType type = AUDIO_DRAIN_NORMAL_MODE;
817 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->DrainBuffer(render_, &type));
818 }
819
820 HWTEST_F(AudioUtRenderTest, RenderIsSupportsDrainIsInValid001, TestSize.Level1)
821 {
822 bool support = false;
823 int32_t ret = render_->IsSupportsDrain(nullptr, &support);
824 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
825 ret = render_->IsSupportsDrain(render_, nullptr);
826 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
827 }
828
829 HWTEST_F(AudioUtRenderTest, RenderIsSupportsDrainIsValid001, TestSize.Level1)
830 {
831 bool support = false;
832 int32_t ret = render_->IsSupportsDrain(render_, &support);
833 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT || ret == HDF_SUCCESS);
834 }
835
836 HWTEST_F(AudioUtRenderTest, RenderAddAudioEffectIsInValid001, TestSize.Level1)
837 {
838 uint64_t effectId = 0;
839 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AddAudioEffect(nullptr, effectId));
840 }
841
842 HWTEST_F(AudioUtRenderTest, RenderRemoveAudioEffectIsInValid001, TestSize.Level1)
843 {
844 uint64_t effectId = 0;
845 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->RemoveAudioEffect(nullptr, effectId));
846 }
847
848 HWTEST_F(AudioUtRenderTest, RenderGetFrameBufferSizeIsInValid001, TestSize.Level1)
849 {
850 uint64_t bufferSize = BUFFER_LENTH;
851 int32_t ret = render_->GetFrameBufferSize(nullptr, &bufferSize);
852 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
853
854 ret = render_->GetFrameBufferSize(render_, nullptr);
855 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
856 }
857
858 HWTEST_F(AudioUtRenderTest, RenderGetFrameBufferSizeIsValid001, TestSize.Level1)
859 {
860 uint64_t bufferSize = BUFFER_LENTH;
861 int32_t ret = render_->GetFrameBufferSize(render_, &bufferSize);
862 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
863 }
864
865 HWTEST_F(AudioUtRenderTest, RenderIsSupportsPauseAndResumeIsInValid001, TestSize.Level1)
866 {
867 bool supportPause = false;
868 bool supportResume = false;
869 int32_t ret = render_->IsSupportsPauseAndResume(nullptr, &supportPause, &supportResume);
870 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
871
872 ret = render_->IsSupportsPauseAndResume(render_, nullptr, &supportResume);
873 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
874
875 ret = render_->IsSupportsPauseAndResume(render_, &supportPause, nullptr);
876 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
877 }
878
879 HWTEST_F(AudioUtRenderTest, RenderIsSupportsPauseAndResumeIsValid001, TestSize.Level1)
880 {
881 bool supportPause = false;
882 bool supportResume = false;
883 int32_t ret = render_->IsSupportsPauseAndResume(render_, &supportPause, &supportResume);
884 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
885 }
886
887 } // end of namespace
888