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