1 /*
2 * Copyright (c) 2021-2022 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 OHOS::Audio;
42
43 namespace {
44 class AudioHdiRenderVolumeTest : public testing::Test {
45 public:
46 static void SetUpTestCase(void);
47 static void TearDownTestCase(void);
48 void SetUp();
49 void TearDown();
50 };
51
SetUpTestCase(void)52 void AudioHdiRenderVolumeTest::SetUpTestCase(void) {}
53
TearDownTestCase(void)54 void AudioHdiRenderVolumeTest::TearDownTestCase(void) {}
55
SetUp(void)56 void AudioHdiRenderVolumeTest::SetUp(void) {}
TearDown(void)57 void AudioHdiRenderVolumeTest::TearDown(void) {}
58
59 /**
60 * @tc.name Test RenderGetGainThreshold API via legal input
61 * @tc.number SUB_Audio_HDI_RenderGetGainThreshold_0001
62 * @tc.desc Test RenderGetGainThreshold interface,return 0 if the GetGainThreshold is obtained successfully
63 */
64 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0001, Function | MediumTest | Level1)
65 {
66 int32_t ret = -1;
67 float min = 0;
68 float max = 0;
69 struct AudioAdapter *adapter = nullptr;
70 struct AudioRender *render = nullptr;
71
72 TestAudioManager* manager = GetAudioManagerFuncs();
73 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
74 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
75
76 ret = render->volume.GetGainThreshold((AudioHandle)render, &min, &max);
77 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
78 EXPECT_TRUE(true);
79 }else{
80 EXPECT_TRUE(false);
81 }
82 adapter->DestroyRender(adapter, render);
83 manager->UnloadAdapter(manager, adapter);
84 }
85 /**
86 * @tc.name Test RenderGetGainThreshold API via set the parameter render to nullptr
87 * @tc.number SUB_Audio_HDI_RenderGetGainThreshold_0002
88 * @tc.desc Test RenderGetGainThreshold interface, return -1 if set render to nullptr
89 */
90 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0002, Function | MediumTest | Level1)
91 {
92 int32_t ret = -1;
93 float min = 0;
94 float max = 0;
95 struct AudioAdapter *adapter = nullptr;
96 struct AudioRender *render = nullptr;
97 struct AudioRender *renderNull = nullptr;
98
99 TestAudioManager* manager = GetAudioManagerFuncs();
100 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
101 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
102
103 ret = render->volume.GetGainThreshold((AudioHandle)renderNull, &min, &max);
104 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
105
106 adapter->DestroyRender(adapter, render);
107 manager->UnloadAdapter(manager, adapter);
108 }
109 /**
110 * @tc.name Test RenderGetGainThreshold API via set the parameter min to nullptr
111 * @tc.number SUB_Audio_HDI_RenderGetGainThreshold_0003
112 * @tc.desc Test RenderGetGainThreshold interface, return -1 if set min to nullptr
113 */
114 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0003, Function | MediumTest | Level1)
115 {
116 int32_t ret = -1;
117 float max = 0;
118 float *minNull = nullptr;
119 struct AudioAdapter *adapter = nullptr;
120 struct AudioRender *render = nullptr;
121
122 TestAudioManager* manager = GetAudioManagerFuncs();
123 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
124 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
125
126 ret = render->volume.GetGainThreshold((AudioHandle)render, minNull, &max);
127 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
128
129 adapter->DestroyRender(adapter, render);
130 manager->UnloadAdapter(manager, adapter);
131 }
132 /**
133 * @tc.name Test RenderGetGainThreshold API via set the parameter max to nullptr
134 * @tc.number SUB_Audio_HDI_RenderGetGainThreshold_0004
135 * @tc.desc Test RenderGetGainThreshold interface, return -1 if set max to nullptr
136 */
137 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGainThreshold_0004, Function | MediumTest | Level1)
138 {
139 int32_t ret = -1;
140 float min = 0;
141 float *maxNull = nullptr;
142 struct AudioAdapter *adapter = nullptr;
143 struct AudioRender *render = nullptr;
144
145 TestAudioManager* manager = GetAudioManagerFuncs();
146 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
147 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
148 ret = render->volume.GetGainThreshold(render, &min, maxNull);
149 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
150
151 adapter->DestroyRender(adapter, render);
152 manager->UnloadAdapter(manager, adapter);
153 }
154 /**
155 * @tc.name Test RenderSetGain API via legal input
156 * @tc.number SUB_Audio_HDI_RenderSetGain_0001
157 * @tc.desc Test RenderSetGain interface,return 0 if Set gain to normal value, maximum or minimum and get success
158 */
159 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0001, 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
167 TestAudioManager* manager = GetAudioManagerFuncs();
168 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
169 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
170 ret = render->volume.GetGainThreshold((AudioHandle)render, &min, &max);
171 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
172 EXPECT_TRUE(true);
173 }else{
174 EXPECT_TRUE(false);
175 }
176 float gain = 10.8;
177 float gainMax = max;
178 float gainMin = min;
179 ret = render->volume.SetGain(render, gain);
180 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
181 EXPECT_TRUE(true);
182 }else{
183 EXPECT_TRUE(false);
184 }
185 ret = render->volume.GetGain(render, &gain);
186 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
187 EXPECT_TRUE(true);
188 }else{
189 EXPECT_TRUE(false);
190 }
191 ret = render->volume.SetGain(render, gainMax);
192 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
193 EXPECT_TRUE(true);
194 }else{
195 EXPECT_TRUE(false);
196 }
197 ret = render->volume.GetGain(render, &gainMax);
198 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
199 EXPECT_TRUE(true);
200 }else{
201 EXPECT_TRUE(false);
202 }
203 ret = render->volume.SetGain(render, gainMin);
204 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
205 EXPECT_TRUE(true);
206 }else{
207 EXPECT_TRUE(false);
208 }
209 ret = render->volume.GetGain(render, &gainMin);
210 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
211 EXPECT_TRUE(true);
212 }else{
213 EXPECT_TRUE(false);
214 }
215 adapter->DestroyRender(adapter, render);
216 manager->UnloadAdapter(manager, adapter);
217 }
218 /**
219 * @tc.name Test RenderSetGain API via set the parameter render to nullptr
220 * @tc.number SUB_Audio_HDI_RenderSetGain_0004
221 * @tc.desc Test RenderSetGain interface, return -1 if set render to nullptr
222 */
223 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderSetGain_0004, Function | MediumTest | Level1)
224 {
225 int32_t ret = -1;
226 float gain = 1;
227 struct AudioAdapter *adapter = nullptr;
228 struct AudioRender *render = nullptr;
229 struct AudioRender *renderNull = nullptr;
230
231 TestAudioManager* manager = GetAudioManagerFuncs();
232 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
233 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
234
235 ret = render->volume.SetGain((AudioHandle)renderNull, gain);
236 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
237
238 adapter->DestroyRender(adapter, render);
239 manager->UnloadAdapter(manager, adapter);
240 }
241 /**
242 * @tc.name Test RenderGetGain API via legal input
243 * @tc.number SUB_Audio_HDI_RenderGetGain_0001
244 * @tc.desc Test RenderGetGain interface,return 0 if the RenderGetGain was obtained successfully
245 */
246 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0001, Function | MediumTest | Level1)
247 {
248 int32_t ret = -1;
249 float min = 0;
250 float max = 0;
251 struct AudioAdapter *adapter = nullptr;
252 struct AudioRender *render = nullptr;
253
254 TestAudioManager* manager = GetAudioManagerFuncs();
255 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
256 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
257 ret = render->volume.GetGainThreshold((AudioHandle)render, &min, &max);
258 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
259 EXPECT_TRUE(true);
260 }else{
261 EXPECT_TRUE(false);
262 }
263 float gain = min+1;
264 ret = render->volume.SetGain(render, gain);
265 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
266 EXPECT_TRUE(true);
267 }else{
268 EXPECT_TRUE(false);
269 }
270 ret = render->volume.GetGain(render, &gain);
271 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
272 EXPECT_TRUE(true);
273 }else{
274 EXPECT_TRUE(false);
275 }
276 render->control.Stop((AudioHandle)render);
277 adapter->DestroyRender(adapter, render);
278 manager->UnloadAdapter(manager, adapter);
279 }
280 /**
281 * @tc.name Test RenderGetGain API via set the parameter render to nullptr
282 * @tc.number SUB_Audio_HDI_RenderGetGain_0002
283 * @tc.desc Test RenderGetGain interface, return -1 if get gain set render to nullptr
284 */
285 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0002, Function | MediumTest | Level1)
286 {
287 int32_t ret = -1;
288 float gain = 0;
289 struct AudioAdapter *adapter = nullptr;
290 struct AudioRender *render = nullptr;
291 struct AudioRender *renderNull = nullptr;
292
293 TestAudioManager* manager = GetAudioManagerFuncs();
294 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
295 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
296
297 ret = render->volume.GetGain((AudioHandle)renderNull, &gain);
298 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
299 adapter->DestroyRender(adapter, render);
300 manager->UnloadAdapter(manager, adapter);
301 }
302 /**
303 * @tc.name Test RenderGetGain API via legal input in difference scenes
304 * @tc.number SUB_Audio_HDI_RenderGetGain_0003
305 * @tc.desc Test RenderGetGainThreshold interface, return 0 if get gain before start successfully
306 */
307 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0003, Function | MediumTest | Level1)
308 {
309 int32_t ret = -1;
310 float gain = GAIN_MAX-1;
311 struct AudioAdapter *adapter = nullptr;
312 struct AudioRender *render = nullptr;
313
314 TestAudioManager* manager = GetAudioManagerFuncs();
315 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
316 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
317
318 ret = render->volume.SetGain(render, gain);
319 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
320 EXPECT_TRUE(true);
321 }else{
322 EXPECT_TRUE(false);
323 }
324 ret = render->volume.GetGain(render, &gain);
325 if ((ret == AUDIO_HAL_SUCCESS) || (ret == AUDIO_HAL_ERR_NOT_SUPPORT)){
326 EXPECT_TRUE(true);
327 }else{
328 EXPECT_TRUE(false);
329 }
330 adapter->DestroyRender(adapter, render);
331 manager->UnloadAdapter(manager, adapter);
332 }
333 /**
334 * @tc.name Test RenderGetGain API via set the parameter gain to nullptr
335 * @tc.number SUB_Audio_HDI_RenderGetGain_0004
336 * @tc.desc Test RenderGetGain interface, return -1 if get gain set gain to nullptr
337 */
338 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_RenderGetGain_0004, Function | MediumTest | Level1)
339 {
340 int32_t ret = -1;
341 float *gainNull = nullptr;
342 struct AudioAdapter *adapter = nullptr;
343 struct AudioRender *render = nullptr;
344
345 TestAudioManager* manager = GetAudioManagerFuncs();
346 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
347 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
348 ret = render->volume.GetGain((AudioHandle)render, gainNull);
349 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
350 adapter->DestroyRender(adapter, render);
351 manager->UnloadAdapter(manager, adapter);
352 }
353 /**
354 * @tc.name Test AudioRenderSetMute API via legal input.
355 * @tc.number SUB_Audio_HDI_AudioRenderSetMute_0001
356 * @tc.desc Test AudioRenderSetMute interface , return 0 if the audiorender object sets mute successfully.
357 */
358 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetMute_0001, Function | MediumTest | Level1)
359 {
360 int32_t ret = -1;
361 bool muteFalse = false;
362 bool muteTrue = true;
363 struct AudioAdapter *adapter = nullptr;
364 struct AudioRender *render = nullptr;
365
366 TestAudioManager* manager = GetAudioManagerFuncs();
367 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
368 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
369
370 ret = render->volume.SetMute(render, muteFalse);
371 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
372 ret = render->volume.GetMute(render, &muteFalse);
373 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
374 EXPECT_EQ(false, muteFalse);
375
376 ret = render->volume.SetMute(render, muteTrue);
377 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
378 ret = render->volume.GetMute(render, &muteTrue);
379 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
380 EXPECT_EQ(true, muteTrue);
381
382 muteTrue = false;
383 ret = render->volume.SetMute(render, muteTrue);
384 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
385 EXPECT_FALSE(muteTrue);
386
387 adapter->DestroyRender(adapter, render);
388 manager->UnloadAdapter(manager, adapter);
389 }
390 /**
391 * @tc.name Test AudioRenderSetMute API via setting the incoming parameter render is empty .
392 * @tc.number SUB_Audio_HDI_AudioRenderSetMute_0002
393 * @tc.desc Test AudioRenderSetMute interface, return -1 if the incoming parameter render is empty.
394 */
395 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetMute_0002, Function | MediumTest | Level1)
396 {
397 int32_t ret = -1;
398 bool mute = true;
399 struct AudioAdapter *adapter = nullptr;
400 struct AudioRender *render = nullptr;
401 struct AudioRender *renderNull = nullptr;
402
403 TestAudioManager* manager = GetAudioManagerFuncs();
404 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
405 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
406 ret = render->volume.SetMute(renderNull, mute);
407 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
408 adapter->DestroyRender(adapter, render);
409 manager->UnloadAdapter(manager, adapter);
410 }
411 /**
412 * @tc.name Test AudioRenderSetMute API,when the parameter mutevalue equals 2.
413 * @tc.number SUB_Audio_HDI_AudioRenderSetMute_0003
414 * @tc.desc Test AudioRenderSetMute interface and set the parameter mutevalue with 2.
415 */
416 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetMute_0003, Function | MediumTest | Level1)
417 {
418 int32_t ret = -1;
419 bool muteValue = 2;
420 struct AudioAdapter *adapter = nullptr;
421 struct AudioRender *render = nullptr;
422
423 TestAudioManager* manager = GetAudioManagerFuncs();
424 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
425 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
426
427 ret = render->volume.SetMute(render, muteValue);
428 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
429 ret = render->volume.GetMute(render, &muteValue);
430 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
431 EXPECT_EQ(true, muteValue);
432
433 adapter->DestroyRender(adapter, render);
434 manager->UnloadAdapter(manager, adapter);
435 }
436 /**
437 * @tc.name Test AudioRenderGetMute API via legal input.
438 * @tc.number SUB_Audio_HDI_AudioRenderGetMute_0001
439 * @tc.desc Test AudioRenderGetMute interface , return 0 if the audiocapture gets mute successfully.
440 */
441 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetMute_0001, Function | MediumTest | Level1)
442 {
443 int32_t ret = -1;
444 bool muteTrue = true;
445 bool muteFalse = false;
446 struct AudioAdapter *adapter = nullptr;
447 struct AudioRender *render = nullptr;
448
449 TestAudioManager* manager = GetAudioManagerFuncs();
450 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
451 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
452
453 ret = render->volume.GetMute(render, &muteTrue);
454 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
455
456 ret = render->volume.SetMute(render, muteFalse);
457 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
458
459 ret = render->volume.GetMute(render, &muteFalse);
460 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
461 EXPECT_FALSE(muteFalse);
462 adapter->DestroyRender(adapter, render);
463 manager->UnloadAdapter(manager, adapter);
464 }
465 /**
466 * @tc.name Test interface AudioRenderGetMute when incoming parameter render is empty.
467 * @tc.number SUB_Audio_HDI_AudioRenderGetMute_0002
468 * @tc.desc Test AudioRenderGetMute interface, return -1 if the incoming parameter render is empty.
469 */
470 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetMute_0002, Function | MediumTest | Level1)
471 {
472 int32_t ret = -1;
473 bool muteTrue = true;
474 bool muteFalse = false;
475 struct AudioAdapter *adapter = nullptr;
476 struct AudioRender *render = nullptr;
477 struct AudioRender *renderNull = nullptr;
478
479 TestAudioManager* manager = GetAudioManagerFuncs();
480 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
481 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
482 ret = render->volume.GetMute(renderNull, &muteTrue);
483 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
484
485 ret = render->volume.GetMute(renderNull, &muteFalse);
486 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
487
488 ret = render->volume.GetMute(render, nullptr);
489 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
490 adapter->DestroyRender(adapter, render);
491 manager->UnloadAdapter(manager, adapter);
492 }
493 /**
494 * @tc.name Test AudioRenderSetVolume API via legal input.
495 * @tc.number SUB_Audio_HDI_AudioRenderSetVolume_0001
496 * @tc.desc Test AudioRenderSetVolume interface , return 0 if the audiocapture sets volume successfully.
497 */
498 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetVolume_0001, Function | MediumTest | Level1)
499 {
500 int32_t ret = -1;
501 float volumeInit = 0.20;
502 float volumeInitExpc = 0.20;
503 float volumeLow = 0.10;
504 float volumeLowExpc = 0.10;
505 float volumeMid = 0.50;
506 float volumeMidExpc = 0.50;
507 float volumeHigh = 0.80;
508 float volumeHighExpc = 0.80;
509 struct AudioAdapter *adapter = nullptr;
510 struct AudioRender *render = nullptr;
511
512 TestAudioManager* manager = GetAudioManagerFuncs();
513 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
514 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
515
516 ret = render->volume.SetVolume(render, volumeInit);
517 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
518 ret = render->volume.GetVolume(render, &volumeInit);
519 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
520 EXPECT_EQ(volumeInitExpc, volumeInit);
521 ret = render->volume.SetVolume(render, volumeLow);
522 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
523 ret = render->volume.GetVolume(render, &volumeLow);
524 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
525 EXPECT_EQ(volumeLowExpc, volumeLow);
526 ret = render->volume.SetVolume(render, volumeMid);
527 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
528 ret = render->volume.GetVolume(render, &volumeMid);
529 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
530 EXPECT_EQ(volumeMidExpc, volumeMid);
531 ret = render->volume.SetVolume(render, volumeHigh);
532 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
533 ret = render->volume.GetVolume(render, &volumeHigh);
534 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
535 EXPECT_EQ(volumeHighExpc, volumeHigh);
536
537 adapter->DestroyRender(adapter, render);
538 manager->UnloadAdapter(manager, adapter);
539 }
540 /**
541 * @tc.name Test AudioRenderSetVolume,when volume is set maximum value or minimum value.
542 * @tc.number SUB_Audio_HDI_AudioRenderSetVolume_0002
543 * @tc.desc Test AudioRenderSetVolume,return 0 if volume is set maximum value or minimum value.
544 */
545 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetVolume_0002, Function | MediumTest | Level1)
546 {
547 int32_t ret = -1;
548 float volumeMin = 0;
549 float volumeMinExpc = 0;
550 float volumeMax = 1.0;
551 float volumeMaxExpc = 1.0;
552 float volumeMinBoundary = -1;
553 float volumeMaxBoundary = 1.01;
554 struct AudioAdapter *adapter = nullptr;
555 struct AudioRender *render = nullptr;
556
557 TestAudioManager* manager = GetAudioManagerFuncs();
558 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
559 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
560 ret = render->volume.SetVolume(render, volumeMin);
561 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
562 ret = render->volume.GetVolume(render, &volumeMin);
563 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
564 EXPECT_EQ(volumeMinExpc, volumeMin);
565
566 ret = render->volume.SetVolume(render, volumeMax);
567 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
568 ret = render->volume.GetVolume(render, &volumeMax);
569 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
570 EXPECT_EQ(volumeMaxExpc, volumeMax);
571
572 ret = render->volume.SetVolume(render, volumeMinBoundary);
573 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
574
575 ret = render->volume.SetVolume(render, volumeMaxBoundary);
576 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
577
578 adapter->DestroyRender(adapter, render);
579 manager->UnloadAdapter(manager, adapter);
580 }
581 /**
582 * @tc.name Test AudioRenderSetVolume,when incoming parameter render is empty.
583 * @tc.number SUB_Audio_HDI_AudioRenderSetVolume_0003
584 * @tc.desc Test AudioRenderSetVolume,return -1 when incoming parameter render is empty.
585 */
586 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderSetVolume_0003, Function | MediumTest | Level1)
587 {
588 int32_t ret = -1;
589 float volume = 0;
590 struct AudioAdapter *adapter = nullptr;
591 struct AudioRender *render = nullptr;
592 struct AudioRender *renderNull = nullptr;
593
594 TestAudioManager* manager = GetAudioManagerFuncs();
595 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
596 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
597 ret = render->volume.SetVolume(renderNull, volume);
598 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
599
600 adapter->DestroyRender(adapter, render);
601 manager->UnloadAdapter(manager, adapter);
602 }
603 /**
604 * @tc.name Test AudioRenderGetVolume API via legal input.
605 * @tc.number SUB_Audio_HDI_AudioRenderGetVolume_001
606 * @tc.desc Test AudioRenderGetVolume interface , return 0 if the audiocapture is get successful.
607 */
608 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetVolume_001, Function | MediumTest | Level1)
609 {
610 int32_t ret = -1;
611 float volume = 0.30;
612 float volumeDefault = 0.30;
613 struct AudioAdapter *adapter = nullptr;
614 struct AudioRender *render = nullptr;
615
616 TestAudioManager* manager = GetAudioManagerFuncs();
617 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
618 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
619
620 ret = render->volume.SetVolume(render, volume);
621 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
622 ret = render->volume.GetVolume(render, &volume);
623 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
624 EXPECT_EQ(volumeDefault, volume);
625
626 adapter->DestroyRender(adapter, render);
627 manager->UnloadAdapter(manager, adapter);
628 }
629 /**
630 * @tc.name Test AudioRenderGetVolume when when capturing is in progress.
631 * @tc.number SUB_Audio_HDI_AudioRenderGetVolume_002.
632 * @tc.desc Test AudioRenderGetVolume,return 0 when when capturing is in progress.
633 */
634 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetVolume_002, Function | MediumTest | Level1)
635 {
636 int32_t ret = -1;
637 float volume = 0.30;
638 float defaultVolume = 0.30;
639 struct AudioAdapter *adapter = nullptr;
640 struct AudioRender *render = nullptr;
641
642 TestAudioManager* manager = GetAudioManagerFuncs();
643 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
644 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
645
646 ret = render->volume.SetVolume(render, volume);
647 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
648 ret = render->volume.GetVolume(render, &volume);
649 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
650 EXPECT_EQ(defaultVolume, volume);
651
652 ret = render->control.Stop((AudioHandle)render);
653 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
654 adapter->DestroyRender(adapter, render);
655 manager->UnloadAdapter(manager, adapter);
656 }
657 /**
658 * @tc.name Test AudioRenderGetVolume,when incoming parameter render is empty.
659 * @tc.number SUB_Audio_HDI_AudioRenderGetVolume_0003
660 * @tc.desc Test AudioRenderGetVolume,return -1 when incoming parameter render is empty.
661 */
662 HWTEST_F(AudioHdiRenderVolumeTest, SUB_Audio_HDI_AudioRenderGetVolume_0003, Function | MediumTest | Level1)
663 {
664 int32_t ret = -1;
665 float volume = 0.3;
666 struct AudioAdapter *adapter = nullptr;
667 struct AudioRender *render = nullptr;
668 struct AudioRender *renderNull = nullptr;
669
670 TestAudioManager* manager = GetAudioManagerFuncs();
671 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
672 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
673 ret = render->volume.GetVolume(renderNull, &volume);
674 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
675 adapter->DestroyRender(adapter, render);
676 manager->UnloadAdapter(manager, adapter);
677 }
678 }