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 "audio_lib_common.h"
17 #include "audio_librender_hardwaredependence_test.h"
18 
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Audio;
22 
23 namespace {
24 const string BIND_CONTROL = "control";
25 const string BIND_RENDER = "render";
26 #ifdef PRODUCT_RK3568
27     const string PATH_SWITCH_ORDER = "Headphone1 Switch";
28     constexpr int MAX_VOLUME = 255;
29     constexpr int MIN_VOLUME = 0;
30     constexpr int BELOW_MAX_VOLUME = 254;
31     constexpr int OVER_MIN_VOLUME = 1;
32 #else
33     const string PATH_SWITCH_ORDER = "Dacl enable";
34     constexpr int MAX_VOLUME = 127;
35     constexpr int MIN_VOLUME = 40;
36     constexpr int BELOW_MAX_VOLUME = 126;
37     constexpr int OVER_MIN_VOLUME = 41;
38 #endif
39     constexpr float MAX_GAIN = 15;
40     constexpr float MIN_GAIN = 0;
41 class AudioLibRenderHardwareDependenceTest : public testing::Test {
42 public:
43     static void SetUpTestCase(void);
44     static void TearDownTestCase(void);
45     void SetUp();
46     void TearDown();
47     static struct DevHandle *(*BindServiceRenderSo)(const char *serverName);
48     static int32_t (*InterfaceLibOutputRender)(struct DevHandle *handle,
49                     int cmdId, struct AudioHwRenderParam *handleData);
50     static int32_t (*InterfaceLibCtlRender)(struct DevHandle *handle, int cmdId, struct AudioHwRenderParam *handleData);
51     static void (*CloseServiceRenderSo)(struct DevHandle *handle);
52     static void *ptrHandle;
53     int32_t LibHwOutputRender(struct AudioHwRender *hwRender, struct DevHandle *handlerender) const;
54     int32_t BindServiceAndHwRender(struct AudioHwRender *&hwRender,
55         const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const;
56 };
57 
58 struct DevHandle *(*AudioLibRenderHardwareDependenceTest::BindServiceRenderSo)(const char *serverName) = nullptr;
59 int32_t (*AudioLibRenderHardwareDependenceTest::InterfaceLibOutputRender)(struct DevHandle *handle, int cmdId,
60     struct AudioHwRenderParam *handleData) = nullptr;
61 int32_t (*AudioLibRenderHardwareDependenceTest::InterfaceLibCtlRender)(struct DevHandle *handle, int cmdId,
62     struct AudioHwRenderParam *handleData) = nullptr;
63 void (*AudioLibRenderHardwareDependenceTest::CloseServiceRenderSo)(struct DevHandle *handle) = nullptr;
64 void *AudioLibRenderHardwareDependenceTest::ptrHandle = nullptr;
65 
SetUpTestCase(void)66 void AudioLibRenderHardwareDependenceTest::SetUpTestCase(void)
67 {
68     char resolvedPath[] = HDF_LIBRARY_FULL_PATH("libaudio_render_adapter");
69     ptrHandle = dlopen(resolvedPath, RTLD_LAZY);
70     if (ptrHandle == nullptr) {
71         return;
72     }
73     BindServiceRenderSo = (struct DevHandle* (*)(const char *serverName))dlsym(ptrHandle, "AudioBindServiceRender");
74     InterfaceLibOutputRender = (int32_t (*)(struct DevHandle *handle, int cmdId,
75         struct AudioHwRenderParam *handleData))dlsym(ptrHandle, "AudioInterfaceLibOutputRender");
76     InterfaceLibCtlRender = (int32_t (*)(struct DevHandle *handle, int cmdId,
77         struct AudioHwRenderParam *handleData))dlsym(ptrHandle, "AudioInterfaceLibCtlRender");
78     CloseServiceRenderSo = (void (*)(struct DevHandle *handle))dlsym(ptrHandle, "AudioCloseServiceRender");
79     if (BindServiceRenderSo == nullptr || CloseServiceRenderSo == nullptr ||
80         InterfaceLibCtlRender == nullptr || InterfaceLibOutputRender == nullptr) {
81         dlclose(ptrHandle);
82         return;
83     }
84 }
85 
TearDownTestCase(void)86 void AudioLibRenderHardwareDependenceTest::TearDownTestCase(void)
87 {
88     if (BindServiceRenderSo != nullptr) {
89         BindServiceRenderSo = nullptr;
90     }
91     if (CloseServiceRenderSo != nullptr) {
92         CloseServiceRenderSo = nullptr;
93     }
94     if (InterfaceLibOutputRender != nullptr) {
95         InterfaceLibOutputRender = nullptr;
96     }
97     if (InterfaceLibCtlRender != nullptr) {
98         InterfaceLibCtlRender = nullptr;
99     }
100     if (ptrHandle != nullptr) {
101         dlclose(ptrHandle);
102         ptrHandle = nullptr;
103     }
104 }
105 
SetUp(void)106 void AudioLibRenderHardwareDependenceTest::SetUp(void) {}
107 
TearDown(void)108 void AudioLibRenderHardwareDependenceTest::TearDown(void) {}
109 
LibHwOutputRender(struct AudioHwRender * hwRender,struct DevHandle * handlerender) const110 int32_t AudioLibRenderHardwareDependenceTest::LibHwOutputRender(struct AudioHwRender *hwRender,
111                                                                 struct DevHandle *handlerender) const
112 {
113     if (hwRender == nullptr || handlerender == nullptr) {
114         return HDF_FAILURE;
115     }
116     if (InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTRL_RENDER_OPEN, &hwRender->renderParam) ||
117         InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwRender->renderParam) ||
118         InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTL_PREPARE, &hwRender->renderParam) ||
119         InterfaceLibOutputRender(handlerender, AUDIO_DRV_PCM_IOCTRL_START, &hwRender->renderParam)) {
120         return HDF_FAILURE;
121     }
122     return HDF_SUCCESS;
123 }
124 
BindServiceAndHwRender(struct AudioHwRender * & hwRender,const std::string BindName,const std::string adapterNameCase,struct DevHandle * & handle) const125 int32_t AudioLibRenderHardwareDependenceTest::BindServiceAndHwRender(struct AudioHwRender *&hwRender,
126     const std::string BindName, const std::string adapterNameCase, struct DevHandle *&handle) const
127 {
128     int32_t ret = HDF_FAILURE;
129     handle = BindServiceRenderSo(BindName.c_str());
130     if (handle == nullptr) {
131         return HDF_FAILURE;
132     }
133     hwRender = static_cast<struct AudioHwRender *>(calloc(1, sizeof(*hwRender)));
134     if (hwRender == nullptr) {
135         CloseServiceRenderSo(handle);
136         return HDF_FAILURE;
137     }
138     ret = InitHwRender(hwRender, adapterNameCase);
139     if (ret != HDF_SUCCESS) {
140         CloseServiceRenderSo(handle);
141         free(hwRender);
142         hwRender = nullptr;
143         return HDF_FAILURE;
144     }
145     return HDF_SUCCESS;
146 }
147 /**
148 * @tc.name  AudioInterfaceLibCtlRenderVolumeWriteRead_001
149 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
150 * @tc.type: FUNC
151 */
152 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderVolumeWriteRead_001, TestSize.Level1)
153 {
154     int32_t ret = HDF_FAILURE;
155     float volumeValue = 0;
156     float volumeThresholdValueMaxIn = 0;
157     float volumeThresholdValueMinIn = 0;
158     float volumeBoundaryValueIn = 127.9;
159     struct DevHandle *handle = nullptr;
160     struct AudioHwRender *hwRender = nullptr;
161     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
162     ASSERT_EQ(HDF_SUCCESS, ret);
163 
164     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
165     EXPECT_EQ(HDF_SUCCESS, ret);
166     volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
167     volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
168 
169     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMaxIn - 1;
170     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
171     EXPECT_EQ(HDF_SUCCESS, ret);
172     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
173     EXPECT_EQ(HDF_SUCCESS, ret);
174     volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
175     EXPECT_EQ(BELOW_MAX_VOLUME, volumeValue);
176 
177     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMinIn + 1;
178     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
179     EXPECT_EQ(HDF_SUCCESS, ret);
180     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
181     EXPECT_EQ(HDF_SUCCESS, ret);
182     volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
183     EXPECT_EQ(OVER_MIN_VOLUME, volumeValue);
184     hwRender->renderParam.renderMode.ctlParam.volume = volumeBoundaryValueIn;
185     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
186     EXPECT_EQ(HDF_SUCCESS, ret);
187     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
188     EXPECT_EQ(HDF_SUCCESS, ret);
189     volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
190     EXPECT_EQ(static_cast<int>(volumeBoundaryValueIn), volumeValue);
191     CloseServiceRenderSo(handle);
192     free(hwRender);
193     hwRender = nullptr;
194 }
195 /**
196 * @tc.name  AudioInterfaceLibCtlRenderVolumeWriteRead_002
197 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
198 * @tc.type: FUNC
199 */
200 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderVolumeWriteRead_002, TestSize.Level1)
201 {
202     int32_t ret = HDF_FAILURE;
203     struct AudioHwRender *hwRender = nullptr;
204     struct DevHandle *handle = nullptr;
205     float volumeThresholdValueMaxIn = 0;
206     float volumeThresholdValueMinIn = 0;
207     float volumeValue = 0;
208     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
209     ASSERT_EQ(HDF_SUCCESS, ret);
210 
211     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
212     EXPECT_EQ(HDF_SUCCESS, ret);
213     volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
214     volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
215 
216     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMinIn;
217     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
218     EXPECT_EQ(HDF_SUCCESS, ret);
219     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
220     EXPECT_EQ(HDF_SUCCESS, ret);
221     volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
222     EXPECT_EQ(MIN_VOLUME, volumeValue);
223 
224     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMaxIn;
225     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
226     EXPECT_EQ(HDF_SUCCESS, ret);
227     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_READ, &hwRender->renderParam);
228     EXPECT_EQ(HDF_SUCCESS, ret);
229     volumeValue = hwRender->renderParam.renderMode.ctlParam.volume;
230     EXPECT_EQ(MAX_VOLUME, volumeValue);
231 
232     CloseServiceRenderSo(handle);
233     free(hwRender);
234     hwRender = nullptr;
235 }
236 /**
237 * @tc.name  AudioInterfaceLibCtlRenderVolumeWriteRead_003
238 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
239 * @tc.type: FUNC
240 */
241 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderVolumeWriteRead_003, TestSize.Level1)
242 {
243     int32_t ret = HDF_FAILURE;
244     struct DevHandle *handle = nullptr;
245     struct AudioHwRender *hwRender = nullptr;
246     float volumeThresholdValueMaxIn = 0;
247     float volumeThresholdValueMinIn = 0;
248 
249     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
250     ASSERT_EQ(HDF_SUCCESS, ret);
251 
252     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
253     EXPECT_EQ(HDF_SUCCESS, ret);
254     volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
255     volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
256 
257     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMaxIn + 1;
258     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
259     EXPECT_EQ(HDF_FAILURE, ret);
260 
261     hwRender->renderParam.renderMode.ctlParam.volume = volumeThresholdValueMinIn - 1;
262     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE, &hwRender->renderParam);
263     EXPECT_EQ(HDF_FAILURE, ret);
264 
265     CloseServiceRenderSo(handle);
266     free(hwRender);
267     hwRender = nullptr;
268 }
269 
270 /**
271 * @tc.name  AudioInterfaceLibCtlRenderGetVolthresholdRead_002
272 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ.
273 * @tc.type: FUNC
274 */
275 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderGetVolthresholdRead_002, TestSize.Level1)
276 {
277     int32_t ret = HDF_FAILURE;
278     float volumeThresholdValueMaxIn = 0;
279     float volumeThresholdValueMinIn = 0;
280     struct AudioHwRender *hwRender = nullptr;
281     struct DevHandle *handle = nullptr;
282     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
283     ASSERT_EQ(HDF_SUCCESS, ret);
284 
285     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ, &hwRender->renderParam);
286     EXPECT_EQ(HDF_SUCCESS, ret);
287     volumeThresholdValueMaxIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMax;
288     volumeThresholdValueMinIn = hwRender->renderParam.renderMode.ctlParam.volThreshold.volMin;
289     EXPECT_EQ(MAX_VOLUME, volumeThresholdValueMaxIn);
290     EXPECT_EQ(MIN_VOLUME, volumeThresholdValueMinIn);
291     CloseServiceRenderSo(handle);
292     free(hwRender);
293     hwRender = nullptr;
294 }
295 /**
296 * @tc.name  AudioInterfaceLibCtlRenderChannelModeWriteRead_001
297 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE
298 *    and AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ.
299 * @tc.type: FUNC
300 */
301 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderChannelModeWriteRead_001,
302          TestSize.Level1)
303 {
304     int32_t ret = HDF_FAILURE;
305     float channelModeExc = 1;
306     struct DevHandle *handle = nullptr;
307     struct DevHandle *handleRender = nullptr;
308     struct AudioHwRender *impl = nullptr;
309     ret = BindServiceAndHwRender(impl, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
310     ASSERT_EQ(HDF_SUCCESS, ret);
311     handleRender = BindServiceRenderSo(BIND_RENDER.c_str());
312     if (handleRender == nullptr) {
313         CloseServiceRenderSo(handle);
314         free(impl);
315         impl = nullptr;
316         ASSERT_NE(nullptr, handleRender);
317     }
318     ret = LibHwOutputRender(impl, handleRender);
319     EXPECT_EQ(HDF_SUCCESS, ret);
320     if (impl != nullptr) {
321         impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_BOTH_RIGHT;
322         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam);
323         EXPECT_EQ(HDF_SUCCESS, ret);
324         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam);
325         EXPECT_EQ(HDF_SUCCESS, ret);
326         channelModeExc = impl->renderParam.frameRenderMode.mode;
327         EXPECT_EQ(AUDIO_CHANNEL_BOTH_RIGHT, channelModeExc);
328 
329         impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_RIGHT_MUTE;
330         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam);
331 #ifdef PRODUCT_RK3568
332         EXPECT_EQ(HDF_FAILURE, ret);
333 #else
334         EXPECT_EQ(HDF_SUCCESS, ret);
335         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam);
336         EXPECT_EQ(HDF_SUCCESS, ret);
337         channelModeExc = impl->renderParam.frameRenderMode.mode;
338         EXPECT_EQ(AUDIO_CHANNEL_RIGHT_MUTE, channelModeExc);
339 #endif
340     }
341     CloseServiceRenderSo(handleRender);
342     CloseServiceRenderSo(handle);
343     free(impl);
344     impl = nullptr;
345 }
346 /**
347 * @tc.name  AudioInterfaceLibCtlRenderChannelModeWriteRead_002
348 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE
349 *    and AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ.
350 * @tc.type: FUNC
351 */
352 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderChannelModeWriteRead_002,
353          TestSize.Level1)
354 {
355     int32_t ret = HDF_FAILURE;
356     float channelModeExc = 1;
357     struct DevHandle *handleRender = nullptr;
358     struct DevHandle *handle = nullptr;
359     struct AudioHwRender *impl = nullptr;
360     ret = BindServiceAndHwRender(impl, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
361     ASSERT_EQ(HDF_SUCCESS, ret);
362     handleRender = BindServiceRenderSo(BIND_RENDER.c_str());
363     if (handleRender == nullptr) {
364         free(impl);
365         impl = nullptr;
366         CloseServiceRenderSo(handle);
367         ASSERT_NE(nullptr, handleRender);
368     }
369     ret = LibHwOutputRender(impl, handleRender);
370     EXPECT_EQ(HDF_SUCCESS, ret);
371     if (impl != nullptr) {
372         impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_BOTH_MUTE;
373         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam);
374 #ifdef PRODUCT_RK3568
375         EXPECT_EQ(HDF_FAILURE, ret);
376 #else
377         EXPECT_EQ(HDF_SUCCESS, ret);
378         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam);
379         EXPECT_EQ(HDF_SUCCESS, ret);
380         channelModeExc = impl->renderParam.frameRenderMode.mode;
381         EXPECT_EQ(AUDIO_CHANNEL_BOTH_MUTE, channelModeExc);
382 #endif
383         impl->renderParam.frameRenderMode.mode = AUDIO_CHANNEL_NORMAL;
384         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_WRITE, &impl->renderParam);
385         EXPECT_EQ(HDF_SUCCESS, ret);
386         ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_CHANNEL_MODE_READ, &impl->renderParam);
387         EXPECT_EQ(HDF_SUCCESS, ret);
388         channelModeExc = impl->renderParam.frameRenderMode.mode;
389         EXPECT_EQ(AUDIO_CHANNEL_NORMAL, channelModeExc);
390     }
391     CloseServiceRenderSo(handleRender);
392     CloseServiceRenderSo(handle);
393     free(impl);
394     impl = nullptr;
395 }
396 /**
397 * @tc.name  AudioInterfaceLibCtlRenderSelectScene_001
398 * @tc.desc  test InterfaceLibCtlRender,cmdId is AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE.
399 * @tc.type: FUNC
400 */
401 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderSelectScene_001, TestSize.Level1)
402 {
403     int32_t ret = HDF_FAILURE;
404     struct DevHandle *handle = nullptr;
405     struct AudioHwRender *hwRender = nullptr;
406     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
407     ASSERT_EQ(HDF_SUCCESS, ret);
408 
409     struct AudioSceneDescriptor scene = {
410         .scene.id = 0,
411         .desc.pins = PIN_OUT_HEADSET,
412     };
413     hwRender->renderParam.renderMode.hwInfo.pathSelect.deviceInfo.deviceNum = 1;
414     ret = strcpy_s(hwRender->renderParam.renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[0].deviceSwitch,
415         PATHPLAN_COUNT, PATH_SWITCH_ORDER.c_str());
416     hwRender->renderParam.renderMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[0].value = 0;
417     hwRender->renderParam.frameRenderMode.attrs.type = (enum AudioCategory)(scene.scene.id);
418     hwRender->renderParam.renderMode.hwInfo.deviceDescript.pins = scene.desc.pins;
419 
420     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_SCENESELECT_WRITE, &hwRender->renderParam);
421     EXPECT_EQ(HDF_SUCCESS, ret);
422 
423     CloseServiceRenderSo(handle);
424     free(hwRender);
425     hwRender = nullptr;
426 }
427 /**
428 * @tc.name  AudioInterfaceLibCtlRenderGainWriteRead_001
429 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE and AUDIODRV_CTL_IOCTL_GAIN_READ.
430 * @tc.type: FUNC
431 */
432 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderGainWriteRead_001, TestSize.Level1)
433 {
434     int32_t ret = HDF_FAILURE;
435     struct AudioHwRender *hwRender = nullptr;
436     struct DevHandle *handle = nullptr;
437     float gainValue = 0;
438     float gainThresholdValueMax, gainThresholdValueMin;
439     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
440     ASSERT_EQ(HDF_SUCCESS, ret);
441 
442     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam);
443     EXPECT_EQ(HDF_SUCCESS, ret);
444     gainThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax;
445     gainThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin;
446     ret = InitHwRenderMode(hwRender->renderParam.renderMode);
447     EXPECT_EQ(HDF_SUCCESS, ret);
448 
449     hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMax - 1;
450     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
451     EXPECT_EQ(HDF_SUCCESS, ret);
452     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
453     EXPECT_EQ(HDF_SUCCESS, ret);
454     gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain;
455     EXPECT_EQ(gainThresholdValueMax - 1, gainValue);
456     hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMin + 1;
457     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
458     EXPECT_EQ(HDF_SUCCESS, ret);
459     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
460     EXPECT_EQ(HDF_SUCCESS, ret);
461     gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain;
462     EXPECT_EQ(gainThresholdValueMin + 1, gainValue);
463     hwRender->renderParam.renderMode.ctlParam.audioGain.gain = 2.3;
464     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
465     EXPECT_EQ(HDF_SUCCESS, ret);
466     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
467     EXPECT_EQ(HDF_SUCCESS, ret);
468     gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain;
469     EXPECT_EQ(2, gainValue);
470     CloseServiceRenderSo(handle);
471     free(hwRender);
472     hwRender = nullptr;
473 }
474 /**
475 * @tc.name  AudioInterfaceLibCtlRenderGainWriteRead_002
476 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE and AUDIODRV_CTL_IOCTL_GAIN_READ.
477 * @tc.type: FUNC
478 */
479 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderGainWriteRead_002, TestSize.Level1)
480 {
481     int32_t ret = HDF_FAILURE;
482     float gainValue = 0;
483     float gainThresholdValueMax, gainThresholdValueMin;
484     struct DevHandle *handle = nullptr;
485     struct AudioHwRender *hwRender = nullptr;
486     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
487     ASSERT_EQ(HDF_SUCCESS, ret);
488 
489     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam);
490     EXPECT_EQ(HDF_SUCCESS, ret);
491     gainThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax;
492     gainThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin;
493     ret = InitHwRenderMode(hwRender->renderParam.renderMode);
494     EXPECT_EQ(HDF_SUCCESS, ret);
495     hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMin;
496     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
497     EXPECT_EQ(HDF_SUCCESS, ret);
498     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
499     EXPECT_EQ(HDF_SUCCESS, ret);
500     gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain;
501     EXPECT_EQ(gainThresholdValueMin, gainValue);
502     hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMax;
503     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
504     EXPECT_EQ(HDF_SUCCESS, ret);
505     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_READ, &hwRender->renderParam);
506     EXPECT_EQ(HDF_SUCCESS, ret);
507     gainValue = hwRender->renderParam.renderMode.ctlParam.audioGain.gain;
508     EXPECT_EQ(gainThresholdValueMax, gainValue);
509     CloseServiceRenderSo(handle);
510     free(hwRender);
511     hwRender = nullptr;
512 }
513 /**
514 * @tc.name  AudioInterfaceLibCtlRenderGainWriteRead_003
515 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE and AUDIODRV_CTL_IOCTL_GAIN_READ.
516 * @tc.type: FUNC
517 */
518 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderGainWriteRead_003, TestSize.Level1)
519 {
520     int32_t ret = HDF_FAILURE;
521     float gainThresholdValueMax, gainThresholdValueMin;
522     struct AudioHwRender *hwRender = nullptr;
523     struct DevHandle *handle = nullptr;
524     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
525     ASSERT_EQ(HDF_SUCCESS, ret);
526 
527     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam);
528     EXPECT_EQ(HDF_SUCCESS, ret);
529     gainThresholdValueMax = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax;
530     gainThresholdValueMin = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin;
531     ret = InitHwRenderMode(hwRender->renderParam.renderMode);
532     EXPECT_EQ(HDF_SUCCESS, ret);
533     hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMax + 1;
534     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
535     EXPECT_EQ(HDF_FAILURE, ret);
536     hwRender->renderParam.renderMode.ctlParam.audioGain.gain = gainThresholdValueMin - 1;
537     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE, &hwRender->renderParam);
538     EXPECT_EQ(HDF_FAILURE, ret);
539     CloseServiceRenderSo(handle);
540     free(hwRender);
541     hwRender = nullptr;
542 }
543 /**
544 * @tc.name  AudioInterfaceLibCtlRenderGetGainthresholdRead_001
545 * @tc.desc  test InterfaceLibCtlRender ,cmdId is AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ.
546 * @tc.type: FUNC
547 */
548 HWTEST_F(AudioLibRenderHardwareDependenceTest, AudioInterfaceLibCtlRenderGetGainthresholdRead_001,
549          TestSize.Level1)
550 {
551     int32_t ret = HDF_FAILURE;
552     float gainThresholdValueMaxGet, gainThresholdValueMinGet;
553     struct DevHandle *handle = nullptr;
554     struct AudioHwRender *hwRender = nullptr;
555     ret = BindServiceAndHwRender(hwRender, BIND_CONTROL.c_str(), ADAPTER_NAME, handle);
556     ASSERT_EQ(HDF_SUCCESS, ret);
557 
558     ret = InterfaceLibCtlRender(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_READ, &hwRender->renderParam);
559     EXPECT_EQ(HDF_SUCCESS, ret);
560     gainThresholdValueMaxGet = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMax;
561     gainThresholdValueMinGet = hwRender->renderParam.renderMode.ctlParam.audioGain.gainMin;
562     EXPECT_EQ(MAX_GAIN, gainThresholdValueMaxGet);
563     EXPECT_EQ(MIN_GAIN, gainThresholdValueMinGet);
564     CloseServiceRenderSo(handle);
565     free(hwRender);
566     hwRender = nullptr;
567 }
568 }
569