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