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 #include "audio_hdi_common.h"
17 #include <pthread.h>
18 #include "audio_hdicapture_reliability_test.h"
19
20 using namespace std;
21 using namespace testing::ext;
22 using namespace HMOS::Audio;
23
24 namespace {
25 const string ADAPTER_NAME_USB = "usb";
26 const int PTHREAD_SAMEADA_COUNT = 3;
27 const int PTHREAD_DIFFADA_COUNT = 3;
28 const uint32_t SAMPLERATEVALUE = 48000;
29 mutex g_testMutex;
30 struct PrepareAudioPara g_para[PTHREAD_DIFFADA_COUNT] = {
31 {
32 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC,
33 .path = AUDIO_CAPTURE_FILE.c_str()
34 }
35 };
36
37 class AudioHdiCaptureReliabilityTest : public testing::Test {
38 public:
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43 static TestAudioManager *(*GetAudioManager)();
44 static void *handleSo;
45 #ifdef AUDIO_MPI_SO
46 static int32_t (*SdkInit)();
47 static void (*SdkExit)();
48 static void *sdkSo;
49 #endif
50 static int32_t RelAudioCreateCapture(struct PrepareAudioPara& ptr);
51 static int32_t RelGetAllAdapter(struct PrepareAudioPara& ptr);
52 static int32_t RelLoadAdapter(struct PrepareAudioPara& ptr);
53 static int32_t RelAudioCaptureSetMute(struct PrepareAudioPara& ptr);
54 static int32_t RelAudioCaptureGetMute(struct PrepareAudioPara& ptr);
55 static int32_t RelAudioCaptureSetVolume(struct PrepareAudioPara& ptr);
56 static int32_t RelAudioCaptureGetVolume(struct PrepareAudioPara& ptr);
57 static int32_t RelAudioCaptureProcedure(struct PrepareAudioPara& ptr);
58 static int32_t RelAudioCaptureStartAndCaputreFrame(struct PrepareAudioPara& ptr);
59 static int32_t RelAudioCaptureSetGain(struct PrepareAudioPara& ptr);
60 static int32_t RelAudioCaptureGetGain(struct PrepareAudioPara& ptr);
61 static int32_t RelAudioCaptureGetGainThreshold(struct PrepareAudioPara& ptr);
62 static int32_t RelAudioCaptureGetFrameSize(struct PrepareAudioPara& ptr);
63 static int32_t RelAudioCaptureGetFrameCount(struct PrepareAudioPara& ptr);
64 static int32_t RelAudioCaptureGetCurrentChannelId(struct PrepareAudioPara& ptr);
65 static int32_t RelAudioCaptureSetSampleAttributes(struct PrepareAudioPara& ptr);
66 static int32_t RelAudioCaptureGetSampleAttributes(struct PrepareAudioPara& ptr);
67 static int32_t RelAudioCaptureSelectScene(struct PrepareAudioPara& ptr);
68 static int32_t RelAudioCaptureCheckSceneCapability(struct PrepareAudioPara& ptr);
69 };
70
71 using THREAD_FUNC = void *(*)(void *);
72
73 TestAudioManager *(*AudioHdiCaptureReliabilityTest::GetAudioManager)() = nullptr;
74 void *AudioHdiCaptureReliabilityTest::handleSo = nullptr;
75 #ifdef AUDIO_MPI_SO
76 int32_t (*AudioHdiCaptureReliabilityTest::SdkInit)() = nullptr;
77 void (*AudioHdiCaptureReliabilityTest::SdkExit)() = nullptr;
78 void *AudioHdiCaptureReliabilityTest::sdkSo = nullptr;
79 #endif
80
SetUpTestCase(void)81 void AudioHdiCaptureReliabilityTest::SetUpTestCase(void)
82 {
83 #ifdef AUDIO_MPI_SO
84 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
85 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
86 if (sdkSo == nullptr) {
87 return;
88 }
89 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
90 if (SdkInit == nullptr) {
91 return;
92 }
93 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
94 if (SdkExit == nullptr) {
95 return;
96 }
97 SdkInit();
98 #endif
99 char absPath[PATH_MAX] = {0};
100 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
101 return;
102 }
103
104 handleSo = dlopen(absPath, RTLD_LAZY);
105 if (handleSo == nullptr) {
106 return;
107 }
108 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
109 if (GetAudioManager == nullptr) {
110 return;
111 }
112 }
113
TearDownTestCase(void)114 void AudioHdiCaptureReliabilityTest::TearDownTestCase(void)
115 {
116 #ifdef AUDIO_MPI_SO
117 SdkExit();
118 if (sdkSo != nullptr) {
119 dlclose(sdkSo);
120 sdkSo = nullptr;
121 }
122 if (SdkInit != nullptr) {
123 SdkInit = nullptr;
124 }
125 if (SdkExit != nullptr) {
126 SdkExit = nullptr;
127 }
128 #endif
129 if (handleSo != nullptr) {
130 dlclose(handleSo);
131 handleSo = nullptr;
132 }
133 if (GetAudioManager != nullptr) {
134 GetAudioManager = nullptr;
135 }
136 }
137
SetUp(void)138 void AudioHdiCaptureReliabilityTest::SetUp(void) {}
139
TearDown(void)140 void AudioHdiCaptureReliabilityTest::TearDown(void) {}
141
RelGetAllAdapter(struct PrepareAudioPara & ptr)142 int32_t AudioHdiCaptureReliabilityTest::RelGetAllAdapter(struct PrepareAudioPara& ptr)
143 {
144 int size = 0;
145 if (ptr.manager == nullptr) {
146 return AUDIO_HAL_ERR_INVALID_PARAM;
147 }
148 g_testMutex.lock();
149 ptr.manager->GetAllAdapters(ptr.manager, &ptr.descs, &size);
150 g_testMutex.unlock();
151 if (ptr.descs == nullptr || size == 0) {
152 return AUDIO_HAL_ERR_INTERNAL;
153 } else {
154 int index = SwitchAdapter(ptr.descs, ptr.adapterName, ptr.portType, ptr.audioPort, size);
155 if (index < 0) {
156 return AUDIO_HAL_ERR_INTERNAL;
157 } else {
158 ptr.desc = &ptr.descs[index];
159 }
160 }
161 return AUDIO_HAL_SUCCESS;
162 }
163
RelLoadAdapter(struct PrepareAudioPara & ptr)164 int32_t AudioHdiCaptureReliabilityTest::RelLoadAdapter(struct PrepareAudioPara& ptr)
165 {
166 if (ptr.desc == nullptr) {
167 return AUDIO_HAL_ERR_INVALID_PARAM;
168 }
169 g_testMutex.lock();
170 ptr.manager->LoadAdapter(ptr.manager, ptr.desc, &ptr.adapter);
171 g_testMutex.unlock();
172 if (ptr.adapter == nullptr) {
173 return AUDIO_HAL_ERR_INVALID_PARAM;
174 }
175 return AUDIO_HAL_SUCCESS;
176 }
177
RelAudioCreateCapture(struct PrepareAudioPara & ptr)178 int32_t AudioHdiCaptureReliabilityTest::RelAudioCreateCapture(struct PrepareAudioPara& ptr)
179 {
180 int32_t ret = -1;
181 struct AudioSampleAttributes attrs = {};
182 struct AudioDeviceDescriptor devDesc = {};
183 if (ptr.adapter == nullptr || ptr.manager == nullptr) {
184 return AUDIO_HAL_ERR_INVALID_PARAM;
185 }
186 InitAttrs(attrs);
187 InitDevDesc(devDesc, ptr.audioPort->portId, ptr.pins);
188 g_testMutex.lock();
189 ret = ptr.adapter->CreateCapture(ptr.adapter, &devDesc, &attrs, &ptr.capture);
190 g_testMutex.unlock();
191 if (ret < 0) {
192 ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter);
193 return ret;
194 }
195 if (ptr.capture == nullptr) {
196 ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter);
197 return AUDIO_HAL_ERR_INVALID_PARAM;
198 }
199 return AUDIO_HAL_SUCCESS;
200 }
201
RelAudioCaptureStartAndCaputreFrame(struct PrepareAudioPara & ptr)202 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureStartAndCaputreFrame(struct PrepareAudioPara& ptr)
203 {
204 int32_t ret = -1;
205 struct AudioSampleAttributes attrs = {};
206 FILE *file = fopen(ptr.path, "wb+");
207 if (file == nullptr) {
208 return AUDIO_HAL_ERR_INTERNAL;
209 }
210 InitAttrs(attrs);
211
212 g_testMutex.lock();
213 ret = FrameStartCapture(ptr.capture, file, attrs);
214 g_testMutex.unlock();
215 fclose(file);
216 return ret;
217 }
218
RelAudioCaptureSetMute(struct PrepareAudioPara & ptr)219 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetMute(struct PrepareAudioPara& ptr)
220 {
221 if (ptr.capture == nullptr) {
222 return AUDIO_HAL_ERR_INVALID_PARAM;
223 }
224 int32_t ret = -1;
225 g_testMutex.lock();
226 ret = ptr.capture->volume.SetMute(ptr.capture, ptr.character.setmute);
227 g_testMutex.unlock();
228 return ret;
229 }
230
RelAudioCaptureGetMute(struct PrepareAudioPara & ptr)231 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetMute(struct PrepareAudioPara& ptr)
232 {
233 if (ptr.capture == nullptr) {
234 return AUDIO_HAL_ERR_INVALID_PARAM;
235 }
236 int32_t ret = -1;
237 g_testMutex.lock();
238 ret = ptr.capture->volume.GetMute(ptr.capture, &(ptr.character.getmute));
239 g_testMutex.unlock();
240 return ret;
241 }
242
RelAudioCaptureSetVolume(struct PrepareAudioPara & ptr)243 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetVolume(struct PrepareAudioPara& ptr)
244 {
245 if (ptr.capture == nullptr) {
246 return AUDIO_HAL_ERR_INVALID_PARAM;
247 }
248 int32_t ret = -1;
249 g_testMutex.lock();
250 ret = ptr.capture->volume.SetVolume(ptr.capture, ptr.character.setvolume);
251 g_testMutex.unlock();
252 return ret;
253 }
254
RelAudioCaptureGetVolume(struct PrepareAudioPara & ptr)255 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetVolume(struct PrepareAudioPara& ptr)
256 {
257 if (ptr.capture == nullptr) {
258 return AUDIO_HAL_ERR_INVALID_PARAM;
259 }
260 int32_t ret = -1;
261 g_testMutex.lock();
262 ret = ptr.capture->volume.GetVolume(ptr.capture, &(ptr.character.getvolume));
263 g_testMutex.unlock();
264 return ret;
265 }
266
RelAudioCaptureProcedure(struct PrepareAudioPara & ptr)267 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureProcedure(struct PrepareAudioPara& ptr)
268 {
269 int32_t ret = -1;
270 ret = RelGetAllAdapter(ptr);
271 if (ret < 0) {
272 return ret;
273 }
274
275 ret = RelLoadAdapter(ptr);
276 if (ret < 0) {
277 return ret;
278 }
279
280 ret = RelAudioCreateCapture(ptr);
281 if (ret < 0) {
282 return ret;
283 }
284
285 ret = RelAudioCaptureStartAndCaputreFrame(ptr);
286 if (ret < 0) {
287 ptr.adapter->DestroyCapture(ptr.adapter, ptr.capture);
288 ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter);
289 return ret;
290 }
291 return AUDIO_HAL_SUCCESS;
292 }
293
RelAudioCaptureGetGainThreshold(struct PrepareAudioPara & ptr)294 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetGainThreshold(struct PrepareAudioPara& ptr)
295 {
296 if (ptr.capture == nullptr) {
297 return AUDIO_HAL_ERR_INVALID_PARAM;
298 }
299 int32_t ret = -1;
300 g_testMutex.lock();
301 ret = ptr.capture->volume.GetGainThreshold(ptr.capture, &(ptr.character.gainthresholdmin),
302 &(ptr.character.gainthresholdmax));
303 g_testMutex.unlock();
304 return ret;
305 }
306
RelAudioCaptureSetGain(struct PrepareAudioPara & ptr)307 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetGain(struct PrepareAudioPara& ptr)
308 {
309 if (ptr.capture == nullptr) {
310 return AUDIO_HAL_ERR_INVALID_PARAM;
311 }
312 int32_t ret = -1;
313 g_testMutex.lock();
314 ret = ptr.capture->volume.SetGain(ptr.capture, ptr.character.setgain);
315 g_testMutex.unlock();
316 return ret;
317 }
318
RelAudioCaptureGetGain(struct PrepareAudioPara & ptr)319 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetGain(struct PrepareAudioPara& ptr)
320 {
321 if (ptr.capture == nullptr) {
322 return AUDIO_HAL_ERR_INVALID_PARAM;
323 }
324 int32_t ret = -1;
325 g_testMutex.lock();
326 ret = ptr.capture->volume.GetGain(ptr.capture, &(ptr.character.getgain));
327 g_testMutex.unlock();
328 return ret;
329 }
330
RelAudioCaptureGetFrameSize(struct PrepareAudioPara & ptr)331 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetFrameSize(struct PrepareAudioPara& ptr)
332 {
333 if (ptr.capture == nullptr) {
334 return AUDIO_HAL_ERR_INVALID_PARAM;
335 }
336 int32_t ret = -1;
337 g_testMutex.lock();
338 ret = ptr.capture->attr.GetFrameSize(ptr.capture, &(ptr.character.getframesize));
339 g_testMutex.unlock();
340 return ret;
341 }
342
RelAudioCaptureGetFrameCount(struct PrepareAudioPara & ptr)343 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetFrameCount(struct PrepareAudioPara& ptr)
344 {
345 if (ptr.capture == nullptr) {
346 return AUDIO_HAL_ERR_INVALID_PARAM;
347 }
348 int32_t ret = -1;
349 g_testMutex.lock();
350 ret = ptr.capture->attr.GetFrameCount(ptr.capture, &(ptr.character.getframecount));
351 g_testMutex.unlock();
352 return ret;
353 }
354
RelAudioCaptureGetCurrentChannelId(struct PrepareAudioPara & ptr)355 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetCurrentChannelId(struct PrepareAudioPara& ptr)
356 {
357 if (ptr.capture == nullptr) {
358 return AUDIO_HAL_ERR_INVALID_PARAM;
359 }
360 int32_t ret = -1;
361 g_testMutex.lock();
362 ret = ptr.capture->attr.GetCurrentChannelId(ptr.capture, &(ptr.character.getcurrentchannelId));
363 g_testMutex.unlock();
364 return ret;
365 }
366
RelAudioCaptureSetSampleAttributes(struct PrepareAudioPara & ptr)367 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSetSampleAttributes(struct PrepareAudioPara& ptr)
368 {
369 if (ptr.capture == nullptr) {
370 return AUDIO_HAL_ERR_INVALID_PARAM;
371 }
372 int32_t ret = -1;
373 g_testMutex.lock();
374 ret = ptr.capture->attr.SetSampleAttributes(ptr.capture, &(ptr.attrs));
375 g_testMutex.unlock();
376 return ret;
377 }
378
RelAudioCaptureGetSampleAttributes(struct PrepareAudioPara & ptr)379 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureGetSampleAttributes(struct PrepareAudioPara& ptr)
380 {
381 if (ptr.capture == nullptr) {
382 return AUDIO_HAL_ERR_INVALID_PARAM;
383 }
384 int32_t ret = -1;
385 g_testMutex.lock();
386 ret = ptr.capture->attr.GetSampleAttributes(ptr.capture, &(ptr.attrsValue));
387 g_testMutex.unlock();
388 return ret;
389 }
390
RelAudioCaptureSelectScene(struct PrepareAudioPara & ptr)391 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureSelectScene(struct PrepareAudioPara& ptr)
392 {
393 if (ptr.capture == nullptr) {
394 return AUDIO_HAL_ERR_INVALID_PARAM;
395 }
396 int32_t ret = -1;
397 g_testMutex.lock();
398 ret = ptr.capture->scene.SelectScene(ptr.capture, &(ptr.scenes));
399 g_testMutex.unlock();
400 return ret;
401 }
402
RelAudioCaptureCheckSceneCapability(struct PrepareAudioPara & ptr)403 int32_t AudioHdiCaptureReliabilityTest::RelAudioCaptureCheckSceneCapability(struct PrepareAudioPara& ptr)
404 {
405 if (ptr.capture == nullptr) {
406 return AUDIO_HAL_ERR_INVALID_PARAM;
407 }
408 int32_t ret = -1;
409 g_testMutex.lock();
410 ret = ptr.capture->scene.CheckSceneCapability(ptr.capture, &ptr.scenes, &(ptr.character.supported));
411 g_testMutex.unlock();
412 return ret;
413 }
414
415 /**
416 * @tc.name test AudioCaptureSetGain API via Multithread call.
417 * @tc.number SUB_Audio_HDI_AudioCaptureSetGain_Reliability_0001
418 * @tc.desc test AudioCaptureSetGain interface Reliability pass through pthread_create fun and adapterName is same.
419 * @tc.author: zhouyongxiao
420 */
421 HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetGain_Reliability_0001, TestSize.Level1)
422 {
423 int32_t ret = -1;
424 ASSERT_NE(nullptr, GetAudioManager);
425 g_para[0].manager = GetAudioManager();
426 ASSERT_NE(nullptr, g_para[0].manager);
427 ret = RelAudioCaptureProcedure(g_para[0]);
428 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
429 pthread_t tids[PTHREAD_SAMEADA_COUNT];
430 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
431 g_para[0].character.setgain = 2;
432 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetGain, &g_para[0]);
433 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
434 }
435
436 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
437 void *result = nullptr;
438 pthread_join(tids[i], &result);
439 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
440 ret = g_para[0].capture->volume.GetGain(g_para[0].capture, &(g_para[0].character.getgain));
441 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
442 EXPECT_EQ(g_para[0].character.setgain, g_para[0].character.getgain);
443 }
444 if (g_para[0].adapter != nullptr){
445 ret = StopAudio(g_para[0]);
446 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
447 }
448 }
449
450 /**
451 * @tc.name test AudioCaptureGetGain API via Multithread call.
452 * @tc.number SUB_Audio_HDI_AudioCaptureGetGain_Reliability_0001
453 * @tc.desc test AudioCaptureGetGain interface Reliability pass through pthread_create fun and adapterName is same.
454 * @tc.author: zhouyongxiao
455 */
456 HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetGain_Reliability_0001, TestSize.Level1)
457 {
458 int32_t ret = -1;
459 ASSERT_NE(nullptr, GetAudioManager);
460 g_para[0].manager = GetAudioManager();
461 ASSERT_NE(nullptr, g_para[0].manager);
462
463 ret = AudioCreateCapture(g_para[0].manager, g_para[0].pins, g_para[0].adapterName, &g_para[0].adapter,
464 &g_para[0].capture);
465 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
466 pthread_t tids[PTHREAD_SAMEADA_COUNT];
467 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
468 g_para[0].character.setgain = 8;
469 ret = g_para[0].capture->volume.SetGain(g_para[0].capture, g_para[0].character.setgain);
470 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
471 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetGain, &g_para[0]);
472 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
473 }
474
475 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
476 void *result = nullptr;
477 pthread_join(tids[i], &result);
478 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
479 EXPECT_EQ(8, g_para[0].character.getgain);
480 }
481 g_para[0].adapter->DestroyCapture(g_para[0].adapter, g_para[0].capture);
482 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
483 }
484
485 /**
486 * @tc.name test AudioCaptureGetGainThreshold API via Multithread call.
487 * @tc.number SUB_Audio_HDI_AudioCaptureGetGainThreshold_Reliability_0001
488 * @tc.desc test GetGainThreshold interface Reliability pass through pthread_create fun and adapterName is same.
489 * @tc.author: zhouyongxiao
490 */
491 HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetGainThreshold_Reliability_0001, TestSize.Level1)
492 {
493 int32_t ret = -1;
494 ASSERT_NE(nullptr, GetAudioManager);
495 g_para[0].manager = GetAudioManager();
496 ASSERT_NE(nullptr, g_para[0].manager);
497
498 ret = AudioCreateCapture(g_para[0].manager, g_para[0].pins, g_para[0].adapterName, &g_para[0].adapter,
499 &g_para[0].capture);
500 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
501
502 pthread_t tids[PTHREAD_SAMEADA_COUNT];
503 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
504 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetGainThreshold, &g_para[0]);
505 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
506 }
507
508 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
509 void *result = nullptr;
510 pthread_join(tids[i], &result);
511 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
512 EXPECT_EQ(0, g_para[0].character.gainthresholdmin);
513 EXPECT_EQ(15, g_para[0].character.gainthresholdmax);
514 }
515 g_para[0].adapter->DestroyCapture(g_para[0].adapter, g_para[0].capture);
516 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
517 }
518
519 /**
520 * @tc.name test AudioCaptureGetFrameSize API via Multithread call.
521 * @tc.number SUB_Audio_HDI_AudioCaptureGetFrameSize_Reliability_0001
522 * @tc.desc test AudioCaptureGetFrameSize interface Reliability pass through pthread_create fun and adapterName is same
523 * @tc.author: zhouyongxiao
524 */
525 HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameSize_Reliability_0001, TestSize.Level1)
526 {
527 int32_t ret = -1;
528 uint64_t sizeValue = 4096;
529 ASSERT_NE(nullptr, GetAudioManager);
530 g_para[0].manager = GetAudioManager();
531 ASSERT_NE(nullptr, g_para[0].manager);
532 ret = AudioCreateCapture(g_para[0].manager, g_para[0].pins, g_para[0].adapterName, &g_para[0].adapter,
533 &g_para[0].capture);
534 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
535
536 pthread_t tids[PTHREAD_SAMEADA_COUNT];
537 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
538 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetFrameSize, &g_para[0]);
539 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
540 }
541
542 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
543 void *result = nullptr;
544 pthread_join(tids[i], &result);
545 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
546 EXPECT_EQ(sizeValue, g_para[0].character.getframesize);
547 }
548 g_para[0].adapter->DestroyCapture(g_para[0].adapter, g_para[0].capture);
549 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
550 }
551
552 /**
553 * @tc.name test AudioCaptureGetFrameCount API via Multithread call.
554 * @tc.number SUB_Audio_HDI_AudioCaptureGetFrameCount_Reliability_0001
555 * @tc.desc test CaptureGetFrameCount interface Reliability pass through pthread_create fun and adapterName is same
556 * @tc.author: zhouyongxiao
557 */
558 HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetFrameCount_Reliability_0001, TestSize.Level1)
559 {
560 int32_t ret = -1;
561 ASSERT_NE(nullptr, GetAudioManager);
562 g_para[0].manager = GetAudioManager();
563 ASSERT_NE(nullptr, g_para[0].manager);
564
565 ret = RelAudioCaptureProcedure(g_para[0]);
566 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
567
568 pthread_t tids[PTHREAD_SAMEADA_COUNT];
569 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
570 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetFrameCount, &g_para[0]);
571 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
572 }
573
574 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
575 void *result = nullptr;
576 pthread_join(tids[i], &result);
577 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
578 EXPECT_LT(INITIAL_VALUE, g_para[0].character.getframecount);
579 }
580 if (g_para[0].adapter != nullptr) {
581 ret = StopAudio(g_para[0]);
582 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
583 }
584 }
585
586 /**
587 * @tc.name test AudioGetCurrentChannelId API via Multithread call.
588 * @tc.number SUB_Audio_HDI_AudioGetCurrentChannelId_Reliability_0001
589 * @tc.desc test AudioGetCurrentChannelId interface Reliability pass through pthread_create fun and adapterName is same
590 * @tc.author: zhouyongxiao
591 */
592 HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioGetCurrentChannelId_Reliability_0001, TestSize.Level1)
593 {
594 int32_t ret = -1;
595 uint32_t channelIdValue = 2;
596 ASSERT_NE(nullptr, GetAudioManager);
597 g_para[0].manager = GetAudioManager();
598 ASSERT_NE(nullptr, g_para[0].manager);
599 ret = AudioCreateCapture(g_para[0].manager, g_para[0].pins, g_para[0].adapterName, &g_para[0].adapter,
600 &g_para[0].capture);
601 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
602
603 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
604 g_para[i].capture = g_para[0].capture;
605 g_para[i].character.getcurrentchannelId = 0;
606 }
607
608 pthread_t tids[PTHREAD_SAMEADA_COUNT];
609 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
610 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetCurrentChannelId, &g_para[i]);
611 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
612 }
613
614 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
615 void *result = nullptr;
616 pthread_join(tids[i], &result);
617 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
618 EXPECT_EQ(channelIdValue, g_para[i].character.getcurrentchannelId);
619 }
620 g_para[0].adapter->DestroyCapture(g_para[0].adapter, g_para[0].capture);
621 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
622
623 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
624 g_para[i].capture = 0;
625 }
626 }
627 /**
628 * @tc.name AudioCapturesetMute
629 * @tc.number SUB_Audio_HDI_AudioCaptureSetMute_0001
630 * @tc.desc test AudioCaptureSetMute interface Reliability pass through pthread_create(adapterName is same)
631 * @tc.author: wangkang
632 */
633 HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetMute_0001, TestSize.Level1)
634 {
635 int32_t ret = -1;
636 ASSERT_NE(nullptr, GetAudioManager);
637 g_para[0].manager = GetAudioManager();
638 ASSERT_NE(nullptr, g_para[0].manager);
639
640 ret = RelAudioCaptureProcedure(g_para[0]);
641 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
642
643 pthread_t tids[PTHREAD_SAMEADA_COUNT];
644 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
645 ret = g_para[0].capture->volume.GetMute(g_para[0].capture, &(g_para[0].character.getmute));
646 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
647 if (g_para[0].character.getmute == false) {
648 g_para[0].character.setmute = true;
649 } else {
650 g_para[0].character.setmute = false;
651 }
652 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetMute, &g_para[0]);
653 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
654 void *result = nullptr;
655 pthread_join(tids[i], &result);
656 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
657
658 ret = g_para[0].capture->volume.GetMute(g_para[0].capture, &(g_para[0].character.getmute));
659 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
660 if (g_para[0].character.setmute == true) {
661 EXPECT_TRUE(g_para[0].character.getmute);
662 } else {
663 EXPECT_FALSE(g_para[0].character.getmute);
664 }
665 }
666
667 if (g_para[0].adapter != nullptr){
668 ret = StopAudio(g_para[0]);
669 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
670 }
671 }
672
673 /**
674 * @tc.name RelAudioCaptureGetMute
675 * @tc.number SUB_Audio_HDI_RelAudioCaptureGetMute_0001
676 * @tc.desc test RelAudioCaptureGetMute interface Reliability pass through pthread_create(adapterName is same)
677 * @tc.author: wangkang
678 */
679 HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetMute_0001, TestSize.Level1)
680 {
681 int32_t ret = -1;
682 ASSERT_NE(nullptr, GetAudioManager);
683 g_para[0].manager = GetAudioManager();
684 ASSERT_NE(nullptr, g_para[0].manager);
685 ret = AudioCreateCapture(g_para[0].manager, g_para[0].pins, g_para[0].adapterName, &g_para[0].adapter,
686 &g_para[0].capture);
687 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
688
689 pthread_t tids[PTHREAD_SAMEADA_COUNT];
690 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
691 g_para[0].character.setmute = true;
692 ret = g_para[0].capture->volume.SetMute(g_para[0].capture, false);
693 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
694 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetMute, &g_para[0]);
695 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
696 }
697
698 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
699 void *result = nullptr;
700 pthread_join(tids[i], &result);
701 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
702 EXPECT_FALSE(g_para[0].character.getmute);
703 }
704 g_para[0].adapter->DestroyCapture(g_para[0].adapter, g_para[0].capture);
705 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
706 }
707
708 /**
709 * @tc.name test AudioCaptureSetVolume API via Multithread call.
710 * @tc.number SUB_Audio_HDI_AudiocaptureSetVolume_Reliability_0001
711 * @tc.desc test SetVolume interface Reliability pass through pthread_create fun and adapterName is same.
712 * @tc.author: ZHANGHAILIN
713 */
714 HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetVolume_Reliability_0001, TestSize.Level1)
715 {
716 int32_t ret = -1;
717 float volumeHighExpc = 0.70;
718 ASSERT_NE(nullptr, GetAudioManager);
719 g_para[0].manager = GetAudioManager();
720 ASSERT_NE(nullptr, g_para[0].manager);
721 ret = RelAudioCaptureProcedure(g_para[0]);
722 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
723
724 pthread_t tids[PTHREAD_SAMEADA_COUNT];
725 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
726 ret = memcpy_s(&g_para[0], sizeof(PrepareAudioPara), &g_para, sizeof(PrepareAudioPara));
727 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
728 ret = g_para[0].capture->volume.GetVolume(g_para[0].capture, &(g_para[0].character.getvolume));
729 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
730 g_para[0].character.setvolume = 0.7;
731 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetVolume, &g_para[0]);
732 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
733 }
734
735 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
736 void *result = nullptr;
737 pthread_join(tids[i], &result);
738 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
739 ret = g_para[0].capture->volume.GetVolume(g_para[0].capture, &(g_para[0].character.getvolume));
740 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
741 EXPECT_EQ(volumeHighExpc, g_para[0].character.getvolume);
742 }
743 if (g_para[0].adapter != nullptr){
744 ret = StopAudio(g_para[0]);
745 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
746 }
747 }
748
749 /**
750 * @tc.name test AudioCaptureGetVolume API via Multithread call.
751 * @tc.number SUB_Audio_HDI_AudioCaptureGetVolume_Reliability_0001
752 * @tc.desc test GetVolume interface Reliability pass through pthread_create fun and adapterName is same.
753 * @tc.author: zhouyongxiao
754 */
755 HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetVolume_Reliability_0001, TestSize.Level1)
756 {
757 int32_t ret = -1;
758 float volumeHighExpc = 0.7;
759 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
760
761 ASSERT_NE(nullptr, GetAudioManager);
762 g_para[0].manager = GetAudioManager();
763 ASSERT_NE(nullptr, g_para[0].manager);
764 ret = AudioCreateCapture(g_para[0].manager, g_para[0].pins, g_para[0].adapterName, &g_para[0].adapter,
765 &g_para[0].capture);
766 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
767 pthread_t tids[PTHREAD_SAMEADA_COUNT];
768 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
769 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
770 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
771 arrpara[i].character.setvolume = 0.7;
772 ret = arrpara[i].capture->volume.SetVolume(arrpara[i].capture, arrpara[i].character.setvolume);
773 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
774 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetVolume, &arrpara[i]);
775 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
776 }
777
778 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
779 void *result = nullptr;
780 pthread_join(tids[i], &result);
781 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
782 EXPECT_EQ(volumeHighExpc, arrpara[i].character.getvolume);
783 }
784 g_para[0].adapter->DestroyCapture(g_para[0].adapter, g_para[0].capture);
785 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
786 }
787
788 /**
789 * @tc.name test AudioCaptureSetSampleAttributes API via Multithread call.
790 * @tc.number SUB_Audio_HDI_AudioCaptureSetSampleAttributes_Reliability_0001
791 * @tc.desc test SetSampleAttributes interface Reliability pass through pthread_create fun and adapterName
792 is same.
793 * @tc.author: ZHANGHAILIN
794 */
795 HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSetSampleAttributes_Reliability_0001,
796 TestSize.Level1)
797 {
798 int32_t ret = -1;
799 uint32_t count = 2;
800 ASSERT_NE(nullptr, GetAudioManager);
801 g_para[0].manager = GetAudioManager();
802 ASSERT_NE(nullptr, g_para[0].manager);
803 ret = AudioCreateCapture(g_para[0].manager, g_para[0].pins, g_para[0].adapterName, &g_para[0].adapter,
804 &g_para[0].capture);
805 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
806 InitAttrs(g_para[0].attrs);
807 pthread_t tids[PTHREAD_SAMEADA_COUNT];
808 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
809
810 int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSetSampleAttributes, &g_para[0]);
811 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
812
813 ret = g_para[0].capture->attr.GetSampleAttributes(g_para[0].capture, &(g_para[0].attrsValue));
814 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
815 EXPECT_EQ(AUDIO_IN_MEDIA, g_para[0].attrsValue.type);
816 EXPECT_FALSE(g_para[0].attrsValue.interleaved);
817 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, g_para[0].attrsValue.format);
818 EXPECT_EQ(SAMPLERATEVALUE, g_para[0].attrsValue.sampleRate);
819 EXPECT_EQ(count, g_para[0].attrsValue.channelCount);
820 }
821
822 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
823 void *result = nullptr;
824 pthread_join(tids[i], &result);
825 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
826 }
827 g_para[0].adapter->DestroyCapture(g_para[0].adapter, g_para[0].capture);
828 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
829 }
830
831 /**
832 * @tc.name test AudioCaptureGetSampleAttributes API via Multithread call.
833 * @tc.number SUB_Audio_HDI_AudioCaptureGetSampleAttributes_Reliability_0001
834 * @tc.desc test AudioCaptureGetSampleAttributes interface Reliability pass through pthread_create fun and adapterName
835 is same.
836 * @tc.author: ZHANGHAILIN
837 */
838 HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureGetSampleAttributes_Reliability_0001,
839 TestSize.Level1)
840 {
841 int32_t ret = -1;
842 uint32_t count = 2;
843 ASSERT_NE(nullptr, GetAudioManager);
844 g_para[0].manager = GetAudioManager();
845 ASSERT_NE(nullptr, g_para[0].manager);
846
847 ret = AudioCreateCapture(g_para[0].manager, g_para[0].pins, g_para[0].adapterName, &g_para[0].adapter,
848 &g_para[0].capture);
849 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
850 InitAttrs(g_para[0].attrs);
851 pthread_t tids[PTHREAD_SAMEADA_COUNT];
852 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
853 ret = g_para[0].capture->attr.SetSampleAttributes(g_para[0].capture, &(g_para[0].attrs));
854 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
855
856 int32_t ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetSampleAttributes, &g_para[0]);
857 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
858
859 EXPECT_EQ(AUDIO_IN_MEDIA, g_para[0].attrsValue.type);
860 EXPECT_FALSE(g_para[0].attrsValue.interleaved);
861 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, g_para[0].attrsValue.format);
862 EXPECT_EQ(SAMPLERATEVALUE, g_para[0].attrsValue.sampleRate);
863 EXPECT_EQ(count, g_para[0].attrsValue.channelCount);
864 }
865
866 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
867 void *result = nullptr;
868 pthread_join(tids[i], &result);
869 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
870 }
871 g_para[0].adapter->DestroyCapture(g_para[0].adapter, g_para[0].capture);
872 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
873 }
874
875 /**
876 * @tc.name test AudioCaptureSelectScene API via Multithread call.
877 * @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_Reliability_0001
878 * @tc.desc test AudioCaptureSelectScene interface Reliability pass through pthread_create fun and adapterName is same.
879 * @tc.author: ZHANGHAILIN
880 */
881 HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureSelectScene_Reliability_0001, TestSize.Level1)
882 {
883 int32_t ret = -1;
884 ASSERT_NE(nullptr, GetAudioManager);
885 g_para[0].manager = GetAudioManager();
886 ASSERT_NE(nullptr, g_para[0].manager);
887 ret = AudioCreateCapture(g_para[0].manager, g_para[0].pins, g_para[0].adapterName, &g_para[0].adapter,
888 &g_para[0].capture);
889 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
890
891 pthread_t tids[PTHREAD_SAMEADA_COUNT];
892 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
893 g_para[0].scenes.scene.id = 0;
894 g_para[0].scenes.desc.pins = PIN_IN_MIC;
895 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureSelectScene, &g_para[0]);
896 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
897 }
898
899 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
900 void *result = nullptr;
901 pthread_join(tids[i], &result);
902 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
903 }
904 g_para[0].adapter->DestroyCapture(g_para[0].adapter, g_para[0].capture);
905 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
906 }
907
908 /**
909 * @tc.name test AudioCaptureCheckSceneCapability API via Multithread call.
910 * @tc.number SUB_Audio_HDI_AudioCaptureCheckSceneCapability_Reliability_0001
911 * @tc.desc test AudioCaptureCheckSceneCapability interface Reliability pass through pthread_create fun and adapterName
912 is same.
913 * @tc.author: ZHANGHAILIN
914 */
915 HWTEST_F(AudioHdiCaptureReliabilityTest, SUB_Audio_HDI_AudioCaptureCheckSceneCapability_Reliability_0001,
916 TestSize.Level1)
917 {
918 int32_t ret = -1;
919 ASSERT_NE(nullptr, GetAudioManager);
920 g_para[0].manager = GetAudioManager();
921 ASSERT_NE(nullptr, g_para[0].manager);
922 ret = AudioCreateCapture(g_para[0].manager, g_para[0].pins, g_para[0].adapterName, &g_para[0].adapter,
923 &g_para[0].capture);
924 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
925
926 pthread_t tids[PTHREAD_SAMEADA_COUNT];
927 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
928 g_para[0].scenes.scene.id = 0;
929 g_para[0].scenes.desc.pins = PIN_IN_MIC;
930 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureCheckSceneCapability, &g_para[0]);
931 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
932 }
933
934 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
935 void *result = nullptr;
936 pthread_join(tids[i], &result);
937 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
938 }
939 g_para[0].adapter->DestroyCapture(g_para[0].adapter, g_para[0].capture);
940 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
941 }
942 }
943