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