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 "audio_capture_test.h"
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 #include "audio_common_test.h"
20
21 using namespace std;
22 using namespace comfun;
23 using namespace testing::ext;
24 namespace {
25 class AudioCaptureTest : public testing::Test {
26 public:
27 struct AudioManager *managerFuncs = nullptr;
28 struct AudioAdapterDescriptor *descs = nullptr;
29 struct AudioAdapterDescriptor *desc = nullptr;
30 struct AudioAdapter *adapter = nullptr;
31 struct AudioDeviceDescriptor devDesc = {};
32 struct AudioSampleAttributes attrs = {};
33 struct AudioCapture *capture = nullptr;
34
35 virtual void SetUp();
36 virtual void TearDown();
37 };
38
SetUp()39 void AudioCaptureTest::SetUp()
40 {
41 managerFuncs = GetAudioManagerFuncs();
42 ASSERT_NE(managerFuncs, nullptr);
43 int32_t size = 0;
44 ASSERT_EQ(HDF_SUCCESS, managerFuncs->GetAllAdapters(managerFuncs, &descs, &size));
45
46 desc = &descs[0];
47 ASSERT_EQ(HDF_SUCCESS, managerFuncs->LoadAdapter(managerFuncs, desc, &adapter));
48 ASSERT_EQ(HDF_SUCCESS, InitDevDescCapture(devDesc));
49 ASSERT_EQ(HDF_SUCCESS, InitAttrsCapture(attrs));
50 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioAdapterCreateCapture(adapter, &devDesc, &attrs, &capture));
51 }
52
TearDown()53 void AudioCaptureTest::TearDown()
54 {
55 ASSERT_EQ(HDF_SUCCESS, AudioAdapterDestroyCapture(adapter, capture));
56 managerFuncs->UnloadAdapter(managerFuncs, adapter);
57 adapter = nullptr;
58 }
59
60 HWTEST_F(AudioCaptureTest, AudioCaptureStartWhenHandleIsNull, TestSize.Level1)
61 {
62 AudioHwCapture *hwCapture = nullptr;
63 AudioHandle handle = (AudioHandle)hwCapture;
64 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureStart(handle));
65 }
66
67 HWTEST_F(AudioCaptureTest, AudioCaptureStartWhenBufferIsNotNull, TestSize.Level1)
68 {
69 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
70 AudioHandle handle = (AudioHandle)hwCapture;
71 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle));
72 EXPECT_EQ(AUDIO_HAL_ERR_AI_BUSY, AudioCaptureStart(handle));
73 }
74
75 HWTEST_F(AudioCaptureTest, AudioCaptureStartWhenDevDataHandleIsNull, TestSize.Level1)
76 {
77 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
78 struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle;
79 hwCapture->devDataHandle = nullptr;
80 AudioHandle handle = (AudioHandle)hwCapture;
81 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureStart(handle));
82 hwCapture->devDataHandle = devDataHandle;
83 }
84
85 HWTEST_F(AudioCaptureTest, AudioCaptureStartWhenDevDataHandleIsError, TestSize.Level1)
86 {
87 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
88 struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle;
89 struct HdfIoService *service = new HdfIoService;
90 hwCapture->devDataHandle = (struct DevHandleCapture *)service;
91 AudioHandle handle = (AudioHandle)hwCapture;
92 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureStart(handle));
93 hwCapture->devDataHandle = devDataHandle;
94 delete(service);
95 service = nullptr;
96 }
97
98 HWTEST_F(AudioCaptureTest, AudioCaptureStartWhenParamIsVaild, TestSize.Level1)
99 {
100 AudioHandle handle = (AudioHandle)capture;
101 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle));
102 }
103
104
105 HWTEST_F(AudioCaptureTest, AudioCaptureStopWhenHandleIsNull, TestSize.Level1)
106 {
107 struct AudioHwCapture *hwCapture = nullptr;
108 AudioHandle handle = (AudioHandle)hwCapture;
109 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureStop(handle));
110 }
111
112 HWTEST_F(AudioCaptureTest, AudioCaptureStopWhenDevDataHandleIsNull, TestSize.Level1)
113 {
114 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
115 AudioHandle handle = (AudioHandle)hwCapture;
116 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle));
117 struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle;
118 hwCapture->devDataHandle = nullptr;
119 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureStop(handle));
120 hwCapture->devDataHandle = devDataHandle;
121 }
122
123 HWTEST_F(AudioCaptureTest, AudioCaptureStopWhenBufferIsNull, TestSize.Level1)
124 {
125 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
126 hwCapture->captureParam.frameCaptureMode.buffer = nullptr;
127 AudioHandle handle = (AudioHandle)hwCapture;
128 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioCaptureStop(handle));
129 }
130
131 HWTEST_F(AudioCaptureTest, AudioCaptureStopWhenDevDataHandleIsError, TestSize.Level1)
132 {
133 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
134 AudioHandle handle = (AudioHandle)hwCapture;
135 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle));
136 struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle;
137 struct HdfIoService *service = new HdfIoService;
138 hwCapture->devDataHandle = (struct DevHandleCapture *)service;
139 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureStop(handle));
140 hwCapture->devDataHandle = devDataHandle;
141 delete(service);
142 service = nullptr;
143 }
144
145 HWTEST_F(AudioCaptureTest, AudioCaptureStopWhenParamIsVaild, TestSize.Level1)
146 {
147 AudioHandle handle = (AudioHandle)capture;
148 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle));
149 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStop(handle));
150 }
151
152 HWTEST_F(AudioCaptureTest, AudioCapturePauseWhenHandleIsNull, TestSize.Level1)
153 {
154 AudioHwCapture *hwCapture = nullptr;
155 AudioHandle handle = (AudioHandle)hwCapture;
156 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCapturePause(handle));
157 }
158
159 HWTEST_F(AudioCaptureTest, AudioCapturePauseWhenBufferIsNull, TestSize.Level1)
160 {
161 AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
162 hwCapture->captureParam.frameCaptureMode.buffer = nullptr;
163 AudioHandle handle = (AudioHandle)hwCapture;
164 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCapturePause(handle));
165 }
166
167 HWTEST_F(AudioCaptureTest, AudioCapturePauseWhenPauseIsTrue, TestSize.Level1)
168 {
169 AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
170 hwCapture->captureParam.captureMode.ctlParam.pause = true;
171 AudioHandle handle = (AudioHandle)hwCapture;
172 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle));
173 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioCapturePause(handle));
174 }
175
176 HWTEST_F(AudioCaptureTest, AudioCapturePauseWhenDevDataHandleIsNull, TestSize.Level1)
177 {
178 struct AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
179 AudioHandle handle = (AudioHandle)hwCapture;
180 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle));
181 struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle;
182 hwCapture->devDataHandle = nullptr;
183 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCapturePause(handle));
184 hwCapture->devDataHandle = devDataHandle;
185 }
186
187 HWTEST_F(AudioCaptureTest, AudioCapturePauseWhenDevDataHandleIsError, TestSize.Level1)
188 {
189 struct AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
190 AudioHandle handle = (AudioHandle)hwCapture;
191 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle));
192 struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle;
193 struct HdfIoService *service = new HdfIoService;
194 hwCapture->devDataHandle = (struct DevHandleCapture *)service;
195 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCapturePause(handle));
196 hwCapture->devDataHandle = devDataHandle;
197 delete(service);
198 service = nullptr;
199 }
200
201 HWTEST_F(AudioCaptureTest, AudioCapturePauseWhenParamVaild, TestSize.Level1)
202 {
203 AudioHandle handle = (AudioHandle)capture;
204 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle));
205 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCapturePause(handle));
206 }
207
208 HWTEST_F(AudioCaptureTest, AudioCaptureResumeWhenHandleIsNull, TestSize.Level1)
209 {
210 struct AudioHwCapture *hwCapture = nullptr;
211 AudioHandle handle = (AudioHandle)hwCapture;
212 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureResume(handle));
213 }
214
215 HWTEST_F(AudioCaptureTest, AudioCaptureResumeWhenPauseIsFalse, TestSize.Level1)
216 {
217 AudioHandle handle = (AudioHandle)capture;
218 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle));
219 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
220 hwCapture->captureParam.captureMode.ctlParam.pause = false;
221 handle = (AudioHandle)hwCapture;
222 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioCaptureResume(handle));
223 }
224
225 HWTEST_F(AudioCaptureTest, AudioCaptureResumeWhenDevDataHandleIsNull, TestSize.Level1)
226 {
227 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
228 AudioHandle handle = (AudioHandle)hwCapture;
229 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle));
230 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCapturePause(handle));
231 struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle;
232 hwCapture->devDataHandle = nullptr;
233 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureResume(handle));
234 hwCapture->devDataHandle = devDataHandle;
235 }
236
237 HWTEST_F(AudioCaptureTest, AudioCaptureResumeWhenDevDataHandleIsError, TestSize.Level1)
238 {
239 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
240 AudioHandle handle = (AudioHandle)hwCapture;
241 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle));
242 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCapturePause(handle));
243 struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle;
244 struct HdfIoService *service = new HdfIoService;
245 hwCapture->devDataHandle = (struct DevHandleCapture *)service;
246 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureResume(handle));
247 hwCapture->devDataHandle = devDataHandle;
248 delete(service);
249 service = nullptr;
250 }
251
252 HWTEST_F(AudioCaptureTest, AudioCaptureResumeWhenParamVaild, TestSize.Level1)
253 {
254 AudioHandle handle = (AudioHandle)capture;
255 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle));
256 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCapturePause(handle));
257 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureResume(handle));
258 }
259
260 HWTEST_F(AudioCaptureTest, AudioCaptureFlushWhenHandleIsNull, TestSize.Level1)
261 {
262 AudioHwCapture *hwCapture = nullptr;
263 AudioHandle handle = (AudioHandle)hwCapture;
264 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureFlush(handle));
265 }
266
267 HWTEST_F(AudioCaptureTest, AudioCaptureFlushWhenParamIsVaild, TestSize.Level1)
268 {
269 AudioHwCapture *hwCapture = new AudioHwCapture;
270 AudioHandle handle = (AudioHandle)hwCapture;
271 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioCaptureFlush(handle));
272 delete(hwCapture);
273 hwCapture = nullptr;
274 }
275
276 HWTEST_F(AudioCaptureTest, AudioCaptureGetFrameSizeWhenHandleIsNull, TestSize.Level1)
277 {
278 AudioHwCapture *hwCapture = nullptr;
279 AudioHandle handle = (AudioHandle)hwCapture;
280 uint64_t size = FRAME_DATA;
281 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetFrameSize(handle, &size));
282 }
283
284 HWTEST_F(AudioCaptureTest, AudioCaptureGetFrameSizeWhenSizeIsNull, TestSize.Level1)
285 {
286 AudioHandle handle = (AudioHandle)capture;
287 uint64_t *frameSize = nullptr;
288 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetFrameSize(handle, frameSize));
289 }
290
291 HWTEST_F(AudioCaptureTest, AudioCaptureGetFrameSizeWhenParamIsNotSupport, TestSize.Level1)
292 {
293 AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
294 hwCapture->captureParam.frameCaptureMode.attrs.format = AUDIO_FORMAT_AAC_MAIN;
295 AudioHandle handle = (AudioHandle)hwCapture;
296 uint64_t frameSize = FRAME_DATA;
297 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioCaptureGetFrameSize(handle, &frameSize));
298 }
299
300 HWTEST_F(AudioCaptureTest, AudioCaptureGetFrameSizeWhenParamVaild, TestSize.Level1)
301 {
302 AudioHandle handle = (AudioHandle)capture;
303 uint64_t frameSize = FRAME_DATA;
304 EXPECT_EQ(HDF_SUCCESS, AudioCaptureGetFrameSize(handle, &frameSize));
305 }
306
307 HWTEST_F(AudioCaptureTest, AudioCaptureGetFrameCountWhenHandleIsNull, TestSize.Level1)
308 {
309 AudioHwCapture *hwCapture = nullptr;
310 AudioHandle handle = (AudioHandle)hwCapture;
311 uint64_t count = FRAME_DATA;
312 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetFrameCount(handle, &count));
313 }
314
315 HWTEST_F(AudioCaptureTest, AudioCaptureGetFrameCountWhenCountIsNull, TestSize.Level1)
316 {
317 AudioHandle handle = (AudioHandle)capture;
318 uint64_t *count = nullptr;
319 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetFrameCount(handle, count));
320 }
321
322 HWTEST_F(AudioCaptureTest, AudioCaptureGetFrameCountWhenParamIsVaild, TestSize.Level1)
323 {
324 AudioHandle handle = (AudioHandle)capture;
325 uint64_t count = FRAME_DATA;
326 EXPECT_EQ(HDF_SUCCESS, AudioCaptureGetFrameCount(handle, &count));
327 }
328
329 HWTEST_F(AudioCaptureTest, AudioCaptureSetSampleAttributesWhenHandleIsNull, TestSize.Level1)
330 {
331 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureSetSampleAttributes(nullptr, &attrs));
332 }
333
334 HWTEST_F(AudioCaptureTest, AudioCaptureSetSampleAttributesWhenAttrsIsNull, TestSize.Level1)
335 {
336 AudioHandle handle = (AudioHandle)capture;
337 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureSetSampleAttributes(handle, nullptr));
338 }
339
340 HWTEST_F(AudioCaptureTest, AudioCaptureSetSampleAttributesWhenDevDataHandleIsNull, TestSize.Level1)
341 {
342 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
343 struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle;
344 hwCapture->devDataHandle = nullptr;
345 AudioHandle handle = (AudioHandle)hwCapture;
346 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureSetSampleAttributes(handle, &attrs));
347 hwCapture->devDataHandle = devDataHandle;
348 }
349
350 HWTEST_F(AudioCaptureTest, AudioCaptureSetSampleAttributesWhenFormatIsError, TestSize.Level1)
351 {
352 AudioHandle handle = (AudioHandle)capture;
353 enum AudioFormat format = attrs.format;
354 attrs.format = AUDIO_FORMAT_G711A;
355 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, AudioCaptureSetSampleAttributes(handle, &attrs));
356 attrs.format = format;
357 }
358
359 HWTEST_F(AudioCaptureTest, AudioCaptureSetSampleAttributesWhenDevDataHandleIsError, TestSize.Level1)
360 {
361 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
362 struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle;
363 struct HdfIoService *service = new HdfIoService;
364 hwCapture->devDataHandle = (struct DevHandleCapture *)service;
365 AudioHandle handle = (AudioHandle)hwCapture;
366 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureSetSampleAttributes(handle, &attrs));
367 hwCapture->devDataHandle = devDataHandle;
368 delete(service);
369 service = nullptr;
370 }
371
372 HWTEST_F(AudioCaptureTest, AudioCaptureSetSampleAttributesWhenParamIsVaild, TestSize.Level1)
373 {
374 AudioHandle handle = (AudioHandle)capture;
375 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSetSampleAttributes(handle, &attrs));
376 }
377
378 HWTEST_F(AudioCaptureTest, AudioCaptureGetSampleAttributesWhenHandleIsNull, TestSize.Level1)
379 {
380 AudioSampleAttributes *attrs = new AudioSampleAttributes;
381 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetSampleAttributes(nullptr, attrs));
382 delete(attrs);
383 attrs = nullptr;
384 }
385
386 HWTEST_F(AudioCaptureTest, AudioCaptureGetSampleAttributesWhenAttrsIsNull, TestSize.Level1)
387 {
388 AudioHandle handle = (AudioHandle)capture;
389 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetSampleAttributes(handle, nullptr));
390 }
391
392 HWTEST_F(AudioCaptureTest, AudioCaptureGetSampleAttributesWhenParamIsVaild, TestSize.Level1)
393 {
394 AudioHandle handle = (AudioHandle)capture;
395 EXPECT_EQ(HDF_SUCCESS, AudioCaptureGetSampleAttributes(handle, &attrs));
396 }
397
398 HWTEST_F(AudioCaptureTest, AudioCaptureGetCurrentChannelIdWhenHandleIsNull, TestSize.Level1)
399 {
400 uint32_t channelIdOne = 1;
401 uint32_t *channelId = &channelIdOne;
402 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetCurrentChannelId(nullptr, channelId));
403 }
404
405 HWTEST_F(AudioCaptureTest, AudioCaptureGetCurrentChannelIdWhenChannelIdIsNull, TestSize.Level1)
406 {
407 AudioHandle handle = (AudioHandle)capture;
408 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetCurrentChannelId(handle, nullptr));
409 }
410
411 HWTEST_F(AudioCaptureTest, AudioCaptureGetCurrentChannelIdWhenParamIsVaild, TestSize.Level1)
412 {
413 AudioHandle handle = (AudioHandle)capture;
414 uint32_t channelId = 1;
415 EXPECT_EQ(HDF_SUCCESS, AudioCaptureGetCurrentChannelId(handle, &channelId));
416 }
417
418 HWTEST_F(AudioCaptureTest, AudioCaptureCheckSceneCapabilityWhenHandleIsNull, TestSize.Level1)
419 {
420 const struct AudioSceneDescriptor *scene = new struct AudioSceneDescriptor;
421 bool supported = false;
422 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureCheckSceneCapability(nullptr, scene, &supported));
423 delete(scene);
424 scene = nullptr;
425 }
426
427 HWTEST_F(AudioCaptureTest, AudioCaptureCheckSceneCapabilityWhenSceneIsNull, TestSize.Level1)
428 {
429 AudioHandle handle = (AudioHandle)capture;
430 bool supported = false;
431 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureCheckSceneCapability(handle, nullptr, &supported));
432 }
433
434 HWTEST_F(AudioCaptureTest, AudioCaptureCheckSceneCapabilityWhenSupportedIsNull, TestSize.Level1)
435 {
436 AudioHandle handle = (AudioHandle)capture;
437 const struct AudioSceneDescriptor *scene = new struct AudioSceneDescriptor;
438 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureCheckSceneCapability(handle, scene, nullptr));
439 delete(scene);
440 scene = nullptr;
441 }
442
443 HWTEST_F(AudioCaptureTest, AudioCaptureCheckSceneCapabilityWhenPinsIsError, TestSize.Level1)
444 {
445 AudioHandle handle = (AudioHandle)capture;
446 struct AudioSceneDescriptor scene;
447 scene.scene.id = AUDIO_IN_MEDIA;
448 scene.desc.pins = PIN_NONE;
449 bool supported = false;
450 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureCheckSceneCapability(handle, &scene, &supported));
451 }
452
453 HWTEST_F(AudioCaptureTest, AudioCaptureCheckSceneCapabilityWhenParamIsVaild, TestSize.Level1)
454 {
455 AudioHandle handle = (AudioHandle)capture;
456 struct AudioSceneDescriptor scene;
457 scene.scene.id = AUDIO_IN_MEDIA;
458 scene.desc.pins = PIN_IN_MIC;
459 bool supported = false;
460 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureCheckSceneCapability(handle, &scene, &supported));
461 }
462
463 HWTEST_F(AudioCaptureTest, AudioCaptureSelectSceneWhenHandleIsNull, TestSize.Level1)
464 {
465 AudioHwCapture *hwCapture = nullptr;
466 AudioHandle handle = (AudioHandle)hwCapture;
467 const struct AudioSceneDescriptor *scene = new struct AudioSceneDescriptor;
468 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureSelectScene(handle, scene));
469 delete(scene);
470 scene = nullptr;
471 }
472
473 HWTEST_F(AudioCaptureTest, AudioCaptureSelectSceneWhenSceneIsNull, TestSize.Level1)
474 {
475 AudioHandle handle = (AudioHandle)capture;
476 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureSelectScene(handle, nullptr));
477 }
478
479 HWTEST_F(AudioCaptureTest, AudioCaptureSelectSceneWhenDevCtlHandleIsNull, TestSize.Level1)
480 {
481 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
482 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
483 hwCapture->devCtlHandle = nullptr;
484 AudioHandle handle = (AudioHandle)hwCapture;
485 struct AudioSceneDescriptor *scene = new AudioSceneDescriptor;
486 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureSelectScene(handle, scene));
487 hwCapture->devCtlHandle = devCtlHandle;
488 delete(scene);
489 scene = nullptr;
490 }
491
492 HWTEST_F(AudioCaptureTest, AudioCaptureSelectSceneWhenDevCtlHandleIsError, TestSize.Level1)
493 {
494 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
495 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
496 struct HdfIoService *service = new HdfIoService;
497 hwCapture->devCtlHandle = (struct DevHandleCapture *)service;
498 AudioHandle handle = (AudioHandle)hwCapture;
499 struct AudioSceneDescriptor scene;
500 scene.scene.id = AUDIO_IN_MEDIA;
501 scene.desc.pins = PIN_IN_MIC;
502 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureSelectScene(handle, &scene));
503 hwCapture->devCtlHandle = devCtlHandle;
504 delete(service);
505 service = nullptr;
506 }
507
508 HWTEST_F(AudioCaptureTest, AudioCaptureSelectSceneWhenParamVaild, TestSize.Level1)
509 {
510 AudioHandle handle = (AudioHandle)capture;
511 struct AudioSceneDescriptor scene;
512 scene.scene.id = AUDIO_IN_MEDIA;
513 scene.desc.pins = PIN_IN_MIC;
514 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSelectScene(handle, &scene));
515 }
516
517 HWTEST_F(AudioCaptureTest, AudioCaptureSetMuteWhenHandleIsNull, TestSize.Level1)
518 {
519 bool mute = true;
520 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureSetMute(nullptr, mute));
521 }
522
523 HWTEST_F(AudioCaptureTest, AudioCaptureSetMuteWhenDevCtlHandleIsNull, TestSize.Level1)
524 {
525 AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
526 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
527 hwCapture->devCtlHandle = nullptr;
528 AudioHandle handle = (AudioHandle)hwCapture;
529 bool mute = true;
530 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureSetMute(handle, mute));
531 hwCapture->devCtlHandle = devCtlHandle;
532 }
533
534 HWTEST_F(AudioCaptureTest, AudioCaptureSetMuteWhenDevCtlHandleIsError, TestSize.Level1)
535 {
536 AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
537 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
538 struct HdfIoService *service = new HdfIoService;
539 hwCapture->devCtlHandle = (struct DevHandleCapture *)service;
540 AudioHandle handle = (AudioHandle)hwCapture;
541 bool mute = true;
542 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureSetMute(handle, mute));
543 hwCapture->devCtlHandle = devCtlHandle;
544 delete(service);
545 service = nullptr;
546 }
547
548 HWTEST_F(AudioCaptureTest, AudioCaptureSetMuteWhenParamVaild, TestSize.Level1)
549 {
550 AudioHandle handle = (AudioHandle)capture;
551 bool mute = true;
552 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSetMute(handle, mute));
553 }
554
555 HWTEST_F(AudioCaptureTest, AudioCaptureGetMuteWhenHandleIsNull, TestSize.Level1)
556 {
557 AudioHwCapture *hwCapture = nullptr;
558 AudioHandle handle = (AudioHandle)hwCapture;
559 bool mute = false;
560 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetMute(handle, &mute));
561 }
562
563 HWTEST_F(AudioCaptureTest, AudioCaptureGetMuteWhenMuteIsNull, TestSize.Level1)
564 {
565 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetMute((AudioHandle)capture, nullptr));
566 }
567
568 HWTEST_F(AudioCaptureTest, AudioCaptureGetMuteWhenDevCtlHandleIsNull, TestSize.Level1)
569 {
570 AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
571 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
572 hwCapture->devCtlHandle = nullptr;
573 AudioHandle handle = (AudioHandle)hwCapture;
574 bool mute = false;
575 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetMute(handle, &mute));
576 hwCapture->devCtlHandle = devCtlHandle;
577 }
578
579 HWTEST_F(AudioCaptureTest, AudioCaptureGetMuteWhenDevCtlHandleIsError, TestSize.Level1)
580 {
581 AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
582 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
583 struct HdfIoService *service = new HdfIoService;
584 hwCapture->devCtlHandle = (struct DevHandleCapture *)service;
585 AudioHandle handle = (AudioHandle)hwCapture;
586 bool mute = false;
587 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetMute(handle, &mute));
588 hwCapture->devCtlHandle = devCtlHandle;
589 delete(service);
590 service = nullptr;
591 }
592
593 HWTEST_F(AudioCaptureTest, AudioCaptureGetMuteWhenParamVaild, TestSize.Level1)
594 {
595 bool mute = false;
596 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureGetMute((AudioHandle)capture, &mute));
597 }
598
599 HWTEST_F(AudioCaptureTest, AudioCaptureSetVolumeWhenHandleIsNull, TestSize.Level1)
600 {
601 float volume = 0;
602 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureSetVolume(nullptr, volume));
603 }
604
605 HWTEST_F(AudioCaptureTest, AudioCaptureSetVolumeWhenDevCtlHandleIsNull, TestSize.Level1)
606 {
607 AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
608 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
609 hwCapture->devCtlHandle = nullptr;
610 AudioHandle handle = (AudioHandle)hwCapture;
611 float volume = 0;
612 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureSetVolume(handle, volume));
613 hwCapture->devCtlHandle = devCtlHandle;
614 }
615
616 HWTEST_F(AudioCaptureTest, AudioCaptureSetVolumeWhenVolumeLessThanZero, TestSize.Level1)
617 {
618 float volume = -1;
619 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureSetVolume((AudioHandle)capture, volume));
620 }
621
622 HWTEST_F(AudioCaptureTest, AudioCaptureSetVolumeWhenHandleIsError, TestSize.Level1)
623 {
624 AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
625 hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMax = 0;
626 hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMin = 1;
627 AudioHandle handle = (AudioHandle)capture;
628 float volume = 0;
629 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureSetVolume(handle, volume));
630 }
631
632 HWTEST_F(AudioCaptureTest, AudioCaptureSetVolumeWhenDevCtlHandleIsError, TestSize.Level1)
633 {
634 AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
635 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
636 struct HdfIoService *service = new HdfIoService;
637 hwCapture->devCtlHandle = (struct DevHandleCapture *)service;
638 AudioHandle handle = (AudioHandle)hwCapture;
639 float volume = 0;
640 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureSetVolume(handle, volume));
641 hwCapture->devCtlHandle = devCtlHandle;
642 delete(service);
643 service = nullptr;
644 }
645
646 HWTEST_F(AudioCaptureTest, AudioCaptureSetVolumeWhenParamVaild, TestSize.Level1)
647 {
648 float volume = 0;
649 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSetVolume((AudioHandle)capture, volume));
650 }
651
652 HWTEST_F(AudioCaptureTest, AudioCaptureGetVolumeWhenHandleIsNull, TestSize.Level1)
653 {
654 float volume = 0;
655 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetVolume(nullptr, &volume));
656 }
657
658 HWTEST_F(AudioCaptureTest, AudioCaptureGetVolumeWhenVolumeIsNull, TestSize.Level1)
659 {
660 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetVolume((AudioHandle)capture, nullptr));
661 }
662
663 HWTEST_F(AudioCaptureTest, AudioCaptureGetVolumeWhenDevCtlHandleIsNull, TestSize.Level1)
664 {
665 AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
666 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
667 hwCapture->devCtlHandle = nullptr;
668 AudioHandle handle = (AudioHandle)hwCapture;
669 float volume = 0;
670 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetVolume(handle, &volume));
671 hwCapture->devCtlHandle = devCtlHandle;
672 }
673
674 HWTEST_F(AudioCaptureTest, AudioCaptureGetVolumeWhenDevCtlHandleIsError, TestSize.Level1)
675 {
676 AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
677 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
678 struct HdfIoService *service = new HdfIoService;
679 hwCapture->devCtlHandle = (struct DevHandleCapture *)service;
680 AudioHandle handle = (AudioHandle)hwCapture;
681 float volume = 0;
682 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetVolume(handle, &volume));
683 hwCapture->devCtlHandle = devCtlHandle;
684 delete(service);
685 service = nullptr;
686 }
687
688 HWTEST_F(AudioCaptureTest, AudioCaptureGetVolumeWhenVolumeIsError, TestSize.Level1)
689 {
690 AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
691 hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMax = 1;
692 hwCapture->captureParam.captureMode.ctlParam.volThreshold.volMin = 1;
693 AudioHandle handle = (AudioHandle)capture;
694 float volume = 0;
695 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetVolume(handle, &volume));
696 }
697
698 HWTEST_F(AudioCaptureTest, AudioCaptureGetVolumeWhenParamVaild, TestSize.Level1)
699 {
700 float volume = 0;
701 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureGetVolume((AudioHandle)capture, &volume));
702 }
703
704 HWTEST_F(AudioCaptureTest, AudioCaptureGetGainThresholdWhenCaptureIsNull, TestSize.Level1)
705 {
706 float min = GAIN_MIN;
707 float max = GAIN_MAX;
708 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetGainThreshold(nullptr, &min, &max));
709 }
710
711 HWTEST_F(AudioCaptureTest, AudioCaptureGetGainThresholdWhenMinIsNull, TestSize.Level1)
712 {
713 float *min = nullptr;
714 float max = GAIN_MAX;
715 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetGainThreshold((AudioHandle)capture, min, &max));
716 }
717
718 HWTEST_F(AudioCaptureTest, AudioCaptureGetGainThresholdWhenMaxIsNull, TestSize.Level1)
719 {
720 float min = GAIN_MIN;
721 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetGainThreshold((AudioHandle)capture, &min, nullptr));
722 }
723
724 HWTEST_F(AudioCaptureTest, AudioCaptureGetGainThresholdWhenDevCtlHandleIsNull, TestSize.Level1)
725 {
726 AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
727 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
728 hwCapture->devCtlHandle = nullptr;
729 AudioHandle handle = (AudioHandle)hwCapture;
730 float min = GAIN_MIN;
731 float max = GAIN_MAX;
732 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetGainThreshold(handle, &min, &max));
733 hwCapture->devCtlHandle = devCtlHandle;
734 }
735
736 HWTEST_F(AudioCaptureTest, AudioCaptureGetGainThresholdWhenDevCtlHandleIsError, TestSize.Level1)
737 {
738 AudioHwCapture *hwCapture = (AudioHwCapture *)capture;
739 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
740 struct HdfIoService *service = new HdfIoService;
741 hwCapture->devCtlHandle = (struct DevHandleCapture *)service;
742 AudioHandle handle = (AudioHandle)hwCapture;
743 float min = GAIN_MIN;
744 float max = GAIN_MAX;
745 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetGainThreshold(handle, &min, &max));
746 hwCapture->devCtlHandle = devCtlHandle;
747 delete(service);
748 service = nullptr;
749 }
750
751 HWTEST_F(AudioCaptureTest, AudioCaptureGetGainThresholdWhenParamVaild, TestSize.Level1)
752 {
753 float min = GAIN_MIN;
754 float max = GAIN_MAX;
755 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureGetGainThreshold((AudioHandle)capture, &min, &max));
756 }
757
758 HWTEST_F(AudioCaptureTest, AudioCaptureGetGainWhenHandleIsNull, TestSize.Level1)
759 {
760 float gain = 0;
761 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetGain(nullptr, &gain));
762 }
763
764 HWTEST_F(AudioCaptureTest, AudioCaptureGetGainWhenGainIsNull, TestSize.Level1)
765 {
766 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetGain((AudioHandle)capture, nullptr));
767 }
768
769 HWTEST_F(AudioCaptureTest, AudioCaptureGetGainWhenDevCtlHandleIsNull, TestSize.Level1)
770 {
771 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
772 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
773 hwCapture->devCtlHandle = nullptr;
774 AudioHandle handle = (AudioHandle)hwCapture;
775 float gain = 0;
776 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetGain(handle, &gain));
777 hwCapture->devCtlHandle = devCtlHandle;
778 }
779
780 HWTEST_F(AudioCaptureTest, AudioCaptureGetGainWhenDevCtlHandleIsError, TestSize.Level1)
781 {
782 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
783 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
784 struct HdfIoService *service = new HdfIoService;
785 hwCapture->devCtlHandle = (struct DevHandleCapture *)service;
786 AudioHandle handle = (AudioHandle)hwCapture;
787 float gain = 0;
788 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureGetGain(handle, &gain));
789 hwCapture->devCtlHandle = devCtlHandle;
790 delete(service);
791 service = nullptr;
792 }
793
794 HWTEST_F(AudioCaptureTest, AudioCaptureGetGainWhenParamVaild, TestSize.Level1)
795 {
796 float gain = 0;
797 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureGetGain((AudioHandle)capture, &gain));
798 }
799
800 HWTEST_F(AudioCaptureTest, AudioCaptureSetGainWhenHandleIsNull, TestSize.Level1)
801 {
802 float gain = 0;
803 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureSetGain(nullptr, gain));
804 }
805
806 HWTEST_F(AudioCaptureTest, AudioCaptureSetGainWhenGainIsLessThanZero, TestSize.Level1)
807 {
808 float gain = -1;
809 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureSetGain((AudioHandle)capture, gain));
810 }
811
812 HWTEST_F(AudioCaptureTest, AudioCaptureSetGainWhenDevCtlHandleIsNull, TestSize.Level1)
813 {
814 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
815 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
816 hwCapture->devCtlHandle = nullptr;
817 AudioHandle handle = (AudioHandle)hwCapture;
818 float gain = 0;
819 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureSetGain(handle, gain));
820 hwCapture->devCtlHandle = devCtlHandle;
821 }
822
823 HWTEST_F(AudioCaptureTest, AudioCaptureSetGainWhenDevCtlHandleIsError, TestSize.Level1)
824 {
825 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
826 struct DevHandleCapture *devCtlHandle = hwCapture->devCtlHandle;
827 struct HdfIoService *service = new HdfIoService;
828 hwCapture->devCtlHandle = (struct DevHandleCapture *)service;
829 AudioHandle handle = (AudioHandle)hwCapture;
830 float gain = 0;
831 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureSetGain(handle, gain));
832 hwCapture->devCtlHandle = devCtlHandle;
833 delete(service);
834 service = nullptr;
835 }
836
837 HWTEST_F(AudioCaptureTest, AudioCaptureSetGainWhenParamVaild, TestSize.Level1)
838 {
839 float gain = 0;
840 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureSetGain((AudioHandle)capture, gain));
841 }
842
843 HWTEST_F(AudioCaptureTest, AudioCaptureCaptureFrameWhenCaptureIsNull, TestSize.Level1)
844 {
845 void *frame = (void *)calloc(1, FRAME_DATA);
846 ASSERT_NE(nullptr, frame);
847 uint64_t requestBytes = FRAME_DATA;
848 uint64_t replyBytes;
849 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureCaptureFrame(nullptr, frame, requestBytes, &replyBytes));
850 free(frame);
851 frame = nullptr;
852 }
853
854 HWTEST_F(AudioCaptureTest, AudioCaptureCaptureFrameWhenFrameIsNull, TestSize.Level1)
855 {
856 uint64_t requestBytes = FRAME_DATA;
857 uint64_t replyBytes;
858 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureCaptureFrame(capture, nullptr, requestBytes, &replyBytes));
859 }
860
861 HWTEST_F(AudioCaptureTest, AudioCaptureCaptureFrameWhenReplyBytesIsNull, TestSize.Level1)
862 {
863 void *frame = (void *)calloc(1, FRAME_DATA);
864 ASSERT_NE(nullptr, frame);
865 uint64_t requestBytes = FRAME_DATA;
866 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureCaptureFrame(capture, frame, requestBytes, nullptr));
867 free(frame);
868 frame = nullptr;
869 }
870
871 HWTEST_F(AudioCaptureTest, AudioCaptureCaptureFrameWhenDevDataHandleIsNull, TestSize.Level1)
872 {
873 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart((AudioHandle)capture));
874 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
875 struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle;
876 hwCapture->devDataHandle = nullptr;
877 void *frame = (void *)calloc(1, FRAME_DATA);
878 ASSERT_NE(nullptr, frame);
879 uint64_t requestBytes = FRAME_DATA;
880 uint64_t replyBytes;
881 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureCaptureFrame(capture, frame, requestBytes, &replyBytes));
882 hwCapture->devDataHandle = devDataHandle;
883 free(frame);
884 frame = nullptr;
885 }
886
887 HWTEST_F(AudioCaptureTest, AudioCaptureCaptureFrameWhenDevDataHandleIsError, TestSize.Level1)
888 {
889 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart((AudioHandle)capture));
890 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
891 struct DevHandleCapture *devDataHandle = hwCapture->devDataHandle;
892 struct HdfIoService *service = new HdfIoService;
893 hwCapture->devDataHandle = (struct DevHandleCapture *)service;
894 void *frame = (void *)calloc(1, FRAME_DATA);
895 ASSERT_NE(nullptr, frame);
896 uint64_t requestBytes = FRAME_DATA;
897 uint64_t replyBytes;
898 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureCaptureFrame(capture, frame, requestBytes, &replyBytes));
899 hwCapture->devDataHandle = devDataHandle;
900 delete(service);
901 service = nullptr;
902 free(frame);
903 frame = nullptr;
904 }
905
906 HWTEST_F(AudioCaptureTest, AudioCaptureCaptureFrameWhenRequestBytesLessThanBufferSize, TestSize.Level1)
907 {
908 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart((AudioHandle)capture));
909 void *frame = (void *)calloc(1, FRAME_DATA);
910 ASSERT_NE(nullptr, frame);
911 uint64_t requestBytes = FRAME_DATA - 1;
912 uint64_t replyBytes;
913 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureCaptureFrame(capture, frame, requestBytes, &replyBytes));
914 free(frame);
915 frame = nullptr;
916 }
917
918 HWTEST_F(AudioCaptureTest, AudioCaptureCaptureFrameWhenSampleRateIsZero, TestSize.Level1)
919 {
920 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart((AudioHandle)capture));
921 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
922 hwCapture->captureParam.frameCaptureMode.attrs.sampleRate = 0;
923 void *frame = (void *)calloc(1, FRAME_DATA);
924 ASSERT_NE(nullptr, frame);
925 uint64_t requestBytes = FRAME_DATA;
926 uint64_t replyBytes;
927 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureCaptureFrame(capture, frame, requestBytes, &replyBytes));
928 free(frame);
929 frame = nullptr;
930 }
931
932 HWTEST_F(AudioCaptureTest, AudioCaptureCaptureFrameWhenParamIsVaild, TestSize.Level1)
933 {
934 ASSERT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart((AudioHandle)capture));
935 void *frame = (void *)calloc(1, FRAME_DATA);
936 ASSERT_NE(nullptr, frame);
937 uint64_t requestBytes = FRAME_DATA;
938 uint64_t replyBytes;
939 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureCaptureFrame(capture, frame, requestBytes, &replyBytes));
940 free(frame);
941 frame = nullptr;
942 }
943
944 HWTEST_F(AudioCaptureTest, AudioCaptureGetCapturePositionWhenCaptureIsNull, TestSize.Level1)
945 {
946 uint64_t frames = 1024;
947 struct AudioTimeStamp *time = new AudioTimeStamp;
948 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetCapturePosition(nullptr, &frames, time));
949 delete(time);
950 time = nullptr;
951 }
952
953 HWTEST_F(AudioCaptureTest, AudioCaptureGetCapturePositionWhenFramesIsNull, TestSize.Level1)
954 {
955 struct AudioTimeStamp *time = new AudioTimeStamp;
956 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetCapturePosition(capture, nullptr, time));
957 delete(time);
958 time = nullptr;
959 }
960
961 HWTEST_F(AudioCaptureTest, AudioCaptureGetCapturePositionWhenTimeIsNull, TestSize.Level1)
962 {
963 uint64_t frames = 1024;
964 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureGetCapturePosition(capture, &frames, nullptr));
965 }
966
967 HWTEST_F(AudioCaptureTest, AudioCaptureGetCapturePositionWhenParamIsVaild, TestSize.Level1)
968 {
969 uint64_t frames = 1024;
970 struct AudioTimeStamp *time = new AudioTimeStamp;
971 EXPECT_EQ(HDF_SUCCESS, AudioCaptureGetCapturePosition(capture, &frames, time));
972 delete(time);
973 time = nullptr;
974 }
975
976 HWTEST_F(AudioCaptureTest, AudioCaptureTurnStandbyModeWhenHandleIsNull, TestSize.Level1)
977 {
978 AudioHwCapture *hwCapture = nullptr;
979 AudioHandle handle = (AudioHandle)hwCapture;
980 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioCaptureTurnStandbyMode(handle));
981 }
982
983 HWTEST_F(AudioCaptureTest, AudioCaptureTurnStandbyModeWhenStopIsError, TestSize.Level1)
984 {
985 AudioHandle handle = (AudioHandle)capture;
986 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioCaptureTurnStandbyMode(handle));
987 }
988
989 HWTEST_F(AudioCaptureTest, AudioCaptureTurnStandbyModeWhenParamIsVaild, TestSize.Level1)
990 {
991 AudioHandle handle = (AudioHandle)capture;
992 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureStart(handle));
993 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioCaptureTurnStandbyMode(handle));
994 }
995 }
996