1 /*
2 * Copyright (c) 2021 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 /**
17 * @addtogroup Audio
18 * @{
19 *
20 * @brief Defines audio-related APIs, including custom data types and functions for loading drivers,
21 * accessing a driver adapter, and rendering audios.
22 *
23 * @since 1.0
24 * @version 1.0
25 */
26
27 /**
28 * @file audio_hdi_common.h
29 *
30 * @brief Declares APIs for operations related to the audio render adapter.
31 *
32 * @since 1.0
33 * @version 1.0
34 */
35
36 #include "audio_hdi_common.h"
37 #include "audio_hdirender_volume_test.h"
38
39 using namespace std;
40 using namespace testing::ext;
41 using namespace HMOS::Audio;
42
43 namespace {
44 const string ADAPTER_NAME_USB = "usb";
45 const string ADAPTER_NAME_INTERNAL = "internal";
46
47 class AudioHdiRenderVolumeTest : public testing::Test {
48 public:
49 static void SetUpTestCase(void);
50 static void TearDownTestCase(void);
51 void SetUp();
52 void TearDown();
53 static TestAudioManager *(*GetAudioManager)();
54 static void *handleSo;
55 #ifdef AUDIO_MPI_SO
56 static int32_t (*SdkInit)();
57 static void (*SdkExit)();
58 static void *sdkSo;
59 #endif
60 };
61
62 TestAudioManager *(*AudioHdiRenderVolumeTest::GetAudioManager)() = nullptr;
63 void *AudioHdiRenderVolumeTest::handleSo = nullptr;
64 #ifdef AUDIO_MPI_SO
65 int32_t (*AudioHdiRenderVolumeTest::SdkInit)() = nullptr;
66 void (*AudioHdiRenderVolumeTest::SdkExit)() = nullptr;
67 void *AudioHdiRenderVolumeTest::sdkSo = nullptr;
68 #endif
69
SetUpTestCase(void)70 void AudioHdiRenderVolumeTest::SetUpTestCase(void)
71 {
72 #ifdef AUDIO_MPI_SO
73 char sdkResolvedPath[] = "//system/lib/libhdi_audio_interface_lib_render.z.so";
74 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
75 if (sdkSo == nullptr) {
76 return;
77 }
78 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
79 if (SdkInit == nullptr) {
80 return;
81 }
82 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
83 if (SdkExit == nullptr) {
84 return;
85 }
86 SdkInit();
87 #endif
88 handleSo = dlopen(RESOLVED_PATH.c_str(), RTLD_LAZY);
89 if (handleSo == nullptr) {
90 return;
91 }
92 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
93 if (GetAudioManager == nullptr) {
94 return;
95 }
96 }
97
TearDownTestCase(void)98 void AudioHdiRenderVolumeTest::TearDownTestCase(void)
99 {
100 #ifdef AUDIO_MPI_SO
101 SdkExit();
102 if (sdkSo != nullptr) {
103 dlclose(sdkSo);
104 sdkSo = nullptr;
105 }
106 if (SdkInit != nullptr) {
107 SdkInit = nullptr;
108 }
109 if (SdkExit != nullptr) {
110 SdkExit = nullptr;
111 }
112 #endif
113 if (GetAudioManager != nullptr) {
114 GetAudioManager = nullptr;
115 }
116 }
117
SetUp(void)118 void AudioHdiRenderVolumeTest::SetUp(void) {}
TearDown(void)119 void AudioHdiRenderVolumeTest::TearDown(void) {}
120
121 /**
122 * @tc.name Test RenderGetGainThreshold API via legal input
123 * @tc.number SUB_Audio_HDI_RenderGetGainThreshold_0001
124 * @tc.desc Test RenderGetGainThreshold interface,return 0 if the GetGainThreshold is obtained successfully
125 * @tc.author: tiansuli
126 */
127 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0001, TestSize.Level1)
128 {
129 int32_t ret = -1;
130 float min = 0;
131 float max = 0;
132 struct AudioAdapter *adapter = nullptr;
133 struct AudioRender *render = nullptr;
134 ASSERT_NE(nullptr, GetAudioManager);
135 TestAudioManager manager = *GetAudioManager();
136 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
137 ASSERT_EQ(HDF_SUCCESS, ret);
138
139 ret = render->volume.GetGainThreshold((AudioHandle)render, &min, &max);
140 EXPECT_EQ(HDF_SUCCESS, ret);
141 EXPECT_EQ(min, GAIN_MIN);
142 EXPECT_EQ(max, GAIN_MAX);
143
144 adapter->DestroyRender(adapter, render);
145 manager.UnloadAdapter(&manager, adapter);
146 }
147 /**
148 * @tc.name Test RenderGetGainThreshold API via set the parameter render to nullptr
149 * @tc.number SUB_Audio_HDI_RenderGetGainThreshold_0002
150 * @tc.desc Test RenderGetGainThreshold interface, return -1 if set render to nullptr
151 * @tc.author: tiansuli
152 */
153 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0002, TestSize.Level1)
154 {
155 int32_t ret = -1;
156 float min = 0;
157 float max = 0;
158 struct AudioAdapter *adapter = nullptr;
159 struct AudioRender *render = nullptr;
160 struct AudioRender *renderNull = nullptr;
161 ASSERT_NE(nullptr, GetAudioManager);
162 TestAudioManager manager = *GetAudioManager();
163 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
164 ASSERT_EQ(HDF_SUCCESS, ret);
165
166 ret = render->volume.GetGainThreshold((AudioHandle)renderNull, &min, &max);
167 EXPECT_EQ(HDF_FAILURE, ret);
168
169 adapter->DestroyRender(adapter, render);
170 manager.UnloadAdapter(&manager, adapter);
171 }
172 /**
173 * @tc.name Test RenderGetGainThreshold API via set the parameter min to nullptr
174 * @tc.number SUB_Audio_HDI_RenderGetGainThreshold_0003
175 * @tc.desc Test RenderGetGainThreshold interface, return -1 if set min to nullptr
176 * @tc.author: tiansuli
177 */
178 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0003, TestSize.Level1)
179 {
180 int32_t ret = -1;
181 float max = 0;
182 float *minNull = nullptr;
183 struct AudioAdapter *adapter = nullptr;
184 struct AudioRender *render = nullptr;
185 ASSERT_NE(nullptr, GetAudioManager);
186 TestAudioManager manager = *GetAudioManager();
187 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
188 ASSERT_EQ(HDF_SUCCESS, ret);
189
190 ret = render->volume.GetGainThreshold((AudioHandle)render, minNull, &max);
191 EXPECT_EQ(HDF_FAILURE, ret);
192
193 adapter->DestroyRender(adapter, render);
194 manager.UnloadAdapter(&manager, adapter);
195 }
196 /**
197 * @tc.name Test RenderGetGainThreshold API via set the parameter max to nullptr
198 * @tc.number SUB_Audio_HDI_RenderGetGainThreshold_0004
199 * @tc.desc Test RenderGetGainThreshold interface, return -1 if set max to nullptr
200 * @tc.author: tiansuli
201 */
202 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0004, TestSize.Level1)
203 {
204 int32_t ret = -1;
205 float min = 0;
206 float *maxNull = nullptr;
207 struct AudioAdapter *adapter = nullptr;
208 struct AudioRender *render = nullptr;
209 ASSERT_NE(nullptr, GetAudioManager);
210 TestAudioManager manager = *GetAudioManager();
211 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
212 ASSERT_EQ(HDF_SUCCESS, ret);
213 ret = render->volume.GetGainThreshold(render, &min, maxNull);
214 EXPECT_EQ(HDF_FAILURE, ret);
215
216 adapter->DestroyRender(adapter, render);
217 manager.UnloadAdapter(&manager, adapter);
218 }
219 /**
220 * @tc.name Test RenderSetGain API via legal input
221 * @tc.number SUB_Audio_HDI_RenderSetGain_0001
222 * @tc.desc Test RenderSetGain interface,return 0 if Set gain to normal value, maximum or minimum and get success
223 * @tc.author: tiansuli
224 */
225 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0001, TestSize.Level1)
226 {
227 int32_t ret = -1;
228 float min = 0;
229 float max = 0;
230 struct AudioAdapter *adapter = nullptr;
231 struct AudioRender *render = nullptr;
232 ASSERT_NE(nullptr, GetAudioManager);
233 TestAudioManager manager = *GetAudioManager();
234 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
235 ASSERT_EQ(HDF_SUCCESS, ret);
236 ret = render->volume.GetGainThreshold((AudioHandle)render, &min, &max);
237 EXPECT_EQ(HDF_SUCCESS, ret);
238 float gain = 10.8;
239 float gainMax = max;
240 float gainMin = min;
241 float gainExpc = 10;
242 float gainMaxExpc = max;
243 float gainMinExpc = min;
244 ret = render->volume.SetGain(render, gain);
245 EXPECT_EQ(HDF_SUCCESS, ret);
246 ret = render->volume.GetGain(render, &gain);
247 EXPECT_EQ(HDF_SUCCESS, ret);
248 EXPECT_EQ(gainExpc, gain);
249
250 ret = render->volume.SetGain(render, gainMax);
251 EXPECT_EQ(HDF_SUCCESS, ret);
252 ret = render->volume.GetGain(render, &gainMax);
253 EXPECT_EQ(HDF_SUCCESS, ret);
254 EXPECT_EQ(gainMaxExpc, gainMax);
255
256 ret = render->volume.SetGain(render, gainMin);
257 EXPECT_EQ(HDF_SUCCESS, ret);
258 ret = render->volume.GetGain(render, &gainMin);
259 EXPECT_EQ(HDF_SUCCESS, ret);
260 EXPECT_EQ(gainMinExpc, gainMin);
261
262 adapter->DestroyRender(adapter, render);
263 manager.UnloadAdapter(&manager, adapter);
264 }
265 /**
266 * @tc.name Test RenderSetGain API via set gain to the boundary value
267 * @tc.number SUB_Audio_HDI_RenderSetGain_0002
268 * @tc.desc Test RenderSetGain interface,return -1 if Set gain to exceed the boundary value
269 * @tc.author: tiansuli
270 */
271 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0002, TestSize.Level1)
272 {
273 int32_t ret = -1;
274 float min = 0;
275 float max = 0;
276 struct AudioAdapter *adapter = nullptr;
277 struct AudioRender *render = nullptr;
278 ASSERT_NE(nullptr, GetAudioManager);
279 TestAudioManager manager = *GetAudioManager();
280 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
281 ASSERT_EQ(HDF_SUCCESS, ret);
282 ret = render->volume.GetGainThreshold((AudioHandle)render, &min, &max);
283 EXPECT_EQ(HDF_SUCCESS, ret);
284
285 float gainOne = max+1;
286 float gainSec = min-1;
287 ret = render->volume.SetGain(render, gainOne);
288 EXPECT_EQ(HDF_FAILURE, ret);
289
290 ret = render->volume.SetGain(render, gainSec);
291 EXPECT_EQ(HDF_FAILURE, ret);
292
293 adapter->DestroyRender(adapter, render);
294 manager.UnloadAdapter(&manager, adapter);
295 }
296 /**
297 * @tc.name Test RenderSetGain API via set gain to exception type
298 * @tc.number SUB_Audio_HDI_RenderSetGain_0003
299 * @tc.desc Test RenderSetGain interface,return -1 if set gain to exception type
300 * @tc.author: tiansuli
301 */
302 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0003, TestSize.Level1)
303 {
304 int32_t ret = -1;
305 char gain = 'a';
306 struct AudioAdapter *adapter = nullptr;
307 struct AudioRender *render = nullptr;
308 ASSERT_NE(nullptr, GetAudioManager);
309 TestAudioManager manager = *GetAudioManager();
310 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
311 ASSERT_EQ(HDF_SUCCESS, ret);
312
313 ret = render->volume.SetGain(render, gain);
314 EXPECT_EQ(HDF_FAILURE, ret);
315
316 adapter->DestroyRender(adapter, render);
317 manager.UnloadAdapter(&manager, adapter);
318 }
319 /**
320 * @tc.name Test RenderSetGain API via set the parameter render to nullptr
321 * @tc.number SUB_Audio_HDI_RenderSetGain_0004
322 * @tc.desc Test RenderSetGain interface, return -1 if set render to nullptr
323 * @tc.author: tiansuli
324 */
325 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0004, TestSize.Level1)
326 {
327 int32_t ret = -1;
328 float gain = 1;
329 struct AudioAdapter *adapter = nullptr;
330 struct AudioRender *render = nullptr;
331 struct AudioRender *renderNull = nullptr;
332 ASSERT_NE(nullptr, GetAudioManager);
333 TestAudioManager manager = *GetAudioManager();
334 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
335 ASSERT_EQ(HDF_SUCCESS, ret);
336
337 ret = render->volume.SetGain((AudioHandle)renderNull, gain);
338 EXPECT_EQ(HDF_FAILURE, ret);
339
340 adapter->DestroyRender(adapter, render);
341 manager.UnloadAdapter(&manager, adapter);
342 }
343 /**
344 * @tc.name Test RenderGetGain API via legal input
345 * @tc.number SUB_Audio_HDI_RenderGetGain_0001
346 * @tc.desc Test RenderGetGain interface,return 0 if the RenderGetGain was obtained successfully
347 * @tc.author: tiansuli
348 */
349 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0001, TestSize.Level1)
350 {
351 int32_t ret = -1;
352 float min = 0;
353 float max = 0;
354 struct AudioAdapter *adapter = nullptr;
355 struct AudioRender *render = nullptr;
356 ASSERT_NE(nullptr, GetAudioManager);
357 TestAudioManager manager = *GetAudioManager();
358 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
359 ASSERT_EQ(HDF_SUCCESS, ret);
360 ret = render->volume.GetGainThreshold((AudioHandle)render, &min, &max);
361 EXPECT_EQ(HDF_SUCCESS, ret);
362
363 float gain = min+1;
364 float gainValue = min+1;
365 ret = render->volume.SetGain(render, gain);
366 EXPECT_EQ(HDF_SUCCESS, ret);
367 ret = render->volume.GetGain(render, &gain);
368 EXPECT_EQ(HDF_SUCCESS, ret);
369 EXPECT_EQ(gainValue, gain);
370
371 render->control.Stop((AudioHandle)render);
372 adapter->DestroyRender(adapter, render);
373 manager.UnloadAdapter(&manager, adapter);
374 }
375 /**
376 * @tc.name Test RenderGetGain API via set the parameter render to nullptr
377 * @tc.number SUB_Audio_HDI_RenderGetGain_0002
378 * @tc.desc Test RenderGetGain interface, return -1 if get gain set render to nullptr
379 * @tc.author: tiansuli
380 */
381 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0002, TestSize.Level1)
382 {
383 int32_t ret = -1;
384 float gain = 0;
385 struct AudioAdapter *adapter = nullptr;
386 struct AudioRender *render = nullptr;
387 struct AudioRender *renderNull = nullptr;
388 ASSERT_NE(nullptr, GetAudioManager);
389 TestAudioManager manager = *GetAudioManager();
390 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
391 ASSERT_EQ(HDF_SUCCESS, ret);
392
393 ret = render->volume.GetGain((AudioHandle)renderNull, &gain);
394 EXPECT_EQ(HDF_FAILURE, ret);
395 adapter->DestroyRender(adapter, render);
396 manager.UnloadAdapter(&manager, adapter);
397 }
398 /**
399 * @tc.name Test RenderGetGain API via legal input in difference scenes
400 * @tc.number SUB_Audio_HDI_RenderGetGain_0003
401 * @tc.desc Test RenderGetGainThreshold interface, return 0 if get gain before start successfully
402 * @tc.author: tiansuli
403 */
404 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0003, TestSize.Level1)
405 {
406 int32_t ret = -1;
407 float gain = GAIN_MAX-1;
408 float gainOne = GAIN_MAX-1;
409 struct AudioAdapter *adapter = nullptr;
410 struct AudioRender *render = nullptr;
411 ASSERT_NE(nullptr, GetAudioManager);
412 TestAudioManager manager = *GetAudioManager();
413 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
414 ASSERT_EQ(HDF_SUCCESS, ret);
415
416 ret = render->volume.SetGain(render, gain);
417 EXPECT_EQ(HDF_SUCCESS, ret);
418 ret = render->volume.GetGain(render, &gain);
419 EXPECT_EQ(HDF_SUCCESS, ret);
420 EXPECT_EQ(gain, gainOne);
421
422 adapter->DestroyRender(adapter, render);
423 manager.UnloadAdapter(&manager, adapter);
424 }
425 /**
426 * @tc.name Test RenderGetGain API via set the parameter gain to nullptr
427 * @tc.number SUB_Audio_HDI_RenderGetGain_0004
428 * @tc.desc Test RenderGetGain interface, return -1 if get gain set gain to nullptr
429 * @tc.author: tiansuli
430 */
431 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0004, TestSize.Level1)
432 {
433 int32_t ret = -1;
434 float *gainNull = nullptr;
435 struct AudioAdapter *adapter = nullptr;
436 struct AudioRender *render = nullptr;
437 ASSERT_NE(nullptr, GetAudioManager);
438 TestAudioManager manager = *GetAudioManager();
439 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
440 ASSERT_EQ(HDF_SUCCESS, ret);
441 ret = render->volume.GetGain((AudioHandle)render, gainNull);
442 EXPECT_EQ(HDF_FAILURE, ret);
443 adapter->DestroyRender(adapter, render);
444 manager.UnloadAdapter(&manager, adapter);
445 }
446 /**
447 * @tc.name Test AudioRenderSetMute API via legal input.
448 * @tc.number SUB_Audio_HDI_AudioRenderSetMute_0001
449 * @tc.desc Test AudioRenderSetMute interface , return 0 if the audiorender object sets mute successfully.
450 * @tc.author:ZHANGHAILIN
451 */
452 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetMute_0001, TestSize.Level1)
453 {
454 int32_t ret = -1;
455 bool muteFalse = false;
456 bool muteTrue = true;
457 struct AudioAdapter *adapter = nullptr;
458 struct AudioRender *render = nullptr;
459 ASSERT_NE(nullptr, GetAudioManager);
460 TestAudioManager manager = *GetAudioManager();
461 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
462 ASSERT_EQ(HDF_SUCCESS, ret);
463
464 ret = render->volume.SetMute(render, muteFalse);
465 EXPECT_EQ(HDF_SUCCESS, ret);
466 ret = render->volume.GetMute(render, &muteFalse);
467 EXPECT_EQ(HDF_SUCCESS, ret);
468 EXPECT_EQ(false, muteFalse);
469
470 ret = render->volume.SetMute(render, muteTrue);
471 EXPECT_EQ(HDF_SUCCESS, ret);
472 ret = render->volume.GetMute(render, &muteTrue);
473 EXPECT_EQ(HDF_SUCCESS, ret);
474 EXPECT_EQ(true, muteTrue);
475
476 muteTrue = false;
477 ret = render->volume.SetMute(render, muteTrue);
478 EXPECT_EQ(HDF_SUCCESS, ret);
479 EXPECT_FALSE(muteTrue);
480
481 adapter->DestroyRender(adapter, render);
482 manager.UnloadAdapter(&manager, adapter);
483 }
484 /**
485 * @tc.name Test AudioRenderSetMute API via setting the incoming parameter render is empty .
486 * @tc.number SUB_Audio_HDI_AudioRenderSetMute_0002
487 * @tc.desc Test AudioRenderSetMute interface, return -1 if the incoming parameter render is empty.
488 * @tc.author: ZHANGHAILIN
489 */
490 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetMute_0002, TestSize.Level1)
491 {
492 int32_t ret = -1;
493 bool mute = true;
494 struct AudioAdapter *adapter = nullptr;
495 struct AudioRender *render = nullptr;
496 struct AudioRender *renderNull = nullptr;
497 ASSERT_NE(nullptr, GetAudioManager);
498 TestAudioManager manager = *GetAudioManager();
499 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
500 ASSERT_EQ(HDF_SUCCESS, ret);
501 ret = render->volume.SetMute(renderNull, mute);
502 EXPECT_EQ(HDF_FAILURE, ret);
503 adapter->DestroyRender(adapter, render);
504 manager.UnloadAdapter(&manager, adapter);
505 }
506 /**
507 * @tc.name Test AudioRenderSetMute API,when the parameter mutevalue equals 2.
508 * @tc.number SUB_Audio_HDI_AudioRenderSetMute_0003
509 * @tc.desc Test AudioRenderSetMute interface and set the parameter mutevalue with 2.
510 * @tc.author: ZHANGHAILIN
511 */
512 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetMute_0003, TestSize.Level1)
513 {
514 int32_t ret = -1;
515 bool muteValue = 2;
516 struct AudioAdapter *adapter = nullptr;
517 struct AudioRender *render = nullptr;
518 ASSERT_NE(nullptr, GetAudioManager);
519 TestAudioManager manager = *GetAudioManager();
520 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
521 ASSERT_EQ(HDF_SUCCESS, ret);
522
523 ret = render->volume.SetMute(render, muteValue);
524 EXPECT_EQ(HDF_SUCCESS, ret);
525 ret = render->volume.GetMute(render, &muteValue);
526 EXPECT_EQ(HDF_SUCCESS, ret);
527 EXPECT_EQ(true, muteValue);
528
529 adapter->DestroyRender(adapter, render);
530 manager.UnloadAdapter(&manager, adapter);
531 }
532 /**
533 * @tc.name Test AudioRenderGetMute API via legal input.
534 * @tc.number SUB_Audio_HDI_AudioRenderGetMute_0001
535 * @tc.desc Test AudioRenderGetMute interface , return 0 if the audiocapture gets mute successfully.
536 * @tc.author: ZHANGHAILIN
537 */
538 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetMute_0001, TestSize.Level1)
539 {
540 int32_t ret = -1;
541 bool muteTrue = true;
542 bool muteFalse = false;
543 bool defaultmute = true;
544 struct AudioAdapter *adapter = nullptr;
545 struct AudioRender *render = nullptr;
546 ASSERT_NE(nullptr, GetAudioManager);
547 TestAudioManager manager = *GetAudioManager();
548 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
549 ASSERT_EQ(HDF_SUCCESS, ret);
550
551 ret = render->volume.GetMute(render, &muteTrue);
552 EXPECT_EQ(HDF_SUCCESS, ret);
553 EXPECT_EQ(muteTrue, defaultmute);
554
555 ret = render->volume.SetMute(render, muteFalse);
556 EXPECT_EQ(HDF_SUCCESS, ret);
557
558 ret = render->volume.GetMute(render, &muteFalse);
559 EXPECT_EQ(HDF_SUCCESS, ret);
560 EXPECT_FALSE(muteFalse);
561 adapter->DestroyRender(adapter, render);
562 manager.UnloadAdapter(&manager, adapter);
563 }
564 /**
565 * @tc.name Test interface AudioRenderGetMute when incoming parameter render is empty.
566 * @tc.number SUB_Audio_HDI_AudioRenderGetMute_0002
567 * @tc.desc Test AudioRenderGetMute interface, return -1 if the incoming parameter render is empty.
568 * @tc.author: ZHANGHAILIN
569 */
570 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetMute_0002, TestSize.Level1)
571 {
572 int32_t ret = -1;
573 bool muteTrue = true;
574 bool muteFalse = false;
575 struct AudioAdapter *adapter = nullptr;
576 struct AudioRender *render = nullptr;
577 struct AudioRender *renderNull = nullptr;
578 ASSERT_NE(nullptr, GetAudioManager);
579 TestAudioManager manager = *GetAudioManager();
580 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
581 ASSERT_EQ(HDF_SUCCESS, ret);
582 ret = render->volume.GetMute(renderNull, &muteTrue);
583 EXPECT_EQ(HDF_FAILURE, ret);
584
585 ret = render->volume.GetMute(renderNull, &muteFalse);
586 EXPECT_EQ(HDF_FAILURE, ret);
587
588 ret = render->volume.GetMute(render, nullptr);
589 EXPECT_EQ(HDF_FAILURE, ret);
590 adapter->DestroyRender(adapter, render);
591 manager.UnloadAdapter(&manager, adapter);
592 }
593 /**
594 * @tc.name Test AudioRenderSetVolume API via legal input.
595 * @tc.number SUB_Audio_HDI_AudioRenderSetVolume_0001
596 * @tc.desc Test AudioRenderSetVolume interface , return 0 if the audiocapture sets volume successfully.
597 * @tc.author: ZHANGHAILIN
598 */
599 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetVolume_0001, TestSize.Level1)
600 {
601 int32_t ret = -1;
602 float volumeInit = 0.20;
603 float volumeInitExpc = 0.20;
604 float volumeLow = 0.10;
605 float volumeLowExpc = 0.10;
606 float volumeMid = 0.50;
607 float volumeMidExpc = 0.50;
608 float volumeHigh = 0.80;
609 float volumeHighExpc = 0.80;
610 struct AudioAdapter *adapter = nullptr;
611 struct AudioRender *render = nullptr;
612 ASSERT_NE(nullptr, GetAudioManager);
613 TestAudioManager manager = *GetAudioManager();
614 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
615 ASSERT_EQ(HDF_SUCCESS, ret);
616
617 ret = render->volume.SetVolume(render, volumeInit);
618 EXPECT_EQ(HDF_SUCCESS, ret);
619 ret = render->volume.GetVolume(render, &volumeInit);
620 EXPECT_EQ(HDF_SUCCESS, ret);
621 EXPECT_EQ(volumeInitExpc, volumeInit);
622 ret = render->volume.SetVolume(render, volumeLow);
623 EXPECT_EQ(HDF_SUCCESS, ret);
624 ret = render->volume.GetVolume(render, &volumeLow);
625 EXPECT_EQ(HDF_SUCCESS, ret);
626 EXPECT_EQ(volumeLowExpc, volumeLow);
627 ret = render->volume.SetVolume(render, volumeMid);
628 EXPECT_EQ(HDF_SUCCESS, ret);
629 ret = render->volume.GetVolume(render, &volumeMid);
630 EXPECT_EQ(HDF_SUCCESS, ret);
631 EXPECT_EQ(volumeMidExpc, volumeMid);
632 ret = render->volume.SetVolume(render, volumeHigh);
633 EXPECT_EQ(HDF_SUCCESS, ret);
634 ret = render->volume.GetVolume(render, &volumeHigh);
635 EXPECT_EQ(HDF_SUCCESS, ret);
636 EXPECT_EQ(volumeHighExpc, volumeHigh);
637
638 adapter->DestroyRender(adapter, render);
639 manager.UnloadAdapter(&manager, adapter);
640 }
641 /**
642 * @tc.name Test AudioRenderSetVolume,when volume is set maximum value or minimum value.
643 * @tc.number SUB_Audio_HDI_AudioRenderSetVolume_0002
644 * @tc.desc Test AudioRenderSetVolume,return 0 if volume is set maximum value or minimum value.
645 * @tc.author: ZHANGHAILIN
646 */
647 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetVolume_0002, TestSize.Level1)
648 {
649 int32_t ret = -1;
650 float volumeMin = 0;
651 float volumeMinExpc = 0;
652 float volumeMax = 1.0;
653 float volumeMaxExpc = 1.0;
654 float volumeMinBoundary = -1;
655 float volumeMaxBoundary = 1.01;
656 struct AudioAdapter *adapter = nullptr;
657 struct AudioRender *render = nullptr;
658 ASSERT_NE(nullptr, GetAudioManager);
659 TestAudioManager manager = *GetAudioManager();
660 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
661 ASSERT_EQ(HDF_SUCCESS, ret);
662 ret = render->volume.SetVolume(render, volumeMin);
663 EXPECT_EQ(HDF_SUCCESS, ret);
664 ret = render->volume.GetVolume(render, &volumeMin);
665 EXPECT_EQ(HDF_SUCCESS, ret);
666 EXPECT_EQ(volumeMinExpc, volumeMin);
667
668 ret = render->volume.SetVolume(render, volumeMax);
669 EXPECT_EQ(HDF_SUCCESS, ret);
670 ret = render->volume.GetVolume(render, &volumeMax);
671 EXPECT_EQ(HDF_SUCCESS, ret);
672 EXPECT_EQ(volumeMaxExpc, volumeMax);
673
674 ret = render->volume.SetVolume(render, volumeMinBoundary);
675 EXPECT_EQ(HDF_FAILURE, ret);
676
677 ret = render->volume.SetVolume(render, volumeMaxBoundary);
678 EXPECT_EQ(HDF_FAILURE, ret);
679
680 adapter->DestroyRender(adapter, render);
681 manager.UnloadAdapter(&manager, adapter);
682 }
683 /**
684 * @tc.name Test AudioRenderSetVolume,when incoming parameter render is empty.
685 * @tc.number SUB_Audio_HDI_AudioRenderSetVolume_0003
686 * @tc.desc Test AudioRenderSetVolume,return -1 when incoming parameter render is empty.
687 * @tc.author: ZHANGHAILIN
688 */
689 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetVolume_0003, TestSize.Level1)
690 {
691 int32_t ret = -1;
692 float volume = 0;
693 struct AudioAdapter *adapter = nullptr;
694 struct AudioRender *render = nullptr;
695 struct AudioRender *renderNull = nullptr;
696 ASSERT_NE(nullptr, GetAudioManager);
697 TestAudioManager manager = *GetAudioManager();
698 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
699 ASSERT_EQ(HDF_SUCCESS, ret);
700 ret = render->volume.SetVolume(renderNull, volume);
701 EXPECT_EQ(HDF_FAILURE, ret);
702
703 adapter->DestroyRender(adapter, render);
704 manager.UnloadAdapter(&manager, adapter);
705 }
706 /**
707 * @tc.name Test AudioRenderGetVolume API via legal input.
708 * @tc.number SUB_Audio_HDI_AudioRenderGetVolume_001
709 * @tc.desc Test AudioRenderGetVolume interface , return 0 if the audiocapture is get successful.
710 * @tc.author: ZHANGHAILIN
711 */
712 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetVolume_001, TestSize.Level1)
713 {
714 int32_t ret = -1;
715 float volume = 0.30;
716 float volumeDefault = 0.30;
717 struct AudioAdapter *adapter = nullptr;
718 struct AudioRender *render = nullptr;
719 ASSERT_NE(nullptr, GetAudioManager);
720 TestAudioManager manager = *GetAudioManager();
721 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
722 ASSERT_EQ(HDF_SUCCESS, ret);
723
724 ret = render->volume.SetVolume(render, volume);
725 EXPECT_EQ(HDF_SUCCESS, ret);
726 ret = render->volume.GetVolume(render, &volume);
727 EXPECT_EQ(HDF_SUCCESS, ret);
728 EXPECT_EQ(volumeDefault, volume);
729
730 adapter->DestroyRender(adapter, render);
731 manager.UnloadAdapter(&manager, adapter);
732 }
733 /**
734 * @tc.name Test AudioRenderGetVolume when when capturing is in progress.
735 * @tc.number SUB_Audio_HDI_AudioRenderGetVolume_002.
736 * @tc.desc Test AudioRenderGetVolume,return 0 when when capturing is in progress.
737 * @tc.author: ZHANGHAILIN
738 */
739 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetVolume_002, TestSize.Level1)
740 {
741 int32_t ret = -1;
742 float volume = 0.30;
743 float defaultVolume = 0.30;
744 struct AudioAdapter *adapter = nullptr;
745 struct AudioRender *render = nullptr;
746 ASSERT_NE(nullptr, GetAudioManager);
747 TestAudioManager manager = *GetAudioManager();
748 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
749 ASSERT_EQ(HDF_SUCCESS, ret);
750
751 ret = render->volume.SetVolume(render, volume);
752 EXPECT_EQ(HDF_SUCCESS, ret);
753 ret = render->volume.GetVolume(render, &volume);
754 EXPECT_EQ(HDF_SUCCESS, ret);
755 EXPECT_EQ(defaultVolume, volume);
756
757 ret = render->control.Stop((AudioHandle)render);
758 EXPECT_EQ(HDF_SUCCESS, ret);
759 adapter->DestroyRender(adapter, render);
760 manager.UnloadAdapter(&manager, adapter);
761 }
762 /**
763 * @tc.name Test AudioRenderGetVolume,when incoming parameter render is empty.
764 * @tc.number SUB_Audio_HDI_AudioRenderGetVolume_0003
765 * @tc.desc Test AudioRenderGetVolume,return -1 when incoming parameter render is empty.
766 * @tc.author: ZHANGHAILIN
767 */
768 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetVolume_0003, TestSize.Level1)
769 {
770 int32_t ret = -1;
771 float volume = 0.3;
772 struct AudioAdapter *adapter = nullptr;
773 struct AudioRender *render = nullptr;
774 struct AudioRender *renderNull = nullptr;
775 ASSERT_NE(nullptr, GetAudioManager);
776 TestAudioManager manager = *GetAudioManager();
777 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
778 ASSERT_EQ(HDF_SUCCESS, ret);
779 ret = render->volume.GetVolume(renderNull, &volume);
780 EXPECT_EQ(HDF_FAILURE, ret);
781 adapter->DestroyRender(adapter, render);
782 manager.UnloadAdapter(&manager, adapter);
783 }
784 }