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_attr_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 AudioHdiCaptureAttrTest : 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 int32_t AudioCaptureStart(const string path, struct AudioCapture *capture) const;
62 };
63
64 using THREAD_FUNC = void *(*)(void *);
65
66 TestAudioManager *(*AudioHdiCaptureAttrTest::GetAudioManager)() = nullptr;
67 void *AudioHdiCaptureAttrTest::handleSo = nullptr;
68 #ifdef AUDIO_MPI_SO
69 int32_t (*AudioHdiCaptureAttrTest::SdkInit)() = nullptr;
70 void (*AudioHdiCaptureAttrTest::SdkExit)() = nullptr;
71 void *AudioHdiCaptureAttrTest::sdkSo = nullptr;
72 #endif
73
SetUpTestCase(void)74 void AudioHdiCaptureAttrTest::SetUpTestCase(void)
75 {
76 #ifdef AUDIO_MPI_SO
77 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
78 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
79 if (sdkSo == nullptr) {
80 return;
81 }
82 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
83 if (SdkInit == nullptr) {
84 return;
85 }
86 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
87 if (SdkExit == nullptr) {
88 return;
89 }
90 SdkInit();
91 #endif
92 char absPath[PATH_MAX] = {0};
93 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
94 return;
95 }
96 handleSo = dlopen(absPath, RTLD_LAZY);
97 if (handleSo == nullptr) {
98 return;
99 }
100 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
101 if (GetAudioManager == nullptr) {
102 return;
103 }
104 }
105
TearDownTestCase(void)106 void AudioHdiCaptureAttrTest::TearDownTestCase(void)
107 {
108 #ifdef AUDIO_MPI_SO
109 SdkExit();
110 if (sdkSo != nullptr) {
111 dlclose(sdkSo);
112 sdkSo = nullptr;
113 }
114 if (SdkInit != nullptr) {
115 SdkInit = nullptr;
116 }
117 if (SdkExit != nullptr) {
118 SdkExit = nullptr;
119 }
120 #endif
121 if (handleSo != nullptr) {
122 dlclose(handleSo);
123 handleSo = nullptr;
124 }
125 if (GetAudioManager != nullptr) {
126 GetAudioManager = nullptr;
127 }
128 }
129
SetUp(void)130 void AudioHdiCaptureAttrTest::SetUp(void) {}
TearDown(void)131 void AudioHdiCaptureAttrTest::TearDown(void) {}
132
AudioCaptureStart(const string path,struct AudioCapture * capture) const133 int32_t AudioHdiCaptureAttrTest::AudioCaptureStart(const string path, struct AudioCapture *capture) const
134 {
135 int32_t ret = -1;
136 struct AudioSampleAttributes attrs = {};
137 if (capture == nullptr) {
138 return AUDIO_HAL_ERR_INVALID_PARAM;
139 }
140 ret = InitAttrs(attrs);
141 if (ret < 0) {
142 return ret;
143 }
144 FILE *file = fopen(path.c_str(), "wb+");
145 if (file == nullptr) {
146 return HDF_FAILURE;
147 }
148 ret = FrameStartCapture(capture, file, attrs);
149 (void)fclose(file);
150 return ret;
151 }
152
153 /**
154 * @tc.name Test AudioCaptureSetSampleAttributes API via legal input.
155 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0001
156 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
157 * attrs.type = AUDIO_IN_MEDIA;
158 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
159 * attrs.sampleRate = 8000;
160 * attrs.channelCount = 1;
161 */
162 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0001, Function | MediumTest | Level1)
163 {
164 int32_t ret = -1;
165 uint32_t ret1 = 1;
166 uint32_t ret2 = 8000;
167 struct AudioSampleAttributes attrs = {};
168 struct AudioSampleAttributes attrsValue = {};
169 struct AudioAdapter *adapter = nullptr;
170 struct AudioCapture *capture = nullptr;
171 ASSERT_NE(nullptr, GetAudioManager);
172 TestAudioManager* manager = GetAudioManager();
173 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
174 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
175 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 8000);
176
177 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
178 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
179 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
180 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
181 EXPECT_EQ(ret2, attrsValue.sampleRate);
182 EXPECT_EQ(ret1, attrsValue.channelCount);
183
184 adapter->DestroyCapture(adapter, capture);
185 manager->UnloadAdapter(manager, adapter);
186 }
187 /**
188 * @tc.name Test AudioCaptureSetSampleAttributes API via legal input.
189 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0002
190 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
191 * attrs.type = AUDIO_IN_MEDIA;
192 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
193 * attrs.sampleRate = 11025;
194 * attrs.channelCount = 2;
195 */
196 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0002, Function | MediumTest | Level1)
197 {
198 int32_t ret = -1;
199 uint32_t ret1 = 2;
200 uint32_t ret2 = 11025;
201 struct AudioSampleAttributes attrs = {};
202 struct AudioSampleAttributes attrsValue = {};
203 struct AudioAdapter *adapter = nullptr;
204 struct AudioCapture *capture = nullptr;
205 ASSERT_NE(nullptr, GetAudioManager);
206 TestAudioManager* manager = GetAudioManager();
207 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
208 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
209 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 11025);
210
211 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
212 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
213 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
214 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
215 EXPECT_EQ(ret2, attrsValue.sampleRate);
216 EXPECT_EQ(ret1, attrsValue.channelCount);
217
218 adapter->DestroyCapture(adapter, capture);
219 manager->UnloadAdapter(manager, adapter);
220 }
221 /**
222 * @tc.name Test AudioCaptureSetSampleAttributes API via legal input.
223 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0003
224 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
225 * attrs.type = AUDIO_IN_MEDIA;
226 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
227 * attrs.sampleRate = 22050;
228 * attrs.channelCount = 1;
229 */
230 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0003, Function | MediumTest | Level1)
231 {
232 int32_t ret = -1;
233 uint32_t ret1 = 1;
234 uint32_t ret2 = 22050;
235 struct AudioSampleAttributes attrs = {};
236 struct AudioSampleAttributes attrsValue = {};
237 struct AudioAdapter *adapter = nullptr;
238 struct AudioCapture *capture = nullptr;
239 ASSERT_NE(nullptr, GetAudioManager);
240 TestAudioManager* manager = GetAudioManager();
241 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
242 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
243 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 22050);
244
245 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
246 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
247 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
248 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
249 EXPECT_EQ(ret2, attrsValue.sampleRate);
250 EXPECT_EQ(ret1, attrsValue.channelCount);
251
252 adapter->DestroyCapture(adapter, capture);
253 manager->UnloadAdapter(manager, adapter);
254 }
255 /**
256 * @tc.name Test AudioCaptureSetSampleAttributes API via legal input.
257 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0004
258 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
259 * attrs.type = AUDIO_IN_MEDIA;
260 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
261 * attrs.sampleRate = 32000;
262 * attrs.channelCount = 2;
263 */
264 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0004, Function | MediumTest | Level1)
265 {
266 int32_t ret = -1;
267 uint32_t ret1 = 2;
268 uint32_t ret2 = 32000;
269 struct AudioSampleAttributes attrs = {};
270 struct AudioSampleAttributes attrsValue = {};
271 struct AudioAdapter *adapter = nullptr;
272 struct AudioCapture *capture = nullptr;
273 ASSERT_NE(nullptr, GetAudioManager);
274 TestAudioManager* manager = GetAudioManager();
275 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
276 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
277 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 32000);
278
279 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
280 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
281 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
282 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
283 EXPECT_EQ(ret2, attrsValue.sampleRate);
284 EXPECT_EQ(ret1, attrsValue.channelCount);
285
286 adapter->DestroyCapture(adapter, capture);
287 manager->UnloadAdapter(manager, adapter);
288 }
289 /**
290 * @tc.name Test AudioCaptureSetSampleAttributes API via legal input.
291 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0005
292 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
293 * attrs.type = AUDIO_IN_MEDIA;
294 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
295 * attrs.sampleRate = 44100;
296 * attrs.channelCount = 1;
297 */
298 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0005, Function | MediumTest | Level1)
299 {
300 int32_t ret = -1;
301 uint32_t ret1 = 1;
302 uint32_t ret2 = 44100;
303 struct AudioSampleAttributes attrs = {};
304 struct AudioSampleAttributes attrsValue = {};
305 struct AudioAdapter *adapter = nullptr;
306 struct AudioCapture *capture = nullptr;
307 ASSERT_NE(nullptr, GetAudioManager);
308 TestAudioManager* manager = GetAudioManager();
309 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
310 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
311 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 44100);
312
313 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
314 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
315 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
316 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
317 EXPECT_EQ(ret2, attrsValue.sampleRate);
318 EXPECT_EQ(ret1, attrsValue.channelCount);
319
320 adapter->DestroyCapture(adapter, capture);
321 manager->UnloadAdapter(manager, adapter);
322 }
323 /**
324 * @tc.name Test AudioCaptureSetSampleAttributes API via legal input.
325 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0006
326 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
327 * attrs.type = AUDIO_IN_COMMUNICATION;
328 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
329 * attrs.sampleRate = 48000;
330 * attrs.channelCount = 2;
331 */
332 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0006, Function | MediumTest | Level1)
333 {
334 int32_t ret = -1;
335 uint32_t ret1 = 2;
336 uint32_t ret2 = 48000;
337 struct AudioSampleAttributes attrs = {};
338 struct AudioSampleAttributes attrsValue = {};
339 struct AudioAdapter *adapter = nullptr;
340 struct AudioCapture *capture = nullptr;
341 ASSERT_NE(nullptr, GetAudioManager);
342 TestAudioManager* manager = GetAudioManager();
343 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
344 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
345 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 48000);
346
347 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
348 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
349 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
350 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
351 EXPECT_EQ(ret2, attrsValue.sampleRate);
352 EXPECT_EQ(ret1, attrsValue.channelCount);
353
354 adapter->DestroyCapture(adapter, capture);
355 manager->UnloadAdapter(manager, adapter);
356 }
357 /**
358 * @tc.name Test AudioCaptureSetSampleAttributes API via setting the capture is empty .
359 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0007
360 * @tc.desc Test AudioCaptureSetSampleAttributes interface, return -1 if the capture is empty.
361 */
362 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0007, Function | MediumTest | Level1)
363 {
364 int32_t ret = -1;
365 struct AudioSampleAttributes attrs = {};
366 struct AudioAdapter *adapter = nullptr;
367 struct AudioCapture *capture = nullptr;
368 struct AudioCapture *captureNull = nullptr;
369 ASSERT_NE(nullptr, GetAudioManager);
370 TestAudioManager* manager = GetAudioManager();
371 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
372 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
373 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 8000);
374
375 ret = capture->attr.SetSampleAttributes(captureNull, &attrs);
376 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
377 ret = capture->attr.SetSampleAttributes(capture, nullptr);
378 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
379
380 adapter->DestroyCapture(adapter, capture);
381 manager->UnloadAdapter(manager, adapter);
382 }
383 /**
384 * @tc.name Test AudioCaptureSetSampleAttributes API via legal input.
385 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0008
386 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
387 * attrs.type = AUDIO_IN_MEDIA;
388 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
389 * attrs.sampleRate = 12000;
390 * attrs.channelCount = 1;
391 */
392 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0008, Function | MediumTest | Level1)
393 {
394 int32_t ret = -1;
395 uint32_t ret1 = 1;
396 uint32_t ret2 = 12000;
397 struct AudioSampleAttributes attrs = {};
398 struct AudioSampleAttributes attrsValue = {};
399 struct AudioAdapter *adapter = nullptr;
400 struct AudioCapture *capture = nullptr;
401 ASSERT_NE(nullptr, GetAudioManager);
402 TestAudioManager* manager = GetAudioManager();
403 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
404 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
405 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 12000);
406
407 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
408 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
409
410 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
411 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
412 EXPECT_EQ(ret2, attrsValue.sampleRate);
413 EXPECT_EQ(ret1, attrsValue.channelCount);
414
415 adapter->DestroyCapture(adapter, capture);
416 manager->UnloadAdapter(manager, adapter);
417 }
418 /**
419 * @tc.name Test AudioCaptureSetSampleAttributes API via legal input.
420 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0009
421 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
422 * attrs.type = AUDIO_IN_MEDIA;
423 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
424 * attrs.sampleRate = 16000;
425 * attrs.channelCount = 1;
426 */
427 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0009, Function | MediumTest | Level1)
428 {
429 int32_t ret = -1;
430 uint32_t ret1 = 1;
431 uint32_t ret2 = 16000;
432 struct AudioSampleAttributes attrs = {};
433 struct AudioSampleAttributes attrsValue = {};
434 struct AudioAdapter *adapter = nullptr;
435 struct AudioCapture *capture = nullptr;
436 ASSERT_NE(nullptr, GetAudioManager);
437 TestAudioManager* manager = GetAudioManager();
438 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
439 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
440 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 16000);
441
442 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
443 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
444
445 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
446 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
447 EXPECT_EQ(ret2, attrsValue.sampleRate);
448 EXPECT_EQ(ret1, attrsValue.channelCount);
449
450 adapter->DestroyCapture(adapter, capture);
451 manager->UnloadAdapter(manager, adapter);
452 }
453 /**
454 * @tc.name Test AudioCaptureSetSampleAttributes API via legal input.
455 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0010
456 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
457 * attrs.type = AUDIO_IN_MEDIA;
458 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
459 * attrs.sampleRate = 24000;
460 * attrs.channelCount = 2;
461 */
462 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0010, Function | MediumTest | Level1)
463 {
464 int32_t ret = -1;
465 uint32_t ret1 = 2;
466 uint32_t ret2 = 24000;
467 struct AudioSampleAttributes attrs = {};
468 struct AudioSampleAttributes attrsValue = {};
469 struct AudioAdapter *adapter = nullptr;
470 struct AudioCapture *capture = nullptr;
471 ASSERT_NE(nullptr, GetAudioManager);
472 TestAudioManager* manager = GetAudioManager();
473 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
474 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
475 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 24000);
476
477 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
478 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
479
480 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
481 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
482 EXPECT_EQ(ret2, attrsValue.sampleRate);
483 EXPECT_EQ(ret1, attrsValue.channelCount);
484
485 adapter->DestroyCapture(adapter, capture);
486 manager->UnloadAdapter(manager, adapter);
487 }
488 /**
489 * @tc.name Test AudioCaptureSetSampleAttributes API via legal input.
490 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0011
491 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
492 * attrs.type = AUDIO_IN_MEDIA;
493 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
494 * attrs.sampleRate = 64000;
495 * attrs.channelCount = 1;
496 */
497 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0011, Function | MediumTest | Level1)
498 {
499 int32_t ret = -1;
500 uint32_t ret1 = 1;
501 uint32_t ret2 = 64000;
502 struct AudioSampleAttributes attrs = {};
503 struct AudioSampleAttributes attrsValue = {};
504 struct AudioAdapter *adapter = nullptr;
505 struct AudioCapture *capture = nullptr;
506 ASSERT_NE(nullptr, GetAudioManager);
507 TestAudioManager* manager = GetAudioManager();
508 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
509 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
510 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 64000);
511
512 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
513 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
514
515 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
516 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
517 EXPECT_EQ(ret2, attrsValue.sampleRate);
518 EXPECT_EQ(ret1, attrsValue.channelCount);
519
520 adapter->DestroyCapture(adapter, capture);
521 manager->UnloadAdapter(manager, adapter);
522 }
523 /**
524 * @tc.name Test AudioCaptureSetSampleAttributes API via legal input.
525 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0012
526 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
527 * attrs.type = AUDIO_IN_MEDIA;
528 * attrs.format = AUDIO_FORMAT_PCM_24_BIT;
529 * attrs.sampleRate = 96000;
530 * attrs.channelCount = 1;
531 */
532 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0012, Function | MediumTest | Level1)
533 {
534 int32_t ret = -1;
535 uint32_t ret1 = 1;
536 uint32_t ret2 = 96000;
537 struct AudioSampleAttributes attrs = {};
538 struct AudioSampleAttributes attrsValue = {};
539 struct AudioAdapter *adapter = nullptr;
540 struct AudioCapture *capture = nullptr;
541 ASSERT_NE(nullptr, GetAudioManager);
542 TestAudioManager* manager = GetAudioManager();
543 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
544 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
545 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 96000);
546
547 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
548 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
549
550 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
551 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
552 EXPECT_EQ(ret2, attrsValue.sampleRate);
553 EXPECT_EQ(ret1, attrsValue.channelCount);
554
555 adapter->DestroyCapture(adapter, capture);
556 manager->UnloadAdapter(manager, adapter);
557 }
558 /**
559 * @tc.name Test AudioCaptureSetSampleAttributes API via illegal input.
560 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0013
561 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
562 * attrs.type = AUDIO_IN_MEDIA;
563 * attrs.format = AUDIO_FORMAT_PCM_16;
564 * attrs.sampleRate = 0xFFFFFFFFu;
565 * attrs.channelCount = 2;
566 */
567 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0013, Function | MediumTest | Level1)
568 {
569 int32_t ret = -1;
570 struct AudioSampleAttributes attrs = {};
571 struct AudioAdapter *adapter = nullptr;
572 struct AudioCapture *capture = nullptr;
573 ASSERT_NE(nullptr, GetAudioManager);
574 TestAudioManager* manager = GetAudioManager();
575 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
576 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
577 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 0xFFFFFFFFu);
578
579 ret = capture->attr.SetSampleAttributes(capture, &attrs);
580 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
581
582 adapter->DestroyCapture(adapter, capture);
583 manager->UnloadAdapter(manager, adapter);
584 }
585 /**
586 * @tc.name Test AudioCaptureSetSampleAttributes API via illegal input.
587 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0014
588 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
589 * attrs.type = AUDIO_IN_MEDIA;
590 * attrs.format = AUDIO_FORMAT_PCM_8/32_BIT/AAC_MAIN;
591 * attrs.sampleRate = 8000/11025/22050;
592 * attrs.channelCount = 1/2;
593 */
594 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0014, Function | MediumTest | Level1)
595 {
596 int32_t ret = -1;
597 struct AudioSampleAttributes attrs1 = {};
598 struct AudioSampleAttributes attrs2 = {};
599 struct AudioSampleAttributes attrs3 = {};
600 struct AudioAdapter *adapter = nullptr;
601 struct AudioCapture *capture = nullptr;
602 ASSERT_NE(nullptr, GetAudioManager);
603 TestAudioManager* manager = GetAudioManager();
604 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
605 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
606
607 InitAttrsUpdate(attrs1, AUDIO_FORMAT_PCM_8_BIT, 1, 8000);
608 ret = capture->attr.SetSampleAttributes(capture, &attrs1);
609 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
610
611 InitAttrsUpdate(attrs2, AUDIO_FORMAT_PCM_32_BIT, 2, 11025);
612 ret = capture->attr.SetSampleAttributes(capture, &attrs2);
613 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
614
615 InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_MAIN, 1, 22050);
616 ret = capture->attr.SetSampleAttributes(capture, &attrs3);
617 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
618
619 adapter->DestroyCapture(adapter, capture);
620 manager->UnloadAdapter(manager, adapter);
621 }
622 /**
623 * @tc.name Test AudioCaptureSetSampleAttributes API via illegal input.
624 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0015
625 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
626 * attrs.type = AUDIO_IN_MEDIA;
627 * attrs.format = AUDIO_FORMAT_AAC_LC/LD/ELD;
628 * attrs.sampleRate = 32000/44100/48000;
629 * attrs.channelCount = 1/2;
630 */
631 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0015, Function | MediumTest | Level1)
632 {
633 int32_t ret = -1;
634 struct AudioSampleAttributes attrs1 = {};
635 struct AudioSampleAttributes attrs2 = {};
636 struct AudioSampleAttributes attrs3 = {};
637 struct AudioAdapter *adapter = nullptr;
638 struct AudioCapture *capture = nullptr;
639 ASSERT_NE(nullptr, GetAudioManager);
640 TestAudioManager* manager = GetAudioManager();
641 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
642 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
643
644 InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_LC, 2, 32000);
645 ret = capture->attr.SetSampleAttributes(capture, &attrs1);
646 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
647
648 InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_LD, 1, 44100);
649 ret = capture->attr.SetSampleAttributes(capture, &attrs2);
650 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
651
652 InitAttrsUpdate(attrs3, AUDIO_FORMAT_AAC_ELD, 2, 48000);
653 ret = capture->attr.SetSampleAttributes(capture, &attrs3);
654 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
655
656 adapter->DestroyCapture(adapter, capture);
657 manager->UnloadAdapter(manager, adapter);
658 }
659 /**
660 * @tc.name Test AudioCaptureSetSampleAttributes API via illegal input.
661 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0016
662 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
663 * attrs.type = AUDIO_IN_MEDIA;
664 * attrs.format = AUDIO_FORMAT_AAC_HE_V1/V2
665 * attrs.sampleRate = 8000/44100;
666 * attrs.channelCount = 1/2;
667 */
668 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0016, Function | MediumTest | Level1)
669 {
670 int32_t ret = -1;
671 struct AudioSampleAttributes attrs1 = {};
672 struct AudioSampleAttributes attrs2 = {};
673 struct AudioAdapter *adapter = nullptr;
674 struct AudioCapture *capture = nullptr;
675 ASSERT_NE(nullptr, GetAudioManager);
676 TestAudioManager* manager = GetAudioManager();
677 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
678 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
679
680 InitAttrsUpdate(attrs1, AUDIO_FORMAT_AAC_HE_V1, 1, 8000);
681 ret = capture->attr.SetSampleAttributes(capture, &attrs1);
682 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
683
684 InitAttrsUpdate(attrs2, AUDIO_FORMAT_AAC_HE_V2, 2, 44100);
685 ret = capture->attr.SetSampleAttributes(capture, &attrs2);
686 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
687
688 adapter->DestroyCapture(adapter, capture);
689 manager->UnloadAdapter(manager, adapter);
690 }
691 /**
692 * @tc.name Test AudioCaptureSetSampleAttributes API via illegal input.
693 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0017
694 * @tc.desc Test AudioCaptureSetSampleAttributes ,the setting parameters are as follows.
695 * attrs.type = AUDIO_IN_MEDIA;
696 * attrs.format = AUDIO_FORMAT_PCM_16_BIT
697 * attrs.sampleRate = 8000;
698 * attrs.channelCount = 5;
699 */
700 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_0017, Function | MediumTest | Level1)
701 {
702 int32_t ret = -1;
703 struct AudioSampleAttributes attrs = {};
704 struct AudioAdapter *adapter = nullptr;
705 struct AudioCapture *capture = nullptr;
706 ASSERT_NE(nullptr, GetAudioManager);
707 TestAudioManager* manager = GetAudioManager();
708 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
709 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
710
711 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 5, 8000);
712 ret = capture->attr.SetSampleAttributes(capture, &attrs);
713 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
714
715 adapter->DestroyCapture(adapter, capture);
716 manager->UnloadAdapter(manager, adapter);
717 }
718 /**
719 * @tc.name Test AudioCaptureGetSampleAttributes API via legal input.
720 * @tc.number SUB_Audio_HDI_AudioCaptureGetSampleAttributes_0001
721 * @tc.desc Test AudioCaptureGetSampleAttributes ,the setting parameters are as follows.
722 * attrs.type = AUDIO_IN_MEDIA;
723 * attrs.format = AUDIO_FORMAT_PCM_16_BIT;
724 * attrs.sampleRate = 8000;
725 * attrs.channelCount = 1;
726 */
727 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureGetSampleAttributes_0001, Function | MediumTest | Level1)
728 {
729 int32_t ret = -1;
730 uint32_t ret1 = 32000;
731 uint32_t ret2 = 1;
732 struct AudioSampleAttributes attrs = {};
733 struct AudioSampleAttributes attrsValue = {};
734 struct AudioAdapter *adapter = nullptr;
735 struct AudioCapture *capture = nullptr;
736 ASSERT_NE(nullptr, GetAudioManager);
737 TestAudioManager* manager = GetAudioManager();
738 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
739 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
740 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
741 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
742 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 32000);
743
744 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
745 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
746 EXPECT_EQ(AUDIO_IN_MEDIA, attrsValue.type);
747 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
748 EXPECT_EQ(ret1, attrsValue.sampleRate);
749 EXPECT_EQ(ret2, attrsValue.channelCount);
750
751 adapter->DestroyCapture(adapter, capture);
752 manager->UnloadAdapter(manager, adapter);
753 }
754 /**
755 * @tc.name Test AudioCaptureGetSampleAttributes API via setting the capture is empty .
756 * @tc.number SUB_Audio_HDI_AudioCaptureGetSampleAttributes_0002
757 * @tc.desc Test AudioCaptureGetSampleAttributes interface, return -1 if the capture is empty.
758 */
759 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_AudioCaptureGetSampleAttributes_0002, Function | MediumTest | Level1)
760 {
761 int32_t ret = -1;
762 struct AudioSampleAttributes attrs = {};
763 struct AudioAdapter *adapter = nullptr;
764 struct AudioCapture *capture = nullptr;
765 struct AudioCapture *captureNull = nullptr;
766 ASSERT_NE(nullptr, GetAudioManager);
767 TestAudioManager* manager = GetAudioManager();
768 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
769 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
770 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 48000);
771
772 ret = capture->attr.GetSampleAttributes(captureNull, &attrs);
773 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
774 ret = capture->attr.GetSampleAttributes(capture, nullptr);
775 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
776
777 adapter->DestroyCapture(adapter, capture);
778 manager->UnloadAdapter(manager, adapter);
779 }
780 /**
781 * @tc.name Test AudioCaptureGetFrameSize API via legal input
782 * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0001
783 * @tc.desc test AudioCaptureGetFrameSize interface, return 0 is call successfully.
784 */
785 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0001, Function | MediumTest | Level1)
786 {
787 int32_t ret = -1;
788 uint64_t size = 0;
789 struct AudioAdapter *adapter = nullptr;
790 struct AudioCapture *capture = nullptr;
791 ASSERT_NE(nullptr, GetAudioManager);
792 TestAudioManager* manager = GetAudioManager();
793 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
794 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
795 ret = capture->attr.GetFrameSize(capture, &size);
796 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
797 EXPECT_GT(size, INITIAL_VALUE);
798
799 adapter->DestroyCapture(adapter, capture);
800 manager->UnloadAdapter(manager, adapter);
801 }
802 /**
803 * @tc.name Test AudioCaptureGetFrameSize API via setting the parameter handle is nullptr
804 * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0002
805 * @tc.desc test AudioCaptureGetFrameSize interface, return -1 if the parameter handle is nullptr.
806 */
807 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0002, Function | MediumTest | Level1)
808 {
809 int32_t ret = -1;
810 uint64_t size = 0;
811 struct AudioAdapter *adapter = nullptr;
812 struct AudioCapture *capture = nullptr;
813 struct AudioCapture *captureNull = nullptr;
814 ASSERT_NE(nullptr, GetAudioManager);
815 TestAudioManager* manager = GetAudioManager();
816 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
817 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
818
819 ret = capture->attr.GetFrameSize(captureNull, &size);
820 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
821
822 adapter->DestroyCapture(adapter, capture);
823 manager->UnloadAdapter(manager, adapter);
824 }
825 /**
826 * @tc.name Test AudioCaptureGetFrameSize API via setting the parameter size is nullptr
827 * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0003
828 * @tc.desc test AudioCaptureGetFrameSize interface, return -1 if the parameter size is nullptr.
829 */
830 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0003, Function | MediumTest | Level1)
831 {
832 int32_t ret = -1;
833 uint64_t *sizeNull = nullptr;
834 struct AudioAdapter *adapter = nullptr;
835 struct AudioCapture *capture = nullptr;
836 ASSERT_NE(nullptr, GetAudioManager);
837 TestAudioManager* manager = GetAudioManager();
838 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
839 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
840
841 ret = capture->attr.GetFrameSize(capture, sizeNull);
842 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
843
844 adapter->DestroyCapture(adapter, capture);
845 manager->UnloadAdapter(manager, adapter);
846 }
847 /**
848 * @tc.name Test CaptureGetFrameSize API via define format to different values
849 * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0004
850 * @tc.desc Test CaptureGetFrameSize interface,return 0 if get framesize define format as different values
851 */
852 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0004, Function | MediumTest | Level1)
853 {
854 int32_t ret = -1;
855 uint64_t size = 0;
856 uint64_t channelCountExp = 2;
857 uint32_t sampleRateExp = 48000;
858 struct AudioSampleAttributes attrs = {};
859 struct AudioSampleAttributes attrsValue = {};
860 struct AudioAdapter *adapter = nullptr;
861 struct AudioCapture *capture = nullptr;
862 ASSERT_NE(nullptr, GetAudioManager);
863 TestAudioManager* manager = GetAudioManager();
864 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
865 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
866 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 48000);
867
868 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
869 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
870 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
871 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
872 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
873
874 ret = capture->attr.GetFrameSize(capture, &size);
875 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
876 EXPECT_GT(size, INITIAL_VALUE);
877
878 adapter->DestroyCapture(adapter, capture);
879 manager->UnloadAdapter(manager, adapter);
880 }
881 /**
882 * @tc.name Test CaptureGetFrameSize API via define sampleRate to different values
883 * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0005
884 * @tc.desc Test CaptureGetFrameSize interface,return 0 if get framesize define sampleRate as different values
885 */
886 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0005, Function | MediumTest | Level1)
887 {
888 int32_t ret = -1;
889 uint64_t size = 0;
890 uint64_t channelCountExp = 1;
891 uint32_t sampleRateExp = 48000;
892 struct AudioSampleAttributes attrs = {};
893 struct AudioSampleAttributes attrsValue = {};
894 struct AudioAdapter *adapter = nullptr;
895 struct AudioCapture *capture = nullptr;
896 ASSERT_NE(nullptr, GetAudioManager);
897 TestAudioManager* manager = GetAudioManager();
898 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
899 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
900 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 48000);
901
902 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
903 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
904 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
905 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
906 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
907
908 ret = capture->attr.GetFrameSize(capture, &size);
909 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
910 EXPECT_GT(size, INITIAL_VALUE);
911
912 adapter->DestroyCapture(adapter, capture);
913 manager->UnloadAdapter(manager, adapter);
914 }
915 /**
916 * @tc.name Test CaptureGetFrameSize API via define channelCount to different values
917 * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0006
918 * @tc.desc Test CaptureGetFrameSize interface,return 0 if get framesize define channelCount as different values
919 */
920 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0006, Function | MediumTest | Level1)
921 {
922 int32_t ret = -1;
923 uint64_t size = 0;
924 uint64_t channelCountExp = 2;
925 uint32_t sampleRateExp = 44100;
926 struct AudioSampleAttributes attrs = {};
927 struct AudioSampleAttributes attrsValue = {};
928 struct AudioAdapter *adapter = nullptr;
929 struct AudioCapture *capture = nullptr;
930 ASSERT_NE(nullptr, GetAudioManager);
931 TestAudioManager* manager = GetAudioManager();
932 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
933 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
934 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 44100);
935
936 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
937 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
938 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
939 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
940 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
941
942 ret = capture->attr.GetFrameSize(capture, &size);
943 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
944 EXPECT_GT(size, INITIAL_VALUE);
945
946 adapter->DestroyCapture(adapter, capture);
947 manager->UnloadAdapter(manager, adapter);
948 }
949 /**
950 * @tc.name Test CaptureGetFrameSize API via define sampleRate to different value
951 * @tc.number SUB_Audio_hdi_CaptureGetFrameSize_0007
952 * @tc.desc Test CaptureGetFrameSize interface,return 0 if get framesize define sampleRate as different values
953 */
954 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameSize_0007, Function | MediumTest | Level1)
955 {
956 int32_t ret = -1;
957 uint64_t size = 0;
958 uint64_t channelCountExp = 1;
959 uint32_t sampleRateExp = 48000;
960 struct AudioSampleAttributes attrs = {};
961 struct AudioSampleAttributes attrsValue = {};
962 struct AudioAdapter *adapter = nullptr;
963 struct AudioCapture *capture = nullptr;
964 ASSERT_NE(nullptr, GetAudioManager);
965 TestAudioManager* manager = GetAudioManager();
966 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
967 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
968 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 48000);
969
970 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
971 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
972 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
973 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
974 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
975
976 ret = capture->attr.GetFrameSize(capture, &size);
977 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
978 EXPECT_GT(size, INITIAL_VALUE);
979
980 adapter->DestroyCapture(adapter, capture);
981 manager->UnloadAdapter(manager, adapter);
982 }
983 /**
984 * @tc.name Test AudioCaptureGetFrameCount API via legal input
985 * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0001
986 * @tc.desc test AudioCaptureGetFrameCount interface, return 0 if the FrameCount is called after creating the object.
987 */
988 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0001, Function | MediumTest | Level1)
989 {
990 int32_t ret = -1;
991 uint64_t count = 0;
992 struct AudioAdapter *adapter = nullptr;
993 struct AudioCapture *capture = nullptr;
994 ASSERT_NE(nullptr, GetAudioManager);
995 TestAudioManager* manager = GetAudioManager();
996 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
997 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
998
999 ret = capture->attr.GetFrameCount(capture, &count);
1000 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1001 EXPECT_EQ(count, INITIAL_VALUE);
1002
1003 adapter->DestroyCapture(adapter, capture);
1004 manager->UnloadAdapter(manager, adapter);
1005 }
1006 /**
1007 * @tc.name Test AudioCaptureGetFrameCount API via legal input in the difference scene
1008 * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0001
1009 * @tc.desc test AudioCaptureGetFrameCount interface, return 0 if the GetFrameCount is called after started.
1010 */
1011 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0002, Function | MediumTest | Level1)
1012 {
1013 int32_t ret = -1;
1014 uint64_t count = 0;
1015 struct AudioAdapter *adapter = nullptr;
1016 struct AudioCapture *capture = nullptr;
1017 ASSERT_NE(nullptr, GetAudioManager);
1018 TestAudioManager* manager = GetAudioManager();
1019 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
1020 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1021
1022 ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture);
1023 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1024
1025 ret = capture->attr.GetFrameCount(capture, &count);
1026 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1027 EXPECT_GT(count, INITIAL_VALUE);
1028
1029 capture->control.Stop((AudioHandle)capture);
1030 adapter->DestroyCapture(adapter, capture);
1031 manager->UnloadAdapter(manager, adapter);
1032 }
1033 /**
1034 * @tc.name Test AudioCaptureGetFrameCount API via setting the parameter handle is nullptr
1035 * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0003
1036 * @tc.desc test AudioCaptureGetFrameCount interface, return -1 if the parameter handle is nullptr.
1037 */
1038 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0003, Function | MediumTest | Level1)
1039 {
1040 int32_t ret = -1;
1041 uint64_t count = 0;
1042 struct AudioAdapter *adapter = nullptr;
1043 struct AudioCapture *capture = nullptr;
1044 struct AudioCapture *captureNull = nullptr;
1045 ASSERT_NE(nullptr, GetAudioManager);
1046 TestAudioManager* manager = GetAudioManager();
1047 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
1048 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1049
1050 ret = capture->attr.GetFrameCount(captureNull, &count);
1051 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1052
1053 adapter->DestroyCapture(adapter, capture);
1054 manager->UnloadAdapter(manager, adapter);
1055 }
1056
1057 /**
1058 * @tc.name Test AudioCaptureGetFrameCount API via setting the parameter handle is nullptr
1059 * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0004
1060 * @tc.desc test AudioCaptureGetFrameCount interface, return -1 if the parameter handle is nullptr.
1061 */
1062 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0004, Function | MediumTest | Level1)
1063 {
1064 int32_t ret = -1;
1065 uint64_t *countNull = nullptr;
1066 struct AudioAdapter *adapter = nullptr;
1067 struct AudioCapture *capture = nullptr;
1068 ASSERT_NE(nullptr, GetAudioManager);
1069 TestAudioManager* manager = GetAudioManager();
1070 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
1071 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1072
1073 ret = capture->attr.GetFrameCount(capture, countNull);
1074 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1075
1076 adapter->DestroyCapture(adapter, capture);
1077 manager->UnloadAdapter(manager, adapter);
1078 }
1079 /**
1080 * @tc.name Test CaptureGetFrameCount API via define channelCount to different value
1081 * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0005
1082 * @tc.desc Test CaptureGetFrameCount interface,return 0 if get framesize define channelCount as different values
1083 */
1084 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0005, Function | MediumTest | Level1)
1085 {
1086 int32_t ret = -1;
1087 uint64_t count = 0;
1088 uint64_t channelCountExp = 2;
1089 uint32_t sampleRateExp = 8000;
1090 struct AudioAdapter *adapter = nullptr;
1091 struct AudioCapture *capture = nullptr;
1092 struct AudioSampleAttributes attrs = {};
1093 struct AudioSampleAttributes attrsValue = {};
1094 ASSERT_NE(nullptr, GetAudioManager);
1095 TestAudioManager* manager = GetAudioManager();
1096 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
1097 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1098 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 2, 8000);
1099
1100 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
1101 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1102 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
1103 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1104 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1105
1106 ret = AudioCaptureStartAndOneFrame(capture);
1107 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1108 ret = capture->attr.GetFrameCount(capture, &count);
1109 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1110 EXPECT_GT(count, INITIAL_VALUE);
1111
1112 ret = capture->control.Stop((AudioHandle)capture);
1113 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1114 adapter->DestroyCapture(adapter, capture);
1115 manager->UnloadAdapter(manager, adapter);
1116 }
1117 /**
1118 * @tc.name Test CaptureGetFrameCount API via define format to different value
1119 * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0006
1120 * @tc.desc Test CaptureGetFrameCount interface,return 0 if get framesize define format as different values
1121 */
1122 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0006, Function | MediumTest | Level1)
1123 {
1124 int32_t ret = -1;
1125 uint64_t count = 0;
1126 uint64_t channelCountExp = 2;
1127 uint32_t sampleRateExp = 8000;
1128 struct AudioAdapter *adapter = nullptr;
1129 struct AudioCapture *capture = nullptr;
1130 struct AudioSampleAttributes attrs = {};
1131 struct AudioSampleAttributes attrsValue = {};
1132 ASSERT_NE(nullptr, GetAudioManager);
1133 TestAudioManager* manager = GetAudioManager();
1134 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
1135 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1136 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 2, 8000);
1137
1138 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
1139 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1140 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
1141 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1142 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1143
1144 ret = AudioCaptureStartAndOneFrame(capture);
1145 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1146 ret = capture->attr.GetFrameCount(capture, &count);
1147 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1148 EXPECT_GT(count, INITIAL_VALUE);
1149
1150 ret = capture->control.Stop((AudioHandle)capture);
1151 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1152 adapter->DestroyCapture(adapter, capture);
1153 manager->UnloadAdapter(manager, adapter);
1154 }
1155 /**
1156 * @tc.name Test CaptureGetFrameCount API via define channelCount to different value
1157 * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0007
1158 * @tc.desc Test CaptureGetFrameCount interface,return 0 if get framesize define channelCount to different values
1159 */
1160 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0007, Function | MediumTest | Level1)
1161 {
1162 int32_t ret = -1;
1163 uint64_t count = 0;
1164 uint64_t channelCountExp = 1;
1165 uint32_t sampleRateExp = 44100;
1166 struct AudioAdapter *adapter = nullptr;
1167 struct AudioCapture *capture = nullptr;
1168 struct AudioSampleAttributes attrs = {};
1169 struct AudioSampleAttributes attrsValue = {};
1170 ASSERT_NE(nullptr, GetAudioManager);
1171 TestAudioManager* manager = GetAudioManager();
1172 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
1173 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1174 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_24_BIT, 1, 44100);
1175
1176 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
1177 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1178 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
1179 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1180 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1181
1182 ret = AudioCaptureStartAndOneFrame(capture);
1183 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1184 ret = capture->attr.GetFrameCount(capture, &count);
1185 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1186 EXPECT_GT(count, INITIAL_VALUE);
1187
1188 ret = capture->control.Stop((AudioHandle)capture);
1189 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1190 adapter->DestroyCapture(adapter, capture);
1191 manager->UnloadAdapter(manager, adapter);
1192 }
1193 /**
1194 * @tc.name Test CaptureGetFrameCount API via define format to different value
1195 * @tc.number SUB_Audio_hdi_CaptureGetFrameCount_0008
1196 * @tc.desc Test CaptureGetFrameCount interface,return 0 if get framesize define format as different values
1197 */
1198 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_hdi_CaptureGetFrameCount_0008, Function | MediumTest | Level1)
1199 {
1200 int32_t ret = -1;
1201 uint64_t count = 0;
1202 uint64_t channelCountExp = 1;
1203 uint32_t sampleRateExp = 32000;
1204 struct AudioAdapter *adapter = nullptr;
1205 struct AudioCapture *capture = nullptr;
1206 struct AudioSampleAttributes attrs = {};
1207 struct AudioSampleAttributes attrsValue = {};
1208 ASSERT_NE(nullptr, GetAudioManager);
1209 TestAudioManager* manager = GetAudioManager();
1210 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
1211 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1212 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 32000);
1213
1214 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
1215 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1216 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
1217 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1218 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1219
1220 ret = AudioCaptureStartAndOneFrame(capture);
1221 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1222 ret = capture->attr.GetFrameCount(capture, &count);
1223 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1224 EXPECT_GT(count, INITIAL_VALUE);
1225
1226 ret = capture->control.Stop((AudioHandle)capture);
1227 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1228 adapter->DestroyCapture(adapter, capture);
1229 manager->UnloadAdapter(manager, adapter);
1230 }
1231 /**
1232 * @tc.name Test CaptureGetCurrentChannelId API via legal input
1233 * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0001
1234 * @tc.desc Test GetCurrentChannelId, return 0 if the default CurrentChannelId is obtained successfully
1235 */
1236 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0001, Function | MediumTest | Level1)
1237 {
1238 int32_t ret = -1;
1239 uint32_t channelId = 0;
1240 uint32_t channelIdValue = CHANNELCOUNT;
1241 struct AudioAdapter *adapter = nullptr;
1242 struct AudioCapture *capture = nullptr;
1243 ASSERT_NE(nullptr, GetAudioManager);
1244 TestAudioManager* manager = GetAudioManager();
1245 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
1246 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1247
1248 ret = capture->attr.GetCurrentChannelId(capture, &channelId);
1249 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1250 EXPECT_EQ(channelIdValue, channelId);
1251
1252 adapter->DestroyCapture(adapter, capture);
1253 manager->UnloadAdapter(manager, adapter);
1254 }
1255 /**
1256 * @tc.name Test GetCurrentChannelId API via getting channelId to 1 and set channelCount to 1
1257 * @tc.number SUB_Audio_HDI_CaptureGetCurrentChannelId_0002
1258 * @tc.desc Test GetCurrentChannelId interface,return 0 if get channelId to 1 and set channelCount to 1
1259 */
1260 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0002, Function | MediumTest | Level1)
1261 {
1262 int32_t ret = -1;
1263 uint32_t channelId = 0;
1264 uint32_t channelIdExp = 1;
1265 uint32_t channelCountExp = 1;
1266 struct AudioSampleAttributes attrs = {};
1267 struct AudioSampleAttributes attrsValue = {};
1268 struct AudioAdapter *adapter = nullptr;
1269 struct AudioCapture *capture = nullptr;
1270 ASSERT_NE(nullptr, GetAudioManager);
1271 TestAudioManager* manager = GetAudioManager();
1272 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
1273 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1274
1275 InitAttrsUpdate(attrs, AUDIO_FORMAT_PCM_16_BIT, 1, 48000);
1276
1277 ret = AudioCaptureSetGetSampleAttributes(attrs, attrsValue, capture);
1278 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1279 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1280
1281 ret = capture->attr.GetCurrentChannelId(capture, &channelId);
1282 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1283 EXPECT_EQ(channelIdExp, channelId);
1284
1285 adapter->DestroyCapture(adapter, capture);
1286 manager->UnloadAdapter(manager, adapter);
1287 }
1288 /**
1289 * @tc.name Test GetCurrentChannelId API via CurrentChannelId is obtained after started
1290 * @tc.number SUB_Audio_HDI_CaptureGetCurrentChannelId_0003
1291 * @tc.desc Test GetCurrentChannelId interface, return 0 if CurrentChannelId is obtained after started
1292 */
1293 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0003, Function | MediumTest | Level1)
1294 {
1295 int32_t ret = -1;
1296 uint32_t channelId = 0;
1297 uint32_t channelIdExp = 2;
1298 struct AudioAdapter *adapter = nullptr;
1299 struct AudioCapture *capture = nullptr;
1300 ASSERT_NE(nullptr, GetAudioManager);
1301 TestAudioManager* manager = GetAudioManager();
1302 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
1303 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1304 ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture);
1305 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1306
1307 ret = capture->attr.GetCurrentChannelId(capture, &channelId);
1308 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1309 EXPECT_EQ(channelIdExp, channelId);
1310
1311 capture->control.Stop((AudioHandle)capture);
1312 adapter->DestroyCapture(adapter, capture);
1313 manager->UnloadAdapter(manager, adapter);
1314 }
1315 /**
1316 * @tc.name Test GetCurrentChannelId API via setting the parameter capture is nullptr
1317 * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0004
1318 * @tc.desc Test GetCurrentChannelId interface,return -1 if set the parameter capture is nullptr
1319 */
1320 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0004, Function | MediumTest | Level1)
1321 {
1322 int32_t ret = -1;
1323 uint32_t channelId = 0;
1324 struct AudioAdapter *adapter = nullptr;
1325 struct AudioCapture *capture = nullptr;
1326 struct AudioCapture *captureNull = nullptr;
1327 ASSERT_NE(nullptr, GetAudioManager);
1328 TestAudioManager* manager = GetAudioManager();
1329 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
1330 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1331
1332 ret = capture->attr.GetCurrentChannelId(captureNull, &channelId);
1333 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1334
1335 adapter->DestroyCapture(adapter, capture);
1336 manager->UnloadAdapter(manager, adapter);
1337 }
1338 /**
1339 * @tc.name Test CaptureGetCurrentChannelId API via setting the parameter channelId is nullptr
1340 * @tc.number SUB_Audio_HDI_RenderGetCurrentChannelId_0005
1341 * @tc.desc Test CaptureGetCurrentChannelId interface, return -1 if setting the parameter channelId is nullptr
1342 */
1343 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetCurrentChannelId_0005, Function | MediumTest | Level1)
1344 {
1345 int32_t ret = -1;
1346 uint32_t *channelIdNull = nullptr;
1347 struct AudioAdapter *adapter = nullptr;
1348 struct AudioCapture *capture = nullptr;
1349 ASSERT_NE(nullptr, GetAudioManager);
1350 TestAudioManager* manager = GetAudioManager();
1351 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
1352 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1353
1354 ret = capture->attr.GetCurrentChannelId(capture, channelIdNull);
1355 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1356
1357 adapter->DestroyCapture(adapter, capture);
1358 manager->UnloadAdapter(manager, adapter);
1359 }
1360 #if defined (AUDIO_ADM_SERVICE) || defined (AUDIO_ADM_SO) || defined (__LITEOS__)
1361 /**
1362 * @tc.name Test CaptureSetExtraParams API via setting ExtraParams during playback
1363 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0001
1364 * @tc.desc Test CaptureSetExtraParams interface,return 0 if the ExtraParams is set during playback
1365 */
1366 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0001, Function | MediumTest | Level1)
1367 {
1368 int32_t ret = -1;
1369 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
1370 char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-sampling-rate=48000";
1371 size_t index = 1;
1372 char keyValueListValue[256] = {};
1373 int32_t listLenth = 256;
1374 uint64_t FILESIZE = 1024;
1375 struct PrepareAudioPara audiopara = {
1376 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC,
1377 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
1378 };
1379 ASSERT_NE(nullptr, GetAudioManager);
1380 audiopara.manager = GetAudioManager();
1381 ASSERT_NE(nullptr, audiopara.manager);
1382
1383 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
1384 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1385 sleep(1);
1386 if (audiopara.capture != nullptr) {
1387 ret = audiopara.capture->attr.SetExtraParams((AudioHandle)audiopara.capture, keyValueList);
1388 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1389 ret = audiopara.capture->attr.GetExtraParams((AudioHandle)audiopara.capture, keyValueListValue, listLenth);
1390 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1391 string strGetValue = keyValueListValue;
1392 size_t indexAttr = strGetValue.find("attr-frame-count");
1393 size_t indexFlag = strGetValue.rfind(";");
1394 if (indexAttr != string::npos && indexFlag != string::npos) {
1395 strGetValue.replace(indexAttr, indexFlag - indexAttr + index, "");
1396 }
1397 EXPECT_STREQ(keyValueListExp, strGetValue.c_str());
1398 }
1399
1400 ret = ThreadRelease(audiopara);
1401 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1402 }
1403 /**
1404 * @tc.name Test CaptureSetExtraParams API via setting some parameters after playing
1405 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0002
1406 * @tc.desc Test CaptureSetExtraParams interface,return 0 if some parameters is set after playing
1407 */
1408 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0002, Function | MediumTest | Level1)
1409 {
1410 int32_t ret = -1;
1411 struct AudioAdapter *adapter = {};
1412 struct AudioCapture *capture = nullptr;
1413 char keyValueListOne[] = "attr-frame-count=4096;";
1414 char keyValueListOneExp[] = "attr-route=0;attr-format=16;attr-channels=2;attr-frame-count=4096;\
1415 attr-sampling-rate=48000";
1416 char keyValueListTwo[] = "attr-route=1;attr-frame-count=1024;";
1417 char keyValueListTwoExp[] = "attr-route=1;attr-format=16;attr-channels=2;attr-frame-count=1024;\
1418 attr-sampling-rate=48000";
1419 char keyValueListThr[] = "attr-route=0;attr-channels=1;attr-frame-count=4096;";
1420 char keyValueListThrExp[] = "attr-route=0;attr-format=16;attr-channels=1;attr-frame-count=4096;\
1421 attr-sampling-rate=48000";
1422 char keyValueListFour[] = "attr-format=32;attr-channels=2;attr-frame-count=4096;attr-sampling-rate=48000";
1423 char keyValueListFourExp[] = "attr-route=0;attr-format=32;attr-channels=2;attr-frame-count=4096;\
1424 attr-sampling-rate=48000";
1425 char keyValueListValueOne[256] = {};
1426 char keyValueListValueTwo[256] = {};
1427 char keyValueListValueThr[256] = {};
1428 char keyValueListValueFour[256] = {};
1429 int32_t listLenth = 256;
1430 ASSERT_NE(nullptr, GetAudioManager);
1431 TestAudioManager* manager = GetAudioManager();
1432 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
1433 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1434
1435 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListOne);
1436 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1437 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueOne, listLenth);
1438 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1439 EXPECT_STREQ(keyValueListOneExp, keyValueListValueOne);
1440 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListTwo);
1441 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1442 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueTwo, listLenth);
1443 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1444 EXPECT_STREQ(keyValueListTwoExp, keyValueListValueTwo);
1445 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListThr);
1446 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1447 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueThr, listLenth);
1448 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1449 EXPECT_STREQ(keyValueListThrExp, keyValueListValueThr);
1450 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListFour);
1451 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1452 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValueFour, listLenth);
1453 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1454 EXPECT_STREQ(keyValueListFourExp, keyValueListValueFour);
1455
1456 ret = capture->control.Stop((AudioHandle)capture);
1457 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1458 adapter->DestroyCapture(adapter, capture);
1459 manager->UnloadAdapter(manager, adapter);
1460 }
1461 /**
1462 * @tc.name Test CaptureSetExtraParams API via setting keyvaluelist to a value outside the range
1463 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0003
1464 * @tc.desc Test CaptureSetExtraParams interface,return -1 if the Keyvaluelist is a value out of range
1465 */
1466 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0003, Function | MediumTest | Level1)
1467 {
1468 int32_t ret = -1;
1469 struct AudioAdapter *adapter = {};
1470 struct AudioCapture *capture = nullptr;
1471 char keyValueList[] = "attr-para=abc;";
1472
1473 ASSERT_NE(nullptr, GetAudioManager);
1474 TestAudioManager* manager = GetAudioManager();
1475 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1476 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1477 ret = ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
1478 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1479
1480 adapter->DestroyCapture(adapter, capture);
1481 manager->UnloadAdapter(manager, adapter);
1482 }
1483 /**
1484 * @tc.name Test CaptureSetExtraParams API via adding parameters to keyvaluelist
1485 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0004
1486 * @tc.desc Test CaptureSetExtraParams interface,return -1 if adding parameters to keyvaluelist
1487 */
1488 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0004, Function | MediumTest | Level1)
1489 {
1490 int32_t ret = -1;
1491 struct AudioAdapter *adapter = {};
1492 struct AudioCapture *capture = nullptr;
1493 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000;\
1494 attr-para=abc";
1495
1496 ASSERT_NE(nullptr, GetAudioManager);
1497 TestAudioManager* manager = GetAudioManager();
1498 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1499 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1500 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
1501 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1502
1503 adapter->DestroyCapture(adapter, capture);
1504 manager->UnloadAdapter(manager, adapter);
1505 }
1506 /**
1507 * @tc.name Test CaptureSetExtraParams API via setting ExtraParams When the key is the same and the value is
1508 different
1509 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0005
1510 * @tc.desc Test CaptureSetExtraParams interface,return 0 if set ExtraParams When the key is the same and the value
1511 is different
1512 */
1513 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0005, Function | MediumTest | Level1)
1514 {
1515 int32_t ret = -1;
1516 struct AudioAdapter *adapter = {};
1517 struct AudioCapture *capture = nullptr;
1518 char keyValueList[] = "attr-route=1;attr-format=32;attr-frame-count=4096;";
1519 char keyValueListExp[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=4096;\
1520 attr-sampling-rate=48000";
1521 char keyValueListValue[256] = {};
1522 int32_t listLenth = 256;
1523
1524 ASSERT_NE(nullptr, GetAudioManager);
1525 TestAudioManager* manager = GetAudioManager();
1526 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
1527 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1528 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
1529 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1530 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValue, listLenth);
1531 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1532 EXPECT_STREQ(keyValueListExp, keyValueListValue);
1533
1534 ret = capture->control.Stop((AudioHandle)capture);
1535 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1536 adapter->DestroyCapture(adapter, capture);
1537 manager->UnloadAdapter(manager, adapter);
1538 }
1539 /**
1540 * @tc.name Test CaptureSetExtraParams API via setting the parameter in keyvaluelist as an abnormal value
1541 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0006
1542 * @tc.desc Test CaptureSetExtraParams interface,return -1 if set the parameter in keyvaluelist as an abnormal value
1543 */
1544 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0006, Function | MediumTest | Level1)
1545 {
1546 int32_t ret = -1;
1547 struct AudioAdapter *adapter = {};
1548 struct AudioCapture *capture = nullptr;
1549 char attrSamplingRateError[] = "attr-sampling-rate=1234567;";
1550 char attrChannelsError[] = "attr-channels=3;";
1551 char attrFrameCountError[] = "attr-frame-count=111111111111111111111;";
1552 char attrRouteError[] = "attr-route=5;";
1553 char attrFormateError[] = "attr-formate=12;";
1554
1555 ASSERT_NE(nullptr, GetAudioManager);
1556 TestAudioManager* manager = GetAudioManager();
1557 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1558 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1559 ret = capture->attr.SetExtraParams((AudioHandle)capture, attrSamplingRateError);
1560 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1561 ret = capture->attr.SetExtraParams((AudioHandle)capture, attrChannelsError);
1562 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1563 ret = capture->attr.SetExtraParams((AudioHandle)capture, attrFrameCountError);
1564 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1565 ret = capture->attr.SetExtraParams((AudioHandle)capture, attrRouteError);
1566 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1567 ret = capture->attr.SetExtraParams((AudioHandle)capture, attrFormateError);
1568 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1569
1570 adapter->DestroyCapture(adapter, capture);
1571 manager->UnloadAdapter(manager, adapter);
1572 }
1573 /**
1574 * @tc.name Test CaptureSetExtraParams API via setting the parameter render is nullptr
1575 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0007
1576 * @tc.desc Test CaptureSetExtraParams interface,return -1 if set the parameter render is nullptr
1577 */
1578 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0007, Function | MediumTest | Level1)
1579 {
1580 int32_t ret = -1;
1581 struct AudioAdapter *adapter = {};
1582 struct AudioCapture *capture = nullptr;
1583 struct AudioCapture *captureNull = nullptr;
1584 char keyValueList[] = "attr-format=2;";
1585
1586 ASSERT_NE(nullptr, GetAudioManager);
1587 TestAudioManager* manager = GetAudioManager();
1588 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1589 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1590 ret = capture->attr.SetExtraParams((AudioHandle)captureNull, keyValueList);
1591 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1592
1593 adapter->DestroyCapture(adapter, capture);
1594 manager->UnloadAdapter(manager, adapter);
1595 }
1596 /**
1597 * @tc.name Test CaptureSetExtraParams API via setting the format of ExtraParams is nullptr
1598 * @tc.number SUB_Audio_HDI_CaptureSetExtraParams_0008
1599 * @tc.desc Test CaptureSetExtraParams interface,return -1 if set the format of ExtraParams is nullptr
1600 */
1601 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureSetExtraParams_0008, Function | MediumTest | Level1)
1602 {
1603 int32_t ret = -1;
1604 struct AudioAdapter *adapter = {};
1605 struct AudioCapture *capture = nullptr;
1606 char keyValueListNull[] = "attr-format=;";
1607
1608 ASSERT_NE(nullptr, GetAudioManager);
1609 TestAudioManager* manager = GetAudioManager();
1610 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1611 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1612 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueListNull);
1613 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1614
1615 adapter->DestroyCapture(adapter, capture);
1616 manager->UnloadAdapter(manager, adapter);
1617 }
1618 /**
1619 * @tc.name Test CaptureGetExtraParams API via legal input
1620 * @tc.number SUB_Audio_HDI_CaptureGetExtraParams_0001
1621 * @tc.desc Test CaptureGetExtraParams interface,return 0 if the RenderGetExtraParams was obtained successfully
1622 */
1623 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetExtraParams_0001, Function | MediumTest | Level1)
1624 {
1625 int32_t ret = -1;
1626 uint64_t count = 0;
1627 struct AudioAdapter *adapter = {};
1628 struct AudioCapture *capture = nullptr;
1629 struct AudioSampleAttributes attrsValue = {};
1630 char keyValueList[] = "attr-format=24;attr-frame-count=4096;";
1631 char keyValueListExp[] = "attr-route=0;attr-format=24;attr-channels=2;attr-frame-count=4096;\
1632 attr-sampling-rate=48000";
1633 char keyValueListValue[256] = {};
1634 int32_t listLenth = 256;
1635 int32_t formatExp = 3;
1636 uint32_t sampleRateExp = 48000;
1637 uint32_t channelCountExp = 2;
1638 uint32_t frameCountExp = 4096;
1639
1640 ASSERT_NE(nullptr, GetAudioManager);
1641 TestAudioManager* manager = GetAudioManager();
1642 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
1643 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1644 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
1645 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1646 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValue, listLenth);
1647 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1648 EXPECT_STREQ(keyValueListExp, keyValueListValue);
1649
1650 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
1651 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1652 EXPECT_EQ(formatExp, attrsValue.format);
1653 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
1654 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
1655 ret = capture->attr.GetFrameCount(capture, &count);
1656 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1657 EXPECT_EQ(count, frameCountExp);
1658
1659 ret = capture->control.Stop((AudioHandle)capture);
1660 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1661 adapter->DestroyCapture(adapter, capture);
1662 manager->UnloadAdapter(manager, adapter);
1663 }
1664 /**
1665 * @tc.name Test CaptureGetExtraParams API via setting the parameter render is nullptr
1666 * @tc.number SUB_Audio_HDI_CaptureGetExtraParams_0002
1667 * @tc.desc Test CaptureGetExtraParams interface,return 0 if set the parameter render is nullptr
1668 */
1669 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetExtraParams_0002, Function | MediumTest | Level1)
1670 {
1671 int32_t ret = -1;
1672 struct AudioAdapter *adapter = {};
1673 struct AudioCapture *capture = nullptr;
1674 struct AudioCapture *captureNull = nullptr;
1675 char keyValueList[] = "attr-format=32;";
1676 char keyValueListValue[256] = {};
1677 int32_t listLenth = 256;
1678
1679 ASSERT_NE(nullptr, GetAudioManager);
1680 TestAudioManager* manager = GetAudioManager();
1681 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1682 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1683 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
1684 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1685 ret = capture->attr.GetExtraParams((AudioHandle)captureNull, keyValueListValue, listLenth);
1686 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1687
1688 adapter->DestroyCapture(adapter, capture);
1689 manager->UnloadAdapter(manager, adapter);
1690 }
1691 /**
1692 * @tc.name Test CaptureGetExtraParams API via setting listlength to be less than the actual length
1693 * @tc.number SUB_Audio_HDI_CaptureGetExtraParams_0003
1694 * @tc.desc Test CaptureGetExtraParams interface,return 0 if set listlength to be less than the actual length
1695 */
1696 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetExtraParams_0003, Function | MediumTest | Level1)
1697 {
1698 int32_t ret = -1;
1699 struct AudioAdapter *adapter = {};
1700 struct AudioCapture *capture = nullptr;
1701 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000;";
1702 char keyValueListValue[256] = {};
1703 int32_t listLenth = 8;
1704
1705 ASSERT_NE(nullptr, GetAudioManager);
1706 TestAudioManager* manager = GetAudioManager();
1707 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1708 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1709 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
1710 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1711 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValue, listLenth);
1712 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
1713
1714 adapter->DestroyCapture(adapter, capture);
1715 manager->UnloadAdapter(manager, adapter);
1716 }
1717 /**
1718 * @tc.name Test CaptureGetExtraParams API via setting listlenth equal to the actual length
1719 * @tc.number SUB_Audio_HDI_CaptureGetExtraParams_0004
1720 * @tc.desc Test CaptureGetExtraParams interface,return 0 if set listlenth equal to the actual length
1721 */
1722 HWTEST_F(AudioHdiCaptureAttrTest, SUB_Audio_HDI_CaptureGetExtraParams_0004, Function | MediumTest | Level1)
1723 {
1724 int32_t ret = -1;
1725 struct AudioAdapter *adapter = {};
1726 struct AudioCapture *capture = nullptr;
1727 char keyValueList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=11111111111111111111;\
1728 attr-sampling-rate=48000";
1729 char keyValueListValue[256] = {};
1730 int32_t listLenth = 107;
1731
1732 ASSERT_NE(nullptr, GetAudioManager);
1733 TestAudioManager* manager = GetAudioManager();
1734 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
1735 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1736 ret = capture->attr.SetExtraParams((AudioHandle)capture, keyValueList);
1737 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1738 ret = capture->attr.GetExtraParams((AudioHandle)capture, keyValueListValue, listLenth);
1739 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1740 EXPECT_STREQ(keyValueList, keyValueListValue);
1741
1742 ret = capture->control.Stop((AudioHandle)capture);
1743 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1744 adapter->DestroyCapture(adapter, capture);
1745 manager->UnloadAdapter(manager, adapter);
1746 }
1747 #endif
1748 }