1 /*
2  * Copyright (c) 2022-2023 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_libcapture_test.h"
18 using namespace std;
19 using namespace testing::ext;
20 using namespace OHOS::Audio;
21 
22 namespace {
23 const string BIND_CONTROL = "control";
24 
25 class AudioAlsaLibCaptureTest : public testing::Test {
26 public:
27     static void SetUpTestCase(void);
28     static void TearDownTestCase(void);
29     void SetUp();
30     void TearDown();
31     static int32_t (*InterfaceLibOutputCapture)(struct DevHandle *, int, struct AudioHwCaptureParam *);
32     static int32_t (*InterfaceLibCtlCapture)(struct DevHandle *, int, struct AudioHwCaptureParam *);
33     static void *ptrHandle;
34     static struct DevHandle *handle;
35     static struct DevHandle *(*AudioBindService)(const char *);
36     static void (*CloseServiceCapture)(struct DevHandle *);
37     int32_t CreatHwCapture(struct AudioHwCapture *&hwCapture, const std::string adapterNameCase) const;
38     int32_t LibCaptureStart(struct AudioHwCapture *hwCapture, struct DevHandle *handleCapture) const;
39 };
40 
41 int32_t (*AudioAlsaLibCaptureTest::InterfaceLibOutputCapture)(struct DevHandle *, int,
42     struct AudioHwCaptureParam *) = nullptr;
43 int32_t (*AudioAlsaLibCaptureTest::InterfaceLibCtlCapture)(struct DevHandle *, int,
44     struct AudioHwCaptureParam *) = nullptr;
45 void *AudioAlsaLibCaptureTest::ptrHandle = nullptr;
46 struct DevHandle *AudioAlsaLibCaptureTest::handle = nullptr;
47 struct DevHandle *(*AudioAlsaLibCaptureTest::AudioBindService)(const char *) = nullptr;
48 void (*AudioAlsaLibCaptureTest::CloseServiceCapture)(struct DevHandle *) = nullptr;
SetUpTestCase(void)49 void AudioAlsaLibCaptureTest::SetUpTestCase(void)
50 {
51     char resolvedPath[] = HDF_LIBRARY_FULL_PATH("libaudio_capture_adapter");
52     ptrHandle = dlopen(resolvedPath, RTLD_LAZY);
53     ASSERT_NE(nullptr, ptrHandle);
54     InterfaceLibOutputCapture = (int32_t (*)(struct DevHandle *, int,
55                                  struct AudioHwCaptureParam *))dlsym(ptrHandle, "AudioInterfaceLibOutputCapture");
56     ASSERT_NE(nullptr, InterfaceLibOutputCapture);
57     InterfaceLibCtlCapture = (int32_t (*)(struct DevHandle *, int,
58                                           struct AudioHwCaptureParam *))dlsym(ptrHandle, "AudioInterfaceLibCtlCapture");
59     ASSERT_NE(nullptr, InterfaceLibCtlCapture);
60     AudioBindService = reinterpret_cast<struct DevHandle* (*)(const char *)>(dlsym(ptrHandle,
61         "AudioBindService"));
62     ASSERT_NE(nullptr, AudioBindService);
63     CloseServiceCapture = (void (*)(struct DevHandle *))dlsym(ptrHandle, "AudioCloseServiceCapture");
64     ASSERT_NE(nullptr, CloseServiceCapture);
65 }
66 
TearDownTestCase(void)67 void AudioAlsaLibCaptureTest::TearDownTestCase(void)
68 {
69     if (InterfaceLibCtlCapture != nullptr) {
70         InterfaceLibCtlCapture = nullptr;
71     }
72     if (InterfaceLibOutputCapture != nullptr) {
73         InterfaceLibOutputCapture = nullptr;
74     }
75     if (ptrHandle != nullptr) {
76         dlclose(ptrHandle);
77         ptrHandle = nullptr;
78     }
79 }
80 
SetUp(void)81 void AudioAlsaLibCaptureTest::SetUp(void)
82 {
83     handle = AudioBindService(BIND_CONTROL.c_str());
84     ASSERT_NE(nullptr, handle);
85 }
86 
TearDown(void)87 void AudioAlsaLibCaptureTest::TearDown(void)
88 {
89     CloseServiceCapture(handle);
90     handle = nullptr;
91 }
92 
CreatHwCapture(struct AudioHwCapture * & hwCapture,const std::string adapterNameCase) const93 int32_t AudioAlsaLibCaptureTest::CreatHwCapture(struct AudioHwCapture *&hwCapture,
94     const std::string adapterNameCase) const
95 {
96     hwCapture = static_cast<struct AudioHwCapture *>(calloc(1, sizeof(*hwCapture)));
97     if (hwCapture == nullptr) {
98         return HDF_FAILURE;
99     }
100     if (InitHwCapture(hwCapture, adapterNameCase)) {
101         free(hwCapture);
102         hwCapture = nullptr;
103         return HDF_FAILURE;
104     }
105     return HDF_SUCCESS;
106 }
LibCaptureStart(struct AudioHwCapture * hwCapture,struct DevHandle * handleCapture) const107 int32_t AudioAlsaLibCaptureTest::LibCaptureStart(struct AudioHwCapture *hwCapture,
108     struct DevHandle *handleCapture) const
109 {
110     if (hwCapture == nullptr) {
111         return HDF_FAILURE;
112     }
113 
114     if (InterfaceLibOutputCapture(handleCapture, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam) ||
115         InterfaceLibOutputCapture(handleCapture, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam) ||
116         InterfaceLibOutputCapture(handleCapture, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, &hwCapture->captureParam) ||
117         InterfaceLibOutputCapture(handleCapture, AUDIO_DRV_PCM_IOCTRL_START_CAPTURE, &hwCapture->captureParam)) {
118         return HDF_FAILURE;
119     }
120     return HDF_SUCCESS;
121 }
122 /**
123 * @tc.name  AudioInterfaceLibOutputCaptureOpen_001
124 * @tc.desc  test Audio lib Interface OutputCapture.return 0 if the Interface call successful.
125 * @tc.type: FUNC
126 */
127 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureOpen_001, TestSize.Level1)
128 {
129     int32_t ret = -1;
130     struct AudioHwCapture *hwCapture = nullptr;
131     ASSERT_NE(nullptr, handle);
132     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
133     ASSERT_EQ(HDF_SUCCESS, ret);
134     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
135     EXPECT_EQ(HDF_SUCCESS, ret);
136     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
137     EXPECT_EQ(HDF_SUCCESS, ret);
138     free(hwCapture);
139     hwCapture = nullptr;
140 }
141 /**
142 * @tc.name  AudioInterfaceLibOutputCaptureOpen_002
143 * @tc.desc  test Audio lib Interface OutputCapture.return -1 if seting cmdid is AUDIO_DRV_PCM_IOCTL_Capture_OPEN twins.
144 * @tc.type: FUNC
145 */
146 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureOpen_002, TestSize.Level1)
147 {
148     int32_t ret = -1;
149     struct AudioHwCapture *hwCapture = nullptr;
150     ASSERT_NE(nullptr, handle);
151     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
152     ASSERT_EQ(HDF_SUCCESS, ret);
153     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
154     EXPECT_EQ(HDF_SUCCESS, ret);
155     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
156     EXPECT_EQ(HDF_ERR_DEVICE_BUSY, ret);
157     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
158     EXPECT_EQ(HDF_SUCCESS, ret);
159     free(hwCapture);
160     hwCapture = nullptr;
161 }
162 /**
163 * @tc.name  AudioInterfaceLibOutputCaptureClose_001
164 * @tc.desc  test Audio lib Interface OutputCapture.return -1 if without opening.
165 * @tc.type: FUNC
166 */
167 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureClose_001, TestSize.Level1)
168 {
169     int32_t ret = -1;
170     struct AudioHwCapture *hwCapture = nullptr;
171     ASSERT_NE(nullptr, handle);
172     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
173     ASSERT_EQ(HDF_SUCCESS, ret);
174     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
175     EXPECT_EQ(HDF_FAILURE, ret);
176     free(hwCapture);
177     hwCapture = nullptr;
178 }
179 /**
180 * @tc.name  AudioInterfaceLibOutputCaptureClose_002
181 * @tc.desc  test Audio lib Interface OutputCapture.return -1 if seting cmdid is AUDIO_DRV_PCM_IOCTL_Capture_CLOSE twins.
182 * @tc.type: FUNC
183 */
184 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureClose_002, TestSize.Level1)
185 {
186     int32_t ret = -1;
187     struct AudioHwCapture *hwCapture = nullptr;
188     ASSERT_NE(nullptr, handle);
189     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
190     ASSERT_EQ(HDF_SUCCESS, ret);
191     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
192     EXPECT_EQ(HDF_SUCCESS, ret);
193 
194     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
195     EXPECT_EQ(HDF_SUCCESS, ret);
196     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
197     EXPECT_EQ(HDF_FAILURE, ret);
198     free(hwCapture);
199     hwCapture = nullptr;
200 }
201 
202 /**
203 * @tc.name  AudioInterfaceLibOutputCaptureHwParams_001
204 * @tc.desc  test Audio lib Interface OutputCapture.return 0 if the Interface call successful.
205 * @tc.type: FUNC
206 */
207 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureHwParams_001, TestSize.Level1)
208 {
209     int32_t ret = -1;
210     struct AudioHwCapture *hwCapture = nullptr;
211     ASSERT_NE(nullptr, handle);
212     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
213     ASSERT_EQ(HDF_SUCCESS, ret);
214     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
215     EXPECT_EQ(HDF_SUCCESS, ret);
216 
217     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam);
218     EXPECT_EQ(HDF_SUCCESS, ret);
219     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
220     EXPECT_EQ(HDF_SUCCESS, ret);
221     free(hwCapture);
222     hwCapture = nullptr;
223 }
224 /**
225 * @tc.name  AudioInterfaceLibOutputCaptureHwParams_002
226 * @tc.desc  test Audio lib Interface OutputCapture.return -1 if without opening.
227 * @tc.type: FUNC
228 */
229 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureHwParams_002, TestSize.Level1)
230 {
231     int32_t ret = -1;
232     struct AudioHwCapture *hwCapture = nullptr;
233     ASSERT_NE(nullptr, handle);
234     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
235     ASSERT_EQ(HDF_SUCCESS, ret);
236     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam);
237     EXPECT_EQ(HDF_FAILURE, ret);
238 
239     free(hwCapture);
240     hwCapture = nullptr;
241 }
242 /**
243 * @tc.name  AudioInterfaceLibOutputCaptureHwParams_003
244 * @tc.desc  test Audio lib Interface OutputCapture.return 0 if the Interface call successful.
245 * @tc.type: FUNC
246 */
247 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureHwParams_003, TestSize.Level1)
248 {
249     int32_t ret = -1;
250     struct AudioHwCapture *hwCapture = nullptr;
251     ASSERT_NE(nullptr, handle);
252     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
253     ASSERT_EQ(HDF_SUCCESS, ret);
254     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
255     EXPECT_EQ(HDF_SUCCESS, ret);
256 
257     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam);
258     EXPECT_EQ(HDF_SUCCESS, ret);
259     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam);
260     EXPECT_EQ(HDF_SUCCESS, ret);
261     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
262     EXPECT_EQ(HDF_SUCCESS, ret);
263     free(hwCapture);
264     hwCapture = nullptr;
265 }
266 /**
267 * @tc.name  AudioInterfaceLibOutputCapturePrepare_001
268 * @tc.desc  test Audio lib Interface OutputCapture.return 0 if the Interface call successful.
269 * @tc.type: FUNC
270 */
271 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCapturePrepare_001, TestSize.Level1)
272 {
273     int32_t ret = -1;
274     struct AudioHwCapture *hwCapture = nullptr;
275     ASSERT_NE(nullptr, handle);
276     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
277     ASSERT_EQ(HDF_SUCCESS, ret);
278 
279     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
280     EXPECT_EQ(HDF_SUCCESS, ret);
281     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam);
282     EXPECT_EQ(HDF_SUCCESS, ret);
283     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, &hwCapture->captureParam);
284     EXPECT_EQ(HDF_SUCCESS, ret);
285     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
286     EXPECT_EQ(HDF_SUCCESS, ret);
287     free(hwCapture);
288     hwCapture = nullptr;
289 }
290 /**
291 * @tc.name  AudioInterfaceLibOutputCapturePrepare_002
292 * @tc.desc  test Audio lib Interface OutputCapture.return -1 if without setting params.
293 * @tc.type: FUNC
294 */
295 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCapturePrepare_002, TestSize.Level1)
296 {
297     int32_t ret = -1;
298     struct AudioHwCapture *hwCapture = nullptr;
299     ASSERT_NE(nullptr, handle);
300     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
301     ASSERT_EQ(HDF_SUCCESS, ret);
302 
303     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
304     EXPECT_EQ(HDF_SUCCESS, ret);
305     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, &hwCapture->captureParam);
306     EXPECT_EQ(HDF_FAILURE, ret);
307     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
308     EXPECT_EQ(HDF_SUCCESS, ret);
309     free(hwCapture);
310     hwCapture = nullptr;
311 }
312 /**
313 * @tc.name  AudioInterfaceLibOutputCapturePrepare_003
314 * @tc.desc  test Audio lib Interface OutputCapture.return -1 if the Interface call twice.
315 * @tc.type: FUNC
316 */
317 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCapturePrepare_003, TestSize.Level1)
318 {
319     int32_t ret = -1;
320     struct AudioHwCapture *hwCapture = nullptr;
321     ASSERT_NE(nullptr, handle);
322     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
323     ASSERT_EQ(HDF_SUCCESS, ret);
324 
325     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
326     EXPECT_EQ(HDF_SUCCESS, ret);
327     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam);
328     EXPECT_EQ(HDF_SUCCESS, ret);
329     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, &hwCapture->captureParam);
330     EXPECT_EQ(HDF_SUCCESS, ret);
331     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, &hwCapture->captureParam);
332     EXPECT_EQ(HDF_SUCCESS, ret);
333     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
334     EXPECT_EQ(HDF_SUCCESS, ret);
335     free(hwCapture);
336     hwCapture = nullptr;
337 }
338 
339 /**
340 * @tc.name  AudioInterfaceLibOutputCaptureStart_001
341 * @tc.desc  test Audio lib Interface OutputCapture.return -1 if the Interface call unsuccessful.
342 * @tc.type: FUNC
343 */
344 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureStart_001, TestSize.Level1)
345 {
346     int32_t ret = -1;
347     struct AudioHwCapture *hwCapture = nullptr;
348     ASSERT_NE(nullptr, handle);
349     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
350     ASSERT_EQ(HDF_SUCCESS, ret);
351 
352     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_START_CAPTURE, &hwCapture->captureParam);
353     EXPECT_EQ(HDF_SUCCESS, ret);
354 
355     free(hwCapture);
356     hwCapture = nullptr;
357 }
358 /**
359 * @tc.name  AudioInterfaceLibOutputCaptureStop_001
360 * @tc.desc  test Audio lib Interface OutputCapture.return 0 if the Interface call successful.
361 * @tc.type: FUNC
362 */
363 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureStop_001, TestSize.Level1)
364 {
365     int32_t ret = -1;
366     struct AudioHwCapture *hwCapture = nullptr;
367     ASSERT_NE(nullptr, handle);
368     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
369     ASSERT_EQ(HDF_SUCCESS, ret);
370 
371     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
372     EXPECT_EQ(HDF_SUCCESS, ret);
373     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam);
374     EXPECT_EQ(HDF_SUCCESS, ret);
375     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, &hwCapture->captureParam);
376     EXPECT_EQ(HDF_SUCCESS, ret);
377     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_START_CAPTURE, &hwCapture->captureParam);
378     EXPECT_EQ(HDF_SUCCESS, ret);
379     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, &hwCapture->captureParam);
380     EXPECT_EQ(HDF_SUCCESS, ret);
381     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
382     EXPECT_EQ(HDF_SUCCESS, ret);
383 
384     free(hwCapture);
385     hwCapture = nullptr;
386 }
387 /**
388 * @tc.name  AudioInterfaceLibOutputCaptureStop_002
389 * @tc.desc  test Audio lib Interface OutputCapture.return -1 if the Interface call unsuccessful.
390 * @tc.type: FUNC
391 */
392 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureStop_002, TestSize.Level1)
393 {
394     int32_t ret = -1;
395     struct AudioHwCapture *hwCapture = nullptr;
396     ASSERT_NE(nullptr, handle);
397     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
398     ASSERT_EQ(HDF_SUCCESS, ret);
399 
400     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, &hwCapture->captureParam);
401     EXPECT_EQ(HDF_FAILURE, ret);
402 
403     free(hwCapture);
404     hwCapture = nullptr;
405 }
406 /**
407 * @tc.name  AudioInterfaceLibOutputCaptureStop_003
408 * @tc.desc  test Audio lib Interface OutputCapture.return -1 if the Interface call twice.
409 * @tc.type: FUNC
410 */
411 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureStop_003, TestSize.Level1)
412 {
413     int32_t ret = -1;
414     struct AudioHwCapture *hwCapture = nullptr;
415     ASSERT_NE(nullptr, handle);
416     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
417     ASSERT_EQ(HDF_SUCCESS, ret);
418 
419     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
420     EXPECT_EQ(HDF_SUCCESS, ret);
421     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, &hwCapture->captureParam);
422     EXPECT_EQ(HDF_SUCCESS, ret);
423     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, &hwCapture->captureParam);
424     EXPECT_EQ(HDF_SUCCESS, ret);
425     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_START_CAPTURE, &hwCapture->captureParam);
426     EXPECT_EQ(HDF_SUCCESS, ret);
427     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, &hwCapture->captureParam);
428     EXPECT_EQ(HDF_SUCCESS, ret);
429     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, &hwCapture->captureParam);
430     EXPECT_EQ(HDF_SUCCESS, ret);
431 
432     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
433     EXPECT_EQ(HDF_SUCCESS, ret);
434 
435     free(hwCapture);
436     hwCapture = nullptr;
437 }
438 
439 /**
440 * @tc.name  AudioInterfaceLibOutputCaptureRead_001
441 * @tc.desc  test Audio lib Interface OutputCapture and Normal data flow distribution.
442 * @tc.type: FUNC
443 */
444 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureRead_001, TestSize.Level1)
445 {
446     int32_t ret = -1;
447     struct AudioHwCapture *hwCapture = nullptr;
448     ASSERT_NE(nullptr, handle);
449     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
450     ASSERT_EQ(HDF_SUCCESS, ret);
451 
452     ret = LibCaptureStart(hwCapture, handle);
453     EXPECT_EQ(HDF_SUCCESS, ret);
454     hwCapture->captureParam.frameCaptureMode.buffer = (char *)calloc(1, BUFFER_LENTH);
455     if (hwCapture->captureParam.frameCaptureMode.buffer == nullptr) {
456         free(hwCapture);
457         hwCapture = nullptr;
458         ASSERT_NE(nullptr, hwCapture);
459     }
460     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_READ, &hwCapture->captureParam);
461     EXPECT_EQ(HDF_SUCCESS, ret);
462     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, &hwCapture->captureParam);
463     EXPECT_EQ(HDF_SUCCESS, ret);
464     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
465     EXPECT_EQ(HDF_SUCCESS, ret);
466     free(hwCapture->captureParam.frameCaptureMode.buffer);
467     hwCapture->captureParam.frameCaptureMode.buffer = nullptr;
468     free(hwCapture);
469     hwCapture = nullptr;
470 }
471 /**
472 * @tc.name  AudioInterfaceLibOutputCaptureRead_002
473 * @tc.desc  test Audio lib Interface OutputCapture,return -1 if without starting.
474 * @tc.type: FUNC
475 */
476 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureRead_002, TestSize.Level1)
477 {
478     int32_t ret = -1;
479     struct AudioHwCapture *hwCapture = nullptr;
480     ASSERT_NE(nullptr, handle);
481     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
482     ASSERT_EQ(HDF_SUCCESS, ret);
483     hwCapture->captureParam.frameCaptureMode.buffer = (char *)calloc(1, BUFFER_LENTH);
484     if (hwCapture->captureParam.frameCaptureMode.buffer == nullptr) {
485         free(hwCapture);
486         hwCapture = nullptr;
487         ASSERT_NE(nullptr, hwCapture);
488     }
489     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_READ, &hwCapture->captureParam);
490     EXPECT_EQ(HDF_FAILURE, ret);
491     free(hwCapture->captureParam.frameCaptureMode.buffer);
492     hwCapture->captureParam.frameCaptureMode.buffer = nullptr;
493     free(hwCapture);
494     hwCapture = nullptr;
495 }
496 
497 /**
498 * @tc.name  AudioInterfaceLibOutputCaptureAbnormal_001
499 * @tc.desc  test OutputCapture interface, return -1 if the cmdId is invalid.
500 * @tc.type: FUNC
501 */
502 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureAbnormal_001, TestSize.Level1)
503 {
504     int32_t ret = -1;
505     struct AudioHwCapture *hwCapture = nullptr;
506     ASSERT_NE(nullptr, handle);
507     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
508     ASSERT_EQ(HDF_SUCCESS, ret);
509 
510     ret = InterfaceLibOutputCapture(handle, 30, &hwCapture->captureParam);
511     EXPECT_EQ(HDF_FAILURE, ret);
512     free(hwCapture);
513     hwCapture = nullptr;
514 }
515 /**
516 * @tc.name  AudioInterfaceLibOutputCaptureAbnormal_002
517 * @tc.desc   Test Outputcapture interface, return -1 if the incoming parameter handleData is empty.
518 * @tc.type: FUNC
519 */
520 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureAbnormal_002, TestSize.Level1)
521 {
522     int32_t ret = -1;
523     ASSERT_NE(nullptr, handle);
524     struct AudioHwCaptureParam *handleData = nullptr;
525     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_READ, handleData);
526     EXPECT_EQ(HDF_FAILURE, ret);
527 }
528 /**
529 * @tc.name  AudioInterfaceLibCtlCaptureGetVolthresholdRead_001
530 * @tc.desc  test InterfaceLibCtlCapture ,cmdId is AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_READ.
531 * @tc.type: FUNC
532 */
533 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibCtlCaptureGetVolthresholdRead_001, TestSize.Level1)
534 {
535     int32_t ret = -1;
536     float volumeThresholdValueMax = 0;
537     float volumeThresholdValueMin = 0;
538     float expMax = 100;
539     float expMin = 0;
540     struct AudioHwCapture *hwCapture = nullptr;
541     ASSERT_NE(nullptr, handle);
542     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
543     ASSERT_EQ(HDF_SUCCESS, ret);
544     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
545     EXPECT_EQ(HDF_SUCCESS, ret);
546 
547     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE, &hwCapture->captureParam);
548     EXPECT_EQ(HDF_SUCCESS, ret);
549     volumeThresholdValueMax = hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMax;
550     volumeThresholdValueMin = hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMin;
551     EXPECT_EQ(expMax, volumeThresholdValueMax);
552     EXPECT_EQ(expMin, volumeThresholdValueMin);
553     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
554     EXPECT_EQ(HDF_SUCCESS, ret);
555 
556     free(hwCapture);
557     hwCapture = nullptr;
558 }
559 /**
560 * @tc.name  AudioInterfaceLibCtlCaptureVolumeWriteRead_001
561 * @tc.desc  test InterfaceLibCtlCapture ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
562 * @tc.type: FUNC
563 */
564 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibCtlCaptureVolumeWriteRead_001, TestSize.Level1)
565 {
566     int32_t ret = -1;
567     float volumeValue = 0;
568     float volumeThresholdValueMax = 0;
569     float volumeThresholdValueMin = 0;
570     float volumeBoundaryValue = 99.9;
571     float expectVolumeValue = 99;
572     ASSERT_NE(nullptr, handle);
573     struct AudioHwCapture *hwCapture = nullptr;
574     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
575     ASSERT_EQ(HDF_SUCCESS, ret);
576     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
577     EXPECT_EQ(HDF_SUCCESS, ret);
578 
579 
580     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE, &hwCapture->captureParam);
581     EXPECT_EQ(HDF_SUCCESS, ret);
582     volumeThresholdValueMax = hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMax;
583     volumeThresholdValueMin = hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMin;
584 
585     hwCapture->captureParam.captureMode.ctlParam.volume = volumeThresholdValueMax - 1;
586     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, &hwCapture->captureParam);
587     EXPECT_EQ(HDF_SUCCESS, ret);
588     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE, &hwCapture->captureParam);
589     EXPECT_EQ(HDF_SUCCESS, ret);
590     volumeValue = hwCapture->captureParam.captureMode.ctlParam.volume;
591     EXPECT_EQ(volumeThresholdValueMax - 1, volumeValue);
592 
593     hwCapture->captureParam.captureMode.ctlParam.volume = volumeThresholdValueMin + 1;
594     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, &hwCapture->captureParam);
595     EXPECT_EQ(HDF_SUCCESS, ret);
596     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE, &hwCapture->captureParam);
597     EXPECT_EQ(HDF_SUCCESS, ret);
598     volumeValue = hwCapture->captureParam.captureMode.ctlParam.volume;
599     EXPECT_EQ(volumeThresholdValueMin + 1, volumeValue);
600     hwCapture->captureParam.captureMode.ctlParam.volume = volumeBoundaryValue;
601     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, &hwCapture->captureParam);
602     EXPECT_EQ(HDF_SUCCESS, ret);
603     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE, &hwCapture->captureParam);
604     EXPECT_EQ(HDF_SUCCESS, ret);
605     volumeValue = hwCapture->captureParam.captureMode.ctlParam.volume;
606     EXPECT_EQ(expectVolumeValue, volumeValue);
607     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
608     EXPECT_EQ(HDF_SUCCESS, ret);
609 
610     free(hwCapture);
611     hwCapture = nullptr;
612 }
613 /**
614 * @tc.name  AudioInterfaceLibCtlCaptureVolumeWriteRead_002
615 * @tc.desc  test InterfaceLibCtlCapture ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
616 * @tc.type: FUNC
617 */
618 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibCtlCaptureVolumeWriteRead_002, TestSize.Level1)
619 {
620     int32_t ret = -1;
621     struct AudioHwCapture *hwCapture = nullptr;
622     float volumeThresholdValueMax = 0;
623     float volumeThresholdValueMin = 0;
624     float volumeValue = 0;
625 
626     ASSERT_NE(nullptr, handle);
627     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
628     ASSERT_EQ(HDF_SUCCESS, ret);
629     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
630     EXPECT_EQ(HDF_SUCCESS, ret);
631 
632     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE, &hwCapture->captureParam);
633     EXPECT_EQ(HDF_SUCCESS, ret);
634     volumeThresholdValueMax = hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMax;
635     volumeThresholdValueMin = hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMin;
636 
637     hwCapture->captureParam.captureMode.ctlParam.volume = volumeThresholdValueMin;
638     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, &hwCapture->captureParam);
639     EXPECT_EQ(HDF_SUCCESS, ret);
640     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE, &hwCapture->captureParam);
641     EXPECT_EQ(HDF_SUCCESS, ret);
642     volumeValue = hwCapture->captureParam.captureMode.ctlParam.volume;
643     EXPECT_EQ(volumeThresholdValueMin, volumeValue);
644 
645     hwCapture->captureParam.captureMode.ctlParam.volume = volumeThresholdValueMax;
646     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, &hwCapture->captureParam);
647     EXPECT_EQ(HDF_SUCCESS, ret);
648     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE, &hwCapture->captureParam);
649     EXPECT_EQ(HDF_SUCCESS, ret);
650     volumeValue = hwCapture->captureParam.captureMode.ctlParam.volume;
651     EXPECT_EQ(volumeThresholdValueMax, volumeValue);
652     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
653     EXPECT_EQ(HDF_SUCCESS, ret);
654 
655     free(hwCapture);
656     hwCapture = nullptr;
657 }
658 /**
659 * @tc.name  AudioInterfaceLibCtlCaptureVolume_AcodecIn_Write_Read_003
660 * @tc.desc  test InterfaceLibCtlCapture ,cmdId is AUDIODRV_CTL_IOCTL_ELEM_WRITE and AUDIODRV_CTL_IOCTL_ELEM_READ.
661 * @tc.type: FUNC
662 */
663 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibCtlCaptureVolumeWriteRead_003, TestSize.Level1)
664 {
665     int32_t ret = -1;
666     struct AudioHwCapture *hwCapture = nullptr;
667     float volumeThresholdValueMax = 0;
668     float volumeThresholdValueMin = 0;
669     float volumeValue = 0;
670 
671     ASSERT_NE(nullptr, handle);
672     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
673     ASSERT_EQ(HDF_SUCCESS, ret);
674     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
675     EXPECT_EQ(HDF_SUCCESS, ret);
676 
677     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE, &hwCapture->captureParam);
678     EXPECT_EQ(HDF_SUCCESS, ret);
679     volumeThresholdValueMax = hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMax;
680     volumeThresholdValueMin = hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMin;
681 
682     hwCapture->captureParam.captureMode.ctlParam.volume = volumeThresholdValueMax + 1;
683     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, &hwCapture->captureParam);
684     EXPECT_EQ(HDF_SUCCESS, ret);
685 
686     hwCapture->captureParam.captureMode.ctlParam.volume = volumeThresholdValueMin - 1;
687     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, &hwCapture->captureParam);
688     EXPECT_EQ(HDF_SUCCESS, ret);
689 
690     volumeValue = hwCapture->captureParam.captureMode.ctlParam.volume;
691     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
692     EXPECT_EQ(HDF_SUCCESS, ret);
693 
694     free(hwCapture);
695     hwCapture = nullptr;
696 }
697 /**
698 * @tc.name  AudioInterfaceLibCtlCaptureMuteWriteRead_001
699 * @tc.desc  test InterfaceLibCtlCapture ,cmdId is AUDIODRV_CTL_IOCTL_MUTE_WRITE and AUDIODRV_CTL_IOCTL_MUTE_READ.
700 * @tc.type: FUNC
701 */
702 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibCtlCaptureMuteWriteRead_001, TestSize.Level1)
703 {
704     int32_t ret = -1;
705     bool muteValue = 1;
706     bool wishValue = 0;
707     bool expectedValue = 1;
708 
709     ASSERT_NE(nullptr, handle);
710     struct AudioHwCapture *hwCapture = nullptr;
711     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
712     ASSERT_EQ(HDF_SUCCESS, ret);
713     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, &hwCapture->captureParam);
714     EXPECT_EQ(HDF_SUCCESS, ret);
715 
716     hwCapture->captureParam.captureMode.ctlParam.mute = 1;
717     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE, &hwCapture->captureParam);
718     EXPECT_EQ(HDF_SUCCESS, ret);
719     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE, &hwCapture->captureParam);
720     EXPECT_EQ(HDF_SUCCESS, ret);
721     muteValue = hwCapture->captureParam.captureMode.ctlParam.mute;
722     EXPECT_EQ(expectedValue, muteValue);
723 
724     hwCapture->captureParam.captureMode.ctlParam.mute = 0;
725     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_MUTE_WRITE_CAPTURE, &hwCapture->captureParam);
726     EXPECT_EQ(HDF_SUCCESS, ret);
727     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE, &hwCapture->captureParam);
728     EXPECT_EQ(HDF_SUCCESS, ret);
729     muteValue = hwCapture->captureParam.captureMode.ctlParam.mute;
730     EXPECT_EQ(wishValue, muteValue);
731     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
732     EXPECT_EQ(HDF_SUCCESS, ret);
733 
734     free(hwCapture);
735     hwCapture = nullptr;
736 }
737 /**
738 * @tc.name  AudioInterfaceLibOutputCapturePause_001
739 * @tc.desc  test InterfaceLibOutputCapture,cmdId is AUDIODRV_CTL_IOCTL_PAUSE_WRITE.
740 * @tc.type: FUNC
741 */
742 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCapturePause_001, TestSize.Level1)
743 {
744     int32_t ret = -1;
745     ASSERT_NE(nullptr, handle);
746     struct AudioHwCapture *hwCapture = nullptr;
747     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
748     ASSERT_EQ(HDF_SUCCESS, ret);
749     ret = LibCaptureStart(hwCapture, handle);
750     EXPECT_EQ(HDF_SUCCESS, ret);
751 
752     hwCapture->captureParam.captureMode.ctlParam.pause = 1;
753     ret = InterfaceLibOutputCapture(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE, &hwCapture->captureParam);
754     EXPECT_EQ(HDF_SUCCESS, ret);
755     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, &hwCapture->captureParam);
756     EXPECT_EQ(HDF_SUCCESS, ret);
757     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
758     EXPECT_EQ(HDF_SUCCESS, ret);
759 
760     free(hwCapture);
761     hwCapture = nullptr;
762 }
763 /**
764 * @tc.name  AudioInterfaceLibOutputCaptureResume_001
765 * @tc.desc  test InterfaceLibOutputCapture,cmdId is AUDIODRV_CTL_IOCTL_PAUSE_WRITE.
766 * @tc.type: FUNC
767 */
768 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibOutputCaptureResume_001, TestSize.Level1)
769 {
770     int32_t ret = -1;
771     ASSERT_NE(nullptr, handle);
772     struct AudioHwCapture *hwCapture = nullptr;
773     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
774     ASSERT_EQ(HDF_SUCCESS, ret);
775     ret = LibCaptureStart(hwCapture, handle);
776     EXPECT_EQ(HDF_SUCCESS, ret);
777 
778     hwCapture->captureParam.captureMode.ctlParam.pause = 0;
779     ret = InterfaceLibOutputCapture(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE, &hwCapture->captureParam);
780     EXPECT_EQ(HDF_SUCCESS, ret);
781     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, &hwCapture->captureParam);
782     EXPECT_EQ(HDF_SUCCESS, ret);
783     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
784     EXPECT_EQ(HDF_SUCCESS, ret);
785     free(hwCapture);
786     hwCapture = nullptr;
787 }
788 /**
789 * @tc.name  AudioInterfaceLibCtlCaptureGetGainthresholdRead_001
790 * @tc.desc  test InterfaceLibCtlCapture ,cmdId is AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE(23).
791 * @tc.type: FUNC
792 */
793 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibCtlCaptureGetGainthresholdRead_001, TestSize.Level1)
794 {
795     int32_t ret = -1;
796     ASSERT_NE(nullptr, handle);
797     struct AudioHwCapture *hwCapture = nullptr;
798     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
799     ASSERT_EQ(HDF_SUCCESS, ret);
800 
801     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAINTHRESHOLD_CAPTURE, &hwCapture->captureParam);
802     EXPECT_EQ(HDF_SUCCESS, ret);
803     free(hwCapture);
804     hwCapture = nullptr;
805 }
806 /**
807 * @tc.name  AudioInterfaceLibCtlCaptureGainWriteRead_001
808 * @tc.desc  test InterfaceLibCtlCapture,cmdId is AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE and
809 *    AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE.
810 * @tc.type: FUNC
811 */
812 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibCtlCaptureGainWriteRead_001, TestSize.Level1)
813 {
814     int32_t ret = -1;
815     ASSERT_NE(nullptr, handle);
816     struct AudioHwCapture *hwCapture = nullptr;
817     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
818     ASSERT_EQ(HDF_SUCCESS, ret);
819 
820     hwCapture->captureParam.captureMode.ctlParam.audioGain.gain = 1;
821     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE, &hwCapture->captureParam);
822     EXPECT_EQ(HDF_SUCCESS, ret);
823     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE, &hwCapture->captureParam);
824     EXPECT_EQ(HDF_SUCCESS, ret);
825     free(hwCapture);
826     hwCapture = nullptr;
827 }
828 /**
829 * @tc.name  AudioInterfaceLibCtlCaptureSelectScene_001
830 * @tc.desc  test InterfaceLibCtlCapture,cmdId is AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE.
831 * @tc.type: FUNC
832 */
833 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibCtlCaptureSelectScene_001, TestSize.Level1)
834 {
835     int32_t ret = -1;
836     ASSERT_NE(nullptr, handle);
837     struct AudioHwCapture *hwCapture = nullptr;
838     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
839     ASSERT_EQ(HDF_SUCCESS, ret);
840 
841     struct AudioSceneDescriptor scene = {
842         .scene.id = 0,
843         .desc.pins = PIN_IN_HS_MIC,
844     };
845     hwCapture->captureParam.captureMode.hwInfo.pathSelect.deviceInfo.deviceNum = 1;
846     ret = strcpy_s(hwCapture->captureParam.captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[0].deviceSwitch,
847         PATHPLAN_COUNT, "LPGA MIC Switch");
848     hwCapture->captureParam.captureMode.hwInfo.pathSelect.deviceInfo.deviceSwitchs[0].value = 0;
849     hwCapture->captureParam.frameCaptureMode.attrs.type = (enum AudioCategory)(scene.scene.id);
850     hwCapture->captureParam.captureMode.hwInfo.deviceDescript.pins = scene.desc.pins;
851 
852     ret = InterfaceLibCtlCapture(handle, AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE, &hwCapture->captureParam);
853     EXPECT_EQ(HDF_SUCCESS, ret);
854 
855     free(hwCapture);
856     hwCapture = nullptr;
857 }
858 
859 /**
860 * @tc.name  AudioInterfaceLibCtlCaptureReqMmpbuffer_001
861 * @tc.desc  test InterfaceLibCtlCapture ,return 0 if the Interface call successful.
862 * @tc.type: FUNC
863 */
864 HWTEST_F(AudioAlsaLibCaptureTest, AudioInterfaceLibCtlCaptureReqMmpbuffer_001, TestSize.Level1)
865 {
866     int32_t ret = -1;
867 
868     ASSERT_NE(nullptr, handle);
869     struct AudioHwCapture *hwCapture = nullptr;
870     ret = CreatHwCapture(hwCapture, ADAPTER_NAME);
871     ASSERT_EQ(HDF_SUCCESS, ret);
872     ret = LibCaptureStart(hwCapture, handle);
873     EXPECT_EQ(HDF_SUCCESS, ret);
874     ret = CaptureReqMmapBufferInit(hwCapture->captureParam.frameCaptureMode,
875                                    AUDIO_LOW_LATENCY_CAPTURE_FILE, FILE_CAPTURE_SIZE);
876     EXPECT_EQ(HDF_SUCCESS, ret);
877     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE, &hwCapture->captureParam);
878     EXPECT_EQ(HDF_SUCCESS, ret);
879     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, &hwCapture->captureParam);
880     EXPECT_EQ(HDF_SUCCESS, ret);
881     ret = InterfaceLibOutputCapture(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, &hwCapture->captureParam);
882     EXPECT_EQ(HDF_SUCCESS, ret);
883     munmap(hwCapture->captureParam.frameCaptureMode.mmapBufDesc.memoryAddress, FILE_CAPTURE_SIZE);
884     free(hwCapture);
885     hwCapture = nullptr;
886 }
887 }
888