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