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_control_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 = 1;
28 const int BUFFER_SIZE = 16384;
29 mutex g_testMutex;
30 static 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 AudioHdiCaptureControlReliabilityTest : 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 RelAudioCaptureStart(struct PrepareAudioPara& ptr);
52 static int32_t RelGetAllAdapter(struct PrepareAudioPara& ptr);
53 static int32_t RelLoadAdapter(struct PrepareAudioPara& ptr);
54 static int32_t RelAudioCaptureStop(struct PrepareAudioPara& ptr);
55 static int32_t RelAudioCaptureResume(struct PrepareAudioPara& ptr);
56 static int32_t RelAudioCapturePause(struct PrepareAudioPara& ptr);
57 static int32_t RelAudioCaptureProcedure(struct PrepareAudioPara& ptr);
58 static int32_t RelAudioCaptureFrame(struct PrepareAudioPara& ptr);
59 static int32_t RelAudioCaptureStartAndCaputreFrame(struct PrepareAudioPara& ptr);
60 static int32_t RelAudioAdapterInitAllPorts(struct PrepareAudioPara& ptr);
61 static int32_t RelAudioAdapterGetPortCapability(struct PrepareAudioPara& ptr);
62 static int32_t RelAudioAdapterSetPassthroughMode(struct PrepareAudioPara& ptr);
63 static int32_t RelAudioAdapterGetPassthroughMode(struct PrepareAudioPara& ptr);
64 static int32_t RelAudioCaptureGetCapturePosition(struct PrepareAudioPara& ptr);
65 };
66
67 using THREAD_FUNC = void *(*)(void *);
68
69 TestAudioManager *(*AudioHdiCaptureControlReliabilityTest::GetAudioManager)() = nullptr;
70 void *AudioHdiCaptureControlReliabilityTest::handleSo = nullptr;
71 #ifdef AUDIO_MPI_SO
72 int32_t (*AudioHdiCaptureControlReliabilityTest::SdkInit)() = nullptr;
73 void (*AudioHdiCaptureControlReliabilityTest::SdkExit)() = nullptr;
74 void *AudioHdiCaptureControlReliabilityTest::sdkSo = nullptr;
75 #endif
76
SetUpTestCase(void)77 void AudioHdiCaptureControlReliabilityTest::SetUpTestCase(void)
78 {
79 #ifdef AUDIO_MPI_SO
80 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
81 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
82 if (sdkSo == nullptr) {
83 return;
84 }
85 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
86 if (SdkInit == nullptr) {
87 return;
88 }
89 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
90 if (SdkExit == nullptr) {
91 return;
92 }
93 SdkInit();
94 #endif
95 char absPath[PATH_MAX] = {0};
96 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
97 return;
98 }
99
100 handleSo = dlopen(absPath, RTLD_LAZY);
101 if (handleSo == nullptr) {
102 return;
103 }
104 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
105 if (GetAudioManager == nullptr) {
106 return;
107 }
108 }
109
TearDownTestCase(void)110 void AudioHdiCaptureControlReliabilityTest::TearDownTestCase(void)
111 {
112 #ifdef AUDIO_MPI_SO
113 SdkExit();
114 if (sdkSo != nullptr) {
115 dlclose(sdkSo);
116 sdkSo = nullptr;
117 }
118 if (SdkInit != nullptr) {
119 SdkInit = nullptr;
120 }
121 if (SdkExit != nullptr) {
122 SdkExit = nullptr;
123 }
124 #endif
125 if (handleSo != nullptr) {
126 dlclose(handleSo);
127 handleSo = nullptr;
128 }
129 if (GetAudioManager != nullptr) {
130 GetAudioManager = nullptr;
131 }
132 }
133
SetUp(void)134 void AudioHdiCaptureControlReliabilityTest::SetUp(void) {}
135
TearDown(void)136 void AudioHdiCaptureControlReliabilityTest::TearDown(void) {}
137
RelGetAllAdapter(struct PrepareAudioPara & ptr)138 int32_t AudioHdiCaptureControlReliabilityTest::RelGetAllAdapter(struct PrepareAudioPara& ptr)
139 {
140 int size = 0;
141 if (ptr.manager == nullptr) {
142 return AUDIO_HAL_ERR_INVALID_PARAM;
143 }
144 g_testMutex.lock();
145 int32_t ret = ptr.manager->GetAllAdapters(ptr.manager, &ptr.descs, &size);
146 g_testMutex.unlock();
147 if (ret < 0) {
148 return ret;
149 }
150 if (ptr.descs == nullptr || size == 0) {
151 return AUDIO_HAL_ERR_INTERNAL;
152 }
153 int index = SwitchAdapter(ptr.descs, ptr.adapterName, ptr.portType, ptr.audioPort, size);
154 if (index < 0) {
155 return AUDIO_HAL_ERR_INTERNAL;
156 }
157 ptr.desc = &ptr.descs[index];
158 if (ptr.desc == nullptr) {
159 return AUDIO_HAL_ERR_INVALID_PARAM;
160 }
161 return AUDIO_HAL_SUCCESS;
162 }
163
RelLoadAdapter(struct PrepareAudioPara & ptr)164 int32_t AudioHdiCaptureControlReliabilityTest::RelLoadAdapter(struct PrepareAudioPara& ptr)
165 {
166 if (ptr.desc == nullptr || ptr.manager == nullptr) {
167 return AUDIO_HAL_ERR_INVALID_PARAM;
168 }
169 g_testMutex.lock();
170 int32_t ret = ptr.manager->LoadAdapter(ptr.manager, ptr.desc, &ptr.adapter);
171 g_testMutex.unlock();
172 if (ret < 0) {
173 return ret;
174 }
175 if (ptr.adapter == nullptr) {
176 return AUDIO_HAL_ERR_INVALID_PARAM;
177 }
178 return ret;
179 }
180
RelAudioCreateCapture(struct PrepareAudioPara & ptr)181 int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCreateCapture(struct PrepareAudioPara& ptr)
182 {
183 int32_t ret = -1;
184 if (ptr.adapter == nullptr || ptr.manager == nullptr) {
185 return AUDIO_HAL_ERR_INVALID_PARAM;
186 }
187 InitAttrs(ptr.attrs);
188 InitDevDesc(ptr.devDesc, ptr.audioPort->portId, ptr.pins);
189 g_testMutex.lock();
190 ret = ptr.adapter->CreateCapture(ptr.adapter, &ptr.devDesc, &ptr.attrs, &ptr.capture);
191 g_testMutex.unlock();
192 if (ret < 0) {
193 ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter);
194 return ret;
195 }
196 if (ptr.capture == nullptr) {
197 ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter);
198 return AUDIO_HAL_ERR_INTERNAL;
199 }
200 return AUDIO_HAL_SUCCESS;
201 }
202
RelAudioCaptureStart(struct PrepareAudioPara & ptr)203 int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureStart(struct PrepareAudioPara& ptr)
204 {
205 if (ptr.capture == nullptr) {
206 return AUDIO_HAL_ERR_INVALID_PARAM;
207 }
208 int32_t ret = -1;
209 g_testMutex.lock();
210 ret = ptr.capture->control.Start((AudioHandle)(ptr.capture));
211 g_testMutex.unlock();
212 return ret;
213 }
214
RelAudioCaptureFrame(struct PrepareAudioPara & ptr)215 int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureFrame(struct PrepareAudioPara& ptr)
216 {
217 int32_t ret = -1;
218 uint64_t requestBytes = BUFFER_SIZE;
219 uint64_t replyBytes = 0;
220
221 char *frame = (char *)calloc(1, BUFFER_SIZE);
222 if (frame == nullptr) {
223 return HDF_ERR_MALLOC_FAIL;
224 }
225
226 g_testMutex.lock();
227 ret = ptr.capture->CaptureFrame(ptr.capture, frame, requestBytes, &replyBytes);
228 g_testMutex.unlock();
229 free(frame);
230 frame = nullptr;
231 return ret;
232 }
233
RelAudioCaptureStartAndCaputreFrame(struct PrepareAudioPara & ptr)234 int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureStartAndCaputreFrame(struct PrepareAudioPara& ptr)
235 {
236 int32_t ret = -1;
237 FILE *file = fopen(ptr.path, "wb+");
238 if (file == nullptr) {
239 return AUDIO_HAL_ERR_INTERNAL;
240 }
241 InitAttrs(ptr.attrs);
242
243 ret = FrameStartCapture(ptr.capture, file, ptr.attrs);
244 if (ret < 0) {
245 fclose(file);
246 return ret;
247 }
248 fclose(file);
249 return ret;
250 }
251
RelAudioCaptureStop(struct PrepareAudioPara & ptr)252 int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureStop(struct PrepareAudioPara& ptr)
253 {
254 if (ptr.capture == nullptr) {
255 return AUDIO_HAL_ERR_INVALID_PARAM;
256 }
257 int32_t ret = -1;
258 g_testMutex.lock();
259 ret = ptr.capture->control.Stop((AudioHandle)(ptr.capture));
260 g_testMutex.unlock();
261 return ret;
262 }
263
RelAudioCapturePause(struct PrepareAudioPara & ptr)264 int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCapturePause(struct PrepareAudioPara& ptr)
265 {
266 if (ptr.capture == nullptr) {
267 return AUDIO_HAL_ERR_INVALID_PARAM;
268 }
269 int32_t ret = -1;
270 g_testMutex.lock();
271 ret = ptr.capture->control.Pause((AudioHandle)(ptr.capture));
272 g_testMutex.unlock();
273 return ret;
274 }
275
RelAudioCaptureResume(struct PrepareAudioPara & ptr)276 int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureResume(struct PrepareAudioPara& ptr)
277 {
278 if (ptr.capture == nullptr) {
279 return AUDIO_HAL_ERR_INVALID_PARAM;
280 }
281 int32_t ret = -1;
282 g_testMutex.lock();
283 ret = ptr.capture->control.Resume((AudioHandle)(ptr.capture));
284 g_testMutex.unlock();
285 return ret;
286 }
287
RelAudioCaptureProcedure(struct PrepareAudioPara & ptr)288 int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureProcedure(struct PrepareAudioPara& ptr)
289 {
290 int32_t ret = -1;
291 ret = RelGetAllAdapter(ptr);
292 if (ret < 0) {
293 return ret;
294 }
295
296 ret = RelLoadAdapter(ptr);
297 if (ret < 0) {
298 return ret;
299 }
300
301 ret = RelAudioCreateCapture(ptr);
302 if (ret < 0) {
303 return ret;
304 }
305
306 ret = RelAudioCaptureStartAndCaputreFrame(ptr);
307 if (ret < 0) {
308 ptr.adapter->DestroyCapture(ptr.adapter, ptr.capture);
309 ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter);
310 return ret;
311 }
312 return AUDIO_HAL_SUCCESS;
313 }
314
RelAudioAdapterInitAllPorts(struct PrepareAudioPara & ptr)315 int32_t AudioHdiCaptureControlReliabilityTest::RelAudioAdapterInitAllPorts(struct PrepareAudioPara& ptr)
316 {
317 int32_t ret = -1;
318 if (ptr.adapter == nullptr) {
319 return AUDIO_HAL_ERR_INVALID_PARAM;
320 }
321 g_testMutex.lock();
322 ret = ptr.adapter->InitAllPorts(ptr.adapter);
323 g_testMutex.unlock();
324 return ret;
325 }
326
RelAudioAdapterGetPortCapability(struct PrepareAudioPara & ptr)327 int32_t AudioHdiCaptureControlReliabilityTest::RelAudioAdapterGetPortCapability(struct PrepareAudioPara& ptr)
328 {
329 int32_t ret = -1;
330 if (ptr.adapter == nullptr) {
331 return AUDIO_HAL_ERR_INVALID_PARAM;
332 }
333 g_testMutex.lock();
334 ret = ptr.adapter->GetPortCapability(ptr.adapter, ptr.audioPort, &(ptr.capability));
335 g_testMutex.unlock();
336 return ret;
337 }
338
RelAudioAdapterSetPassthroughMode(struct PrepareAudioPara & ptr)339 int32_t AudioHdiCaptureControlReliabilityTest::RelAudioAdapterSetPassthroughMode(struct PrepareAudioPara& ptr)
340 {
341 int32_t ret = -1;
342 if (ptr.adapter == nullptr) {
343 return AUDIO_HAL_ERR_INVALID_PARAM;
344 }
345 g_testMutex.lock();
346 ret = ptr.adapter->SetPassthroughMode(ptr.adapter, ptr.audioPort, ptr.mode);
347 g_testMutex.unlock();
348 return ret;
349 }
350
RelAudioAdapterGetPassthroughMode(struct PrepareAudioPara & ptr)351 int32_t AudioHdiCaptureControlReliabilityTest::RelAudioAdapterGetPassthroughMode(struct PrepareAudioPara& ptr)
352 {
353 int32_t ret = -1;
354 if (ptr.adapter == nullptr) {
355 return AUDIO_HAL_ERR_INVALID_PARAM;
356 }
357 g_testMutex.lock();
358 ret = ptr.adapter->GetPassthroughMode(ptr.adapter, ptr.audioPort, &(ptr.mode));
359 g_testMutex.unlock();
360 return ret;
361 }
362
RelAudioCaptureGetCapturePosition(struct PrepareAudioPara & ptr)363 int32_t AudioHdiCaptureControlReliabilityTest::RelAudioCaptureGetCapturePosition(struct PrepareAudioPara& ptr)
364 {
365 if (ptr.capture == nullptr) {
366 return AUDIO_HAL_ERR_INVALID_PARAM;
367 }
368 int32_t ret = -1;
369 g_testMutex.lock();
370 ret = ptr.capture->GetCapturePosition(ptr.capture, &(ptr.character.getframes), &(ptr.time));
371 g_testMutex.unlock();
372 return ret;
373 }
374
375 /**
376 * @tc.name test AudioCaptureFrame API via Multithread call.
377 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_Reliability_0001
378 * @tc.desc test AudioCaptureFrame interface Reliability pass through pthread_create fun and adapterName is same.
379 * @tc.author: zhouyongxiao
380 */
381 HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureFrame_Reliability_0001, TestSize.Level1)
382 {
383 int32_t ret = -1;
384 ASSERT_NE(nullptr, GetAudioManager);
385 g_para[0].manager = GetAudioManager();
386 ASSERT_NE(nullptr, g_para[0].manager);
387 ret = RelGetAllAdapter(g_para[0]);
388 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
389 ret = RelLoadAdapter(g_para[0]);
390 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
391 ret = RelAudioCreateCapture(g_para[0]);
392 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
393 ret = RelAudioCaptureStart(g_para[0]);
394 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
395 pthread_t tids[PTHREAD_SAMEADA_COUNT];
396 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
397 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureFrame, &g_para[0]);
398 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
399 }
400 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
401 void *result = nullptr;
402 pthread_join(tids[i], &result);
403 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
404 }
405 if (g_para[0].adapter != nullptr) {
406 ret = StopAudio(g_para[0]);
407 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
408 }
409 }
410
411 /**
412 * @tc.name test AudioCaptureStart API via Multithread call.
413 * @tc.number SUB_Audio_HDI_AudioCaptureStart_Reliability_0001
414 * @tc.desc test AudioCaptureStart interface Reliability pass through pthread_create fun and adapterName is same.
415 * @tc.author: zhouyongxiao
416 */
417 HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureStart_Reliability_0001, TestSize.Level1)
418 {
419 int32_t ret = -1;
420 int32_t failcount = 0;
421 int32_t succeedcount = 0;
422 ASSERT_NE(nullptr, GetAudioManager);
423 g_para[0].manager = GetAudioManager();
424 ASSERT_NE(nullptr, g_para[0].manager);
425 ret = RelGetAllAdapter(g_para[0]);
426 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
427 ret = RelLoadAdapter(g_para[0]);
428 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
429 ret = RelAudioCreateCapture(g_para[0]);
430 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
431 pthread_t tids[PTHREAD_SAMEADA_COUNT];
432 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
433 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureStart, &g_para[0]);
434 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
435 }
436 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
437 void *result = nullptr;
438 pthread_join(tids[i], &result);
439 ret = (intptr_t)result;
440 if (ret == 0) {
441 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
442 succeedcount = succeedcount + 1;
443 } else {
444 EXPECT_EQ(AUDIO_HAL_ERR_AI_BUSY, ret);
445 failcount = failcount + 1;
446 }
447 }
448 if (g_para[0].adapter != nullptr) {
449 ret = StopAudio(g_para[0]);
450 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
451 EXPECT_EQ(failcount, PTHREAD_SAMEADA_COUNT - 1);
452 EXPECT_EQ(succeedcount, 1);
453 }
454 }
455
456
457 /**
458 * @tc.name test AudioCaptureStop API via Multithread call.
459 * @tc.number SUB_Audio_HDI_AudioCaptureStop_Reliability_0001
460 * @tc.desc test AudioCaptureStop interface Reliability pass through pthread_create fun and adapterName is same.
461 * @tc.author: zhouyongxiao
462 */
463 HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureStop_Reliability_0001, TestSize.Level1)
464 {
465 int32_t ret = -1;
466 int32_t failcount = 0;
467 int32_t succeedcount = 0;
468 ASSERT_NE(nullptr, GetAudioManager);
469 g_para[0].manager = GetAudioManager();
470 ASSERT_NE(nullptr, g_para[0].manager);
471 ret = RelAudioCaptureProcedure(g_para[0]);
472 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
473 pthread_t tids[PTHREAD_SAMEADA_COUNT];
474 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
475 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureStop, &g_para[0]);
476 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
477 }
478 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
479 void *result = nullptr;
480 pthread_join(tids[i], &result);
481 if ((intptr_t)result == 0) {
482 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
483 succeedcount = succeedcount + 1;
484 } else {
485 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, (intptr_t)result);
486 failcount = failcount + 1;
487 }
488 }
489 if (g_para[0].manager != nullptr && g_para[0].adapter != nullptr) {
490 g_para[0].adapter->DestroyCapture(g_para[0].adapter, g_para[0].capture);
491 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
492 EXPECT_EQ(failcount, PTHREAD_SAMEADA_COUNT - 1);
493 EXPECT_EQ(succeedcount, 1);
494 }
495 }
496
497
498 /**
499 * @tc.name test AudioCapturePause API via Multithread call.
500 * @tc.number SUB_Audio_HDI_AudioCapturePause_Reliability_0001
501 * @tc.desc test AudioCapturePause interface Reliability pass through pthread_create fun and adapterName is same.
502 * @tc.author: zhouyongxiao
503 */
504 HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCapturePause_Reliability_0001, TestSize.Level1)
505 {
506 int32_t ret = -1;
507 int32_t failcount = 0;
508 int32_t succeedcount = 0;
509 ASSERT_NE(nullptr, GetAudioManager);
510 g_para[0].manager = GetAudioManager();
511 ASSERT_NE(nullptr, g_para[0].manager);
512 ret = RelAudioCaptureProcedure(g_para[0]);
513 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
514 pthread_t tids[PTHREAD_SAMEADA_COUNT];
515 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
516 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCapturePause, &g_para[0]);
517 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
518 }
519
520 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
521 void *result = nullptr;
522 pthread_join(tids[i], &result);
523 if ((intptr_t)result == 0) {
524 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
525 succeedcount = succeedcount + 1;
526 } else {
527 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, (intptr_t)result);
528 failcount = failcount + 1;
529 }
530 }
531 if (g_para[0].adapter != nullptr) {
532 ret = StopAudio(g_para[0]);
533 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
534 EXPECT_EQ(failcount, PTHREAD_SAMEADA_COUNT - 1);
535 EXPECT_EQ(succeedcount, 1);
536 }
537 }
538
539 /**
540 * @tc.name test RelAudioAdapterInitAllPorts API via Multi thread calling mono card
541 * @tc.number SUB_Audio_HDI_AudioInitAllPorts_Reliability_0002
542 * @tc.desc test InitAllPorts interface, return 0 if the ports is initialize successfully.
543 * @tc.author: liutian
544 */
545 HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioInitAllPorts_Reliability_0002, TestSize.Level1)
546 {
547 int32_t ret = -1;
548 pthread_t tids[PTHREAD_SAMEADA_COUNT];
549 ASSERT_NE(nullptr, GetAudioManager);
550 g_para[0].manager = GetAudioManager();
551 ASSERT_NE(nullptr, g_para[0].manager);
552 ret = RelGetAllAdapter(g_para[0]);
553 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
554 ret = RelLoadAdapter(g_para[0]);
555 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
556 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
557 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioAdapterInitAllPorts, &g_para[0]);
558 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
559 }
560 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
561 void *result = nullptr;
562 pthread_join(tids[i], &result);
563 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
564 }
565 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
566 }
567
568 /**
569 * @tc.name test RelAudioAdapterGetPortCapability API via Multi thread calling mono card
570 * @tc.number SUB_Audio_HDI_AudioGetPortCapability_Reliability_0002
571 * @tc.desc test GetPortCapability interface,return 0 if the Get Port capability successfully.
572 * @tc.author: liutian
573 */
574 HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioGetPortCapability_Reliability_0002, TestSize.Level1)
575 {
576 int32_t ret = -1;
577 ASSERT_NE(nullptr, GetAudioManager);
578 g_para[0].manager = GetAudioManager();
579 ASSERT_NE(nullptr, g_para[0].manager);
580 pthread_t tids[PTHREAD_SAMEADA_COUNT];
581 ret = RelGetAllAdapter(g_para[0]);
582 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
583 ret = RelLoadAdapter(g_para[0]);
584 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
585 ret = RelAudioAdapterInitAllPorts(g_para[0]);
586 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
587 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
588 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioAdapterGetPortCapability, &g_para[0]);
589 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
590 }
591 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
592 void *result = nullptr;
593 pthread_join(tids[i], &result);
594 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
595 }
596 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
597 }
598
599 /**
600 * @tc.name test RelAudioAdapterSetPassthroughMode API via Multi thread calling mono card
601 * @tc.number SUB_Audio_HDI_AudioSetPassthroughMode_Reliability_0002
602 * @tc.desc test SetPassthroughMode interface,return 0 if the Set Passthrough Mode successfully.
603 * @tc.author: liutian
604 */
605 HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioSetPassthroughMode_Reliability_0002, TestSize.Level1)
606 {
607 int32_t ret = -1;
608 g_para[0].mode = PORT_PASSTHROUGH_LPCM;
609 g_para[0].portType = PORT_OUT;
610 pthread_t tids[PTHREAD_SAMEADA_COUNT];
611 ASSERT_NE(nullptr, GetAudioManager);
612 g_para[0].manager = GetAudioManager();
613 ASSERT_NE(nullptr, g_para[0].manager);
614 ret = RelGetAllAdapter(g_para[0]);
615 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
616 ret = RelLoadAdapter(g_para[0]);
617 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
618 ret = RelAudioAdapterInitAllPorts(g_para[0]);
619 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
620 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
621 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioAdapterSetPassthroughMode, &g_para[0]);
622 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
623 }
624 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
625 void *result = nullptr;
626 pthread_join(tids[i], &result);
627 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
628 ret = g_para[0].adapter->GetPassthroughMode(g_para[0].adapter, g_para[0].audioPort, &(g_para[0].mode));
629 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
630 EXPECT_EQ(PORT_PASSTHROUGH_LPCM, g_para[0].mode);
631 }
632 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
633 }
634
635 /**
636 * @tc.name test RelAudioAdapterGetPassthroughMode API via Multi thread calling mono card
637 * @tc.number SUB_Audio_HDI_AudioGetPassthroughMode_Reliability_0002
638 * @tc.desc test GetPassthroughMode interface,return 0 if the Get Passthrough Mode successfully.
639 * @tc.author: liutian
640 */
641 HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioGetPassthroughMode_Reliability_0002, TestSize.Level1)
642 {
643 int32_t ret = -1;
644 g_para[0].portType = PORT_OUT;
645 g_para[0].mode = PORT_PASSTHROUGH_LPCM;
646 pthread_t tids[PTHREAD_SAMEADA_COUNT];
647 ASSERT_NE(nullptr, GetAudioManager);
648 g_para[0].manager = GetAudioManager();
649 ASSERT_NE(nullptr, g_para[0].manager);
650 ret = RelGetAllAdapter(g_para[0]);
651 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
652 ret = RelLoadAdapter(g_para[0]);
653 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
654 ret = RelAudioAdapterInitAllPorts(g_para[0]);
655 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
656 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
657 ret = RelAudioAdapterSetPassthroughMode(g_para[0]);
658 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
659 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioAdapterGetPassthroughMode, &g_para[0]);
660 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
661 }
662 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
663 void *result = nullptr;
664 pthread_join(tids[i], &result);
665 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
666 EXPECT_EQ(PORT_PASSTHROUGH_LPCM, g_para[0].mode);
667 }
668 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
669 }
670
671 /**
672 * @tc.name test AudioCaptureResume API via Multithread call.
673 * @tc.number SUB_Audio_HDI_AudioCaptureResume_Reliability_0001
674 * @tc.desc test RelAudioCaptureResume interface Reliability pass through pthread_create fun and adapterName is same.
675 * @tc.author: zhouyongxiao
676 */
677 HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioCaptureResume_Reliability_0001, TestSize.Level1)
678 {
679 int32_t ret = -1;
680 int32_t failcount = 0;
681 int32_t succeedcount = 0;
682 ASSERT_NE(nullptr, GetAudioManager);
683 g_para[0].manager = GetAudioManager();
684 ASSERT_NE(nullptr, g_para[0].manager);
685 ret = RelAudioCaptureProcedure(g_para[0]);
686 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
687 ret = RelAudioCapturePause(g_para[0]);
688 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
689 pthread_t tids[PTHREAD_SAMEADA_COUNT];
690 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
691 ret = memcpy_s(&g_para[0], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
692 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
693 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureResume, &g_para[0]);
694 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
695 }
696
697 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
698 void *result = nullptr;
699 pthread_join(tids[i], &result);
700 if ((intptr_t)result == 0) {
701 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
702 succeedcount = succeedcount + 1;
703 } else {
704 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, (intptr_t)result);
705 failcount = failcount + 1;
706 }
707 }
708 if (g_para[0].adapter != nullptr) {
709 ret = StopAudio(g_para[0]);
710 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
711 EXPECT_EQ(failcount, PTHREAD_SAMEADA_COUNT - 1);
712 EXPECT_EQ(succeedcount, 1);
713 }
714 }
715
716 /**
717 * @tc.name test AudioGetCapturePosition API via Multithread call.
718 * @tc.number SUB_Audio_HDI_AudioGetCapturePosition_Reliability_0001
719 * @tc.desc test AudioGetCapturePosition interface Reliability pass through pthread_create fun and adapterName is same.
720 * @tc.author: zhouyongxiao
721 */
722 HWTEST_F(AudioHdiCaptureControlReliabilityTest, SUB_Audio_HDI_AudioGetCapturePosition_Reliability_0001, TestSize.Level1)
723 {
724 int32_t ret = -1;
725 int64_t timeExp = 0;
726 ASSERT_NE(nullptr, GetAudioManager);
727 g_para[0].manager = GetAudioManager();
728 ASSERT_NE(nullptr, g_para[0].manager);
729 ret = RelAudioCaptureProcedure(g_para[0]);
730 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
731 pthread_t tids[PTHREAD_SAMEADA_COUNT];
732 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
733 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioCaptureGetCapturePosition, &g_para[0]);
734 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
735 }
736
737 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
738 void *result = nullptr;
739 pthread_join(tids[i], &result);
740 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
741 EXPECT_LT(INITIAL_VALUE, g_para[0].character.getframes);
742 EXPECT_LT(timeExp, g_para[0].time.tvNSec);
743 }
744 if (g_para[0].adapter != nullptr) {
745 ret = StopAudio(g_para[0]);
746 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
747 }
748 }
749 }
750