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