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