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