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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include "alsa_lib_capture.h"
19 
20 using namespace std;
21 using namespace testing::ext;
22 namespace {
23 constexpr int32_t capChannel = 2;
24 constexpr int32_t capSampleRate = 48000;
25 constexpr int32_t capVolMin = 0;
26 constexpr int32_t capVolMax = 100;
27 constexpr int32_t capFrameData = 16 * 1024;
28 constexpr int32_t capMmapFrameData = 256 * 1024;
29 const string BIND_CAPTURE = "capture";
30 
31 class AudioAlsaIfLibCaptureTest : public testing::Test {
32 public:
33     static struct DevHandle *handle;
34     static void SetUpTestCase();
35     static void TearDownTestCase();
36     void SetUp();
37     void TearDown();
38     int32_t AudioInterfaceCaptureInit(struct AudioHwCaptureParam *&handleData);
39     int32_t AudioCapInitHwParams(struct AudioHwCaptureParam *&handleData);
40     int32_t AudioCapResourceRelease(struct AudioHwCaptureParam *&handleData);
41 };
42 
43 struct DevHandle *AudioAlsaIfLibCaptureTest::handle = nullptr;
44 
SetUpTestCase()45 void AudioAlsaIfLibCaptureTest::SetUpTestCase()
46 {
47 }
48 
TearDownTestCase()49 void AudioAlsaIfLibCaptureTest::TearDownTestCase()
50 {
51 }
52 
SetUp()53 void AudioAlsaIfLibCaptureTest::SetUp()
54 {
55     handle = AudioBindService(BIND_CAPTURE.c_str());
56 }
57 
TearDown()58 void AudioAlsaIfLibCaptureTest::TearDown()
59 {
60     AudioCloseService(handle);
61 }
62 
AudioInterfaceCaptureInit(struct AudioHwCaptureParam * & handleData)63 int32_t AudioAlsaIfLibCaptureTest::AudioInterfaceCaptureInit(struct AudioHwCaptureParam *&handleData)
64 {
65     int32_t ret;
66     if (handleData == nullptr) {
67         return HDF_FAILURE;
68     }
69     ret = AudioOutputCaptureOpen(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, handleData);
70     if (ret != HDF_SUCCESS) {
71         return HDF_FAILURE;
72     }
73     ret = AudioOutputCaptureHwParams(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, handleData);
74     if (ret != HDF_SUCCESS) {
75         return HDF_FAILURE;
76     }
77     ret = AudioOutputCapturePrepare(handle, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, handleData);
78     if (ret != HDF_SUCCESS) {
79         return HDF_FAILURE;
80     }
81     return HDF_SUCCESS;
82 }
83 
AudioCapInitHwParams(struct AudioHwCaptureParam * & handleData)84 int32_t AudioAlsaIfLibCaptureTest::AudioCapInitHwParams(struct AudioHwCaptureParam *&handleData)
85 {
86     if (handleData == nullptr) {
87         return HDF_FAILURE;
88     }
89     (void)memcpy_s(handleData->captureMode.hwInfo.adapterName, NAME_LEN, "primary", strlen("primary"));
90     handleData->frameCaptureMode.attrs.channelCount = capChannel;
91     handleData->frameCaptureMode.attrs.sampleRate = capSampleRate;
92     handleData->frameCaptureMode.attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
93     handleData->frameCaptureMode.attrs.isBigEndian = false;
94     handleData->frameCaptureMode.attrs.isSignedData = true;
95     return HDF_SUCCESS;
96 }
97 
AudioCapResourceRelease(struct AudioHwCaptureParam * & handleData)98 int32_t AudioAlsaIfLibCaptureTest::AudioCapResourceRelease(struct AudioHwCaptureParam *&handleData)
99 {
100     if (handleData == nullptr) {
101         return HDF_FAILURE;
102     }
103 
104     int32_t ret = AudioOutputCaptureClose(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_CLOSE, handleData);
105     EXPECT_EQ(HDF_SUCCESS, ret);
106     delete(handleData);
107     handleData = nullptr;
108     return HDF_SUCCESS;
109 }
110 
111 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioOutputCaptureOpen_001, TestSize.Level1)
112 {
113     struct AudioHwCaptureParam *handleData = nullptr;
114     int32_t ret = AudioOutputCaptureOpen(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, handleData);
115     EXPECT_EQ(HDF_FAILURE, ret);
116 }
117 
118 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioOutputCaptureOpen_002, TestSize.Level1)
119 {
120     struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
121     memset_s(handleData, sizeof(AudioHwCaptureParam), 0, sizeof(AudioHwCaptureParam));
122     (void)memcpy_s(handleData->captureMode.hwInfo.adapterName, NAME_LEN, "primary", strlen("primary"));
123     int32_t ret = AudioOutputCaptureOpen(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, handleData);
124     EXPECT_EQ(HDF_SUCCESS, ret);
125     ret = AudioCapResourceRelease(handleData);
126     EXPECT_EQ(HDF_SUCCESS, ret);
127 }
128 
129 HWTEST_F(AudioAlsaIfLibCaptureTest, SetHwParams_001, TestSize.Level1)
130 {
131     struct AudioHwCaptureParam *handleData = nullptr;
132     int32_t ret = AudioOutputCaptureHwParams(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, handleData);
133     EXPECT_EQ(HDF_FAILURE, ret);
134 }
135 
136 HWTEST_F(AudioAlsaIfLibCaptureTest, SetHwParams_002, TestSize.Level1)
137 {
138     int32_t ret;
139     struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
140     memset_s(handleData, sizeof(AudioHwCaptureParam), 0, sizeof(AudioHwCaptureParam));
141     ret = AudioCapInitHwParams(handleData);
142     EXPECT_EQ(HDF_SUCCESS, ret);
143     ret = AudioOutputCaptureOpen(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, handleData);
144     EXPECT_EQ(HDF_SUCCESS, ret);
145     ret = AudioOutputCaptureHwParams(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, handleData);
146     EXPECT_EQ(HDF_SUCCESS, ret);
147     ret = AudioCapResourceRelease(handleData);
148     EXPECT_EQ(HDF_SUCCESS, ret);
149 }
150 
151 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioOutputCapturePrepare_001, TestSize.Level1)
152 {
153     struct AudioHwCaptureParam *handleData = nullptr;
154     int32_t ret = AudioOutputCapturePrepare(handle, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, handleData);
155     EXPECT_EQ(HDF_FAILURE, ret);
156 }
157 
158 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioOutputCapturePrepare_002, TestSize.Level1)
159 {
160     int32_t ret;
161     struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
162     memset_s(handleData, sizeof(AudioHwCaptureParam), 0, sizeof(AudioHwCaptureParam));
163     ret = AudioCapInitHwParams(handleData);
164     EXPECT_EQ(HDF_SUCCESS, ret);
165     ret = AudioOutputCaptureOpen(handle, AUDIO_DRV_PCM_IOCTRL_CAPTURE_OPEN, handleData);
166     EXPECT_EQ(HDF_SUCCESS, ret);
167     ret = AudioOutputCaptureHwParams(handle, AUDIO_DRV_PCM_IOCTL_HW_PARAMS, handleData);
168     EXPECT_EQ(HDF_SUCCESS, ret);
169     ret = AudioOutputCapturePrepare(handle, AUDIO_DRV_PCM_IOCTL_PREPARE_CAPTURE, handleData);
170     EXPECT_EQ(HDF_SUCCESS, ret);
171     ret = AudioCapResourceRelease(handleData);
172     EXPECT_EQ(HDF_SUCCESS, ret);
173 }
174 
175 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureGetVolThresholds_001, TestSize.Level1)
176 {
177     struct AudioHwCaptureParam *handleData = nullptr;
178     int32_t ret = AudioCtlCaptureGetVolThreshold(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE, handleData);
179     EXPECT_EQ(HDF_FAILURE, ret);
180 }
181 
182 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureGetVolThresholds_002, TestSize.Level1)
183 {
184     int32_t ret;
185     struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
186     memset_s(handleData, sizeof(AudioHwCaptureParam), 0, sizeof(AudioHwCaptureParam));
187     ret = AudioCapInitHwParams(handleData);
188     EXPECT_EQ(HDF_SUCCESS, ret);
189     ret = AudioInterfaceCaptureInit(handleData);
190     EXPECT_EQ(HDF_SUCCESS, ret);
191     ret = AudioCtlCaptureGetVolThreshold(handle, AUDIODRV_CTL_IOCTL_VOL_THRESHOLD_CAPTURE, handleData);
192     EXPECT_EQ(HDF_SUCCESS, ret);
193     int32_t volumeMin = handleData->captureMode.ctlParam.volThreshold.volMin;
194     int32_t volumeMax = handleData->captureMode.ctlParam.volThreshold.volMax;
195     EXPECT_EQ(capVolMin, volumeMin);
196     EXPECT_EQ(capVolMax, volumeMax);
197     ret = AudioCapResourceRelease(handleData);
198     EXPECT_EQ(HDF_SUCCESS, ret);
199 }
200 
201 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlRenderGetVolume_001, TestSize.Level1)
202 {
203     struct AudioHwCaptureParam *handleData = nullptr;
204     int32_t ret = AudioCtlCaptureGetVolume(handle, AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE, handleData);
205     EXPECT_EQ(HDF_FAILURE, ret);
206 }
207 
208 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlRenderGetVolume_002, TestSize.Level1)
209 {
210     int32_t ret;
211     struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
212     memset_s(handleData, sizeof(AudioHwCaptureParam), 0, sizeof(AudioHwCaptureParam));
213     ret = AudioCapInitHwParams(handleData);
214     EXPECT_EQ(HDF_SUCCESS, ret);
215     ret = AudioInterfaceCaptureInit(handleData);
216     EXPECT_EQ(HDF_SUCCESS, ret);
217     ret = AudioCtlCaptureGetVolume(handle, AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE, handleData);
218     EXPECT_EQ(HDF_SUCCESS, ret);
219     int32_t vol = (int32_t)handleData->captureMode.ctlParam.volume;
220     EXPECT_GE(vol, capVolMin);
221     EXPECT_LE(vol, capVolMax);
222     ret = AudioCapResourceRelease(handleData);
223     EXPECT_EQ(HDF_SUCCESS, ret);
224 }
225 
226 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureSetVolume_001, TestSize.Level1)
227 {
228     struct AudioHwCaptureParam *handleData = nullptr;
229     int32_t ret = AudioCtlCaptureSetVolume(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, handleData);
230     EXPECT_EQ(HDF_FAILURE, ret);
231 }
232 
233 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureSetVolume_002, TestSize.Level1)
234 {
235     int32_t ret;
236     float setVol;
237     struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
238     memset_s(handleData, sizeof(AudioHwCaptureParam), 0, sizeof(AudioHwCaptureParam));
239     setVol = 60.0;
240     handleData->captureMode.ctlParam.volume = setVol;
241     ret = AudioCapInitHwParams(handleData);
242     EXPECT_EQ(HDF_SUCCESS, ret);
243     ret = AudioInterfaceCaptureInit(handleData);
244     EXPECT_EQ(HDF_SUCCESS, ret);
245     ret = AudioCtlCaptureSetVolume(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, handleData);
246     EXPECT_EQ(HDF_SUCCESS, ret);
247     ret = AudioCtlCaptureGetVolume(handle, AUDIODRV_CTL_IOCTL_ELEM_READ_CAPTURE, handleData);
248     EXPECT_EQ(HDF_SUCCESS, ret);
249     float getVol = handleData->captureMode.ctlParam.volume;
250     EXPECT_EQ(setVol, getVol);
251     ret = AudioCapResourceRelease(handleData);
252     EXPECT_EQ(HDF_SUCCESS, ret);
253 }
254 
255 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureGetMuteStu_001, TestSize.Level1)
256 {
257     struct AudioHwCaptureParam *handleData = nullptr;
258     int32_t ret = AudioCtlCaptureGetMuteStu(handle, AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE, handleData);
259     EXPECT_EQ(HDF_FAILURE, ret);
260 }
261 
262 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureGetMuteStu_002, TestSize.Level1)
263 {
264     int32_t ret;
265     bool mute = true;
266     struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
267     memset_s(handleData, sizeof(AudioHwCaptureParam), 0, sizeof(AudioHwCaptureParam));
268     ret = AudioCapInitHwParams(handleData);
269     EXPECT_EQ(HDF_SUCCESS, ret);
270     ret = AudioInterfaceCaptureInit(handleData);
271     EXPECT_EQ(HDF_SUCCESS, ret);
272     ret = AudioCtlCaptureGetMuteStu(handle, AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE, handleData);
273     EXPECT_EQ(HDF_SUCCESS, ret);
274     mute = handleData->captureMode.ctlParam.mute;
275     EXPECT_EQ(false, mute);
276     ret = AudioCapResourceRelease(handleData);
277     EXPECT_EQ(HDF_SUCCESS, ret);
278 }
279 
280 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureSetMuteStu_001, TestSize.Level1)
281 {
282     struct AudioHwCaptureParam *handleData = nullptr;
283     int32_t ret = AudioCtlCaptureSetMuteStu(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, handleData);
284     EXPECT_EQ(HDF_FAILURE, ret);
285 }
286 
287 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureSetMuteStu_002, TestSize.Level1)
288 {
289     int32_t ret;
290     bool mute = false;
291     struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
292     memset_s(handleData, sizeof(AudioHwCaptureParam), 0, sizeof(AudioHwCaptureParam));
293     handleData->captureMode.ctlParam.mute = true;
294     ret = AudioCapInitHwParams(handleData);
295     EXPECT_EQ(HDF_SUCCESS, ret);
296     ret = AudioInterfaceCaptureInit(handleData);
297     EXPECT_EQ(HDF_SUCCESS, ret);
298     ret = AudioCtlCaptureSetMuteStu(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, handleData);
299     EXPECT_EQ(HDF_SUCCESS, ret);
300     ret = AudioCtlCaptureGetMuteStu(handle, AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE, handleData);
301     EXPECT_EQ(HDF_SUCCESS, ret);
302     mute = handleData->captureMode.ctlParam.mute;
303     EXPECT_EQ(true, mute);
304     handleData->captureMode.ctlParam.mute = false;
305     ret = AudioCtlCaptureSetMuteStu(handle, AUDIODRV_CTL_IOCTL_ELEM_WRITE_CAPTURE, handleData);
306     EXPECT_EQ(HDF_SUCCESS, ret);
307     ret = AudioCtlCaptureGetMuteStu(handle, AUDIODRV_CTL_IOCTL_MUTE_READ_CAPTURE, handleData);
308     EXPECT_EQ(HDF_SUCCESS, ret);
309     mute = handleData->captureMode.ctlParam.mute;
310     EXPECT_EQ(false, mute);
311     ret = AudioCapResourceRelease(handleData);
312     EXPECT_EQ(HDF_SUCCESS, ret);
313 }
314 
315 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureSetPauseStu_001, TestSize.Level1)
316 {
317     struct AudioHwCaptureParam *handleData = nullptr;
318     int32_t ret = AudioCtlCaptureSetPauseStu(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE, handleData);
319     EXPECT_EQ(HDF_FAILURE, ret);
320 }
321 
322 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureSetPauseStu_002, TestSize.Level1)
323 {
324     int32_t ret;
325     bool pause = true;
326     struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
327     memset_s(handleData, sizeof(AudioHwCaptureParam), 0, sizeof(AudioHwCaptureParam));
328     handleData->captureMode.ctlParam.pause = false;
329     ret = AudioCapInitHwParams(handleData);
330     EXPECT_EQ(HDF_SUCCESS, ret);
331     ret = AudioInterfaceCaptureInit(handleData);
332     EXPECT_EQ(HDF_SUCCESS, ret);
333     AudioCtlCaptureSetPauseStu(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE, handleData);
334     EXPECT_EQ(HDF_SUCCESS, ret);
335     pause = handleData->captureMode.ctlParam.pause;
336     EXPECT_EQ(false, pause);
337     ret = AudioCapResourceRelease(handleData);
338     EXPECT_EQ(HDF_SUCCESS, ret);
339 }
340 
341 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureSetPauseStu_003, TestSize.Level1)
342 {
343     int32_t ret;
344     bool pause = false;
345     struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
346     memset_s(handleData, sizeof(AudioHwCaptureParam), 0, sizeof(AudioHwCaptureParam));
347     handleData->captureMode.ctlParam.pause = true;
348     ret = AudioCapInitHwParams(handleData);
349     EXPECT_EQ(HDF_SUCCESS, ret);
350     ret = AudioInterfaceCaptureInit(handleData);
351     EXPECT_EQ(HDF_SUCCESS, ret);
352     AudioCtlCaptureSetPauseStu(handle, AUDIODRV_CTL_IOCTL_PAUSE_WRITE_CAPTURE, handleData);
353     EXPECT_EQ(HDF_SUCCESS, ret);
354     pause = handleData->captureMode.ctlParam.pause;
355     EXPECT_EQ(true, pause);
356     ret = AudioCapResourceRelease(handleData);
357     EXPECT_EQ(HDF_SUCCESS, ret);
358 }
359 
360 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureSetGainStu_001, TestSize.Level1)
361 {
362     struct AudioHwCaptureParam *handleData = nullptr;
363     int32_t ret = AudioCtlCaptureSetGainStu(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE, handleData);
364     EXPECT_EQ(HDF_FAILURE, ret);
365 }
366 
367 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureSetGainStu_002, TestSize.Level1)
368 {
369     struct AudioHwCaptureParam handleData;
370     int32_t ret = AudioCtlCaptureSetGainStu(handle, AUDIODRV_CTL_IOCTL_GAIN_WRITE_CAPTURE, &handleData);
371     /* alsa_lib not support AudioCtlCaptureSetGainStu, Therefore, success is returned directly */
372     EXPECT_EQ(HDF_SUCCESS, ret);
373 }
374 
375 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureGetGainStu_001, TestSize.Level1)
376 {
377     struct AudioHwCaptureParam *handleData = nullptr;
378     int32_t ret = AudioCtlCaptureGetGainStu(handle, AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE, handleData);
379     EXPECT_EQ(HDF_FAILURE, ret);
380 }
381 
382 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureGetGainStu_002, TestSize.Level1)
383 {
384     struct AudioHwCaptureParam handleData;
385     int32_t ret = AudioCtlCaptureGetGainStu(handle, AUDIODRV_CTL_IOCTL_GAIN_READ_CAPTURE, &handleData);
386     /* alsa_lib not support AudioCtlCaptureGetGainStu, Therefore, success is returned directly */
387     EXPECT_EQ(HDF_SUCCESS, ret);
388 }
389 
390 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureSceneSelect_001, TestSize.Level1)
391 {
392     struct AudioHwCaptureParam *handleData = nullptr;
393     int32_t ret = AudioCtlCaptureSceneSelect(handle, AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE, handleData);
394     EXPECT_EQ(HDF_FAILURE, ret);
395 }
396 
397 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioCtlCaptureSceneSelect_002, TestSize.Level1)
398 {
399     int32_t ret;
400     struct AudioHwCaptureParam handleData;
401     /* alsa_lib not support AudioCtlCaptureSceneSelect, Therefore, success is returned directly */
402     handleData.captureMode.hwInfo.pathSelect.deviceInfo.deviceNum = AUDIO_MIN_CARD_NUM;
403     ret = AudioCtlCaptureSceneSelect(handle, AUDIODRV_CTL_IOCTL_SCENESELECT_CAPTURE, &handleData);
404     EXPECT_EQ(HDF_SUCCESS, ret);
405 }
406 
407 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioOutputCaptureStart_001, TestSize.Level1)
408 {
409     struct AudioHwCaptureParam *handleData = nullptr;
410     int32_t ret = AudioOutputCaptureStart(handle, AUDIO_DRV_PCM_IOCTRL_START_CAPTURE, handleData);
411     EXPECT_EQ(HDF_FAILURE, ret);
412 }
413 
414 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioOutputCaptureStart_002, TestSize.Level1)
415 {
416     int32_t ret;
417     struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
418     memset_s(handleData, sizeof(AudioHwCaptureParam), 0, sizeof(AudioHwCaptureParam));
419     ret = AudioCapInitHwParams(handleData);
420     EXPECT_EQ(HDF_SUCCESS, ret);
421     ret = AudioInterfaceCaptureInit(handleData);
422     EXPECT_EQ(HDF_SUCCESS, ret);
423     ret = AudioOutputCaptureStart(handle, AUDIO_DRV_PCM_IOCTRL_START_CAPTURE, handleData);
424     EXPECT_EQ(HDF_SUCCESS, ret);
425     ret = AudioCapResourceRelease(handleData);
426     EXPECT_EQ(HDF_SUCCESS, ret);
427 }
428 
429 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioOutputCaptureStop_001, TestSize.Level1)
430 {
431     struct AudioHwCaptureParam *handleData = nullptr;
432     int32_t ret = AudioOutputCaptureStop(handle, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, handleData);
433     EXPECT_EQ(HDF_FAILURE, ret);
434 }
435 
436 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioOutputCaptureStop_002, TestSize.Level1)
437 {
438     int32_t ret;
439     struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
440     memset_s(handleData, sizeof(AudioHwCaptureParam), 0, sizeof(AudioHwCaptureParam));
441     ret = AudioCapInitHwParams(handleData);
442     EXPECT_EQ(HDF_SUCCESS, ret);
443     ret = AudioInterfaceCaptureInit(handleData);
444     EXPECT_EQ(HDF_SUCCESS, ret);
445     ret = AudioOutputCaptureStop(handle, AUDIO_DRV_PCM_IOCTRL_STOP_CAPTURE, handleData);
446     EXPECT_EQ(HDF_SUCCESS, ret);
447     ret = AudioCapResourceRelease(handleData);
448     EXPECT_EQ(HDF_SUCCESS, ret);
449 }
450 
451 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioOutputCaptureRead_001, TestSize.Level1)
452 {
453     struct AudioHwCaptureParam *handleData = nullptr;
454     int32_t ret = AudioOutputCaptureRead(handle, AUDIO_DRV_PCM_IOCTL_READ, handleData);
455     EXPECT_EQ(HDF_FAILURE, ret);
456 }
457 
458 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioOutputCaptureRead_002, TestSize.Level1)
459 {
460     int32_t ret;
461     struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
462     memset_s(handleData, sizeof(AudioHwCaptureParam), 0, sizeof(AudioHwCaptureParam));
463     ret = AudioCapInitHwParams(handleData);
464     EXPECT_EQ(HDF_SUCCESS, ret);
465     int32_t frameSize = capChannel * 2; /* 2 is for AUDIO_FORMAT_TYPE_PCM_16_BIT to byte */
466     ASSERT_NE(frameSize, 0);
467     char *bufferFrameSize = new char[capFrameData];
468     memset_s(bufferFrameSize, capFrameData, 0, capFrameData);
469     handleData->frameCaptureMode.buffer = bufferFrameSize;
470     ret = AudioInterfaceCaptureInit(handleData);
471     EXPECT_EQ(HDF_SUCCESS, ret);
472     ret = AudioOutputCaptureRead(handle, AUDIO_DRV_PCM_IOCTL_READ, handleData);
473     EXPECT_EQ(HDF_SUCCESS, ret);
474     delete[] bufferFrameSize;
475     bufferFrameSize = nullptr;
476     handleData->frameCaptureMode.buffer = nullptr;
477     ret = AudioCapResourceRelease(handleData);
478     EXPECT_EQ(HDF_SUCCESS, ret);
479 }
480 
481 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioOutputCaptureReqMmapBuffer_001, TestSize.Level1)
482 {
483     struct AudioHwCaptureParam *handleData = nullptr;
484     int32_t ret = AudioOutputCaptureReqMmapBuffer(handle, AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE, handleData);
485     EXPECT_EQ(HDF_FAILURE, ret);
486 }
487 
488 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioOutputCaptureReqMmapBuffer_002, TestSize.Level1)
489 {
490     int32_t ret;
491     struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
492     memset_s(handleData, sizeof(AudioHwCaptureParam), 0, sizeof(AudioHwCaptureParam));
493     ret = AudioCapInitHwParams(handleData);
494     EXPECT_EQ(HDF_SUCCESS, ret);
495     int32_t capFrameSize = capChannel * 2; /* 2 is for AUDIO_FORMAT_TYPE_PCM_16_BIT to byte */
496     ASSERT_NE(capFrameSize, 0);
497     handleData->frameCaptureMode.mmapBufDesc.totalBufferFrames = capMmapFrameData / capFrameSize;
498     char *mmapBufferFrameSize = new char[capMmapFrameData];
499     handleData->frameCaptureMode.mmapBufDesc.memoryAddress = mmapBufferFrameSize ;
500     ret = AudioInterfaceCaptureInit(handleData);
501     EXPECT_EQ(HDF_SUCCESS, ret);
502     ret = AudioOutputCaptureReqMmapBuffer(handle, AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE, handleData);
503     EXPECT_EQ(HDF_SUCCESS, ret);
504     delete[] mmapBufferFrameSize;
505     mmapBufferFrameSize = nullptr;
506     handleData->frameCaptureMode.mmapBufDesc.memoryAddress = nullptr;
507     ret = AudioCapResourceRelease(handleData);
508     EXPECT_EQ(HDF_SUCCESS, ret);
509 }
510 
511 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioOutputCaptureGetMmapPosition_001, TestSize.Level1)
512 {
513     struct AudioHwCaptureParam *handleData = nullptr;
514     int32_t ret = AudioOutputCaptureGetMmapPosition(handle, AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE, handleData);
515     EXPECT_EQ(HDF_FAILURE, ret);
516 }
517 
518 HWTEST_F(AudioAlsaIfLibCaptureTest, AudioOutputCaptureGetMmapPosition_002, TestSize.Level1)
519 {
520     int32_t ret;
521     char mmapBuffer[capMmapFrameData];
522     struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
523     memset_s(handleData, sizeof(AudioHwCaptureParam), 0, sizeof(AudioHwCaptureParam));
524     ret = AudioCapInitHwParams(handleData);
525     EXPECT_EQ(HDF_SUCCESS, ret);
526     int32_t mmapFrameSize = capChannel * 2; /* 2 is for AUDIO_FORMAT_TYPE_PCM_16_BIT to byte */
527     ASSERT_NE(mmapFrameSize, 0);
528     handleData->frameCaptureMode.mmapBufDesc.totalBufferFrames = capMmapFrameData / mmapFrameSize;
529     handleData->frameCaptureMode.mmapBufDesc.memoryAddress = mmapBuffer ;
530     ret = AudioInterfaceCaptureInit(handleData);
531     EXPECT_EQ(HDF_SUCCESS, ret);
532     ret = AudioOutputCaptureReqMmapBuffer(handle, AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE, handleData);
533     EXPECT_EQ(HDF_SUCCESS, ret);
534     handleData->frameCaptureMode.frames = 0;
535     ret = AudioOutputCaptureGetMmapPosition(handle, AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE, handleData);
536     EXPECT_EQ(HDF_SUCCESS, ret);
537     uint64_t getFramePosition = handleData->frameCaptureMode.frames;
538     EXPECT_EQ(getFramePosition, capMmapFrameData / mmapFrameSize);
539     ret = AudioCapResourceRelease(handleData);
540     EXPECT_EQ(HDF_SUCCESS, ret);
541 }
542 }
543