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