1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include "audio_interface_lib_capture.h"
19
20 using namespace std;
21 using namespace testing::ext;
22 namespace {
23 extern "C" {
24 struct HdfSBuf *HdfSbufObtainDefaultSize();
25 int32_t SetHwParamsCapture(const struct AudioHwCaptureParam * const handleData);
26 int32_t AudioServiceCaptureDispatch(struct HdfIoService *service,
27 int cmdId, struct HdfSBuf *sBuf, struct HdfSBuf *reply);
28 int32_t AudioCtlCaptureSetPauseBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData);
29 int32_t AudioCtlCaptureSetPauseStu(const struct DevHandle *handle,
30 int cmdId, const struct AudioHwCaptureParam *handleData);
31 int32_t AudioCtlCaptureGetVolumeSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData);
32 int32_t AudioCtlCaptureGetVolume(const struct DevHandle *handle,
33 int cmdId, struct AudioHwCaptureParam *handleData);
34 int32_t AudioCtlCaptureSetVolumeSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData);
35 int32_t AudioCtlCaptureSetVolume(const struct DevHandle *handle,
36 int cmdId, const struct AudioHwCaptureParam *handleData);
37 int32_t AudioCtlCaptureSetMuteSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData);
38 int32_t AudioCtlCaptureSetMuteStu(const struct DevHandle *handle,
39 int cmdId, const struct AudioHwCaptureParam *handleData);
40 int32_t AudioCtlCaptureGetMuteSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData);
41 int32_t AudioCtlCaptureGetMuteStu(const struct DevHandle *handle,
42 int cmdId, struct AudioHwCaptureParam *handleData);
43 int32_t AudioCtlCaptureSetGainSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData);
44 int32_t AudioCtlCaptureSetGainStu(const struct DevHandle *handle,
45 int cmdId, const struct AudioHwCaptureParam *handleData);
46 int32_t AudioCtlCaptureGetGainSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData);
47 int32_t AudioCtlCaptureGetGainStu(const struct DevHandle *handle,
48 int cmdId, struct AudioHwCaptureParam *handleData);
49 int32_t AudioCtlCaptureSceneSelectSBuf(struct HdfSBuf *sBuf,
50 struct AudioHwCaptureParam *handleData, int32_t deviceIndex);
51 int32_t AudioCtlCaptureSceneSelect(const struct DevHandle *handle,
52 int cmdId, const struct AudioHwCaptureParam *handleData);
53 int32_t AudioCtlCaptureGetGainThresholdSBuf(struct HdfSBuf *sBuf, struct AudioHwCaptureParam *handleData);
54 int32_t AudioCtlCaptureGetGainThreshold(const struct DevHandle *handle,
55 int cmdId, struct AudioHwCaptureParam *handleData);
56 int32_t AudioInterfaceLibCtlCapture(const struct DevHandle *handle,
57 int cmdId, struct AudioHwCaptureParam *handleData);
58 int32_t AudioOutputCaptureHwParams(const struct DevHandle *handle,
59 int cmdId, const struct AudioHwCaptureParam *handleData);
60 int32_t AudioOutputCaptureRead(const struct DevHandle *handle,
61 int cmdId, struct AudioHwCaptureParam *handleData);
62 int32_t AudioOutputCaptureStop(const struct DevHandle *handle,
63 int cmdId, const struct AudioHwCaptureParam *handleData);
64 int32_t AudioInterfaceLibOutputCapture(const struct DevHandle *handle, int cmdId,
65 struct AudioHwCaptureParam *handleData);
66 }
67
68 class AudioAdmIfLibCaptureTest : public testing::Test {
69 public:
70 static void SetUpTestCase();
71 static void TearDownTestCase();
72 };
73
SetUpTestCase()74 void AudioAdmIfLibCaptureTest::SetUpTestCase()
75 {
76 }
77
TearDownTestCase()78 void AudioAdmIfLibCaptureTest::TearDownTestCase()
79 {
80 }
81
82 HWTEST_F(AudioAdmIfLibCaptureTest, SetHwParamsCapture_001, TestSize.Level1)
83 {
84 const struct AudioHwCaptureParam *handleData = nullptr;
85 int32_t ret = SetHwParamsCapture(handleData);
86 EXPECT_EQ(HDF_FAILURE, ret);
87 }
88
89 HWTEST_F(AudioAdmIfLibCaptureTest, SetHwParamsCapture_002, TestSize.Level1)
90 {
91 struct AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
92 handleData->captureMode.hwInfo.card = AUDIO_SERVICE_IN;
93 int32_t ret = SetHwParamsCapture((const struct AudioHwCaptureParam *)handleData);
94 EXPECT_EQ(HDF_SUCCESS, ret);
95 delete(handleData);
96 handleData = nullptr;
97 }
98
99 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureSetPauseBuf_001, TestSize.Level1)
100 {
101 struct HdfSBuf *sBuf = nullptr;
102 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
103 int32_t ret = AudioCtlCaptureSetPauseBuf(sBuf, handleData);
104 EXPECT_EQ(HDF_FAILURE, ret);
105 delete(handleData);
106 handleData = nullptr;
107 }
108
109 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureSetPauseBuf_002, TestSize.Level1)
110 {
111 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
112 AudioHwCaptureParam *handleData = nullptr;
113 int32_t ret = AudioCtlCaptureSetPauseBuf(sBuf, handleData);
114 EXPECT_EQ(HDF_FAILURE, ret);
115 HdfSbufRecycle(sBuf);
116 }
117
118 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureSetPauseBuf_003, TestSize.Level1)
119 {
120 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
121 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
122 handleData->captureMode.hwInfo.card = AUDIO_SERVICE_IN;
123 int32_t ret = AudioCtlCaptureSetPauseBuf(sBuf, handleData);
124 EXPECT_EQ(HDF_SUCCESS, ret);
125 HdfSbufRecycle(sBuf);
126 delete(handleData);
127 handleData = nullptr;
128 }
129
130 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureGetVolumeSBuf_001, TestSize.Level1)
131 {
132 struct HdfSBuf *sBuf = nullptr;
133 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
134 int32_t ret = AudioCtlCaptureGetVolumeSBuf(sBuf, handleData);
135 EXPECT_EQ(HDF_FAILURE, ret);
136 delete(handleData);
137 handleData = nullptr;
138 }
139
140 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureGetVolumeSBuf_002, TestSize.Level1)
141 {
142 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
143 AudioHwCaptureParam *handleData = nullptr;
144 int32_t ret = AudioCtlCaptureGetVolumeSBuf(sBuf, handleData);
145 EXPECT_EQ(HDF_FAILURE, ret);
146 HdfSbufRecycle(sBuf);
147 }
148
149 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureGetVolumeSBuf_003, TestSize.Level1)
150 {
151 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
152 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
153 handleData->captureMode.hwInfo.card = AUDIO_SERVICE_IN;
154 int32_t ret = AudioCtlCaptureGetVolumeSBuf(sBuf, handleData);
155 EXPECT_EQ(HDF_SUCCESS, ret);
156 HdfSbufRecycle(sBuf);
157 delete(handleData);
158 handleData = nullptr;
159 }
160
161 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureSetVolumeSBuf_001, TestSize.Level1)
162 {
163 struct HdfSBuf *sBuf = nullptr;
164 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
165 int32_t ret = AudioCtlCaptureSetVolumeSBuf(sBuf, handleData);
166 EXPECT_EQ(HDF_FAILURE, ret);
167 delete(handleData);
168 handleData = nullptr;
169 }
170
171 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureSetVolumeSBuf_002, TestSize.Level1)
172 {
173 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
174 AudioHwCaptureParam *handleData = nullptr;
175 int32_t ret = AudioCtlCaptureSetVolumeSBuf(sBuf, handleData);
176 EXPECT_EQ(HDF_FAILURE, ret);
177 HdfSbufRecycle(sBuf);
178 }
179
180 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureSetVolumeSBuf_003, TestSize.Level1)
181 {
182 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
183 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
184 handleData->captureMode.hwInfo.card = AUDIO_SERVICE_IN;
185 int32_t ret = AudioCtlCaptureSetVolumeSBuf(sBuf, handleData);
186 EXPECT_EQ(HDF_SUCCESS, ret);
187 HdfSbufRecycle(sBuf);
188 delete(handleData);
189 handleData = nullptr;
190 }
191
192 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureSetMuteSBuf_001, TestSize.Level1)
193 {
194 struct HdfSBuf *sBuf = nullptr;
195 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
196 int32_t ret = AudioCtlCaptureSetMuteSBuf(sBuf, handleData);
197 EXPECT_EQ(HDF_FAILURE, ret);
198 delete(handleData);
199 handleData = nullptr;
200 }
201
202 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureSetMuteSBuf_002, TestSize.Level1)
203 {
204 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
205 AudioHwCaptureParam *handleData = nullptr;
206 int32_t ret = AudioCtlCaptureSetMuteSBuf(sBuf, handleData);
207 EXPECT_EQ(HDF_FAILURE, ret);
208 HdfSbufRecycle(sBuf);
209 }
210
211 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureSetMuteSBuf_003, TestSize.Level1)
212 {
213 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
214 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
215 handleData->captureMode.hwInfo.card = AUDIO_SERVICE_IN;
216 int32_t ret = AudioCtlCaptureSetMuteSBuf(sBuf, handleData);
217 EXPECT_EQ(HDF_SUCCESS, ret);
218 HdfSbufRecycle(sBuf);
219 delete(handleData);
220 handleData = nullptr;
221 }
222
223 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureGetMuteSBuf_001, TestSize.Level1)
224 {
225 struct HdfSBuf *sBuf = nullptr;
226 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
227 int32_t ret = AudioCtlCaptureGetMuteSBuf(sBuf, handleData);
228 EXPECT_EQ(HDF_FAILURE, ret);
229 delete(handleData);
230 handleData = nullptr;
231 }
232
233 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureGetMuteSBuf_002, TestSize.Level1)
234 {
235 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
236 AudioHwCaptureParam *handleData = nullptr;
237 int32_t ret = AudioCtlCaptureGetMuteSBuf(sBuf, handleData);
238 EXPECT_EQ(HDF_FAILURE, ret);
239 HdfSbufRecycle(sBuf);
240 }
241
242 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureGetMuteSBuf_003, TestSize.Level1)
243 {
244 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
245 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
246 handleData->captureMode.hwInfo.card = AUDIO_SERVICE_IN;
247 int32_t ret = AudioCtlCaptureGetMuteSBuf(sBuf, handleData);
248 EXPECT_EQ(HDF_SUCCESS, ret);
249 HdfSbufRecycle(sBuf);
250 delete(handleData);
251 handleData = nullptr;
252 }
253
254 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureSetGainSBuf_001, TestSize.Level1)
255 {
256 struct HdfSBuf *sBuf = nullptr;
257 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
258 int32_t ret = AudioCtlCaptureSetGainSBuf(sBuf, handleData);
259 EXPECT_EQ(HDF_FAILURE, ret);
260 delete(handleData);
261 handleData = nullptr;
262 }
263
264 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureSetGainSBuf_002, TestSize.Level1)
265 {
266 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
267 AudioHwCaptureParam *handleData = nullptr;
268 int32_t ret = AudioCtlCaptureSetGainSBuf(sBuf, handleData);
269 EXPECT_EQ(HDF_FAILURE, ret);
270 HdfSbufRecycle(sBuf);
271 }
272
273 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureSetGainSBuf_003, TestSize.Level1)
274 {
275 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
276 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
277 handleData->captureMode.hwInfo.card = AUDIO_SERVICE_IN;
278 int32_t ret = AudioCtlCaptureSetGainSBuf(sBuf, handleData);
279 EXPECT_EQ(HDF_SUCCESS, ret);
280 HdfSbufRecycle(sBuf);
281 delete(handleData);
282 handleData = nullptr;
283 }
284
285 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureGetGainSBuf_001, TestSize.Level1)
286 {
287 struct HdfSBuf *sBuf = nullptr;
288 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
289 int32_t ret = AudioCtlCaptureGetGainSBuf(sBuf, handleData);
290 EXPECT_EQ(HDF_FAILURE, ret);
291 delete(handleData);
292 handleData = nullptr;
293 }
294
295 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureGetGainSBuf_002, TestSize.Level1)
296 {
297 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
298 AudioHwCaptureParam *handleData = nullptr;
299 int32_t ret = AudioCtlCaptureGetGainSBuf(sBuf, handleData);
300 EXPECT_EQ(HDF_FAILURE, ret);
301 HdfSbufRecycle(sBuf);
302 }
303
304 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureGetGainSBuf_003, TestSize.Level1)
305 {
306 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
307 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
308 handleData->captureMode.hwInfo.card = AUDIO_SERVICE_IN;
309 int32_t ret = AudioCtlCaptureGetGainSBuf(sBuf, handleData);
310 EXPECT_EQ(HDF_SUCCESS, ret);
311 HdfSbufRecycle(sBuf);
312 delete(handleData);
313 handleData = nullptr;
314 }
315
316 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureSceneSelectSBuf_001, TestSize.Level1)
317 {
318 struct HdfSBuf *sBuf = nullptr;
319 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
320 int32_t deviceIndex = 0;
321 int32_t ret = AudioCtlCaptureSceneSelectSBuf(sBuf, handleData, deviceIndex);
322 EXPECT_EQ(HDF_FAILURE, ret);
323 delete(handleData);
324 handleData = nullptr;
325 }
326
327 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureSceneSelectSBuf_002, TestSize.Level1)
328 {
329 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
330 AudioHwCaptureParam *handleData = nullptr;
331 int32_t deviceIndex = 0;
332 int32_t ret = AudioCtlCaptureSceneSelectSBuf(sBuf, handleData, deviceIndex);
333 EXPECT_EQ(HDF_FAILURE, ret);
334 HdfSbufRecycle(sBuf);
335 }
336
337 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureSceneSelectSBuf_003, TestSize.Level1)
338 {
339 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
340 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
341 handleData->captureMode.hwInfo.card = AUDIO_SERVICE_IN;
342 int32_t deviceIndex = 0;
343 int32_t ret = AudioCtlCaptureSceneSelectSBuf(sBuf, handleData, deviceIndex);
344 EXPECT_EQ(HDF_SUCCESS, ret);
345 HdfSbufRecycle(sBuf);
346 delete(handleData);
347 handleData = nullptr;
348 }
349
350 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureGetGainThresholdSBuf_001, TestSize.Level1)
351 {
352 struct HdfSBuf *sBuf = nullptr;
353 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
354 int32_t ret = AudioCtlCaptureGetGainThresholdSBuf(sBuf, handleData);
355 EXPECT_EQ(HDF_FAILURE, ret);
356 delete(handleData);
357 handleData = nullptr;
358 }
359
360 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureGetGainThresholdSBuf_002, TestSize.Level1)
361 {
362 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
363 AudioHwCaptureParam *handleData = nullptr;
364 int32_t ret = AudioCtlCaptureGetGainThresholdSBuf(sBuf, handleData);
365 EXPECT_EQ(HDF_FAILURE, ret);
366 HdfSbufRecycle(sBuf);
367 }
368
369 HWTEST_F(AudioAdmIfLibCaptureTest, AudioCtlCaptureGetGainThresholdSBuf_003, TestSize.Level1)
370 {
371 struct HdfSBuf *sBuf = HdfSbufObtainDefaultSize();
372 AudioHwCaptureParam *handleData = new AudioHwCaptureParam;
373 handleData->captureMode.hwInfo.card = AUDIO_SERVICE_IN;
374 int32_t ret = AudioCtlCaptureGetGainThresholdSBuf(sBuf, handleData);
375 EXPECT_EQ(HDF_SUCCESS, ret);
376 HdfSbufRecycle(sBuf);
377 delete(handleData);
378 handleData = nullptr;
379 }
380 }
381