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_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 AudioHdiRenderReliabilityTest : 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 RelAudioCreateRender(struct PrepareAudioPara& ptr);
50 static int32_t RelAudioRenderProcedure(struct PrepareAudioPara& ptr);
51 static int32_t RelAudioRenderSetGain(struct PrepareAudioPara& ptr);
52 static int32_t RelAudioRenderGetGain(struct PrepareAudioPara& ptr);
53 static int32_t RelAudioRenderGetGainThreshold(struct PrepareAudioPara& ptr);
54 static int32_t RelAudioRenderSetMute(struct PrepareAudioPara& ptr);
55 static int32_t RelAudioRenderGetMute(struct PrepareAudioPara& ptr);
56 static int32_t RelAudioRenderSetVolume(struct PrepareAudioPara& ptr);
57 static int32_t RelAudioRenderGetVolume(struct PrepareAudioPara& ptr);
58 static int32_t RelAudioRenderGetFrameSize(struct PrepareAudioPara& ptr);
59 static int32_t RelAudioRenderGetFrameCount(struct PrepareAudioPara& ptr);
60 static int32_t RelAudioRenderGetCurrentChannelId(struct PrepareAudioPara& ptr);
61 static int32_t RelAudioRenderSetChannelMode(struct PrepareAudioPara& ptr);
62 static int32_t RelAudioRenderGetChannelMode(struct PrepareAudioPara& ptr);
63 static int32_t RelAudioRenderSetSampleAttributes(struct PrepareAudioPara& ptr);
64 static int32_t RelAudioRenderGetSampleAttributes(struct PrepareAudioPara& ptr);
65 static int32_t RelAudioRenderSelectScene(struct PrepareAudioPara& ptr);
66 static int32_t RelAudioRenderCheckSceneCapability(struct PrepareAudioPara& ptr);
67 static int32_t RelAudioRenderGetLatency(struct PrepareAudioPara& ptr);
68 };
69
70 using THREAD_FUNC = void *(*)(void *);
71
72 TestAudioManager *(*AudioHdiRenderReliabilityTest::GetAudioManager)() = nullptr;
73 void *AudioHdiRenderReliabilityTest::handleSo = nullptr;
74 #ifdef AUDIO_MPI_SO
75 int32_t (*AudioHdiRenderReliabilityTest::SdkInit)() = nullptr;
76 void (*AudioHdiRenderReliabilityTest::SdkExit)() = nullptr;
77 void *AudioHdiRenderReliabilityTest::sdkSo = nullptr;
78 #endif
79
SetUpTestCase(void)80 void AudioHdiRenderReliabilityTest::SetUpTestCase(void)
81 {
82 #ifdef AUDIO_MPI_SO
83 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
84 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
85 if (sdkSo == nullptr) {
86 return;
87 }
88 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
89 if (SdkInit == nullptr) {
90 return;
91 }
92 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
93 if (SdkExit == nullptr) {
94 return;
95 }
96 SdkInit();
97 #endif
98 char absPath[PATH_MAX] = {0};
99 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
100 return;
101 }
102 handleSo = dlopen(absPath, RTLD_LAZY);
103 if (handleSo == nullptr) {
104 return;
105 }
106 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
107 if (GetAudioManager == nullptr) {
108 return;
109 }
110 }
111
TearDownTestCase(void)112 void AudioHdiRenderReliabilityTest::TearDownTestCase(void)
113 {
114 #ifdef AUDIO_MPI_SO
115 SdkExit();
116 if (sdkSo != nullptr) {
117 dlclose(sdkSo);
118 sdkSo = nullptr;
119 }
120 if (SdkInit != nullptr) {
121 SdkInit = nullptr;
122 }
123 if (SdkExit != nullptr) {
124 SdkExit = nullptr;
125 }
126 #endif
127 if (handleSo != nullptr) {
128 dlclose(handleSo);
129 handleSo = nullptr;
130 }
131 if (GetAudioManager != nullptr) {
132 GetAudioManager = nullptr;
133 }
134 }
135
SetUp(void)136 void AudioHdiRenderReliabilityTest::SetUp(void) {}
137
TearDown(void)138 void AudioHdiRenderReliabilityTest::TearDown(void) {}
139
RelAudioCreateRender(struct PrepareAudioPara & ptr)140 int32_t AudioHdiRenderReliabilityTest::RelAudioCreateRender(struct PrepareAudioPara& ptr)
141 {
142 if (ptr.manager == nullptr || ptr.adapter == nullptr) {
143 return AUDIO_HAL_ERR_INVALID_PARAM;
144 }
145 struct AudioSampleAttributes attrs = {};
146 struct AudioDeviceDescriptor devDesc = {};
147 InitAttrs(attrs);
148 InitDevDesc(devDesc, ptr.audioPort->portId, ptr.pins);
149 g_testMutex.lock();
150 int32_t ret = ptr.adapter->CreateRender(ptr.adapter, &devDesc, &attrs, &ptr.render);
151 g_testMutex.unlock();
152 if (ret < 0) {
153 ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter);
154 return ret;
155 }
156 if (ptr.render == nullptr) {
157 ptr.manager->UnloadAdapter(ptr.manager, ptr.adapter);
158 return AUDIO_HAL_ERR_INTERNAL;
159 }
160 return AUDIO_HAL_SUCCESS;
161 }
162
RelAudioRenderGetGainThreshold(struct PrepareAudioPara & ptr)163 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetGainThreshold(struct PrepareAudioPara& ptr)
164 {
165 if (ptr.render == nullptr) {
166 return AUDIO_HAL_ERR_INVALID_PARAM;
167 }
168 int32_t ret = -1;
169 g_testMutex.lock();
170 ret = ptr.render->volume.GetGainThreshold(ptr.render, &(ptr.character.gainthresholdmin),
171 &(ptr.character.gainthresholdmax));
172 g_testMutex.unlock();
173 return ret;
174 }
175
RelAudioRenderSetGain(struct PrepareAudioPara & ptr)176 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetGain(struct PrepareAudioPara& ptr)
177 {
178 if (ptr.render == nullptr) {
179 return AUDIO_HAL_ERR_INVALID_PARAM;
180 }
181 int32_t ret = -1;
182 g_testMutex.lock();
183 ret = ptr.render->volume.SetGain(ptr.render, ptr.character.setgain);
184 g_testMutex.unlock();
185 return ret;
186 }
187
RelAudioRenderGetGain(struct PrepareAudioPara & ptr)188 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetGain(struct PrepareAudioPara& ptr)
189 {
190 if (ptr.render == nullptr) {
191 return AUDIO_HAL_ERR_INVALID_PARAM;
192 }
193 int32_t ret = -1;
194 g_testMutex.lock();
195 ret = ptr.render->volume.GetGain(ptr.render, &(ptr.character.getgain));
196 g_testMutex.unlock();
197 return ret;
198 }
199
RelAudioRenderProcedure(struct PrepareAudioPara & ptr)200 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderProcedure(struct PrepareAudioPara& ptr)
201 {
202 int32_t ret = -1;
203 ret = GetLoadAdapter(ptr.manager, ptr.portType, ptr.adapterName, &ptr.adapter, ptr.audioPort);
204 if (ret < 0) {
205 return ret;
206 }
207 ret = RelAudioCreateRender(ptr);
208 if (ret < 0) {
209 return ret;
210 }
211 ret = AudioRenderStartAndOneFrame(ptr.render);
212 if (ret < 0) {
213 return ret;
214 }
215 return AUDIO_HAL_SUCCESS;
216 }
217
RelAudioRenderSetMute(struct PrepareAudioPara & ptr)218 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetMute(struct PrepareAudioPara& ptr)
219 {
220 if (ptr.render == nullptr) {
221 return AUDIO_HAL_ERR_INVALID_PARAM;
222 }
223 int32_t ret = -1;
224 g_testMutex.lock();
225 ret = ptr.render->volume.SetMute(ptr.render, ptr.character.setmute);
226 g_testMutex.unlock();
227 return ret;
228 }
229
RelAudioRenderGetMute(struct PrepareAudioPara & ptr)230 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetMute(struct PrepareAudioPara& ptr)
231 {
232 if (ptr.render == nullptr) {
233 return AUDIO_HAL_ERR_INVALID_PARAM;
234 }
235 int32_t ret = -1;
236 g_testMutex.lock();
237 ret = ptr.render->volume.GetMute(ptr.render, &(ptr.character.getmute));
238 g_testMutex.unlock();
239 return ret;
240 }
241
RelAudioRenderSetVolume(struct PrepareAudioPara & ptr)242 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetVolume(struct PrepareAudioPara& ptr)
243 {
244 if (ptr.render == nullptr) {
245 return AUDIO_HAL_ERR_INVALID_PARAM;
246 }
247 int32_t ret = -1;
248 g_testMutex.lock();
249 ret = ptr.render->volume.SetVolume(ptr.render, ptr.character.setvolume);
250 g_testMutex.unlock();
251 return ret;
252 }
253
RelAudioRenderGetVolume(struct PrepareAudioPara & ptr)254 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetVolume(struct PrepareAudioPara& ptr)
255 {
256 if (ptr.render == nullptr) {
257 return AUDIO_HAL_ERR_INVALID_PARAM;
258 }
259 int32_t ret = -1;
260 g_testMutex.lock();
261 ret = ptr.render->volume.GetVolume(ptr.render, &(ptr.character.getvolume));
262 g_testMutex.unlock();
263 return ret;
264 }
265
RelAudioRenderGetFrameSize(struct PrepareAudioPara & ptr)266 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetFrameSize(struct PrepareAudioPara& ptr)
267 {
268 if (ptr.render == nullptr) {
269 return AUDIO_HAL_ERR_INVALID_PARAM;
270 }
271 int32_t ret = -1;
272 g_testMutex.lock();
273 ret = ptr.render->attr.GetFrameSize(ptr.render, &(ptr.character.getframesize));
274 g_testMutex.unlock();
275 return ret;
276 }
277
RelAudioRenderGetFrameCount(struct PrepareAudioPara & ptr)278 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetFrameCount(struct PrepareAudioPara& ptr)
279 {
280 if (ptr.render == nullptr) {
281 return AUDIO_HAL_ERR_INVALID_PARAM;
282 }
283 int32_t ret = -1;
284 g_testMutex.lock();
285 ret = ptr.render->attr.GetFrameCount(ptr.render, &(ptr.character.getframecount));
286 g_testMutex.unlock();
287 return ret;
288 }
289
RelAudioRenderGetCurrentChannelId(struct PrepareAudioPara & ptr)290 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetCurrentChannelId(struct PrepareAudioPara& ptr)
291 {
292 if (ptr.render == nullptr) {
293 return AUDIO_HAL_ERR_INVALID_PARAM;
294 }
295 int32_t ret = -1;
296 g_testMutex.lock();
297 ret = ptr.render->attr.GetCurrentChannelId(ptr.render, &(ptr.character.getcurrentchannelId));
298 g_testMutex.unlock();
299 return ret;
300 }
301
RelAudioRenderSetSampleAttributes(struct PrepareAudioPara & ptr)302 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetSampleAttributes(struct PrepareAudioPara& ptr)
303 {
304 if (ptr.render == nullptr) {
305 return AUDIO_HAL_ERR_INVALID_PARAM;
306 }
307 int32_t ret = -1;
308 g_testMutex.lock();
309 ret = ptr.render->attr.SetSampleAttributes(ptr.render, &(ptr.attrs));
310 g_testMutex.unlock();
311 return ret;
312 }
313
RelAudioRenderGetSampleAttributes(struct PrepareAudioPara & ptr)314 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetSampleAttributes(struct PrepareAudioPara& ptr)
315 {
316 if (ptr.render == nullptr) {
317 return AUDIO_HAL_ERR_INVALID_PARAM;
318 }
319 int32_t ret = -1;
320 g_testMutex.lock();
321 ret = ptr.render->attr.GetSampleAttributes(ptr.render, &(ptr.attrsValue));
322 g_testMutex.unlock();
323 return ret;
324 }
325
RelAudioRenderSelectScene(struct PrepareAudioPara & ptr)326 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSelectScene(struct PrepareAudioPara& ptr)
327 {
328 if (ptr.render == nullptr) {
329 return AUDIO_HAL_ERR_INVALID_PARAM;
330 }
331 int32_t ret = -1;
332 g_testMutex.lock();
333 ret = ptr.render->scene.SelectScene(ptr.render, &(ptr.scenes));
334 g_testMutex.unlock();
335 return ret;
336 }
337
RelAudioRenderCheckSceneCapability(struct PrepareAudioPara & ptr)338 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderCheckSceneCapability(struct PrepareAudioPara& ptr)
339 {
340 if (ptr.render == nullptr) {
341 return AUDIO_HAL_ERR_INVALID_PARAM;
342 }
343 int32_t ret = -1;
344 g_testMutex.lock();
345 ret = ptr.render->scene.CheckSceneCapability(ptr.render, &ptr.scenes, &(ptr.character.supported));
346 g_testMutex.unlock();
347 return ret;
348 }
349
RelAudioRenderSetChannelMode(struct PrepareAudioPara & ptr)350 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetChannelMode(struct PrepareAudioPara &ptr)
351 {
352 if (ptr.render == nullptr) {
353 return AUDIO_HAL_ERR_INVALID_PARAM;
354 }
355 int32_t ret = -1;
356 g_testMutex.lock();
357 ret = ptr.render->SetChannelMode(ptr.render, ptr.character.setmode);
358 g_testMutex.unlock();
359 return ret;
360 }
361
RelAudioRenderGetChannelMode(struct PrepareAudioPara & ptr)362 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetChannelMode(struct PrepareAudioPara &ptr)
363 {
364 if (ptr.render == nullptr) {
365 return AUDIO_HAL_ERR_INVALID_PARAM;
366 }
367 int32_t ret = -1;
368 g_testMutex.lock();
369 ret = ptr.render->GetChannelMode(ptr.render, &(ptr.character.getmode));
370 g_testMutex.unlock();
371 return ret;
372 }
373
RelAudioRenderGetLatency(struct PrepareAudioPara & ptr)374 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetLatency(struct PrepareAudioPara& ptr)
375 {
376 if (ptr.render == nullptr) {
377 return AUDIO_HAL_ERR_INVALID_PARAM;
378 }
379 int32_t ret = -1;
380 g_testMutex.lock();
381 ret = ptr.render->GetLatency(ptr.render, &(ptr.character.latencyTime));
382 g_testMutex.unlock();
383 return ret;
384 }
385
386 /**
387 * @tc.name test AudioRenderGetFrameSize API via Multithread call.
388 * @tc.number SUB_Audio_HDI_AudiorenderGetVolume_Reliability_0001
389 * @tc.desc test GetFrameSize interface Reliability pass through pthread_create fun and adapterName is same.
390 * @tc.author: zhouyongxiao
391 */
392 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetFrameSize_Reliability_0001, TestSize.Level1)
393 {
394 int32_t ret = -1;
395 ASSERT_NE(nullptr, GetAudioManager);
396 g_para[0].manager = GetAudioManager();
397 ASSERT_NE(nullptr, g_para[0].manager);
398 ret = GetLoadAdapter(g_para[0].manager, g_para[0].portType, g_para[0].adapterName, &g_para[0].adapter,
399 g_para[0].audioPort);
400 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
401 ret = RelAudioCreateRender(g_para[0]);
402 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
403
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)RelAudioRenderGetFrameSize, &g_para[0]);
407 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
408 }
409
410 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
411 void *result = nullptr;
412 pthread_join(tids[i], &result);
413 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
414 EXPECT_LT(INITIAL_VALUE, g_para[0].character.getframesize);
415 }
416 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
417 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
418 g_para[0].render = nullptr;
419 }
420
421 /**
422 * @tc.name test AudioRenderGetFrameCount API via Multithread call.
423 * @tc.number SUB_Audio_HDI_AudiorenderGetVolume_Reliability_0001
424 * @tc.desc test GetFrameCount interface Reliability pass through pthread_create fun and adapterName is same.
425 * @tc.author: zhouyongxiao
426 */
427 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetFrameCount_Reliability_0001, TestSize.Level1)
428 {
429 int32_t ret = -1;
430 ASSERT_NE(nullptr, GetAudioManager);
431 g_para[0].manager = GetAudioManager();
432 ASSERT_NE(nullptr, g_para[0].manager);
433
434 ret = RelAudioRenderProcedure(g_para[0]);
435 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
436
437 pthread_t tids[PTHREAD_SAMEADA_COUNT];
438 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
439 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetFrameCount, &g_para[0]);
440 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
441 }
442
443 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
444 void *result = nullptr;
445 pthread_join(tids[i], &result);
446 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
447 EXPECT_LT(INITIAL_VALUE, g_para[0].character.getframecount);
448 }
449 if (g_para[0].adapter != nullptr){
450 ret = StopAudio(g_para[0]);
451 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
452 g_para[0].render = nullptr;
453 }
454 }
455
456 /**
457 * @tc.name test AudioRenderGetVolume API via Multithread call.
458 * @tc.number SUB_Audio_HDI_AudiorenderGetVolume_Reliability_0001
459 * @tc.desc test GetCurrentChannelId interface Reliability pass through pthread_create fun and adapterName is same.
460 * @tc.author: zhouyongxiao
461 */
462 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetCurrentChannelId_Reliability_0001, TestSize.Level1)
463 {
464 int32_t ret = -1;
465 uint32_t channelIdValue = 2;
466 ASSERT_NE(nullptr, GetAudioManager);
467 g_para[0].manager = GetAudioManager();
468 ASSERT_NE(nullptr, g_para[0].manager);
469 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
470 ret = GetLoadAdapter(g_para[0].manager, g_para[0].portType, g_para[0].adapterName, &g_para[0].adapter,
471 g_para[0].audioPort);
472 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
473 ret = RelAudioCreateRender(g_para[0]);
474 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
475
476 pthread_t tids[PTHREAD_SAMEADA_COUNT];
477 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
478 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
479 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
480 arrpara[i].character.getcurrentchannelId = 0;
481 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetCurrentChannelId, &arrpara[i]);
482 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
483 }
484
485 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
486 void *result = nullptr;
487 pthread_join(tids[i], &result);
488 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
489 EXPECT_EQ(channelIdValue, arrpara[i].character.getcurrentchannelId);
490 }
491 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
492 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
493 g_para[0].render = nullptr;
494 }
495
496 /**
497 * @tc.name test AudioRenderSetMute API via Multithread call.
498 * @tc.number SUB_Audio_HDI_AudiorenderSetMute_Reliability_0001
499 * @tc.desc test AudioRenderSetMute interface Reliability pass through pthread_create fun and adapterName is same.
500 * @tc.author: zhouyongxiao
501 */
502 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderSetMute_Reliability_0001, TestSize.Level1)
503 {
504 int32_t ret = -1;
505 ASSERT_NE(nullptr, GetAudioManager);
506 g_para[0].manager = GetAudioManager();
507 ASSERT_NE(nullptr, g_para[0].manager);
508 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
509
510 ret = RelAudioRenderProcedure(g_para[0]);
511 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
512
513 pthread_t tids[PTHREAD_SAMEADA_COUNT];
514 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
515 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
516 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
517 ret = arrpara[i].render->volume.GetMute(arrpara[i].render, &(arrpara[i].character.getmute));
518 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
519 if (arrpara[i].character.getmute == false) {
520 arrpara[i].character.setmute = true;
521 } else {
522 arrpara[i].character.setmute = false;
523 }
524 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetMute, &arrpara[i]);
525 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
526 }
527
528 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
529 void *result = nullptr;
530 pthread_join(tids[i], &result);
531 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
532 }
533 if (g_para[0].adapter != nullptr){
534 ret = StopAudio(g_para[0]);
535 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
536 g_para[0].render = nullptr;
537 }
538 }
539
540 /**
541 * @tc.name test AudioRenderGetMute API via Multithread call.
542 * @tc.number SUB_Audio_HDI_AudiorenderGetMute_Reliability_0001
543 * @tc.desc test AudioRenderGetMute interface Reliability pass through pthread_create fun and adapterName is same.
544 * @tc.author: zhouyongxiao
545 */
546 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderGetMute_Reliability_0001, TestSize.Level1)
547 {
548 int32_t ret = -1;
549 ASSERT_NE(nullptr, GetAudioManager);
550 g_para[0].manager = GetAudioManager();
551 ASSERT_NE(nullptr, g_para[0].manager);
552 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
553 ret = GetLoadAdapter(g_para[0].manager, g_para[0].portType, g_para[0].adapterName, &g_para[0].adapter,
554 g_para[0].audioPort);
555 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
556 ret = RelAudioCreateRender(g_para[0]);
557 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
558
559 pthread_t tids[PTHREAD_SAMEADA_COUNT];
560 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
561 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
562 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
563 ret = arrpara[i].render->volume.SetMute(arrpara[i].render, false);
564 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
565 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetMute, &arrpara[i]);
566 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
567 }
568
569 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
570 void *result = nullptr;
571 pthread_join(tids[i], &result);
572 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
573 EXPECT_FALSE(arrpara[i].character.getmute);
574 }
575 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
576 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
577 g_para[0].render = nullptr;
578 }
579
580 /**
581 * @tc.name test AudioRenderSetVolume API via Multithread call.
582 * @tc.number SUB_Audio_HDI_AudiorenderSetVolume_Reliability_0001
583 * @tc.desc test SetVolume interface Reliability pass through pthread_create fun and adapterName is same.
584 * @tc.author: zhouyongxiao
585 */
586 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderSetVolume_Reliability_0001, TestSize.Level1)
587 {
588 int32_t ret = -1;
589 float volumeHighExpc = 0.70;
590 ASSERT_NE(nullptr, GetAudioManager);
591 g_para[0].manager = GetAudioManager();
592 ASSERT_NE(nullptr, g_para[0].manager);
593 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
594
595 ret = RelAudioRenderProcedure(g_para[0]);
596 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
597 pthread_t tids[PTHREAD_SAMEADA_COUNT];
598 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
599 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
600 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
601 arrpara[i].character.setvolume = 0.70;
602 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetVolume, &arrpara[i]);
603 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
604 }
605
606 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
607 void *result = nullptr;
608 pthread_join(tids[i], &result);
609 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
610 ret = arrpara[i].render->volume.GetVolume(arrpara[i].render, &(arrpara[i].character.getvolume));
611 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
612 EXPECT_EQ(volumeHighExpc, arrpara[i].character.getvolume);
613 }
614 if (g_para[0].adapter != nullptr){
615 ret = StopAudio(g_para[0]);
616 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
617 g_para[0].render = nullptr;
618 }
619 }
620
621 /**
622 * @tc.name test AudioRenderGetVolume API via Multithread call.
623 * @tc.number SUB_Audio_HDI_AudiorenderGetVolume_Reliability_0001
624 * @tc.desc test GetVolume interface Reliability pass through pthread_create fun and adapterName is same.
625 * @tc.author: zhouyongxiao
626 */
627 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudiorenderGetVolume_Reliability_0001, TestSize.Level1)
628 {
629 int32_t ret = -1;
630 float volumeHighExpc = 0.7;
631 ASSERT_NE(nullptr, GetAudioManager);
632 g_para[0].manager = GetAudioManager();
633 ASSERT_NE(nullptr, g_para[0].manager);
634 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
635 ret = GetLoadAdapter(g_para[0].manager, g_para[0].portType, g_para[0].adapterName, &g_para[0].adapter,
636 g_para[0].audioPort);
637 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
638 ret = RelAudioCreateRender(g_para[0]);
639 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
640
641 pthread_t tids[PTHREAD_SAMEADA_COUNT];
642 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
643 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
644 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
645 arrpara[i].character.setvolume = 0.7;
646 ret = arrpara[i].render->volume.SetVolume(arrpara[i].render, arrpara[i].character.setvolume);
647 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
648 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetVolume, &arrpara[i]);
649 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
650 }
651
652 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
653 void *result = nullptr;
654 pthread_join(tids[i], &result);
655 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
656 EXPECT_EQ(volumeHighExpc, arrpara[i].character.getvolume);
657 }
658 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
659 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
660 g_para[0].render = nullptr;
661 }
662
663 /**
664 * @tc.name test AudioRenderSetSampleAttributes API via Multithread call.
665 * @tc.number SUB_Audio_HDI_AudioRenderSetSampleAttributes_Reliability_0001
666 * @tc.desc test AudioRenderSetSampleAttributes interface Reliability pass through pthread_create fun and adapterName
667 is same.
668 * @tc.author: ZHANGHAILIN
669 */
670 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSetSampleAttributes_Reliability_0001, TestSize.Level1)
671 {
672 int32_t ret = -1;
673 uint32_t count = 2;
674 uint32_t rateExpc = 48000;
675 ASSERT_NE(nullptr, GetAudioManager);
676 g_para[0].manager = GetAudioManager();
677 ASSERT_NE(nullptr, g_para[0].manager);
678 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
679 ret = GetLoadAdapter(g_para[0].manager, g_para[0].portType, g_para[0].adapterName, &g_para[0].adapter,
680 g_para[0].audioPort);
681 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
682 ret = RelAudioCreateRender(g_para[0]);
683 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
684 InitAttrs(g_para[0].attrs);
685 pthread_t tids[PTHREAD_SAMEADA_COUNT];
686 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
687 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
688 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
689 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetSampleAttributes, &arrpara[i]);
690 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
691 }
692
693 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
694 void *result = nullptr;
695 pthread_join(tids[i], &result);
696 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
697 ret = arrpara[i].render->attr.GetSampleAttributes(arrpara[i].render, &(arrpara[i].attrsValue));
698 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
699 EXPECT_EQ(AUDIO_IN_MEDIA, arrpara[i].attrsValue.type);
700 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, arrpara[i].attrsValue.format);
701 EXPECT_EQ(rateExpc, arrpara[i].attrsValue.sampleRate);
702 EXPECT_EQ(count, arrpara[i].attrsValue.channelCount);
703 }
704 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
705 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
706 g_para[0].render = nullptr;
707 }
708
709 /**
710 * @tc.name test AudioRenderGetSampleAttributes API via Multithread call.
711 * @tc.number SUB_Audio_HDI_AudioRenderGetSampleAttributes_Reliability_0001
712 * @tc.desc test AudioRenderGetSampleAttributes interface Reliability pass through pthread_create fun and adapterName
713 is same.
714 * @tc.author: ZHANGHAILIN
715 */
716 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetSampleAttributes_Reliability_0001, TestSize.Level1)
717 {
718 int32_t ret = -1;
719 uint32_t count = 2;
720 uint32_t rateExpc = 48000;
721 ASSERT_NE(nullptr, GetAudioManager);
722 g_para[0].manager = GetAudioManager();
723 ASSERT_NE(nullptr, g_para[0].manager);
724 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
725 ret = GetLoadAdapter(g_para[0].manager, g_para[0].portType, g_para[0].adapterName, &g_para[0].adapter,
726 g_para[0].audioPort);
727 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
728 ret = RelAudioCreateRender(g_para[0]);
729 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
730 InitAttrs(g_para[0].attrs);
731 ret = g_para[0].render->attr.SetSampleAttributes(g_para[0].render, &(g_para[0].attrs));
732 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
733 pthread_t tids[PTHREAD_SAMEADA_COUNT];
734 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
735 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
736 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
737 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetSampleAttributes, &arrpara[i]);
738 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
739 }
740
741 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
742 void *result = nullptr;
743 pthread_join(tids[i], &result);
744 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
745 EXPECT_EQ(AUDIO_IN_MEDIA, arrpara[i].attrsValue.type);
746 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, arrpara[i].attrsValue.format);
747 EXPECT_EQ(rateExpc, arrpara[i].attrsValue.sampleRate);
748 EXPECT_EQ(count, arrpara[i].attrsValue.channelCount);
749 }
750 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
751 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
752 g_para[0].render = nullptr;
753 }
754
755 /**
756 * @tc.name test AudioRenderSelectScene API via Multithread call.
757 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_Reliability_0001
758 * @tc.desc test AudioRenderSelectScene interface Reliability pass through pthread_create fun and adapterName is same.
759 * @tc.author: ZHANGHAILIN
760 */
761 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSelectScene_Reliability_0001, TestSize.Level1)
762 {
763 int32_t ret = -1;
764 ASSERT_NE(nullptr, GetAudioManager);
765 g_para[0].manager = GetAudioManager();
766 ASSERT_NE(nullptr, g_para[0].manager);
767 ret = GetLoadAdapter(g_para[0].manager, g_para[0].portType, g_para[0].adapterName, &g_para[0].adapter,
768 g_para[0].audioPort);
769 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
770 ret = RelAudioCreateRender(g_para[0]);
771 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
772 pthread_t tids[PTHREAD_SAMEADA_COUNT];
773 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
774 g_para[0].scenes.scene.id = 0;
775 g_para[0].scenes.desc.pins = PIN_OUT_SPEAKER;
776 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSelectScene, &g_para[0]);
777 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
778 }
779
780 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
781 void *result = nullptr;
782 pthread_join(tids[i], &result);
783 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
784 }
785 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
786 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
787 g_para[0].render = nullptr;
788 }
789
790 /**
791 * @tc.name test AudioRenderCheckSceneCapability API via Multithread call.
792 * @tc.number SUB_Audio_HDI_AudioRenderCheckSceneCapability_Reliability_0001
793 * @tc.desc test AudioRenderCheckSceneCapability interface Reliability pass through pthread_create fun and adapterName
794 is same.
795 * @tc.author: ZHANGHAILIN
796 */
797 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderCheckSceneCapability_Reliability_0001, TestSize.Level1)
798 {
799 int32_t ret = -1;
800 ASSERT_NE(nullptr, GetAudioManager);
801 g_para[0].manager = GetAudioManager();
802 ASSERT_NE(nullptr, g_para[0].manager);
803 ret = GetLoadAdapter(g_para[0].manager, g_para[0].portType, g_para[0].adapterName, &g_para[0].adapter,
804 g_para[0].audioPort);
805 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
806 ret = RelAudioCreateRender(g_para[0]);
807 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
808
809 pthread_t tids[PTHREAD_SAMEADA_COUNT];
810 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
811 g_para[0].scenes.scene.id = 0;
812 g_para[0].scenes.desc.pins = PIN_OUT_SPEAKER;
813 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderCheckSceneCapability, &g_para[0]);
814 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
815 }
816
817 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
818 void *result = nullptr;
819 pthread_join(tids[i], &result);
820 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
821 }
822 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
823 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
824 g_para[0].render = nullptr;
825 }
826
827 /**
828 * @tc.name test AudioRenderSetGain API via Multithread call.
829 * @tc.number SUB_Audio_HDI_AudioRenderSetGain_Reliability_0001
830 * @tc.desc test AudioRenderSetGain interface Reliability pass through pthread_create fun and adapterName is same.
831 * @tc.author: zhouyongxiao
832 */
833 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSetGain_Reliability_0001, TestSize.Level1)
834 {
835 int32_t ret = -1;
836 ASSERT_NE(nullptr, GetAudioManager);
837 g_para[0].manager = GetAudioManager();
838 ASSERT_NE(nullptr, g_para[0].manager);
839 ret = GetLoadAdapter(g_para[0].manager, g_para[0].portType, g_para[0].adapterName, &g_para[0].adapter,
840 g_para[0].audioPort);
841 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
842 ret = RelAudioCreateRender(g_para[0]);
843 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
844
845 pthread_t tids[PTHREAD_SAMEADA_COUNT];
846 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
847 g_para[0].character.setgain = 5;
848 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetGain, &g_para[0]);
849 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
850 }
851 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
852 void *result = nullptr;
853 pthread_join(tids[i], &result);
854 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
855 EXPECT_LT(GAIN_MIN, g_para[0].character.setgain);
856 }
857 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
858 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
859 g_para[0].render = nullptr;
860 }
861
862 /**
863 * @tc.name test AudioRenderGetGain API via Multithread call.
864 * @tc.number SUB_Audio_HDI_AudioRenderGetGain_Reliability_0001
865 * @tc.desc test GetGain interface Reliability pass through pthread_create fun and adapterName is same.
866 * @tc.author: zhouyongxiao
867 */
868 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetGain_Reliability_0001, TestSize.Level1)
869 {
870 int32_t ret = -1;
871 ASSERT_NE(nullptr, GetAudioManager);
872 g_para[0].manager = GetAudioManager();
873 ASSERT_NE(nullptr, g_para[0].manager);
874 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
875 ret = GetLoadAdapter(g_para[0].manager, g_para[0].portType, g_para[0].adapterName, &g_para[0].adapter,
876 g_para[0].audioPort);
877 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
878 ret = RelAudioCreateRender(g_para[0]);
879 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
880
881 pthread_t tids[PTHREAD_SAMEADA_COUNT];
882 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
883 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
884 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
885 arrpara[i].character.setgain = 7;
886 ret = arrpara[i].render->volume.SetGain(arrpara[i].render, arrpara[i].character.setgain);
887 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
888 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetGain, &arrpara[i]);
889 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
890 }
891 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
892 void *result = nullptr;
893 pthread_join(tids[i], &result);
894 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
895 EXPECT_LT(GAIN_MIN, arrpara[i].character.setgain);
896 }
897 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
898 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
899 g_para[0].render = nullptr;
900 }
901
902 /**
903 * @tc.name test AudioRenderGetGainThreshold API via Multithread call.
904 * @tc.number SUB_Audio_HDI_AudioRenderGetGainThreshold_Reliability_0001
905 * @tc.desc test GetGainThreshold interface Reliability pass through pthread_create fun and adapterName is same.
906 * @tc.author: zhouyongxiao
907 */
908 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetGainThreshold_Reliability_0001, TestSize.Level1)
909 {
910 int32_t ret = -1;
911 ASSERT_NE(nullptr, GetAudioManager);
912 g_para[0].manager = GetAudioManager();
913 ASSERT_NE(nullptr, g_para[0].manager);
914 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
915 ret = GetLoadAdapter(g_para[0].manager, g_para[0].portType, g_para[0].adapterName, &g_para[0].adapter,
916 g_para[0].audioPort);
917 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
918 ret = RelAudioCreateRender(g_para[0]);
919 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
920
921 pthread_t tids[PTHREAD_SAMEADA_COUNT];
922 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
923 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
924 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
925 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetGainThreshold, &arrpara[i]);
926 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
927 }
928 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
929 void *result = nullptr;
930 pthread_join(tids[i], &result);
931 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
932 EXPECT_EQ(0, arrpara[i].character.gainthresholdmin);
933 EXPECT_EQ(15, arrpara[i].character.gainthresholdmax);
934 }
935 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
936 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
937 g_para[0].render = nullptr;
938 }
939
940 /**
941 * @tc.name test AudioRenderSetChannelMode API via Multithread call.
942 * @tc.number SUB_Audio_HDI_AudioRenderSetChannelMode_Reliability_0001
943 * @tc.desc test SetChannelMode interface Reliability pass through pthread_create fun and adapterName is same.
944 * @tc.author: zhouyongxiao
945 */
946 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderSetChannelMode_Reliability_0001, TestSize.Level1)
947 {
948 int32_t ret = -1;
949 ASSERT_NE(nullptr, GetAudioManager);
950 g_para[0].manager = GetAudioManager();
951 ASSERT_NE(nullptr, g_para[0].manager);
952 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
953 ret = GetLoadAdapter(g_para[0].manager, g_para[0].portType, g_para[0].adapterName, &g_para[0].adapter,
954 g_para[0].audioPort);
955 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
956 ret = RelAudioCreateRender(g_para[0]);
957 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
958
959 pthread_t tids[PTHREAD_SAMEADA_COUNT];
960 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
961 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
962 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
963 arrpara[i].character.setmode = AUDIO_CHANNEL_NORMAL;
964 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetChannelMode, &arrpara[i]);
965 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
966 }
967 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
968 void *result = nullptr;
969 pthread_join(tids[i], &result);
970 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
971 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, arrpara[i].character.getmode);
972 }
973 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
974 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
975 g_para[0].render = nullptr;
976 }
977
978 /**
979 * @tc.name test AudioRenderGetChannelMode API via Multithread call.
980 * @tc.number SUB_Audio_HDI_AudioRenderGetChannelMode_Reliability_0001
981 * @tc.desc test GetChannelMode interface Reliability pass through pthread_create fun and adapterName is same.
982 * @tc.author: zhouyongxiao
983 */
984 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderGetChannelMode_Reliability_0001, TestSize.Level1)
985 {
986 int32_t ret = -1;
987 ASSERT_NE(nullptr, GetAudioManager);
988 g_para[0].manager = GetAudioManager();
989 ASSERT_NE(nullptr, g_para[0].manager);
990 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
991 ret = GetLoadAdapter(g_para[0].manager, g_para[0].portType, g_para[0].adapterName, &g_para[0].adapter,
992 g_para[0].audioPort);
993 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
994 ret = RelAudioCreateRender(g_para[0]);
995 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
996
997 pthread_t tids[PTHREAD_SAMEADA_COUNT];
998 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
999 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
1000 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1001 arrpara[i].character.setmode = AUDIO_CHANNEL_NORMAL;
1002 ret = arrpara[i].render->SetChannelMode(arrpara[i].render, arrpara[i].character.setmode);
1003 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1004 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetChannelMode, &arrpara[i]);
1005 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1006 }
1007 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
1008 void *result = nullptr;
1009 pthread_join(tids[i], &result);
1010 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
1011 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, arrpara[i].character.getmode);
1012 }
1013 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
1014 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
1015 g_para[0].render = nullptr;
1016 }
1017
1018 /**
1019 * @tc.name test AudioRenderRenderGetLatency API via Multithread call.
1020 * @tc.number SUB_Audio_HDI_AudioRenderRenderGetLatency_Reliability_0001
1021 * @tc.desc test GetLatency interface Reliability pass through pthread_create fun and adapterName is same.
1022 * @tc.author: wangkang
1023 */
1024 HWTEST_F(AudioHdiRenderReliabilityTest, SUB_Audio_HDI_AudioRenderRenderGetLatency_Reliability_0001, TestSize.Level1)
1025 {
1026 int32_t ret = -1;
1027 uint32_t expectLatency = 0;
1028 ASSERT_NE(nullptr, GetAudioManager);
1029 g_para[0].manager = GetAudioManager();
1030 ASSERT_NE(nullptr, g_para[0].manager);
1031 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
1032 ret = GetLoadAdapter(g_para[0].manager, g_para[0].portType, g_para[0].adapterName, &g_para[0].adapter,
1033 g_para[0].audioPort);
1034 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1035 ret = RelAudioCreateRender(g_para[0]);
1036 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1037 pthread_t tids[PTHREAD_SAMEADA_COUNT];
1038 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
1039 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
1040 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1041 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetLatency, &arrpara[i]);
1042 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1043 }
1044 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
1045 void *result = nullptr;
1046 pthread_join(tids[i], &result);
1047 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
1048 EXPECT_LT(expectLatency, arrpara[i].character.latencyTime);
1049 }
1050 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
1051 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
1052 g_para[0].render = nullptr;
1053 }
1054 }