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 HMOS::Audio;
42
43 namespace {
44 const string ADAPTER_NAME_HDMI = "hdmi";
45 const string ADAPTER_NAME_USB = "usb";
46 const string ADAPTER_NAME_INTERNAL = "internal";
47
48 class AudioHdiCaptureControlTest : public testing::Test {
49 public:
50 static void SetUpTestCase(void);
51 static void TearDownTestCase(void);
52 void SetUp();
53 void TearDown();
54 static TestAudioManager *(*GetAudioManager)();
55 static void *handleSo;
56 #ifdef AUDIO_MPI_SO
57 static int32_t (*SdkInit)();
58 static void (*SdkExit)();
59 static void *sdkSo;
60 #endif
61 };
62
63 TestAudioManager *(*AudioHdiCaptureControlTest::GetAudioManager)() = nullptr;
64 void *AudioHdiCaptureControlTest::handleSo = nullptr;
65 #ifdef AUDIO_MPI_SO
66 int32_t (*AudioHdiCaptureControlTest::SdkInit)() = nullptr;
67 void (*AudioHdiCaptureControlTest::SdkExit)() = nullptr;
68 void *AudioHdiCaptureControlTest::sdkSo = nullptr;
69 #endif
70
SetUpTestCase(void)71 void AudioHdiCaptureControlTest::SetUpTestCase(void)
72 {
73 #ifdef AUDIO_MPI_SO
74 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
75 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
76 if (sdkSo == nullptr) {
77 return;
78 }
79 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
80 if (SdkInit == nullptr) {
81 return;
82 }
83 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
84 if (SdkExit == nullptr) {
85 return;
86 }
87 SdkInit();
88 #endif
89 char absPath[PATH_MAX] = {0};
90 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
91 return;
92 }
93 handleSo = dlopen(absPath, RTLD_LAZY);
94 if (handleSo == nullptr) {
95 return;
96 }
97 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
98 if (GetAudioManager == nullptr) {
99 return;
100 }
101 }
102
TearDownTestCase(void)103 void AudioHdiCaptureControlTest::TearDownTestCase(void)
104 {
105 #ifdef AUDIO_MPI_SO
106 SdkExit();
107 if (sdkSo != nullptr) {
108 dlclose(sdkSo);
109 sdkSo = nullptr;
110 }
111 if (SdkInit != nullptr) {
112 SdkInit = nullptr;
113 }
114 if (SdkExit != nullptr) {
115 SdkExit = nullptr;
116 }
117 #endif
118 if (handleSo != nullptr) {
119 dlclose(handleSo);
120 handleSo = nullptr;
121 }
122 if (GetAudioManager != nullptr) {
123 GetAudioManager = nullptr;
124 }
125 }
126
SetUp(void)127 void AudioHdiCaptureControlTest::SetUp(void) {}
128
TearDown(void)129 void AudioHdiCaptureControlTest::TearDown(void) {}
130
131 /**
132 * @tc.name Test AudioCreateCapture API via legal input
133 * @tc.number SUB_Audio_HDI_AudioCreateCapture_0001
134 * @tc.desc Test AudioCreateCapture interface,Returns 0 if the AudioCapture object is created successfully
135 */
136 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0001, Function | MediumTest | Level1)
137 {
138 int32_t ret = -1;
139 enum AudioPortPin pins = PIN_IN_MIC;
140 struct AudioAdapter *adapter = nullptr;
141 struct AudioCapture *capture = nullptr;
142
143 TestAudioManager* manager = GetAudioManager();
144 ASSERT_NE(nullptr, GetAudioManager);
145 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture);
146 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
147 adapter->DestroyCapture(adapter, capture);
148 manager->UnloadAdapter(manager, adapter);
149 }
150 /**
151 * @tc.name Test AudioCreateCapture API via creating a capture object when a render object was created
152 * @tc.number SUB_Audio_HDI_AudioCreateCapture_0002
153 * @tc.desc test AudioCreateCapture interface:
154 (1)service mode:Returns 0,if the AudioCapture object can be created successfully which was created
155 (2)passthrough mode: Returns -1,if the AudioCapture object can't be created which was created
156 */
157 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0002, Function | MediumTest | Level1)
158 {
159 int32_t ret = -1;
160 enum AudioPortDirection portType = PORT_OUT_IN;
161 struct AudioAdapter *adapter = nullptr;
162 struct AudioCapture *firstCapture = nullptr;
163 struct AudioCapture *secondCapture = nullptr;
164 struct AudioPort* audioPort = nullptr;
165 struct AudioSampleAttributes attrs = {};
166 struct AudioDeviceDescriptor DevDesc = {};
167
168 ASSERT_NE(nullptr, GetAudioManager);
169 TestAudioManager* manager = GetAudioManager();
170 ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_USB, &adapter, audioPort);
171 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
172 InitAttrs(attrs);
173 InitDevDesc(DevDesc, audioPort->portId, PIN_IN_MIC);
174 ret = adapter->CreateCapture(adapter, &DevDesc, &attrs, &firstCapture);
175 if (ret < 0) {
176 manager->UnloadAdapter(manager, adapter);
177 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
178 }
179 ret = adapter->CreateCapture(adapter, &DevDesc, &attrs, &secondCapture);
180 #if defined (AUDIO_ADM_SERVICE) || defined (AUDIO_MPI_SERVICE)
181 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
182 adapter->DestroyCapture(adapter, secondCapture);
183 #endif
184 #if defined (AUDIO_ADM_SO) || defined (AUDIO_MPI_SO) || defined (__LITEOS__)
185 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
186 adapter->DestroyCapture(adapter, firstCapture);
187 #endif
188 manager->UnloadAdapter(manager, adapter);
189 }
190 /**
191 * @tc.name Test AudioCreateCapture API via creating a capture object when a render object was created
192 * @tc.number SUB_Audio_HDI_AudioCreateCapture_0003
193 * @tc.desc test AudioCreateCapture interface,Returns 0 if the AudioCapture object can be created successfully
194 when AudioRender was created
195 */
196 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0003, Function | MediumTest | Level1)
197 {
198 int32_t ret = -1;
199 enum AudioPortDirection portType = PORT_OUT_IN;
200 struct AudioAdapter *adapter = nullptr;
201 struct AudioRender *render = nullptr;
202 struct AudioCapture *capture = nullptr;
203 struct AudioPort* audioPort = nullptr;
204 struct AudioSampleAttributes attrs = {};
205 struct AudioDeviceDescriptor renderDevDesc = {};
206 struct AudioDeviceDescriptor captureDevDesc = {};
207
208 ASSERT_NE(nullptr, GetAudioManager);
209 TestAudioManager* manager = GetAudioManager();
210 ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_USB, &adapter, audioPort);
211 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
212 InitAttrs(attrs);
213 InitDevDesc(renderDevDesc, audioPort->portId, PIN_OUT_SPEAKER);
214 InitDevDesc(captureDevDesc, audioPort->portId, PIN_IN_MIC);
215 ret = adapter->CreateRender(adapter, &renderDevDesc, &attrs, &render);
216 if (ret < 0) {
217 manager->UnloadAdapter(manager, adapter);
218 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
219 }
220 ret = adapter->CreateCapture(adapter, &captureDevDesc, &attrs, &capture);
221 if (ret < 0) {
222 adapter->DestroyRender(adapter, render);
223 manager->UnloadAdapter(manager, adapter);
224 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
225 }
226 adapter->DestroyRender(adapter, render);
227 adapter->DestroyCapture(adapter, capture);
228 manager->UnloadAdapter(manager, adapter);
229 }
230 /**
231 * @tc.name Test AudioCreateCapture API via creating two capture objects
232 * @tc.number SUB_Audio_HDI_AudioCreateCapture_0004
233 * @tc.desc Test AudioCreateCapture interface,return 0 if the the two audiocapture objects are created successfully
234 */
235 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0004, Function | MediumTest | Level1)
236 {
237 int32_t ret = -1;
238 enum AudioPortPin pins = PIN_IN_MIC;
239 struct AudioAdapter *adapterFirst = nullptr;
240 struct AudioAdapter *adapterSecond = nullptr;
241 struct AudioCapture *captureFirst = nullptr;
242 struct AudioCapture *captureSecond = nullptr;
243
244 ASSERT_NE(nullptr, GetAudioManager);
245 TestAudioManager* manager = GetAudioManager();
246 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapterFirst, &captureFirst);
247 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
248 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_INTERNAL, &adapterSecond, &captureSecond);
249 if (ret < 0) {
250 adapterFirst->DestroyCapture(adapterFirst, captureFirst);
251 manager->UnloadAdapter(manager, adapterFirst);
252 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
253 }
254 adapterFirst->DestroyCapture(adapterFirst, captureFirst);
255 adapterSecond->DestroyCapture(adapterSecond, captureSecond);
256 manager->UnloadAdapter(manager, adapterFirst);
257 manager->UnloadAdapter(manager, adapterSecond);
258 }
259 /**
260 * @tc.name Test AudioCreateCapture API via setting the incoming parameter adapter is nullptr
261 * @tc.number SUB_Audio_HDI_AudioCreateCapture_0005
262 * @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter adapter is nullptr
263 */
264 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0005, Function | MediumTest | Level1)
265 {
266 int32_t ret = -1;
267 struct AudioPort* capturePort = nullptr;
268 struct AudioDeviceDescriptor devDesc = {};
269 struct AudioSampleAttributes attrs = {};
270 enum AudioPortDirection portType = PORT_IN;
271 enum AudioPortPin pins = PIN_IN_MIC;
272 struct AudioAdapter *adapter = nullptr;
273 struct AudioAdapter *adapterNull = nullptr;
274 struct AudioCapture *capture = nullptr;
275
276 ASSERT_NE(nullptr, GetAudioManager);
277 TestAudioManager* manager = GetAudioManager();
278 ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_USB, &adapter, capturePort);
279 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
280 ret = InitAttrs(attrs);
281 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
282 ret = InitDevDesc(devDesc, capturePort->portId, pins);
283 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
284 ret = adapter->CreateCapture(adapterNull, &devDesc, &attrs, &capture);
285 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
286
287 manager->UnloadAdapter(manager, adapter);
288 }
289 /**
290 * @tc.name Test AudioCreateCapture API via setting the incoming parameter desc is nullptr
291 * @tc.number SUB_Audio_HDI_AudioCreateCapture_0006
292 * @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter desc is nullptr
293 */
294 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0006, Function | MediumTest | Level1)
295 {
296 int32_t ret = -1;
297 struct AudioPort* capturePort = nullptr;
298 struct AudioSampleAttributes attrs = {};
299 enum AudioPortDirection portType = PORT_IN;
300 struct AudioDeviceDescriptor *devDesc = nullptr;
301 struct AudioAdapter *adapter = nullptr;
302 struct AudioCapture *capture = nullptr;
303
304 ASSERT_NE(nullptr, GetAudioManager);
305 TestAudioManager* manager = GetAudioManager();
306 ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_USB, &adapter, capturePort);
307 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
308 ret = InitAttrs(attrs);
309 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
310 ret = adapter->CreateCapture(adapter, devDesc, &attrs, &capture);
311 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
312
313 manager->UnloadAdapter(manager, adapter);
314 }
315 /**
316 * @tc.name Test AudioCreateCapture API via setting the incoming parameter attrs is nullptr
317 * @tc.number SUB_Audio_HDI_AudioCreateCapture_0007
318 * @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter attrs is nullptr
319 */
320 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0007, Function | MediumTest | Level1)
321 {
322 int32_t ret = -1;
323 struct AudioPort* capturePort = nullptr;
324 struct AudioDeviceDescriptor devDesc = {};
325 enum AudioPortDirection portType = PORT_IN;
326 enum AudioPortPin pins = PIN_IN_MIC;
327 struct AudioSampleAttributes *attrs = nullptr;
328 struct AudioAdapter *adapter = nullptr;
329 struct AudioCapture *capture = nullptr;
330
331 ASSERT_NE(nullptr, GetAudioManager);
332 TestAudioManager* manager = GetAudioManager();
333 ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_USB, &adapter, capturePort);
334 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
335 ret = InitDevDesc(devDesc, capturePort->portId, pins);
336 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
337 ret = adapter->CreateCapture(adapter, &devDesc, attrs, &capture);
338 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
339
340 manager->UnloadAdapter(manager, adapter);
341 }
342 /**
343 * @tc.name Test AudioCreateCapture API via setting the incoming parameter capture is nullptr
344 * @tc.number SUB_Audio_HDI_AudioCreateCapture_0008
345 * @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter capture is nullptr
346 */
347 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0008, Function | MediumTest | Level1)
348 {
349 int32_t ret = -1;
350 struct AudioPort* capturePort = nullptr;
351 struct AudioDeviceDescriptor devDesc = {};
352 struct AudioSampleAttributes attrs = {};
353 enum AudioPortDirection portType = PORT_IN;
354 enum AudioPortPin pins = PIN_IN_MIC;
355 struct AudioAdapter *adapter = nullptr;
356 struct AudioCapture **capture = nullptr;
357
358 ASSERT_NE(nullptr, GetAudioManager);
359 TestAudioManager* manager = GetAudioManager();
360 ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_USB, &adapter, capturePort);
361 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
362 ret = InitAttrs(attrs);
363 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
364 ret = InitDevDesc(devDesc, capturePort->portId, pins);
365 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
366 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, capture);
367 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
368 manager->UnloadAdapter(manager, adapter);
369 }
370 /**
371 * @tc.name Test AudioCreateCapture API via setting the incoming parameter adapter which port type is PORT_OUT
372 * @tc.number SUB_Audio_HDI_AudioCreateCapture_0008
373 * @tc.desc Test AudioCreateCapture interface,Returns -1 if the incoming parameter adapter which port type is PORT_OUT
374 */
375 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioCreateCapture_0009, Function | MediumTest | Level1)
376 {
377 int32_t ret = -1;
378 struct AudioPort* capturePort = nullptr;
379 struct AudioDeviceDescriptor devDesc = {};
380 struct AudioSampleAttributes attrs = {};
381 enum AudioPortDirection portType = PORT_OUT;
382 enum AudioPortPin pins = PIN_OUT_SPEAKER;
383 struct AudioAdapter *adapter = nullptr;
384 struct AudioCapture *capture = nullptr;
385
386 ASSERT_NE(nullptr, GetAudioManager);
387 TestAudioManager* manager = GetAudioManager();
388 ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_HDMI, &adapter, capturePort);
389 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
390 ret = InitAttrs(attrs);
391 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
392 ret = InitDevDesc(devDesc, capturePort->portId, pins);
393 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
394 ret = adapter->CreateCapture(adapter, &devDesc, &attrs, &capture);
395 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
396 adapter->DestroyCapture(adapter, capture);
397 manager->UnloadAdapter(manager, adapter);
398 }
399 /**
400 * @tc.name Test AudioDestroyCapture API via legal input
401 * @tc.number SUB_Audio_HDI_AudioDestroyCapture_0001
402 * @tc.desc Test AudioDestroyCapture interface,Returns 0 if the AudioCapture object is destroyed
403 */
404 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioDestroyCapture_0001, Function | MediumTest | Level1)
405 {
406 int32_t ret = -1;
407 enum AudioPortPin pins = PIN_IN_MIC;
408 struct AudioAdapter *adapter = nullptr;
409 struct AudioCapture *capture = nullptr;
410
411 TestAudioManager* manager = GetAudioManager();
412 ASSERT_NE(nullptr, GetAudioManager);
413 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture);
414 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
415 ret = adapter->DestroyCapture(adapter, capture);
416 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
417 manager->UnloadAdapter(manager, adapter);
418 }
419 /**
420 * @tc.name Test AudioDestroyCapture API via setting the incoming parameter adapter is nullptr
421 * @tc.number SUB_Audio_HDI_AudioDestroyCapture_0002
422 * @tc.desc Test AudioDestroyCapture interface,Returns -1 if the incoming parameter adapter is nullptr
423 */
424 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioDestroyCapture_0002, Function | MediumTest | Level1)
425 {
426 int32_t ret = -1;
427 enum AudioPortPin pins = PIN_IN_MIC;
428 struct AudioAdapter *adapter = nullptr;
429 struct AudioAdapter *adapterNull = nullptr;
430 struct AudioCapture *capture = nullptr;
431
432 TestAudioManager* manager = GetAudioManager();
433 ASSERT_NE(nullptr, GetAudioManager);
434 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture);
435 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
436 ret = adapter->DestroyCapture(adapterNull, capture);
437 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
438 ret = adapter->DestroyCapture(adapter, capture);
439 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
440 manager->UnloadAdapter(manager, adapter);
441 }
442 /**
443 * @tc.name Test AudioDestroyCapture API via setting the incoming parameter capture is nullptr
444 * @tc.number SUB_Audio_HDI_AudioDestroyCapture_0003
445 * @tc.desc Test AudioDestroyCapture interface,Returns -1 if the incoming parameter capture is nullptr
446 */
447 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_AudioDestroyCapture_0003, Function | MediumTest | Level1)
448 {
449 int32_t ret = -1;
450 struct AudioPort* capturePort = nullptr;
451 enum AudioPortDirection portType = PORT_IN;
452 struct AudioAdapter *adapter = nullptr;
453 struct AudioCapture *capture = nullptr;
454
455 ASSERT_NE(nullptr, GetAudioManager);
456 TestAudioManager* manager = GetAudioManager();
457 ret = GetLoadAdapter(manager, portType, ADAPTER_NAME_USB, &adapter, capturePort);
458 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
459 ret = adapter->DestroyCapture(adapter, capture);
460 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
461 manager->UnloadAdapter(manager, adapter);
462 }
463 /**
464 * @tc.name Test AudioCaptureStart API via legal input
465 * @tc.number SUB_Audio_HDI_StartCapture_0001
466 * @tc.desc Test AudioCaptureStart interface,return 0 if the audiocapture object is started successfully
467 */
468 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStart_0001, Function | MediumTest | Level1)
469 {
470 int32_t ret = -1;
471 TestAudioManager* manager = {};
472 enum AudioPortPin pins = PIN_IN_MIC;
473 struct AudioAdapter *adapter = nullptr;
474 struct AudioCapture *capture = nullptr;
475
476 manager = GetAudioManager();
477 ASSERT_NE(nullptr, GetAudioManager);
478 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture);
479 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
480 ret = capture->control.Start((AudioHandle)capture);
481 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
482
483 capture->control.Stop((AudioHandle)capture);
484 adapter->DestroyCapture(adapter, capture);
485 manager->UnloadAdapter(manager, adapter);
486 }
487 /**
488 * @tc.name Test CaptureStart API via setting the incoming parameter handle is nullptr
489 * @tc.number SUB_Audio_HDI_CaptureStart_0002
490 * @tc.desc Test CaptureStart interface,return -1 if the incoming parameter handle is nullptr
491 */
492 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStart_0002, Function | MediumTest | Level1)
493 {
494 int32_t ret = -1;
495 TestAudioManager* manager = {};
496 enum AudioPortPin pins = PIN_IN_MIC;
497 struct AudioAdapter *adapter = nullptr;
498 struct AudioCapture *capture = nullptr;
499 struct AudioCapture *captureNull = nullptr;
500
501 manager = GetAudioManager();
502 ASSERT_NE(nullptr, GetAudioManager);
503 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture);
504 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
505 ret = capture->control.Start((AudioHandle)captureNull);
506 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
507
508 capture->control.Stop((AudioHandle)capture);
509 adapter->DestroyCapture(adapter, capture);
510 manager->UnloadAdapter(manager, adapter);
511 }
512 /**
513 * @tc.name Test AudioCaptureStart API via start two capture object continuously
514 * @tc.number SUB_Audio_HDI_CaptureStart_0003
515 * @tc.desc Test AudioCaptureStart interface,return 0 if the Audiocapturestart was successfully called twice
516 */
517 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStart_0003, Function | MediumTest | Level1)
518 {
519 int32_t ret = -1;
520 TestAudioManager* manager = {};
521 enum AudioPortPin pins = PIN_IN_MIC;
522 struct AudioAdapter *adapter = nullptr;
523 struct AudioCapture *capture = nullptr;
524
525 manager = GetAudioManager();
526 ASSERT_NE(nullptr, GetAudioManager);
527 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture);
528 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
529 ret = capture->control.Start((AudioHandle)capture);
530 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
531 ret = capture->control.Start((AudioHandle)capture);
532 EXPECT_EQ(AUDIO_HAL_ERR_AI_BUSY, ret);
533
534 capture->control.Stop((AudioHandle)capture);
535 adapter->DestroyCapture(adapter, capture);
536 manager->UnloadAdapter(manager, adapter);
537 }
538 /**
539 * @tc.name Test AudioCaptureStop API via legal input
540 * @tc.number SUB_Audio_HDI_CaptureStop_0001
541 * @tc.desc Test AudioCaptureStop interface,return 0 if the audiocapture object is stopped successfully
542 */
543 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0001, Function | MediumTest | Level1)
544 {
545 int32_t ret = -1;
546 TestAudioManager* manager = {};
547 struct AudioAdapter *adapter = nullptr;
548 struct AudioCapture *capture = nullptr;
549
550 manager = GetAudioManager();
551 ASSERT_NE(nullptr, GetAudioManager);
552 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
553 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
554 ret = capture->control.Stop((AudioHandle)capture);
555 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
556
557 adapter->DestroyCapture(adapter, capture);
558 manager->UnloadAdapter(manager, adapter);
559 }
560 /**
561 * @tc.name Test AudioCaptureStop API via stop two capture object continuously
562 * @tc.number SUB_Audio_HDI_CaptureStop_0002
563 * @tc.desc Test AudioCaptureStop interface,return -4 if Audiocapturestop was successfully called twice
564 */
565 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0002, Function | MediumTest | Level1)
566 {
567 int32_t ret = -1;
568 TestAudioManager* manager = {};
569 struct AudioAdapter *adapter = nullptr;
570 struct AudioCapture *capture = nullptr;
571
572 manager = GetAudioManager();
573 ASSERT_NE(nullptr, GetAudioManager);
574 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
575 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
576 ret = capture->control.Stop((AudioHandle)capture);
577 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
578 ret = capture->control.Stop((AudioHandle)capture);
579 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
580
581 adapter->DestroyCapture(adapter, capture);
582 manager->UnloadAdapter(manager, adapter);
583 }
584 /**
585 * @tc.name Test AudioCaptureStop API via start an audio capture after stopping
586 * @tc.number SUB_Audio_HDI_CaptureStop_0003
587 * @tc.desc Test AudioCaptureStop interface,return 0 if stop and start an audio capture successfully
588 */
589 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0003, Function | MediumTest | Level1)
590 {
591 int32_t ret = -1;
592 TestAudioManager* manager = {};
593 struct AudioAdapter *adapter = nullptr;
594 struct AudioCapture *capture = nullptr;
595
596 manager = GetAudioManager();
597 ASSERT_NE(nullptr, GetAudioManager);
598 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
599 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
600 ret = capture->control.Stop((AudioHandle)capture);
601 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
602 ret = capture->control.Start((AudioHandle)capture);
603 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
604
605 capture->control.Stop((AudioHandle)capture);
606 adapter->DestroyCapture(adapter, capture);
607 manager->UnloadAdapter(manager, adapter);
608 }
609 /**
610 * @tc.name Test AudioCaptureStop API via the capture does not start and stop only
611 * @tc.number SUB_Audio_HDI_CaptureStop_0004
612 * @tc.desc Test AudioCaptureStop interface,return -4 if the capture does not start and stop only
613 */
614 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0004, Function | MediumTest | Level1)
615 {
616 int32_t ret = -1;
617 TestAudioManager* manager = {};
618 enum AudioPortPin pins = PIN_IN_MIC;
619 struct AudioAdapter *adapter = nullptr;
620 struct AudioCapture *capture = nullptr;
621
622 manager = GetAudioManager();
623 ASSERT_NE(nullptr, GetAudioManager);
624 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture);
625 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
626 ret = capture->control.Stop((AudioHandle)capture);
627 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
628
629 adapter->DestroyCapture(adapter, capture);
630 manager->UnloadAdapter(manager, adapter);
631 }
632 /**
633 * @tc.name Test CaptureStop API via setting the incoming parameter handle is nullptr
634 * @tc.number SUB_Audio_HDI_CaptureStop_0005
635 * @tc.desc Test CaptureStop interface, return -1 if the incoming parameter handle is nullptr
636 */
637 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureStop_0005, Function | MediumTest | Level1)
638 {
639 int32_t ret = -1;
640 TestAudioManager* manager = {};
641 struct AudioAdapter *adapter = nullptr;
642 struct AudioCapture *capture = nullptr;
643 struct AudioCapture *captureNull = nullptr;
644
645 manager = GetAudioManager();
646 ASSERT_NE(nullptr, GetAudioManager);
647 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
648 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
649 ret = capture->control.Stop((AudioHandle)captureNull);
650 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
651
652 adapter->DestroyCapture(adapter, capture);
653 manager->UnloadAdapter(manager, adapter);
654 }
655 /**
656 * @tc.name Test CapturePause API via legal input
657 * @tc.number SUB_Audio_HDI_CapturePause_0001
658 * @tc.desc test HDI CapturePause interface，return 0 if the capture is paused after start
659 */
660 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0001, Function | MediumTest | Level1)
661 {
662 int32_t ret = -1;
663 TestAudioManager* manager = {};
664 struct AudioAdapter *adapter = nullptr;
665 struct AudioCapture *capture = nullptr;
666
667 manager = GetAudioManager();
668 ASSERT_NE(nullptr, GetAudioManager);
669 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
670 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
671 ret = capture->control.Pause((AudioHandle)capture);
672 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
673
674 ret = capture->control.Stop((AudioHandle)capture);
675 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
676 adapter->DestroyCapture(adapter, capture);
677 manager->UnloadAdapter(manager, adapter);
678 }
679 /**
680 * @tc.name Test CapturePause API via the interface is called twice in a row
681 * @tc.number SUB_Audio_HDI_CapturePause_0002
682 * @tc.desc Test CapturePause interface, return -1 the second time if CapturePause is called twice
683 */
684 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0002, Function | MediumTest | Level1)
685 {
686 int32_t ret = -1;
687 TestAudioManager* manager = {};
688 struct AudioAdapter *adapter = nullptr;
689 struct AudioCapture *capture = nullptr;
690
691 manager = GetAudioManager();
692 ASSERT_NE(nullptr, GetAudioManager);
693 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
694 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
695 ret = capture->control.Pause((AudioHandle)capture);
696 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
697 ret = capture->control.Pause((AudioHandle)capture);
698 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
699
700 ret = capture->control.Stop((AudioHandle)capture);
701 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
702 adapter->DestroyCapture(adapter, capture);
703 manager->UnloadAdapter(manager, adapter);
704 }
705 /**
706 * @tc.name Test CapturePause API via setting the incoming parameter handle is nullptr
707 * @tc.number SUB_Audio_HDI_CapturePause_0003
708 * @tc.desc Test CapturePause interface,return -1 if the incoming parameter handle is nullptr
709 */
710 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0003, Function | MediumTest | Level1)
711 {
712 int32_t ret = -1;
713 TestAudioManager* manager = {};
714 struct AudioAdapter *adapter = nullptr;
715 struct AudioCapture *capture = nullptr;
716 struct AudioCapture *captureNull = nullptr;
717
718 manager = GetAudioManager();
719 ASSERT_NE(nullptr, GetAudioManager);
720 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
721 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
722 ret = capture->control.Pause((AudioHandle)captureNull);
723 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
724
725 ret = capture->control.Stop((AudioHandle)capture);
726 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
727 adapter->DestroyCapture(adapter, capture);
728 manager->UnloadAdapter(manager, adapter);
729 }
730 /**
731 * @tc.name Test CapturePause API via the capture is not Started and paused only.
732 * @tc.number SUB_Audio_HDI_CapturePause_0004
733 * @tc.desc Test AudioRenderPause interface,return -1 if the capture is not Started and paused only.
734 */
735 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0004, Function | MediumTest | Level1)
736 {
737 int32_t ret = -1;
738 TestAudioManager* manager = {};
739 enum AudioPortPin pins = PIN_IN_MIC;
740 struct AudioAdapter *adapter = nullptr;
741 struct AudioCapture *capture = nullptr;
742
743 manager = GetAudioManager();
744 ASSERT_NE(nullptr, GetAudioManager);
745 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture);
746 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
747 ret = capture->control.Pause((AudioHandle)capture);
748 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
749
750 adapter->DestroyCapture(adapter, capture);
751 manager->UnloadAdapter(manager, adapter);
752 }
753 /**
754 * @tc.name Test CapturePause API via the capture is paused after stoped.
755 * @tc.number SUB_Audio_HDI_CapturePause_0005
756 * @tc.desc Test CapturePause interface, return -1 the capture is paused after stoped.
757 */
758 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CapturePause_0005, Function | MediumTest | Level1)
759 {
760 int32_t ret = -1;
761 TestAudioManager* manager = {};
762 struct AudioAdapter *adapter = nullptr;
763 struct AudioCapture *capture = nullptr;
764 manager = GetAudioManager();
765 ASSERT_NE(nullptr, GetAudioManager);
766
767 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
768 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
769 ret = capture->control.Stop((AudioHandle)capture);
770 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
771 ret = capture->control.Pause((AudioHandle)capture);
772 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
773
774 adapter->DestroyCapture(adapter, capture);
775 manager->UnloadAdapter(manager, adapter);
776 }
777 /**
778 * @tc.name Test CaptureResume API via legal input
779 * @tc.number SUB_Audio_HDI_CaptureResume_0001
780 * @tc.desc Test CaptureResume interface,return 0 if the capture is resumed after paused
781 */
782 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0001, Function | MediumTest | Level1)
783 {
784 int32_t ret = -1;
785 TestAudioManager* manager = {};
786 struct AudioAdapter *adapter = nullptr;
787 struct AudioCapture *capture = nullptr;
788
789 manager = GetAudioManager();
790 ASSERT_NE(nullptr, GetAudioManager);
791 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
792 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
793 ret = capture->control.Pause((AudioHandle)capture);
794 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
795 ret = capture->control.Resume((AudioHandle)capture);
796 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
797 ret = capture->control.Stop((AudioHandle)capture);
798 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
799 adapter->DestroyCapture(adapter, capture);
800 manager->UnloadAdapter(manager, adapter);
801 }
802 /**
803 * @tc.name Test CaptureResume API via the interface is called twice in a row
804 * @tc.number SUB_Audio_HDI_CaptureResume_0002
805 * @tc.desc Test CaptureResume interface,return -1 the second time if the CaptureResume is called twice
806 */
807 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0002, Function | MediumTest | Level1)
808 {
809 int32_t ret = -1;
810 TestAudioManager* manager = {};
811 struct AudioAdapter *adapter = nullptr;
812 struct AudioCapture *capture = nullptr;
813
814 manager = GetAudioManager();
815 ASSERT_NE(nullptr, GetAudioManager);
816 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
817 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
818 ret = capture->control.Pause((AudioHandle)capture);
819 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
820 ret = capture->control.Resume((AudioHandle)capture);
821 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
822 ret = capture->control.Resume((AudioHandle)capture);
823 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
824
825 ret = capture->control.Stop((AudioHandle)capture);
826 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
827 adapter->DestroyCapture(adapter, capture);
828 manager->UnloadAdapter(manager, adapter);
829 }
830
831 /**
832 * @tc.name Test CaptureResume API via the capture is resumed after started
833 * @tc.number SUB_Audio_HDI_CaptureResume_0003
834 * @tc.desc test HDI CaptureResume interface,return -1 if the capture is resumed after started
835 */
836 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0003, Function | MediumTest | Level1)
837 {
838 int32_t ret = -1;
839 TestAudioManager* manager = {};
840 struct AudioAdapter *adapter = nullptr;
841 struct AudioCapture *capture = nullptr;
842
843 manager = GetAudioManager();
844 ASSERT_NE(nullptr, GetAudioManager);
845 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
846 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
847 ret = capture->control.Resume((AudioHandle)capture);
848 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
849
850 ret = capture->control.Stop((AudioHandle)capture);
851 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
852 adapter->DestroyCapture(adapter, capture);
853 manager->UnloadAdapter(manager, adapter);
854 }
855 /**
856 * @tc.name Test CaptureResume API via setting the incoming parameter handle is nullptr
857 * @tc.number SUB_Audio_HDI_CaptureResume_0004
858 * @tc.desc Test CaptureResume interface, return -1 if the incoming parameter handle is nullptr
859 */
860 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0004, Function | MediumTest | Level1)
861 {
862 int32_t ret = -1;
863 TestAudioManager* manager = {};
864 struct AudioAdapter *adapter = nullptr;
865 struct AudioCapture *capture = nullptr;
866 struct AudioCapture *captureNull = nullptr;
867
868 manager = GetAudioManager();
869 ASSERT_NE(nullptr, GetAudioManager);
870 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
871 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
872 ret = capture->control.Pause((AudioHandle)capture);
873 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
874 ret = capture->control.Resume((AudioHandle)captureNull);
875 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
876
877 ret = capture->control.Stop((AudioHandle)capture);
878 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
879 adapter->DestroyCapture(adapter, capture);
880 manager->UnloadAdapter(manager, adapter);
881 }
882 /**
883 * @tc.name Test CaptureResume API via the capture is resumed after stopped
884 * @tc.number SUB_Audio_HDI_CaptureResume_0005
885 * @tc.desc test HDI CaptureResume interface,return -1 if the capture is resumed after stopped
886 */
887 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0005, Function | MediumTest | Level1)
888 {
889 int32_t ret = -1;
890 TestAudioManager* manager = {};
891 struct AudioAdapter *adapter = nullptr;
892 struct AudioCapture *capture = nullptr;
893
894 manager = GetAudioManager();
895 ASSERT_NE(nullptr, GetAudioManager);
896 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
897 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
898 ret = capture->control.Stop((AudioHandle)capture);
899 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
900 ret = capture->control.Resume((AudioHandle)capture);
901 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
902
903 adapter->DestroyCapture(adapter, capture);
904 manager->UnloadAdapter(manager, adapter);
905 }
906 /**
907 * @tc.name Test CaptureResume API via the capture Continue to start after resume
908 * @tc.number SUB_Audio_HDI_CaptureResume_0006
909 * @tc.desc test HDI CaptureResume interface,return -1 if the capture Continue to start after resume
910 */
911 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0006, Function | MediumTest | Level1)
912 {
913 int32_t ret = -1;
914 TestAudioManager* manager = {};
915 struct AudioAdapter *adapter = nullptr;
916 struct AudioCapture *capture = nullptr;
917
918 manager = GetAudioManager();
919 ASSERT_NE(nullptr, GetAudioManager);
920 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
921 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
922 ret = capture->control.Pause((AudioHandle)capture);
923 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
924 ret = capture->control.Resume((AudioHandle)capture);
925 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
926 ret = capture->control.Start((AudioHandle)capture);
927 EXPECT_EQ(AUDIO_HAL_ERR_AI_BUSY, ret);
928
929 capture->control.Stop((AudioHandle)capture);
930 adapter->DestroyCapture(adapter, capture);
931 manager->UnloadAdapter(manager, adapter);
932 }
933 /**
934 * @tc.name Test RenderResume API via the different capture objects is started、paused、resumed and stopped.
935 * @tc.number SUB_Audio_HDI_CaptureResume_0007
936 * @tc.desc test HDI CaptureResume interface,return 0 if the different objects is started、paused、resumed and stopped.
937 */
938 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureResume_0007, Function | MediumTest | Level1)
939 {
940 int32_t ret1 = -1;
941 int32_t ret2 = -1;
942 TestAudioManager* manager = {};
943 struct AudioAdapter *adapterOne = nullptr;
944 struct AudioAdapter *adapterSec = nullptr;
945 struct AudioCapture *captureOne = nullptr;
946 struct AudioCapture *captureSec = nullptr;
947 manager = GetAudioManager();
948 ASSERT_NE(nullptr, GetAudioManager);
949 ret1 = AudioCreateStartCapture(manager, &captureOne, &adapterOne, ADAPTER_NAME_USB);
950 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret1);
951 ret1 = captureOne->control.Pause((AudioHandle)captureOne);
952 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret1);
953 ret1 = captureOne->control.Resume((AudioHandle)captureOne);
954 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret1);
955 ret1 = captureOne->control.Stop((AudioHandle)captureOne);
956 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret1);
957 adapterOne->DestroyCapture(adapterOne, captureOne);
958 manager->UnloadAdapter(manager, adapterOne);
959 ret2 = AudioCreateStartCapture(manager, &captureSec, &adapterSec, ADAPTER_NAME_USB);
960 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret2);
961 ret2 = captureSec->control.Pause((AudioHandle)captureSec);
962 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret2);
963 ret2 = captureSec->control.Resume((AudioHandle)captureSec);
964 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret2);
965 ret2 = captureSec->control.Stop((AudioHandle)captureSec);
966 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret2);
967 adapterSec->DestroyCapture(adapterSec, captureSec);
968 manager->UnloadAdapter(manager, adapterSec);
969 }
970 /**
971 * @tc.name Test CaptureFlush API via legal input Verify that the data in the buffer is flushed after stop
972 * @tc.number SUB_Audio_HDI_CaptureFlush_0001
973 * @tc.desc Test CaptureFlush interface,return -2 if the data in the buffer is flushed successfully after stop
974 */
975 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureFlush_0001, Function | MediumTest | Level1)
976 {
977 int32_t ret = -1;
978 TestAudioManager* manager = {};
979 struct AudioAdapter *adapter = nullptr;
980 struct AudioCapture *capture = nullptr;
981
982 manager = GetAudioManager();
983 ASSERT_NE(nullptr, GetAudioManager);
984 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
985 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
986 ret = capture->control.Stop((AudioHandle)capture);
987 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
988 ret = capture->control.Flush((AudioHandle)capture);
989 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
990
991 adapter->DestroyCapture(adapter, capture);
992 manager->UnloadAdapter(manager, adapter);
993 }
994 /**
995 * @tc.name Test CaptureFlush that the data in the buffer is flushed when handle is nullptr
996 * @tc.number SUB_Audio_HDI_CaptureFlush_0002
997 * @tc.desc Test CaptureFlush, return -1 if the data in the buffer is flushed when handle is nullptr
998 */
999 HWTEST_F(AudioHdiCaptureControlTest, SUB_Audio_HDI_CaptureFlush_0002, Function | MediumTest | Level1)
1000 {
1001 int32_t ret = -1;
1002 TestAudioManager* manager = {};
1003 struct AudioAdapter *adapter = nullptr;
1004 struct AudioCapture *capture = nullptr;
1005 struct AudioCapture *captureNull = nullptr;
1006
1007 manager = GetAudioManager();
1008 ASSERT_NE(nullptr, GetAudioManager);
1009 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
1010 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1011 ret = capture->control.Stop((AudioHandle)capture);
1012 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1013 ret = capture->control.Flush((AudioHandle)captureNull);
1014 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1015
1016 adapter->DestroyCapture(adapter, capture);
1017 manager->UnloadAdapter(manager, adapter);
1018 }
1019 }