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