1 /*
2 * Copyright (c) 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 #include <gtest/gtest.h>
17 #include "hdi_service_common.h"
18
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Audio;
22
23 namespace {
24 class AudioIdlHdiCaptureVolumeTest : public testing::Test {
25 public:
26 static void SetUpTestCase(void);
27 static void TearDownTestCase(void);
28 void SetUp();
29 void TearDown();
30 static TestAudioManager *manager;
31 struct IAudioCapture *capture = nullptr;
32 struct IAudioAdapter *adapter = nullptr;
33 uint32_t captureId_ = 0;
34 };
35
36 TestAudioManager *AudioIdlHdiCaptureVolumeTest::manager = nullptr;
37 using THREAD_FUNC = void *(*)(void *);
38
SetUpTestCase(void)39 void AudioIdlHdiCaptureVolumeTest::SetUpTestCase(void)
40 {
41 manager = IAudioManagerGet(IS_STUB);
42 ASSERT_NE(nullptr, manager);
43 }
44
TearDownTestCase(void)45 void AudioIdlHdiCaptureVolumeTest::TearDownTestCase(void)
46 {
47 if (manager != nullptr) {
48 (void)IAudioManagerRelease(manager, IS_STUB);
49 }
50 }
51
SetUp(void)52 void AudioIdlHdiCaptureVolumeTest::SetUp(void)
53 {
54 ASSERT_NE(nullptr, manager);
55 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture, &captureId_);
56 ASSERT_EQ(HDF_SUCCESS, ret);
57 }
58
TearDown(void)59 void AudioIdlHdiCaptureVolumeTest::TearDown(void)
60 {
61 int32_t ret = ReleaseCaptureSource(manager, adapter, capture, captureId_);
62 ASSERT_EQ(HDF_SUCCESS, ret);
63 }
64
65 /**
66 * @tc.name AudioCaptureSetMute_001
67 * @tc.desc Test AudioCaptureSetMute interface , return 0 if the audiocapture object sets mute successfully.
68 * @tc.type: FUNC
69 */
70 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureSetMute_001, TestSize.Level1)
71 {
72 int32_t ret = -1;
73 bool muteTrue = true;
74 bool muteFalse = false;
75 ASSERT_NE(nullptr, capture);
76
77 ret = capture->SetMute(capture, muteTrue);
78 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
79
80 ret = capture->GetMute(capture, &muteTrue);
81 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
82 EXPECT_TRUE(muteTrue);
83
84 ret = capture->SetMute(capture, muteFalse);
85 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
86
87 ret = capture->GetMute(capture, &muteFalse);
88 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
89 EXPECT_FALSE(muteFalse);
90 }
91 /**
92 * @tc.name AudioCaptureSetMuteNull_002
93 * @tc.desc Test AudioCaptureSetMute interface, return -3/-4 if the capture is nullptr.
94 * @tc.type: FUNC
95 */
96 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureSetMuteNull_002, TestSize.Level1)
97 {
98 bool muteTrue = true;
99 bool muteFalse = false;
100 int32_t ret = -1;
101 struct IAudioCapture *captureNull = nullptr;
102 ASSERT_NE(nullptr, capture);
103 ret = capture->SetMute(captureNull, muteTrue);
104 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
105
106 ret = capture->SetMute(captureNull, muteFalse);
107 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
108 }
109 /**
110 * @tc.name AudioCaptureSetMute_003
111 * @tc.desc Test AudioCaptureSetMute interface and set the parameter mutevalue with 2.
112 * @tc.type: FUNC
113 */
114 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureSetMute_003, TestSize.Level1)
115 {
116 bool muteValue = 2;
117 int32_t ret = -1;
118 ASSERT_NE(nullptr, capture);
119
120 ret = capture->SetMute(capture, muteValue);
121 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
122
123 ret = capture->GetMute(capture, &muteValue);
124 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
125 EXPECT_TRUE(muteValue);
126 }
127 /**
128 * @tc.name AudioCaptureGetMute_001
129 * @tc.desc Test AudioCaptureGetMute interface , return 0 if the audiocapture gets mute successfully.
130 * @tc.type: FUNC
131 */
132 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureGetMute_001, TestSize.Level1)
133 {
134 int32_t ret = -1;
135 bool muteTrue = true;
136 bool muteFalse = false;
137 #ifdef ALSA_LIB_MODE
138 bool defaultmute = false;
139 #else
140 bool defaultmute = true;
141 #endif
142 ASSERT_NE(nullptr, capture);
143 ret = capture->GetMute(capture, &muteTrue);
144 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
145 EXPECT_EQ(muteTrue, defaultmute);
146
147 ret = capture->SetMute(capture, muteFalse);
148 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
149
150 ret = capture->GetMute(capture, &muteFalse);
151 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
152 EXPECT_FALSE(muteFalse);
153 }
154 /**
155 * @tc.name AudioCaptureGetMuteNull_002
156 * @tc.desc Test AudioCreateCapture interface, return -3/-4 if the capture is nullptr.
157 * @tc.type: FUNC
158 */
159 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureGetMuteNull_002, TestSize.Level1)
160 {
161 int32_t ret = -1;
162 bool muteTrue = true;
163 bool muteFalse = false;
164 struct IAudioCapture *captureNull = nullptr;
165 ASSERT_NE(nullptr, capture);
166 ret = capture->GetMute(captureNull, &muteTrue);
167 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
168
169 ret = capture->GetMute(captureNull, &muteFalse);
170 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
171
172 ret = capture->GetMute(capture, nullptr);
173 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
174 }
175 /**
176 * @tc.name AudioCaptureSetVolume_001
177 * @tc.desc Test AudioCaptureSetVolume interface , return 0 if the audiocapture sets volume successfully.
178 * @tc.type: FUNC
179 */
180 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureSetVolume_001, TestSize.Level1)
181 {
182 int32_t ret = -1;
183 float volumeInit = 0.30;
184 float volumeInitExpc = 0.30;
185 float volumeLow = 0.10;
186 float volumeLowExpc = 0.10;
187 float volumeMid = 0.40;
188 float volumeMidExpc = 0.40;
189 float volumeHigh = 0.70;
190 float volumeHighExpc = 0.70;
191 ASSERT_NE(nullptr, capture);
192 ret = capture->SetVolume(capture, volumeInit);
193 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
194 ret = capture->GetVolume(capture, &volumeInit);
195 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
196 EXPECT_EQ(volumeInitExpc, volumeInit);
197 ret = capture->SetVolume(capture, volumeLow);
198 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
199 ret = capture->GetVolume(capture, &volumeLow);
200 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
201 EXPECT_EQ(volumeLowExpc, volumeLow);
202 ret = capture->SetVolume(capture, volumeMid);
203 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
204 ret = capture->GetVolume(capture, &volumeMid);
205 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
206 EXPECT_EQ(volumeMidExpc, volumeMid);
207 ret = capture->SetVolume(capture, volumeHigh);
208 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
209 ret = capture->GetVolume(capture, &volumeHigh);
210 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
211 EXPECT_EQ(volumeHighExpc, volumeHigh);
212 }
213 /**
214 * @tc.name AudioCaptureSetVolume_002
215 * @tc.desc Test AudioCaptureSetVolume,return -3 if volume is set maximum value or minimum value.
216 * @tc.type: FUNC
217 */
218 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureSetVolume_002, TestSize.Level1)
219 {
220 int32_t ret = -1;
221 float volumeMin = 0;
222 float volumeMinExpc = 0;
223 float volumeMax = 1.0;
224 float volumeMaxExpc = 1.0;
225 float volumeMinBoundary = -1;
226 float volumeMaxBoundary = 1.1;
227 ASSERT_NE(nullptr, capture);
228
229 ret = capture->SetVolume(capture, volumeMin);
230 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
231 ret = capture->GetVolume(capture, &volumeMin);
232 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
233 EXPECT_EQ(volumeMinExpc, volumeMin);
234
235 ret = capture->SetVolume(capture, volumeMax);
236 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
237 ret = capture->GetVolume(capture, &volumeMax);
238 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
239 EXPECT_EQ(volumeMaxExpc, volumeMax);
240
241 ret = capture->SetVolume(capture, volumeMinBoundary);
242 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
243
244 ret = capture->SetVolume(capture, volumeMaxBoundary);
245 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
246 }
247 /**
248 * @tc.name AudioCaptureSetVolumeNull_003
249 * @tc.desc Test AudioCaptureSetVolume,return -3/-4 when capture is nullptr.
250 * @tc.type: FUNC
251 */
252 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureSetVolumeNull_003, TestSize.Level1)
253 {
254 int32_t ret = -1;
255 float volume = 0;
256 struct IAudioCapture *captureNull = nullptr;
257 ASSERT_NE(nullptr, capture);
258
259 ret = capture->SetVolume(captureNull, volume);
260 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
261 }
262 /**
263 * @tc.name AudioCaptureGetVolume_001
264 * @tc.desc Test AudioCaptureGetVolume interface , return 0 if the audiocapture is get successful.
265 * @tc.type: FUNC
266 */
267 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureGetVolume_001, TestSize.Level1)
268 {
269 int32_t ret = -1;
270 float volume = 0.60;
271 float defaultVolume = 0.60;
272 ASSERT_NE(nullptr, capture);
273
274 ret = capture->SetVolume(capture, volume);
275 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
276 ret = capture->GetVolume(capture, &volume);
277 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
278 EXPECT_EQ(defaultVolume, volume);
279 }
280 /**
281 * @tc.name AudioCaptureGetVolume_002.
282 * @tc.desc Test AudioCaptureGetVolume,return 0 when when capturing is in progress.
283 * @tc.type: FUNC
284 */
285 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureGetVolume_002, TestSize.Level1)
286 {
287 int32_t ret = -1;
288 float volume = 0.60;
289 float defaultVolume = 0.60;
290 ASSERT_NE(nullptr, capture);
291 ret = AudioCaptureStartAndOneFrame(capture);
292 EXPECT_EQ(HDF_SUCCESS, ret);
293
294 ret = capture->SetVolume(capture, volume);
295 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
296 ret = capture->GetVolume(capture, &volume);
297 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
298 EXPECT_EQ(defaultVolume, volume);
299
300 ret = capture->Stop(capture);
301 EXPECT_EQ(HDF_SUCCESS, ret);
302 }
303 /**
304 * @tc.name AudioCaptureGetVolumeNull_003
305 * @tc.desc Test AudioCaptureGetVolume,return -3/-4 when capture is nullptr.
306 * @tc.type: FUNC
307 */
308 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureGetVolumeNull_003, TestSize.Level1)
309 {
310 int32_t ret = -1;
311 float volume = 0.30;
312 struct IAudioCapture *captureNull = nullptr;
313 ASSERT_NE(nullptr, capture);
314
315 ret = capture->GetVolume(captureNull, &volume);
316 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
317 }
318 /**
319 * @tc.name AudioCaptureGetGainThreshold_001
320 * @tc.desc test AudioCaptureGetGainThreshold interface, return 0 is call successfully.
321 * @tc.type: FUNC
322 */
323 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureGetGainThreshold_001, TestSize.Level1)
324 {
325 int32_t ret = -1;
326 float min = 0;
327 float max = 0;
328 ASSERT_NE(nullptr, capture);
329
330 ret = capture->GetGainThreshold(capture, &min, &max);
331 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
332 #ifndef ALSA_LIB_MODE
333 EXPECT_EQ(min, GAIN_MIN);
334 EXPECT_LE(max, GAIN_MAX);
335 #endif
336 }
337 /**
338 * @tc.name AudioCaptureGetGainThresholdNull_002
339 * @tc.desc test AudioCaptureGetGainThreshold interface, return -3/-4 if the incoming parameter handle is nullptr.
340 * @tc.type: FUNC
341 */
342 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureGetGainThresholdNull_002, TestSize.Level1)
343 {
344 int32_t ret = -1;
345 float min = 0;
346 float max = 0;
347 struct IAudioCapture *captureNull = nullptr;
348 ASSERT_NE(nullptr, capture);
349
350 ret = capture->GetGainThreshold(captureNull, &min, &max);
351 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
352 }
353 /**
354 * @tc.name AudioCaptureGetGainThresholdNull_003
355 * @tc.desc test AudioCaptureGetGainThreshold interface, return -3 if the incoming parameter min is nullptr.
356 * @tc.type: FUNC
357 */
358 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureGetGainThresholdNull_003, TestSize.Level1)
359 {
360 int32_t ret = -1;
361 float max = 0;
362 float* minNull = nullptr;
363 ASSERT_NE(nullptr, capture);
364
365 ret = capture->GetGainThreshold(capture, minNull, &max);
366 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
367 }
368 /**
369 * @tc.name AudioCaptureGetGainThresholdNull_004
370 * @tc.desc test AudioCaptureGetGainThreshold interface, return -3 if the incoming parameter max is nullptr.
371 * @tc.type: FUNC
372 */
373 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureGetGainThresholdNull_004, TestSize.Level1)
374 {
375 int32_t ret = -1;
376 float min = 0;
377 float* maxNull = nullptr;
378 ASSERT_NE(nullptr, capture);
379
380 ret = capture->GetGainThreshold(capture, &min, maxNull);
381 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
382 }
383 /**
384 * @tc.name AudioCaptureSetGain_001
385 * @tc.desc test AudioCaptureSetGain interface, return 0 is call successfully.
386 * @tc.type: FUNC
387 */
388 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureSetGain_001, TestSize.Level1)
389 {
390 int32_t ret = -1;
391 float min = 0;
392 float max = 0;
393 ASSERT_NE(nullptr, capture);
394
395 ret = capture->GetGainThreshold(capture, &min, &max);
396 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
397 float gain = max - 1;
398 float gainMax = max;
399 float gainMin = min;
400 float gainExpc = max - 1;
401 float gainMaxExpc = max;
402 float gainMinExpc = min;
403 ret = capture->SetGain(capture, gainMax);
404 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
405 ret = capture->GetGain(capture, &gainMax);
406 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
407 EXPECT_EQ(gainMaxExpc, gainMax);
408
409 ret = capture->SetGain(capture, gainMin);
410 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
411 ret = capture->GetGain(capture, &gainMin);
412 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
413 EXPECT_EQ(gainMinExpc, gainMin);
414
415 ret = capture->SetGain(capture, gain);
416 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
417 ret = capture->GetGain(capture, &gain);
418 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
419 EXPECT_EQ(gainExpc, gain);
420 }
421 #ifndef ALSA_LIB_MODE
422 /**
423 * @tc.name AudioCaptureSetGain_002
424 * @tc.desc test AudioCaptureSetGain interface, return -3 if gain greater than the maximum and less than the minimum
425 * @tc.type: FUNC
426 */
427 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureSetGain_002, TestSize.Level1)
428 {
429 int32_t ret = -1;
430 float min = 0;
431 float max = 0;
432 ASSERT_NE(nullptr, capture);
433 ret = capture->GetGainThreshold(capture, &min, &max);
434 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
435
436 float gainOne = max + 1;
437 float gainSec = min - 1;
438 ret = capture->SetGain(capture, gainOne);
439 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_NOT_SUPPORT);
440
441 ret = capture->SetGain(capture, gainSec);
442 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
443 }
444 #endif
445 /**
446 * @tc.name AudioCaptureSetGainNull_003
447 * @tc.desc test AudioCaptureSetGain interface, return -3/-4 if the incoming parameter handle is nullptr.
448 * @tc.type: FUNC
449 */
450 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureSetGainNull_003, TestSize.Level1)
451 {
452 int32_t ret = -1;
453 float gain = 0;
454 struct IAudioCapture *captureNull = nullptr;
455 ASSERT_NE(nullptr, capture);
456
457 ret = capture->SetGain(captureNull, gain);
458 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
459 }
460 /**
461 * @tc.name AudioCaptureGetGain_001
462 * @tc.desc test AudioCaptureGetGain interface, return 0 if CaptureGetGain is call successfully.
463 * @tc.type: FUNC
464 */
465 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureGetGain_001, TestSize.Level1)
466 {
467 int32_t ret = -1;
468 float min = 0;
469 float max = 0;
470 ASSERT_NE(nullptr, capture);
471 ret = capture->GetGainThreshold(capture, &min, &max);
472 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
473
474 float gain = min + 1;
475 float gainValue = min + 1;
476 ret = capture->SetGain(capture, gain);
477 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
478 ret = capture->GetGain(capture, &gain);
479 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
480 EXPECT_EQ(gainValue, gain);
481 }
482 /**
483 * @tc.name AudioCaptureGetGainNull_002
484 * @tc.desc test AudioCaptureGetGain interface, return -3 if the incoming parameter handle is nullptr.
485 * @tc.type: FUNC
486 */
487 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureGetGainNull_002, TestSize.Level1)
488 {
489 int32_t ret = -1;
490 float gainValue = 0;
491 struct IAudioCapture *captureNull = nullptr;
492 ASSERT_NE(nullptr, capture);
493 ret = capture->GetGain(captureNull, &gainValue);
494 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
495 }
496 /**
497 * @tc.name AudioCaptureGetGain_003
498 * @tc.desc test AudioCaptureGetGain interface, return 0 if get gain after creating the capture object.
499 * @tc.type: FUNC
500 */
501 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureGetGain_003, TestSize.Level1)
502 {
503 int32_t ret = -1;
504 float gain = GAIN_MAX - 1;
505 float gainOne = GAIN_MAX - 1;
506 ASSERT_NE(nullptr, capture);
507
508 ret = capture->SetGain(capture, gain);
509 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
510 ret = capture->GetGain(capture, &gain);
511 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
512 EXPECT_EQ(gainOne, gain);
513 }
514 /**
515 * @tc.name AudioCaptureGetGainNull_004
516 * @tc.desc test AudioCaptureGetGain interface, return -3 if the parameter gain is nullptr.
517 * @tc.type: FUNC
518 */
519 HWTEST_F(AudioIdlHdiCaptureVolumeTest, AudioCaptureGetGainNull_004, TestSize.Level1)
520 {
521 int32_t ret = -1;
522 float *gainNull = nullptr;
523 ASSERT_NE(nullptr, capture);
524
525 ret = capture->GetGain(capture, gainNull);
526 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
527 }
528 }