1 /*
2 * Copyright (c) 2022 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_opensles_unit_test.h"
17
18 using namespace std;
19 using namespace testing::ext;
20
21 namespace OHOS {
22 namespace AudioStandard {
23 namespace {
24 const char *AUDIORENDER_TEST_FILE_PATH = "/data/test_44100_2.wav";
25 const int64_t PERFORMANCE_TEST_TIME = 10;
26 const int64_t USEC_TIMES = 1000000000;
27 const int64_t EXPECT_TIME = 1000000000;
28 FILE *wavFile_;
29 wav_hdr wavHeader_;
30 SLObjectItf engineObject_;
31 SLObjectItf outputMixObject_;
32 SLPlayItf playItf_;
33 SLVolumeItf volumeItf_;
34 SLOHBufferQueueItf bufferQueueItf_;
35 SLObjectItf pcmPlayerObject_;
36 SLEngineItf engineEngine_;
37 } // namespace
38
BuqqerQueueCallback(SLOHBufferQueueItf bufferQueueItf,void * pContext,SLuint32 size)39 static void BuqqerQueueCallback (SLOHBufferQueueItf bufferQueueItf, void *pContext, SLuint32 size)
40 {
41 FILE *wavFile = (FILE *)pContext;
42 if (!feof(wavFile)) {
43 SLuint8 *buffer = nullptr;
44 SLuint32 pSize = 0;
45 (*bufferQueueItf)->GetBuffer(bufferQueueItf, &buffer, pSize);
46 if (buffer != nullptr) {
47 fread(buffer, 1, size, wavFile);
48 (*bufferQueueItf)->Enqueue(bufferQueueItf, buffer, size);
49 }
50 }
51 return;
52 }
53
SetUpTestCase(void)54 void AudioOpenslesUnitTest::SetUpTestCase(void) { }
55
TearDownTestCase(void)56 void AudioOpenslesUnitTest::TearDownTestCase(void) { }
57
SetUp(void)58 void AudioOpenslesUnitTest::SetUp(void) { }
59
TearDown(void)60 void AudioOpenslesUnitTest::TearDown(void) { }
61
62 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateEngine_001, TestSize.Level0)
63 {
64 SLresult result = slCreateEngine(&engineObject_, 0, nullptr, 0, nullptr, nullptr);
65 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
66 }
67
68 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateEngine_002, TestSize.Level0)
69 {
70 SLresult result = (*engineObject_)->Realize(engineObject_, SL_BOOLEAN_FALSE);
71 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
72 }
73
74 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateEngine_003, TestSize.Level0)
75 {
76 SLresult result = (*engineObject_)->GetInterface(engineObject_, SL_IID_ENGINE, &engineEngine_);
77 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
78 }
79
80 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateOutputMix_001, TestSize.Level0)
81 {
82 SLresult result = (*engineEngine_)->CreateOutputMix(engineEngine_, &outputMixObject_, 0, nullptr, nullptr);
83 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
84 }
85
86 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateOutputMix_002, TestSize.Level0)
87 {
88 SLresult result = (*outputMixObject_)->Realize(outputMixObject_, SL_BOOLEAN_FALSE);
89 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
90 }
91
92 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_Realize_001, TestSize.Level1)
93 {
94 SLresult result = (*outputMixObject_)->Realize(nullptr, SL_BOOLEAN_FALSE);
95 EXPECT_TRUE(result == SL_RESULT_PARAMETER_INVALID);
96 }
97
98 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_Resume_001, TestSize.Level1)
99 {
100 SLresult result = (*outputMixObject_)->Resume(outputMixObject_, SL_BOOLEAN_FALSE);
101 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
102 }
103
104 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetState_001, TestSize.Level1)
105 {
106 SLresult result = (*outputMixObject_)->GetState(nullptr, nullptr);
107 EXPECT_TRUE(result == SL_RESULT_PARAMETER_INVALID);
108 }
109
110 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetState_002, TestSize.Level1)
111 {
112 SLuint32 state;
113 SLresult result = (*outputMixObject_)->GetState(outputMixObject_, &state);
114 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
115 }
116
117 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_RegisterCallback_001, TestSize.Level1)
118 {
119 SLresult result = (*outputMixObject_)->RegisterCallback(outputMixObject_, nullptr, nullptr);
120 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
121 }
122
123 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_AbortAsyncOperation_001, TestSize.Level1)
124 {
125 (*engineObject_)->AbortAsyncOperation(outputMixObject_);
126 }
127
128 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateAudioPlayer_001, TestSize.Level0)
129 {
130 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
131 if (wavFile_ == nullptr) {
132 AUDIO_INFO_LOG("CreateAudioPlayer_001: Unable to open wave file");
133 }
134 size_t headerSize = sizeof(wav_hdr);
135 fread(&wavHeader_, 1, headerSize, wavFile_);
136
137 SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject_};
138 SLDataSink slSink = {&slOutputMix, nullptr};
139 SLDataLocator_BufferQueue slBufferQueue = {
140 SL_DATALOCATOR_BUFFERQUEUE,
141 0
142 };
143 SLDataFormat_PCM pcmFormat = {
144 SL_DATAFORMAT_PCM,
145 wavHeader_.NumOfChan,
146 wavHeader_.SamplesPerSec * 1000,
147 wavHeader_.bitsPerSample,
148 0,
149 0,
150 0
151 };
152 SLDataSource slSource = {&slBufferQueue, &pcmFormat};
153 SLresult result = (*engineEngine_)->CreateAudioPlayer(engineEngine_, &pcmPlayerObject_,
154 &slSource, &slSink, 0, nullptr, nullptr);
155 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
156 }
157
158 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateAudioPlayerAdapter_001, TestSize.Level1)
159 {
160 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
161 if (wavFile_ == nullptr) {
162 AUDIO_INFO_LOG("CreateAudioPlayerAdapter_001: Unable to open wave file");
163 }
164 size_t headerSize = sizeof(wav_hdr);
165 fread(&wavHeader_, 1, headerSize, wavFile_);
166 wavHeader_.NumOfChan = 1;
167 wavHeader_.SamplesPerSec = 8000;
168 wavHeader_.bitsPerSample = 8;
169 SLDataLocator_BufferQueue slBufferQueue = {
170 SL_DATALOCATOR_BUFFERQUEUE,
171 0
172 };
173 SLDataFormat_PCM pcmFormat = {
174 SL_DATAFORMAT_PCM,
175 wavHeader_.NumOfChan,
176 wavHeader_.SamplesPerSec * 1000,
177 wavHeader_.bitsPerSample,
178 0,
179 0,
180 0
181 };
182 SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject_};
183 SLDataSink slSink = {&slOutputMix, nullptr};
184 SLDataSource slSource = {&slBufferQueue, &pcmFormat};
185 SLresult result = (*engineEngine_)->CreateAudioPlayer(engineEngine_, &pcmPlayerObject_, &slSource,
186 &slSink, 0, nullptr, nullptr);
187 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
188 }
189
190 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateAudioPlayerAdapter_002, TestSize.Level1)
191 {
192 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
193 if (wavFile_ == nullptr) {
194 AUDIO_INFO_LOG("CreateAudioPlayerAdapter_002: Unable to open wave file");
195 }
196 size_t headerSize = sizeof(wav_hdr);
197 fread(&wavHeader_, 1, headerSize, wavFile_);
198 wavHeader_.NumOfChan = 2;
199 wavHeader_.SamplesPerSec = 11025;
200 wavHeader_.bitsPerSample = 16;
201 SLDataLocator_BufferQueue slBufferQueue = {
202 SL_DATALOCATOR_BUFFERQUEUE,
203 0
204 };
205 SLDataFormat_PCM pcmFormat = {
206 SL_DATAFORMAT_PCM,
207 wavHeader_.NumOfChan,
208 wavHeader_.SamplesPerSec * 1000,
209 wavHeader_.bitsPerSample,
210 0,
211 0,
212 0
213 };
214 SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject_};
215 SLDataSink slSink = {&slOutputMix, nullptr};
216 SLDataSource slSource = {&slBufferQueue, &pcmFormat};
217 SLresult result = (*engineEngine_)->CreateAudioPlayer(engineEngine_, &pcmPlayerObject_, &slSource,
218 &slSink, 0, nullptr, nullptr);
219 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
220 }
221
222 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateAudioPlayerAdapter_003, TestSize.Level1)
223 {
224 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
225 if (wavFile_ == nullptr) {
226 AUDIO_INFO_LOG("CreateAudioPlayerAdapter_003: Unable to open wave file");
227 }
228 size_t headerSize = sizeof(wav_hdr);
229 fread(&wavHeader_, 1, headerSize, wavFile_);
230 wavHeader_.NumOfChan = 3;
231 wavHeader_.SamplesPerSec = 12000;
232 SLDataLocator_BufferQueue slBufferQueue = {
233 SL_DATALOCATOR_BUFFERQUEUE,
234 0
235 };
236 SLDataFormat_PCM pcmFormat = {
237 SL_DATAFORMAT_PCM,
238 wavHeader_.NumOfChan,
239 wavHeader_.SamplesPerSec * 1000,
240 wavHeader_.bitsPerSample,
241 0,
242 0,
243 0
244 };
245 SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject_};
246 SLDataSink slSink = {&slOutputMix, nullptr};
247 SLDataSource slSource = {&slBufferQueue, &pcmFormat};
248 SLresult result = (*engineEngine_)->CreateAudioPlayer(engineEngine_, &pcmPlayerObject_, &slSource,
249 &slSink, 0, nullptr, nullptr);
250 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
251 }
252
253 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateAudioPlayerAdapter_004, TestSize.Level1)
254 {
255 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
256 if (wavFile_ == nullptr) {
257 AUDIO_INFO_LOG("CreateAudioPlayerAdapter_004: Unable to open wave file");
258 }
259 size_t headerSize = sizeof(wav_hdr);
260 fread(&wavHeader_, 1, headerSize, wavFile_);
261 wavHeader_.NumOfChan = 4;
262 wavHeader_.SamplesPerSec = 16000;
263 SLDataLocator_BufferQueue slBufferQueue = {
264 SL_DATALOCATOR_BUFFERQUEUE,
265 0
266 };
267 SLDataFormat_PCM pcmFormat = {
268 SL_DATAFORMAT_PCM,
269 wavHeader_.NumOfChan,
270 wavHeader_.SamplesPerSec * 1000,
271 wavHeader_.bitsPerSample,
272 0,
273 0,
274 0
275 };
276 SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject_};
277 SLDataSink slSink = {&slOutputMix, nullptr};
278 SLDataSource slSource = {&slBufferQueue, &pcmFormat};
279 SLresult result = (*engineEngine_)->CreateAudioPlayer(engineEngine_, &pcmPlayerObject_, &slSource,
280 &slSink, 0, nullptr, nullptr);
281 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
282 }
283
284 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateAudioPlayerAdapter_005, TestSize.Level1)
285 {
286 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
287 if (wavFile_ == nullptr) {
288 AUDIO_INFO_LOG("CreateAudioPlayerAdapter_005: Unable to open wave file");
289 }
290 size_t headerSize = sizeof(wav_hdr);
291 fread(&wavHeader_, 1, headerSize, wavFile_);
292 wavHeader_.SamplesPerSec = 22050;
293 SLDataLocator_BufferQueue slBufferQueue = {
294 SL_DATALOCATOR_BUFFERQUEUE,
295 0
296 };
297 SLDataFormat_PCM pcmFormat = {
298 SL_DATAFORMAT_PCM,
299 wavHeader_.NumOfChan,
300 wavHeader_.SamplesPerSec * 1000,
301 wavHeader_.bitsPerSample,
302 0,
303 0,
304 0
305 };
306 SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject_};
307 SLDataSink slSink = {&slOutputMix, nullptr};
308 SLDataSource slSource = {&slBufferQueue, &pcmFormat};
309 SLresult result = (*engineEngine_)->CreateAudioPlayer(engineEngine_, &pcmPlayerObject_, &slSource,
310 &slSink, 0, nullptr, nullptr);
311 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
312 }
313
314 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateAudioPlayerAdapter_006, TestSize.Level1)
315 {
316 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
317 if (wavFile_ == nullptr) {
318 AUDIO_INFO_LOG("CreateAudioPlayerAdapter_006: Unable to open wave file");
319 }
320 size_t headerSize = sizeof(wav_hdr);
321 fread(&wavHeader_, 1, headerSize, wavFile_);
322 wavHeader_.SamplesPerSec = 24000;
323 SLDataLocator_BufferQueue slBufferQueue = {
324 SL_DATALOCATOR_BUFFERQUEUE,
325 0
326 };
327 SLDataFormat_PCM pcmFormat = {
328 SL_DATAFORMAT_PCM,
329 wavHeader_.NumOfChan,
330 wavHeader_.SamplesPerSec * 1000,
331 wavHeader_.bitsPerSample,
332 0,
333 0,
334 0
335 };
336 SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject_};
337 SLDataSink slSink = {&slOutputMix, nullptr};
338 SLDataSource slSource = {&slBufferQueue, &pcmFormat};
339 SLresult result = (*engineEngine_)->CreateAudioPlayer(engineEngine_, &pcmPlayerObject_, &slSource,
340 &slSink, 0, nullptr, nullptr);
341 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
342 }
343
344 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateAudioPlayerAdapter_007, TestSize.Level1)
345 {
346 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
347 if (wavFile_ == nullptr) {
348 AUDIO_INFO_LOG("CreateAudioPlayerAdapter_007: Unable to open wave file");
349 }
350 size_t headerSize = sizeof(wav_hdr);
351 fread(&wavHeader_, 1, headerSize, wavFile_);
352 wavHeader_.SamplesPerSec = 32000;
353 SLDataLocator_BufferQueue slBufferQueue = {
354 SL_DATALOCATOR_BUFFERQUEUE,
355 0
356 };
357 SLDataFormat_PCM pcmFormat = {
358 SL_DATAFORMAT_PCM,
359 wavHeader_.NumOfChan,
360 wavHeader_.SamplesPerSec * 1000,
361 wavHeader_.bitsPerSample,
362 0,
363 0,
364 0
365 };
366 SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject_};
367 SLDataSink slSink = {&slOutputMix, nullptr};
368 SLDataSource slSource = {&slBufferQueue, &pcmFormat};
369 SLresult result = (*engineEngine_)->CreateAudioPlayer(engineEngine_, &pcmPlayerObject_, &slSource,
370 &slSink, 0, nullptr, nullptr);
371 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
372 }
373
374 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateAudioPlayerAdapter_008, TestSize.Level1)
375 {
376 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
377 if (wavFile_ == nullptr) {
378 AUDIO_INFO_LOG("CreateAudioPlayerAdapter_008: Unable to open wave file");
379 }
380 size_t headerSize = sizeof(wav_hdr);
381 fread(&wavHeader_, 1, headerSize, wavFile_);
382 wavHeader_.SamplesPerSec = 44100;
383 SLDataLocator_BufferQueue slBufferQueue = {
384 SL_DATALOCATOR_BUFFERQUEUE,
385 0
386 };
387 SLDataFormat_PCM pcmFormat = {
388 SL_DATAFORMAT_PCM,
389 wavHeader_.NumOfChan,
390 wavHeader_.SamplesPerSec * 1000,
391 wavHeader_.bitsPerSample,
392 0,
393 0,
394 0
395 };
396 SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject_};
397 SLDataSink slSink = {&slOutputMix, nullptr};
398 SLDataSource slSource = {&slBufferQueue, &pcmFormat};
399 SLresult result = (*engineEngine_)->CreateAudioPlayer(engineEngine_, &pcmPlayerObject_, &slSource,
400 &slSink, 0, nullptr, nullptr);
401 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
402 }
403
404 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateAudioPlayerAdapter_009, TestSize.Level1)
405 {
406 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
407 if (wavFile_ == nullptr) {
408 AUDIO_INFO_LOG("CreateAudioPlayerAdapter_009: Unable to open wave file");
409 }
410 size_t headerSize = sizeof(wav_hdr);
411 fread(&wavHeader_, 1, headerSize, wavFile_);
412 wavHeader_.SamplesPerSec = 48000;
413 SLDataLocator_BufferQueue slBufferQueue = {
414 SL_DATALOCATOR_BUFFERQUEUE,
415 0
416 };
417 SLDataFormat_PCM pcmFormat = {
418 SL_DATAFORMAT_PCM,
419 wavHeader_.NumOfChan,
420 wavHeader_.SamplesPerSec * 1000,
421 wavHeader_.bitsPerSample,
422 0,
423 0,
424 0
425 };
426 SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject_};
427 SLDataSink slSink = {&slOutputMix, nullptr};
428 SLDataSource slSource = {&slBufferQueue, &pcmFormat};
429 SLresult result = (*engineEngine_)->CreateAudioPlayer(engineEngine_, &pcmPlayerObject_, &slSource,
430 &slSink, 0, nullptr, nullptr);
431 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
432 }
433
434 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateAudioPlayerAdapter_010, TestSize.Level1)
435 {
436 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
437 if (wavFile_ == nullptr) {
438 AUDIO_INFO_LOG("CreateAudioPlayerAdapter_010: Unable to open wave file");
439 }
440 size_t headerSize = sizeof(wav_hdr);
441 fread(&wavHeader_, 1, headerSize, wavFile_);
442 wavHeader_.SamplesPerSec = 64000;
443 SLDataLocator_BufferQueue slBufferQueue = {
444 SL_DATALOCATOR_BUFFERQUEUE,
445 0
446 };
447 SLDataFormat_PCM pcmFormat = {
448 SL_DATAFORMAT_PCM,
449 wavHeader_.NumOfChan,
450 wavHeader_.SamplesPerSec * 1000,
451 wavHeader_.bitsPerSample,
452 0,
453 0,
454 0
455 };
456 SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject_};
457 SLDataSink slSink = {&slOutputMix, nullptr};
458 SLDataSource slSource = {&slBufferQueue, &pcmFormat};
459 SLresult result = (*engineEngine_)->CreateAudioPlayer(engineEngine_, &pcmPlayerObject_, &slSource,
460 &slSink, 0, nullptr, nullptr);
461 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
462 }
463
464 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateAudioPlayerAdapter_011, TestSize.Level1)
465 {
466 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
467 if (wavFile_ == nullptr) {
468 AUDIO_INFO_LOG("CreateAudioPlayerAdapter_011: Unable to open wave file");
469 }
470 size_t headerSize = sizeof(wav_hdr);
471 fread(&wavHeader_, 1, headerSize, wavFile_);
472 wavHeader_.SamplesPerSec = 96000;
473 SLDataLocator_BufferQueue slBufferQueue = {
474 SL_DATALOCATOR_BUFFERQUEUE,
475 0
476 };
477 SLDataFormat_PCM pcmFormat = {
478 SL_DATAFORMAT_PCM,
479 wavHeader_.NumOfChan,
480 wavHeader_.SamplesPerSec * 1000,
481 wavHeader_.bitsPerSample,
482 0,
483 0,
484 0
485 };
486 SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject_};
487 SLDataSink slSink = {&slOutputMix, nullptr};
488 SLDataSource slSource = {&slBufferQueue, &pcmFormat};
489 SLresult result = (*engineEngine_)->CreateAudioPlayer(engineEngine_, &pcmPlayerObject_, &slSource,
490 &slSink, 0, nullptr, nullptr);
491 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
492 }
493
494 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetPlayStateAdapter_014, TestSize.Level1)
495 {
496 SLresult result = AudioPlayerAdapter::GetInstance()->SetPlayStateAdapter(-1, SL_PLAYSTATE_PLAYING);
497 EXPECT_TRUE(result == SL_RESULT_RESOURCE_ERROR);
498 }
499
500 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetPlayStateAdapter_001, TestSize.Level1)
501 {
502 SLresult result = AudioPlayerAdapter::GetInstance()->SetPlayStateAdapter(-1, SL_PLAYSTATE_PLAYING);
503 EXPECT_TRUE(result == SL_RESULT_RESOURCE_ERROR);
504 }
505
506 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetPlayStateAdapter_001, TestSize.Level1)
507 {
508 SLuint32 state = SL_PLAYSTATE_PAUSED;
509 SLresult result = AudioPlayerAdapter::GetInstance()->GetPlayStateAdapter(-1, &state);
510 EXPECT_TRUE(result == SL_RESULT_RESOURCE_ERROR);
511 }
512
513 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetCaptureStateAdapter_001, TestSize.Level1)
514 {
515 SLresult result = AudioCapturerAdapter::GetInstance()->SetCaptureStateAdapter(-1, SL_PLAYSTATE_PLAYING);
516 EXPECT_TRUE(result == SL_RESULT_RESOURCE_ERROR);
517 }
518
519 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetCaptureStateAdapter_001, TestSize.Level1)
520 {
521 SLuint32 state = SL_PLAYSTATE_PAUSED;
522 SLresult result = AudioCapturerAdapter::GetInstance()->GetCaptureStateAdapter(-1, &state);
523 EXPECT_TRUE(result == SL_RESULT_RESOURCE_ERROR);
524 }
525
526 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_EnqueueAdapter_001, TestSize.Level1)
527 {
528 SLresult result = AudioCapturerAdapter::GetInstance()->EnqueueAdapter(-1, nullptr, 0);
529 EXPECT_TRUE(result == SL_RESULT_RESOURCE_ERROR);
530 }
531
532 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_ClearAdapter_001, TestSize.Level1)
533 {
534 SLresult result = AudioCapturerAdapter::GetInstance()->ClearAdapter(-1);
535 EXPECT_TRUE(result == SL_RESULT_RESOURCE_ERROR);
536 }
537
538 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetStateAdapter_001, TestSize.Level1)
539 {
540 SLresult result = AudioCapturerAdapter::GetInstance()->GetStateAdapter(-1, nullptr);
541 EXPECT_TRUE(result == SL_RESULT_RESOURCE_ERROR);
542 }
543
544 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetBufferAdapter_001, TestSize.Level1)
545 {
546 SLresult result = AudioCapturerAdapter::GetInstance()->GetBufferAdapter(-1, nullptr, nullptr);
547 EXPECT_TRUE(result == SL_RESULT_RESOURCE_ERROR);
548 }
549
550 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateAudioPlayer_002, TestSize.Level0)
551 {
552 SLresult result = (*pcmPlayerObject_)->Realize(pcmPlayerObject_, SL_BOOLEAN_FALSE);
553 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
554 }
555
556 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateAudioPlayer_003, TestSize.Level0)
557 {
558 SLresult result = (*pcmPlayerObject_)->GetInterface(pcmPlayerObject_, SL_IID_PLAY, &playItf_);
559 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
560 }
561
562 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateAudioPlayer_004, TestSize.Level1)
563 {
564 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
565 if (wavFile_ == nullptr) {
566 AUDIO_INFO_LOG("CreateAudioPlayer_004: Unable to open wave file");
567 }
568 size_t headerSize = sizeof(wav_hdr);
569 fread(&wavHeader_, 1, headerSize, wavFile_);
570
571 SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject_};
572 SLDataSink slSink = {&slOutputMix, nullptr};
573 SLDataLocator_BufferQueue slBufferQueue = {
574 SL_DATALOCATOR_BUFFERQUEUE,
575 0
576 };
577 SLDataFormat_PCM pcmFormat = {
578 SL_DATAFORMAT_PCM,
579 wavHeader_.NumOfChan,
580 wavHeader_.SamplesPerSec * 1000,
581 wavHeader_.bitsPerSample,
582 0,
583 0,
584 0
585 };
586 SLDataSource slSource = {&slBufferQueue, &pcmFormat};
587 SLresult result = (*engineEngine_)->CreateAudioPlayer(engineEngine_, nullptr,
588 &slSource, &slSink, 0, nullptr, nullptr);
589 EXPECT_TRUE(result == SL_RESULT_PARAMETER_INVALID);
590 }
591
592 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetInterface_003, TestSize.Level1)
593 {
594 SLresult result = (*pcmPlayerObject_)->GetInterface(nullptr, SL_IID_PLAY, &playItf_);
595 EXPECT_TRUE(result == SL_RESULT_PARAMETER_INVALID);
596 }
597
598 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateLEDDevice_001, TestSize.Level1)
599 {
600 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
601 if (wavFile_ == nullptr) {
602 AUDIO_INFO_LOG("CreateLEDDevice_001: CreateLEDDevice Unable to open wave file");
603 }
604 size_t headerSize = sizeof(wav_hdr);
605 fread(&wavHeader_, 1, headerSize, wavFile_);
606
607 SLresult result = (*engineEngine_)->CreateLEDDevice(engineEngine_, nullptr, 0, 0, nullptr, nullptr);
608 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
609 }
610
611 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateVibraDevice_001, TestSize.Level1)
612 {
613 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
614 if (wavFile_ == nullptr) {
615 AUDIO_INFO_LOG("CreateVibraDevice_001: CreateVibraDevice Unable to open wave file");
616 }
617 size_t headerSize = sizeof(wav_hdr);
618 fread(&wavHeader_, 1, headerSize, wavFile_);
619
620 SLresult result = (*engineEngine_)->CreateVibraDevice(engineEngine_, nullptr, 0, 0, nullptr, nullptr);
621 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
622 }
623
624 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateMidiPlayer_001, TestSize.Level1)
625 {
626 SLresult result = (*engineEngine_)->CreateMidiPlayer(engineEngine_, nullptr, nullptr,
627 nullptr, nullptr, nullptr, nullptr, 0, nullptr, nullptr);
628 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
629 }
630
631 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateListener_001, TestSize.Level1)
632 {
633 SLresult result = (*engineEngine_)->CreateListener(engineEngine_, nullptr, 0, nullptr, nullptr);
634 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
635 }
636
637 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_Create3DGroup_001, TestSize.Level1)
638 {
639 SLresult result = (*engineEngine_)->Create3DGroup(engineEngine_, nullptr, 0, nullptr, nullptr);
640 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
641 }
642
643 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateMetadataExtractor_001, TestSize.Level1)
644 {
645 SLresult result = (*engineEngine_)->CreateMetadataExtractor(engineEngine_, nullptr, nullptr, 0, nullptr, nullptr);
646 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
647 }
648
649 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_CreateExtensionObject_001, TestSize.Level1)
650 {
651 SLresult result = (*engineEngine_)->CreateExtensionObject(engineEngine_, nullptr, nullptr, 0, 0, nullptr, nullptr);
652 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
653 }
654
655 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_QueryNumSupportedInterfaces_001, TestSize.Level1)
656 {
657 SLresult result = (*engineEngine_)->QueryNumSupportedInterfaces(engineEngine_, 0, nullptr);
658 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
659 }
660
661 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_QueryNumSupportedExtensions_001, TestSize.Level1)
662 {
663 SLresult result = (*engineEngine_)->QueryNumSupportedExtensions(engineEngine_, nullptr);
664 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
665 }
666
667 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_QuerySupportedInterfaces_001, TestSize.Level1)
668 {
669 SLresult result = (*engineEngine_)->QuerySupportedInterfaces(engineEngine_, 0, 0, nullptr);
670 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
671 }
672
673 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_QuerySupportedExtension_001, TestSize.Level1)
674 {
675 SLresult result = (*engineEngine_)->QuerySupportedExtension(engineEngine_, 0, nullptr, nullptr);
676 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
677 }
678
679 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_IsExtensionSupported_001, TestSize.Level1)
680 {
681 SLresult result = (*engineEngine_)->IsExtensionSupported(engineEngine_, nullptr, nullptr);
682 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
683 }
684
685 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetVoumeItf_001, TestSize.Level0)
686 {
687 SLresult result = (*pcmPlayerObject_)->GetInterface(pcmPlayerObject_, SL_IID_VOLUME, &volumeItf_);
688 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
689 }
690
691 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetVoume_001, TestSize.Level0)
692 {
693 SLmillibel level = 0;
694 SLresult result = (*volumeItf_)->GetVolumeLevel(volumeItf_, &level);
695 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
696 }
697
698 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetVoume_002, TestSize.Level0)
699 {
700 SLmillibel level = 0;
701 SLresult result = (*volumeItf_)->GetMaxVolumeLevel(volumeItf_, &level);
702 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
703 }
704
705 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetVoume_001, TestSize.Level0)
706 {
707 SLresult result = (*volumeItf_)->SetVolumeLevel(volumeItf_, 0);
708 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
709 }
710
711 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetVoume_002, TestSize.Level0)
712 {
713 SLmillibel level = 0;
714 (*volumeItf_)->GetMaxVolumeLevel(volumeItf_, &level);
715 SLresult result = (*volumeItf_)->SetVolumeLevel(volumeItf_, level);
716 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
717 }
718
719 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetBufferQueue_001, TestSize.Level0)
720 {
721 SLresult result = (*pcmPlayerObject_)->GetInterface(pcmPlayerObject_, SL_IID_OH_BUFFERQUEUE, &bufferQueueItf_);
722 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
723 }
724
725 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_RegisterCallback_002, TestSize.Level0)
726 {
727 SLresult result = (*bufferQueueItf_)->RegisterCallback(bufferQueueItf_, BuqqerQueueCallback, wavFile_);
728 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
729 }
730
731 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetPlayState_001, TestSize.Level0)
732 {
733 SLresult result = (*playItf_)->SetPlayState(playItf_, SL_PLAYSTATE_PLAYING);
734 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
735 }
736
737 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetPlayState_002, TestSize.Level1)
738 {
739 SLresult result = (*playItf_)->SetPlayState(playItf_, -1);
740 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
741 }
742
743 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetDuration_001, TestSize.Level1)
744 {
745 SLresult result = (*playItf_)->GetDuration(playItf_, nullptr);
746 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
747 }
748
749 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_RegisterCallback_003, TestSize.Level1)
750 {
751 SLresult result = (*playItf_)->RegisterCallback(playItf_, nullptr, nullptr);
752 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
753 }
754
755 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetCallbackEventsMask_001, TestSize.Level1)
756 {
757 SLresult result = (*playItf_)->SetCallbackEventsMask(playItf_, 0);
758 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
759 }
760
761 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetCallbackEventsMask_001, TestSize.Level1)
762 {
763 SLresult result = (*playItf_)->GetCallbackEventsMask(playItf_, 0);
764 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
765 }
766
767 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetMarkerPosition_001, TestSize.Level1)
768 {
769 SLresult result = (*playItf_)->SetMarkerPosition(playItf_, 0);
770 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
771 }
772
773 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetMarkerPosition_001, TestSize.Level1)
774 {
775 SLresult result = (*playItf_)->GetMarkerPosition(playItf_, nullptr);
776 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
777 }
778
779 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetPositionUpdatePeriod_001, TestSize.Level1)
780 {
781 SLresult result = (*playItf_)->SetPositionUpdatePeriod(playItf_, 0);
782 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
783 }
784
785 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetPositionUpdatePeriod_001, TestSize.Level1)
786 {
787 SLresult result = (*playItf_)->GetPositionUpdatePeriod(playItf_, nullptr);
788 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
789 }
790
791 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_ClearMarkerPosition_001, TestSize.Level1)
792 {
793 SLresult result = (*playItf_)->ClearMarkerPosition(playItf_);
794 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
795 }
796
797 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetPosition_001, TestSize.Level1)
798 {
799 SLresult result = (*playItf_)->GetPosition(playItf_, nullptr);
800 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
801 }
802
803 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetPlayState_003, TestSize.Level0)
804 {
805 SLresult result = (*playItf_)->SetPlayState(playItf_, SL_PLAYSTATE_PAUSED);
806 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
807 }
808
809 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetPlayState_004, TestSize.Level0)
810 {
811 SLresult result = (*playItf_)->SetPlayState(playItf_, SL_PLAYSTATE_STOPPED);
812 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
813 }
814
815 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetPlayState_005, TestSize.Level1)
816 {
817 SLresult result = (*playItf_)->SetPlayState(nullptr, SL_PLAYSTATE_STOPPED);
818 EXPECT_TRUE(result == SL_RESULT_PARAMETER_INVALID);
819 }
820
821 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetPlayState_001, TestSize.Level1)
822 {
823 SLuint32 state = SL_PLAYSTATE_PAUSED;
824 SLresult result = (*playItf_)->GetPlayState(playItf_, &state);
825 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
826 }
827
828 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetPlayState_002, TestSize.Level1)
829 {
830 SLuint32 state = SL_PLAYSTATE_PLAYING;
831 SLresult result = (*playItf_)->GetPlayState(playItf_, &state);
832 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
833 }
834
835 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetPlayState_003, TestSize.Level1)
836 {
837 SLuint32 state = SL_PLAYSTATE_STOPPED;
838 SLresult result = (*playItf_)->GetPlayState(playItf_, &state);
839 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
840 }
841
842 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetPlayState_004, TestSize.Level1)
843 {
844 SLuint32 state = -1;
845 SLresult result = (*playItf_)->GetPlayState(playItf_, &state);
846 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
847 }
848
849 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetPlayState_005, TestSize.Level1)
850 {
851 SLuint32 state = -1;
852 SLresult result = (*playItf_)->GetPlayState(nullptr, &state);
853 EXPECT_TRUE(result == SL_RESULT_PARAMETER_INVALID);
854 }
855
856 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetPlayState_006, TestSize.Level1)
857 {
858 SLresult result = (*playItf_)->SetPlayState(playItf_, -1);
859 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
860 }
861
862
863 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_Destroy_001, TestSize.Level0)
864 {
865 (*pcmPlayerObject_)->Destroy(pcmPlayerObject_);
866 EXPECT_TRUE(true);
867 }
868
869 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_Destroy_002, TestSize.Level0)
870 {
871 (*engineObject_)->Destroy(engineObject_);
872 EXPECT_TRUE(true);
873 }
874
875 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_Destroy_003, TestSize.Level0)
876 {
877 (*outputMixObject_)->Destroy(outputMixObject_);
878 EXPECT_TRUE(true);
879 }
880
881 HWTEST(AudioOpenslesUnitTest, Prf_Audio_Opensles_CreateEngine_001, TestSize.Level0)
882 {
883 struct timespec tv1 = {0};
884 struct timespec tv2 = {0};
885 int64_t totalTime = 0;
886 for (int32_t i = 0; i < PERFORMANCE_TEST_TIME; i++) {
887 clock_gettime(CLOCK_REALTIME, &tv1);
888 slCreateEngine(&engineObject_, 0, nullptr, 0, nullptr, nullptr);
889 clock_gettime(CLOCK_REALTIME, &tv2);
890 totalTime += tv2.tv_sec * USEC_TIMES + tv2.tv_nsec - (tv1.tv_sec * USEC_TIMES + tv1.tv_nsec);
891 }
892 EXPECT_TRUE(totalTime <= EXPECT_TIME * PERFORMANCE_TEST_TIME);
893 }
894
895 HWTEST(AudioOpenslesUnitTest, Prf_Audio_Opensles_CreateEngine_002, TestSize.Level1)
896 {
897 struct timespec tv1 = {0};
898 struct timespec tv2 = {0};
899 int64_t totalTime = 0;
900 for (int32_t i = 0; i < PERFORMANCE_TEST_TIME; i++) {
901 clock_gettime(CLOCK_REALTIME, &tv1);
902 slCreateEngine(nullptr, 0, nullptr, 0, nullptr, nullptr);
903 clock_gettime(CLOCK_REALTIME, &tv2);
904 totalTime += tv2.tv_sec * USEC_TIMES + tv2.tv_nsec - (tv1.tv_sec * USEC_TIMES + tv1.tv_nsec);
905 }
906 EXPECT_TRUE(totalTime <= EXPECT_TIME * PERFORMANCE_TEST_TIME);
907 }
908
909 HWTEST(AudioOpenslesUnitTest, Prf_Audio_Opensles_DestoryEngine_001, TestSize.Level0)
910 {
911 struct timespec tv1 = {0};
912 struct timespec tv2 = {0};
913 int64_t totalTime = 0;
914 for (int32_t i = 0; i < PERFORMANCE_TEST_TIME; i++) {
915 engineObject_ = {};
916 slCreateEngine(&engineObject_, 0, nullptr, 0, nullptr, nullptr);
917 clock_gettime(CLOCK_REALTIME, &tv1);
918 (*engineObject_)->Destroy(engineObject_);
919 clock_gettime(CLOCK_REALTIME, &tv2);
920 totalTime += tv2.tv_sec * USEC_TIMES + tv2.tv_nsec - (tv1.tv_sec * USEC_TIMES + tv1.tv_nsec);
921 }
922 EXPECT_TRUE(totalTime <= EXPECT_TIME * PERFORMANCE_TEST_TIME);
923 }
924
925 HWTEST(AudioOpenslesUnitTest, Prf_Audio_Opensles_Realize_001, TestSize.Level0)
926 {
927 struct timespec tv1 = {0};
928 struct timespec tv2 = {0};
929 int64_t totalTime = 0;
930 engineObject_ = {};
931 slCreateEngine(&engineObject_, 0, nullptr, 0, nullptr, nullptr);
932 for (int32_t i = 0; i < PERFORMANCE_TEST_TIME; i++) {
933 clock_gettime(CLOCK_REALTIME, &tv1);
934 (*engineObject_)->Realize(engineObject_, SL_BOOLEAN_FALSE);
935 clock_gettime(CLOCK_REALTIME, &tv2);
936 totalTime += tv2.tv_sec * USEC_TIMES + tv2.tv_nsec - (tv1.tv_sec * USEC_TIMES + tv1.tv_nsec);
937 }
938 EXPECT_TRUE(totalTime <= EXPECT_TIME * PERFORMANCE_TEST_TIME);
939 }
940
941 HWTEST(AudioOpenslesUnitTest, Prf_Audio_Opensles_GetInterface_001, TestSize.Level0)
942 {
943 struct timespec tv1 = {0};
944 struct timespec tv2 = {0};
945 int64_t totalTime = 0;
946 for (int32_t i = 0; i < PERFORMANCE_TEST_TIME; i++) {
947 clock_gettime(CLOCK_REALTIME, &tv1);
948 (*engineObject_)->GetInterface(engineObject_, SL_IID_ENGINE, &engineEngine_);
949 clock_gettime(CLOCK_REALTIME, &tv2);
950 totalTime += tv2.tv_sec * USEC_TIMES + tv2.tv_nsec - (tv1.tv_sec * USEC_TIMES + tv1.tv_nsec);
951 }
952 EXPECT_TRUE(totalTime <= EXPECT_TIME * PERFORMANCE_TEST_TIME);
953 }
954
955 HWTEST(AudioOpenslesUnitTest, Prf_Audio_Opensles_CreateOutputMix_001, TestSize.Level0)
956 {
957 struct timespec tv1 = {0};
958 struct timespec tv2 = {0};
959 int64_t totalTime = 0;
960 for (int32_t i = 0; i < PERFORMANCE_TEST_TIME; i++) {
961 clock_gettime(CLOCK_REALTIME, &tv1);
962 (*engineEngine_)->CreateOutputMix(engineEngine_, &outputMixObject_, 0, nullptr, nullptr);
963 clock_gettime(CLOCK_REALTIME, &tv2);
964 totalTime += tv2.tv_sec * USEC_TIMES + tv2.tv_nsec - (tv1.tv_sec * USEC_TIMES + tv1.tv_nsec);
965 }
966 EXPECT_TRUE(totalTime <= EXPECT_TIME * PERFORMANCE_TEST_TIME);
967 }
968
969 HWTEST(AudioOpenslesUnitTest, Prf_Audio_Opensles_CreateAudioPlayer_001, TestSize.Level0)
970 {
971 wavFile_ = fopen(AUDIORENDER_TEST_FILE_PATH, "rb");
972 if (wavFile_ == nullptr) {
973 AUDIO_INFO_LOG("CreateAudioPlayer_001: Unable to open wave file");
974 }
975 size_t headerSize = sizeof(wav_hdr);
976 fread(&wavHeader_, 1, headerSize, wavFile_);
977 SLDataLocator_OutputMix slOutputMix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject_};
978 SLDataSink slSink = {&slOutputMix, nullptr};
979 SLDataLocator_BufferQueue slBufferQueue = {
980 SL_DATALOCATOR_BUFFERQUEUE,
981 0
982 };
983 SLDataFormat_PCM pcmFormat = {
984 SL_DATAFORMAT_PCM,
985 wavHeader_.NumOfChan,
986 wavHeader_.SamplesPerSec * 1000,
987 wavHeader_.bitsPerSample,
988 0,
989 0,
990 0
991 };
992 SLDataSource slSource = {&slBufferQueue, &pcmFormat};
993 struct timespec tv1 = {0};
994 struct timespec tv2 = {0};
995 int64_t totalTime = 0;
996 for (int32_t i = 0; i < PERFORMANCE_TEST_TIME; i++) {
997 clock_gettime(CLOCK_REALTIME, &tv1);
998 (*engineEngine_)->CreateAudioPlayer(engineEngine_, &pcmPlayerObject_, &slSource, &slSink, 0, nullptr, nullptr);
999 clock_gettime(CLOCK_REALTIME, &tv2);
1000 totalTime += tv2.tv_sec * USEC_TIMES + tv2.tv_nsec - (tv1.tv_sec * USEC_TIMES + tv1.tv_nsec);
1001 }
1002 EXPECT_TRUE(totalTime <= EXPECT_TIME * PERFORMANCE_TEST_TIME);
1003 }
1004
1005 HWTEST(AudioOpenslesUnitTest, Prf_Audio_Opensles_GetVolumeLevel_001, TestSize.Level0)
1006 {
1007 struct timespec tv1 = {0};
1008 struct timespec tv2 = {0};
1009 int64_t totalTime = 0;
1010 SLmillibel level = 0;
1011 (*pcmPlayerObject_)->GetInterface(pcmPlayerObject_, SL_IID_VOLUME, &volumeItf_);
1012 for (int32_t i = 0; i < PERFORMANCE_TEST_TIME; i++) {
1013 clock_gettime(CLOCK_REALTIME, &tv1);
1014 (*volumeItf_)->GetVolumeLevel(volumeItf_, &level);
1015 clock_gettime(CLOCK_REALTIME, &tv2);
1016 totalTime += tv2.tv_sec * USEC_TIMES + tv2.tv_nsec - (tv1.tv_sec * USEC_TIMES + tv1.tv_nsec);
1017 }
1018 EXPECT_TRUE(totalTime <= EXPECT_TIME * PERFORMANCE_TEST_TIME);
1019 }
1020
1021 HWTEST(AudioOpenslesUnitTest, Prf_Audio_Opensles_GetVolumeLevel_002, TestSize.Level1)
1022 {
1023 struct timespec tv1 = {0};
1024 struct timespec tv2 = {0};
1025 int64_t totalTime = 0;
1026 (*pcmPlayerObject_)->GetInterface(pcmPlayerObject_, SL_IID_VOLUME, &volumeItf_);
1027 for (int32_t i = 0; i < PERFORMANCE_TEST_TIME; i++) {
1028 clock_gettime(CLOCK_REALTIME, &tv1);
1029 (*volumeItf_)->GetVolumeLevel(volumeItf_, nullptr);
1030 clock_gettime(CLOCK_REALTIME, &tv2);
1031 totalTime += tv2.tv_sec * USEC_TIMES + tv2.tv_nsec - (tv1.tv_sec * USEC_TIMES + tv1.tv_nsec);
1032 }
1033 EXPECT_TRUE(totalTime <= EXPECT_TIME * PERFORMANCE_TEST_TIME);
1034 }
1035
1036 HWTEST(AudioOpenslesUnitTest, Prf_Audio_Opensles_GetMaxVolumeLevel_001, TestSize.Level0)
1037 {
1038 struct timespec tv1 = {0};
1039 struct timespec tv2 = {0};
1040 int64_t totalTime = 0;
1041 SLmillibel level = 0;
1042 for (int32_t i = 0; i < PERFORMANCE_TEST_TIME; i++) {
1043 clock_gettime(CLOCK_REALTIME, &tv1);
1044 (*volumeItf_)->GetMaxVolumeLevel(volumeItf_, &level);
1045 clock_gettime(CLOCK_REALTIME, &tv2);
1046 totalTime += tv2.tv_sec * USEC_TIMES + tv2.tv_nsec - (tv1.tv_sec * USEC_TIMES + tv1.tv_nsec);
1047 }
1048 EXPECT_TRUE(totalTime <= EXPECT_TIME * PERFORMANCE_TEST_TIME);
1049 }
1050
1051 HWTEST(AudioOpenslesUnitTest, Prf_Audio_Opensles_GetMaxVolumeLevel_002, TestSize.Level1)
1052 {
1053 struct timespec tv1 = {0};
1054 struct timespec tv2 = {0};
1055 int64_t totalTime = 0;
1056 for (int32_t i = 0; i < PERFORMANCE_TEST_TIME; i++) {
1057 clock_gettime(CLOCK_REALTIME, &tv1);
1058 (*volumeItf_)->GetMaxVolumeLevel(volumeItf_, nullptr);
1059 clock_gettime(CLOCK_REALTIME, &tv2);
1060 totalTime += tv2.tv_sec * USEC_TIMES + tv2.tv_nsec - (tv1.tv_sec * USEC_TIMES + tv1.tv_nsec);
1061 }
1062 EXPECT_TRUE(totalTime <= EXPECT_TIME * PERFORMANCE_TEST_TIME);
1063 }
1064
1065 HWTEST(AudioOpenslesUnitTest, Prf_Audio_Opensles_SetVolumeLevel_001, TestSize.Level0)
1066 {
1067 struct timespec tv1 = {0};
1068 struct timespec tv2 = {0};
1069 int64_t totalTime = 0;
1070 SLmillibel level = 0;
1071 for (int32_t i = 0; i < PERFORMANCE_TEST_TIME; i++) {
1072 clock_gettime(CLOCK_REALTIME, &tv1);
1073 (*volumeItf_)->SetVolumeLevel(volumeItf_, level);
1074 clock_gettime(CLOCK_REALTIME, &tv2);
1075 totalTime += tv2.tv_sec * USEC_TIMES + tv2.tv_nsec - (tv1.tv_sec * USEC_TIMES + tv1.tv_nsec);
1076 }
1077 EXPECT_TRUE(totalTime <= EXPECT_TIME * PERFORMANCE_TEST_TIME);
1078 }
1079
1080 HWTEST(AudioOpenslesUnitTest, Prf_Audio_Opensles_SetVolumeLevel_002, TestSize.Level1)
1081 {
1082 struct timespec tv1 = {0};
1083 struct timespec tv2 = {0};
1084 int64_t totalTime = 0;
1085 SLmillibel level = 0;
1086 for (int32_t i = 0; i < PERFORMANCE_TEST_TIME; i++) {
1087 clock_gettime(CLOCK_REALTIME, &tv1);
1088 (*volumeItf_)->SetVolumeLevel(nullptr, level);
1089 clock_gettime(CLOCK_REALTIME, &tv2);
1090 totalTime += tv2.tv_sec * USEC_TIMES + tv2.tv_nsec - (tv1.tv_sec * USEC_TIMES + tv1.tv_nsec);
1091 }
1092 EXPECT_TRUE(totalTime <= EXPECT_TIME * PERFORMANCE_TEST_TIME);
1093 }
1094
1095 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetMute_001, TestSize.Level1)
1096 {
1097 SLresult result = (*volumeItf_)->SetMute(volumeItf_, SL_BOOLEAN_FALSE);
1098 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
1099 }
1100
1101 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetMute_001, TestSize.Level1)
1102 {
1103 SLresult result = (*volumeItf_)->GetMute(volumeItf_, nullptr);
1104 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
1105 }
1106
1107 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_EnableStereoPosition_001, TestSize.Level1)
1108 {
1109 SLresult result = (*volumeItf_)->EnableStereoPosition(volumeItf_, SL_BOOLEAN_FALSE);
1110 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
1111 }
1112
1113 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_IsEnabledStereoPosition_001, TestSize.Level1)
1114 {
1115 SLresult result = (*volumeItf_)->IsEnabledStereoPosition(volumeItf_, nullptr);
1116 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
1117 }
1118
1119 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetStereoPosition_001, TestSize.Level1)
1120 {
1121 SLresult result = (*volumeItf_)->SetStereoPosition(volumeItf_, 0);
1122 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
1123 }
1124
1125 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetStereoPosition_001, TestSize.Level1)
1126 {
1127 SLresult result = (*volumeItf_)->GetStereoPosition(volumeItf_, nullptr);
1128 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
1129 }
1130
1131 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_GetPriority_001, TestSize.Level1)
1132 {
1133 SLresult result = (*engineObject_)->GetPriority(engineObject_, nullptr, nullptr);
1134 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
1135 }
1136
1137 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_SetPriority_001, TestSize.Level1)
1138 {
1139 SLresult result = (*engineObject_)->SetPriority(engineObject_, 0, SL_BOOLEAN_FALSE);
1140 EXPECT_TRUE(result == SL_RESULT_FEATURE_UNSUPPORTED);
1141 }
1142
1143 HWTEST(AudioOpenslesUnitTest, Audio_Opensles_Enqueue_001, TestSize.Level1)
1144 {
1145 if (!feof(wavFile_)) {
1146 SLuint8* buffer = nullptr;
1147 SLuint32 size = 0;
1148 SLresult result = (*bufferQueueItf_)->GetBuffer(bufferQueueItf_, &buffer, size);
1149 EXPECT_TRUE(result == SL_RESULT_SUCCESS);
1150 fread(buffer, 1, size, wavFile_);
1151 result = (*bufferQueueItf_)->Enqueue(nullptr, buffer, size);
1152 EXPECT_TRUE(result == SL_RESULT_PARAMETER_INVALID);
1153 }
1154 }
1155 } // namespace AudioStandard
1156 } // namespace OHOS
1157