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 OHOS::Audio;
23
24 namespace {
25 const int PTHREAD_SAMEADA_COUNT = 10;
26 const int PTHREAD_DIFFADA_COUNT = 1;
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 AudioHdiRenderControlReliabilityTest : 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 static int32_t RelGetAllAdapter(struct PrepareAudioPara& ptr);
43 static int32_t RelLoadAdapter(struct PrepareAudioPara& ptr);
44 static int32_t RelUnloadAdapter(struct PrepareAudioPara& ptr);
45 static int32_t RelAudioRenderStart(struct PrepareAudioPara& ptr);
46 static int32_t RelAudioRenderFrame(struct PrepareAudioPara& ptr);
47 static int32_t RelAudioRenderStop(struct PrepareAudioPara& ptr);
48 static int32_t RelAudioRenderProcedure(struct PrepareAudioPara& ptr);
49 static int32_t RelAudioRenderPause(struct PrepareAudioPara& ptr);
50 static int32_t RelAudioRenderResume(struct PrepareAudioPara& ptr);
51 static int32_t RelAudioRenderGetRenderPosition(struct PrepareAudioPara& ptr);
52 };
53
54 using THREAD_FUNC = void *(*)(void *);
55 TestAudioManager *AudioHdiRenderControlReliabilityTest::manager = nullptr;
56
SetUpTestCase(void)57 void AudioHdiRenderControlReliabilityTest::SetUpTestCase(void)
58 {
59 manager = GetAudioManagerFuncs();
60 ASSERT_NE(nullptr, manager);
61 }
62
TearDownTestCase(void)63 void AudioHdiRenderControlReliabilityTest::TearDownTestCase(void) {}
64
SetUp(void)65 void AudioHdiRenderControlReliabilityTest::SetUp(void) {}
66
TearDown(void)67 void AudioHdiRenderControlReliabilityTest::TearDown(void) {}
68
RelGetAllAdapter(struct PrepareAudioPara & ptr)69 int32_t AudioHdiRenderControlReliabilityTest::RelGetAllAdapter(struct PrepareAudioPara& ptr)
70 {
71 if (ptr.manager == nullptr) {
72 return AUDIO_HAL_ERR_INVALID_PARAM;
73 }
74 int size = 0;
75 g_testMutex.lock();
76 int32_t ret = ptr.manager->GetAllAdapters(ptr.manager, &ptr.descs, &size);
77 g_testMutex.unlock();
78 if (ret < 0) {
79 return ret;
80 }
81 if (ptr.descs == nullptr || size == 0) {
82 return AUDIO_HAL_ERR_INTERNAL;
83 }
84 int index = SwitchAdapter(ptr.descs, ptr.adapterName, ptr.portType, ptr.audioPort, size);
85 if (index < 0) {
86 return index;
87 }
88 ptr.desc = &ptr.descs[index];
89 if (ptr.desc == nullptr) {
90 return AUDIO_HAL_ERR_INVALID_PARAM;
91 }
92 return AUDIO_HAL_SUCCESS;
93 }
94
RelLoadAdapter(struct PrepareAudioPara & ptr)95 int32_t AudioHdiRenderControlReliabilityTest::RelLoadAdapter(struct PrepareAudioPara& ptr)
96 {
97 if (ptr.manager == nullptr) {
98 return AUDIO_HAL_ERR_INVALID_PARAM;
99 }
100 g_testMutex.lock();
101 int32_t ret = ptr.manager->LoadAdapter(ptr.manager, ptr.desc, &ptr.adapter);
102 g_testMutex.unlock();
103 if (ret < 0) {
104 return ret;
105 }
106
107 if (ptr.adapter == nullptr) {
108 return AUDIO_HAL_ERR_INTERNAL;
109 }
110 return ret;
111 }
112
RelAudioRenderStart(struct PrepareAudioPara & ptr)113 int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderStart(struct PrepareAudioPara& ptr)
114 {
115 if (ptr.render == nullptr) {
116 return AUDIO_HAL_ERR_INVALID_PARAM;
117 }
118 int32_t ret = -1;
119 g_testMutex.lock();
120 ret = ptr.render->control.Start((AudioHandle)(ptr.render));
121 g_testMutex.unlock();
122 return ret;
123 }
124
RelAudioRenderFrame(struct PrepareAudioPara & ptr)125 int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderFrame(struct PrepareAudioPara& ptr)
126 {
127 if (ptr.render == nullptr) {
128 return AUDIO_HAL_ERR_INVALID_PARAM;
129 }
130 int32_t ret = -1;
131 uint64_t requestBytes = 0;
132 uint64_t replyBytes = 0;
133 char *frame = nullptr;
134
135 ret = RenderFramePrepare(ptr.path, frame, requestBytes);
136 if (ret < 0) {
137 return ret;
138 }
139 g_testMutex.lock();
140 ret = ptr.render->RenderFrame(ptr.render, frame, requestBytes, &replyBytes);
141 g_testMutex.unlock();
142 if (frame != nullptr) {
143 free(frame);
144 frame = nullptr;
145 }
146 return ret;
147 }
148
RelAudioRenderStop(struct PrepareAudioPara & ptr)149 int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderStop(struct PrepareAudioPara& ptr)
150 {
151 if (ptr.render == nullptr) {
152 return AUDIO_HAL_ERR_INVALID_PARAM;
153 }
154 int32_t ret = -1;
155 g_testMutex.lock();
156 ret = ptr.render->control.Stop((AudioHandle)(ptr.render));
157 g_testMutex.unlock();
158 return ret;
159 }
160
RelAudioRenderPause(struct PrepareAudioPara & ptr)161 int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderPause(struct PrepareAudioPara& ptr)
162 {
163 if (ptr.render == nullptr) {
164 return AUDIO_HAL_ERR_INVALID_PARAM;
165 }
166 int32_t ret = -1;
167 g_testMutex.lock();
168 ret = ptr.render->control.Pause((AudioHandle)(ptr.render));
169 g_testMutex.unlock();
170 return ret;
171 }
172
RelAudioRenderResume(struct PrepareAudioPara & ptr)173 int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderResume(struct PrepareAudioPara& ptr)
174 {
175 if (ptr.render == nullptr) {
176 return AUDIO_HAL_ERR_INVALID_PARAM;
177 }
178 int32_t ret = -1;
179 g_testMutex.lock();
180 ret = ptr.render->control.Resume((AudioHandle)(ptr.render));
181 g_testMutex.unlock();
182 return ret;
183 }
184
RelAudioRenderProcedure(struct PrepareAudioPara & ptr)185 int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderProcedure(struct PrepareAudioPara& ptr)
186 {
187 int32_t ret = -1;
188 g_testMutex.lock();
189 ret = AudioCreateRender(ptr.manager, ptr.pins, ptr.adapterName, &ptr.adapter, &ptr.render);
190 g_testMutex.unlock();
191 if (ret < 0) {
192 return ret;
193 }
194 ret = AudioRenderStartAndOneFrame(ptr.render);
195 return ret;
196 }
197
RelAudioRenderGetRenderPosition(struct PrepareAudioPara & ptr)198 int32_t AudioHdiRenderControlReliabilityTest::RelAudioRenderGetRenderPosition(struct PrepareAudioPara& ptr)
199 {
200 if (ptr.render == nullptr) {
201 return AUDIO_HAL_ERR_INVALID_PARAM;
202 }
203 int32_t ret = -1;
204 g_testMutex.lock();
205 ret = ptr.render->GetRenderPosition(ptr.render, &(ptr.character.getframes), &(ptr.time));
206 g_testMutex.unlock();
207 return ret;
208 }
209
210 /**
211 * @tc.name AudioGetAllAdapterReliability_001
212 * @tc.desc test Reliability GetAllAdapters interface.
213 * @tc.type: RELI
214 */
215 HWTEST_F(AudioHdiRenderControlReliabilityTest, AudioGetAllAdapterReliability_001, TestSize.Level1)
216 {
217 int32_t ret = -1;
218 g_para[0].manager = manager;
219 ASSERT_NE(nullptr, g_para[0].manager);
220 pthread_t tids[PTHREAD_SAMEADA_COUNT];
221 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
222 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelGetAllAdapter, &g_para[0]);
223 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
224 }
225 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
226 void *result = nullptr;
227 pthread_join(tids[i], &result);
228 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
229 }
230 }
231
232 /**
233 * @tc.name AudioLoadlAdapterReliability_001
234 * @tc.desc test LoadAdapter interface Reliability pass through pthread_create fun and adapterName is same.
235 * @tc.type: RELI
236 */
237 HWTEST_F(AudioHdiRenderControlReliabilityTest, AudioLoadlAdapterReliability_001, TestSize.Level1)
238 {
239 int32_t ret = -1;
240 g_para[0].manager = manager;
241 ASSERT_NE(nullptr, g_para[0].manager);
242 pthread_t tids[PTHREAD_SAMEADA_COUNT];
243 ret = RelGetAllAdapter(g_para[0]);
244 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
245 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
246 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelLoadAdapter, &g_para[0]);
247 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
248 }
249 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
250 void *loadadapterresult = nullptr;
251 pthread_join(tids[i], &loadadapterresult);
252 ret = (intptr_t)loadadapterresult;
253 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
254 }
255 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
256 g_para[0].adapter = nullptr;
257 }
258
259 /**
260 * @tc.name AudioRenderStartReliability_001
261 * @tc.desc test AudioRenderStart interface Reliability pass through pthread_create fun and adapterName is same.
262 * @tc.type: RELI
263 */
264 HWTEST_F(AudioHdiRenderControlReliabilityTest, AudioRenderStartReliability_001, TestSize.Level1)
265 {
266 int32_t ret = -1;
267 int32_t failcount = 0;
268 int32_t succeedcount = 0;
269 g_para[0].manager = manager;
270 ASSERT_NE(nullptr, g_para[0].manager);
271 ret = AudioCreateRender(g_para[0].manager, g_para[0].pins, g_para[0].adapterName, &g_para[0].adapter,
272 &g_para[0].render);
273 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
274
275 pthread_t tids[PTHREAD_SAMEADA_COUNT];
276 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
277 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderStart, &g_para[0]);
278 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
279 }
280 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
281 void *renderStartResult = nullptr;
282 pthread_join(tids[i], &renderStartResult);
283 ret = (intptr_t)renderStartResult;
284 if (ret == 0) {
285 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
286 succeedcount = succeedcount + 1;
287 } else {
288 EXPECT_EQ(AUDIO_HAL_ERR_AO_BUSY, ret);
289 failcount = failcount + 1;
290 }
291 }
292 if (g_para[0].adapter != nullptr) {
293 ret = StopAudio(g_para[0]);
294 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
295 EXPECT_EQ(failcount, PTHREAD_SAMEADA_COUNT - 1);
296 EXPECT_EQ(succeedcount, 1);
297 g_para[0].render = nullptr;
298 }
299 }
300
301 /**
302 * @tc.name AudioRelAudioRenderFrameReliability_001
303 * @tc.desc test AudioRenderFrame iinterface Reliability pass through pthread_create fun and adapterName is same.
304 * @tc.type: RELI
305 */
306 HWTEST_F(AudioHdiRenderControlReliabilityTest, AudioRenderFrameReliability_001, TestSize.Level1)
307 {
308 g_para[0].manager = manager;
309 ASSERT_NE(nullptr, g_para[0].manager);
310 int32_t ret = -1;
311 ret = AudioCreateRender(g_para[0].manager, g_para[0].pins, g_para[0].adapterName, &g_para[0].adapter,
312 &g_para[0].render);
313 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
314 ret = RelAudioRenderStart(g_para[0]);
315 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
316 pthread_t tids[PTHREAD_SAMEADA_COUNT];
317 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
318 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderFrame, &g_para[0]);
319 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
320 }
321 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
322 void *result = nullptr;
323 pthread_join(tids[i], &result);
324 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
325 }
326 ret = StopAudio(g_para[0]);
327 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
328 g_para[0].render = nullptr;
329 }
330
331 /**
332 * @tc.name AudioRenderStopReliability_001
333 * @tc.desc test AudioRenderStop interface Reliability pass through pthread_create fun and adapterName is same.
334 * @tc.type: RELI
335 */
336 HWTEST_F(AudioHdiRenderControlReliabilityTest, AudioRenderStopReliability_001, TestSize.Level1)
337 {
338 int32_t ret = -1;
339 int32_t failcount = 0;
340 int32_t succeedcount = 0;
341 g_para[0].manager = manager;
342 ASSERT_NE(nullptr, g_para[0].manager);
343 ret = RelAudioRenderProcedure(g_para[0]);
344 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
345 pthread_t tids[PTHREAD_SAMEADA_COUNT];
346 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
347 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderStop, &g_para[0]);
348 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
349 }
350 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
351 void *renderStopResult = nullptr;
352 pthread_join(tids[i], &renderStopResult);
353 ret = (intptr_t)renderStopResult;
354 if (ret == 0) {
355 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
356 succeedcount = succeedcount + 1;
357 } else {
358 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
359 failcount = failcount + 1;
360 }
361 }
362 if (g_para[0].manager != nullptr && g_para[0].adapter != nullptr) {
363 g_para[0].adapter->DestroyRender(g_para[0].adapter, g_para[0].render);
364 g_para[0].manager->UnloadAdapter(g_para[0].manager, g_para[0].adapter);
365 EXPECT_EQ(failcount, PTHREAD_SAMEADA_COUNT - 1);
366 EXPECT_EQ(succeedcount, 1);
367 g_para[0].render = nullptr;
368 }
369 }
370
371 /**
372 * @tc.name AudioRenderPauseReliability_001
373 * @tc.desc test AudioRenderPause interface Reliability pass through pthread_create fun and adapterName is same.
374 * @tc.type: RELI
375 */
376 HWTEST_F(AudioHdiRenderControlReliabilityTest, AudioRenderPauseReliability_001, TestSize.Level1)
377 {
378 int32_t ret = -1;
379 int32_t failcount = 0;
380 g_para[0].manager = manager;
381 ASSERT_NE(nullptr, g_para[0].manager);
382 int32_t succeedcount = 0;
383
384 ret = RelAudioRenderProcedure(g_para[0]);
385 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
386
387 pthread_t tids[PTHREAD_SAMEADA_COUNT];
388 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
389 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderPause, &g_para[0]);
390 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
391 }
392
393 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
394 void *renderPauseResult = nullptr;
395 pthread_join(tids[i], &renderPauseResult);
396 ret = (intptr_t)renderPauseResult;
397 if (ret == 0) {
398 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
399 succeedcount = succeedcount + 1;
400 } else {
401 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
402 failcount = failcount + 1;
403 }
404 }
405 if (g_para[0].adapter != nullptr) {
406 ret = StopAudio(g_para[0]);
407 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
408 EXPECT_EQ(failcount, PTHREAD_SAMEADA_COUNT - 1);
409 EXPECT_EQ(succeedcount, 1);
410 g_para[0].render = nullptr;
411 }
412 }
413
414 /**
415 * @tc.name AudioRenderResumeReliability_001
416 * @tc.desc test RelAudioRenderResume interface Reliability pass through pthread_create fun and adapterName is same.
417 * @tc.type: RELI
418 */
419 HWTEST_F(AudioHdiRenderControlReliabilityTest, AudioRenderResumeReliability_001, TestSize.Level1)
420 {
421 int32_t ret = -1;
422 int32_t failcount = 0;
423 int32_t succeedcount = 0;
424 g_para[0].manager = manager;
425 ASSERT_NE(nullptr, g_para[0].manager);
426 ret = RelAudioRenderProcedure(g_para[0]);
427 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
428 ret = RelAudioRenderPause(g_para[0]);
429 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
430
431 pthread_t tids[PTHREAD_SAMEADA_COUNT];
432 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
433 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderResume, &g_para[0]);
434 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
435 }
436
437 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
438 void *renderResumeResult = nullptr;
439 pthread_join(tids[i], &renderResumeResult);
440 ret = (intptr_t)renderResumeResult;
441 if (ret == 0) {
442 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
443 succeedcount = succeedcount + 1;
444 } else {
445 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, ret);
446 failcount = failcount + 1;
447 }
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 AudiorenderGetVolumeReliability_001
458 * @tc.desc test GetRenderPosition interface Reliability pass through pthread_create fun and adapterName is same.
459 * @tc.type: RELI
460 */
461 HWTEST_F(AudioHdiRenderControlReliabilityTest, AudioRenderGetRenderPositionReliability_001,
462 TestSize.Level1)
463 {
464 int32_t ret = -1;
465 int64_t timeExp = 0;
466 g_para[0].manager = manager;
467 ASSERT_NE(nullptr, g_para[0].manager);
468 struct PrepareAudioPara arrpara[PTHREAD_SAMEADA_COUNT];
469 ret = RelAudioRenderProcedure(g_para[0]);
470 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
471
472 pthread_t tids[PTHREAD_SAMEADA_COUNT];
473 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
474 ret = memcpy_s(&arrpara[i], sizeof(PrepareAudioPara), &g_para[0], sizeof(PrepareAudioPara));
475 arrpara[i].time = {.tvSec = 0, .tvNSec = 0};
476 ret = pthread_create(&tids[i], NULL, (THREAD_FUNC)RelAudioRenderGetRenderPosition, &arrpara[i]);
477 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
478 }
479
480 for (int32_t i = 0; i < PTHREAD_SAMEADA_COUNT; ++i) {
481 void *result = nullptr;
482 pthread_join(tids[i], &result);
483 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
484 EXPECT_LT(INITIAL_VALUE, arrpara[i].character.getframes);
485 EXPECT_LT(timeExp, (arrpara[i].time.tvSec) * SECTONSEC + (arrpara[i].time.tvNSec));
486 }
487 if (g_para[0].adapter != nullptr) {
488 ret = StopAudio(g_para[0]);
489 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
490 g_para[0].render = nullptr;
491 }
492 }
493 }
494