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