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 /**
17 * @addtogroup Audio
18 * @{
19 *
20 * @brief Defines audio-related APIs, including custom data types and functions for capture drivers function.
21 * accessing a driver adapter, and capturing audios.
22 *
23 * @since 1.0
24 * @version 1.0
25 */
26
27 /**
28 * @file audio_hdi_common.h
29 *
30 * @brief Declares APIs for operations related to the capturing audio adapter.
31 *
32 * @since 1.0
33 * @version 1.0
34 */
35
36 #include "audio_hdi_common.h"
37 #include "audio_hdicapture_control_test.h"
38
39 using namespace std;
40 using namespace testing::ext;
41 using namespace OHOS::Audio;
42
43 namespace {
44 const string ADAPTER_NAME_USB = "USB";
45
46 class AudioHdiCaptureControlTest : public testing::Test {
47 public:
48 static void SetUpTestCase(void);
49 static void TearDownTestCase(void);
50 void SetUp();
51 void TearDown();
52 static TestAudioManager *manager;
53 };
54
55 TestAudioManager *AudioHdiCaptureControlTest::manager = nullptr;
56
SetUpTestCase(void)57 void AudioHdiCaptureControlTest::SetUpTestCase(void)
58 {
59 manager = GetAudioManagerFuncs();
60 ASSERT_NE(nullptr, manager);
61 }
62
TearDownTestCase(void)63 void AudioHdiCaptureControlTest::TearDownTestCase(void) {}
64
SetUp(void)65 void AudioHdiCaptureControlTest::SetUp(void) {}
66
TearDown(void)67 void AudioHdiCaptureControlTest::TearDown(void) {}
68
69 /**
70 * @tc.name AudioCreateCapture_001
71 * @tc.desc Test AudioCreateCapture interface,Returns 0 if the AudioCapture object is created successfully
72 * @tc.type: FUNC
73 */
74 HWTEST_F(AudioHdiCaptureControlTest, AudioCreateCapture_001, TestSize.Level1)
75 {
76 int32_t ret = -1;
77 struct AudioAdapter *adapter = nullptr;
78 struct AudioCapture *capture = nullptr;
79
80 ASSERT_NE(nullptr, manager);
81 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
82 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
83 adapter->DestroyCapture(adapter, capture);
84 manager->UnloadAdapter(manager, adapter);
85 }
86 /**
87 * @tc.name AudioCreateCapture_002
88 * @tc.desc test AudioCreateCapture interface:
89 (1)service mode:Returns 0,if the AudioCapture object can be created successfully which was created
90 (2)passthrough mode: Returns -1,if the AudioCapture object can't be created which was created
91 * @tc.type: FUNC
92 */
93 HWTEST_F(AudioHdiCaptureControlTest, AudioCreateCapture_002, TestSize.Level1)
94 {
95 int32_t ret = -1;
96 struct AudioAdapter *adapter = nullptr;
97 struct AudioCapture *firstCapture = nullptr;
98 struct AudioCapture *secondCapture = nullptr;
99 struct AudioPort* audioPort = nullptr;
100 struct AudioSampleAttributes attrs = {};
101 struct AudioDeviceDescriptor DevDesc = {};
102
103 ASSERT_NE(nullptr, manager);
104 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
105 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
106 InitAttrs(attrs);
107 InitDevDesc(DevDesc, audioPort->portId, PIN_IN_MIC);
108 ret = adapter->CreateCapture(adapter, &DevDesc, &attrs, &firstCapture);
109 if (ret < 0) {
110 manager->UnloadAdapter(manager, adapter);
111 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
112 }
113 ret = adapter->CreateCapture(adapter, &DevDesc, &attrs, &secondCapture);
114 #if defined (AUDIO_ADM_SERVICE)
115 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
116 adapter->DestroyCapture(adapter, secondCapture);
117 #endif
118 #if defined (AUDIO_ADM_SO) || defined (__LITEOS__)
119 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
120 adapter->DestroyCapture(adapter, firstCapture);
121 #endif
122 manager->UnloadAdapter(manager, adapter);
123 }
124 /**
125 * @tc.name AudioCreateCapture_003
126 * @tc.desc test AudioCreateCapture interface,Returns 0 if the AudioCapture object can be created successfully
127 when AudioRender was created
128 * @tc.type: FUNC
129 */
130 HWTEST_F(AudioHdiCaptureControlTest, AudioCreateCapture_003, TestSize.Level1)
131 {
132 int32_t ret = -1;
133 struct AudioAdapter *adapter = nullptr;
134 struct AudioRender *render = nullptr;
135 struct AudioCapture *capture = nullptr;
136 struct AudioPort* audioPort = nullptr;
137 struct AudioSampleAttributes attrs = {};
138 struct AudioDeviceDescriptor renderDevDesc = {};
139 struct AudioDeviceDescriptor captureDevDesc = {};
140
141 ASSERT_NE(nullptr, manager);
142 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, audioPort);
143 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
144 InitAttrs(attrs);
145 InitDevDesc(renderDevDesc, audioPort->portId, PIN_OUT_SPEAKER);
146 InitDevDesc(captureDevDesc, audioPort->portId, PIN_IN_MIC);
147 ret = adapter->CreateRender(adapter, &renderDevDesc, &attrs, &render);
148 if (ret < 0) {
149 manager->UnloadAdapter(manager, adapter);
150 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
151 }
152 ret = adapter->CreateCapture(adapter, &captureDevDesc, &attrs, &capture);
153 if (ret < 0) {
154 adapter->DestroyRender(adapter, render);
155 manager->UnloadAdapter(manager, adapter);
156 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
157 }
158 adapter->DestroyRender(adapter, render);
159 adapter->DestroyCapture(adapter, capture);
160 manager->UnloadAdapter(manager, adapter);
161 }
162 /**
163 * @tc.name AudioCreateCapture_005
164 * @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter adapter is nullptr
165 * @tc.type: FUNC
166 */
167 HWTEST_F(AudioHdiCaptureControlTest, AudioCreateCapture_005, TestSize.Level1)
168 {
169 int32_t ret = -1;
170 struct AudioPort* capturePort = nullptr;
171 struct AudioDeviceDescriptor devDesc = {};
172 struct AudioSampleAttributes attrs = {};
173 struct AudioAdapter *adapter = nullptr;
174 struct AudioAdapter *adapterNull = nullptr;
175 struct AudioCapture *capture = nullptr;
176
177 ASSERT_NE(nullptr, manager);
178 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, capturePort);
179 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
180 InitAttrs(attrs);
181 ret = InitDevDesc(devDesc, capturePort->portId, PIN_IN_MIC);
182 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
183 ret = adapter->CreateCapture(adapterNull, &devDesc, &attrs, &capture);
184 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
185
186 manager->UnloadAdapter(manager, adapter);
187 }
188 /**
189 * @tc.name AudioCreateCapture_006
190 * @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter desc is nullptr
191 * @tc.type: FUNC
192 */
193 HWTEST_F(AudioHdiCaptureControlTest, AudioCreateCapture_006, TestSize.Level1)
194 {
195 int32_t ret = -1;
196 struct AudioPort* capturePort = nullptr;
197 struct AudioSampleAttributes attrs = {};
198 struct AudioDeviceDescriptor *devDesc = nullptr;
199 struct AudioAdapter *adapter = nullptr;
200 struct AudioCapture *capture = nullptr;
201
202 ASSERT_NE(nullptr, manager);
203 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, capturePort);
204 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
205 InitAttrs(attrs);
206 ret = adapter->CreateCapture(adapter, devDesc, &attrs, &capture);
207 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
208
209 manager->UnloadAdapter(manager, adapter);
210 }
211 /**
212 * @tc.name AudioCreateCapture_007
213 * @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter attrs is nullptr
214 * @tc.type: FUNC
215 */
216 HWTEST_F(AudioHdiCaptureControlTest, AudioCreateCapture_007, TestSize.Level1)
217 {
218 int32_t ret = -1;
219 struct AudioPort* capturePort = nullptr;
220 struct AudioDeviceDescriptor devDesc = {};
221 struct AudioSampleAttributes *attrs = nullptr;
222 struct AudioAdapter *adapter = nullptr;
223 struct AudioCapture *capture = nullptr;
224
225 ASSERT_NE(nullptr, manager);
226 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, capturePort);
227 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
228 ret = InitDevDesc(devDesc, capturePort->portId, PIN_IN_MIC);
229 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
230 ret = adapter->CreateCapture(adapter, &devDesc, attrs, &capture);
231 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
232
233 manager->UnloadAdapter(manager, adapter);
234 }
235 /**
236 * @tc.name AudioCreateCapture_008
237 * @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter capture is nullptr
238 * @tc.type: FUNC
239 */
240 HWTEST_F(AudioHdiCaptureControlTest, AudioCreateCapture_008, TestSize.Level1)
241 {
242 int32_t ret = -1;
243 struct AudioPort* capturePort = nullptr;
244 struct AudioDeviceDescriptor devDesc = {};
245 struct AudioSampleAttributes attrs = {};
246 struct AudioAdapter *adapter = nullptr;
247 struct AudioCapture **capture = nullptr;
248
249 ASSERT_NE(nullptr, manager);
250 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, capturePort);
251 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
252 InitAttrs(attrs);
253 ret = InitDevDesc(devDesc, capturePort->portId, PIN_IN_MIC);
254 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
255 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, capture);
256 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
257 manager->UnloadAdapter(manager, adapter);
258 }
259 /**
260 * @tc.name AudioCreateCapture_008
261 * @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter adapter which port type is PORT_OUT
262 * @tc.type: FUNC
263 */
264 HWTEST_F(AudioHdiCaptureControlTest, AudioCreateCapture_009, TestSize.Level1)
265 {
266 int32_t ret = -1;
267 struct AudioPort* capturePort = nullptr;
268 struct AudioDeviceDescriptor devDesc = {};
269 struct AudioSampleAttributes attrs = {};
270 struct AudioAdapter *adapter = nullptr;
271 struct AudioCapture *capture = nullptr;
272
273 ASSERT_NE(nullptr, manager);
274 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_OUT, &adapter, capturePort);
275 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
276 InitAttrs(attrs);
277 ret = InitDevDesc(devDesc, capturePort->portId, PIN_OUT_SPEAKER);
278 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
279 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &capture);
280 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
281 adapter->DestroyCapture(adapter, capture);
282 manager->UnloadAdapter(manager, adapter);
283 }
284 /**
285 * @tc.name AudioCreateCapture_010
286 * @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter desc which portID is not configured
287 * @tc.type: FUNC
288 */
289 HWTEST_F(AudioHdiCaptureControlTest, AudioCreateCapture_010, TestSize.Level1)
290 {
291 int32_t ret = -1;
292 struct AudioPort* capturePort = nullptr;
293 struct AudioDeviceDescriptor devDesc = {};
294 struct AudioSampleAttributes attrs = {};
295 uint32_t portID = 12;
296 struct AudioAdapter *adapter = nullptr;
297 struct AudioCapture *capture = nullptr;
298
299 ASSERT_NE(nullptr, manager);
300 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, capturePort);
301 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
302 InitAttrs(attrs);
303 ret = InitDevDesc(devDesc, portID, PIN_IN_MIC);
304 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
305 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &capture);
306 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
307 adapter->DestroyCapture(adapter, capture);
308 manager->UnloadAdapter(manager, adapter);
309 }
310 /**
311 * @tc.name AudioDestroyCapture_001
312 * @tc.desc Test AudioDestroyCapture interface,Returns 0 if the AudioCapture object is destroyed
313 * @tc.type: FUNC
314 */
315 HWTEST_F(AudioHdiCaptureControlTest, AudioDestroyCapture_001, TestSize.Level1)
316 {
317 int32_t ret = -1;
318 struct AudioAdapter *adapter = nullptr;
319 struct AudioCapture *capture = nullptr;
320
321 ASSERT_NE(nullptr, manager);
322 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
323 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
324 ret = adapter->DestroyCapture(adapter, capture);
325 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
326 manager->UnloadAdapter(manager, adapter);
327 }
328 /**
329 * @tc.name AudioDestroyCapture_002
330 * @tc.desc Test AudioDestroyCapture interface,Returns -1 if the incoming parameter adapter is nullptr
331 * @tc.type: FUNC
332 */
333 HWTEST_F(AudioHdiCaptureControlTest, AudioDestroyCapture_002, TestSize.Level1)
334 {
335 int32_t ret = -1;
336 struct AudioAdapter *adapter = nullptr;
337 struct AudioAdapter *adapterNull = nullptr;
338 struct AudioCapture *capture = nullptr;
339
340 ASSERT_NE(nullptr, manager);
341 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
342 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
343 ret = adapter->DestroyCapture(adapterNull, capture);
344 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
345 ret = adapter->DestroyCapture(adapter, capture);
346 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
347 manager->UnloadAdapter(manager, adapter);
348 }
349 /**
350 * @tc.name AudioDestroyCapture_003
351 * @tc.desc Test AudioDestroyCapture interface,Returns -1 if the incoming parameter capture is nullptr
352 * @tc.type: FUNC
353 */
354 HWTEST_F(AudioHdiCaptureControlTest, AudioDestroyCapture_003, TestSize.Level1)
355 {
356 int32_t ret = -1;
357 struct AudioPort* capturePort = nullptr;
358 struct AudioAdapter *adapter = nullptr;
359 struct AudioCapture *capture = nullptr;
360
361 ASSERT_NE(nullptr, manager);
362 ret = GetLoadAdapter(manager, PORT_IN, ADAPTER_NAME, &adapter, capturePort);
363 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
364 ret = adapter->DestroyCapture(adapter, capture);
365 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
366 manager->UnloadAdapter(manager, adapter);
367 }
368 /**
369 * @tc.name AudioStartCapture_001
370 * @tc.desc Test AudioCaptureStart interface,return 0 if the audiocapture object is started successfully
371 * @tc.type: FUNC
372 */
373 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureStart_001, TestSize.Level1)
374 {
375 int32_t ret = -1;
376 struct AudioAdapter *adapter = nullptr;
377 struct AudioCapture *capture = nullptr;
378
379 ASSERT_NE(nullptr, manager);
380 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
381 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
382 ret = capture->control.Start((AudioHandle)capture);
383 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
384
385 capture->control.Stop((AudioHandle)capture);
386 adapter->DestroyCapture(adapter, capture);
387 manager->UnloadAdapter(manager, adapter);
388 }
389 /**
390 * @tc.name AudioCaptureStart_002
391 * @tc.desc Test CaptureStart interface,return -1 if the incoming parameter handle is nullptr
392 * @tc.type: FUNC
393 */
394 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureStart_002, TestSize.Level1)
395 {
396 int32_t ret = -1;
397 struct AudioAdapter *adapter = nullptr;
398 struct AudioCapture *capture = nullptr;
399 struct AudioCapture *captureNull = nullptr;
400
401 ASSERT_NE(nullptr, manager);
402 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
403 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
404 ret = capture->control.Start((AudioHandle)captureNull);
405 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
406
407 capture->control.Stop((AudioHandle)capture);
408 adapter->DestroyCapture(adapter, capture);
409 manager->UnloadAdapter(manager, adapter);
410 }
411 /**
412 * @tc.name AudioCaptureStart_003
413 * @tc.desc Test AudioCaptureStart interface,return 0 if the Audiocapturestart was successfully called twice
414 * @tc.type: FUNC
415 */
416 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureStart_003, TestSize.Level1)
417 {
418 int32_t ret = -1;
419 struct AudioAdapter *adapter = nullptr;
420 struct AudioCapture *capture = nullptr;
421
422 ASSERT_NE(nullptr, manager);
423 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
424 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
425 ret = capture->control.Start((AudioHandle)capture);
426 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
427 ret = capture->control.Start((AudioHandle)capture);
428 EXPECT_EQ(AUDIO_HAL_ERR_AI_BUSY, ret);
429
430 capture->control.Stop((AudioHandle)capture);
431 adapter->DestroyCapture(adapter, capture);
432 manager->UnloadAdapter(manager, adapter);
433 }
434 /**
435 * @tc.name AudioCaptureStop_001
436 * @tc.desc Test AudioCaptureStop interface,return 0 if the audiocapture object is stopped successfully
437 * @tc.type: FUNC
438 */
439 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureStop_001, TestSize.Level1)
440 {
441 int32_t ret = -1;
442 struct AudioAdapter *adapter = nullptr;
443 struct AudioCapture *capture = nullptr;
444
445 ASSERT_NE(nullptr, manager);
446 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
447 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
448 ret = capture->control.Stop((AudioHandle)capture);
449 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
450
451 adapter->DestroyCapture(adapter, capture);
452 manager->UnloadAdapter(manager, adapter);
453 }
454 /**
455 * @tc.name AudioCaptureStop_002
456 * @tc.desc Test AudioCaptureStop interface,return -4 if Audiocapturestop was successfully called twice
457 * @tc.type: FUNC
458 */
459 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureStop_002, TestSize.Level1)
460 {
461 int32_t ret = -1;
462 struct AudioAdapter *adapter = nullptr;
463 struct AudioCapture *capture = nullptr;
464
465 ASSERT_NE(nullptr, manager);
466 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
467 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
468 ret = capture->control.Stop((AudioHandle)capture);
469 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
470 ret = capture->control.Stop((AudioHandle)capture);
471 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
472
473 adapter->DestroyCapture(adapter, capture);
474 manager->UnloadAdapter(manager, adapter);
475 }
476 /**
477 * @tc.name AudioCaptureStop_003
478 * @tc.desc Test AudioCaptureStop interface,return 0 if stop and start an audio capture successfully
479 * @tc.type: FUNC
480 */
481 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureStop_003, TestSize.Level1)
482 {
483 int32_t ret = -1;
484 struct AudioAdapter *adapter = nullptr;
485 struct AudioCapture *capture = nullptr;
486
487 ASSERT_NE(nullptr, manager);
488 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
489 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
490 ret = capture->control.Stop((AudioHandle)capture);
491 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
492 ret = capture->control.Start((AudioHandle)capture);
493 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
494
495 capture->control.Stop((AudioHandle)capture);
496 adapter->DestroyCapture(adapter, capture);
497 manager->UnloadAdapter(manager, adapter);
498 }
499 /**
500 * @tc.name AudioCaptureStop_004
501 * @tc.desc Test AudioCaptureStop interface,return -4 if the capture does not start and stop only
502 * @tc.type: FUNC
503 */
504 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureStop_004, TestSize.Level1)
505 {
506 int32_t ret = -1;
507 struct AudioAdapter *adapter = nullptr;
508 struct AudioCapture *capture = nullptr;
509
510 ASSERT_NE(nullptr, manager);
511 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
512 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
513 ret = capture->control.Stop((AudioHandle)capture);
514 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
515
516 adapter->DestroyCapture(adapter, capture);
517 manager->UnloadAdapter(manager, adapter);
518 }
519 /**
520 * @tc.name AudioCaptureStop_005
521 * @tc.desc Test CaptureStop interface, return -1 if the incoming parameter handle is nullptr
522 * @tc.type: FUNC
523 */
524 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureStop_005, TestSize.Level1)
525 {
526 int32_t ret = -1;
527 struct AudioAdapter *adapter = nullptr;
528 struct AudioCapture *capture = nullptr;
529 struct AudioCapture *captureNull = nullptr;
530
531 ASSERT_NE(nullptr, manager);
532 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
533 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
534 ret = capture->control.Stop((AudioHandle)captureNull);
535 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
536
537 adapter->DestroyCapture(adapter, capture);
538 manager->UnloadAdapter(manager, adapter);
539 }
540 /**
541 * @tc.name AudioCapturePause_001
542 * @tc.desc test HDI CapturePause interface，return 0 if the capture is paused after start
543 * @tc.type: FUNC
544 */
545 HWTEST_F(AudioHdiCaptureControlTest, AudioCapturePause_001, TestSize.Level1)
546 {
547 int32_t ret = -1;
548 struct AudioAdapter *adapter = nullptr;
549 struct AudioCapture *capture = nullptr;
550
551 ASSERT_NE(nullptr, manager);
552 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
553 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
554 ret = capture->control.Pause((AudioHandle)capture);
555 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
556
557 ret = capture->control.Stop((AudioHandle)capture);
558 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
559 adapter->DestroyCapture(adapter, capture);
560 manager->UnloadAdapter(manager, adapter);
561 }
562 /**
563 * @tc.name AudioCapturePause_002
564 * @tc.desc Test CapturePause interface, return -1 the second time if CapturePause is called twice
565 * @tc.type: FUNC
566 */
567 HWTEST_F(AudioHdiCaptureControlTest, AudioCapturePause_002, TestSize.Level1)
568 {
569 int32_t ret = -1;
570 struct AudioAdapter *adapter = nullptr;
571 struct AudioCapture *capture = nullptr;
572
573 ASSERT_NE(nullptr, manager);
574 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
575 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
576 ret = capture->control.Pause((AudioHandle)capture);
577 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
578 ret = capture->control.Pause((AudioHandle)capture);
579 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
580
581 ret = capture->control.Stop((AudioHandle)capture);
582 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
583 adapter->DestroyCapture(adapter, capture);
584 manager->UnloadAdapter(manager, adapter);
585 }
586 /**
587 * @tc.name AudioCapturePause_003
588 * @tc.desc Test CapturePause interface,return -1 if the incoming parameter handle is nullptr
589 * @tc.type: FUNC
590 */
591 HWTEST_F(AudioHdiCaptureControlTest, AudioCapturePause_003, TestSize.Level1)
592 {
593 int32_t ret = -1;
594 struct AudioAdapter *adapter = nullptr;
595 struct AudioCapture *capture = nullptr;
596 struct AudioCapture *captureNull = nullptr;
597
598 ASSERT_NE(nullptr, manager);
599 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
600 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
601 ret = capture->control.Pause((AudioHandle)captureNull);
602 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
603
604 ret = capture->control.Stop((AudioHandle)capture);
605 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
606 adapter->DestroyCapture(adapter, capture);
607 manager->UnloadAdapter(manager, adapter);
608 }
609 /**
610 * @tc.name AudioCapturePause_004
611 * @tc.desc Test AudioRenderPause interface,return -1 if the capture is not Started and paused only.
612 * @tc.type: FUNC
613 */
614 HWTEST_F(AudioHdiCaptureControlTest, AudioCapturePause_004, TestSize.Level1)
615 {
616 int32_t ret = -1;
617 struct AudioAdapter *adapter = nullptr;
618 struct AudioCapture *capture = nullptr;
619
620 ASSERT_NE(nullptr, manager);
621 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
622 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
623 ret = capture->control.Pause((AudioHandle)capture);
624 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
625
626 adapter->DestroyCapture(adapter, capture);
627 manager->UnloadAdapter(manager, adapter);
628 }
629 /**
630 * @tc.name AudioCapturePause_005
631 * @tc.desc Test CapturePause interface, return -1 the capture is paused after stopped.
632 * @tc.type: FUNC
633 */
634 HWTEST_F(AudioHdiCaptureControlTest, AudioCapturePause_005, TestSize.Level1)
635 {
636 int32_t ret = -1;
637 struct AudioAdapter *adapter = nullptr;
638 struct AudioCapture *capture = nullptr;
639 ASSERT_NE(nullptr, manager);
640
641 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
642 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
643 ret = capture->control.Stop((AudioHandle)capture);
644 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
645 ret = capture->control.Pause((AudioHandle)capture);
646 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
647
648 adapter->DestroyCapture(adapter, capture);
649 manager->UnloadAdapter(manager, adapter);
650 }
651 /**
652 * @tc.name AudioCaptureResume_001
653 * @tc.desc Test CaptureResume interface,return 0 if the capture is resumed after paused
654 * @tc.type: FUNC
655 */
656 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureResume_001, TestSize.Level1)
657 {
658 int32_t ret = -1;
659 struct AudioAdapter *adapter = nullptr;
660 struct AudioCapture *capture = nullptr;
661
662 ASSERT_NE(nullptr, manager);
663 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
664 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
665 ret = capture->control.Pause((AudioHandle)capture);
666 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
667 ret = capture->control.Resume((AudioHandle)capture);
668 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
669 ret = capture->control.Stop((AudioHandle)capture);
670 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
671 adapter->DestroyCapture(adapter, capture);
672 manager->UnloadAdapter(manager, adapter);
673 }
674 /**
675 * @tc.name AudioCaptureResume_002
676 * @tc.desc Test CaptureResume interface,return -1 the second time if the CaptureResume is called twice
677 * @tc.type: FUNC
678 */
679 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureResume_002, TestSize.Level1)
680 {
681 int32_t ret = -1;
682 struct AudioAdapter *adapter = nullptr;
683 struct AudioCapture *capture = nullptr;
684
685 ASSERT_NE(nullptr, manager);
686 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
687 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
688 ret = capture->control.Pause((AudioHandle)capture);
689 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
690 ret = capture->control.Resume((AudioHandle)capture);
691 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
692 ret = capture->control.Resume((AudioHandle)capture);
693 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
694
695 ret = capture->control.Stop((AudioHandle)capture);
696 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
697 adapter->DestroyCapture(adapter, capture);
698 manager->UnloadAdapter(manager, adapter);
699 }
700
701 /**
702 * @tc.name AudioCaptureResume_003
703 * @tc.desc test HDI CaptureResume interface,return -1 if the capture is resumed after started
704 * @tc.type: FUNC
705 */
706 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureResume_003, TestSize.Level1)
707 {
708 int32_t ret = -1;
709 struct AudioAdapter *adapter = nullptr;
710 struct AudioCapture *capture = nullptr;
711
712 ASSERT_NE(nullptr, manager);
713 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
714 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
715 ret = capture->control.Resume((AudioHandle)capture);
716 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
717
718 ret = capture->control.Stop((AudioHandle)capture);
719 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
720 adapter->DestroyCapture(adapter, capture);
721 manager->UnloadAdapter(manager, adapter);
722 }
723 /**
724 * @tc.name AudioCaptureResume_004
725 * @tc.desc Test CaptureResume interface, return -1 if the incoming parameter handle is nullptr
726 * @tc.type: FUNC
727 */
728 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureResume_004, TestSize.Level1)
729 {
730 int32_t ret = -1;
731 struct AudioAdapter *adapter = nullptr;
732 struct AudioCapture *capture = nullptr;
733 struct AudioCapture *captureNull = nullptr;
734
735 ASSERT_NE(nullptr, manager);
736 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
737 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
738 ret = capture->control.Pause((AudioHandle)capture);
739 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
740 ret = capture->control.Resume((AudioHandle)captureNull);
741 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
742
743 ret = capture->control.Stop((AudioHandle)capture);
744 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
745 adapter->DestroyCapture(adapter, capture);
746 manager->UnloadAdapter(manager, adapter);
747 }
748 /**
749 * @tc.name AudioCaptureResume_005
750 * @tc.desc test HDI CaptureResume interface,return -1 if the capture is resumed after stopped
751 * @tc.type: FUNC
752 */
753 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureResume_005, TestSize.Level1)
754 {
755 int32_t ret = -1;
756 struct AudioAdapter *adapter = nullptr;
757 struct AudioCapture *capture = nullptr;
758
759 ASSERT_NE(nullptr, manager);
760 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
761 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
762 ret = capture->control.Stop((AudioHandle)capture);
763 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
764 ret = capture->control.Resume((AudioHandle)capture);
765 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
766
767 adapter->DestroyCapture(adapter, capture);
768 manager->UnloadAdapter(manager, adapter);
769 }
770 /**
771 * @tc.name AudioCaptureResume_006
772 * @tc.desc test HDI CaptureResume interface,return -1 if the capture Continue to start after resume
773 * @tc.type: FUNC
774 */
775 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureResume_006, TestSize.Level1)
776 {
777 int32_t ret = -1;
778 struct AudioAdapter *adapter = nullptr;
779 struct AudioCapture *capture = nullptr;
780
781 ASSERT_NE(nullptr, manager);
782 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
783 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
784 ret = capture->control.Pause((AudioHandle)capture);
785 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
786 ret = capture->control.Resume((AudioHandle)capture);
787 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
788 ret = capture->control.Start((AudioHandle)capture);
789 EXPECT_EQ(AUDIO_HAL_ERR_AI_BUSY, ret);
790
791 capture->control.Stop((AudioHandle)capture);
792 adapter->DestroyCapture(adapter, capture);
793 manager->UnloadAdapter(manager, adapter);
794 }
795 /**
796 * @tc.name AudioCaptureResume_007
797 * @tc.desc test HDI CaptureResume interface,return 0 if the different objects is started、paused、resumed and stopped.
798 * @tc.type: FUNC
799 */
800 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureResume_007, TestSize.Level1)
801 {
802 int32_t ret1 = -1;
803 int32_t ret2 = -1;
804 struct AudioAdapter *adapterOne = nullptr;
805 struct AudioAdapter *adapterSec = nullptr;
806 struct AudioCapture *captureOne = nullptr;
807 struct AudioCapture *captureSec = nullptr;
808 ASSERT_NE(nullptr, manager);
809 ret1 = AudioCreateStartCapture(manager, &captureOne, &adapterOne, ADAPTER_NAME);
810 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret1);
811 ret1 = captureOne->control.Pause((AudioHandle)captureOne);
812 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret1);
813 ret1 = captureOne->control.Resume((AudioHandle)captureOne);
814 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret1);
815 ret1 = captureOne->control.Stop((AudioHandle)captureOne);
816 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret1);
817 adapterOne->DestroyCapture(adapterOne, captureOne);
818 manager->UnloadAdapter(manager, adapterOne);
819 ret2 = AudioCreateStartCapture(manager, &captureSec, &adapterSec, ADAPTER_NAME);
820 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret2);
821 ret2 = captureSec->control.Pause((AudioHandle)captureSec);
822 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret2);
823 ret2 = captureSec->control.Resume((AudioHandle)captureSec);
824 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret2);
825 ret2 = captureSec->control.Stop((AudioHandle)captureSec);
826 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret2);
827 adapterSec->DestroyCapture(adapterSec, captureSec);
828 manager->UnloadAdapter(manager, adapterSec);
829 }
830 /**
831 * @tc.name AudioCaptureFlush_001
832 * @tc.desc Test CaptureFlush interface,return -2 if the data in the buffer is flushed successfully after stop
833 * @tc.type: FUNC
834 */
835 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureFlush_001, TestSize.Level1)
836 {
837 int32_t ret = -1;
838 struct AudioAdapter *adapter = nullptr;
839 struct AudioCapture *capture = nullptr;
840
841 ASSERT_NE(nullptr, manager);
842 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
843 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
844 ret = capture->control.Stop((AudioHandle)capture);
845 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
846 ret = capture->control.Flush((AudioHandle)capture);
847 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
848
849 adapter->DestroyCapture(adapter, capture);
850 manager->UnloadAdapter(manager, adapter);
851 }
852 /**
853 * @tc.name AudioCaptureFlush_002
854 * @tc.desc Test CaptureFlush, return -1 if the data in the buffer is flushed when handle is nullptr
855 * @tc.type: FUNC
856 */
857 HWTEST_F(AudioHdiCaptureControlTest, AudioCaptureFlush_002, TestSize.Level1)
858 {
859 int32_t ret = -1;
860 struct AudioAdapter *adapter = nullptr;
861 struct AudioCapture *capture = nullptr;
862 struct AudioCapture *captureNull = nullptr;
863
864 ASSERT_NE(nullptr, manager);
865 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
866 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
867 ret = capture->control.Stop((AudioHandle)capture);
868 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
869 ret = capture->control.Flush((AudioHandle)captureNull);
870 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
871
872 adapter->DestroyCapture(adapter, capture);
873 manager->UnloadAdapter(manager, adapter);
874 }
875 }
876