1 /*
2 * Copyright (c) 2022 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 Test audio-related APIs, including custom data types and functions for loading drivers,
21 * accessing a driver adapter.
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 audio adapter.
31 *
32 * @since 1.0
33 * @version 1.0
34 */
35
36 #include "audio_hdi_common.h"
37 #include "audio_usb_caputer_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 const int BUFFER_SIZE = 16384;
46 const uint64_t FILESIZE = 1024;
47
48 class AudioUsbCaputerTest : public testing::Test {
49 public:
50 static void SetUpTestCase(void);
51 static void TearDownTestCase(void);
52 void SetUp();
53 void TearDown();
54 static TestAudioManager *manager;
55 };
56
57 using THREAD_FUNC = void *(*)(void *);
58 TestAudioManager *AudioUsbCaputerTest::manager = nullptr;
59
SetUpTestCase(void)60 void AudioUsbCaputerTest::SetUpTestCase(void)
61 {
62 manager = GetAudioManagerFuncs();
63 ASSERT_NE(nullptr, manager);
64 }
65
TearDownTestCase(void)66 void AudioUsbCaputerTest::TearDownTestCase(void) {}
67
SetUp(void)68 void AudioUsbCaputerTest::SetUp(void) {}
69
TearDown(void)70 void AudioUsbCaputerTest::TearDown(void) {}
71
72 /**
73 * @tc.name AudioStartCapture_001
74 * @tc.desc Test AudioCaptureStart interface,return 0 if the audiocapture object is started successfully
75 * @tc.type: FUNC
76 */
77 HWTEST_F(AudioUsbCaputerTest, AudioCaptureStart_001, TestSize.Level1)
78 {
79 int32_t ret = -1;
80 struct AudioAdapter *adapter = nullptr;
81 struct AudioCapture *capture = nullptr;
82
83 ASSERT_NE(nullptr, manager);
84 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
85 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
86 ret = capture->control.Start((AudioHandle)capture);
87 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
88
89 ret = capture->control.Pause((AudioHandle)capture);
90 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
91 ret = capture->control.Resume((AudioHandle)capture);
92 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
93 ret = capture->control.Stop((AudioHandle)capture);
94 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
95 adapter->DestroyCapture(adapter, capture);
96 manager->UnloadAdapter(manager, adapter);
97 }
98 /**
99 * @tc.name AudioCaptureStart_003
100 * @tc.desc Test AudioCaptureStart interface,return 0 if the Audiocapturestart was successfully called twice
101 * @tc.type: FUNC
102 */
103 HWTEST_F(AudioUsbCaputerTest, AudioCaptureStart_003, TestSize.Level1)
104 {
105 int32_t ret = -1;
106 struct AudioAdapter *adapter = nullptr;
107 struct AudioCapture *capture = nullptr;
108
109 ASSERT_NE(nullptr, manager);
110 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
111 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
112 ret = capture->control.Start((AudioHandle)capture);
113 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
114 ret = capture->control.Start((AudioHandle)capture);
115 EXPECT_EQ(AUDIO_HAL_ERR_AI_BUSY, ret);
116
117 capture->control.Stop((AudioHandle)capture);
118 adapter->DestroyCapture(adapter, capture);
119 manager->UnloadAdapter(manager, adapter);
120 }
121 /**
122 * @tc.name AudioCaptureStop_001
123 * @tc.desc Test AudioCaptureStop interface,return 0 if the audiocapture object is stopped successfully
124 * @tc.type: FUNC
125 */
126 HWTEST_F(AudioUsbCaputerTest, AudioCaptureStop_001, TestSize.Level1)
127 {
128 int32_t ret = -1;
129 struct AudioAdapter *adapter = nullptr;
130 struct AudioCapture *capture = nullptr;
131
132 ASSERT_NE(nullptr, manager);
133 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
134 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
135 ret = capture->control.Stop((AudioHandle)capture);
136 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
137
138 adapter->DestroyCapture(adapter, capture);
139 manager->UnloadAdapter(manager, adapter);
140 }
141 /**
142 * @tc.name AudioCaptureStop_002
143 * @tc.desc Test AudioCaptureStop interface,return -4 if Audiocapturestop was successfully called twice
144 * @tc.type: FUNC
145 */
146 HWTEST_F(AudioUsbCaputerTest, AudioCaptureStop_002, TestSize.Level1)
147 {
148 int32_t ret = -1;
149 struct AudioAdapter *adapter = nullptr;
150 struct AudioCapture *capture = nullptr;
151
152 ASSERT_NE(nullptr, manager);
153 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
154 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
155 ret = capture->control.Stop((AudioHandle)capture);
156 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
157 ret = capture->control.Stop((AudioHandle)capture);
158 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
159
160 adapter->DestroyCapture(adapter, capture);
161 manager->UnloadAdapter(manager, adapter);
162 }
163 /**
164 * @tc.name AudioCaptureStop_003
165 * @tc.desc Test AudioCaptureStop interface,return 0 if stop and start an audio capture successfully
166 * @tc.type: FUNC
167 */
168 HWTEST_F(AudioUsbCaputerTest, AudioCaptureStop_003, TestSize.Level1)
169 {
170 int32_t ret = -1;
171 struct AudioAdapter *adapter = nullptr;
172 struct AudioCapture *capture = nullptr;
173
174 ASSERT_NE(nullptr, manager);
175 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
176 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
177 ret = capture->control.Stop((AudioHandle)capture);
178 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
179 ret = capture->control.Start((AudioHandle)capture);
180 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
181
182 capture->control.Stop((AudioHandle)capture);
183 adapter->DestroyCapture(adapter, capture);
184 manager->UnloadAdapter(manager, adapter);
185 }
186 /**
187 * @tc.name AudioCaptureStop_004
188 * @tc.desc Test AudioCaptureStop interface,return -4 if the capture does not start and stop only
189 * @tc.type: FUNC
190 */
191 HWTEST_F(AudioUsbCaputerTest, AudioCaptureStop_004, TestSize.Level1)
192 {
193 int32_t ret = -1;
194 struct AudioAdapter *adapter = nullptr;
195 struct AudioCapture *capture = nullptr;
196
197 ASSERT_NE(nullptr, manager);
198 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
199 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
200 ret = capture->control.Stop((AudioHandle)capture);
201 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
202
203 adapter->DestroyCapture(adapter, capture);
204 manager->UnloadAdapter(manager, adapter);
205 }
206 /**
207 * @tc.name AudioCapturePause_001
208 * @tc.desc test HDI CapturePause interface，return 0 if the capture is paused after start
209 * @tc.type: FUNC
210 */
211 HWTEST_F(AudioUsbCaputerTest, AudioCapturePause_001, TestSize.Level1)
212 {
213 int32_t ret = -1;
214 struct AudioAdapter *adapter = nullptr;
215 struct AudioCapture *capture = nullptr;
216
217 ASSERT_NE(nullptr, manager);
218 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
219 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
220 ret = capture->control.Pause((AudioHandle)capture);
221 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
222
223 ret = capture->control.Stop((AudioHandle)capture);
224 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
225 adapter->DestroyCapture(adapter, capture);
226 manager->UnloadAdapter(manager, adapter);
227 }
228 /**
229 * @tc.name AudioCapturePause_002
230 * @tc.desc Test CapturePause interface, return -1 the second time if CapturePause is called twice
231 * @tc.type: FUNC
232 */
233 HWTEST_F(AudioUsbCaputerTest, AudioCapturePause_002, TestSize.Level1)
234 {
235 int32_t ret = -1;
236 struct AudioAdapter *adapter = nullptr;
237 struct AudioCapture *capture = nullptr;
238
239 ASSERT_NE(nullptr, manager);
240 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
241 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
242 ret = capture->control.Pause((AudioHandle)capture);
243 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
244 ret = capture->control.Pause((AudioHandle)capture);
245 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
246
247 ret = capture->control.Stop((AudioHandle)capture);
248 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
249 adapter->DestroyCapture(adapter, capture);
250 manager->UnloadAdapter(manager, adapter);
251 }
252 /**
253 * @tc.name AudioCapturePause_004
254 * @tc.desc Test AudioRenderPause interface,return -1 if the capture is not Started and paused only.
255 * @tc.type: FUNC
256 */
257 HWTEST_F(AudioUsbCaputerTest, AudioCapturePause_004, TestSize.Level1)
258 {
259 int32_t ret = -1;
260 struct AudioAdapter *adapter = nullptr;
261 struct AudioCapture *capture = nullptr;
262
263 ASSERT_NE(nullptr, manager);
264 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
265 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
266 ret = capture->control.Pause((AudioHandle)capture);
267 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
268
269 adapter->DestroyCapture(adapter, capture);
270 manager->UnloadAdapter(manager, adapter);
271 }
272 /**
273 * @tc.name AudioCapturePause_005
274 * @tc.desc Test CapturePause interface, return -1 the capture is paused after stopped.
275 * @tc.type: FUNC
276 */
277 HWTEST_F(AudioUsbCaputerTest, AudioCapturePause_005, TestSize.Level1)
278 {
279 int32_t ret = -1;
280 struct AudioAdapter *adapter = nullptr;
281 struct AudioCapture *capture = nullptr;
282 ASSERT_NE(nullptr, manager);
283
284 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
285 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
286 ret = capture->control.Stop((AudioHandle)capture);
287 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
288 ret = capture->control.Pause((AudioHandle)capture);
289 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
290
291 adapter->DestroyCapture(adapter, capture);
292 manager->UnloadAdapter(manager, adapter);
293 }
294 /**
295 * @tc.name AudioCaptureResume_001
296 * @tc.desc Test CaptureResume interface,return 0 if the capture is resumed after paused
297 * @tc.type: FUNC
298 */
299 HWTEST_F(AudioUsbCaputerTest, AudioCaptureResume_001, TestSize.Level1)
300 {
301 int32_t ret = -1;
302 struct AudioAdapter *adapter = nullptr;
303 struct AudioCapture *capture = nullptr;
304
305 ASSERT_NE(nullptr, manager);
306 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
307 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
308 ret = capture->control.Pause((AudioHandle)capture);
309 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
310 ret = capture->control.Resume((AudioHandle)capture);
311 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
312 ret = capture->control.Stop((AudioHandle)capture);
313 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
314 adapter->DestroyCapture(adapter, capture);
315 manager->UnloadAdapter(manager, adapter);
316 }
317 /**
318 * @tc.name AudioCaptureResume_002
319 * @tc.desc Test CaptureResume interface,return -1 the second time if the CaptureResume is called twice
320 * @tc.type: FUNC
321 */
322 HWTEST_F(AudioUsbCaputerTest, AudioCaptureResume_002, TestSize.Level1)
323 {
324 int32_t ret = -1;
325 struct AudioAdapter *adapter = nullptr;
326 struct AudioCapture *capture = nullptr;
327
328 ASSERT_NE(nullptr, manager);
329 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
330 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
331 ret = capture->control.Pause((AudioHandle)capture);
332 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
333 ret = capture->control.Resume((AudioHandle)capture);
334 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
335 ret = capture->control.Resume((AudioHandle)capture);
336 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
337
338 ret = capture->control.Stop((AudioHandle)capture);
339 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
340 adapter->DestroyCapture(adapter, capture);
341 manager->UnloadAdapter(manager, adapter);
342 }
343 /**
344 * @tc.name AudioCaptureResume_003
345 * @tc.desc test HDI CaptureResume interface,return -1 if the capture is resumed after started
346 * @tc.type: FUNC
347 */
348 HWTEST_F(AudioUsbCaputerTest, AudioCaptureResume_003, TestSize.Level1)
349 {
350 int32_t ret = -1;
351 struct AudioAdapter *adapter = nullptr;
352 struct AudioCapture *capture = nullptr;
353
354 ASSERT_NE(nullptr, manager);
355 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
356 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
357 ret = capture->control.Resume((AudioHandle)capture);
358 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
359
360 ret = capture->control.Stop((AudioHandle)capture);
361 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
362 adapter->DestroyCapture(adapter, capture);
363 manager->UnloadAdapter(manager, adapter);
364 }
365 /**
366 * @tc.name AudioCaptureResume_005
367 * @tc.desc test HDI CaptureResume interface,return -1 if the capture is resumed after stopped
368 * @tc.type: FUNC
369 */
370 HWTEST_F(AudioUsbCaputerTest, AudioCaptureResume_005, TestSize.Level1)
371 {
372 int32_t ret = -1;
373 struct AudioAdapter *adapter = nullptr;
374 struct AudioCapture *capture = nullptr;
375
376 ASSERT_NE(nullptr, manager);
377 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
378 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
379 ret = capture->control.Stop((AudioHandle)capture);
380 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
381 ret = capture->control.Resume((AudioHandle)capture);
382 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
383
384 adapter->DestroyCapture(adapter, capture);
385 manager->UnloadAdapter(manager, adapter);
386 }
387 /**
388 * @tc.name AudioCaptureResume_006
389 * @tc.desc test HDI CaptureResume interface,return -1 if the capture Continue to start after resume
390 * @tc.type: FUNC
391 */
392 HWTEST_F(AudioUsbCaputerTest, AudioCaptureResume_006, TestSize.Level1)
393 {
394 int32_t ret = -1;
395 struct AudioAdapter *adapter = nullptr;
396 struct AudioCapture *capture = nullptr;
397
398 ASSERT_NE(nullptr, manager);
399 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
400 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
401 ret = capture->control.Pause((AudioHandle)capture);
402 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
403 ret = capture->control.Resume((AudioHandle)capture);
404 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
405 ret = capture->control.Start((AudioHandle)capture);
406 EXPECT_EQ(AUDIO_HAL_ERR_AI_BUSY, ret);
407
408 capture->control.Stop((AudioHandle)capture);
409 adapter->DestroyCapture(adapter, capture);
410 manager->UnloadAdapter(manager, adapter);
411 }
412 /**
413 * @tc.name AudioCaptureFlush_001
414 * @tc.desc Test CaptureFlush interface,return -2 if the data in the buffer is flushed successfully after stop
415 * @tc.type: FUNC
416 */
417 HWTEST_F(AudioUsbCaputerTest, AudioCaptureFlush_001, TestSize.Level1)
418 {
419 int32_t ret = -1;
420 struct AudioAdapter *adapter = nullptr;
421 struct AudioCapture *capture = nullptr;
422
423 ASSERT_NE(nullptr, manager);
424 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
425 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
426 ret = capture->control.Stop((AudioHandle)capture);
427 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
428 ret = capture->control.Flush((AudioHandle)capture);
429 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
430
431 adapter->DestroyCapture(adapter, capture);
432 manager->UnloadAdapter(manager, adapter);
433 }
434 /**
435 * @tc.name AudioCaptureSetSampleAttributes_001
436 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
437 * attrs.type = AUDIO_IN_MEDIA;
438 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
439 * attrs.sampleRate = 8000;
440 * attrs.channelCount = 1;
441 * @tc.type: FUNC
442 */
443 HWTEST_F(AudioUsbCaputerTest, AudioCaptureSetSampleAttributes_001, TestSize.Level1)
444 {
445 int32_t ret = -1;
446 uint32_t ret1 = 1;
447 uint32_t ret2 = 8000;
448 struct AudioSampleAttributes attrs = {};
449 struct AudioSampleAttributes attrsValue = {};
450 struct AudioAdapter *adapter = nullptr;
451 struct AudioCapture *capture = nullptr;
452 ASSERT_NE(nullptr, manager);
453 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
454 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
455 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 8000);
456
457 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
458 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
459 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
460 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
461 EXPECT_EQ(ret2, attrsValue.sampleRate);
462 EXPECT_EQ(ret1, attrsValue.channelCount);
463
464 adapter->DestroyCapture(adapter, capture);
465 manager->UnloadAdapter(manager, adapter);
466 }
467 /**
468 * @tc.name AudioCaptureGetSampleAttributes_001
469 * @tc.desc Test AudioCaptureGetSampleAttributes ,the setting parameters are as follows.
470 * attrs.type = AUDIO_IN_MEDIA;
471 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
472 * attrs.sampleRate = 8000;
473 * attrs.channelCount = 1;
474 * @tc.type: FUNC
475 */
476 HWTEST_F(AudioUsbCaputerTest, AudioCaptureGetSampleAttributes_001, TestSize.Level1)
477 {
478 int32_t ret = -1;
479 uint32_t ret1 = 32000;
480 uint32_t ret2 = 1;
481 struct AudioSampleAttributes attrs = {};
482 struct AudioSampleAttributes attrsValue = {};
483 struct AudioAdapter *adapter = nullptr;
484 struct AudioCapture *capture = nullptr;
485 ASSERT_NE(nullptr, manager);
486 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
487 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
488 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
489 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
490 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 32000);
491
492 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
493 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
494 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
495 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
496 EXPECT_EQ(ret1, attrsValue.sampleRate);
497 EXPECT_EQ(ret2, attrsValue.channelCount);
498
499 adapter->DestroyCapture(adapter, capture);
500 manager->UnloadAdapter(manager, adapter);
501 }
502 /**
503 * @tc.name AudioCaptureGetFrameSize_001
504 * @tc.desc test AudioCaptureGetFrameSize interface, return 0 is call successfully.
505 * @tc.type: FUNC
506 */
507 HWTEST_F(AudioUsbCaputerTest, AudioCaptureGetFrameSize_001, TestSize.Level1)
508 {
509 int32_t ret = -1;
510 uint64_t size = 0;
511 struct AudioAdapter *adapter = nullptr;
512 struct AudioCapture *capture = nullptr;
513 ASSERT_NE(nullptr, manager);
514 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
515 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
516 ret = capture->attr.GetFrameSize(capture, &size);
517 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
518 EXPECT_GT(size, INITIAL_VALUE);
519
520 adapter->DestroyCapture(adapter, capture);
521 manager->UnloadAdapter(manager, adapter);
522 }
523 /**
524 * @tc.name AudioCaptureGetFrameCount_001
525 * @tc.desc test AudioCaptureGetFrameCount interface, return 0 if the FrameCount is called after creating the object.
526 * @tc.type: FUNC
527 */
528 HWTEST_F(AudioUsbCaputerTest, AudioCaptureGetFrameCount_001, TestSize.Level1)
529 {
530 int32_t ret = -1;
531 uint64_t count = 0;
532 struct AudioAdapter *adapter = nullptr;
533 struct AudioCapture *capture = nullptr;
534 ASSERT_NE(nullptr, manager);
535 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
536 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
537
538 ret = capture->attr.GetFrameCount(capture, &count);
539 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
540 EXPECT_EQ(count, INITIAL_VALUE);
541
542 adapter->DestroyCapture(adapter, capture);
543 manager->UnloadAdapter(manager, adapter);
544 }
545 /**
546 * @tc.name AudioCaptureGetFrameCount_002
547 * @tc.desc test AudioCaptureGetFrameCount interface, return 0 if the GetFrameCount is called after started.
548 * @tc.type: FUNC
549 */
550 HWTEST_F(AudioUsbCaputerTest, AudioCaptureGetFrameCount_002, TestSize.Level1)
551 {
552 int32_t ret = -1;
553 uint64_t count = 0;
554 struct AudioAdapter *adapter = nullptr;
555 struct AudioCapture *capture = nullptr;
556 ASSERT_NE(nullptr, manager);
557 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
558 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
559
560 ret = AudioCaptureStartAndOneFrame(capture);
561 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
562
563 ret = capture->attr.GetFrameCount(capture, &count);
564 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
565 EXPECT_GT(count, INITIAL_VALUE);
566
567 capture->control.Stop((AudioHandle)capture);
568 adapter->DestroyCapture(adapter, capture);
569 manager->UnloadAdapter(manager, adapter);
570 }
571
572 /**
573 * @tc.name AudioRenderGetCurrentChannelId_001
574 * @tc.desc Test GetCurrentChannelId, return 0 if the default CurrentChannelId is obtained successfully
575 * @tc.type: FUNC
576 */
577 HWTEST_F(AudioUsbCaputerTest, AudioCaptureGetCurrentChannelId_001, TestSize.Level1)
578 {
579 int32_t ret = -1;
580 uint32_t channelId = 0;
581 uint32_t channelIdValue = CHANNELCOUNT;
582 struct AudioAdapter *adapter = nullptr;
583 struct AudioCapture *capture = nullptr;
584 ASSERT_NE(nullptr, manager);
585 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
586 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
587
588 ret = capture->attr.GetCurrentChannelId(capture, &channelId);
589 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
590 EXPECT_EQ(channelIdValue, channelId);
591
592 adapter->DestroyCapture(adapter, capture);
593 manager->UnloadAdapter(manager, adapter);
594 }
595 /**
596 * @tc.name AudioCaptureGetCurrentChannelId_002
597 * @tc.desc Test GetCurrentChannelId interface,return 0 if get channelId to 1 and set channelCount to 1
598 * @tc.type: FUNC
599 */
600 HWTEST_F(AudioUsbCaputerTest, AudioCaptureGetCurrentChannelId_002, TestSize.Level1)
601 {
602 int32_t ret = -1;
603 uint32_t channelId = 0;
604 uint32_t channelIdExp = 1;
605 uint32_t channelCountExp = 1;
606 struct AudioSampleAttributes attrs = {};
607 struct AudioSampleAttributes attrsValue = {};
608 struct AudioAdapter *adapter = nullptr;
609 struct AudioCapture *capture = nullptr;
610 ASSERT_NE(nullptr, manager);
611 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
612 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
613
614 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 48000);
615
616 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
617 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
618 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
619
620 ret = capture->attr.GetCurrentChannelId(capture, &channelId);
621 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
622 EXPECT_EQ(channelIdExp, channelId);
623
624 adapter->DestroyCapture(adapter, capture);
625 manager->UnloadAdapter(manager, adapter);
626 }
627 /**
628 * @tc.name AudioCaptureGetCurrentChannelId_003
629 * @tc.desc Test GetCurrentChannelId interface, return 0 if CurrentChannelId is obtained after started
630 * @tc.type: FUNC
631 */
632 HWTEST_F(AudioUsbCaputerTest, AudioCaptureGetCurrentChannelId_003, TestSize.Level1)
633 {
634 int32_t ret = -1;
635 uint32_t channelId = 0;
636 uint32_t channelIdExp = 2;
637 struct AudioAdapter *adapter = nullptr;
638 struct AudioCapture *capture = nullptr;
639 ASSERT_NE(nullptr, manager);
640 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
641 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
642 ret = AudioCaptureStartAndOneFrame(capture);
643 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
644
645 ret = capture->attr.GetCurrentChannelId(capture, &channelId);
646 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
647 EXPECT_EQ(channelIdExp, channelId);
648
649 capture->control.Stop((AudioHandle)capture);
650 adapter->DestroyCapture(adapter, capture);
651 manager->UnloadAdapter(manager, adapter);
652 }
653 /**
654 * @tc.name AudioCaptureSetExtraParams_001
655 * @tc.desc Test CaptureSetExtraParams interface,return 0 if the ExtraParams is set during playback
656 * @tc.type: FUNC
657 */
658 HWTEST_F(AudioUsbCaputerTest, AudioCaptureSetExtraParams_001, TestSize.Level1)
659 {
660 int32_t ret = -1;
661 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
662 char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-sampling-rate=48000";
663 size_t index = 1;
664 char keyValueListValue[256] = {};
665 int32_t listLenth = 256;
666 uint64_t FILESIZE = 1024;
667 struct PrepareAudioPara audiopara = {
668 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC,
669 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
670 };
671 audiopara.manager = manager;
672 ASSERT_NE(nullptr, audiopara.manager);
673
674 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
675 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
676 sleep(1);
677 if (audiopara.capture != nullptr) {
678 ret = audiopara.capture->attr.SetExtraParams((AudioHandle)audiopara.capture, keyValueList);
679 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
680 ret = audiopara.capture->attr.GetExtraParams((AudioHandle)audiopara.capture, keyValueListValue, listLenth);
681 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
682 string strGetValue = keyValueListValue;
683 size_t indexAttr = strGetValue.find("attr-frame-count");
684 size_t indexFlag = strGetValue.rfind(";");
685 if (indexAttr != string::npos && indexFlag != string::npos) {
686 strGetValue.replace(indexAttr, indexFlag - indexAttr + index, "");
687 }
688 EXPECT_STREQ(keyValueListExp, strGetValue.c_str());
689 }
690
691 ret = ThreadRelease(audiopara);
692 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
693 }
694 /**
695 * @tc.name AudioCaptureSetExtraParams_002
696 * @tc.desc Test CaptureSetExtraParams interface,return 0 if some parameters is set after playing
697 * @tc.type: FUNC
698 */
699 HWTEST_F(AudioUsbCaputerTest, AudioCaptureSetExtraParams_002, TestSize.Level1)
700 {
701 int32_t ret = -1;
702 struct AudioAdapter *adapter = {};
703 struct AudioCapture *capture = nullptr;
704 char keyValueListOne[] = "attr-frame-count=4096;";
705 char keyValueListOneExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=4096;\
706 attr-sampling-rate=48000";
707 char keyValueListTwo[] = "attr-route=1;attr-frame-count=1024;";
708 char keyValueListTwoExp[] = "attr-route=1;attr-format=16;attr-channels=2;attr-frame-count=1024;\
709 attr-sampling-rate=48000";
710 char keyValueListThr[] = "attr-route=0;attr-channels=1;attr-frame-count=4096;";
711 char keyValueListThrExp[] = "attr-route=0;attr-format=16;attr-channels=1;attr-frame-count=4096;\
712 attr-sampling-rate=48000";
713 char keyValueListFour[] = "attr-format=32;attr-channels=2;attr-frame-count=4096;attr-sampling-rate=48000";
714 char keyValueListFourExp[] = "attr-route=0;attr-format=32;attr-channels=2;attr-frame-count=4096;\
715 attr-sampling-rate=48000";
716 char keyValueListValueOne[256] = {};
717 char keyValueListValueTwo[256] = {};
718 char keyValueListValueThr[256] = {};
719 char keyValueListValueFour[256] = {};
720 int32_t listLenth = 256;
721 ASSERT_NE(nullptr, manager);
722 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
723 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
724
725 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListOne);
726 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
727 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueOne, listLenth);
728 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
729 EXPECT_STREQ(keyValueListOneExp, keyValueListValueOne);
730 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListTwo);
731 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
732 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueTwo, listLenth);
733 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
734 EXPECT_STREQ(keyValueListTwoExp, keyValueListValueTwo);
735 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListThr);
736 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
737 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueThr, listLenth);
738 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
739 EXPECT_STREQ(keyValueListThrExp, keyValueListValueThr);
740 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListFour);
741 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
742 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueFour, listLenth);
743 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
744 EXPECT_STREQ(keyValueListFourExp, keyValueListValueFour);
745
746 ret = capture->control.Stop((AudioHandle)capture);
747 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
748 adapter->DestroyCapture(adapter, capture);
749 manager->UnloadAdapter(manager, adapter);
750 }
751 /**
752 * @tc.name AudioCaptureGetExtraParams_001
753 * @tc.desc Test CaptureGetExtraParams interface,return 0 if the RenderGetExtraParams was obtained successfully
754 * @tc.type: FUNC
755 */
756 HWTEST_F(AudioUsbCaputerTest, AudioCaptureGetExtraParams_001, TestSize.Level1)
757 {
758 int32_t ret = -1;
759 uint64_t count = 0;
760 struct AudioAdapter *adapter = {};
761 struct AudioCapture *capture = nullptr;
762 struct AudioSampleAttributes attrsValue = {};
763 char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
764 char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\
765 attr-sampling-rate=48000";
766 char keyValueListValue[256] = {};
767 int32_t listLenth = 256;
768 int32_t formatExp = 3;
769 uint32_t sampleRateExp = 48000;
770 uint32_t channelCountExp = 2;
771 uint32_t frameCountExp = 4096;
772
773 ASSERT_NE(nullptr, manager);
774 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
775 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
776 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
777 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
778 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValue, listLenth);
779 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
780 EXPECT_STREQ(keyValueListExp, keyValueListValue);
781
782 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
783 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
784 EXPECT_EQ(formatExp, attrsValue.format);
785 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
786 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
787 ret = capture->attr.GetFrameCount(capture, &count);
788 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
789 EXPECT_EQ(count, frameCountExp);
790
791 ret = capture->control.Stop((AudioHandle)capture);
792 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
793 adapter->DestroyCapture(adapter, capture);
794 manager->UnloadAdapter(manager, adapter);
795 }
796 /**
797 * @tc.name AudioCaptureCheckSceneCapability_001
798 * @tc.desc Test AudioCaptureCheckSceneCapability interface,return 0 if check scene's capability successful.
799 * @tc.type: FUNC
800 */
801 HWTEST_F(AudioUsbCaputerTest, AudioCaptureCheckSceneCapability_001, TestSize.Level1)
802 {
803 int32_t ret = -1;
804 bool supported = false;
805 struct AudioSceneDescriptor scenes = {};
806 struct AudioAdapter *adapter = nullptr;
807 struct AudioCapture *capture = nullptr;
808 ASSERT_NE(nullptr, manager);
809 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
810 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
811 scenes.scene.id = 0;
812 scenes.desc.pins = PIN_IN_MIC;
813 ret = capture->scene.CheckSceneCapability(capture, &scenes, &supported);
814 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
815 EXPECT_TRUE(supported);
816
817 adapter->DestroyCapture(adapter, capture);
818 manager->UnloadAdapter(manager, adapter);
819 }
820 /**
821 * @tc.name AudioCaptureCheckSceneCapability_002
822 * @tc.desc Test AudioCreateCapture interface,return -1 if the scene is not configured in the json.
823 * @tc.type: FUNC
824 */
825 HWTEST_F(AudioUsbCaputerTest, AudioCaptureCheckSceneCapability_002, TestSize.Level1)
826 {
827 int32_t ret = -1;
828 bool supported = true;
829 struct AudioSceneDescriptor scenes = {};
830 struct AudioAdapter *adapter = nullptr;
831 struct AudioCapture *capture = nullptr;
832 ASSERT_NE(nullptr, manager);
833 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
834 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
835 scenes.scene.id = 5;
836 scenes.desc.pins = PIN_IN_MIC;
837 ret = capture->scene.CheckSceneCapability(capture, &scenes, &supported);
838 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
839
840 adapter->DestroyCapture(adapter, capture);
841 manager->UnloadAdapter(manager, adapter);
842 }
843
844 /**
845 * @tc.name AudioCaptureSelectScene_001
846 * @tc.desc Test AudioCaptureSelectScene interface,return 0 if select capture's scene successful.
847 * @tc.type: FUNC
848 */
849 HWTEST_F(AudioUsbCaputerTest, AudioCaptureSelectScene_001, TestSize.Level1)
850 {
851 int32_t ret = -1;
852 struct AudioSceneDescriptor scenes = {};
853 struct AudioAdapter *adapter = nullptr;
854 struct AudioCapture *capture = nullptr;
855 ASSERT_NE(nullptr, manager);
856 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
857 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
858 scenes.scene.id = 0;
859 scenes.desc.pins = PIN_IN_MIC;
860 ret = capture->scene.SelectScene(capture, &scenes);
861 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
862
863 adapter->DestroyCapture(adapter, capture);
864 manager->UnloadAdapter(manager, adapter);
865 }
866 /**
867 * @tc.name AudioCaptureSelectScene_002
868 * @tc.desc Test AudioCaptureSelectScene, return 0 if select capture's scene successful after capture start.
869 * @tc.type: FUNC
870 */
871 HWTEST_F(AudioUsbCaputerTest, AudioCaptureSelectScene_002, TestSize.Level1)
872 {
873 int32_t ret = -1;
874 struct AudioSceneDescriptor scenes = {};
875 struct AudioAdapter *adapter = nullptr;
876 struct AudioCapture *capture = nullptr;
877 ASSERT_NE(nullptr, manager);
878 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
879 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
880
881 ret = AudioCaptureStartAndOneFrame(capture);
882 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
883
884 scenes.scene.id = 0;
885 scenes.desc.pins = PIN_IN_MIC;
886 ret = capture->scene.SelectScene(capture, &scenes);
887 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
888
889 capture->control.Stop((AudioHandle)capture);
890 adapter->DestroyCapture(adapter, capture);
891 manager->UnloadAdapter(manager, adapter);
892 }
893 /**
894 * @tc.name AudioCaptureSelectScene_005
895 * @tc.desc Test AudioCaptureSelectScene, return -1 if the scene is not configured in the json.
896 * @tc.type: FUNC
897 */
898 HWTEST_F(AudioUsbCaputerTest, AudioCaptureSelectScene_005, TestSize.Level1)
899 {
900 int32_t ret = -1;
901 struct AudioSceneDescriptor scenes = {};
902 struct AudioAdapter *adapter = nullptr;
903 struct AudioCapture *capture = nullptr;
904 ASSERT_NE(nullptr, manager);
905 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
906 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
907
908 scenes.scene.id = 5;
909 scenes.desc.pins = PIN_OUT_HDMI;
910 ret = capture->scene.SelectScene(capture, &scenes);
911 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
912
913 adapter->DestroyCapture(adapter, capture);
914 manager->UnloadAdapter(manager, adapter);
915 }
916 /**
917 * @tc.name AudioCaptureFrame_001
918 * @tc.desc test AudioCaptureCaptureFrame interface,Returns 0 if the input data is read successfully
919 * @tc.type: FUNC
920 */
921 HWTEST_F(AudioUsbCaputerTest, AudioCaptureFrame_001, TestSize.Level1)
922 {
923 int32_t ret = -1;
924 uint64_t replyBytes = 0;
925 uint64_t requestBytes = BUFFER_SIZE;
926 struct AudioAdapter *adapter = nullptr;
927 struct AudioCapture *capture = nullptr;
928
929 ASSERT_NE(nullptr, manager);
930 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
931 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
932 ret = capture->control.Start((AudioHandle)capture);
933 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
934 char *frame = static_cast<char *>(calloc(1, BUFFER_SIZE));
935 EXPECT_NE(nullptr, frame);
936 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
937 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
938
939 capture->control.Stop((AudioHandle)capture);
940 adapter->DestroyCapture(adapter, capture);
941 manager->UnloadAdapter(manager, adapter);
942 if (frame != nullptr) {
943 free(frame);
944 frame = nullptr;
945 }
946 }
947 /**
948 * @tc.name AudioCaptureFrame_005
949 * @tc.desc Test AudioCaptureFrame interface,Returns -1 if without calling interface capturestart
950 * @tc.type: FUNC
951 */
952 HWTEST_F(AudioUsbCaputerTest, AudioCaptureFrame_005, TestSize.Level1)
953 {
954 int32_t ret = -1;
955 uint64_t requestBytes = BUFFER_SIZE;
956 struct AudioAdapter *adapter = nullptr;
957 struct AudioCapture *capture = nullptr;
958 uint64_t replyBytes = 0;
959
960 ASSERT_NE(nullptr, manager);
961 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
962 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
963 char *frame = static_cast<char *>(calloc(1, BUFFER_SIZE));
964 EXPECT_NE(nullptr, frame);
965 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
966 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
967
968 adapter->DestroyCapture(adapter, capture);
969 manager->UnloadAdapter(manager, adapter);
970 if (frame != nullptr) {
971 free(frame);
972 frame = nullptr;
973 }
974 }
975 /**
976 * @tc.name AudioCaptureGetCapturePosition_001
977 * @tc.desc Test AudioCaptureGetCapturePosition interface,Returns 0 if get CapturePosition during playing.
978 * @tc.type: FUNC
979 */
980 HWTEST_F(AudioUsbCaputerTest, AudioCaptureGetCapturePosition_001, TestSize.Level1)
981 {
982 int32_t ret = -1;
983 uint64_t frames = 0;
984 int64_t timeExp = 0;
985 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
986 struct PrepareAudioPara audiopara = {
987 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC,
988 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
989 };
990 audiopara.manager = manager;
991 ASSERT_NE(nullptr, audiopara.manager);
992
993 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
994 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
995 sleep(1);
996 if (audiopara.capture != nullptr) {
997 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time);
998 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
999 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
1000 EXPECT_GT(frames, INITIAL_VALUE);
1001 }
1002
1003 ret = ThreadRelease(audiopara);
1004 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1005 }
1006 /**
1007 * @tc.name AudioCaptureReqMmapBuffer_001
1008 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully
1009 * @tc.type: FUNC
1010 */
1011 HWTEST_F(AudioUsbCaputerTest, AudioCaptureReqMmapBuffer_001, TestSize.Level1)
1012 {
1013 int32_t ret = -1;
1014 bool isRender = false;
1015 int32_t reqSize = 0;
1016 struct AudioMmapBufferDescripter desc = {};
1017 struct AudioCapture *capture = nullptr;
1018 struct AudioAdapter *adapter = nullptr;
1019 ASSERT_NE(nullptr, manager);
1020 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
1021 ASSERT_NE(nullptr, fp);
1022 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1023 if (ret < 0 || capture == nullptr) {
1024 fclose(fp);
1025 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1026 ASSERT_EQ(nullptr, capture);
1027 }
1028 ret = InitMmapDesc(fp, desc, reqSize, isRender);
1029 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1030 ret = capture->control.Start((AudioHandle)capture);
1031 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1032 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
1033 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1034 fclose(fp);
1035 if (ret == 0) {
1036 munmap(desc.memoryAddress, reqSize);
1037 }
1038 capture->control.Stop((AudioHandle)capture);
1039 adapter->DestroyCapture(adapter, capture);
1040 manager->UnloadAdapter(manager, adapter);
1041 }
1042
1043 /**
1044 * @tc.name AudioCaptureGetMmapPosition_001
1045 * @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully.
1046 * @tc.type: FUNC
1047 */
1048 HWTEST_F(AudioUsbCaputerTest, AudioCaptureGetMmapPosition_001, TestSize.Level1)
1049 {
1050 int32_t ret = -1;
1051 uint64_t frames = 0;
1052 uint64_t framesCapturing = 0;
1053 uint64_t framesExpCapture = 0;
1054 int64_t timeExp = 0;
1055 int64_t timeExpCaptureing = 0;
1056 struct PrepareAudioPara audiopara = {
1057 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC,
1058 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
1059 };
1060 audiopara.manager = manager;
1061 ASSERT_NE(nullptr, audiopara.manager);
1062 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1063 &audiopara.capture);
1064 if (ret < 0 || audiopara.capture == nullptr) {
1065 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1066 ASSERT_EQ(nullptr, audiopara.capture);
1067 }
1068 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &frames, &(audiopara.time));
1069 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1070 EXPECT_EQ((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1071 EXPECT_EQ(frames, INITIAL_VALUE);
1072 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordMapAudio, &audiopara);
1073 if (ret != 0) {
1074 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1075 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1076 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1077 }
1078 sleep(1);
1079 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &framesCapturing, &(audiopara.time));
1080 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1081 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1082 EXPECT_GT(framesCapturing, INITIAL_VALUE);
1083 timeExpCaptureing = (audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec);
1084 void *result = nullptr;
1085 pthread_join(audiopara.tids, &result);
1086 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
1087 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &framesExpCapture, &(audiopara.time));
1088 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1089 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExpCaptureing);
1090 EXPECT_GT(framesExpCapture, framesCapturing);
1091
1092 audiopara.capture->control.Stop((AudioHandle)audiopara.capture);
1093 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1094 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1095 }
1096 /**
1097 * @tc.name AudioCaptureGetMmapPosition_002
1098 * @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully.
1099 * @tc.type: FUNC
1100 */
1101 HWTEST_F(AudioUsbCaputerTest, AudioCaptureGetMmapPosition_002, TestSize.Level1)
1102 {
1103 int32_t ret = -1;
1104 uint64_t frames = 0;
1105 int64_t timeExp = 0;
1106 struct PrepareAudioPara audiopara = {
1107 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC,
1108 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
1109 };
1110 audiopara.manager = manager;
1111 ASSERT_NE(nullptr, audiopara.manager);
1112 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1113 &audiopara.capture);
1114 if (ret < 0 || audiopara.capture == nullptr) {
1115 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1116 ASSERT_EQ(nullptr, audiopara.capture);
1117 }
1118 InitAttrs(audiopara.attrs);
1119 audiopara.attrs.format = AUDIO_FORMAT_PCM_24_BIT;
1120 audiopara.attrs.channelCount = 1;
1121 ret = audiopara.capture->attr.SetSampleAttributes(audiopara.capture, &(audiopara.attrs));
1122 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1123
1124 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordMapAudio, &audiopara);
1125 if (ret != 0) {
1126 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1127 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1128 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1129 }
1130
1131 void *result = nullptr;
1132 pthread_join(audiopara.tids, &result);
1133 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
1134
1135 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &frames, &(audiopara.time));
1136 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1137 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1138 EXPECT_GT(frames, INITIAL_VALUE);
1139
1140 audiopara.capture->control.Stop((AudioHandle)audiopara.capture);
1141 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1142 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1143 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1144 }
1145 /**
1146 * @tc.name AudioCaptureGetMute_001
1147 * @tc.desc Test AudioCaptureGetMute interface , return 0 if the audiocapture gets mute successfully.
1148 * @tc.type: FUNC
1149 */
1150 HWTEST_F(AudioUsbCaputerTest, AudioCaptureGetMute_001, TestSize.Level1)
1151 {
1152 int32_t ret = -1;
1153 bool muteTrue = true;
1154 bool muteFalse = false;
1155 bool defaultmute = false;
1156 struct AudioAdapter *adapter = nullptr;
1157 struct AudioCapture *capture = nullptr;
1158 ASSERT_NE(nullptr, manager);
1159 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1160 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1161
1162 ret = capture->volume.GetMute(capture, &muteFalse);
1163 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1164 EXPECT_EQ(muteFalse, defaultmute);
1165
1166 ret = capture->volume.SetMute(capture, muteTrue);
1167 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1168
1169 ret = capture->volume.GetMute(capture, &muteTrue);
1170 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1171 EXPECT_TRUE(muteTrue);
1172
1173 adapter->DestroyCapture(adapter, capture);
1174 manager->UnloadAdapter(manager, adapter);
1175 }
1176
1177 /**
1178 * @tc.name AudioCaptureSetMute_001
1179 * @tc.desc Test AudioCaptureSetMute interface , return 0 if the audiocapture object sets mute successfully.
1180 * @tc.type: FUNC
1181 */
1182 HWTEST_F(AudioUsbCaputerTest, AudioCaptureSetMute_001, TestSize.Level1)
1183 {
1184 int32_t ret = -1;
1185 bool muteTrue = true;
1186 bool muteFalse = false;
1187 struct AudioAdapter *adapter = nullptr;
1188 struct AudioCapture *capture = nullptr;
1189 ASSERT_NE(nullptr, manager);
1190 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1191 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1192
1193 ret = capture->volume.SetMute(capture, muteTrue);
1194 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1195
1196 ret = capture->volume.GetMute(capture, &muteTrue);
1197 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1198 EXPECT_TRUE(muteTrue);
1199
1200 ret = capture->volume.SetMute(capture, muteFalse);
1201 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1202
1203 ret = capture->volume.GetMute(capture, &muteFalse);
1204 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1205 EXPECT_FALSE(muteFalse);
1206
1207 adapter->DestroyCapture(adapter, capture);
1208 manager->UnloadAdapter(manager, adapter);
1209 }
1210 /**
1211 * @tc.name AudioCaptureSetVolume_001
1212 * @tc.desc Test AudioCaptureSetVolume interface , return 0 if the audiocapture sets volume successfully.
1213 * @tc.type: FUNC
1214 */
1215 HWTEST_F(AudioUsbCaputerTest, AudioCaptureSetVolume_001, TestSize.Level1)
1216 {
1217 int32_t ret = -1;
1218 float volumeInit = 0.30;
1219 float volumeInitExpc = 0.30;
1220 float volumeLow = 0.10;
1221 float volumeLowExpc = 0.10;
1222 float volumeMid = 0.40;
1223 float volumeMidExpc = 0.40;
1224 float volumeHigh = 0.70;
1225 float volumeHighExpc = 0.70;
1226 struct AudioAdapter *adapter = nullptr;
1227 struct AudioCapture *capture = nullptr;
1228 ASSERT_NE(nullptr, manager);
1229 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1230 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1231 ret = capture->volume.SetVolume(capture, volumeInit);
1232 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1233 ret = capture->volume.GetVolume(capture, &volumeInit);
1234 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1235 EXPECT_EQ(volumeInitExpc, volumeInit);
1236 ret = capture->volume.SetVolume(capture, volumeLow);
1237 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1238 ret = capture->volume.GetVolume(capture, &volumeLow);
1239 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1240 EXPECT_EQ(volumeLowExpc, volumeLow);
1241 ret = capture->volume.SetVolume(capture, volumeMid);
1242 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1243 ret = capture->volume.GetVolume(capture, &volumeMid);
1244 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1245 EXPECT_EQ(volumeMidExpc, volumeMid);
1246 ret = capture->volume.SetVolume(capture, volumeHigh);
1247 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1248 ret = capture->volume.GetVolume(capture, &volumeHigh);
1249 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1250 EXPECT_EQ(volumeHighExpc, volumeHigh);
1251
1252 adapter->DestroyCapture(adapter, capture);
1253 manager->UnloadAdapter(manager, adapter);
1254 }
1255 /**
1256 * @tc.name AudioCaptureGetVolume_001
1257 * @tc.desc Test AudioCaptureGetVolume interface , return 0 if the audiocapture is get successful.
1258 * @tc.type: FUNC
1259 */
1260 HWTEST_F(AudioUsbCaputerTest, AudioCaptureGetVolume_001, TestSize.Level1)
1261 {
1262 int32_t ret = -1;
1263 float volume = 0.60;
1264 float defaultVolume = 0.60;
1265 struct AudioAdapter *adapter = nullptr;
1266 struct AudioCapture *capture = nullptr;
1267 ASSERT_NE(nullptr, manager);
1268 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1269 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1270
1271 ret = capture->volume.SetVolume(capture, volume);
1272 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1273 ret = capture->volume.GetVolume(capture, &volume);
1274 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1275 EXPECT_EQ(defaultVolume, volume);
1276
1277 adapter->DestroyCapture(adapter, capture);
1278 manager->UnloadAdapter(manager, adapter);
1279 }
1280 /**
1281 * @tc.name AudioCaptureGetGainThreshold_001
1282 * @tc.desc test AudioCaptureGetGainThreshold interface, return 0 is call successfully.
1283 * @tc.type: FUNC
1284 */
1285 HWTEST_F(AudioUsbCaputerTest, AudioCaptureGetGainThreshold_001, TestSize.Level1)
1286 {
1287 int32_t ret = -1;
1288 float min = 0;
1289 float max = 0;
1290 struct AudioAdapter *adapter = nullptr;
1291 struct AudioCapture *capture = nullptr;
1292 ASSERT_NE(nullptr, manager);
1293 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1294 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1295
1296 ret = capture->volume.GetGainThreshold((AudioHandle)capture, &min, &max);
1297 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1298 EXPECT_EQ(min, GAIN_MIN);
1299 EXPECT_EQ(max, GAIN_MAX);
1300
1301 adapter->DestroyCapture(adapter, capture);
1302 manager->UnloadAdapter(manager, adapter);
1303 }
1304 /**
1305 * @tc.name AudioCaptureSetGain_001
1306 * @tc.desc test AudioCaptureSetGain interface, return 0 is call successfully.
1307 * @tc.type: FUNC
1308 */
1309 HWTEST_F(AudioUsbCaputerTest, AudioCaptureSetGain_001, TestSize.Level1)
1310 {
1311 int32_t ret = -1;
1312 float min = 0;
1313 float max = 0;
1314 struct AudioAdapter *adapter = nullptr;
1315 struct AudioCapture *capture = nullptr;
1316 ASSERT_NE(nullptr, manager);
1317 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1318 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1319
1320 ret = capture->volume.GetGainThreshold((AudioHandle)capture, &min, &max);
1321 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1322 float gain = max - 1;
1323 float gainMax = max;
1324 float gainMin = min;
1325 float gainExpc = max - 1;
1326 float gainMaxExpc = max;
1327 float gainMinExpc = min;
1328 ret = capture->volume.SetGain((AudioHandle)capture, gainMax);
1329 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1330 ret = capture->volume.GetGain((AudioHandle)capture, &gainMax);
1331 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1332 EXPECT_EQ(gainMaxExpc, gainMax);
1333
1334 ret = capture->volume.SetGain((AudioHandle)capture, gainMin);
1335 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1336 ret = capture->volume.GetGain((AudioHandle)capture, &gainMin);
1337 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1338 EXPECT_EQ(gainMinExpc, gainMin);
1339
1340 ret = capture->volume.SetGain((AudioHandle)capture, gain);
1341 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1342 ret = capture->volume.GetGain((AudioHandle)capture, &gain);
1343 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1344 EXPECT_EQ(gainExpc, gain);
1345
1346 adapter->DestroyCapture(adapter, capture);
1347 manager->UnloadAdapter(manager, adapter);
1348 }
1349 /**
1350 * @tc.name AudioCaptureGetGain_001
1351 * @tc.desc test AudioCaptureGetGain interface, return 0 if CaptureGetGain is call successfully.
1352 * @tc.type: FUNC
1353 */
1354 HWTEST_F(AudioUsbCaputerTest, AudioCaptureGetGain_001, TestSize.Level1)
1355 {
1356 int32_t ret = -1;
1357 float min = 0;
1358 float max = 0;
1359 struct AudioAdapter *adapter = nullptr;
1360 struct AudioCapture *capture = nullptr;
1361 ASSERT_NE(nullptr, manager);
1362 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1363 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1364 ret = capture->volume.GetGainThreshold((AudioHandle)capture, &min, &max);
1365 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1366
1367 float gain = min + 1;
1368 float gainValue = min + 1;
1369 ret = capture->volume.SetGain((AudioHandle)capture, gain);
1370 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1371 ret = capture->volume.GetGain((AudioHandle)capture, &gain);
1372 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1373 EXPECT_EQ(gainValue, gain);
1374
1375 capture->control.Stop((AudioHandle)capture);
1376 adapter->DestroyCapture(adapter, capture);
1377 manager->UnloadAdapter(manager, adapter);
1378 }
1379 /**
1380 * @tc.name AudioCaptureTurnStandbyMode_001
1381 * @tc.desc Test AudioCaptureTurnStandbyMode interface,return 0 if the interface use correctly.
1382 * @tc.type: FUNC
1383 */
1384 HWTEST_F(AudioUsbCaputerTest, AudioCaptureTurnStandbyMode_001, TestSize.Level1)
1385 {
1386 int32_t ret = -1;
1387 struct AudioAdapter *adapter = nullptr;
1388 struct AudioCapture *capture = nullptr;
1389 ASSERT_NE(nullptr, manager);
1390 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
1391 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1392
1393 ret = capture->control.TurnStandbyMode((AudioHandle)capture);
1394 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1395
1396 sleep(3);
1397
1398 ret = capture->control.Stop((AudioHandle)capture);
1399 adapter->DestroyCapture(adapter, capture);
1400 manager->UnloadAdapter(manager, adapter);
1401 }
1402
1403 /**
1404 * @tc.name AudioCaptureAudioDevDump_001
1405 * @tc.desc Test AudioCaptureAudioDevDump interface,return 0 if the interface use correctly.
1406 * @tc.type: FUNC
1407 */
1408 HWTEST_F(AudioUsbCaputerTest, AudioCaptureAudioDevDump_001, TestSize.Level1)
1409 {
1410 int32_t ret = -1;
1411 char pathBuf[] = "./DevDump.log";
1412 ASSERT_NE(nullptr, manager);
1413 FILE *fp = fopen(pathBuf, "wb+");
1414 ASSERT_NE(nullptr, fp);
1415 int fd = fileno(fp);
1416 if (fd == -1) {
1417 fclose(fp);
1418 ASSERT_NE(fd, -1);
1419 }
1420 struct PrepareAudioPara audiopara = {
1421 .manager = manager, .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC,
1422 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
1423 };
1424
1425 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
1426 if (ret < 0) {
1427 fclose(fp);
1428 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1429 }
1430 sleep(1);
1431 ret = audiopara.capture->control.Pause((AudioHandle)audiopara.capture);
1432 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1433 sleep(1);
1434 ret = audiopara.capture->control.Resume((AudioHandle)audiopara.capture);
1435 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1436 ret = audiopara.capture->control.AudioDevDump((AudioHandle)audiopara.capture, RANGE, fd);
1437 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1438 fclose(fp);
1439 ret = ThreadRelease(audiopara);
1440 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1441 }
1442 }
1443