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