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 using namespace std;
19 using namespace testing::ext;
20 using namespace OHOS::Audio;
21
22 namespace {
23 class AudioIdlHdiRendervolumeTest : public testing::Test {
24 public:
25 static void SetUpTestCase(void);
26 static void TearDownTestCase(void);
27 void SetUp();
28 void TearDown();
29 static TestAudioManager *manager;
30 struct IAudioRender *render = nullptr;
31 struct IAudioAdapter *adapter = nullptr;
32 uint32_t renderId_ = 0;
33 };
34
35 TestAudioManager *AudioIdlHdiRendervolumeTest::manager = nullptr;
36
SetUpTestCase(void)37 void AudioIdlHdiRendervolumeTest::SetUpTestCase(void)
38 {
39 manager = IAudioManagerGet(IS_STUB);
40 ASSERT_NE(nullptr, manager);
41 }
42
TearDownTestCase(void)43 void AudioIdlHdiRendervolumeTest::TearDownTestCase(void)
44 {
45 if (manager != nullptr) {
46 (void)IAudioManagerRelease(manager, IS_STUB);
47 }
48 }
49
SetUp(void)50 void AudioIdlHdiRendervolumeTest::SetUp(void)
51 {
52 ASSERT_NE(nullptr, manager);
53 int32_t ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render, &renderId_);
54 ASSERT_EQ(HDF_SUCCESS, ret);
55 }
56
TearDown(void)57 void AudioIdlHdiRendervolumeTest::TearDown(void)
58 {
59 int32_t ret = ReleaseRenderSource(manager, adapter, render, renderId_);
60 ASSERT_EQ(HDF_SUCCESS, ret);
61 }
62 /**
63 * @tc.name AudioRenderGetGainThreshold_001
64 * @tc.desc Test RenderGetGainThreshold interface,return 0 if the GetGainThreshold is obtained successfully
65 * @tc.type: FUNC
66 */
67 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderGetGainThreshold_001, TestSize.Level1)
68 {
69 int32_t ret = -1;
70 float min = 0;
71 float max = 0;
72
73 ASSERT_NE(nullptr, render);
74 ret = render->GetGainThreshold(render, &min, &max);
75 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
76 #ifndef ALSA_LIB_MODE
77 EXPECT_EQ(min, GAIN_MIN);
78 EXPECT_LE(max, GAIN_MAX);
79 #endif
80 }
81 /**
82 * @tc.name AudioRenderGetGainThresholdNull_002
83 * @tc.desc Test RenderGetGainThreshold interface, return -3/-4 if set render to nullptr
84 * @tc.type: FUNC
85 */
86 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderGetGainThresholdNull_002, TestSize.Level1)
87 {
88 int32_t ret = -1;
89 float min = 0;
90 float max = 0;
91 struct IAudioRender *renderNull = nullptr;
92
93 ASSERT_NE(nullptr, render);
94 ret = render->GetGainThreshold(renderNull, &min, &max);
95 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
96 }
97 /**
98 * @tc.name AudioRenderGetGainThresholdNull_003
99 * @tc.desc Test RenderGetGainThreshold interface, return -3 if set min to nullptr
100 * @tc.type: FUNC
101 */
102 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderGetGainThresholdNull_003, TestSize.Level1)
103 {
104 int32_t ret = -1;
105 float max = 0;
106 float *minNull = nullptr;
107
108 ASSERT_NE(nullptr, render);
109 ret = render->GetGainThreshold(render, minNull, &max);
110 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
111 }
112 /**
113 * @tc.name AudioRenderGetGainThresholdNull_004
114 * @tc.desc Test RenderGetGainThreshold interface, return -3 if set max to nullptr
115 * @tc.type: FUNC
116 */
117 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderGetGainThresholdNull_004, TestSize.Level1)
118 {
119 int32_t ret = -1;
120 float min = 0;
121 float *maxNull = nullptr;
122
123 ASSERT_NE(nullptr, render);
124 ret = render->GetGainThreshold(render, &min, maxNull);
125 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
126 }
127 /**
128 * @tc.name AudioRenderSetGain_001
129 * @tc.desc Test RenderSetGain interface,return 0 if Set gain to normal value, maximum or minimum and get success
130 * @tc.type: FUNC
131 */
132 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderSetGain_001, TestSize.Level1)
133 {
134 int32_t ret = -1;
135 ASSERT_NE(nullptr, render);
136 float gain = 10.8;
137 ret = render->SetGain(render, gain);
138 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
139 ret = render->GetGain(render, &gain);
140 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
141 #ifndef ALSA_LIB_MODE
142 float gainExpc = 10;
143 EXPECT_LE(gainExpc, gain);
144 float min = 0;
145 float max = 0;
146 ret = render->GetGainThreshold(render, &min, &max);
147 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
148 float gainMax = max;
149 float gainMin = min;
150 float gainMaxExpc = max;
151 float gainMinExpc = min;
152 ret = render->SetGain(render, gainMax);
153 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
154 ret = render->GetGain(render, &gainMax);
155 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
156 EXPECT_EQ(gainMaxExpc, gainMax);
157
158 ret = render->SetGain(render, gainMin);
159 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
160 ret = render->GetGain(render, &gainMin);
161 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
162 EXPECT_EQ(gainMinExpc, gainMin);
163 #endif
164 }
165 #ifndef ALSA_LIB_MODE
166 /**
167 * @tc.name AudioRenderSetGain_002
168 * @tc.desc Test RenderSetGain interface,return -3 if Set gain to exceed the boundary value
169 * @tc.type: FUNC
170 */
171 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderSetGain_002, TestSize.Level1)
172 {
173 int32_t ret = -1;
174 float min = 0;
175 float max = 0;
176
177 ASSERT_NE(nullptr, render);
178 ret = render->GetGainThreshold(render, &min, &max);
179 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
180
181 float gainOne = max + 1;
182 float gainSec = min - 1;
183 ret = render->SetGain(render, gainOne);
184 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_NOT_SUPPORT);
185
186 ret = render->SetGain(render, gainSec);
187 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
188 }
189 /**
190 * @tc.name AudioRenderSetGain_003
191 * @tc.desc Test RenderSetGain interface,return -1 if set gain to exception type
192 * @tc.type: FUNC
193 */
194 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderSetGain_003, TestSize.Level1)
195 {
196 int32_t ret = -1;
197 char gain = 'a';
198
199 ASSERT_NE(nullptr, render);
200 ret = render->SetGain(render, gain);
201 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_NOT_SUPPORT);
202 }
203 #endif
204 /**
205 * @tc.name AudioRenderSetGainNull_004
206 * @tc.desc Test RenderSetGain interface, return -3/-4 if set render to nullptr
207 * @tc.type: FUNC
208 */
209 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderSetGainNull_004, TestSize.Level1)
210 {
211 int32_t ret = -1;
212 float gain = 1;
213 struct IAudioRender *renderNull = nullptr;
214
215 ASSERT_NE(nullptr, render);
216 ret = render->SetGain(renderNull, gain);
217 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
218 }
219 /**
220 * @tc.name AudioRenderGetGain_001
221 * @tc.desc Test RenderGetGain interface,return 0 if the RenderGetGain was obtained successfully
222 * @tc.type: FUNC
223 */
224 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderGetGain_001, TestSize.Level1)
225 {
226 int32_t ret = -1;
227 float min = 0;
228 float max = 0;
229
230 ASSERT_NE(nullptr, render);
231 ret = render->GetGainThreshold(render, &min, &max);
232 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
233
234 float gain = min + 1;
235 float gainValue = min + 1;
236 ret = render->SetGain(render, gain);
237 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
238 ret = render->GetGain(render, &gain);
239 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
240 EXPECT_EQ(gainValue, gain);
241 }
242 /**
243 * @tc.name AudioRenderGetGainNull_002
244 * @tc.desc Test RenderGetGain interface, return -3/-4 if get gain set render to nullptr
245 * @tc.type: FUNC
246 */
247 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderGetGainNull_002, TestSize.Level1)
248 {
249 int32_t ret = -1;
250 float gain = 0;
251 struct IAudioRender *renderNull = nullptr;
252
253 ASSERT_NE(nullptr, render);
254 ret = render->GetGain(renderNull, &gain);
255 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
256 }
257 /**
258 * @tc.name AudioRenderGetGain_003
259 * @tc.desc Test RenderGetGainThreshold interface, return 0 if get gain before start successfully
260 * @tc.type: FUNC
261 */
262 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderGetGain_003, TestSize.Level1)
263 {
264 int32_t ret = -1;
265 float gain = GAIN_MAX - 1;
266 float gainOne = GAIN_MAX - 1;
267
268 ASSERT_NE(nullptr, render);
269 ret = render->SetGain(render, gain);
270 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
271 ret = render->GetGain(render, &gain);
272 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
273 EXPECT_EQ(gain, gainOne);
274 }
275 /**
276 * @tc.name AudioRenderGetGainNull_004
277 * @tc.desc Test RenderGetGain interface, return -3 if get gain set gain to nullptr
278 * @tc.type: FUNC
279 */
280 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderGetGainNull_004, TestSize.Level1)
281 {
282 int32_t ret = -1;
283 float *gainNull = nullptr;
284
285 ASSERT_NE(nullptr, render);
286 ret = render->GetGain(render, gainNull);
287 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
288 }
289 /**
290 * @tc.name AudioRenderSetMute_001
291 * @tc.desc Test AudioRenderSetMute interface , return 0 if the audiorender object sets mute successfully.
292 * @tc.type: FUNC
293 */
294 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderSetMute_001, TestSize.Level1)
295 {
296 int32_t ret = -1;
297 bool muteFalse = false;
298 bool muteTrue = true;
299
300 ASSERT_NE(nullptr, render);
301 ret = render->SetMute(render, muteFalse);
302 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
303 ret = render->GetMute(render, &muteFalse);
304 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
305 EXPECT_EQ(false, muteFalse);
306
307 ret = render->SetMute(render, muteTrue);
308 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
309 ret = render->GetMute(render, &muteTrue);
310 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
311 EXPECT_EQ(true, muteTrue);
312
313 muteTrue = false;
314 ret = render->SetMute(render, muteTrue);
315 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
316 EXPECT_FALSE(muteTrue);
317 }
318 /**
319 * @tc.name AudioRenderSetMuteNull_002
320 * @tc.desc Test AudioRenderSetMute interface, return -3/-4 if the incoming parameter render is empty.
321 * @tc.type: FUNC
322 */
323 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderSetMuteNull_002, TestSize.Level1)
324 {
325 int32_t ret = -1;
326 bool mute = true;
327 struct IAudioRender *renderNull = nullptr;
328
329 ASSERT_NE(nullptr, render);
330 ret = render->SetMute(renderNull, mute);
331 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
332 }
333 /**
334 * @tc.name AudioRenderSetMute_003
335 * @tc.desc Test AudioRenderSetMute interface and set the parameter mutevalue with 2.
336 * @tc.type: FUNC
337 */
338 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderSetMute_003, TestSize.Level1)
339 {
340 int32_t ret = -1;
341 bool muteValue = 2;
342
343 ASSERT_NE(nullptr, render);
344 ret = render->SetMute(render, muteValue);
345 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
346 ret = render->GetMute(render, &muteValue);
347 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
348 EXPECT_EQ(true, muteValue);
349 }
350 /**
351 * @tc.name AudioRenderGetMute_001
352 * @tc.desc Test AudioRenderGetMute interface , return 0 if the audiocapture gets mute successfully.
353 * @tc.type: FUNC
354 */
355 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderGetMute_001, TestSize.Level1)
356 {
357 int32_t ret = -1;
358 bool muteTrue = true;
359 bool muteFalse = false;
360 #ifdef ALSA_LIB_MODE
361 bool defaultmute = false;
362 #else
363 bool defaultmute = true;
364 #endif
365 ASSERT_NE(nullptr, render);
366 ret = render->GetMute(render, &muteTrue);
367 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
368 EXPECT_EQ(muteTrue, defaultmute);
369
370 ret = render->SetMute(render, muteFalse);
371 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
372
373 ret = render->GetMute(render, &muteFalse);
374 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
375 EXPECT_FALSE(muteFalse);
376 }
377 /**
378 * @tc.name AudioRenderGetMuteNull_002
379 * @tc.desc Test AudioRenderGetMute interface, return -3/-4 if the incoming parameter render is empty.
380 * @tc.type: FUNC
381 */
382 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderGetMuteNull_002, TestSize.Level1)
383 {
384 int32_t ret = -1;
385 bool muteTrue = true;
386 bool muteFalse = false;
387 struct IAudioRender *renderNull = nullptr;
388
389 ASSERT_NE(nullptr, render);
390 ret = render->GetMute(renderNull, &muteTrue);
391 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
392
393 ret = render->GetMute(renderNull, &muteFalse);
394 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
395 }
396 /**
397 * @tc.name AudioRenderGetMuteNull_003
398 * @tc.desc Test AudioRenderGetMute interface, return -3 if the incoming parameter mute is empty.
399 * @tc.type: FUNC
400 */
401 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderGetMuteNull_003, TestSize.Level1)
402 {
403 int32_t ret = -1;
404
405 ASSERT_NE(nullptr, render);
406 ret = render->GetMute(render, nullptr);
407 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
408 }
409
410 /**
411 * @tc.name AudioRenderSetVolume_001
412 * @tc.desc Test AudioRenderSetVolume interface , return 0 if the audiocapture sets volume successfully.
413 * @tc.type: FUNC
414 */
415 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderSetVolume_001, TestSize.Level1)
416 {
417 int32_t ret = -1;
418 float volumeInit = 0.20;
419 float volumeInitExpc = 0.20;
420 float volumeLow = 0.10;
421 float volumeLowExpc = 0.10;
422 float volumeMid = 0.50;
423 float volumeMidExpc = 0.50;
424 float volumeHigh = 0.80;
425 float volumeHighExpc = 0.80;
426
427 ASSERT_NE(nullptr, render);
428 ret = render->SetVolume(render, volumeInit);
429 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
430 ret = render->GetVolume(render, &volumeInit);
431 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
432 EXPECT_EQ(volumeInitExpc, volumeInit);
433 ret = render->SetVolume(render, volumeLow);
434 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
435 ret = render->GetVolume(render, &volumeLow);
436 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
437 EXPECT_EQ(volumeLowExpc, volumeLow);
438 ret = render->SetVolume(render, volumeMid);
439 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
440 ret = render->GetVolume(render, &volumeMid);
441 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
442 EXPECT_EQ(volumeMidExpc, volumeMid);
443 ret = render->SetVolume(render, volumeHigh);
444 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
445 ret = render->GetVolume(render, &volumeHigh);
446 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
447 EXPECT_EQ(volumeHighExpc, volumeHigh);
448 }
449 /**
450 * @tc.name AudioRenderSetVolume_002
451 * @tc.desc Test AudioRenderSetVolume,return 0 if volume is set maximum value or minimum value.
452 * @tc.type: FUNC
453 */
454 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderSetVolume_002, TestSize.Level1)
455 {
456 int32_t ret = -1;
457 float volumeMin = 0;
458 float volumeMinExpc = 0;
459 float volumeMax = 1.0;
460 float volumeMaxExpc = 1.0;
461 float volumeMinBoundary = -1;
462 float volumeMaxBoundary = 1.01;
463
464 ASSERT_NE(nullptr, render);
465 ret = render->SetVolume(render, volumeMin);
466 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
467 ret = render->GetVolume(render, &volumeMin);
468 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
469 EXPECT_EQ(volumeMinExpc, volumeMin);
470
471 ret = render->SetVolume(render, volumeMax);
472 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
473 ret = render->GetVolume(render, &volumeMax);
474 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
475 EXPECT_EQ(volumeMaxExpc, volumeMax);
476
477 ret = render->SetVolume(render, volumeMinBoundary);
478 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
479
480 ret = render->SetVolume(render, volumeMaxBoundary);
481 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
482 }
483 /**
484 * @tc.name AudioRenderSetVolumeNull_003
485 * @tc.desc Test AudioRenderSetVolume,return -3/-4 when incoming parameter render is empty.
486 * @tc.type: FUNC
487 */
488 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderSetVolumeNull_003, TestSize.Level1)
489 {
490 int32_t ret = -1;
491 float volume = 0;
492 struct IAudioRender *renderNull = nullptr;
493
494 ASSERT_NE(nullptr, render);
495 ret = render->SetVolume(renderNull, volume);
496 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
497 }
498 /**
499 * @tc.name AudioRenderGetVolume_001
500 * @tc.desc Test AudioRenderGetVolume interface , return 0 if the audiocapture is get successful.
501 * @tc.type: FUNC
502 */
503 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderGetVolume_001, TestSize.Level1)
504 {
505 int32_t ret = -1;
506 float volume = 0.30;
507 float volumeDefault = 0.30;
508
509 ASSERT_NE(nullptr, render);
510 ret = render->SetVolume(render, volume);
511 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
512 ret = render->GetVolume(render, &volume);
513 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
514 EXPECT_EQ(volumeDefault, volume);
515 }
516 /**
517 * @tc.name AudioRenderGetVolume_002.
518 * @tc.desc Test AudioRenderGetVolume,return 0 when when rendering is in progress.
519 * @tc.type: FUNC
520 */
521 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderGetVolume_002, TestSize.Level1)
522 {
523 int32_t ret = -1;
524 float volume = 0.30;
525 float defaultVolume = 0.30;
526
527 ASSERT_NE(nullptr, render);
528 ret = AudioRenderStartAndOneFrame(render);
529 EXPECT_EQ(HDF_SUCCESS, ret);
530
531 ret = render->SetVolume(render, volume);
532 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
533 ret = render->GetVolume(render, &volume);
534 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
535 EXPECT_EQ(defaultVolume, volume);
536
537 ret = render->Stop(render);
538 EXPECT_EQ(HDF_SUCCESS, ret);
539 }
540 /**
541 * @tc.name AudioRenderGetVolumeNull_003
542 * @tc.desc Test AudioRenderGetVolume,return -3/-4 when incoming parameter render is empty.
543 * @tc.type: FUNC
544 */
545 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderGetVolumeNull_003, TestSize.Level1)
546 {
547 int32_t ret = -1;
548 float volume = 0.3;
549 struct IAudioRender *renderNull = nullptr;
550
551 ASSERT_NE(nullptr, render);
552 ret = render->GetVolume(renderNull, &volume);
553 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT);
554 }
555 /**
556 * @tc.name AudioRenderGetVolumeNull_004
557 * @tc.desc Test AudioRenderGetVolume,return -3 when incoming parameter render is empty.
558 * @tc.type: FUNC
559 */
560 HWTEST_F(AudioIdlHdiRendervolumeTest, AudioRenderGetVolumeNull_004, TestSize.Level1)
561 {
562 int32_t ret = -1;
563 float *volumeNull = nullptr;
564
565 ASSERT_NE(nullptr, render);
566 ret = render->GetVolume(render, volumeNull);
567 ASSERT_TRUE(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_NOT_SUPPORT);
568 }
569 }