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