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 OHOS::Audio;
23
24 namespace {
25 const int PTHREAD_DIFFADA_COUNT = 1;
26 const int PTHREAD_SAMEADA_COUNT = 10;
27 mutex g_testMutex;
28 static struct PrepareAudioPara g_para[PTHREAD_DIFFADA_COUNT] = {
29 {
30 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_OUT_SPEAKER,
31 .path = AUDIO_FILE.c_str()
32 }
33 };
34
35 class AudioHdiRenderReliabilityTest : public testing::Test {
36 public:
37 static void SetUpTestCase(void);
38 static void TearDownTestCase(void);
39 void SetUp();
40 void TearDown();
41 static TestAudioManager *manager;
42 AudioAdapter *adapter = nullptr;
43 AudioRender *render = nullptr;
44 static int32_t RelAudioRenderSetGain(struct PrepareAudioPara& ptr);
45 static int32_t RelAudioRenderGetGain(struct PrepareAudioPara& ptr);
46 static int32_t RelAudioRenderGetGainThreshold(struct PrepareAudioPara& ptr);
47 static int32_t RelAudioRenderSetMute(struct PrepareAudioPara& ptr);
48 static int32_t RelAudioRenderGetMute(struct PrepareAudioPara& ptr);
49 static int32_t RelAudioRenderSetVolume(struct PrepareAudioPara& ptr);
50 static int32_t RelAudioRenderGetVolume(struct PrepareAudioPara& ptr);
51 static int32_t RelAudioRenderGetFrameSize(struct PrepareAudioPara& ptr);
52 static int32_t RelAudioRenderGetFrameCount(struct PrepareAudioPara& ptr);
53 static int32_t RelAudioRenderGetCurrentChannelId(struct PrepareAudioPara& ptr);
54 static int32_t RelAudioRenderSetChannelMode(struct PrepareAudioPara& ptr);
55 static int32_t RelAudioRenderGetChannelMode(struct PrepareAudioPara& ptr);
56 static int32_t RelAudioRenderSetSampleAttributes(struct PrepareAudioPara& ptr);
57 static int32_t RelAudioRenderGetSampleAttributes(struct PrepareAudioPara& ptr);
58 static int32_t RelAudioRenderSelectScene(struct PrepareAudioPara& ptr);
59 static int32_t RelAudioRenderCheckSceneCapability(struct PrepareAudioPara& ptr);
60 static int32_t RelAudioRenderGetLatency(struct PrepareAudioPara& ptr);
61 };
62
63 using THREAD_FUNC = void *(*)(void *);
64 TestAudioManager *AudioHdiRenderReliabilityTest::manager = nullptr;
65
SetUpTestCase(void)66 void AudioHdiRenderReliabilityTest::SetUpTestCase(void)
67 {
68 manager = GetAudioManagerFuncs();
69 ASSERT_NE(nullptr, manager);
70 }
71
TearDownTestCase(void)72 void AudioHdiRenderReliabilityTest::TearDownTestCase(void) {}
73
SetUp(void)74 void AudioHdiRenderReliabilityTest::SetUp(void)
75 {
76 ASSERT_NE(nullptr, manager);
77 int32_t ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
78 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
79 }
80
TearDown(void)81 void AudioHdiRenderReliabilityTest::TearDown(void)
82 {
83 int32_t ret = ReleaseRenderSource(manager, adapter, render);
84 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
85 }
86
RelAudioRenderGetGainThreshold(struct PrepareAudioPara & ptr)87 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetGainThreshold(struct PrepareAudioPara& ptr)
88 {
89 if (ptr.render == nullptr) {
90 return AUDIO_HAL_ERR_INVALID_PARAM;
91 }
92 int32_t ret = -1;
93 g_testMutex.lock();
94 ret = ptr.render->volume.GetGainThreshold(ptr.render, &(ptr.character.gainthresholdmin),
95 &(ptr.character.gainthresholdmax));
96 g_testMutex.unlock();
97 return ret;
98 }
99
RelAudioRenderSetGain(struct PrepareAudioPara & ptr)100 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetGain(struct PrepareAudioPara& ptr)
101 {
102 if (ptr.render == nullptr) {
103 return AUDIO_HAL_ERR_INVALID_PARAM;
104 }
105 int32_t ret = -1;
106 g_testMutex.lock();
107 ret = ptr.render->volume.SetGain(ptr.render, ptr.character.setgain);
108 g_testMutex.unlock();
109 return ret;
110 }
111
RelAudioRenderGetGain(struct PrepareAudioPara & ptr)112 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetGain(struct PrepareAudioPara& ptr)
113 {
114 if (ptr.render == nullptr) {
115 return AUDIO_HAL_ERR_INVALID_PARAM;
116 }
117 int32_t ret = -1;
118 g_testMutex.lock();
119 ret = ptr.render->volume.GetGain(ptr.render, &(ptr.character.getgain));
120 g_testMutex.unlock();
121 return ret;
122 }
123
RelAudioRenderSetMute(struct PrepareAudioPara & ptr)124 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetMute(struct PrepareAudioPara& ptr)
125 {
126 if (ptr.render == nullptr) {
127 return AUDIO_HAL_ERR_INVALID_PARAM;
128 }
129 int32_t ret = -1;
130 g_testMutex.lock();
131 ret = ptr.render->volume.SetMute(ptr.render, ptr.character.setmute);
132 g_testMutex.unlock();
133 return ret;
134 }
135
RelAudioRenderGetMute(struct PrepareAudioPara & ptr)136 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetMute(struct PrepareAudioPara& ptr)
137 {
138 if (ptr.render == nullptr) {
139 return AUDIO_HAL_ERR_INVALID_PARAM;
140 }
141 int32_t ret = -1;
142 g_testMutex.lock();
143 ret = ptr.render->volume.GetMute(ptr.render, &(ptr.character.getmute));
144 g_testMutex.unlock();
145 return ret;
146 }
147
RelAudioRenderSetVolume(struct PrepareAudioPara & ptr)148 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetVolume(struct PrepareAudioPara& ptr)
149 {
150 if (ptr.render == nullptr) {
151 return AUDIO_HAL_ERR_INVALID_PARAM;
152 }
153 int32_t ret = -1;
154 g_testMutex.lock();
155 ret = ptr.render->volume.SetVolume(ptr.render, ptr.character.setvolume);
156 g_testMutex.unlock();
157 return ret;
158 }
159
RelAudioRenderGetVolume(struct PrepareAudioPara & ptr)160 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetVolume(struct PrepareAudioPara& ptr)
161 {
162 if (ptr.render == nullptr) {
163 return AUDIO_HAL_ERR_INVALID_PARAM;
164 }
165 int32_t ret = -1;
166 g_testMutex.lock();
167 ret = ptr.render->volume.GetVolume(ptr.render, &(ptr.character.getvolume));
168 g_testMutex.unlock();
169 return ret;
170 }
171
RelAudioRenderGetFrameSize(struct PrepareAudioPara & ptr)172 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetFrameSize(struct PrepareAudioPara& ptr)
173 {
174 if (ptr.render == nullptr) {
175 return AUDIO_HAL_ERR_INVALID_PARAM;
176 }
177 int32_t ret = -1;
178 g_testMutex.lock();
179 ret = ptr.render->attr.GetFrameSize(ptr.render, &(ptr.character.getframesize));
180 g_testMutex.unlock();
181 return ret;
182 }
183
RelAudioRenderGetFrameCount(struct PrepareAudioPara & ptr)184 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetFrameCount(struct PrepareAudioPara& ptr)
185 {
186 if (ptr.render == nullptr) {
187 return AUDIO_HAL_ERR_INVALID_PARAM;
188 }
189 int32_t ret = -1;
190 g_testMutex.lock();
191 ret = ptr.render->attr.GetFrameCount(ptr.render, &(ptr.character.getframecount));
192 g_testMutex.unlock();
193 return ret;
194 }
195
RelAudioRenderGetCurrentChannelId(struct PrepareAudioPara & ptr)196 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetCurrentChannelId(struct PrepareAudioPara& ptr)
197 {
198 if (ptr.render == nullptr) {
199 return AUDIO_HAL_ERR_INVALID_PARAM;
200 }
201 int32_t ret = -1;
202 g_testMutex.lock();
203 ret = ptr.render->attr.GetCurrentChannelId(ptr.render, &(ptr.character.getcurrentchannelId));
204 g_testMutex.unlock();
205 return ret;
206 }
207
RelAudioRenderSetSampleAttributes(struct PrepareAudioPara & ptr)208 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetSampleAttributes(struct PrepareAudioPara& ptr)
209 {
210 if (ptr.render == nullptr) {
211 return AUDIO_HAL_ERR_INVALID_PARAM;
212 }
213 int32_t ret = -1;
214 g_testMutex.lock();
215 ret = ptr.render->attr.SetSampleAttributes(ptr.render, &(ptr.attrs));
216 g_testMutex.unlock();
217 return ret;
218 }
219
RelAudioRenderGetSampleAttributes(struct PrepareAudioPara & ptr)220 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetSampleAttributes(struct PrepareAudioPara& ptr)
221 {
222 if (ptr.render == nullptr) {
223 return AUDIO_HAL_ERR_INVALID_PARAM;
224 }
225 int32_t ret = -1;
226 g_testMutex.lock();
227 ret = ptr.render->attr.GetSampleAttributes(ptr.render, &(ptr.attrsValue));
228 g_testMutex.unlock();
229 return ret;
230 }
231
RelAudioRenderSelectScene(struct PrepareAudioPara & ptr)232 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSelectScene(struct PrepareAudioPara& ptr)
233 {
234 if (ptr.render == nullptr) {
235 return AUDIO_HAL_ERR_INVALID_PARAM;
236 }
237 int32_t ret = -1;
238 g_testMutex.lock();
239 ret = ptr.render->scene.SelectScene(ptr.render, &(ptr.scenes));
240 g_testMutex.unlock();
241 return ret;
242 }
243
RelAudioRenderCheckSceneCapability(struct PrepareAudioPara & ptr)244 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderCheckSceneCapability(struct PrepareAudioPara& ptr)
245 {
246 if (ptr.render == nullptr) {
247 return AUDIO_HAL_ERR_INVALID_PARAM;
248 }
249 int32_t ret = -1;
250 g_testMutex.lock();
251 ret = ptr.render->scene.CheckSceneCapability(ptr.render, &ptr.scenes, &(ptr.character.supported));
252 g_testMutex.unlock();
253 return ret;
254 }
255
RelAudioRenderSetChannelMode(struct PrepareAudioPara & ptr)256 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderSetChannelMode(struct PrepareAudioPara &ptr)
257 {
258 if (ptr.render == nullptr) {
259 return AUDIO_HAL_ERR_INVALID_PARAM;
260 }
261 int32_t ret = -1;
262 g_testMutex.lock();
263 ret = ptr.render->SetChannelMode(ptr.render, ptr.character.setmode);
264 g_testMutex.unlock();
265 return ret;
266 }
267
RelAudioRenderGetChannelMode(struct PrepareAudioPara & ptr)268 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetChannelMode(struct PrepareAudioPara &ptr)
269 {
270 if (ptr.render == nullptr) {
271 return AUDIO_HAL_ERR_INVALID_PARAM;
272 }
273 int32_t ret = -1;
274 g_testMutex.lock();
275 ret = ptr.render->GetChannelMode(ptr.render, &(ptr.character.getmode));
276 g_testMutex.unlock();
277 return ret;
278 }
279
RelAudioRenderGetLatency(struct PrepareAudioPara & ptr)280 int32_t AudioHdiRenderReliabilityTest::RelAudioRenderGetLatency(struct PrepareAudioPara& ptr)
281 {
282 if (ptr.render == nullptr) {
283 return AUDIO_HAL_ERR_INVALID_PARAM;
284 }
285 int32_t ret = -1;
286 g_testMutex.lock();
287 ret = ptr.render->GetLatency(ptr.render, &(ptr.character.latencyTime));
288 g_testMutex.unlock();
289 return ret;
290 }
291
292 /**
293 * @tc.name AudiorenderGetVolumeReliability_001
294 * @tc.desc test GetFrameSize interface Reliability pass through pthread_create fun and adapterName is same.
295 * @tc.type: RELI
296 */
297 HWTEST_F(AudioHdiRenderReliabilityTest, AudioRenderGetFrameSizeReliability_001, TestSize.Level1)
298 {
299 int32_t ret = -1;
300 g_para[0].render = render;
301 ASSERT_NE(nullptr, g_para[0].render);
302
303 pthread_t tids[PTHREAD_SAMEADA_COUNT];
304 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
305 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetFrameSize, &g_para[0]);
306 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
307 }
308
309 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
310 void *result = nullptr;
311 pthread_join(tids[i], &result);
312 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
313 EXPECT_LT(INITIAL_VALUE, g_para[0].character.getframesize);
314 }
315 }
316
317 /**
318 * @tc.name AudiorenderGetVolumeReliability_001
319 * @tc.desc test GetFrameCount interface Reliability pass through pthread_create fun and adapterName is same.
320 * @tc.type: RELI
321 */
322 HWTEST_F(AudioHdiRenderReliabilityTest, AudioRenderGetFrameCountReliability_001, TestSize.Level1)
323 {
324 int32_t ret = -1;
325 g_para[0].render = render;
326 ASSERT_NE(nullptr, g_para[0].render);
327
328 ret = AudioRenderStartAndOneFrame(g_para[0].render);
329 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
330
331 pthread_t tids[PTHREAD_SAMEADA_COUNT];
332 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
333 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetFrameCount, &g_para[0]);
334 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
335 }
336
337 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
338 void *result = nullptr;
339 pthread_join(tids[i], &result);
340 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
341 EXPECT_LT(INITIAL_VALUE, g_para[0].character.getframecount);
342 }
343 g_para[0].render->control.Stop(g_para[0].render);
344 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
345 }
346
347 /**
348 * @tc.name AudiorenderGetVolumeReliability_001
349 * @tc.desc test GetCurrentChannelId interface Reliability pass through pthread_create fun and adapterName is same.
350 * @tc.type: RELI
351 */
352 HWTEST_F(AudioHdiRenderReliabilityTest, AudioRenderGetCurrentChannelIdReliability_001, TestSize.Level1)
353 {
354 int32_t ret = -1;
355 uint32_t channelIdValue = 2;
356 g_para[0].render = render;
357 ASSERT_NE(nullptr, g_para[0].render);
358 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
359 pthread_t tids[PTHREAD_SAMEADA_COUNT];
360 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
361 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
362 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
363 arrpara[i].character.getcurrentchannelId = 0;
364 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetCurrentChannelId, &arrpara[i]);
365 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
366 }
367
368 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
369 void *result = nullptr;
370 pthread_join(tids[i], &result);
371 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
372 EXPECT_EQ(channelIdValue, arrpara[i].character.getcurrentchannelId);
373 }
374 }
375
376 /**
377 * @tc.name AudiorenderSetMuteReliability_001
378 * @tc.desc test AudioRenderSetMute interface Reliability pass through pthread_create fun and adapterName is same.
379 * @tc.type: RELI
380 */
381 HWTEST_F(AudioHdiRenderReliabilityTest, AudiorenderSetMuteReliability_001, TestSize.Level1)
382 {
383 int32_t ret = -1;
384 g_para[0].render = render;
385 ASSERT_NE(nullptr, g_para[0].render);
386 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
387
388 pthread_t tids[PTHREAD_SAMEADA_COUNT];
389 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
390 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
391 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
392 ret = arrpara[i].render->volume.GetMute(arrpara[i].render, &(arrpara[i].character.getmute));
393 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
394 if (arrpara[i].character.getmute == false) {
395 arrpara[i].character.setmute = true;
396 } else {
397 arrpara[i].character.setmute = false;
398 }
399 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetMute, &arrpara[i]);
400 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
401 }
402
403 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
404 void *result = nullptr;
405 pthread_join(tids[i], &result);
406 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
407 }
408 }
409
410 /**
411 * @tc.name AudiorenderGetMuteReliability_001
412 * @tc.desc test AudioRenderGetMute interface Reliability pass through pthread_create fun and adapterName is same.
413 * @tc.type: RELI
414 */
415 HWTEST_F(AudioHdiRenderReliabilityTest, AudiorenderGetMuteReliability_001, TestSize.Level1)
416 {
417 int32_t ret = -1;
418 g_para[0].render = render;
419 ASSERT_NE(nullptr, g_para[0].render);
420 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
421
422 pthread_t tids[PTHREAD_SAMEADA_COUNT];
423 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
424 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
425 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
426 ret = arrpara[i].render->volume.SetMute(arrpara[i].render, false);
427 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
428 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetMute, &arrpara[i]);
429 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
430 }
431
432 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
433 void *result = nullptr;
434 pthread_join(tids[i], &result);
435 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
436 EXPECT_FALSE(arrpara[i].character.getmute);
437 }
438 }
439
440 /**
441 * @tc.name AudiorenderSetVolumeReliability_001
442 * @tc.desc test SetVolume interface Reliability pass through pthread_create fun and adapterName is same.
443 * @tc.type: RELI
444 */
445 HWTEST_F(AudioHdiRenderReliabilityTest, AudiorenderSetVolumeReliability_001, TestSize.Level1)
446 {
447 int32_t ret = -1;
448 float volumeHighExpc = 0.70;
449 g_para[0].render = render;
450 ASSERT_NE(nullptr, g_para[0].render);
451 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
452
453 pthread_t tids[PTHREAD_SAMEADA_COUNT];
454 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
455 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
456 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
457 arrpara[i].character.setvolume = 0.70;
458 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetVolume, &arrpara[i]);
459 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
460 }
461
462 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
463 void *result = nullptr;
464 pthread_join(tids[i], &result);
465 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
466 ret = arrpara[i].render->volume.GetVolume(arrpara[i].render, &(arrpara[i].character.getvolume));
467 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
468 EXPECT_EQ(volumeHighExpc, arrpara[i].character.getvolume);
469 }
470 }
471
472 /**
473 * @tc.name AudiorenderGetVolumeReliability_001
474 * @tc.desc test GetVolume interface Reliability pass through pthread_create fun and adapterName is same.
475 * @tc.type: RELI
476 */
477 HWTEST_F(AudioHdiRenderReliabilityTest, AudiorenderGetVolumeReliability_001, TestSize.Level1)
478 {
479 int32_t ret = -1;
480 float volumeHighExpc = 0.7;
481 g_para[0].render = render;
482 ASSERT_NE(nullptr, g_para[0].render);
483 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
484
485 pthread_t tids[PTHREAD_SAMEADA_COUNT];
486 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
487 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
488 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
489 arrpara[i].character.setvolume = 0.7;
490 ret = arrpara[i].render->volume.SetVolume(arrpara[i].render, arrpara[i].character.setvolume);
491 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
492 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetVolume, &arrpara[i]);
493 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
494 }
495
496 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
497 void *result = nullptr;
498 pthread_join(tids[i], &result);
499 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
500 EXPECT_EQ(volumeHighExpc, arrpara[i].character.getvolume);
501 }
502 }
503
504 /**
505 * @tc.name AudioRenderSetSampleAttributesReliability_001
506 * @tc.desc test AudioRenderSetSampleAttributes interface Reliability pass through pthread_create fun and adapterName
507 is same.
508 * @tc.type: RELI
509 */
510 HWTEST_F(AudioHdiRenderReliabilityTest, AudioRenderSetSampleAttributesReliability_001, TestSize.Level1)
511 {
512 int32_t ret = -1;
513 uint32_t count = 2;
514 uint32_t rateExpc = 48000;
515 g_para[0].render = render;
516 ASSERT_NE(nullptr, g_para[0].render);
517 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
518 InitAttrs(g_para[0].attrs);
519 pthread_t tids[PTHREAD_SAMEADA_COUNT];
520 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
521 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
522 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
523 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetSampleAttributes, &arrpara[i]);
524 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
525 }
526
527 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
528 void *result = nullptr;
529 pthread_join(tids[i], &result);
530 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
531 ret = arrpara[i].render->attr.GetSampleAttributes(arrpara[i].render, &(arrpara[i].attrsValue));
532 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
533 EXPECT_EQ(AUDIO_IN_MEDIA, arrpara[i].attrsValue.type);
534 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, arrpara[i].attrsValue.format);
535 EXPECT_EQ(rateExpc, arrpara[i].attrsValue.sampleRate);
536 EXPECT_EQ(count, arrpara[i].attrsValue.channelCount);
537 }
538 }
539
540 /**
541 * @tc.name AudioRenderGetSampleAttributesReliability_001
542 * @tc.desc test AudioRenderGetSampleAttributes interface Reliability pass through pthread_create fun and adapterName
543 is same.
544 * @tc.type: RELI
545 */
546 HWTEST_F(AudioHdiRenderReliabilityTest, AudioRenderGetSampleAttributesReliability_001, TestSize.Level1)
547 {
548 int32_t ret = -1;
549 uint32_t count = 2;
550 uint32_t rateExpc = 48000;
551 g_para[0].render = render;
552 ASSERT_NE(nullptr, g_para[0].render);
553 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
554 InitAttrs(g_para[0].attrs);
555 ret = g_para[0].render->attr.SetSampleAttributes(g_para[0].render, &(g_para[0].attrs));
556 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
557 pthread_t tids[PTHREAD_SAMEADA_COUNT];
558 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
559 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
560 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
561 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetSampleAttributes, &arrpara[i]);
562 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
563 }
564
565 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
566 void *result = nullptr;
567 pthread_join(tids[i], &result);
568 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
569 EXPECT_EQ(AUDIO_IN_MEDIA, arrpara[i].attrsValue.type);
570 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, arrpara[i].attrsValue.format);
571 EXPECT_EQ(rateExpc, arrpara[i].attrsValue.sampleRate);
572 EXPECT_EQ(count, arrpara[i].attrsValue.channelCount);
573 }
574 }
575
576 /**
577 * @tc.name AudioRenderSelectSceneReliability_001
578 * @tc.desc test AudioRenderSelectScene interface Reliability pass through pthread_create fun and adapterName is same.
579 * @tc.type: RELI
580 */
581 HWTEST_F(AudioHdiRenderReliabilityTest, AudioRenderSelectSceneReliability_001, TestSize.Level1)
582 {
583 int32_t ret = -1;
584 g_para[0].render = render;
585 ASSERT_NE(nullptr, g_para[0].render);
586 pthread_t tids[PTHREAD_SAMEADA_COUNT];
587 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
588 g_para[0].scenes.scene.id = 0;
589 g_para[0].scenes.desc.pins = PIN_OUT_SPEAKER;
590 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSelectScene, &g_para[0]);
591 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
592 }
593
594 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
595 void *result = nullptr;
596 pthread_join(tids[i], &result);
597 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
598 }
599 }
600
601 /**
602 * @tc.name AudioRenderCheckSceneCapabilityReliability_001
603 * @tc.desc test AudioRenderCheckSceneCapability interface Reliability pass through pthread_create fun and adapterName
604 is same.
605 * @tc.type: RELI
606 */
607 HWTEST_F(AudioHdiRenderReliabilityTest, AudioRenderCheckSceneCapabilityReliability_001, TestSize.Level1)
608 {
609 int32_t ret = -1;
610 g_para[0].render = render;
611 ASSERT_NE(nullptr, g_para[0].render);
612
613 pthread_t tids[PTHREAD_SAMEADA_COUNT];
614 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
615 g_para[0].scenes.scene.id = 0;
616 g_para[0].scenes.desc.pins = PIN_OUT_SPEAKER;
617 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderCheckSceneCapability, &g_para[0]);
618 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
619 }
620
621 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
622 void *result = nullptr;
623 pthread_join(tids[i], &result);
624 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
625 }
626 }
627
628 /**
629 * @tc.name AudioRenderSetGainReliability_001
630 * @tc.desc test AudioRenderSetGain interface Reliability pass through pthread_create fun and adapterName is same.
631 * @tc.type: RELI
632 */
633 HWTEST_F(AudioHdiRenderReliabilityTest, AudioRenderSetGainReliability_001, TestSize.Level1)
634 {
635 int32_t ret = -1;
636 g_para[0].render = render;
637 ASSERT_NE(nullptr, g_para[0].render);
638
639 pthread_t tids[PTHREAD_SAMEADA_COUNT];
640 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
641 g_para[0].character.setgain = 5;
642 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetGain, &g_para[0]);
643 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
644 }
645 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
646 void *result = nullptr;
647 pthread_join(tids[i], &result);
648 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
649 EXPECT_LT(GAIN_MIN, g_para[0].character.setgain);
650 }
651 }
652
653 /**
654 * @tc.name AudioRenderGetGainReliability_001
655 * @tc.desc test GetGain interface Reliability pass through pthread_create fun and adapterName is same.
656 * @tc.type: RELI
657 */
658 HWTEST_F(AudioHdiRenderReliabilityTest, AudioRenderGetGainReliability_001, TestSize.Level1)
659 {
660 int32_t ret = -1;
661 g_para[0].render = render;
662 ASSERT_NE(nullptr, g_para[0].render);
663 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
664
665 pthread_t tids[PTHREAD_SAMEADA_COUNT];
666 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
667 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
668 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
669 arrpara[i].character.setgain = 7;
670 ret = arrpara[i].render->volume.SetGain(arrpara[i].render, arrpara[i].character.setgain);
671 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
672 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetGain, &arrpara[i]);
673 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
674 }
675 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
676 void *result = nullptr;
677 pthread_join(tids[i], &result);
678 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
679 EXPECT_LT(GAIN_MIN, arrpara[i].character.setgain);
680 }
681 }
682
683 /**
684 * @tc.name AudioRenderGetGainThresholdReliability_001
685 * @tc.desc test GetGainThreshold interface Reliability pass through pthread_create fun and adapterName is same.
686 * @tc.type: RELI
687 */
688 HWTEST_F(AudioHdiRenderReliabilityTest, AudioRenderGetGainThresholdReliability_001, TestSize.Level1)
689 {
690 int32_t ret = -1;
691 g_para[0].render = render;
692 ASSERT_NE(nullptr, g_para[0].render);
693 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
694
695 pthread_t tids[PTHREAD_SAMEADA_COUNT];
696 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
697 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
698 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
699 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetGainThreshold, &arrpara[i]);
700 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
701 }
702 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
703 void *result = nullptr;
704 pthread_join(tids[i], &result);
705 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
706 EXPECT_EQ(0, arrpara[i].character.gainthresholdmin);
707 EXPECT_EQ(15, arrpara[i].character.gainthresholdmax);
708 }
709 }
710
711 /**
712 * @tc.name AudioRenderSetChannelModeReliability_001
713 * @tc.desc test SetChannelMode interface Reliability pass through pthread_create fun and adapterName is same.
714 * @tc.type: RELI
715 */
716 HWTEST_F(AudioHdiRenderReliabilityTest, AudioRenderSetChannelModeReliability_001, TestSize.Level1)
717 {
718 int32_t ret = -1;
719 g_para[0].render = render;
720 ASSERT_NE(nullptr, g_para[0].render);
721 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
722
723 pthread_t tids[PTHREAD_SAMEADA_COUNT];
724 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
725 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
726 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
727 arrpara[i].character.setmode = AUDIO_CHANNEL_NORMAL;
728 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetChannelMode, &arrpara[i]);
729 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
730 }
731 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
732 void *result = nullptr;
733 pthread_join(tids[i], &result);
734 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
735 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, arrpara[i].character.getmode);
736 }
737 }
738
739 /**
740 * @tc.name AudioRenderGetChannelModeReliability_001
741 * @tc.desc test GetChannelMode interface Reliability pass through pthread_create fun and adapterName is same.
742 * @tc.type: RELI
743 */
744 HWTEST_F(AudioHdiRenderReliabilityTest, AudioRenderGetChannelModeReliability_001, TestSize.Level1)
745 {
746 int32_t ret = -1;
747 g_para[0].render = render;
748 ASSERT_NE(nullptr, g_para[0].render);
749 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
750
751 pthread_t tids[PTHREAD_SAMEADA_COUNT];
752 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
753 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
754 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
755 arrpara[i].character.setmode = AUDIO_CHANNEL_NORMAL;
756 ret = arrpara[i].render->SetChannelMode(arrpara[i].render, arrpara[i].character.setmode);
757 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
758 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderSetChannelMode, &arrpara[i]);
759 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
760 }
761 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
762 void *result = nullptr;
763 pthread_join(tids[i], &result);
764 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
765 EXPECT_EQ(AUDIO_CHANNEL_NORMAL, arrpara[i].character.getmode);
766 }
767 }
768
769 /**
770 * @tc.name AudioRenderRenderGetLatencyReliability_001
771 * @tc.desc test GetLatency interface Reliability pass through pthread_create fun and adapterName is same.
772 * @tc.type: RELI
773 */
774 HWTEST_F(AudioHdiRenderReliabilityTest, AudioRenderRenderGetLatencyReliability_001, TestSize.Level1)
775 {
776 int32_t ret = -1;
777 uint32_t expectLatency = 0;
778 g_para[0].render = render;
779 ASSERT_NE(nullptr, g_para[0].render);
780 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
781 pthread_t tids[PTHREAD_SAMEADA_COUNT];
782 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
783 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
784 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
785 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetLatency, &arrpara[i]);
786 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
787 }
788 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
789 void *result = nullptr;
790 pthread_join(tids[i], &result);
791 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
792 EXPECT_LT(expectLatency, arrpara[i].character.latencyTime);
793 }
794 }
795 }
796