1 /*
2 * Copyright (c) 2021-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 Defines audio-related APIs, including custom data types and functions for capture drivers
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_attr_test.h"
38
39 using namespace std;
40 using namespace testing::ext;
41 using namespace OHOS::Audio;
42
43 namespace {
44 class AudioHdiCaptureAttrTest : public testing::Test {
45 public:
46 static void SetUpTestCase(void);
47 static void TearDownTestCase(void);
48 void SetUp();
49 void TearDown();
50 int32_t AudioCaptureStart(const string path, struct AudioCapture *capture) const;
51 };
52
53 using THREAD_FUNC = void *(*)(void *);
54
SetUpTestCase(void)55 void AudioHdiCaptureAttrTest::SetUpTestCase(void) {}
56
TearDownTestCase(void)57 void AudioHdiCaptureAttrTest::TearDownTestCase(void) {}
58
SetUp(void)59 void AudioHdiCaptureAttrTest::SetUp(void) {}
TearDown(void)60 void AudioHdiCaptureAttrTest::TearDown(void) {}
61
AudioCaptureStart(const string path,struct AudioCapture * capture) const62 int32_t AudioHdiCaptureAttrTest::AudioCaptureStart(const string path, struct AudioCapture *capture) const
63 {
64 int32_t ret = -1;
65 struct AudioSampleAttributes attrs = {};
66 if (capture == nullptr) {
67 return AUDIO_HAL_ERR_INVALID_PARAM;
68 }
69 ret = InitAttrs(attrs);
70 if (ret < 0) {
71 return ret;
72 }
73 FILE *file = fopen(path.c_str(), "wb+");
74 if (file == nullptr) {
75 return HDF_FAILURE;
76 }
77 ret = FrameStartCapture(capture, file, attrs);
78 (void)fclose(file);
79 return ret;
80 }
81
82 /**
83 * @tc.name Test AudioCaptureSetSampleAttributes API via legal input.
84 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0002
85 * @tc.desc Test AudioCaptureSetSampleAttributes with the following parameter settings
86 * attrs.type = AUDIO_IN_MEDIA;
87 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
88 * attrs.sampleRate = 11025;
89 * attrs.channelCount = 2;
90 */
91 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0002, Function | MediumTest | Level1)
92 {
93 int32_t ret = -1;
94 uint32_t ret1 = 2;
95 uint32_t ret2 = 11025;
96 struct AudioSampleAttributes attrs = {};
97 struct AudioSampleAttributes attrsValue = {};
98 struct AudioAdapter *adapter = nullptr;
99 struct AudioCapture *capture = nullptr;
100
101 TestAudioManager* manager = GetAudioManagerFuncs();
102 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
103 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
104 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 11025);
105
106 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
107 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
108 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
109 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
110 EXPECT_EQ(ret2, attrsValue.sampleRate);
111 EXPECT_EQ(ret1, attrsValue.channelCount);
112
113 adapter->DestroyCapture(adapter, capture);
114 manager->UnloadAdapter(manager, adapter);
115 }
116 /**
117 * @tc.name Test AudioCaptureSetSampleAttributes API via legal input.
118 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0004
119 * @tc.desc Test AudioCaptureSetSampleAttributes with the following parameter settings
120 * attrs.type = AUDIO_IN_MEDIA;
121 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
122 * attrs.sampleRate = 32000;
123 * attrs.channelCount = 2;
124 */
125 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0004, Function | MediumTest | Level1)
126 {
127 int32_t ret = -1;
128 uint32_t ret1 = 2;
129 uint32_t ret2 = 32000;
130 struct AudioSampleAttributes attrs = {};
131 struct AudioSampleAttributes attrsValue = {};
132 struct AudioAdapter *adapter = nullptr;
133 struct AudioCapture *capture = nullptr;
134
135 TestAudioManager* manager = GetAudioManagerFuncs();
136 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
137 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
138 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 32000);
139
140 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
141 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
142 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
143 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
144 EXPECT_EQ(ret2, attrsValue.sampleRate);
145 EXPECT_EQ(ret1, attrsValue.channelCount);
146
147 adapter->DestroyCapture(adapter, capture);
148 manager->UnloadAdapter(manager, adapter);
149 }
150 /**
151 * @tc.name Test AudioCaptureSetSampleAttributes API via legal input.
152 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0006
153 * @tc.desc Test AudioCaptureSetSampleAttributes with the following parameter settings
154 * attrs.type = AUDIO_IN_COMMUNICATION;
155 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
156 * attrs.sampleRate = 48000;
157 * attrs.channelCount = 2;
158 */
159 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0006, Function | MediumTest | Level1)
160 {
161 int32_t ret = -1;
162 uint32_t ret1 = 2;
163 uint32_t ret2 = 48000;
164 struct AudioSampleAttributes attrs = {};
165 struct AudioSampleAttributes attrsValue = {};
166 struct AudioAdapter *adapter = nullptr;
167 struct AudioCapture *capture = nullptr;
168
169 TestAudioManager* manager = GetAudioManagerFuncs();
170 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
171 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
172 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 48000);
173
174 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
175 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
176 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
177 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
178 EXPECT_EQ(ret2, attrsValue.sampleRate);
179 EXPECT_EQ(ret1, attrsValue.channelCount);
180
181 adapter->DestroyCapture(adapter, capture);
182 manager->UnloadAdapter(manager, adapter);
183 }
184 /**
185 * @tc.name Test AudioCaptureSetSampleAttributes API via setting the capture is empty .
186 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0007
187 * @tc.desc Test AudioCaptureSetSampleAttributes , and check if -1 is returned when the parameter capture is empty
188 */
189 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0007, Function | MediumTest | Level1)
190 {
191 int32_t ret = -1;
192 struct AudioSampleAttributes attrs = {};
193 struct AudioAdapter *adapter = nullptr;
194 struct AudioCapture *capture = nullptr;
195 struct AudioCapture *captureNull = nullptr;
196
197 TestAudioManager* manager = GetAudioManagerFuncs();
198 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
199 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
200 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 8000);
201
202 ret = capture->attr.SetSampleAttributes(captureNull, &attrs);
203 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
204 ret = capture->attr.SetSampleAttributes(capture, nullptr);
205 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
206
207 adapter->DestroyCapture(adapter, capture);
208 manager->UnloadAdapter(manager, adapter);
209 }
210 /**
211 * @tc.name Test AudioCaptureSetSampleAttributes API via legal input.
212 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0010
213 * @tc.desc Test AudioCaptureSetSampleAttributes with the following parameter settings
214 * attrs.type = AUDIO_IN_MEDIA;
215 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
216 * attrs.sampleRate = 24000;
217 * attrs.channelCount = 2;
218 */
219 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0010, Function | MediumTest | Level1)
220 {
221 int32_t ret = -1;
222 uint32_t ret1 = 2;
223 uint32_t ret2 = 24000;
224 struct AudioSampleAttributes attrs = {};
225 struct AudioSampleAttributes attrsValue = {};
226 struct AudioAdapter *adapter = nullptr;
227 struct AudioCapture *capture = nullptr;
228
229 TestAudioManager* manager = GetAudioManagerFuncs();
230 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
231 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
232 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 24000);
233
234 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
235 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
236
237 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
238 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
239 EXPECT_EQ(ret2, attrsValue.sampleRate);
240 EXPECT_EQ(ret1, attrsValue.channelCount);
241
242 adapter->DestroyCapture(adapter, capture);
243 manager->UnloadAdapter(manager, adapter);
244 }
245 /**
246 * @tc.name Test AudioCaptureSetSampleAttributes API via illegal input.
247 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0013
248 * @tc.desc Test AudioCaptureSetSampleAttributes with the following parameter settings
249 * attrs.type = AUDIO_IN_MEDIA;
250 * attrs.format = AUDIO_FORMAT_PCM_16;
251 * attrs.sampleRate = 0xFFFFFFFFu;
252 * attrs.channelCount = 2;
253 */
254 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0013, Function | MediumTest | Level1)
255 {
256 int32_t ret = -1;
257 struct AudioSampleAttributes attrs = {};
258 struct AudioAdapter *adapter = nullptr;
259 struct AudioCapture *capture = nullptr;
260
261 TestAudioManager* manager = GetAudioManagerFuncs();
262 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
263 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
264 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 0xFFFFFFFFu);
265
266 ret = capture->attr.SetSampleAttributes(capture, &attrs);
267 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
268
269 adapter->DestroyCapture(adapter, capture);
270 manager->UnloadAdapter(manager, adapter);
271 }
272 /**
273 * @tc.name Test AudioCaptureSetSampleAttributes API via illegal input.
274 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0014
275 * @tc.desc Test AudioCaptureSetSampleAttributes with the following parameter settings
276 * attrs.type = AUDIO_IN_MEDIA;
277 * attrs.format = AUDIO_FORMAT_PCM_8/32_BIT/AAC_MAIN;
278 * attrs.sampleRate = 8000/11025/22050;
279 * attrs.channelCount = 1/2;
280 */
281 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0014, Function | MediumTest | Level1)
282 {
283 int32_t ret = -1;
284 struct AudioSampleAttributes attrs1 = {};
285 struct AudioSampleAttributes attrs2 = {};
286 struct AudioSampleAttributes attrs3 = {};
287 struct AudioAdapter *adapter = nullptr;
288 struct AudioCapture *capture = nullptr;
289
290 TestAudioManager* manager = GetAudioManagerFuncs();
291 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
292 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
293
294 InitAttrsUpdate(attrs1, AUDIO_FORMAT_PCM_8_BIT, 1, 8000);
295 ret = capture->attr.SetSampleAttributes(capture, &attrs1);
296 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
297
298 InitAttrsUpdate(attrs2, AUDIO_FORMAT_PCM_32_BIT, 2, 11025);
299 ret = capture->attr.SetSampleAttributes(capture, &attrs2);
300 #ifdef ALSA_LIB_MODE
301 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
302 #else
303 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
304 #endif
305 InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_MAIN, 1, 22050);
306 ret = capture->attr.SetSampleAttributes(capture, &attrs3);
307 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
308
309 adapter->DestroyCapture(adapter, capture);
310 manager->UnloadAdapter(manager, adapter);
311 }
312 /**
313 * @tc.name Test AudioCaptureSetSampleAttributes API via illegal input.
314 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0015
315 * @tc.desc Test AudioCaptureSetSampleAttributes with the following parameter settings
316 * attrs.type = AUDIO_IN_MEDIA;
317 * attrs.format = AUDIO_FORMAT_AAC_LC/LD/ELD;
318 * attrs.sampleRate = 32000/44100/48000;
319 * attrs.channelCount = 1/2;
320 */
321 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0015, Function | MediumTest | Level1)
322 {
323 int32_t ret = -1;
324 struct AudioSampleAttributes attrs1 = {};
325 struct AudioSampleAttributes attrs2 = {};
326 struct AudioSampleAttributes attrs3 = {};
327 struct AudioAdapter *adapter = nullptr;
328 struct AudioCapture *capture = nullptr;
329
330 TestAudioManager* manager = GetAudioManagerFuncs();
331 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
332 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
333
334 InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_LC, 2, 32000);
335 ret = capture->attr.SetSampleAttributes(capture, &attrs1);
336 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
337
338 InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_LD, 1, 44100);
339 ret = capture->attr.SetSampleAttributes(capture, &attrs2);
340 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
341
342 InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_ELD, 2, 48000);
343 ret = capture->attr.SetSampleAttributes(capture, &attrs3);
344 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
345
346 adapter->DestroyCapture(adapter, capture);
347 manager->UnloadAdapter(manager, adapter);
348 }
349 /**
350 * @tc.name Test AudioCaptureSetSampleAttributes API via illegal input.
351 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0016
352 * @tc.desc Test AudioCaptureSetSampleAttributes with the following parameter settings
353 * attrs.type = AUDIO_IN_MEDIA;
354 * attrs.format = AUDIO_FORMAT_AAC_HE_V1/V2
355 * attrs.sampleRate = 8000/44100;
356 * attrs.channelCount = 1/2;
357 */
358 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0016, Function | MediumTest | Level1)
359 {
360 int32_t ret = -1;
361 struct AudioSampleAttributes attrs1 = {};
362 struct AudioSampleAttributes attrs2 = {};
363 struct AudioAdapter *adapter = nullptr;
364 struct AudioCapture *capture = nullptr;
365
366 TestAudioManager* manager = GetAudioManagerFuncs();
367 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
368 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
369
370 InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_HE_V1, 1, 8000);
371 ret = capture->attr.SetSampleAttributes(capture, &attrs1);
372 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
373
374 InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_HE_V2, 2, 44100);
375 ret = capture->attr.SetSampleAttributes(capture, &attrs2);
376 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
377
378 adapter->DestroyCapture(adapter, capture);
379 manager->UnloadAdapter(manager, adapter);
380 }
381 /**
382 * @tc.name Test AudioCaptureSetSampleAttributes API via illegal input.
383 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0017
384 * @tc.desc Test AudioCaptureSetSampleAttributes with the following parameter settings
385 * attrs.type = AUDIO_IN_MEDIA;
386 * attrs.format = AUDIO_FORMAT_PCM_16_BIT
387 * attrs.sampleRate = 8000;
388 * attrs.channelCount = 5;
389 */
390 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0017, Function | MediumTest | Level1)
391 {
392 int32_t ret = -1;
393 struct AudioSampleAttributes attrs = {};
394 struct AudioAdapter *adapter = nullptr;
395 struct AudioCapture *capture = nullptr;
396
397 TestAudioManager* manager = GetAudioManagerFuncs();
398 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
399 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
400
401 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 5, 8000);
402 ret = capture->attr.SetSampleAttributes(capture, &attrs);
403 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
404
405 adapter->DestroyCapture(adapter, capture);
406 manager->UnloadAdapter(manager, adapter);
407 }
408 /**
409 * @tc.name Test AudioCaptureGetSampleAttributes API via setting the capture is empty .
410 * @tc.number SUB_Audio_HDI_AudioCaptureGetSampleAttributes_0002
411 * @tc.desc Test AudioCaptureGetSampleAttributes , and check if -1 is returned when the parameter capture is empty.
412 */
413 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureGetSampleAttributes_0002, Function | MediumTest | Level1)
414 {
415 int32_t ret = -1;
416 struct AudioSampleAttributes attrs = {};
417 struct AudioAdapter *adapter = nullptr;
418 struct AudioCapture *capture = nullptr;
419 struct AudioCapture *captureNull = nullptr;
420
421 TestAudioManager* manager = GetAudioManagerFuncs();
422 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
423 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
424 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 48000);
425
426 ret = capture->attr.GetSampleAttributes(captureNull, &attrs);
427 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
428 ret = capture->attr.GetSampleAttributes(capture, nullptr);
429 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
430
431 adapter->DestroyCapture(adapter, capture);
432 manager->UnloadAdapter(manager, adapter);
433 }
434 /**
435 * @tc.name Test AudioCaptureGetFrameSize API via legal input
436 * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0001
437 * @tc.desc Test AudioCaptureGetFrameSize , and check if 0 is returned when the API is called successfully.
438 */
439 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0001, Function | MediumTest | Level1)
440 {
441 int32_t ret = -1;
442 uint64_t size = 0;
443 struct AudioAdapter *adapter = nullptr;
444 struct AudioCapture *capture = nullptr;
445
446 TestAudioManager* manager = GetAudioManagerFuncs();
447 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
448 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
449 ret = capture->attr.GetFrameSize(capture, &size);
450 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
451 EXPECT_GT(size, INITIAL_VALUE);
452
453 adapter->DestroyCapture(adapter, capture);
454 manager->UnloadAdapter(manager, adapter);
455 }
456 /**
457 * @tc.name Test AudioCaptureGetFrameSize API via setting the parameter handle is nullptr
458 * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0002
459 * @tc.desc Test AudioCaptureGetFrameSize API , and check if -1 is returned when the parameter handle is nullptr.
460 */
461 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0002, Function | MediumTest | Level1)
462 {
463 int32_t ret = -1;
464 uint64_t size = 0;
465 struct AudioAdapter *adapter = nullptr;
466 struct AudioCapture *capture = nullptr;
467 struct AudioCapture *captureNull = nullptr;
468
469 TestAudioManager* manager = GetAudioManagerFuncs();
470 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
471 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
472
473 ret = capture->attr.GetFrameSize(captureNull, &size);
474 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
475
476 adapter->DestroyCapture(adapter, capture);
477 manager->UnloadAdapter(manager, adapter);
478 }
479 /**
480 * @tc.name Test AudioCaptureGetFrameSize API via setting the parameter size is nullptr
481 * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0003
482 * @tc.desc Test AudioCaptureGetFrameSize API, and check if -1 is returned when the parameter size is nullptr.
483 */
484 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0003, Function | MediumTest | Level1)
485 {
486 int32_t ret = -1;
487 uint64_t *sizeNull = nullptr;
488 struct AudioAdapter *adapter = nullptr;
489 struct AudioCapture *capture = nullptr;
490
491 TestAudioManager* manager = GetAudioManagerFuncs();
492 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
493 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
494
495 ret = capture->attr.GetFrameSize(capture, sizeNull);
496 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
497
498 adapter->DestroyCapture(adapter, capture);
499 manager->UnloadAdapter(manager, adapter);
500 }
501 /**
502 * @tc.name Test CaptureGetFrameSize API via define format to different values
503 * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0004
504 * @tc.desc Test AudioCaptureGetFrameSize API, and check if 0 is returned when the parameter format is set to different values
505 */
506 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0004, Function | MediumTest | Level1)
507 {
508 int32_t ret = -1;
509 uint64_t size = 0;
510 uint64_t channelCountExp = 2;
511 uint32_t sampleRateExp = 48000;
512 struct AudioSampleAttributes attrs = {};
513 struct AudioSampleAttributes attrsValue = {};
514 struct AudioAdapter *adapter = nullptr;
515 struct AudioCapture *capture = nullptr;
516
517 TestAudioManager* manager = GetAudioManagerFuncs();
518 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
519 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
520 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 48000);
521
522 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
523 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
524 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
525 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
526 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
527
528 ret = capture->attr.GetFrameSize(capture, &size);
529 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
530 EXPECT_GT(size, INITIAL_VALUE);
531
532 adapter->DestroyCapture(adapter, capture);
533 manager->UnloadAdapter(manager, adapter);
534 }
535 /**
536 * @tc.name Test CaptureGetFrameSize API via define channelCount to different values
537 * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0006
538 * @tc.desc Test AudioCaptureGetFrameSize API, and check if 0 is returned when channelCount is set to different values
539 */
540 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0006, Function | MediumTest | Level1)
541 {
542 int32_t ret = -1;
543 uint64_t size = 0;
544 uint64_t channelCountExp = 2;
545 uint32_t sampleRateExp = 44100;
546 struct AudioSampleAttributes attrs = {};
547 struct AudioSampleAttributes attrsValue = {};
548 struct AudioAdapter *adapter = nullptr;
549 struct AudioCapture *capture = nullptr;
550
551 TestAudioManager* manager = GetAudioManagerFuncs();
552 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
553 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
554 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 44100);
555
556 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
557 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
558 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
559 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
560 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
561
562 ret = capture->attr.GetFrameSize(capture, &size);
563 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
564 EXPECT_GT(size, INITIAL_VALUE);
565
566 adapter->DestroyCapture(adapter, capture);
567 manager->UnloadAdapter(manager, adapter);
568 }
569 /**
570 * @tc.name Test AudioCaptureGetFrameCount API via legal input
571 * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0001
572 * @tc.desc Test the AudioCaptureGetFrameCount API, and check if 0 is returned when the API is called after creating the object.
573 */
574 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0001, Function | MediumTest | Level1)
575 {
576 int32_t ret = -1;
577 uint64_t count = 0;
578 struct AudioAdapter *adapter = nullptr;
579 struct AudioCapture *capture = nullptr;
580
581 TestAudioManager* manager = GetAudioManagerFuncs();
582 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
583 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
584
585 ret = capture->attr.GetFrameCount(capture, &count);
586 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
587 EXPECT_EQ(count, INITIAL_VALUE);
588
589 adapter->DestroyCapture(adapter, capture);
590 manager->UnloadAdapter(manager, adapter);
591 }
592 /**
593 * @tc.name Test AudioCaptureGetFrameCount API via legal input in the difference scene
594 * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0001
595 * @tc.desc Test the AudioCaptureGetFrameCount API, and check if 0 is returned when the API is called after being started.
596 */
597 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0002, Function | MediumTest | Level1)
598 {
599 int32_t ret = -1;
600 uint64_t count = 0;
601 struct AudioAdapter *adapter = nullptr;
602 struct AudioCapture *capture = nullptr;
603
604 TestAudioManager* manager = GetAudioManagerFuncs();
605 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
606 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
607
608 ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture);
609 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
610
611 ret = capture->attr.GetFrameCount(capture, &count);
612 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
613 EXPECT_GT(count, INITIAL_VALUE);
614
615 capture->control.Stop((AudioHandle)capture);
616 adapter->DestroyCapture(adapter, capture);
617 manager->UnloadAdapter(manager, adapter);
618 }
619 /**
620 * @tc.name Test AudioCaptureGetFrameCount API via setting the parameter handle is nullptr
621 * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0003
622 * @tc.desc Test the AudioCaptureGetFrameCount API, and check if -1 is returned when the parameter handle is nullptr.
623 */
624 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0003, Function | MediumTest | Level1)
625 {
626 int32_t ret = -1;
627 uint64_t count = 0;
628 struct AudioAdapter *adapter = nullptr;
629 struct AudioCapture *capture = nullptr;
630 struct AudioCapture *captureNull = nullptr;
631
632 TestAudioManager* manager = GetAudioManagerFuncs();
633 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
634 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
635
636 ret = capture->attr.GetFrameCount(captureNull, &count);
637 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
638
639 adapter->DestroyCapture(adapter, capture);
640 manager->UnloadAdapter(manager, adapter);
641 }
642
643 /**
644 * @tc.name Test AudioCaptureGetFrameCount API via setting the parameter handle is nullptr
645 * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0004
646 * @tc.desc Test the AudioCaptureGetFrameCount API, and check if -1 is returned when the parameter handle is nullptr.
647 */
648 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0004, Function | MediumTest | Level1)
649 {
650 int32_t ret = -1;
651 uint64_t *countNull = nullptr;
652 struct AudioAdapter *adapter = nullptr;
653 struct AudioCapture *capture = nullptr;
654
655 TestAudioManager* manager = GetAudioManagerFuncs();
656 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
657 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
658
659 ret = capture->attr.GetFrameCount(capture, countNull);
660 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
661
662 adapter->DestroyCapture(adapter, capture);
663 manager->UnloadAdapter(manager, adapter);
664 }
665 /**
666 * @tc.name Test CaptureGetFrameCount API via define channelCount to different values
667 * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0005
668 * @tc.desc Test the AudioCaptureGetFrameCount API, and check if 0 is returned when channelCount is set to different values
669 */
670 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0005, Function | MediumTest | Level1)
671 {
672 int32_t ret = -1;
673 uint64_t count = 0;
674 uint64_t channelCountExp = 2;
675 uint32_t sampleRateExp = 8000;
676 struct AudioAdapter *adapter = nullptr;
677 struct AudioCapture *capture = nullptr;
678 struct AudioSampleAttributes attrs = {};
679 struct AudioSampleAttributes attrsValue = {};
680
681 TestAudioManager* manager = GetAudioManagerFuncs();
682 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
683 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
684 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 8000);
685
686 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
687 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
688 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
689 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
690 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
691
692 ret = AudioCaptureStartAndOneFrame(capture);
693 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
694 ret = capture->attr.GetFrameCount(capture, &count);
695 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
696 EXPECT_GT(count, INITIAL_VALUE);
697
698 ret = capture->control.Stop((AudioHandle)capture);
699 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
700 adapter->DestroyCapture(adapter, capture);
701 manager->UnloadAdapter(manager, adapter);
702 }
703 /**
704 * @tc.name Test CaptureGetFrameCount API via define format to different values
705 * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0006
706 * @tc.desc Test the AudioCaptureGetFrameCount API, and check if 0 is returned when format is set to different values
707 */
708 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0006, Function | MediumTest | Level1)
709 {
710 int32_t ret = -1;
711 uint64_t count = 0;
712 uint64_t channelCountExp = 2;
713 uint32_t sampleRateExp = 8000;
714 struct AudioAdapter *adapter = nullptr;
715 struct AudioCapture *capture = nullptr;
716 struct AudioSampleAttributes attrs = {};
717 struct AudioSampleAttributes attrsValue = {};
718
719 TestAudioManager* manager = GetAudioManagerFuncs();
720 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
721 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
722 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 8000);
723
724 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
725 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
726 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
727 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
728 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
729
730 ret = AudioCaptureStartAndOneFrame(capture);
731 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
732 ret = capture->attr.GetFrameCount(capture, &count);
733 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
734 EXPECT_GT(count, INITIAL_VALUE);
735
736 ret = capture->control.Stop((AudioHandle)capture);
737 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
738 adapter->DestroyCapture(adapter, capture);
739 manager->UnloadAdapter(manager, adapter);
740 }
741
742 /**
743 * @tc.name Test CaptureGetCurrentChannelId API via legal input
744 * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0001
745 * @tc.desc Test the GetCurrentChannelId API, and check if 0 is returned when the default CurrentChannelId is obtained successfully
746 */
747 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0001, Function | MediumTest | Level1)
748 {
749 int32_t ret = -1;
750 uint32_t channelId = 0;
751 uint32_t channelIdValue = CHANNELCOUNT;
752 struct AudioAdapter *adapter = nullptr;
753 struct AudioCapture *capture = nullptr;
754
755 TestAudioManager* manager = GetAudioManagerFuncs();
756 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
757 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
758
759 ret = capture->attr.GetCurrentChannelId(capture, &channelId);
760 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
761 EXPECT_EQ(channelIdValue, channelId);
762
763 adapter->DestroyCapture(adapter, capture);
764 manager->UnloadAdapter(manager, adapter);
765 }
766 /**
767 * @tc.name Test GetCurrentChannelId API via CurrentChannelId is obtained after started
768 * @tc.number SUB_Audio_HDI_CaptureGetCurrentChannelId_0003
769 * @tc.desc Test the GetCurrentChannelId API, and check if 0 is returned when CurrentChannelId is obtained
770 */
771 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0003, Function | MediumTest | Level1)
772 {
773 int32_t ret = -1;
774 uint32_t channelId = 0;
775 uint32_t channelIdExp = 2;
776 struct AudioAdapter *adapter = nullptr;
777 struct AudioCapture *capture = nullptr;
778
779 TestAudioManager* manager = GetAudioManagerFuncs();
780 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
781 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
782 ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture);
783 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
784
785 ret = capture->attr.GetCurrentChannelId(capture, &channelId);
786 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
787 EXPECT_EQ(channelIdExp, channelId);
788
789 capture->control.Stop((AudioHandle)capture);
790 adapter->DestroyCapture(adapter, capture);
791 manager->UnloadAdapter(manager, adapter);
792 }
793 /**
794 * @tc.name Test GetCurrentChannelId API via setting the parameter capture is nullptr
795 * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0004
796 * @tc.desc Test the GetCurrentChannelId API, and check if -1 is returned when the parameter capture is nullptr
797 */
798 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0004, Function | MediumTest | Level1)
799 {
800 int32_t ret = -1;
801 uint32_t channelId = 0;
802 struct AudioAdapter *adapter = nullptr;
803 struct AudioCapture *capture = nullptr;
804 struct AudioCapture *captureNull = nullptr;
805
806 TestAudioManager* manager = GetAudioManagerFuncs();
807 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
808 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
809
810 ret = capture->attr.GetCurrentChannelId(captureNull, &channelId);
811 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
812
813 adapter->DestroyCapture(adapter, capture);
814 manager->UnloadAdapter(manager, adapter);
815 }
816 /**
817 * @tc.name Test CaptureGetCurrentChannelId API via setting the parameter channelId is nullptr
818 * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0005
819 * @tc.desc Test the GetCurrentChannelId API, and check if -1 is returned when the parameter channelId is nullptr
820 */
821 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0005, Function | MediumTest | Level1)
822 {
823 int32_t ret = -1;
824 uint32_t *channelIdNull = nullptr;
825 struct AudioAdapter *adapter = nullptr;
826 struct AudioCapture *capture = nullptr;
827
828 TestAudioManager* manager = GetAudioManagerFuncs();
829 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
830 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
831
832 ret = capture->attr.GetCurrentChannelId(capture, channelIdNull);
833 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
834
835 adapter->DestroyCapture(adapter, capture);
836 manager->UnloadAdapter(manager, adapter);
837 }
838 /**
839 * @tc.name Test CaptureSetExtraParams API via setting ExtraParams during playback
840 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0001
841 * @tc.desc Test the CaptureSetExtraParams API,and check if -1 is returned when ExtraParams is set during playback
842 */
843 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0001, Function | MediumTest | Level1)
844 {
845 int32_t ret = -1;
846 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
847 char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-sampling-rate=48000";
848 size_t index = 1;
849 char keyValueListValue[256] = {};
850 int32_t listLenth = 256;
851 uint64_t FILESIZE = 1024;
852 struct PrepareAudioPara audiopara = {
853 .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_IN_MIC,
854 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
855 };
856
857 audiopara.manager = GetAudioManagerFuncs();
858 ASSERT_NE(nullptr, audiopara.manager);
859
860 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
861 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
862 sleep(1);
863 if (audiopara.capture != nullptr) {
864 ret = audiopara.capture->attr.SetExtraParams((AudioHandle)audiopara.capture, keyValueList);
865 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
866 ret = audiopara.capture->attr.GetExtraParams((AudioHandle)audiopara.capture, keyValueListValue, listLenth);
867 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
868 string strGetValue = keyValueListValue;
869 size_t indexAttr = strGetValue.find("attr-frame-count");
870 size_t indexFlag = strGetValue.rfind(";");
871 if (indexAttr != string::npos && indexFlag != string::npos) {
872 strGetValue.replace(indexAttr, indexFlag - indexAttr + index, "");
873 }
874 EXPECT_STREQ(keyValueListExp, strGetValue.c_str());
875 }
876
877 ret = ThreadRelease(audiopara);
878 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
879 }
880 /**
881 * @tc.name Test CaptureSetExtraParams API via setting some parameters after playing
882 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0002
883 * @tc.desc Test the CaptureSetExtraParams API,and check if 0 is returned when some parameters are set after media playback
884 */
885 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0002, Function | MediumTest | Level1)
886 {
887 int32_t ret = -1;
888 struct AudioAdapter *adapter = {};
889 struct AudioCapture *capture = nullptr;
890 char keyValueListOne[] = "attr-frame-count=4096;";
891 char keyValueListOneExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=4096;\
892 attr-sampling-rate=48000";
893 char keyValueListTwo[] = "attr-route=1;attr-frame-count=1024;";
894 char keyValueListTwoExp[] = "attr-route=1;attr-format=16;attr-channels=2;attr-frame-count=1024;\
895 attr-sampling-rate=48000";
896 char keyValueListThr[] = "attr-route=0;attr-channels=1;attr-frame-count=4096;";
897 char keyValueListThrExp[] = "attr-route=0;attr-format=16;attr-channels=1;attr-frame-count=4096;\
898 attr-sampling-rate=48000";
899 char keyValueListFour[] = "attr-format=32;attr-channels=2;attr-frame-count=4096;attr-sampling-rate=48000";
900 char keyValueListFourExp[] = "attr-route=0;attr-format=32;attr-channels=2;attr-frame-count=4096;\
901 attr-sampling-rate=48000";
902 char keyValueListValueOne[256] = {};
903 char keyValueListValueTwo[256] = {};
904 char keyValueListValueThr[256] = {};
905 char keyValueListValueFour[256] = {};
906 int32_t listLenth = 256;
907
908 TestAudioManager* manager = GetAudioManagerFuncs();
909 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
910 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
911
912 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListOne);
913 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
914 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueOne, listLenth);
915 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
916 EXPECT_STREQ(keyValueListOneExp, keyValueListValueOne);
917 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListTwo);
918 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
919 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueTwo, listLenth);
920 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
921 EXPECT_STREQ(keyValueListTwoExp, keyValueListValueTwo);
922 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListThr);
923 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
924 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueThr, listLenth);
925 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
926 EXPECT_STREQ(keyValueListThrExp, keyValueListValueThr);
927 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListFour);
928 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
929 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueFour, listLenth);
930 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
931 EXPECT_STREQ(keyValueListFourExp, keyValueListValueFour);
932
933 ret = capture->control.Stop((AudioHandle)capture);
934 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
935 adapter->DestroyCapture(adapter, capture);
936 manager->UnloadAdapter(manager, adapter);
937 }
938 /**
939 * @tc.name Test CaptureSetExtraParams API via setting keyvaluelist to a value outside the range
940 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0003
941 * @tc.desc Test the CaptureSetExtraParams API,and check if -1 is returned when Keyvaluelist is set to a value out of the value range
942 */
943 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0003, Function | MediumTest | Level1)
944 {
945 int32_t ret = -1;
946 struct AudioAdapter *adapter = {};
947 struct AudioCapture *capture = nullptr;
948 char keyValueList[] = "attr-para=abc;";
949
950
951 TestAudioManager* manager = GetAudioManagerFuncs();
952 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
953 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
954 ret = ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
955 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
956
957 adapter->DestroyCapture(adapter, capture);
958 manager->UnloadAdapter(manager, adapter);
959 }
960 /**
961 * @tc.name Test CaptureSetExtraParams API via adding parameters to keyvaluelist
962 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0004
963 * @tc.desc Test the CaptureSetExtraParams API,and check if -1 is returned when parameters are added to keyvaluelist.
964 */
965 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0004, Function | MediumTest | Level1)
966 {
967 int32_t ret = -1;
968 struct AudioAdapter *adapter = {};
969 struct AudioCapture *capture = nullptr;
970 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000;\
971 attr-para=abc";
972
973
974 TestAudioManager* manager = GetAudioManagerFuncs();
975 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
976 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
977 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
978 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
979
980 adapter->DestroyCapture(adapter, capture);
981 manager->UnloadAdapter(manager, adapter);
982 }
983 /**
984 * @tc.name Test CaptureSetExtraParams API via setting ExtraParams When the key is the same and the value is
985 different
986 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0005
987 * @tc.desc Test the CaptureSetExtraParams API,and check if 0 is returned when two keys with the same name but different values are set.
988 is different
989 */
990 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0005, Function | MediumTest | Level1)
991 {
992 int32_t ret = -1;
993 struct AudioAdapter *adapter = {};
994 struct AudioCapture *capture = nullptr;
995 char keyValueList[] = "attr-route=1;attr-format=32;attr-frame-count=4096;";
996 char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=4096;\
997 attr-sampling-rate=48000";
998 char keyValueListValue[256] = {};
999 int32_t listLenth = 256;
1000
1001
1002 TestAudioManager* manager = GetAudioManagerFuncs();
1003 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
1004 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1005 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
1006 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1007 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValue, listLenth);
1008 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1009 EXPECT_STREQ(keyValueListExp, keyValueListValue);
1010
1011 ret = capture->control.Stop((AudioHandle)capture);
1012 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1013 adapter->DestroyCapture(adapter, capture);
1014 manager->UnloadAdapter(manager, adapter);
1015 }
1016 /**
1017 * @tc.name Test CaptureSetExtraParams API via setting the parameter in keyvaluelist as an abnormal value
1018 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0006
1019 * @tc.desc Test the CaptureSetExtraParams API,and check if -1 is returned when the parameter in keyvaluelist is set to an invalid value
1020 */
1021 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0006, Function | MediumTest | Level1)
1022 {
1023 int32_t ret = -1;
1024 struct AudioAdapter *adapter = {};
1025 struct AudioCapture *capture = nullptr;
1026 char attrSamplingRateError[] = "attr-sampling-rate=1234567;";
1027 char attrChannelsError[] = "attr-channels=3;";
1028 char attrFrameCountError[] = "attr-frame-count=111111111111111111111;";
1029 char attrRouteError[] = "attr-route=5;";
1030 char attrFormateError[] = "attr-formate=12;";
1031
1032
1033 TestAudioManager* manager = GetAudioManagerFuncs();
1034 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
1035 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1036 ret = capture->attr.SetExtraParams((AudioHandle)capture, attrSamplingRateError);
1037 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1038 ret = capture->attr.SetExtraParams((AudioHandle)capture, attrChannelsError);
1039 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1040 ret = capture->attr.SetExtraParams((AudioHandle)capture, attrFrameCountError);
1041 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1042 ret = capture->attr.SetExtraParams((AudioHandle)capture, attrRouteError);
1043 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1044 ret = capture->attr.SetExtraParams((AudioHandle)capture, attrFormateError);
1045 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1046
1047 adapter->DestroyCapture(adapter, capture);
1048 manager->UnloadAdapter(manager, adapter);
1049 }
1050 /**
1051 * @tc.name Test CaptureSetExtraParams API via setting the parameter render is nullptr
1052 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0007
1053 * @tc.desc Test the CaptureSetExtraParams API,and check if -1 is returned when the parameter render is nullptr
1054 */
1055 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0007, Function | MediumTest | Level1)
1056 {
1057 int32_t ret = -1;
1058 struct AudioAdapter *adapter = {};
1059 struct AudioCapture *capture = nullptr;
1060 struct AudioCapture *captureNull = nullptr;
1061 char keyValueList[] = "attr-format=2;";
1062
1063
1064 TestAudioManager* manager = GetAudioManagerFuncs();
1065 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
1066 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1067 ret = capture->attr.SetExtraParams((AudioHandle)captureNull, keyValueList);
1068 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1069
1070 adapter->DestroyCapture(adapter, capture);
1071 manager->UnloadAdapter(manager, adapter);
1072 }
1073 /**
1074 * @tc.name Test CaptureSetExtraParams API via setting the format of ExtraParams is nullptr
1075 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0008
1076 * @tc.desc Test the CaptureSetExtraParams API,and check if -1 is returned when the parameter format is nullptr
1077 */
1078 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0008, Function | MediumTest | Level1)
1079 {
1080 int32_t ret = -1;
1081 struct AudioAdapter *adapter = {};
1082 struct AudioCapture *capture = nullptr;
1083 char keyValueListNull[] = "attr-format=;";
1084
1085
1086 TestAudioManager* manager = GetAudioManagerFuncs();
1087 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
1088 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1089 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListNull);
1090 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1091
1092 adapter->DestroyCapture(adapter, capture);
1093 manager->UnloadAdapter(manager, adapter);
1094 }
1095 /**
1096 * @tc.name Test CaptureGetExtraParams API via legal input
1097 * @tc.number SUB_Audio_HDI_CaptureGetExtraParams_0001
1098 * @tc.desc Test the CaptureGetExtraParams API,and check if 0 is returned when RenderGetExtraParams is obtained successfully
1099 */
1100 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetExtraParams_0001, Function | MediumTest | Level1)
1101 {
1102 int32_t ret = -1;
1103 uint64_t count = 0;
1104 struct AudioAdapter *adapter = {};
1105 struct AudioCapture *capture = nullptr;
1106 struct AudioSampleAttributes attrsValue = {};
1107 char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
1108 char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\
1109 attr-sampling-rate=48000";
1110 char keyValueListValue[256] = {};
1111 int32_t listLenth = 256;
1112 int32_t formatExp = 3;
1113 uint32_t sampleRateExp = 48000;
1114 uint32_t channelCountExp = 2;
1115 uint32_t frameCountExp = 4096;
1116
1117
1118 TestAudioManager* manager = GetAudioManagerFuncs();
1119 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
1120 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1121 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
1122 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1123 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValue, listLenth);
1124 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1125 EXPECT_STREQ(keyValueListExp, keyValueListValue);
1126
1127 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
1128 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1129 EXPECT_EQ(formatExp, attrsValue.format);
1130 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1131 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1132 ret = capture->attr.GetFrameCount(capture, &count);
1133 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1134 EXPECT_EQ(count, frameCountExp);
1135
1136 ret = capture->control.Stop((AudioHandle)capture);
1137 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1138 adapter->DestroyCapture(adapter, capture);
1139 manager->UnloadAdapter(manager, adapter);
1140 }
1141 /**
1142 * @tc.name Test CaptureGetExtraParams API via setting the parameter render is nullptr
1143 * @tc.number SUB_Audio_HDI_CaptureGetExtraParams_0002
1144 * @tc.desc Test the CaptureGetExtraParams API,and check if 0 is returned when the parameter render is nullptr
1145 */
1146 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetExtraParams_0002, Function | MediumTest | Level1)
1147 {
1148 int32_t ret = -1;
1149 struct AudioAdapter *adapter = {};
1150 struct AudioCapture *capture = nullptr;
1151 struct AudioCapture *captureNull = nullptr;
1152 char keyValueList[] = "attr-format=32;";
1153 char keyValueListValue[256] = {};
1154 int32_t listLenth = 256;
1155
1156
1157 TestAudioManager* manager = GetAudioManagerFuncs();
1158 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
1159 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1160 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
1161 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1162 ret = capture->attr.GetExtraParams((AudioHandle)captureNull, keyValueListValue, listLenth);
1163 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1164
1165 adapter->DestroyCapture(adapter, capture);
1166 manager->UnloadAdapter(manager, adapter);
1167 }
1168 /**
1169 * @tc.name Test CaptureGetExtraParams API via setting listlength to be less than the actual length
1170 * @tc.number SUB_Audio_HDI_CaptureGetExtraParams_0003
1171 * @tc.desc Test the CaptureGetExtraParams API,and check if 0 is returned when listlength is set to a value less than the actual length
1172 */
1173 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetExtraParams_0003, Function | MediumTest | Level1)
1174 {
1175 int32_t ret = -1;
1176 struct AudioAdapter *adapter = {};
1177 struct AudioCapture *capture = nullptr;
1178 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000;";
1179 char keyValueListValue[256] = {};
1180 int32_t listLenth = 8;
1181
1182
1183 TestAudioManager* manager = GetAudioManagerFuncs();
1184 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
1185 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1186 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
1187 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1188 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValue, listLenth);
1189 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1190
1191 adapter->DestroyCapture(adapter, capture);
1192 manager->UnloadAdapter(manager, adapter);
1193 }
1194 /**
1195 * @tc.name Test CaptureGetExtraParams API via setting listlenth equal to the actual length
1196 * @tc.number SUB_Audio_HDI_CaptureGetExtraParams_0004
1197 * @tc.desc Test the CaptureGetExtraParams API,and check if 0 is returned when listlenth is set to a value equal to the actual length
1198 */
1199 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetExtraParams_0004, Function | MediumTest | Level1)
1200 {
1201 int32_t ret = -1;
1202 struct AudioAdapter *adapter = {};
1203 struct AudioCapture *capture = nullptr;
1204 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=11111111111111111111;\
1205 attr-sampling-rate=48000";
1206 char keyValueListValue[256] = {};
1207 int32_t listLenth = 107;
1208
1209
1210 TestAudioManager* manager = GetAudioManagerFuncs();
1211 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME);
1212 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1213 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
1214 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1215 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValue, listLenth);
1216 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1217 EXPECT_STREQ(keyValueList, keyValueListValue);
1218
1219 ret = capture->control.Stop((AudioHandle)capture);
1220 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1221 adapter->DestroyCapture(adapter, capture);
1222 manager->UnloadAdapter(manager, adapter);
1223 }
1224 /**
1225 * @tc.name Test CaptureAddAudioEffect API via legal input
1226 * @tc.number SUB_Audio_HDI_CaptureAddAudioEffect_0001
1227 * @tc.desc Test CaptureAddAudioEffect interface,return 0 if set the legal parameter
1228 */
1229 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureAddAudioEffect_0001, TestSize.Level1)
1230 {
1231 int32_t ret = -1;
1232 struct AudioAdapter *adapter = nullptr;
1233 struct AudioCapture *capture = nullptr;
1234 uint64_t effectid = 14;
1235
1236 TestAudioManager* manager = GetAudioManagerFuncs();
1237 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
1238 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1239 ret = capture->attr.AddAudioEffect((AudioHandle)capture, effectid);
1240 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1241
1242 adapter->DestroyCapture(adapter, capture);
1243 manager->UnloadAdapter(manager, adapter);
1244 }
1245 /**
1246 * @tc.name Test CaptureAddAudioEffect API via setting the parameter Capture is nullptr
1247 * @tc.number SUB_Audio_HDI_CaptureAddAudioEffect_0001
1248 * @tc.desc Test CaptureAddAudioEffect interface,return -3 if set the parameter Capture is nullptr
1249 */
1250 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureAddAudioEffect_0002, TestSize.Level1)
1251 {
1252 int32_t ret = -1;
1253 struct AudioAdapter *adapter = nullptr;
1254 struct AudioCapture *capture = nullptr;
1255 struct AudioCapture *captureNull = nullptr;
1256 uint64_t effectid = 14;
1257
1258 TestAudioManager* manager = GetAudioManagerFuncs();
1259 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
1260 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1261 ret = capture->attr.AddAudioEffect((AudioHandle)captureNull, effectid);
1262 #ifdef AUDIO_ADM_SERVICE
1263 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1264 #else
1265 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1266 #endif
1267
1268 adapter->DestroyCapture(adapter, capture);
1269 manager->UnloadAdapter(manager, adapter);
1270 }
1271 /**
1272 * @tc.name Test CaptureRemoveAudioEffect API via legal input
1273 * @tc.number SUB_Audio_HDI_CaptureRemoveAudioEffect_0001
1274 * @tc.desc Test CaptureAddAudioEffect interface,return 0 if set the legal parameter
1275 */
1276 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureRemoveAudioEffect_0001, TestSize.Level1)
1277 {
1278 int32_t ret = -1;
1279 struct AudioAdapter *adapter = nullptr;
1280 struct AudioCapture *capture = nullptr;
1281 uint64_t effectid = 14;
1282
1283 TestAudioManager* manager = GetAudioManagerFuncs();
1284 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
1285 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1286 ret = capture->attr.AddAudioEffect((AudioHandle)capture, effectid);
1287 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1288 ret = capture->attr.RemoveAudioEffect((AudioHandle)capture, effectid);
1289 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1290
1291 adapter->DestroyCapture(adapter, capture);
1292 manager->UnloadAdapter(manager, adapter);
1293 }
1294 /**
1295 * @tc.name Test CaptureAddAudioEffect API via setting the parameter Capture is nullptr
1296 * @tc.number SUB_Audio_HDI_CaptureAddAudioEffect_0002
1297 * @tc.desc Test CaptureAddAudioEffect interface,return -3 if setting the parameter Capture is nullptr
1298 */
1299 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureRemoveAudioEffect_0002, TestSize.Level1)
1300 {
1301 int32_t ret = -1;
1302 struct AudioAdapter *adapter = nullptr;
1303 struct AudioCapture *capture = nullptr;
1304 struct AudioCapture *captureNull = nullptr;
1305 uint64_t effectid = 14;
1306
1307 TestAudioManager* manager = GetAudioManagerFuncs();
1308 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
1309 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1310 ret = capture->attr.RemoveAudioEffect((AudioHandle)captureNull, effectid);
1311 #ifdef AUDIO_ADM_SERVICE
1312 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1313 #else
1314 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1315 #endif
1316
1317 adapter->DestroyCapture(adapter, capture);
1318 manager->UnloadAdapter(manager, adapter);
1319 }
1320 }