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