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_hdirender_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 = 10;
27 const int PTHREAD_DIFFADA_COUNT = 1;
28 mutex g_testMutex;
29 static struct PrepareAudioPara g_para[PTHREAD_DIFFADA_COUNT] = {
30 {
31 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_OUT_SPEAKER,
32 .path = AUDIO_FILE.c_str()
33 }
34 };
35
36 class AudioHdiRenderControlReliabilityTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42 static TestAudioManager *(*GetAudioManager)();
43 static void *handleSo;
44 #ifdef AUDIO_MPI_SO
45 static int32_t (*SdkInit)();
46 static void (*SdkExit)();
47 static void *sdkSo;
48 #endif
49 static int32_t RelGetAllAdapter(struct PrepareAudioPara& ptr);
50 static int32_t RelLoadAdapter(struct PrepareAudioPara& ptr);
51 static int32_t RelUnloadAdapter(struct PrepareAudioPara& ptr);
52 static int32_t RelAudioRenderStart(struct PrepareAudioPara& ptr);
53 static int32_t RelAudioRenderFrame(struct PrepareAudioPara& ptr);
54 static int32_t RelAudioRenderStop(struct PrepareAudioPara& ptr);
55 static int32_t RelAudioRenderProcedure(struct PrepareAudioPara& ptr);
56 static int32_t RelAudioRenderPause(struct PrepareAudioPara& ptr);
57 static int32_t RelAudioRenderResume(struct PrepareAudioPara& ptr);
58 static int32_t RelAudioRenderGetRenderPosition(struct PrepareAudioPara& ptr);
59 };
60
61 using THREAD_FUNC = void *(*)(void *);
62
63 TestAudioManager *(*AudioHdiRenderControlReliabilityTest::GetAudioManager)() = nullptr;
64 void *AudioHdiRenderControlReliabilityTest::handleSo = nullptr;
65 #ifdef AUDIO_MPI_SO
66 int32_t (*AudioHdiRenderControlReliabilityTest::SdkInit)() = nullptr;
67 void (*AudioHdiRenderControlReliabilityTest::SdkExit)() = nullptr;
68 void *AudioHdiRenderControlReliabilityTest::sdkSo = nullptr;
69 #endif
70
SetUpTestCase(void)71 void AudioHdiRenderControlReliabilityTest::SetUpTestCase(void)
72 {
73 #ifdef AUDIO_MPI_SO
74 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
75 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
76 if (sdkSo == nullptr) {
77 return;
78 }
79 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
80 if (SdkInit == nullptr) {
81 return;
82 }
83 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
84 if (SdkExit == nullptr) {
85 return;
86 }
87 SdkInit();
88 #endif
89 char absPath[PATH_MAX] = {0};
90 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
91 return;
92 }
93 handleSo = dlopen(absPath, RTLD_LAZY);
94 if (handleSo == nullptr) {
95 return;
96 }
97 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
98 if (GetAudioManager == nullptr) {
99 return;
100 }
101 }
102
TearDownTestCase(void)103 void AudioHdiRenderControlReliabilityTest::TearDownTestCase(void)
104 {
105 #ifdef AUDIO_MPI_SO
106 SdkExit();
107 if (sdkSo != nullptr) {
108 dlclose(sdkSo);
109 sdkSo = nullptr;
110 }
111 if (SdkInit != nullptr) {
112 SdkInit = nullptr;
113 }
114 if (SdkExit != nullptr) {
115 SdkExit = nullptr;
116 }
117 #endif
118 if (handleSo != nullptr) {
119 dlclose(handleSo);
120 handleSo = nullptr;
121 }
122 if (GetAudioManager != nullptr) {
123 GetAudioManager = nullptr;
124 }
125 }
126
SetUp(void)127 void AudioHdiRenderControlReliabilityTest::SetUp(void) {}
128
TearDown(void)129 void AudioHdiRenderControlReliabilityTest::TearDown(void) {}
130
RelGetAllAdapter(struct PrepareAudioPara & ptr)131 int32_t AudioHdiRenderControlReliabilityTest::RelGetAllAdapter(struct PrepareAudioPara& ptr)
132 {
133 if (ptr.manager == nullptr) {
134 return AUDIO_HAL_ERR_INVALID_PARAM;
135 }
136 int size = 0;
137 g_testMutex.lock();
138 int32_t ret = ptr.manager->GetAllAdapters(ptr.manager, &ptr.descs, &size);
139 g_testMutex.unlock();
140 if (ret < 0) {
141 return ret;
142 }
143 if (ptr.descs == nullptr || size == 0) {
144 return AUDIO_HAL_ERR_INTERNAL;
145 }
146 int index = SwitchAdapter(ptr.descs, ptr.adapterName, ptr.portType, ptr.audioPort, size);
147 if (index < 0) {
148 return index;
149 }
150 ptr.desc = &ptr.descs[index];
151 if (ptr.desc == nullptr) {
152 return AUDIO_HAL_ERR_INVALID_PARAM;
153 }
154 return AUDIO_HAL_SUCCESS;
155 }
156
RelLoadAdapter(struct PrepareAudioPara & ptr)157 int32_t AudioHdiRenderControlReliabilityTest::RelLoadAdapter(struct PrepareAudioPara& ptr)
158 {
159 if (ptr.manager == nullptr) {
160 return AUDIO_HAL_ERR_INVALID_PARAM;
161 }
162 g_testMutex.lock();
163 int32_t ret = ptr.manager->LoadAdapter(ptr.manager, ptr.desc, &ptr.adapter);
164 g_testMutex.unlock();
165 if (ret < 0) {
166 return ret;
167 }
168
169 if (ptr.adapter == nullptr) {
170 return AUDIO_HAL_ERR_INTERNAL;
171 }
172 return ret;
173 }
174
RelAudioRenderStart(struct PrepareAudioPara & ptr)175 int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderStart(struct PrepareAudioPara& ptr)
176 {
177 if (ptr.render == nullptr) {
178 return AUDIO_HAL_ERR_INVALID_PARAM;
179 }
180 int32_t ret = -1;
181 g_testMutex.lock();
182 ret = ptr.render->control.Start((AudioHandle)(ptr.render));
183 g_testMutex.unlock();
184 return ret;
185 }
186
RelAudioRenderFrame(struct PrepareAudioPara & ptr)187 int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderFrame(struct PrepareAudioPara& ptr)
188 {
189 if (ptr.render == nullptr) {
190 return AUDIO_HAL_ERR_INVALID_PARAM;
191 }
192 int32_t ret = -1;
193 uint64_t requestBytes = 0;
194 uint64_t replyBytes = 0;
195 char *frame = nullptr;
196
197 ret = RenderFramePrepare(ptr.path, frame, requestBytes);
198 if (ret < 0) {
199 return ret;
200 }
201 g_testMutex.lock();
202 ret = ptr.render->RenderFrame(ptr.render, frame, requestBytes, &replyBytes);
203 g_testMutex.unlock();
204 if (frame != nullptr) {
205 free(frame);
206 frame = nullptr;
207 }
208 return ret;
209 }
210
RelAudioRenderStop(struct PrepareAudioPara & ptr)211 int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderStop(struct PrepareAudioPara& ptr)
212 {
213 if (ptr.render == nullptr) {
214 return AUDIO_HAL_ERR_INVALID_PARAM;
215 }
216 int32_t ret = -1;
217 g_testMutex.lock();
218 ret = ptr.render->control.Stop((AudioHandle)(ptr.render));
219 g_testMutex.unlock();
220 return ret;
221 }
222
RelAudioRenderPause(struct PrepareAudioPara & ptr)223 int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderPause(struct PrepareAudioPara& ptr)
224 {
225 if (ptr.render == nullptr) {
226 return AUDIO_HAL_ERR_INVALID_PARAM;
227 }
228 int32_t ret = -1;
229 g_testMutex.lock();
230 ret = ptr.render->control.Pause((AudioHandle)(ptr.render));
231 g_testMutex.unlock();
232 return ret;
233 }
234
RelAudioRenderResume(struct PrepareAudioPara & ptr)235 int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderResume(struct PrepareAudioPara& ptr)
236 {
237 if (ptr.render == nullptr) {
238 return AUDIO_HAL_ERR_INVALID_PARAM;
239 }
240 int32_t ret = -1;
241 g_testMutex.lock();
242 ret = ptr.render->control.Resume((AudioHandle)(ptr.render));
243 g_testMutex.unlock();
244 return ret;
245 }
246
RelAudioRenderProcedure(struct PrepareAudioPara & ptr)247 int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderProcedure(struct PrepareAudioPara& ptr)
248 {
249 int32_t ret = -1;
250 g_testMutex.lock();
251 ret = AudioCreateRender(ptr.manager, ptr.pins, ptr.adapterName, &ptr.adapter, &ptr.render);
252 g_testMutex.unlock();
253 if (ret < 0) {
254 return ret;
255 }
256 ret = AudioRenderStartAndOneFrame(ptr.render);
257 return ret;
258 }
259
RelAudioRenderGetRenderPosition(struct PrepareAudioPara & ptr)260 int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderGetRenderPosition(struct PrepareAudioPara& ptr)
261 {
262 if (ptr.render == nullptr) {
263 return AUDIO_HAL_ERR_INVALID_PARAM;
264 }
265 int32_t ret = -1;
266 g_testMutex.lock();
267 ret = ptr.render->GetRenderPosition(ptr.render, &(ptr.character.getframes), &(ptr.time));
268 g_testMutex.unlock();
269 return ret;
270 }
271
272 /**
273 * @tc.name test GetAllAdapter API via Multithread call.
274 * @tc.number SUB_Audio_HDI_AudioGetAllAdapter_Reliability_0001
275 * @tc.desc test Reliability GetAllAdapters interface.
276 * @tc.author: zhouyongxiao
277 */
278 HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioGetAllAdapter_Reliability_0001, TestSize.Level1)
279 {
280 int32_t ret = -1;
281 ASSERT_NE(nullptr, GetAudioManager);
282 g_para[0].manager = GetAudioManager();
283 ASSERT_NE(nullptr, g_para[0].manager);
284 pthread_t tids[PTHREAD_SAMEADA_COUNT];
285 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
286 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelGetAllAdapter, &g_para[0]);
287 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
288 }
289 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
290 void *result = nullptr;
291 pthread_join(tids[i], &result);
292 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
293 }
294 }
295
296 /**
297 * @tc.name test LoadAdapter API via Multithread call.
298 * @tc.number SUB_Audio_HDI_AudioLoadlAdapter_Reliability_0001
299 * @tc.desc test LoadAdapter interface Reliability pass through pthread_create fun and adapterName is same.
300 * @tc.author: zhouyongxiao
301 */
302 HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioLoadlAdapter_Reliability_0001, TestSize.Level1)
303 {
304 int32_t ret = -1;
305 int32_t failcount = 0;
306 int32_t succeedcount = 0;
307 ASSERT_NE(nullptr, GetAudioManager);
308 g_para[0].manager = GetAudioManager();
309 ASSERT_NE(nullptr, g_para[0].manager);
310 pthread_t tids[PTHREAD_SAMEADA_COUNT];
311 ret = RelGetAllAdapter(g_para[0]);
312 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
313 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
314 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelLoadAdapter, &g_para[0]);
315 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
316 }
317 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
318 void *result = nullptr;
319 pthread_join(tids[i], &result);
320 ret = (intptr_t)result;
321 if (ret == 0) {
322 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
323 succeedcount = succeedcount + 1;
324 } else {
325 EXPECT_EQ(AUDIO_HAL_ERR_NOTREADY, ret);
326 failcount = failcount + 1;
327 }
328 }
329 EXPECT_EQ(failcount, PTHREAD_SAMEADA_COUNT - 1);
330 EXPECT_EQ(succeedcount, 1);
331 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
332 g_para[0].adapter = nullptr;
333 }
334
335 /**
336 * @tc.name test AudioRenderStart API via Multithread call.
337 * @tc.number SUB_Audio_HDI_AudioRenderStart_Reliability_0001
338 * @tc.desc test AudioRenderStart interface Reliability pass through pthread_create fun and adapterName is same.
339 * @tc.author: zhouyongxiao
340 */
341 HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderStart_Reliability_0001, TestSize.Level1)
342 {
343 int32_t ret = -1;
344 int32_t failcount = 0;
345 int32_t succeedcount = 0;
346 ASSERT_NE(nullptr, GetAudioManager);
347 g_para[0].manager = GetAudioManager();
348 ASSERT_NE(nullptr, g_para[0].manager);
349 ret = AudioCreateRender(g_para[0].manager, g_para[0].pins, g_para[0].adapterName, &g_para[0].adapter,
350 &g_para[0].render);
351 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
352
353 pthread_t tids[PTHREAD_SAMEADA_COUNT];
354 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
355 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderStart, &g_para[0]);
356 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
357 }
358 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
359 void *result = nullptr;
360 pthread_join(tids[i], &result);
361 ret = (intptr_t)result;
362 if (ret == 0) {
363 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
364 succeedcount = succeedcount + 1;
365 } else {
366 EXPECT_EQ(AUDIO_HAL_ERR_AO_BUSY, ret);
367 failcount = failcount + 1;
368 }
369 }
370 if (g_para[0].adapter != nullptr) {
371 ret = StopAudio(g_para[0]);
372 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
373 EXPECT_EQ(failcount, PTHREAD_SAMEADA_COUNT - 1);
374 EXPECT_EQ(succeedcount, 1);
375 g_para[0].render = nullptr;
376 }
377 }
378
379 /**
380 * @tc.name test AudioRenderFrame API via Multithread call.
381 * @tc.number SUB_Audio_HDI_RelAudioRenderFrame_Reliability_0001
382 * @tc.desc test AudioRenderFrame iinterface Reliability pass through pthread_create fun and adapterName is same.
383 * @tc.author: zhouyongxiao
384 */
385 HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderFrame_Reliability_0001, TestSize.Level1)
386 {
387 ASSERT_NE(nullptr, GetAudioManager);
388 g_para[0].manager = GetAudioManager();
389 ASSERT_NE(nullptr, g_para[0].manager);
390 int32_t ret = -1;
391 ret = AudioCreateRender(g_para[0].manager, g_para[0].pins, g_para[0].adapterName, &g_para[0].adapter,
392 &g_para[0].render);
393 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
394 ret = RelAudioRenderStart(g_para[0]);
395 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
396 pthread_t tids[PTHREAD_SAMEADA_COUNT];
397 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
398 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderFrame, &g_para[0]);
399 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
400 }
401 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
402 void *result = nullptr;
403 pthread_join(tids[i], &result);
404 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
405 }
406 ret = StopAudio(g_para[0]);
407 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
408 g_para[0].render = nullptr;
409 }
410
411 /**
412 * @tc.name test AudioRenderStop API via Multithread call.
413 * @tc.number SUB_Audio_HDI_AudioRenderStop_Reliability_0001
414 * @tc.desc test AudioRenderStop interface Reliability pass through pthread_create fun and adapterName is same.
415 * @tc.author: zhouyongxiao
416 */
417 HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderStop_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 = RelAudioRenderProcedure(g_para[0]);
426 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
427 pthread_t tids[PTHREAD_SAMEADA_COUNT];
428 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
429 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderStop, &g_para[0]);
430 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
431 }
432 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
433 void *result = nullptr;
434 pthread_join(tids[i], &result);
435 ret = (intptr_t)result;
436 if (ret == 0) {
437 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
438 succeedcount = succeedcount + 1;
439 } else {
440 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
441 failcount = failcount + 1;
442 }
443 }
444 if (g_para[0].manager != nullptr && g_para[0].adapter != nullptr) {
445 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
446 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
447 EXPECT_EQ(failcount, PTHREAD_SAMEADA_COUNT - 1);
448 EXPECT_EQ(succeedcount, 1);
449 g_para[0].render = nullptr;
450 }
451 }
452
453 /**
454 * @tc.name test AudioRenderPause API via Multithread call.
455 * @tc.number SUB_Audio_HDI_AudioRenderPause_Reliability_0001
456 * @tc.desc test AudioRenderPause interface Reliability pass through pthread_create fun and adapterName is same.
457 * @tc.author: zhouyongxiao
458 */
459 HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderPause_Reliability_0001, TestSize.Level1)
460 {
461 int32_t ret = -1;
462 int32_t failcount = 0;
463 ASSERT_NE(nullptr, GetAudioManager);
464 g_para[0].manager = GetAudioManager();
465 ASSERT_NE(nullptr, g_para[0].manager);
466 int32_t succeedcount = 0;
467
468 ret = RelAudioRenderProcedure(g_para[0]);
469 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
470
471 pthread_t tids[PTHREAD_SAMEADA_COUNT];
472 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
473 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderPause, &g_para[0]);
474 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
475 }
476
477 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
478 void *result = nullptr;
479 pthread_join(tids[i], &result);
480 ret = (intptr_t)result;
481 if (ret == 0) {
482 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
483 succeedcount = succeedcount + 1;
484 } else {
485 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
486 failcount = failcount + 1;
487 }
488 }
489 if (g_para[0].adapter != nullptr) {
490 ret = StopAudio(g_para[0]);
491 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
492 EXPECT_EQ(failcount, PTHREAD_SAMEADA_COUNT - 1);
493 EXPECT_EQ(succeedcount, 1);
494 g_para[0].render = nullptr;
495 }
496 }
497
498 /**
499 * @tc.name test AudioRenderResume API via Multithread call.
500 * @tc.number SUB_Audio_HDI_AudioRenderResume_Reliability_0001
501 * @tc.desc test RelAudioRenderResume interface Reliability pass through pthread_create fun and adapterName is same.
502 * @tc.author: zhouyongxiao
503 */
504 HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderResume_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 = RelAudioRenderProcedure(g_para[0]);
513 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
514 ret = RelAudioRenderPause(g_para[0]);
515 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
516
517 pthread_t tids[PTHREAD_SAMEADA_COUNT];
518 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
519 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderResume, &g_para[0]);
520 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
521 }
522
523 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
524 void *result = nullptr;
525 pthread_join(tids[i], &result);
526 ret = (intptr_t)result;
527 if (ret == 0) {
528 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
529 succeedcount = succeedcount + 1;
530 } else {
531 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
532 failcount = failcount + 1;
533 }
534 }
535 if (g_para[0].adapter != nullptr) {
536 ret = StopAudio(g_para[0]);
537 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
538 g_para[0].render = nullptr;
539 }
540 }
541
542 /**
543 * @tc.name test AudioRenderGetRenderPosition API via Multithread call.
544 * @tc.number SUB_Audio_HDI_AudiorenderGetVolume_Reliability_0001
545 * @tc.desc test GetRenderPosition interface Reliability pass through pthread_create fun and adapterName is same.
546 * @tc.author: zhouyongxiao
547 */
548 HWTEST_F(AudioHdiRenderControlReliabilityTest, SUB_Audio_HDI_AudioRenderGetRenderPosition_Reliability_0001,
549 TestSize.Level1)
550 {
551 int32_t ret = -1;
552 int64_t timeExp = 0;
553 ASSERT_NE(nullptr, GetAudioManager);
554 g_para[0].manager = GetAudioManager();
555 ASSERT_NE(nullptr, g_para[0].manager);
556 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
557 ret = RelAudioRenderProcedure(g_para[0]);
558 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
559
560 pthread_t tids[PTHREAD_SAMEADA_COUNT];
561 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
562 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
563 arrpara[i].time = {.tvSec = 0, .tvNSec = 0};
564 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetRenderPosition, &arrpara[i]);
565 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
566 }
567
568 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
569 void *result = nullptr;
570 pthread_join(tids[i], &result);
571 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
572 EXPECT_LT(INITIAL_VALUE, arrpara[i].character.getframes);
573 EXPECT_LT(timeExp, (arrpara[i].time.tvSec) * SECTONSEC + (arrpara[i].time.tvNSec));
574 }
575 if (g_para[0].adapter != nullptr) {
576 ret = StopAudio(g_para[0]);
577 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
578 g_para[0].render = nullptr;
579 }
580 }
581 }