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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include "audio_proxy_common_fun_test.h"
19
20 using namespace std;
21 using namespace comfun;
22 using namespace testing::ext;
23 namespace {
24 class AudioProxyRenderTest : public testing::Test {
25 public:
26 struct AudioManager *managerFuncs = nullptr;
27 struct AudioManager *(*getAudioManager)(void) = NULL;
28 struct AudioAdapterDescriptor *descs = nullptr;
29 struct AudioAdapterDescriptor *desc = nullptr;
30 struct AudioAdapter *adapter = nullptr;
31 struct AudioRender *render = nullptr;
32 void *clientHandle = nullptr;
33 struct AudioDeviceDescriptor devDescRender = {};
34 struct AudioSampleAttributes attrsRender = {};
35 virtual void SetUp();
36 virtual void TearDown();
37 };
38
SetUp()39 void AudioProxyRenderTest::SetUp()
40 {
41 clientHandle = GetDynamicLibHandle(RESOLVED_PATH);
42 ASSERT_NE(clientHandle, nullptr);
43 getAudioManager = (struct AudioManager *(*)())(dlsym(clientHandle, FUNCTION_NAME.c_str()));
44 ASSERT_NE(getAudioManager, nullptr);
45 managerFuncs = getAudioManager();
46 ASSERT_NE(managerFuncs, nullptr);
47 int32_t size = 0;
48 ASSERT_EQ(HDF_SUCCESS, managerFuncs->GetAllAdapters(managerFuncs, &descs, &size));
49 ASSERT_NE(descs, nullptr);
50 desc = &descs[0];
51 ASSERT_EQ(HDF_SUCCESS, managerFuncs->LoadAdapter(managerFuncs, desc, &adapter));
52 ASSERT_NE(adapter, nullptr);
53 ASSERT_EQ(HDF_SUCCESS, InitDevDesc(devDescRender));
54 ASSERT_EQ(HDF_SUCCESS, InitAttrs(attrsRender));
55 ASSERT_EQ(HDF_SUCCESS, adapter->CreateRender(adapter, &devDescRender, &attrsRender, &render));
56 }
57
TearDown()58 void AudioProxyRenderTest::TearDown()
59 {
60 if (adapter != nullptr) {
61 adapter->DestroyRender(adapter, render);
62 render = nullptr;
63 }
64 if (managerFuncs != nullptr) {
65 managerFuncs->UnloadAdapter(managerFuncs, adapter);
66 adapter = nullptr;
67 managerFuncs->ReleaseAudioManagerObject(managerFuncs);
68 managerFuncs = nullptr;
69 }
70 if (clientHandle != nullptr) {
71 dlclose(clientHandle);
72 clientHandle = nullptr;
73 }
74 }
75
76 HWTEST_F(AudioProxyRenderTest, RenderStart_001, TestSize.Level1)
77 {
78 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderStart(nullptr));
79 }
80
81 HWTEST_F(AudioProxyRenderTest, RenderStart_002, TestSize.Level1)
82 {
83 ASSERT_NE(render, nullptr);
84 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
85 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
86 hwRender->proxyRemoteHandle = nullptr;
87 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderStart((AudioHandle)render));
88 hwRender->proxyRemoteHandle = proxyRemoteHandle;
89 }
90
91 HWTEST_F(AudioProxyRenderTest, RenderStart_003, TestSize.Level1)
92 {
93 ASSERT_NE(render, nullptr);
94 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderStart((AudioHandle)render));
95 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderStop((AudioHandle)render));
96 }
97
98 HWTEST_F(AudioProxyRenderTest, RenderStop_001, TestSize.Level1)
99 {
100 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderStop(nullptr));
101 }
102
103 HWTEST_F(AudioProxyRenderTest, RenderStop_002, TestSize.Level1)
104 {
105 ASSERT_NE(render, nullptr);
106 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
107 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
108 hwRender->proxyRemoteHandle = nullptr;
109 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderStop((AudioHandle)render));
110 hwRender->proxyRemoteHandle = proxyRemoteHandle;
111 }
112
113 HWTEST_F(AudioProxyRenderTest, RenderPause_001, TestSize.Level1)
114 {
115 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderPause(nullptr));
116 }
117
118 HWTEST_F(AudioProxyRenderTest, RenderPause_002, TestSize.Level1)
119 {
120 ASSERT_NE(render, nullptr);
121 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
122 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
123 hwRender->proxyRemoteHandle = nullptr;
124 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderPause((AudioHandle)render));
125 hwRender->proxyRemoteHandle = proxyRemoteHandle;
126 }
127
128 HWTEST_F(AudioProxyRenderTest, RenderResume_001, TestSize.Level1)
129 {
130 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderResume(nullptr));
131 }
132
133 HWTEST_F(AudioProxyRenderTest, RenderResume_002, TestSize.Level1)
134 {
135 ASSERT_NE(render, nullptr);
136 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
137 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
138 hwRender->proxyRemoteHandle = nullptr;
139 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderResume((AudioHandle)render));
140 hwRender->proxyRemoteHandle = proxyRemoteHandle;
141 }
142
143 HWTEST_F(AudioProxyRenderTest, RenderFlush_001, TestSize.Level1)
144 {
145 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderFlush(nullptr));
146 }
147
148 HWTEST_F(AudioProxyRenderTest, RenderFlush_002, TestSize.Level1)
149 {
150 ASSERT_NE(render, nullptr);
151 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioProxyRenderFlush((AudioHandle)render));
152 }
153
154 HWTEST_F(AudioProxyRenderTest, RenderGetFrameSize_001, TestSize.Level1)
155 {
156 ASSERT_NE(render, nullptr);
157 uint64_t size = 0;
158 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetFrameSize(nullptr, &size));
159 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetFrameSize((AudioHandle)render, nullptr));
160 }
161
162 HWTEST_F(AudioProxyRenderTest, RenderGetFrameSize_002, TestSize.Level1)
163 {
164 ASSERT_NE(render, nullptr);
165 uint64_t size = 0;
166 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
167 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
168 hwRender->proxyRemoteHandle = nullptr;
169 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetFrameSize((AudioHandle)render, &size));
170 hwRender->proxyRemoteHandle = proxyRemoteHandle;
171 }
172
173 HWTEST_F(AudioProxyRenderTest, RenderGetFrameCount_001, TestSize.Level1)
174 {
175 ASSERT_NE(render, nullptr);
176 uint64_t count = 0;
177 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetFrameCount(nullptr, &count));
178 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetFrameCount((AudioHandle)render, nullptr));
179 }
180
181 HWTEST_F(AudioProxyRenderTest, RenderGetFrameCount_002, TestSize.Level1)
182 {
183 ASSERT_NE(render, nullptr);
184 uint64_t count = 0;
185 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
186 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
187 hwRender->proxyRemoteHandle = nullptr;
188 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetFrameCount((AudioHandle)render, &count));
189 hwRender->proxyRemoteHandle = proxyRemoteHandle;
190 }
191
192 HWTEST_F(AudioProxyRenderTest, RenderSetSampleAttributes_001, TestSize.Level1)
193 {
194 ASSERT_NE(render, nullptr);
195 struct AudioSampleAttributes attrs;
196 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetSampleAttributes(nullptr, &attrs));
197 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetSampleAttributes((AudioHandle)render, nullptr));
198 }
199
200 HWTEST_F(AudioProxyRenderTest, RenderSetSampleAttributes_002, TestSize.Level1)
201 {
202 ASSERT_NE(render, nullptr);
203 struct AudioSampleAttributes attrs;
204 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
205 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
206 hwRender->proxyRemoteHandle = nullptr;
207 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetSampleAttributes((AudioHandle)render, &attrs));
208 hwRender->proxyRemoteHandle = proxyRemoteHandle;
209 }
210
211 HWTEST_F(AudioProxyRenderTest, RenderGetSampleAttributes_001, TestSize.Level1)
212 {
213 ASSERT_NE(render, nullptr);
214 struct AudioSampleAttributes attrs;
215 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetSampleAttributes(nullptr, &attrs));
216 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetSampleAttributes((AudioHandle)render, nullptr));
217 }
218
219 HWTEST_F(AudioProxyRenderTest, RenderGetSampleAttributes_002, TestSize.Level1)
220 {
221 ASSERT_NE(render, nullptr);
222 struct AudioSampleAttributes attrs;
223 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
224 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
225 hwRender->proxyRemoteHandle = nullptr;
226 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetSampleAttributes((AudioHandle)render, &attrs));
227 hwRender->proxyRemoteHandle = proxyRemoteHandle;
228 }
229
230 HWTEST_F(AudioProxyRenderTest, RenderGetCurrentChannelId_001, TestSize.Level1)
231 {
232 ASSERT_NE(render, nullptr);
233 uint32_t channelId = 0;
234 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetCurrentChannelId(nullptr, &channelId));
235 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetCurrentChannelId((AudioHandle)render, nullptr));
236 }
237
238 HWTEST_F(AudioProxyRenderTest, RenderGetCurrentChannelId_002, TestSize.Level1)
239 {
240 ASSERT_NE(render, nullptr);
241 uint32_t channelId = 0;
242 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
243 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
244 hwRender->proxyRemoteHandle = nullptr;
245 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetCurrentChannelId((AudioHandle)render, &channelId));
246 hwRender->proxyRemoteHandle = proxyRemoteHandle;
247 }
248
249 HWTEST_F(AudioProxyRenderTest, RenderCheckSceneCapability_001, TestSize.Level1)
250 {
251 ASSERT_NE(render, nullptr);
252 struct AudioSceneDescriptor scene;
253 scene.scene.id = 0;
254 scene.desc.pins = PIN_OUT_SPEAKER;
255 bool supported = false;
256 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderCheckSceneCapability(nullptr, &scene, &supported));
257 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderCheckSceneCapability((AudioHandle)render, nullptr,
258 &supported));
259 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderCheckSceneCapability((AudioHandle)render, &scene, nullptr));
260 }
261
262 HWTEST_F(AudioProxyRenderTest, RenderCheckSceneCapability_002, TestSize.Level1)
263 {
264 ASSERT_NE(render, nullptr);
265 struct AudioSceneDescriptor scene;
266 scene.scene.id = 0;
267 scene.desc.pins = PIN_OUT_SPEAKER;
268 bool supported = false;
269 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
270 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
271 hwRender->proxyRemoteHandle = nullptr;
272 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderCheckSceneCapability((AudioHandle)render, &scene,
273 &supported));
274 hwRender->proxyRemoteHandle = proxyRemoteHandle;
275 }
276
277 HWTEST_F(AudioProxyRenderTest, RenderSelectScene_001, TestSize.Level1)
278 {
279 ASSERT_NE(render, nullptr);
280 struct AudioSceneDescriptor scene;
281 scene.scene.id = 0;
282 scene.desc.pins = PIN_OUT_SPEAKER;
283 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSelectScene(nullptr, &scene));
284 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSelectScene((AudioHandle)render, nullptr));
285 }
286
287 HWTEST_F(AudioProxyRenderTest, RenderSelectScene_002, TestSize.Level1)
288 {
289 ASSERT_NE(render, nullptr);
290 struct AudioSceneDescriptor scene;
291 scene.scene.id = 0;
292 scene.desc.pins = PIN_OUT_SPEAKER;
293 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
294 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
295 hwRender->proxyRemoteHandle = nullptr;
296 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSelectScene((AudioHandle)render, &scene));
297 hwRender->proxyRemoteHandle = proxyRemoteHandle;
298 }
299
300 HWTEST_F(AudioProxyRenderTest, RenderSelectScene_003, TestSize.Level1)
301 {
302 ASSERT_NE(render, nullptr);
303 AudioSceneDescriptor scene;
304 scene.scene.id = 0; // 0 is Media
305 scene.desc.pins = PIN_OUT_HEADSET;
306 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderSelectScene((AudioHandle)render, &scene));
307 scene.desc.pins = PIN_OUT_SPEAKER;
308 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderSelectScene((AudioHandle)render, &scene));
309 }
310
311 HWTEST_F(AudioProxyRenderTest, RenderSetMute_001, TestSize.Level1)
312 {
313 bool mute = false;
314 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetMute(nullptr, mute));
315 }
316
317 HWTEST_F(AudioProxyRenderTest, RenderSetMute_002, TestSize.Level1)
318 {
319 ASSERT_NE(render, nullptr);
320 bool mute = false;
321 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
322 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
323 hwRender->proxyRemoteHandle = nullptr;
324 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetMute((AudioHandle)render, mute));
325 hwRender->proxyRemoteHandle = proxyRemoteHandle;
326 }
327
328 HWTEST_F(AudioProxyRenderTest, RenderGetMute_001, TestSize.Level1)
329 {
330 ASSERT_NE(render, nullptr);
331 bool mute = false;
332 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetMute(nullptr, &mute));
333 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetMute((AudioHandle)render, nullptr));
334 }
335
336 HWTEST_F(AudioProxyRenderTest, RenderGetMute_002, TestSize.Level1)
337 {
338 ASSERT_NE(render, nullptr);
339 bool mute = false;
340 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
341 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
342 hwRender->proxyRemoteHandle = nullptr;
343 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetMute((AudioHandle)render, &mute));
344 hwRender->proxyRemoteHandle = proxyRemoteHandle;
345 }
346
347 HWTEST_F(AudioProxyRenderTest, RenderSetVolume_001, TestSize.Level1)
348 {
349 float volume = HALF_OF_NORMAL_VALUE; // Adjust the volume to half
350 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetVolume(nullptr, volume));
351 }
352
353 HWTEST_F(AudioProxyRenderTest, RenderSetVolume_002, TestSize.Level1)
354 {
355 ASSERT_NE(render, nullptr);
356 float volume = HALF_OF_NORMAL_VALUE; // Adjust the volume to half
357 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
358 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
359 hwRender->proxyRemoteHandle = nullptr;
360 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetVolume((AudioHandle)render, volume));
361 hwRender->proxyRemoteHandle = proxyRemoteHandle;
362 }
363
364 HWTEST_F(AudioProxyRenderTest, RenderSetVolume_003, TestSize.Level1)
365 {
366 ASSERT_NE(render, nullptr);
367 float volume = MIN_VALUE_OUT_OF_BOUNDS; // The volume value is not within the threshold range [0,1]
368 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetVolume((AudioHandle)render, volume));
369 volume = MAX_VALUE_OUT_OF_BOUNDS; // The volume value is not within the threshold range [0,1]
370 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetVolume((AudioHandle)render, volume));
371 }
372
373 HWTEST_F(AudioProxyRenderTest, RenderGetVolume_001, TestSize.Level1)
374 {
375 ASSERT_NE(render, nullptr);
376 float volume = 0;
377 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetVolume(nullptr, &volume));
378 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetVolume((AudioHandle)render, nullptr));
379 }
380
381 HWTEST_F(AudioProxyRenderTest, RenderGetVolume_002, TestSize.Level1)
382 {
383 ASSERT_NE(render, nullptr);
384 float volume = 0;
385 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
386 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
387 hwRender->proxyRemoteHandle = nullptr;
388 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetVolume((AudioHandle)render, &volume));
389 hwRender->proxyRemoteHandle = proxyRemoteHandle;
390 }
391
392 HWTEST_F(AudioProxyRenderTest, RenderGetGainThreshold_001, TestSize.Level1)
393 {
394 ASSERT_NE(render, nullptr);
395 float min = 0;
396 float max = 0;
397 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetGainThreshold(nullptr, &min, &max));
398 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetGainThreshold((AudioHandle)render, nullptr, &max));
399 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetGainThreshold((AudioHandle)render, &min, nullptr));
400 }
401
402 HWTEST_F(AudioProxyRenderTest, RenderGetGainThreshold_002, TestSize.Level1)
403 {
404 ASSERT_NE(render, nullptr);
405 float min = 0;
406 float max = 0;
407 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
408 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
409 hwRender->proxyRemoteHandle = nullptr;
410 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetGainThreshold((AudioHandle)render, &min, &max));
411 hwRender->proxyRemoteHandle = proxyRemoteHandle;
412 }
413
414 HWTEST_F(AudioProxyRenderTest, RenderGetGain_001, TestSize.Level1)
415 {
416 ASSERT_NE(render, nullptr);
417 float gain = 0;
418 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetGain(nullptr, &gain));
419 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetGain((AudioHandle)render, nullptr));
420 }
421
422 HWTEST_F(AudioProxyRenderTest, RenderGetGain_002, TestSize.Level1)
423 {
424 ASSERT_NE(render, nullptr);
425 float gain = 0;
426 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
427 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
428 hwRender->proxyRemoteHandle = nullptr;
429 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetGain((AudioHandle)render, &gain));
430 hwRender->proxyRemoteHandle = proxyRemoteHandle;
431 }
432
433 HWTEST_F(AudioProxyRenderTest, RenderSetGain_001, TestSize.Level1)
434 {
435 float gain = HALF_OF_NORMAL_VALUE; // Adjust the gain to half
436 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetGain(nullptr, gain));
437 }
438
439 HWTEST_F(AudioProxyRenderTest, RenderSetGain_002, TestSize.Level1)
440 {
441 ASSERT_NE(render, nullptr);
442 float gain = HALF_OF_NORMAL_VALUE; // Adjust the gain to half
443 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
444 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
445 hwRender->proxyRemoteHandle = nullptr;
446 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetGain((AudioHandle)render, gain));
447 hwRender->proxyRemoteHandle = proxyRemoteHandle;
448 }
449
450 HWTEST_F(AudioProxyRenderTest, RenderSetGain_003, TestSize.Level1)
451 {
452 ASSERT_NE(render, nullptr);
453 float gain = MIN_VALUE_OUT_OF_BOUNDS; // The gain value is not within the threshold range [0,1]
454 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetGain((AudioHandle)render, gain));
455 }
456
457 HWTEST_F(AudioProxyRenderTest, RenderGetLatency_001, TestSize.Level1)
458 {
459 uint32_t ms = 0;
460 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetLatency(nullptr, &ms));
461 }
462
463 HWTEST_F(AudioProxyRenderTest, RenderGetLatency_002, TestSize.Level1)
464 {
465 ASSERT_NE(render, nullptr);
466 uint32_t ms = 0;
467 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
468 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
469 hwRender->proxyRemoteHandle = nullptr;
470 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetLatency(render, &ms));
471 hwRender->proxyRemoteHandle = proxyRemoteHandle;
472 }
473
474 HWTEST_F(AudioProxyRenderTest, RenderGetLatency_003, TestSize.Level1)
475 {
476 ASSERT_NE(render, nullptr);
477 uint32_t ms = 0;
478 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderGetLatency(render, &ms));
479 }
480
481 HWTEST_F(AudioProxyRenderTest, RenderFrame_001, TestSize.Level1)
482 {
483 ASSERT_NE(render, nullptr);
484 int8_t frame[AUDIO_RENDER_BUF_TEST];
485 uint64_t frameLen = AUDIO_RENDER_BUF_TEST;
486 uint64_t requestBytes = AUDIO_RENDER_BUF_TEST;
487 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRenderFrame(nullptr, &frame, frameLen, &requestBytes));
488 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRenderFrame(render, nullptr, frameLen, &requestBytes));
489 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRenderFrame(render, &frame, frameLen, nullptr));
490 }
491
492 HWTEST_F(AudioProxyRenderTest, RenderFrame_002, TestSize.Level1)
493 {
494 ASSERT_NE(render, nullptr);
495 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
496 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
497 hwRender->proxyRemoteHandle = nullptr;
498 int8_t frame[AUDIO_RENDER_BUF_TEST];
499 uint64_t frameLen = AUDIO_RENDER_BUF_TEST;
500 uint64_t requestBytes = AUDIO_RENDER_BUF_TEST;
501 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRenderFrame(render, &frame, frameLen, &requestBytes));
502 hwRender->proxyRemoteHandle = proxyRemoteHandle;
503 }
504
505 HWTEST_F(AudioProxyRenderTest, RenderFrame_003, TestSize.Level1)
506 {
507 ASSERT_NE(render, nullptr);
508 int8_t frame[AUDIO_RENDER_BUF_TEST] = {0};
509 uint64_t frameLen = AUDIO_RENDER_BUF_TEST;
510 uint64_t requestBytes = AUDIO_RENDER_BUF_TEST;
511 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderStart((AudioHandle)render));
512 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderRenderFrame(render, &frame, frameLen, &requestBytes));
513 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyRenderStop((AudioHandle)render));
514 }
515
516
517 HWTEST_F(AudioProxyRenderTest, RenderGetRenderPosition_001, TestSize.Level1)
518 {
519 ASSERT_NE(render, nullptr);
520 uint64_t frames = 0;
521 struct AudioTimeStamp time;
522 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetRenderPosition(nullptr, &frames, &time));
523 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetRenderPosition(render, nullptr, &time));
524 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetRenderPosition(render, &frames, nullptr));
525 }
526
527 HWTEST_F(AudioProxyRenderTest, RenderGetRenderPosition_002, TestSize.Level1)
528 {
529 ASSERT_NE(render, nullptr);
530 uint64_t frames = 0;
531 struct AudioTimeStamp time;
532 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
533 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
534 hwRender->proxyRemoteHandle = nullptr;
535 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetRenderPosition(render, &frames, &time));
536 hwRender->proxyRemoteHandle = proxyRemoteHandle;
537 }
538
539 HWTEST_F(AudioProxyRenderTest, RenderSetRenderSpeed_001, TestSize.Level1)
540 {
541 ASSERT_NE(render, nullptr);
542 float speed = 0;
543 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetRenderSpeed(nullptr, speed));
544 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioProxyRenderSetRenderSpeed(render, speed));
545 }
546
547 HWTEST_F(AudioProxyRenderTest, RenderGetRenderSpeed_001, TestSize.Level1)
548 {
549 ASSERT_NE(render, nullptr);
550 float speed = 0;
551 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetRenderSpeed(nullptr, &speed));
552 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetRenderSpeed(render, nullptr));
553 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioProxyRenderGetRenderSpeed(render, &speed));
554 }
555
556 HWTEST_F(AudioProxyRenderTest, RenderSetChannelMode_001, TestSize.Level1)
557 {
558 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
559 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetChannelMode(nullptr, mode));
560 }
561
562 HWTEST_F(AudioProxyRenderTest, RenderSetChannelMode_002, TestSize.Level1)
563 {
564 ASSERT_NE(render, nullptr);
565 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
566 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
567 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
568 hwRender->proxyRemoteHandle = nullptr;
569 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetChannelMode(render, mode));
570 hwRender->proxyRemoteHandle = proxyRemoteHandle;
571 }
572
573 HWTEST_F(AudioProxyRenderTest, RenderGetChannelMode_001, TestSize.Level1)
574 {
575 ASSERT_NE(render, nullptr);
576 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
577 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetChannelMode(nullptr, &mode));
578 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetChannelMode(render, nullptr));
579 }
580
581 HWTEST_F(AudioProxyRenderTest, RenderGetChannelMode_002, TestSize.Level1)
582 {
583 ASSERT_NE(render, nullptr);
584 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
585 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
586 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
587 hwRender->proxyRemoteHandle = nullptr;
588 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetChannelMode(render, &mode));
589 hwRender->proxyRemoteHandle = proxyRemoteHandle;
590 }
591
592 HWTEST_F(AudioProxyRenderTest, RenderSetExtraParams_001, TestSize.Level1)
593 {
594 ASSERT_NE(render, nullptr);
595 char keyValueList[AUDIO_RENDER_BUF_TEST];
596 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetExtraParams(nullptr, keyValueList));
597 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetExtraParams((AudioHandle)render, nullptr));
598 }
599
600 HWTEST_F(AudioProxyRenderTest, RenderSetExtraParams_002, TestSize.Level1)
601 {
602 ASSERT_NE(render, nullptr);
603 char keyValueList[AUDIO_RENDER_BUF_TEST];
604 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
605 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
606 hwRender->proxyRemoteHandle = nullptr;
607 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderSetExtraParams((AudioHandle)render, keyValueList));
608 hwRender->proxyRemoteHandle = proxyRemoteHandle;
609 }
610
611 HWTEST_F(AudioProxyRenderTest, RenderGetExtraParams_001, TestSize.Level1)
612 {
613 ASSERT_NE(render, nullptr);
614 char keyValueList[AUDIO_RENDER_BUF_TEST];
615 int32_t listLenth = AUDIO_RENDER_BUF_TEST;
616 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetExtraParams(nullptr, keyValueList, listLenth));
617 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetExtraParams((AudioHandle)render, nullptr, listLenth));
618 }
619
620 HWTEST_F(AudioProxyRenderTest, RenderGetExtraParams_002, TestSize.Level1)
621 {
622 ASSERT_NE(render, nullptr);
623 char keyValueList[AUDIO_RENDER_BUF_TEST];
624 int32_t listLenth = AUDIO_RENDER_BUF_TEST;
625 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
626 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
627 hwRender->proxyRemoteHandle = nullptr;
628 int32_t ret = AudioProxyRenderGetExtraParams((AudioHandle)render, keyValueList, listLenth);
629 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
630 hwRender->proxyRemoteHandle = proxyRemoteHandle;
631 }
632
633 HWTEST_F(AudioProxyRenderTest, RenderReqMmapBuffer_001, TestSize.Level1)
634 {
635 ASSERT_NE(render, nullptr);
636 int32_t reqSize = 0;
637 struct AudioMmapBufferDescripter desc;
638 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderReqMmapBuffer(nullptr, reqSize, &desc));
639 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderReqMmapBuffer((AudioHandle)render, reqSize, nullptr));
640 }
641
642 HWTEST_F(AudioProxyRenderTest, RenderReqMmapBuffer_002, TestSize.Level1)
643 {
644 ASSERT_NE(render, nullptr);
645 int32_t reqSize = 0;
646 struct AudioMmapBufferDescripter desc;
647 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
648 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
649 hwRender->proxyRemoteHandle = nullptr;
650 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderReqMmapBuffer((AudioHandle)render, reqSize, &desc));
651 hwRender->proxyRemoteHandle = proxyRemoteHandle;
652 }
653
654 HWTEST_F(AudioProxyRenderTest, RenderGetMmapPosition_001, TestSize.Level1)
655 {
656 ASSERT_NE(render, nullptr);
657 uint64_t frames;
658 struct AudioTimeStamp time;
659 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetMmapPosition(nullptr, &frames, &time));
660 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetMmapPosition((AudioHandle)render, nullptr, &time));
661 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetMmapPosition((AudioHandle)render, &frames, nullptr));
662 }
663
664 HWTEST_F(AudioProxyRenderTest, RenderGetMmapPosition_002, TestSize.Level1)
665 {
666 ASSERT_NE(render, nullptr);
667 uint64_t frames;
668 struct AudioTimeStamp time;
669 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
670 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
671 hwRender->proxyRemoteHandle = nullptr;
672 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderGetMmapPosition((AudioHandle)render, &frames, &time));
673 hwRender->proxyRemoteHandle = proxyRemoteHandle;
674 }
675
676 HWTEST_F(AudioProxyRenderTest, RenderTurnStandbyMode_001, TestSize.Level1)
677 {
678 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderTurnStandbyMode(nullptr));
679 }
680
681 HWTEST_F(AudioProxyRenderTest, RenderTurnStandbyMode_002, TestSize.Level1)
682 {
683 ASSERT_NE(render, nullptr);
684 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
685 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
686 hwRender->proxyRemoteHandle = nullptr;
687 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderTurnStandbyMode((AudioHandle)render));
688 hwRender->proxyRemoteHandle = proxyRemoteHandle;
689 }
690
691 HWTEST_F(AudioProxyRenderTest, RenderAudioDevDump_001, TestSize.Level1)
692 {
693 int32_t range = 0;
694 int32_t fd = 0;
695 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderAudioDevDump(nullptr, range, fd));
696 }
697
698 HWTEST_F(AudioProxyRenderTest, RenderAudioDevDump_002, TestSize.Level1)
699 {
700 ASSERT_NE(render, nullptr);
701 int32_t range = 0;
702 int32_t fd = 0;
703 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
704 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
705 hwRender->proxyRemoteHandle = nullptr;
706 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderAudioDevDump((AudioHandle)render, range, fd));
707 hwRender->proxyRemoteHandle = proxyRemoteHandle;
708 }
709
710 HWTEST_F(AudioProxyRenderTest, RenderRegCallback_001, TestSize.Level1)
711 {
712 ASSERT_NE(render, nullptr);
713 uint64_t tempAddr = 1;
714 void *cookie = (void *)(uintptr_t)tempAddr;
715 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRegCallback(nullptr, AudioRenderCallbackUtTest, cookie));
716 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRegCallback(render, nullptr, cookie));
717 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRegCallback(render, AudioRenderCallbackUtTest, nullptr));
718 }
719
720 HWTEST_F(AudioProxyRenderTest, RenderRegCallback_002, TestSize.Level1)
721 {
722 ASSERT_NE(render, nullptr);
723 uint64_t tempAddr = 1;
724 void *cookie = (void *)(uintptr_t)tempAddr;
725 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
726 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
727 hwRender->proxyRemoteHandle = nullptr;
728 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderRegCallback(render, AudioRenderCallbackUtTest, cookie));
729 hwRender->proxyRemoteHandle = proxyRemoteHandle;
730 }
731
732 HWTEST_F(AudioProxyRenderTest, RenderDrainBuffer_001, TestSize.Level1)
733 {
734 ASSERT_NE(render, nullptr);
735 AudioDrainNotifyType type = AUDIO_DRAIN_NORMAL_MODE;
736 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderDrainBuffer(nullptr, &type));
737 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderDrainBuffer(render, nullptr));
738 }
739
740 HWTEST_F(AudioProxyRenderTest, RenderDrainBuffer_002, TestSize.Level1)
741 {
742 ASSERT_NE(render, nullptr);
743 AudioDrainNotifyType type = AUDIO_DRAIN_NORMAL_MODE;
744 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
745 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
746 hwRender->proxyRemoteHandle = nullptr;
747 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyRenderDrainBuffer(render, &type));
748 hwRender->proxyRemoteHandle = proxyRemoteHandle;
749 }
750 }
751