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