1 /*
2 * Copyright (c) 2021-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_renderer_unit_test.h"
17
18 #include <chrono>
19 #include <thread>
20
21 #include "audio_errors.h"
22 #include "audio_info.h"
23 #include "audio_renderer.h"
24
25 using namespace std;
26 using namespace std::chrono;
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace AudioStandard {
31 namespace {
32 const string AUDIORENDER_TEST_FILE_PATH = "/data/test_44100_2.wav";
33 const int32_t VALUE_NEGATIVE = -1;
34 const int32_t VALUE_ZERO = 0;
35 const int32_t VALUE_HUNDRED = 100;
36 const int32_t VALUE_THOUSAND = 1000;
37 const int32_t RENDERER_FLAG = 0;
38 // Writing only 500 buffers of data for test
39 const int32_t WRITE_BUFFERS_COUNT = 500;
40 constexpr int32_t PAUSE_BUFFER_POSITION = 400000;
41 constexpr int32_t PAUSE_RENDER_TIME_SECONDS = 1;
42
43 constexpr uint64_t BUFFER_DURATION_FIVE = 5;
44 constexpr uint64_t BUFFER_DURATION_TEN = 10;
45 constexpr uint64_t BUFFER_DURATION_FIFTEEN = 15;
46 constexpr uint64_t BUFFER_DURATION_TWENTY = 20;
47 constexpr uint32_t PLAYBACK_DURATION = 2;
48
49 static size_t g_reqBufLen = 0;
50 } // namespace
51
SetUpTestCase(void)52 void AudioRendererUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)53 void AudioRendererUnitTest::TearDownTestCase(void) {}
SetUp(void)54 void AudioRendererUnitTest::SetUp(void) {}
TearDown(void)55 void AudioRendererUnitTest::TearDown(void) {}
56
OnWriteData(size_t length)57 void AudioRenderModeCallbackTest::OnWriteData(size_t length)
58 {
59 g_reqBufLen = length;
60 }
61
InitializeRenderer(unique_ptr<AudioRenderer> & audioRenderer)62 int32_t AudioRendererUnitTest::InitializeRenderer(unique_ptr<AudioRenderer> &audioRenderer)
63 {
64 AudioRendererParams rendererParams;
65 rendererParams.sampleFormat = SAMPLE_S16LE;
66 rendererParams.sampleRate = SAMPLE_RATE_44100;
67 rendererParams.channelCount = STEREO;
68 rendererParams.encodingType = ENCODING_PCM;
69
70 return audioRenderer->SetParams(rendererParams);
71 }
72
InitializeRendererOptions(AudioRendererOptions & rendererOptions)73 void AudioRendererUnitTest::InitializeRendererOptions(AudioRendererOptions &rendererOptions)
74 {
75 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
76 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
77 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
78 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
79 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
80 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
81 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
82
83 return;
84 }
85
StartRenderThread(AudioRenderer * audioRenderer,uint32_t limit)86 void StartRenderThread(AudioRenderer *audioRenderer, uint32_t limit)
87 {
88 int32_t ret = -1;
89 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
90 ASSERT_NE(nullptr, wavFile);
91
92 size_t bufferLen;
93 ret = audioRenderer->GetBufferSize(bufferLen);
94 EXPECT_EQ(SUCCESS, ret);
95
96 auto buffer = std::make_unique<uint8_t[]>(bufferLen);
97 ASSERT_NE(nullptr, buffer);
98
99 size_t bytesToWrite = 0;
100 int32_t bytesWritten = 0;
101 size_t minBytes = 4;
102 int32_t numBuffersToRender = WRITE_BUFFERS_COUNT;
103 auto start = chrono::system_clock::now();
104
105 while (numBuffersToRender) {
106 bytesToWrite = fread(buffer.get(), 1, bufferLen, wavFile);
107 bytesWritten = 0;
108 while ((static_cast<size_t>(bytesWritten) < bytesToWrite) &&
109 ((static_cast<size_t>(bytesToWrite) - bytesWritten) > minBytes)) {
110 bytesWritten += audioRenderer->Write(buffer.get() + static_cast<size_t>(bytesWritten),
111 bytesToWrite - static_cast<size_t>(bytesWritten));
112 EXPECT_GE(bytesWritten, VALUE_ZERO);
113 if (bytesWritten < 0) {
114 break;
115 }
116 }
117 numBuffersToRender--;
118
119 if ((limit > 0) && (duration_cast<seconds>(system_clock::now() - start).count() > limit)) {
120 break;
121 }
122 }
123
124 audioRenderer->Drain();
125
126 fclose(wavFile);
127 }
128
129 /**
130 * @tc.name : Test GetSupportedFormats API
131 * @tc.number: Audio_Renderer_GetSupportedFormats_001
132 * @tc.desc : Test GetSupportedFormats interface. Returns supported Formats on success.
133 */
134 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetSupportedFormats_001, TestSize.Level0)
135 {
136 vector<AudioSampleFormat> supportedFormatList = AudioRenderer::GetSupportedFormats();
137 EXPECT_EQ(AUDIO_SUPPORTED_FORMATS.size(), supportedFormatList.size());
138 }
139
140 /**
141 * @tc.name : Test GetSupportedChannels API
142 * @tc.number: Audio_Renderer_GetSupportedChannels_001
143 * @tc.desc : Test GetSupportedChannels interface. Returns supported Channels on success.
144 */
145 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetSupportedChannels_001, TestSize.Level0)
146 {
147 vector<AudioChannel> supportedChannelList = AudioRenderer::GetSupportedChannels();
148 EXPECT_EQ(RENDERER_SUPPORTED_CHANNELS.size(), supportedChannelList.size());
149 }
150
151 /**
152 * @tc.name : Test GetSupportedEncodingTypes API
153 * @tc.number: Audio_Renderer_GetSupportedEncodingTypes_001
154 * @tc.desc : Test GetSupportedEncodingTypes interface. Returns supported Encoding types on success.
155 */
156 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetSupportedEncodingTypes_001, TestSize.Level0)
157 {
158 vector<AudioEncodingType> supportedEncodingTypes
159 = AudioRenderer::GetSupportedEncodingTypes();
160 EXPECT_EQ(AUDIO_SUPPORTED_ENCODING_TYPES.size(), supportedEncodingTypes.size());
161 }
162
163 /**
164 * @tc.name : Test GetSupportedSamplingRates API
165 * @tc.number: Audio_Renderer_GetSupportedSamplingRates_001
166 * @tc.desc : Test GetSupportedSamplingRates interface. Returns supported Sampling rates on success.
167 */
168 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetSupportedSamplingRates_001, TestSize.Level0)
169 {
170 vector<AudioSamplingRate> supportedSamplingRates = AudioRenderer::GetSupportedSamplingRates();
171 EXPECT_EQ(AUDIO_SUPPORTED_SAMPLING_RATES.size(), supportedSamplingRates.size());
172 }
173
174 /**
175 * @tc.name : Test Create API via legal input.
176 * @tc.number: Audio_Renderer_Create_001
177 * @tc.desc : Test Create interface with STREAM_MUSIC. Returns audioRenderer instance, if create is successful.
178 */
179 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_001, TestSize.Level0)
180 {
181 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
182 EXPECT_NE(nullptr, audioRenderer);
183 }
184
185 /**
186 * @tc.name : Test Create API via legal input.
187 * @tc.number: Audio_Renderer_Create_002
188 * @tc.desc : Test Create interface with STREAM_RING. Returns audioRenderer instance, if create is successful.
189 */
190 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_002, TestSize.Level0)
191 {
192 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_RING);
193 EXPECT_NE(nullptr, audioRenderer);
194 }
195
196 /**
197 * @tc.name : Test Create API via legal input.
198 * @tc.number: Audio_Renderer_Create_003
199 * @tc.desc : Test Create interface with STREAM_VOICE_CALL. Returns audioRenderer instance if create is successful.
200 * Note: instance will be created but functional support for STREAM_VOICE_CALL not available yet.
201 */
202 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_003, TestSize.Level0)
203 {
204 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_VOICE_CALL);
205 EXPECT_NE(nullptr, audioRenderer);
206 }
207
208 /**
209 * @tc.name : Test Create API via legal input.
210 * @tc.number: Audio_Renderer_Create_004
211 * @tc.desc : Test Create interface with STREAM_SYSTEM. Returns audioRenderer instance, if create is successful.
212 * Note: instance will be created but functional support for STREAM_SYSTEM not available yet.
213 */
214 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_004, TestSize.Level0)
215 {
216 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_SYSTEM);
217 EXPECT_NE(nullptr, audioRenderer);
218 }
219
220 /**
221 * @tc.name : Test Create API via legal input.
222 * @tc.number: Audio_Renderer_Create_005
223 * @tc.desc : Test Create interface with STREAM_BLUETOOTH_SCO. Returns audioRenderer instance, if create is successful.
224 * Note: instance will be created but functional support for STREAM_BLUETOOTH_SCO not available yet
225 */
226 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_005, TestSize.Level0)
227 {
228 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_BLUETOOTH_SCO);
229 EXPECT_NE(nullptr, audioRenderer);
230 }
231
232 /**
233 * @tc.name : Test Create API via legal input.
234 * @tc.number: Audio_Renderer_Create_006
235 * @tc.desc : Test Create interface with STREAM_ALARM. Returns audioRenderer instance, if create is successful.
236 * Note: instance will be created but functional support for STREAM_ALARM not available yet.
237 */
238 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_006, TestSize.Level0)
239 {
240 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_ALARM);
241 EXPECT_NE(nullptr, audioRenderer);
242 }
243
244 /**
245 * @tc.name : Test Create API via legal input.
246 * @tc.number: Audio_Renderer_Create_007
247 * @tc.desc : Test Create interface with STREAM_NOTIFICATION. Returns audioRenderer instance, if create is successful.
248 * Note: instance will be created but functional support for STREAM_NOTIFICATION not available yet.
249 */
250 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_007, TestSize.Level0)
251 {
252 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_NOTIFICATION);
253 EXPECT_NE(nullptr, audioRenderer);
254 }
255
256 /**
257 * @tc.name : Test Create API via legal input.
258 * @tc.number: Audio_Renderer_Create_008
259 * @tc.desc : Test Create interface with AudioRendererOptions below.
260 * Returns audioRenderer instance, if create is successful.
261 * rendererOptions.streamInfo.samplingRate = SAMPLE_RATE_96000;
262 * rendererOptions.streamInfo.encoding = ENCODING_PCM;
263 * rendererOptions.streamInfo.format = SAMPLE_U8;
264 * rendererOptions.streamInfo.channels = MONO;
265 * rendererOptions.rendererInfo.contentType = CONTENT_TYPE_MUSIC;
266 * rendererOptions.rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
267 * rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
268 */
269 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_008, TestSize.Level0)
270 {
271 AudioRendererOptions rendererOptions;
272 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
273 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
274 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
275 rendererOptions.streamInfo.channels = AudioChannel::MONO;
276 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
277 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
278 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
279
280 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
281 ASSERT_NE(nullptr, audioRenderer);
282 audioRenderer->Release();
283 }
284
285 /**
286 * @tc.name : Test Create API via legal input.
287 * @tc.number: Audio_Renderer_Create_009
288 * @tc.desc : Test Create interface with AudioRendererOptions below.
289 * Returns audioRenderer instance, if create is successful.
290 * rendererOptions.streamInfo.samplingRate = SAMPLE_RATE_96000;
291 * rendererOptions.streamInfo.encoding = ENCODING_PCM;
292 * rendererOptions.streamInfo.format = SAMPLE_U8;
293 * rendererOptions.streamInfo.channels = STEREO;
294 * rendererOptions.rendererInfo.contentType = CONTENT_TYPE_MOVIE;
295 * rendererOptions.rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
296 * rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
297 */
298 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_009, TestSize.Level0)
299 {
300 AudioRendererOptions rendererOptions;
301 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
302 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
303 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
304 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
305 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MOVIE;
306 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
307 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
308
309 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
310 ASSERT_NE(nullptr, audioRenderer);
311 audioRenderer->Release();
312 }
313
314 /**
315 * @tc.name : Test Create API via legal input.
316 * @tc.number: Audio_Renderer_Create_010
317 * @tc.desc : Test Create interface with AudioRendererOptions below.
318 * Returns audioRenderer instance, if create is successful.
319 * rendererOptions.streamInfo.samplingRate = SAMPLE_RATE_64000;
320 * rendererOptions.streamInfo.encoding = ENCODING_PCM;
321 * rendererOptions.streamInfo.format = SAMPLE_S32LE;
322 * rendererOptions.streamInfo.channels = MONO;
323 * rendererOptions.rendererInfo.contentType = CONTENT_TYPE_RINGTONE;
324 * rendererOptions.rendererInfo.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
325 * rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
326 */
327 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_010, TestSize.Level0)
328 {
329 AudioRendererOptions rendererOptions;
330 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_64000;
331 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
332 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S32LE;
333 rendererOptions.streamInfo.channels = AudioChannel::MONO;
334 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_RINGTONE;
335 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_NOTIFICATION_RINGTONE;
336 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
337
338 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
339 ASSERT_NE(nullptr, audioRenderer);
340 audioRenderer->Release();
341 }
342
343 /**
344 * @tc.name : Test Create API via legal input.
345 * @tc.number: Audio_Renderer_Create_011
346 * @tc.desc : Test Create interface with AudioRendererOptions below.
347 * Returns audioRenderer instance, if create is successful.
348 * rendererOptions.streamInfo.samplingRate = SAMPLE_RATE_48000;
349 * rendererOptions.streamInfo.encoding = ENCODING_PCM;
350 * rendererOptions.streamInfo.format = SAMPLE_S24LE;
351 * rendererOptions.streamInfo.channels = STEREO;
352 * rendererOptions.rendererInfo.contentType = CONTENT_TYPE_MOVIE;
353 * rendererOptions.rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
354 * rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
355 */
356 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_011, TestSize.Level0)
357 {
358 AudioRendererOptions rendererOptions;
359 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
360 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
361 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S24LE;
362 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
363 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MOVIE;
364 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
365 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
366
367 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
368 ASSERT_NE(nullptr, audioRenderer);
369 audioRenderer->Release();
370 }
371
372 /**
373 * @tc.name : Test Create API via legal input.
374 * @tc.number: Audio_Renderer_Create_012
375 * @tc.desc : Test Create interface with AudioRendererOptions below.
376 * Returns audioRenderer instance, if create is successful.
377 * rendererOptions.streamInfo.samplingRate = SAMPLE_RATE_44100;
378 * rendererOptions.streamInfo.encoding = ENCODING_PCM;
379 * rendererOptions.streamInfo.format = SAMPLE_S16LE;
380 * rendererOptions.streamInfo.channels = MONO;
381 * rendererOptions.rendererInfo.contentType = CONTENT_TYPE_SONIFICATION;
382 * rendererOptions.rendererInfo.streamUsage = STREAM_USAGE_VOICE_ASSISTANT;
383 * rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
384 */
385 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_012, TestSize.Level0)
386 {
387 AudioRendererOptions rendererOptions;
388 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
389 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
390 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
391 rendererOptions.streamInfo.channels = AudioChannel::MONO;
392 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_SONIFICATION;
393 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_VOICE_ASSISTANT;
394 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
395
396 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
397 ASSERT_NE(nullptr, audioRenderer);
398 audioRenderer->Release();
399 }
400
401 /**
402 * @tc.name : Test Create API via legal input.
403 * @tc.number: Audio_Renderer_Create_013
404 * @tc.desc : Test Create interface with AudioRendererOptions below.
405 * Returns audioRenderer instance, if create is successful.
406 * rendererOptions.streamInfo.samplingRate = SAMPLE_RATE_22050;
407 * rendererOptions.streamInfo.encoding = ENCODING_PCM;
408 * rendererOptions.streamInfo.format = SAMPLE_S24LE;
409 * rendererOptions.streamInfo.channels = STEREO;
410 * rendererOptions.rendererInfo.contentType = CONTENT_TYPE_SPEECH;
411 * rendererOptions.rendererInfo.streamUsage = STREAM_USAGE_VOICE_COMMUNICATION;
412 * rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
413 */
414 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_013, TestSize.Level0)
415 {
416 AudioRendererOptions rendererOptions;
417 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_22050;
418 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
419 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S24LE;
420 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
421 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_SPEECH;
422 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION;
423 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
424
425 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
426 ASSERT_NE(nullptr, audioRenderer);
427 audioRenderer->Release();
428 }
429
430 /**
431 * @tc.name : Test Create API via legal input.
432 * @tc.number: Audio_Renderer_Create_014
433 * @tc.desc : Test Create interface with AudioRendererOptions below.
434 * Returns audioRenderer instance, if create is successful.
435 * rendererOptions.streamInfo.samplingRate = SAMPLE_RATE_12000;
436 * rendererOptions.streamInfo.encoding = ENCODING_PCM;
437 * rendererOptions.streamInfo.format = SAMPLE_S24LE;
438 * rendererOptions.streamInfo.channels = MONO;
439 * rendererOptions.rendererInfo.contentType = CONTENT_TYPE_MUSIC;
440 * rendererOptions.rendererInfo.streamUsage = STREAM_USAGE_VOICE_ASSISTANT;
441 * rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
442 */
443 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_014, TestSize.Level0)
444 {
445 AudioRendererOptions rendererOptions;
446 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_12000;
447 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
448 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S24LE;
449 rendererOptions.streamInfo.channels = AudioChannel::MONO;
450 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
451 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_VOICE_ASSISTANT;
452 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
453
454 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
455 ASSERT_NE(nullptr, audioRenderer);
456 audioRenderer->Release();
457 }
458
459 /**
460 * @tc.name : Test Renderer playback
461 * @tc.number: Audio_Renderer_Playback_001
462 * @tc.desc : Test normal playback for 2 sec
463 */
464 HWTEST(AudioRendererUnitTest, Audio_Renderer_Playback_001, TestSize.Level0)
465 {
466 AudioRendererOptions rendererOptions;
467 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
468 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
469 ASSERT_NE(nullptr, audioRenderer);
470
471 bool isStarted = audioRenderer->Start();
472 EXPECT_EQ(true, isStarted);
473
474 thread renderThread(StartRenderThread, audioRenderer.get(), PLAYBACK_DURATION);
475
476 renderThread.join();
477
478 bool isStopped = audioRenderer->Stop();
479 EXPECT_EQ(true, isStopped);
480
481 bool isReleased = audioRenderer->Release();
482 EXPECT_EQ(true, isReleased);
483 }
484
485 /**
486 * @tc.name : Test SetParams API via legal input
487 * @tc.number: Audio_Renderer_SetParams_001
488 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
489 * rendererParams.sampleFormat = SAMPLE_S16LE;
490 * rendererParams.sampleRate = SAMPLE_RATE_44100;
491 * rendererParams.channelCount = STEREO;
492 * rendererParams.encodingType = ENCODING_PCM;
493 */
494 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_001, TestSize.Level1)
495 {
496 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
497 ASSERT_NE(nullptr, audioRenderer);
498
499 AudioRendererParams rendererParams;
500 rendererParams.sampleFormat = SAMPLE_S16LE;
501 rendererParams.sampleRate = SAMPLE_RATE_44100;
502 rendererParams.channelCount = STEREO;
503 rendererParams.encodingType = ENCODING_PCM;
504
505 int32_t ret = audioRenderer->SetParams(rendererParams);
506 EXPECT_EQ(SUCCESS, ret);
507 audioRenderer->Release();
508 }
509
510 /**
511 * @tc.name : Test SetParams API via legal input.
512 * @tc.number: Audio_Renderer_SetParams_002
513 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
514 * rendererParams.sampleFormat = SAMPLE_S16LE;
515 * rendererParams.sampleRate = SAMPLE_RATE_8000;
516 * rendererParams.channelCount = MONO;
517 * rendererParams.encodingType = ENCODING_PCM;
518 */
519 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_002, TestSize.Level1)
520 {
521 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
522 ASSERT_NE(nullptr, audioRenderer);
523
524 AudioRendererParams rendererParams;
525 rendererParams.sampleFormat = SAMPLE_S16LE;
526 rendererParams.sampleRate = SAMPLE_RATE_8000;
527 rendererParams.channelCount = MONO;
528 rendererParams.encodingType = ENCODING_PCM;
529
530 int32_t ret = audioRenderer->SetParams(rendererParams);
531 EXPECT_EQ(SUCCESS, ret);
532 audioRenderer->Release();
533 }
534
535 /**
536 * @tc.name : Test SetParams API via legal input.
537 * @tc.number: Audio_Renderer_SetParams_003
538 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
539 * rendererParams.sampleFormat = SAMPLE_S16LE;
540 * rendererParams.sampleRate = SAMPLE_RATE_11025;
541 * rendererParams.channelCount = STEREO;
542 * rendererParams.encodingType = ENCODING_PCM;
543 */
544 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_003, TestSize.Level1)
545 {
546 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
547 ASSERT_NE(nullptr, audioRenderer);
548
549 AudioRendererParams rendererParams;
550 rendererParams.sampleFormat = SAMPLE_S16LE;
551 rendererParams.sampleRate = SAMPLE_RATE_11025;
552 rendererParams.channelCount = STEREO;
553 rendererParams.encodingType = ENCODING_PCM;
554
555 int32_t ret = audioRenderer->SetParams(rendererParams);
556 EXPECT_EQ(SUCCESS, ret);
557 audioRenderer->Release();
558 }
559
560 /**
561 * @tc.name : Test SetParams API via legal input.
562 * @tc.number: Audio_Renderer_SetParams_004
563 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
564 * rendererParams.sampleFormat = SAMPLE_S16LE;
565 * rendererParams.sampleRate = SAMPLE_RATE_22050;
566 * rendererParams.channelCount = MONO;
567 * rendererParams.encodingType = ENCODING_PCM;
568 */
569 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_004, TestSize.Level1)
570 {
571 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
572 ASSERT_NE(nullptr, audioRenderer);
573
574 AudioRendererParams rendererParams;
575 rendererParams.sampleFormat = SAMPLE_S16LE;
576 rendererParams.sampleRate = SAMPLE_RATE_22050;
577 rendererParams.channelCount = MONO;
578 rendererParams.encodingType = ENCODING_PCM;
579
580 int32_t ret = audioRenderer->SetParams(rendererParams);
581 EXPECT_EQ(SUCCESS, ret);
582 audioRenderer->Release();
583 }
584
585 /**
586 * @tc.name : Test SetParams API via legal input.
587 * @tc.number: Audio_Renderer_SetParams_005
588 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
589 * rendererParams.sampleFormat = SAMPLE_S16LE;
590 * rendererParams.sampleRate = SAMPLE_RATE_96000;
591 * rendererParams.channelCount = MONO;
592 * rendererParams.encodingType = ENCODING_PCM;
593 */
594 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_005, TestSize.Level1)
595 {
596 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
597 ASSERT_NE(nullptr, audioRenderer);
598
599 AudioRendererParams rendererParams;
600 rendererParams.sampleFormat = SAMPLE_S16LE;
601 rendererParams.sampleRate = SAMPLE_RATE_96000;
602 rendererParams.channelCount = MONO;
603 rendererParams.encodingType = ENCODING_PCM;
604
605 int32_t ret = audioRenderer->SetParams(rendererParams);
606 EXPECT_EQ(SUCCESS, ret);
607 }
608
609 /**
610 * @tc.name : Test SetParams API via legal input.
611 * @tc.number: Audio_Renderer_SetParams_006
612 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
613 * rendererParams.sampleFormat = SAMPLE_S24LE;
614 * rendererParams.sampleRate = SAMPLE_RATE_64000;
615 * rendererParams.channelCount = MONO;
616 * rendererParams.encodingType = ENCODING_PCM;
617 */
618 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_006, TestSize.Level1)
619 {
620 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
621 ASSERT_NE(nullptr, audioRenderer);
622
623 AudioRendererParams rendererParams;
624 rendererParams.sampleFormat = SAMPLE_S24LE;
625 rendererParams.sampleRate = SAMPLE_RATE_64000;
626 rendererParams.channelCount = MONO;
627 rendererParams.encodingType = ENCODING_PCM;
628
629 int32_t ret = audioRenderer->SetParams(rendererParams);
630 EXPECT_EQ(SUCCESS, ret);
631 }
632
633 /**
634 * @tc.name : Test SetParams API via illegal input.
635 * @tc.number: Audio_Renderer_SetParams_007
636 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
637 * rendererParams.sampleFormat = SAMPLE_S16LE;
638 * rendererParams.sampleRate = SAMPLE_RATE_16000;
639 * rendererParams.channelCount = STEREO;
640 * rendererParams.encodingType = ENCODING_PCM;
641 */
642 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_007, TestSize.Level1)
643 {
644 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
645 ASSERT_NE(nullptr, audioRenderer);
646
647 AudioRendererParams rendererParams;
648 rendererParams.sampleFormat = SAMPLE_S16LE;
649 rendererParams.sampleRate = SAMPLE_RATE_16000;
650 rendererParams.channelCount = STEREO;
651 rendererParams.encodingType = ENCODING_PCM;
652
653 int32_t ret = audioRenderer->SetParams(rendererParams);
654 EXPECT_EQ(SUCCESS, ret);
655 audioRenderer->Release();
656 }
657
658 /**
659 * @tc.name : Test SetParams API stability.
660 * @tc.number: Audio_Renderer_SetParams_Stability_001
661 * @tc.desc : Test SetParams interface stability.
662 */
663 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_Stability_001, TestSize.Level1)
664 {
665 int32_t ret = -1;
666 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
667 ASSERT_NE(nullptr, audioRenderer);
668
669 AudioRendererParams rendererParams;
670 rendererParams.sampleFormat = SAMPLE_S16LE;
671 rendererParams.sampleRate = SAMPLE_RATE_44100;
672 rendererParams.channelCount = STEREO;
673 rendererParams.encodingType = ENCODING_PCM;
674
675 for (int i = 0; i < VALUE_HUNDRED; i++) {
676 ret = audioRenderer->SetParams(rendererParams);
677 EXPECT_EQ(SUCCESS, ret);
678
679 AudioRendererParams getRendererParams;
680 ret = audioRenderer->GetParams(getRendererParams);
681 EXPECT_EQ(SUCCESS, ret);
682 }
683
684 audioRenderer->Release();
685 }
686
687 /**
688 * @tc.name : Test GetParams API via legal input.
689 * @tc.number: Audio_Renderer_GetParams_001
690 * @tc.desc : Test GetParams interface. Returns 0 {SUCCESS}, if the getting is successful.
691 */
692 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_001, TestSize.Level1)
693 {
694 int32_t ret = -1;
695 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
696 ASSERT_NE(nullptr, audioRenderer);
697
698 AudioRendererParams rendererParams;
699 rendererParams.sampleFormat = SAMPLE_S16LE;
700 rendererParams.sampleRate = SAMPLE_RATE_44100;
701 rendererParams.channelCount = STEREO;
702 rendererParams.encodingType = ENCODING_PCM;
703 ret = audioRenderer->SetParams(rendererParams);
704 EXPECT_EQ(SUCCESS, ret);
705
706 AudioRendererParams getRendererParams;
707 ret = audioRenderer->GetParams(getRendererParams);
708 EXPECT_EQ(SUCCESS, ret);
709 EXPECT_EQ(rendererParams.sampleFormat, getRendererParams.sampleFormat);
710 EXPECT_EQ(rendererParams.sampleRate, getRendererParams.sampleRate);
711 EXPECT_EQ(rendererParams.channelCount, getRendererParams.channelCount);
712 EXPECT_EQ(rendererParams.encodingType, getRendererParams.encodingType);
713
714 audioRenderer->Release();
715 }
716
717 /**
718 * @tc.name : Test GetParams API via legal state, RENDERER_RUNNING: GetParams after Start.
719 * @tc.number: Audio_Renderer_GetParams_002
720 * @tc.desc : Test GetParams interface. Returns 0 {SUCCESS} if the getting is successful.
721 */
722 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_002, TestSize.Level1)
723 {
724 int32_t ret = -1;
725 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
726 ASSERT_NE(nullptr, audioRenderer);
727
728 AudioRendererParams rendererParams;
729 rendererParams.sampleFormat = SAMPLE_S16LE;
730 rendererParams.sampleRate = SAMPLE_RATE_44100;
731 rendererParams.channelCount = MONO;
732 rendererParams.encodingType = ENCODING_PCM;
733 ret = audioRenderer->SetParams(rendererParams);
734 EXPECT_EQ(SUCCESS, ret);
735
736 bool isStarted = audioRenderer->Start();
737 EXPECT_EQ(true, isStarted);
738
739 AudioRendererParams getRendererParams;
740 ret = audioRenderer->GetParams(getRendererParams);
741 EXPECT_EQ(SUCCESS, ret);
742
743 audioRenderer->Release();
744 }
745
746 /**
747 * @tc.name : Test GetParams API via illegal state, RENDERER_NEW: Call GetParams without SetParams.
748 * @tc.number: Audio_Renderer_GetParams_003
749 * @tc.desc : Test GetParams interface. Returns error code, if the renderer state is RENDERER_NEW.
750 */
751 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_003, TestSize.Level1)
752 {
753 int32_t ret = -1;
754 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
755 ASSERT_NE(nullptr, audioRenderer);
756
757 AudioRendererParams rendererParams;
758 rendererParams.sampleFormat = SAMPLE_S16LE;
759 rendererParams.sampleRate = SAMPLE_RATE_44100;
760 rendererParams.channelCount = MONO;
761 rendererParams.encodingType = ENCODING_PCM;
762
763 AudioRendererParams getRendererParams;
764 ret = audioRenderer->GetParams(getRendererParams);
765 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
766 }
767
768 /**
769 * @tc.name : Test GetParams API via illegal state, RENDERER_RELEASED: Call GetParams after Release.
770 * @tc.number: Audio_Renderer_GetParams_004
771 * @tc.desc : Test GetParams interface. Returns error code, if the renderer state is RENDERER_RELEASED.
772 */
773 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_004, TestSize.Level1)
774 {
775 int32_t ret = -1;
776 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
777 ASSERT_NE(nullptr, audioRenderer);
778
779 ret = AudioRendererUnitTest::InitializeRenderer(audioRenderer);
780 EXPECT_EQ(SUCCESS, ret);
781
782 bool isReleased = audioRenderer->Release();
783 EXPECT_EQ(true, isReleased);
784
785 AudioRendererParams getRendererParams;
786 ret = audioRenderer->GetParams(getRendererParams);
787 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
788 }
789
790 /**
791 * @tc.name : Test GetParams API via legal state, RENDERER_STOPPED: GetParams after Stop.
792 * @tc.number: Audio_Renderer_GetParams_005
793 * @tc.desc : Test GetParams interface. Returns 0 {SUCCESS}, if the getting is successful.
794 */
795 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_005, TestSize.Level1)
796 {
797 int32_t ret = -1;
798 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
799 ASSERT_NE(nullptr, audioRenderer);
800
801 ret = AudioRendererUnitTest::InitializeRenderer(audioRenderer);
802 EXPECT_EQ(SUCCESS, ret);
803
804 bool isStarted = audioRenderer->Start();
805 EXPECT_EQ(true, isStarted);
806
807 bool isStopped = audioRenderer->Stop();
808 EXPECT_EQ(true, isStopped);
809
810 AudioRendererParams getRendererParams;
811 ret = audioRenderer->GetParams(getRendererParams);
812 EXPECT_EQ(SUCCESS, ret);
813
814 audioRenderer->Release();
815 }
816
817 /**
818 * @tc.name : Test GetParams API via legal input.
819 * @tc.number: Audio_Renderer_GetParams_006
820 * @tc.desc : Test GetParams interface. Returns 0 {SUCCESS}, if the getting is successful.
821 */
822 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_006, TestSize.Level1)
823 {
824 int32_t ret = -1;
825 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
826 ASSERT_NE(nullptr, audioRenderer);
827
828 AudioRendererParams rendererParams;
829 rendererParams.sampleFormat = SAMPLE_S24LE;
830 rendererParams.sampleRate = SAMPLE_RATE_44100;
831 rendererParams.channelCount = STEREO;
832 rendererParams.encodingType = ENCODING_PCM;
833 ret = audioRenderer->SetParams(rendererParams);
834 EXPECT_EQ(SUCCESS, ret);
835
836 AudioRendererParams getRendererParams;
837 ret = audioRenderer->GetParams(getRendererParams);
838 EXPECT_EQ(SUCCESS, ret);
839 EXPECT_EQ(rendererParams.sampleFormat, getRendererParams.sampleFormat);
840 EXPECT_EQ(rendererParams.sampleRate, getRendererParams.sampleRate);
841 EXPECT_EQ(rendererParams.channelCount, getRendererParams.channelCount);
842 EXPECT_EQ(rendererParams.encodingType, getRendererParams.encodingType);
843
844 audioRenderer->Release();
845 }
846
847 /**
848 * @tc.name : Test GetParams API via legal input.
849 * @tc.number: Audio_Renderer_GetParams_007
850 * @tc.desc : Test GetParams interface. Returns 0 {SUCCESS}, if the getting is successful.
851 */
852 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_007, TestSize.Level1)
853 {
854 int32_t ret = -1;
855 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
856 ASSERT_NE(nullptr, audioRenderer);
857
858 AudioRendererParams rendererParams;
859 rendererParams.sampleFormat = SAMPLE_S32LE;
860 rendererParams.sampleRate = SAMPLE_RATE_44100;
861 rendererParams.channelCount = STEREO;
862 rendererParams.encodingType = ENCODING_PCM;
863 ret = audioRenderer->SetParams(rendererParams);
864 EXPECT_EQ(SUCCESS, ret);
865
866 AudioRendererParams getRendererParams;
867 ret = audioRenderer->GetParams(getRendererParams);
868 EXPECT_EQ(SUCCESS, ret);
869 EXPECT_EQ(rendererParams.sampleFormat, getRendererParams.sampleFormat);
870 EXPECT_EQ(rendererParams.sampleRate, getRendererParams.sampleRate);
871 EXPECT_EQ(rendererParams.channelCount, getRendererParams.channelCount);
872 EXPECT_EQ(rendererParams.encodingType, getRendererParams.encodingType);
873
874 audioRenderer->Release();
875 }
876
877 /**
878 * @tc.name : Test GetParams API via legal input.
879 * @tc.number: Audio_Renderer_GetParams_008
880 * @tc.desc : Test GetParams interface. Returns 0 {SUCCESS}, if the getting is successful.
881 */
882 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_008, TestSize.Level1)
883 {
884 int32_t ret = -1;
885 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
886 ASSERT_NE(nullptr, audioRenderer);
887
888 AudioRendererParams getRendererParams;
889 getRendererParams.sampleFormat = AudioSampleFormat::INVALID_WIDTH;
890 ret = audioRenderer->GetParams(getRendererParams);
891 EXPECT_EQ(true, ret < 0);
892 audioRenderer->Release();
893 }
894
895 /**
896 * @tc.name : Test SetInterruptMode API via legal input
897 * @tc.number: Audio_Renderer_SetInterruptMode_001
898 * @tc.desc : Test SetInterruptMode interface. Returns 0 {SUCCESS}, if the setting is successful.
899 */
900 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetInterruptMode_001, TestSize.Level1)
901 {
902 int32_t ret = -1;
903 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
904 ASSERT_NE(nullptr, audioRenderer);
905
906 ret = AudioRendererUnitTest::InitializeRenderer(audioRenderer);
907 EXPECT_EQ(SUCCESS, ret);
908
909 audioRenderer->SetInterruptMode(SHARE_MODE);
910
911 bool isStarted = audioRenderer->Start();
912 EXPECT_EQ(true, isStarted);
913
914 bool isStopped = audioRenderer->Stop();
915 EXPECT_EQ(true, isStopped);
916 audioRenderer->Release();
917 }
918
919 /**
920 * @tc.name : Test SetInterruptMode API via legal input
921 * @tc.number: Audio_Renderer_SetInterruptMode_002
922 * @tc.desc : Test SetInterruptMode interface. Returns 0 {SUCCESS}, if the setting is successful.
923 */
924 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetInterruptMode_002, TestSize.Level1)
925 {
926 int32_t ret = -1;
927 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
928 ASSERT_NE(nullptr, audioRenderer);
929
930 ret = AudioRendererUnitTest::InitializeRenderer(audioRenderer);
931 EXPECT_EQ(SUCCESS, ret);
932
933 audioRenderer->SetInterruptMode(INDEPENDENT_MODE);
934
935 bool isStarted = audioRenderer->Start();
936 EXPECT_EQ(true, isStarted);
937
938 bool isStopped = audioRenderer->Stop();
939 EXPECT_EQ(true, isStopped);
940 audioRenderer->Release();
941 }
942
943 /**
944 * @tc.name : Test GetBufQueueState
945 * @tc.number: Audio_Renderer_GetBufQueueState_001
946 * @tc.desc : Test GetBufQueueState interface. Returns BufferQueueState, if obtained successfully.
947 */
948 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufQueueState_001, TestSize.Level1)
949 {
950 int32_t ret = -1;
951 AudioRendererOptions rendererOptions;
952
953 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
954 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
955 ASSERT_NE(nullptr, audioRenderer);
956
957 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
958 EXPECT_EQ(SUCCESS, ret);
959 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
960 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
961
962 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
963
964 ret = audioRenderer->SetRendererWriteCallback(cb);
965 EXPECT_EQ(SUCCESS, ret);
966
967 BufferQueueState bQueueSate {};
968 bQueueSate.currentIndex = 1;
969 bQueueSate.numBuffers = 1;
970
971 ret = audioRenderer->GetBufQueueState(bQueueSate);
972 EXPECT_EQ(SUCCESS, ret);
973 audioRenderer->Release();
974 }
975
976 /**
977 * @tc.name : Test GetParams API stability.
978 * @tc.number: Audio_Renderer_GetParams_Stability_001
979 * @tc.desc : Test GetParams interface stability.
980 */
981 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_Stability_001, TestSize.Level1)
982 {
983 int32_t ret = -1;
984 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
985 ASSERT_NE(nullptr, audioRenderer);
986
987 AudioRendererParams rendererParams;
988 rendererParams.sampleFormat = SAMPLE_S16LE;
989 rendererParams.sampleRate = SAMPLE_RATE_44100;
990 rendererParams.channelCount = STEREO;
991 rendererParams.encodingType = ENCODING_PCM;
992
993 ret = audioRenderer->SetParams(rendererParams);
994 EXPECT_EQ(SUCCESS, ret);
995
996 for (int i = 0; i < VALUE_THOUSAND; i++) {
997 AudioRendererParams getRendererParams;
998 ret = audioRenderer->GetParams(getRendererParams);
999 EXPECT_EQ(SUCCESS, ret);
1000 }
1001
1002 audioRenderer->Release();
1003 }
1004
1005 /**
1006 * @tc.name : Test GetBufferSize API via legal input.
1007 * @tc.number: Audio_Renderer_GetBufferSize_001
1008 * @tc.desc : Test GetBufferSize interface. Returns 0 {SUCCESS}, if the getting is successful.
1009 */
1010 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufferSize_001, TestSize.Level1)
1011 {
1012 int32_t ret = -1;
1013 AudioRendererOptions rendererOptions;
1014
1015 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1016 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1017 ASSERT_NE(nullptr, audioRenderer);
1018
1019 size_t bufferLen;
1020 ret = audioRenderer->GetBufferSize(bufferLen);
1021 EXPECT_EQ(SUCCESS, ret);
1022
1023 audioRenderer->Release();
1024 }
1025
1026 /**
1027 * @tc.name : Test GetBufferSize API via illegal state, RENDERER_NEW: without initializing the renderer.
1028 * @tc.number: Audio_Renderer_GetBufferSize_002
1029 * @tc.desc : Test GetBufferSize interface. Returns error code, if the renderer state is RENDERER_NEW.
1030 */
1031 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufferSize_002, TestSize.Level1)
1032 {
1033 int32_t ret = -1;
1034 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
1035 ASSERT_NE(nullptr, audioRenderer);
1036
1037 size_t bufferLen;
1038 ret = audioRenderer->GetBufferSize(bufferLen);
1039 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
1040 }
1041
1042 /**
1043 * @tc.name : Test GetBufferSize API via illegal state, RENDERER_RELEASED: call Release before GetBufferSize
1044 * @tc.number: Audio_Renderer_GetBufferSize_003
1045 * @tc.desc : Test GetBufferSize interface. Returns error code, if the renderer state is RENDERER_RELEASED.
1046 */
1047 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufferSize_003, TestSize.Level1)
1048 {
1049 int32_t ret = -1;
1050 AudioRendererOptions rendererOptions;
1051
1052 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1053 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1054 ASSERT_NE(nullptr, audioRenderer);
1055
1056 bool isReleased = audioRenderer->Release();
1057 EXPECT_EQ(true, isReleased);
1058
1059 size_t bufferLen;
1060 ret = audioRenderer->GetBufferSize(bufferLen);
1061 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
1062 }
1063
1064 /**
1065 * @tc.name : Test GetBufferSize API via legal state, RENDERER_STOPPED: call Stop before GetBufferSize
1066 * @tc.number: Audio_Renderer_GetBufferSize_004
1067 * @tc.desc : Test GetBufferSize interface. Returns 0 {SUCCESS}, if the getting is successful.
1068 */
1069 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufferSize_004, TestSize.Level1)
1070 {
1071 int32_t ret = -1;
1072 AudioRendererOptions rendererOptions;
1073
1074 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1075 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1076 ASSERT_NE(nullptr, audioRenderer);
1077
1078 bool isStarted = audioRenderer->Start();
1079 EXPECT_EQ(true, isStarted);
1080
1081 bool isStopped = audioRenderer->Stop();
1082 EXPECT_EQ(true, isStopped);
1083
1084 size_t bufferLen;
1085 ret = audioRenderer->GetBufferSize(bufferLen);
1086 EXPECT_EQ(SUCCESS, ret);
1087
1088 audioRenderer->Release();
1089 }
1090
1091 /**
1092 * @tc.name : Test GetBufferSize API via legal state, RENDERER_RUNNING: call Start before GetBufferSize
1093 * @tc.number: Audio_Renderer_GetBufferSize_005
1094 * @tc.desc : test GetBufferSize interface. Returns 0 {SUCCESS}, if the getting is successful.
1095 */
1096 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufferSize_005, TestSize.Level1)
1097 {
1098 int32_t ret = -1;
1099 AudioRendererOptions rendererOptions;
1100
1101 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1102 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1103 ASSERT_NE(nullptr, audioRenderer);
1104
1105 bool isStarted = audioRenderer->Start();
1106 EXPECT_EQ(true, isStarted);
1107
1108 size_t bufferLen;
1109 ret = audioRenderer->GetBufferSize(bufferLen);
1110 EXPECT_EQ(SUCCESS, ret);
1111
1112 audioRenderer->Release();
1113 }
1114
1115 /**
1116 * @tc.name : Test GetAudioStreamId API stability.
1117 * @tc.number: Audio_Renderer_GetAudioStreamId_001
1118 * @tc.desc : Test GetAudioStreamId interface stability.
1119 */
1120 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioStreamId_001, TestSize.Level1)
1121 {
1122 int32_t ret = -1;
1123 AudioRendererOptions rendererOptions;
1124
1125 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1126 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1127 ASSERT_NE(nullptr, audioRenderer);
1128
1129 uint32_t sessionID;
1130 ret = audioRenderer->GetAudioStreamId(sessionID);
1131 EXPECT_EQ(SUCCESS, ret);
1132
1133 audioRenderer->Release();
1134 }
1135
1136 /**
1137 * @tc.name : Test SetAudioRendererDesc API stability.
1138 * @tc.number: Audio_Renderer_SetAudioRendererDesc_001
1139 * @tc.desc : Test SetAudioRendererDesc interface stability.
1140 */
1141 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetAudioRendererDesc_001, TestSize.Level1)
1142 {
1143 int32_t ret = -1;
1144 AudioRendererOptions rendererOptions;
1145
1146 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1147 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1148 ASSERT_NE(nullptr, audioRenderer);
1149
1150 AudioRendererDesc audioRD = {CONTENT_TYPE_MUSIC, STREAM_USAGE_VOICE_COMMUNICATION};
1151 ret = audioRenderer->SetAudioRendererDesc(audioRD);
1152 EXPECT_EQ(SUCCESS, ret);
1153
1154 audioRenderer->Release();
1155 }
1156
1157 /**
1158 * @tc.name : Test SetStreamType API stability.
1159 * @tc.number: Audio_Renderer_SetStreamType_001
1160 * @tc.desc : Test SetStreamType interface stability.
1161 */
1162 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetStreamType_001, TestSize.Level1)
1163 {
1164 int32_t ret = -1;
1165 AudioRendererOptions rendererOptions;
1166
1167 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1168 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1169 ASSERT_NE(nullptr, audioRenderer);
1170
1171 AudioStreamType audioStreamType = STREAM_MUSIC;
1172 ret = audioRenderer->SetStreamType(audioStreamType);
1173 EXPECT_EQ(SUCCESS, ret);
1174
1175 audioRenderer->Release();
1176 }
1177
1178 /**
1179 * @tc.name : Test GetFrameCount API via legal input.
1180 * @tc.number: Audio_Renderer_GetFrameCount_001
1181 * @tc.desc : test GetFrameCount interface, Returns 0 {SUCCESS}, if the getting is successful.
1182 */
1183 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetFrameCount_001, TestSize.Level1)
1184 {
1185 int32_t ret = -1;
1186 AudioRendererOptions rendererOptions;
1187
1188 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1189 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1190 ASSERT_NE(nullptr, audioRenderer);
1191
1192 uint32_t frameCount;
1193 ret = audioRenderer->GetFrameCount(frameCount);
1194 EXPECT_EQ(SUCCESS, ret);
1195
1196 audioRenderer->Release();
1197 }
1198
1199 /**
1200 * @tc.name : Test GetFrameCount API via illegal state, RENDERER_NEW: without initialiing the renderer.
1201 * @tc.number: Audio_Renderer_GetFrameCount_002
1202 * @tc.desc : Test GetFrameCount interface. Returns error code, if the renderer state is RENDERER_NEW.
1203 */
1204 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetFrameCount_002, TestSize.Level1)
1205 {
1206 int32_t ret = -1;
1207 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
1208 ASSERT_NE(nullptr, audioRenderer);
1209
1210 uint32_t frameCount;
1211 ret = audioRenderer->GetFrameCount(frameCount);
1212 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
1213 }
1214
1215 /**
1216 * @tc.name : Test GetFrameCount API via legal state, RENDERER_RUNNING: call Start before GetFrameCount.
1217 * @tc.number: Audio_Renderer_GetFrameCount_003
1218 * @tc.desc : Test GetFrameCount interface. Returns 0 {SUCCESS}, if the getting is successful.
1219 */
1220 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetFrameCount_003, TestSize.Level1)
1221 {
1222 int32_t ret = -1;
1223 AudioRendererOptions rendererOptions;
1224
1225 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1226 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1227 ASSERT_NE(nullptr, audioRenderer);
1228
1229 bool isStarted = audioRenderer->Start();
1230 EXPECT_EQ(true, isStarted);
1231
1232 uint32_t frameCount;
1233 ret = audioRenderer->GetFrameCount(frameCount);
1234 EXPECT_EQ(SUCCESS, ret);
1235
1236 audioRenderer->Release();
1237 }
1238
1239 /**
1240 * @tc.name : Test GetFrameCount API via legal state, RENDERER_STOPPED: call Stop before GetFrameCount
1241 * @tc.number: Audio_Renderer_GetFrameCount_004
1242 * @tc.desc : Test GetFrameCount interface. Returns 0 {SUCCESS}, if the getting is successful.
1243 */
1244 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetFrameCount_004, TestSize.Level1)
1245 {
1246 int32_t ret = -1;
1247 AudioRendererOptions rendererOptions;
1248
1249 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1250 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1251 ASSERT_NE(nullptr, audioRenderer);
1252
1253 bool isStarted = audioRenderer->Start();
1254 EXPECT_EQ(true, isStarted);
1255
1256 bool isStopped = audioRenderer->Stop();
1257 EXPECT_EQ(true, isStopped);
1258
1259 uint32_t frameCount;
1260 ret = audioRenderer->GetFrameCount(frameCount);
1261 EXPECT_EQ(SUCCESS, ret);
1262
1263 audioRenderer->Release();
1264 }
1265
1266 /**
1267 * @tc.name : Test GetFrameCount API via illegal state, RENDERER_RELEASED: call Release before GetFrameCount
1268 * @tc.number: Audio_Renderer_GetFrameCount_005
1269 * @tc.desc : Test GetFrameCount interface. Returns error code, if the state is RENDERER_RELEASED.
1270 */
1271 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetFrameCount_005, TestSize.Level1)
1272 {
1273 int32_t ret = -1;
1274 AudioRendererOptions rendererOptions;
1275
1276 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1277 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1278 ASSERT_NE(nullptr, audioRenderer);
1279
1280 bool isReleased = audioRenderer->Release();
1281 EXPECT_EQ(true, isReleased);
1282
1283 uint32_t frameCount;
1284 ret = audioRenderer->GetFrameCount(frameCount);
1285 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
1286 }
1287
1288 /**
1289 * @tc.name : Test GetFrameCount API via legal state, RENDERER_PAUSED: call Pause before GetFrameCount
1290 * @tc.number: Audio_Renderer_GetFrameCount_006
1291 * @tc.desc : Test GetFrameCount interface. Returns 0 {SUCCESS}, if the getting is successful.
1292 */
1293 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetFrameCount_006, TestSize.Level1)
1294 {
1295 int32_t ret = -1;
1296 AudioRendererOptions rendererOptions;
1297
1298 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1299 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1300 ASSERT_NE(nullptr, audioRenderer);
1301
1302 bool isStarted = audioRenderer->Start();
1303 EXPECT_EQ(true, isStarted);
1304
1305 bool isPaused = audioRenderer->Pause();
1306 EXPECT_EQ(true, isPaused);
1307
1308 uint32_t frameCount;
1309 ret = audioRenderer->GetFrameCount(frameCount);
1310 EXPECT_EQ(SUCCESS, ret);
1311
1312 audioRenderer->Release();
1313 }
1314
1315 /**
1316 * @tc.name : Test SetVolume
1317 * @tc.number: Audio_Renderer_SetVolume_001
1318 * @tc.desc : Test SetVolume interface, Returns 0 {SUCCESS}, if the track volume is set.
1319 */
1320 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetVolume_001, TestSize.Level1)
1321 {
1322 int32_t ret = -1;
1323 AudioRendererOptions rendererOptions;
1324
1325 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1326 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1327 ASSERT_NE(nullptr, audioRenderer);
1328
1329 ret = audioRenderer->SetVolume(0.5);
1330 EXPECT_EQ(SUCCESS, ret);
1331
1332 bool isReleased = audioRenderer->Release();
1333 EXPECT_EQ(true, isReleased);
1334 }
1335
1336 /**
1337 * @tc.name : Test SetVolume
1338 * @tc.number: Audio_Renderer_SetVolume_002
1339 * @tc.desc : Test SetVolume interface for minimum and maximum volumes.
1340 */
1341 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetVolume_002, TestSize.Level1)
1342 {
1343 int32_t ret = -1;
1344 AudioRendererOptions rendererOptions;
1345
1346 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1347 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1348 ASSERT_NE(nullptr, audioRenderer);
1349
1350 ret = audioRenderer->SetVolume(0);
1351 EXPECT_EQ(SUCCESS, ret);
1352
1353 ret = audioRenderer->SetVolume(1.0);
1354 EXPECT_EQ(SUCCESS, ret);
1355
1356 bool isReleased = audioRenderer->Release();
1357 EXPECT_EQ(true, isReleased);
1358 }
1359
1360 /**
1361 * @tc.name : Test SetVolume
1362 * @tc.number: Audio_Renderer_SetVolume_003
1363 * @tc.desc : Test SetVolume interface for out of range values.
1364 */
1365 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetVolume_003, TestSize.Level1)
1366 {
1367 int32_t ret = -1;
1368 AudioRendererOptions rendererOptions;
1369
1370 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1371 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1372 ASSERT_NE(nullptr, audioRenderer);
1373
1374 ret = audioRenderer->SetVolume(-0.5);
1375 EXPECT_NE(SUCCESS, ret);
1376
1377 ret = audioRenderer->SetVolume(1.5);
1378 EXPECT_NE(SUCCESS, ret);
1379
1380 bool isReleased = audioRenderer->Release();
1381 EXPECT_EQ(true, isReleased);
1382 }
1383
1384 /**
1385 * @tc.name : Test SetVolume
1386 * @tc.number: Audio_Renderer_SetVolume_Stability_001
1387 * @tc.desc : Test SetVolume interface stability.
1388 */
1389 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetVolume_Stability_001, TestSize.Level1)
1390 {
1391 AudioRendererOptions rendererOptions;
1392
1393 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1394 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1395 ASSERT_NE(nullptr, audioRenderer);
1396
1397 bool isStarted = audioRenderer->Start();
1398 EXPECT_EQ(true, isStarted);
1399
1400 thread renderThread(StartRenderThread, audioRenderer.get(), 0);
1401
1402 for (int i = 0; i < VALUE_THOUSAND; i++) {
1403 audioRenderer->SetVolume(0.1);
1404 audioRenderer->SetVolume(1.0);
1405 }
1406
1407 renderThread.join();
1408
1409 bool isStopped = audioRenderer->Stop();
1410 EXPECT_EQ(true, isStopped);
1411
1412 bool isReleased = audioRenderer->Release();
1413 EXPECT_EQ(true, isReleased);
1414 }
1415
1416 /**
1417 * @tc.name : Test GetVolume
1418 * @tc.number: Audio_Renderer_GetVolume_001
1419 * @tc.desc : Test GetVolume interface to get the default value.
1420 */
1421 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetVolume_001, TestSize.Level1)
1422 {
1423 AudioRendererOptions rendererOptions;
1424
1425 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1426 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1427 ASSERT_NE(nullptr, audioRenderer);
1428
1429 float volume = audioRenderer->GetVolume();
1430 EXPECT_EQ(1.0, volume);
1431
1432 bool isReleased = audioRenderer->Release();
1433 EXPECT_EQ(true, isReleased);
1434 }
1435
1436 /**
1437 * @tc.name : Test GetVolume
1438 * @tc.number: Audio_Renderer_GetVolume_002
1439 * @tc.desc : Test GetVolume interface after set volume call.
1440 */
1441 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetVolume_002, TestSize.Level1)
1442 {
1443 int32_t ret = -1;
1444 AudioRendererOptions rendererOptions;
1445
1446 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1447 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1448 ASSERT_NE(nullptr, audioRenderer);
1449
1450 ret = audioRenderer->SetVolume(0.5);
1451 EXPECT_EQ(SUCCESS, ret);
1452
1453 float volume = audioRenderer->GetVolume();
1454 EXPECT_EQ(0.5, volume);
1455
1456 bool isReleased = audioRenderer->Release();
1457 EXPECT_EQ(true, isReleased);
1458 }
1459
1460 /**
1461 * @tc.name : Test GetVolume
1462 * @tc.number: Audio_Renderer_GetVolume_003
1463 * @tc.desc : Test GetVolume interface after set volume fails.
1464 */
1465 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetVolume_003, TestSize.Level1)
1466 {
1467 int32_t ret = -1;
1468 AudioRendererOptions rendererOptions;
1469
1470 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1471 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1472 ASSERT_NE(nullptr, audioRenderer);
1473
1474 ret = audioRenderer->SetVolume(0.5);
1475 EXPECT_EQ(SUCCESS, ret);
1476
1477 ret = audioRenderer->SetVolume(1.5);
1478 EXPECT_NE(SUCCESS, ret);
1479
1480 float volume = audioRenderer->GetVolume();
1481 EXPECT_EQ(0.5, volume);
1482
1483 bool isReleased = audioRenderer->Release();
1484 EXPECT_EQ(true, isReleased);
1485 }
1486
1487 /**
1488 * @tc.name : Test SetRenderRate
1489 * @tc.number: Audio_Renderer_SetRenderRate_001
1490 * @tc.desc : Test SetRenderRate interface after set volume fails.
1491 */
1492 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRenderRate_001, TestSize.Level1)
1493 {
1494 int32_t ret = -1;
1495 AudioRendererOptions rendererOptions;
1496
1497 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1498 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1499 ASSERT_NE(nullptr, audioRenderer);
1500
1501 AudioRendererRate renderRate = RENDER_RATE_NORMAL;
1502 ret = audioRenderer->SetRenderRate(renderRate);
1503 EXPECT_EQ(SUCCESS, ret);
1504 audioRenderer->Release();
1505 }
1506
1507 /**
1508 * @tc.name : Test GetRenderRate
1509 * @tc.number: Audio_Renderer_GetRenderRate_001
1510 * @tc.desc : Test GetRenderRate interface after set volume fails.
1511 */
1512 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRenderRate_001, TestSize.Level1)
1513 {
1514 int32_t ret = -1;
1515 AudioRendererOptions rendererOptions;
1516
1517 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1518 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1519 ASSERT_NE(nullptr, audioRenderer);
1520
1521 ret = audioRenderer->SetRenderRate(RENDER_RATE_DOUBLE);
1522 EXPECT_EQ(SUCCESS, ret);
1523
1524 AudioRendererRate renderRate = audioRenderer->GetRenderRate();
1525 EXPECT_EQ(RENDER_RATE_DOUBLE, renderRate);
1526 audioRenderer->Release();
1527 }
1528
1529 /**
1530 * @tc.name : Test Start API via legal state, RENDERER_PREPARED.
1531 * @tc.number: Audio_Renderer_Start_001
1532 * @tc.desc : Test Start interface. Returns true if start is successful.
1533 */
1534 HWTEST(AudioRendererUnitTest, Audio_Renderer_Start_001, TestSize.Level1)
1535 {
1536 AudioRendererOptions rendererOptions;
1537
1538 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1539 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1540 ASSERT_NE(nullptr, audioRenderer);
1541
1542 bool isStarted = audioRenderer->Start();
1543 EXPECT_EQ(true, isStarted);
1544
1545 audioRenderer->Release();
1546 }
1547
1548 /**
1549 * @tc.name : Test Start API via illegal state, RENDERER_NEW: without initializing the renderer.
1550 * @tc.number: Audio_Renderer_Start_002
1551 * @tc.desc : Test Start interface. Returns false, if the renderer state is RENDERER_NEW.
1552 */
1553 HWTEST(AudioRendererUnitTest, Audio_Renderer_Start_002, TestSize.Level1)
1554 {
1555 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
1556 ASSERT_NE(nullptr, audioRenderer);
1557
1558 bool isStarted = audioRenderer->Start();
1559 EXPECT_EQ(false, isStarted);
1560 }
1561
1562 /**
1563 * @tc.name : Test Start API via illegal state, RENDERER_RELEASED: call Start after Release
1564 * @tc.number: Audio_Renderer_Start_003
1565 * @tc.desc : Test Start interface. Returns false, if the renderer state is RENDERER_RELEASED.
1566 */
1567 HWTEST(AudioRendererUnitTest, Audio_Renderer_Start_003, TestSize.Level1)
1568 {
1569 AudioRendererOptions rendererOptions;
1570
1571 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1572 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1573 ASSERT_NE(nullptr, audioRenderer);
1574
1575 bool isReleased = audioRenderer->Release();
1576 EXPECT_EQ(true, isReleased);
1577
1578 bool isStarted = audioRenderer->Start();
1579 EXPECT_EQ(false, isStarted);
1580
1581 audioRenderer->Release();
1582 }
1583
1584 /**
1585 * @tc.name : Test Start API via legal state, RENDERER_STOPPED: Start Stop and then Start again
1586 * @tc.number: Audio_Renderer_Start_004
1587 * @tc.desc : Test Start interface. Returns true, if the start is successful.
1588 */
1589 HWTEST(AudioRendererUnitTest, Audio_Renderer_Start_004, TestSize.Level1)
1590 {
1591 AudioRendererOptions rendererOptions;
1592
1593 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1594 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1595 ASSERT_NE(nullptr, audioRenderer);
1596
1597 bool isStarted = audioRenderer->Start();
1598 EXPECT_EQ(true, isStarted);
1599
1600 bool isStopped = audioRenderer->Stop();
1601 EXPECT_EQ(true, isStopped);
1602
1603 isStarted = audioRenderer->Start();
1604 EXPECT_EQ(true, isStarted);
1605
1606 audioRenderer->Release();
1607 }
1608
1609 /**
1610 * @tc.name : Test Start API via illegal state, RENDERER_RUNNING : call Start repeatedly
1611 * @tc.number: Audio_Renderer_Start_005
1612 * @tc.desc : Test Start interface. Returns false, if the renderer state is RENDERER_RUNNING.
1613 */
1614 HWTEST(AudioRendererUnitTest, Audio_Renderer_Start_005, TestSize.Level1)
1615 {
1616 AudioRendererOptions rendererOptions;
1617
1618 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1619 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1620 ASSERT_NE(nullptr, audioRenderer);
1621
1622 bool isStarted = audioRenderer->Start();
1623 EXPECT_EQ(true, isStarted);
1624
1625 isStarted = audioRenderer->Start();
1626 EXPECT_EQ(false, isStarted);
1627
1628 audioRenderer->Release();
1629 }
1630
1631 /**
1632 * @tc.name : Test Start API via legal state, RENDERER_PAUSED : call Start after pause
1633 * @tc.number: Audio_Renderer_Start_005
1634 * @tc.desc : Test Start interface. Returns false, if the renderer state is RENDERER_PAUSED.
1635 */
1636 HWTEST(AudioRendererUnitTest, Audio_Renderer_Start_006, TestSize.Level1)
1637 {
1638 AudioRendererOptions rendererOptions;
1639
1640 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1641 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1642 ASSERT_NE(nullptr, audioRenderer);
1643
1644 bool isStarted = audioRenderer->Start();
1645 EXPECT_EQ(true, isStarted);
1646
1647 bool isPaused = audioRenderer->Pause();
1648 EXPECT_EQ(true, isPaused);
1649
1650 isStarted = audioRenderer->Start();
1651 EXPECT_EQ(true, isStarted);
1652
1653 audioRenderer->Release();
1654 }
1655
1656 /**
1657 * @tc.name : Test Write API.
1658 * @tc.number: Audio_Renderer_Write_001
1659 * @tc.desc : Test Write interface. Returns number of bytes written, if the write is successful.
1660 */
1661
1662 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_001, TestSize.Level1)
1663 {
1664 int32_t ret = -1;
1665 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1666 ASSERT_NE(nullptr, wavFile);
1667
1668 AudioRendererOptions rendererOptions;
1669 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1670 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1671 ASSERT_NE(nullptr, audioRenderer);
1672
1673 bool isStarted = audioRenderer->Start();
1674 EXPECT_EQ(true, isStarted);
1675
1676 size_t bufferLen;
1677 ret = audioRenderer->GetBufferSize(bufferLen);
1678 EXPECT_EQ(SUCCESS, ret);
1679
1680 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1681 ASSERT_NE(nullptr, buffer);
1682
1683 size_t bytesToWrite = 0;
1684 int32_t bytesWritten = 0;
1685 size_t minBytes = 4;
1686 int32_t numBuffersToRender = WRITE_BUFFERS_COUNT;
1687
1688 while (numBuffersToRender) {
1689 bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1690 bytesWritten = 0;
1691 while ((static_cast<size_t>(bytesWritten) < bytesToWrite) &&
1692 ((static_cast<size_t>(bytesToWrite) - bytesWritten) > minBytes)) {
1693 bytesWritten += audioRenderer->Write(buffer + static_cast<size_t>(bytesWritten),
1694 bytesToWrite - static_cast<size_t>(bytesWritten));
1695 EXPECT_GE(bytesWritten, VALUE_ZERO);
1696 if (bytesWritten < 0) {
1697 break;
1698 }
1699 }
1700 numBuffersToRender--;
1701 }
1702
1703 audioRenderer->Drain();
1704 audioRenderer->Stop();
1705 audioRenderer->Release();
1706
1707 free(buffer);
1708 fclose(wavFile);
1709 }
1710
1711 /**
1712 * @tc.name : Test Write API via illegl state, RENDERER_NEW : without Initializing the renderer.
1713 * @tc.number: Audio_Renderer_Write_002
1714 * @tc.desc : Test Write interface. Returns error code, if the renderer state is RENDERER_NEW.
1715 * : bufferLen is invalid here, firstly bufferLen is validated in Write. So it returns ERR_INVALID_PARAM.
1716 */
1717 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_002, TestSize.Level1)
1718 {
1719 int32_t ret = -1;
1720 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1721 ASSERT_NE(nullptr, wavFile);
1722
1723 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
1724 ASSERT_NE(nullptr, audioRenderer);
1725
1726 bool isStarted = audioRenderer->Start();
1727 EXPECT_EQ(false, isStarted);
1728
1729 size_t bufferLen;
1730 ret = audioRenderer->GetBufferSize(bufferLen);
1731 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
1732
1733 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1734 ASSERT_NE(nullptr, buffer);
1735
1736 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1737 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
1738 EXPECT_EQ(ERR_INVALID_PARAM, bytesWritten);
1739
1740 free(buffer);
1741 fclose(wavFile);
1742 }
1743
1744 /**
1745 * @tc.name : Test Write API via illegl state, RENDERER_PREPARED : Write without Start.
1746 * @tc.number: Audio_Renderer_Write_003
1747 * @tc.desc : Test Write interface. Returns error code, if the renderer state is not RENDERER_RUNNING.
1748 */
1749 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_003, TestSize.Level1)
1750 {
1751 int32_t ret = -1;
1752 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1753 ASSERT_NE(nullptr, wavFile);
1754
1755 AudioRendererOptions rendererOptions;
1756
1757 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1758 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1759 ASSERT_NE(nullptr, audioRenderer);
1760
1761 size_t bufferLen;
1762 ret = audioRenderer->GetBufferSize(bufferLen);
1763 EXPECT_EQ(SUCCESS, ret);
1764
1765 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1766 ASSERT_NE(nullptr, buffer);
1767
1768 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1769 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
1770 EXPECT_EQ(ERR_ILLEGAL_STATE, bytesWritten);
1771
1772 audioRenderer->Release();
1773
1774 free(buffer);
1775 fclose(wavFile);
1776 }
1777
1778 /**
1779 * @tc.name : Test Write API via illegal input, bufferLength = 0.
1780 * @tc.number: Audio_Renderer_Write_004
1781 * @tc.desc : Test Write interface. Returns error code, if the bufferLength <= 0.
1782 */
1783 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_004, TestSize.Level1)
1784 {
1785 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1786 ASSERT_NE(nullptr, wavFile);
1787
1788 AudioRendererOptions rendererOptions;
1789
1790 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1791 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1792 ASSERT_NE(nullptr, audioRenderer);
1793
1794 bool isStarted = audioRenderer->Start();
1795 EXPECT_EQ(true, isStarted);
1796
1797 size_t bufferLen = 0;
1798
1799 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1800 ASSERT_NE(nullptr, buffer);
1801
1802 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1803 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
1804 EXPECT_EQ(ERR_INVALID_PARAM, bytesWritten);
1805
1806 audioRenderer->Stop();
1807 audioRenderer->Release();
1808
1809 free(buffer);
1810 fclose(wavFile);
1811 }
1812
1813 /**
1814 * @tc.name : Test Write API via illegal input, buffer = nullptr.
1815 * @tc.number: Audio_Renderer_Write_005
1816 * @tc.desc : Test Write interface. Returns error code, if the buffer = nullptr.
1817 */
1818 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_005, TestSize.Level1)
1819 {
1820 int32_t ret = -1;
1821 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1822 ASSERT_NE(nullptr, wavFile);
1823
1824 AudioRendererOptions rendererOptions;
1825
1826 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1827 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1828 ASSERT_NE(nullptr, audioRenderer);
1829
1830 bool isStarted = audioRenderer->Start();
1831 EXPECT_EQ(true, isStarted);
1832
1833 size_t bufferLen;
1834 ret = audioRenderer->GetBufferSize(bufferLen);
1835 EXPECT_EQ(SUCCESS, ret);
1836
1837 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1838 ASSERT_NE(nullptr, buffer);
1839
1840 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1841 uint8_t *buffer_null = nullptr;
1842 int32_t bytesWritten = audioRenderer->Write(buffer_null, bytesToWrite);
1843 EXPECT_EQ(ERR_INVALID_PARAM, bytesWritten);
1844
1845 audioRenderer->Stop();
1846 audioRenderer->Release();
1847
1848 free(buffer);
1849 fclose(wavFile);
1850 }
1851
1852 /**
1853 * @tc.name : Test Write API via illegal state, RENDERER_STOPPED: Write after Stop
1854 * @tc.number: Audio_Renderer_Write_006
1855 * @tc.desc : Test Write interface. Returns error code, if the renderer state is not RENDERER_RUNNING
1856 */
1857 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_006, TestSize.Level1)
1858 {
1859 int32_t ret = -1;
1860 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1861 ASSERT_NE(nullptr, wavFile);
1862
1863 AudioRendererOptions rendererOptions;
1864
1865 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1866 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1867 ASSERT_NE(nullptr, audioRenderer);
1868
1869 bool isStarted = audioRenderer->Start();
1870 EXPECT_EQ(true, isStarted);
1871
1872 size_t bufferLen;
1873 ret = audioRenderer->GetBufferSize(bufferLen);
1874 EXPECT_EQ(SUCCESS, ret);
1875
1876 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1877 ASSERT_NE(nullptr, buffer);
1878
1879 bool isStopped = audioRenderer->Stop();
1880 EXPECT_EQ(true, isStopped);
1881
1882 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1883 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
1884 EXPECT_EQ(ERR_ILLEGAL_STATE, bytesWritten);
1885
1886 audioRenderer->Release();
1887
1888 free(buffer);
1889 fclose(wavFile);
1890 }
1891
1892 /**
1893 * @tc.name : Test Write API via illegal state, RENDERER_RELEASED: Write after Release
1894 * @tc.number: Audio_Renderer_Write_007
1895 * @tc.desc : Test Write interface. Returns error code, if the renderer state is not RENDERER_RUNNING
1896 */
1897 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_007, TestSize.Level1)
1898 {
1899 int32_t ret = -1;
1900 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1901 ASSERT_NE(nullptr, wavFile);
1902
1903 AudioRendererOptions rendererOptions;
1904
1905 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1906 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1907 ASSERT_NE(nullptr, audioRenderer);
1908
1909 bool isStarted = audioRenderer->Start();
1910 EXPECT_EQ(true, isStarted);
1911
1912 size_t bufferLen;
1913 ret = audioRenderer->GetBufferSize(bufferLen);
1914 EXPECT_EQ(SUCCESS, ret);
1915
1916 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1917 ASSERT_NE(nullptr, buffer);
1918
1919 bool isReleased = audioRenderer->Release();
1920 EXPECT_EQ(true, isReleased);
1921
1922 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1923 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
1924 EXPECT_EQ(ERR_ILLEGAL_STATE, bytesWritten);
1925
1926 free(buffer);
1927 fclose(wavFile);
1928 }
1929
1930 /**
1931 * @tc.name : Test Write API.
1932 * @tc.number: Audio_Renderer_Write_008
1933 * @tc.desc : Test Write interface after pause and resume. Returns number of bytes written, if the write is successful.
1934 */
1935
1936 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_008, TestSize.Level1)
1937 {
1938 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1939 ASSERT_NE(nullptr, wavFile);
1940
1941 AudioRendererOptions rendererOptions;
1942
1943 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1944 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1945 ASSERT_NE(nullptr, audioRenderer);
1946
1947 bool isStarted = audioRenderer->Start();
1948 EXPECT_EQ(true, isStarted);
1949
1950 size_t bufferLen;
1951 int32_t ret = audioRenderer->GetBufferSize(bufferLen);
1952 EXPECT_EQ(SUCCESS, ret);
1953
1954 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1955 ASSERT_NE(nullptr, buffer);
1956
1957 size_t bytesToWrite = 0;
1958 int32_t bytesWritten = 0;
1959 size_t minBytes = 4;
1960 int32_t numBuffersToRender = WRITE_BUFFERS_COUNT;
1961 bool pauseTested = false;
1962
1963 while (numBuffersToRender) {
1964 bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1965 bytesWritten = 0;
1966 uint64_t currFilePos = ftell(wavFile);
1967 if (!pauseTested && (currFilePos > PAUSE_BUFFER_POSITION) && audioRenderer->Pause()) {
1968 pauseTested = true;
1969 sleep(PAUSE_RENDER_TIME_SECONDS);
1970 isStarted = audioRenderer->Start();
1971 EXPECT_EQ(true, isStarted);
1972
1973 ret = audioRenderer->SetVolume(0.5);
1974 EXPECT_EQ(SUCCESS, ret);
1975 float volume = audioRenderer->GetVolume();
1976 EXPECT_EQ(0.5, volume);
1977 }
1978
1979 while ((static_cast<size_t>(bytesWritten) < bytesToWrite) &&
1980 ((static_cast<size_t>(bytesToWrite) - bytesWritten) > minBytes)) {
1981 bytesWritten += audioRenderer->Write(buffer + static_cast<size_t>(bytesWritten),
1982 bytesToWrite - static_cast<size_t>(bytesWritten));
1983 EXPECT_GE(bytesWritten, VALUE_ZERO);
1984 if (bytesWritten < 0) {
1985 break;
1986 }
1987 }
1988 numBuffersToRender--;
1989 }
1990
1991 audioRenderer->Drain();
1992 audioRenderer->Stop();
1993 audioRenderer->Release();
1994
1995 free(buffer);
1996 fclose(wavFile);
1997 }
1998
1999 /**
2000 * @tc.name : Test Write API via illegl render mode, RENDER_MODE_CALLBACK.
2001 * @tc.number: Audio_Renderer_Write_009
2002 * @tc.desc : Test Write interface. Returns error code, if the render mode is RENDER_MODE_CALLBACK.
2003 * : In RENDER_MODE_CALLBACK Write API call not supported. By default render mode is RENDER_MODE_NORMAL.
2004 */
2005 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_009, TestSize.Level1)
2006 {
2007 int32_t ret = -1;
2008 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2009 ASSERT_NE(nullptr, wavFile);
2010
2011 AudioRendererOptions rendererOptions;
2012
2013 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2014 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2015 ASSERT_NE(nullptr, audioRenderer);
2016
2017 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
2018 EXPECT_EQ(SUCCESS, ret);
2019
2020 size_t bufferLen;
2021 ret = audioRenderer->GetBufferSize(bufferLen);
2022 EXPECT_EQ(SUCCESS, ret);
2023
2024 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2025 ASSERT_NE(nullptr, buffer);
2026
2027 bool isStarted = audioRenderer->Start();
2028 EXPECT_EQ(true, isStarted);
2029
2030 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2031 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2032 EXPECT_EQ(ERR_INCORRECT_MODE, bytesWritten);
2033
2034 audioRenderer->Release();
2035
2036 free(buffer);
2037 fclose(wavFile);
2038 }
2039
2040 /**
2041 * @tc.name : Test GetAudioTime API via legal input.
2042 * @tc.number: Audio_Renderer_GetAudioTime_001
2043 * @tc.desc : Test GetAudioTime interface. Returns true, if the getting is successful.
2044 */
2045 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioTime_001, TestSize.Level1)
2046 {
2047 int32_t ret = -1;
2048 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2049 ASSERT_NE(nullptr, wavFile);
2050
2051 AudioRendererOptions rendererOptions;
2052
2053 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2054 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2055 ASSERT_NE(nullptr, audioRenderer);
2056
2057 bool isStarted = audioRenderer->Start();
2058 EXPECT_EQ(true, isStarted);
2059
2060 size_t bufferLen;
2061 ret = audioRenderer->GetBufferSize(bufferLen);
2062 EXPECT_EQ(SUCCESS, ret);
2063
2064 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2065 ASSERT_NE(nullptr, buffer);
2066
2067 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2068 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2069 EXPECT_GE(bytesWritten, VALUE_ZERO);
2070
2071 Timestamp timeStamp;
2072 bool getAudioTime = audioRenderer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
2073 EXPECT_EQ(true, getAudioTime);
2074 EXPECT_GE(timeStamp.time.tv_sec, (const long)VALUE_ZERO);
2075 EXPECT_GE(timeStamp.time.tv_nsec, (const long)VALUE_ZERO);
2076
2077 audioRenderer->Drain();
2078 audioRenderer->Stop();
2079 audioRenderer->Release();
2080
2081 free(buffer);
2082 fclose(wavFile);
2083 }
2084
2085 /**
2086 * @tc.name : Test GetAudioTime API via illegal state, RENDERER_NEW: GetAudioTime without initializing the renderer.
2087 * @tc.number: Audio_Renderer_GetAudioTime_002
2088 * @tc.desc : Test GetAudioTime interface. Returns false, if the renderer state is RENDERER_NEW
2089 */
2090 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioTime_002, TestSize.Level1)
2091 {
2092 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
2093 ASSERT_NE(nullptr, audioRenderer);
2094
2095 Timestamp timeStamp;
2096 bool getAudioTime = audioRenderer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
2097 EXPECT_EQ(false, getAudioTime);
2098 }
2099
2100 /**
2101 * @tc.name : Test GetAudioTime API via legal state, RENDERER_RUNNING.
2102 * @tc.number: Audio_Renderer_GetAudioTime_003
2103 * @tc.desc : test GetAudioTime interface. Returns true, if the getting is successful.
2104 */
2105 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioTime_003, TestSize.Level1)
2106 {
2107 AudioRendererOptions rendererOptions;
2108
2109 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2110 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2111 ASSERT_NE(nullptr, audioRenderer);
2112
2113 bool isStarted = audioRenderer->Start();
2114 EXPECT_EQ(true, isStarted);
2115
2116 Timestamp timeStamp;
2117 bool getAudioTime = audioRenderer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
2118 EXPECT_EQ(true, getAudioTime);
2119
2120 audioRenderer->Release();
2121 }
2122
2123 /**
2124 * @tc.name : Test GetAudioTime API via legal state, RENDERER_STOPPED.
2125 * @tc.number: Audio_Renderer_GetAudioTime_004
2126 * @tc.desc : Test GetAudioTime interface. Returns true, if the getting is successful.
2127 */
2128 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioTime_004, TestSize.Level1)
2129 {
2130 AudioRendererOptions rendererOptions;
2131
2132 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2133 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2134 ASSERT_NE(nullptr, audioRenderer);
2135
2136 bool isStarted = audioRenderer->Start();
2137 EXPECT_EQ(true, isStarted);
2138
2139 bool isStopped = audioRenderer->Stop();
2140 EXPECT_EQ(true, isStopped);
2141
2142 Timestamp timeStamp;
2143 bool getAudioTime = audioRenderer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
2144 EXPECT_EQ(false, getAudioTime);
2145
2146 audioRenderer->Release();
2147 }
2148
2149 /**
2150 * @tc.name : Test GetAudioTime API via illegal state, RENDERER_RELEASED: GetAudioTime after Release.
2151 * @tc.number: Audio_Renderer_GetAudioTime_005
2152 * @tc.desc : Test GetAudioTime interface. Returns false, if the renderer state is RENDERER_RELEASED
2153 */
2154 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioTime_005, TestSize.Level1)
2155 {
2156 AudioRendererOptions rendererOptions;
2157
2158 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2159 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2160 ASSERT_NE(nullptr, audioRenderer);
2161
2162 bool isStarted = audioRenderer->Start();
2163 EXPECT_EQ(true, isStarted);
2164
2165 bool isStopped = audioRenderer->Stop();
2166 EXPECT_EQ(true, isStopped);
2167
2168 bool isReleased = audioRenderer->Release();
2169 EXPECT_EQ(true, isReleased);
2170
2171 Timestamp timeStamp;
2172 bool getAudioTime = audioRenderer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
2173 EXPECT_EQ(false, getAudioTime);
2174 }
2175
2176 /**
2177 * @tc.name : Test GetAudioTime API via legal state, RENDERER_PAUSED.
2178 * @tc.number: Audio_Renderer_GetAudioTime_006
2179 * @tc.desc : Test GetAudioTime interface. Returns true, if the getting is successful.
2180 */
2181 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioTime_006, TestSize.Level1)
2182 {
2183 AudioRendererOptions rendererOptions;
2184
2185 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2186 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2187 ASSERT_NE(nullptr, audioRenderer);
2188
2189 bool isStarted = audioRenderer->Start();
2190 EXPECT_EQ(true, isStarted);
2191
2192 bool isPaused = audioRenderer->Pause();
2193 EXPECT_EQ(true, isPaused);
2194
2195 Timestamp timeStamp;
2196 bool getAudioTime = audioRenderer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
2197 EXPECT_EQ(true, getAudioTime);
2198
2199 audioRenderer->Release();
2200 }
2201
2202 /**
2203 * @tc.name : Test Drain API.
2204 * @tc.number: Audio_Renderer_Drain_001
2205 * @tc.desc : Test Drain interface. Returns true, if the flush is successful.
2206 */
2207 HWTEST(AudioRendererUnitTest, Audio_Renderer_Drain_001, TestSize.Level1)
2208 {
2209 int32_t ret = -1;
2210 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2211 ASSERT_NE(nullptr, wavFile);
2212
2213 AudioRendererOptions rendererOptions;
2214
2215 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2216 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2217 ASSERT_NE(nullptr, audioRenderer);
2218
2219 bool isStarted = audioRenderer->Start();
2220 EXPECT_EQ(true, isStarted);
2221
2222 size_t bufferLen;
2223 ret = audioRenderer->GetBufferSize(bufferLen);
2224 EXPECT_EQ(SUCCESS, ret);
2225
2226 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2227 ASSERT_NE(nullptr, buffer);
2228
2229 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2230 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2231 EXPECT_GE(bytesWritten, VALUE_ZERO);
2232
2233 bool isDrained = audioRenderer->Drain();
2234 EXPECT_EQ(true, isDrained);
2235
2236 audioRenderer->Stop();
2237 audioRenderer->Release();
2238
2239 free(buffer);
2240 fclose(wavFile);
2241 }
2242
2243 /**
2244 * @tc.name : Test Drain API via illegal state, RENDERER_NEW: Without initializing the renderer.
2245 * @tc.number: Audio_Renderer_Drain_002
2246 * @tc.desc : Test Drain interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2247 */
2248 HWTEST(AudioRendererUnitTest, Audio_Renderer_Drain_002, TestSize.Level1)
2249 {
2250 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
2251 ASSERT_NE(nullptr, audioRenderer);
2252
2253 bool isDrained = audioRenderer->Drain();
2254 EXPECT_EQ(false, isDrained);
2255
2256 audioRenderer->Release();
2257 }
2258
2259 /**
2260 * @tc.name : Test Drain API via illegal state, RENDERER_PREPARED: Without Start.
2261 * @tc.number: Audio_Renderer_Drain_003
2262 * @tc.desc : Test Drain interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2263 */
2264 HWTEST(AudioRendererUnitTest, Audio_Renderer_Drain_003, TestSize.Level1)
2265 {
2266 AudioRendererOptions rendererOptions;
2267
2268 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2269 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2270 ASSERT_NE(nullptr, audioRenderer);
2271
2272 bool isDrained = audioRenderer->Drain();
2273 EXPECT_EQ(false, isDrained);
2274
2275 audioRenderer->Release();
2276 }
2277
2278 /**
2279 * @tc.name : Test Drain API via illegal state, RENDERER_STOPPED: call Stop before Drain.
2280 * @tc.number: Audio_Renderer_Drain_004
2281 * @tc.desc : Test Drain interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2282 */
2283 HWTEST(AudioRendererUnitTest, Audio_Renderer_Drain_004, TestSize.Level1)
2284 {
2285 AudioRendererOptions rendererOptions;
2286
2287 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2288 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2289 ASSERT_NE(nullptr, audioRenderer);
2290
2291 bool isStarted = audioRenderer->Start();
2292 EXPECT_EQ(true, isStarted);
2293
2294 bool isStopped = audioRenderer->Stop();
2295 EXPECT_EQ(true, isStopped);
2296
2297 bool isDrained = audioRenderer->Drain();
2298 EXPECT_EQ(false, isDrained);
2299
2300 audioRenderer->Release();
2301 }
2302
2303 /**
2304 * @tc.name : Test Drain API via illegal state, RENDERER_RELEASED: call Release before Drain.
2305 * @tc.number: Audio_Renderer_Drain_005
2306 * @tc.desc : Test Drain interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2307 */
2308 HWTEST(AudioRendererUnitTest, Audio_Renderer_Drain_005, TestSize.Level1)
2309 {
2310 AudioRendererOptions rendererOptions;
2311
2312 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2313 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2314 ASSERT_NE(nullptr, audioRenderer);
2315
2316 bool isStarted = audioRenderer->Start();
2317 EXPECT_EQ(true, isStarted);
2318
2319 bool isReleased = audioRenderer->Release();
2320 EXPECT_EQ(true, isReleased);
2321
2322 bool isDrained = audioRenderer->Drain();
2323 EXPECT_EQ(false, isDrained);
2324
2325 audioRenderer->Release();
2326 }
2327
2328 /**
2329 * @tc.name : Test Drain API via illegal state, RENDERER_PAUSED: call Pause before Drain.
2330 * @tc.number: Audio_Renderer_Drain_006
2331 * @tc.desc : Test Drain interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2332 */
2333 HWTEST(AudioRendererUnitTest, Audio_Renderer_Drain_006, TestSize.Level1)
2334 {
2335 AudioRendererOptions rendererOptions;
2336
2337 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2338 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2339 ASSERT_NE(nullptr, audioRenderer);
2340
2341 bool isStarted = audioRenderer->Start();
2342 EXPECT_EQ(true, isStarted);
2343
2344 bool isPaused = audioRenderer->Pause();
2345 EXPECT_EQ(true, isPaused);
2346
2347 bool isDrained = audioRenderer->Drain();
2348 EXPECT_EQ(false, isDrained);
2349
2350 audioRenderer->Release();
2351 }
2352
2353 /**
2354 * @tc.name : Test Drain API stability.
2355 * @tc.number: Audio_Renderer_Drain_Stability_001
2356 * @tc.desc : Test Drain interface stability.
2357 */
2358 HWTEST(AudioRendererUnitTest, Audio_Renderer_Drain_Stability_001, TestSize.Level1)
2359 {
2360 AudioRendererOptions rendererOptions;
2361
2362 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2363 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2364 ASSERT_NE(nullptr, audioRenderer);
2365
2366 bool isStarted = audioRenderer->Start();
2367 EXPECT_EQ(true, isStarted);
2368
2369 thread renderThread(StartRenderThread, audioRenderer.get(), 0);
2370
2371 for (int i = 0; i < VALUE_THOUSAND; i++) {
2372 bool isDrained = audioRenderer->Drain();
2373 EXPECT_EQ(true, isDrained);
2374 }
2375
2376 renderThread.join();
2377
2378 bool isStopped = audioRenderer->Stop();
2379 EXPECT_EQ(true, isStopped);
2380
2381 bool isReleased = audioRenderer->Release();
2382 EXPECT_EQ(true, isReleased);
2383 }
2384
2385 /**
2386 * @tc.name : Test Flush API.
2387 * @tc.number: Audio_Renderer_Flush_001
2388 * @tc.desc : Test Flush interface. Returns true, if the flush is successful.
2389 */
2390 HWTEST(AudioRendererUnitTest, Audio_Renderer_Flush_001, TestSize.Level1)
2391 {
2392 int32_t ret = -1;
2393 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2394 ASSERT_NE(nullptr, wavFile);
2395
2396 AudioRendererOptions rendererOptions;
2397
2398 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2399 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2400 ASSERT_NE(nullptr, audioRenderer);
2401
2402 bool isStarted = audioRenderer->Start();
2403 EXPECT_EQ(true, isStarted);
2404
2405 size_t bufferLen;
2406 ret = audioRenderer->GetBufferSize(bufferLen);
2407 EXPECT_EQ(SUCCESS, ret);
2408
2409 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2410 ASSERT_NE(nullptr, buffer);
2411
2412 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2413 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2414 EXPECT_GE(bytesWritten, VALUE_ZERO);
2415
2416 bool isFlushed = audioRenderer->Flush();
2417 EXPECT_EQ(true, isFlushed);
2418
2419 audioRenderer->Release();
2420
2421 free(buffer);
2422 fclose(wavFile);
2423 }
2424
2425 /**
2426 * @tc.name : Test Flush API.
2427 * @tc.number: Audio_Renderer_Flush_002
2428 * @tc.desc : Test Flush interface after Pause call. Returns true, if the flush is successful.
2429 */
2430 HWTEST(AudioRendererUnitTest, Audio_Renderer_Flush_002, TestSize.Level1)
2431 {
2432 int32_t ret = -1;
2433 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2434 ASSERT_NE(nullptr, wavFile);
2435
2436 AudioRendererOptions rendererOptions;
2437
2438 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2439 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2440 ASSERT_NE(nullptr, audioRenderer);
2441
2442 bool isStarted = audioRenderer->Start();
2443 EXPECT_EQ(true, isStarted);
2444
2445 size_t bufferLen;
2446 ret = audioRenderer->GetBufferSize(bufferLen);
2447 EXPECT_EQ(SUCCESS, ret);
2448
2449 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2450 ASSERT_NE(nullptr, buffer);
2451
2452 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2453 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2454 EXPECT_GE(bytesWritten, VALUE_ZERO);
2455
2456 audioRenderer->Pause();
2457
2458 bool isFlushed = audioRenderer->Flush();
2459 EXPECT_EQ(true, isFlushed);
2460
2461 audioRenderer->Release();
2462
2463 free(buffer);
2464 fclose(wavFile);
2465 }
2466
2467 /**
2468 * @tc.name : Test Flush API via illegal state, RENDERER_NEW: Without initializing the renderer.
2469 * @tc.number: Audio_Renderer_Flush_003
2470 * @tc.desc : Test Flush interface. Returns false, if the renderer state is not RENDERER_RUNNING or RENDERER_PAUSED.
2471 */
2472 HWTEST(AudioRendererUnitTest, Audio_Renderer_Flush_003, TestSize.Level1)
2473 {
2474 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
2475 ASSERT_NE(nullptr, audioRenderer);
2476
2477 bool isFlushed = audioRenderer->Flush();
2478 EXPECT_EQ(false, isFlushed);
2479 }
2480
2481 /**
2482 * @tc.name : Test Flush API via illegal state, RENDERER_PREPARED: Without Start.
2483 * @tc.number: Audio_Renderer_Flush_004
2484 * @tc.desc : Test Flush interface. Returns false, if the renderer state is not RENDERER_RUNNING or RENDERER_PAUSED.
2485 */
2486 HWTEST(AudioRendererUnitTest, Audio_Renderer_Flush_004, TestSize.Level1)
2487 {
2488 AudioRendererOptions rendererOptions;
2489
2490 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2491 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2492 ASSERT_NE(nullptr, audioRenderer);
2493
2494 bool isFlushed = audioRenderer->Flush();
2495 EXPECT_EQ(false, isFlushed);
2496
2497 audioRenderer->Release();
2498 }
2499
2500 /**
2501 * @tc.name : Test Flush API: call Stop before Flush.
2502 * @tc.number: Audio_Renderer_Flush_005
2503 * @tc.desc : Test Flush interface. Returns true, if the renderer state is RENDERER_STOPPED.
2504 */
2505 HWTEST(AudioRendererUnitTest, Audio_Renderer_Flush_005, TestSize.Level1)
2506 {
2507 AudioRendererOptions rendererOptions;
2508
2509 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2510 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2511 ASSERT_NE(nullptr, audioRenderer);
2512
2513 bool isStarted = audioRenderer->Start();
2514 EXPECT_EQ(true, isStarted);
2515
2516 bool isStopped = audioRenderer->Stop();
2517 EXPECT_EQ(true, isStopped);
2518
2519 bool isFlushed = audioRenderer->Flush();
2520 EXPECT_EQ(true, isFlushed);
2521
2522 audioRenderer->Release();
2523 }
2524
2525 /**
2526 * @tc.name : Test Flush API via illegal state, RENDERER_RELEASED: call Release before Flush.
2527 * @tc.number: Audio_Renderer_Flush_006
2528 * @tc.desc : Test Flush interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2529 */
2530 HWTEST(AudioRendererUnitTest, Audio_Renderer_Flush_006, TestSize.Level1)
2531 {
2532 AudioRendererOptions rendererOptions;
2533
2534 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2535 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2536 ASSERT_NE(nullptr, audioRenderer);
2537
2538 bool isStarted = audioRenderer->Start();
2539 EXPECT_EQ(true, isStarted);
2540
2541 bool isReleased = audioRenderer->Release();
2542 EXPECT_EQ(true, isReleased);
2543
2544 bool isFlushed = audioRenderer->Flush();
2545 EXPECT_EQ(false, isFlushed);
2546 }
2547
2548 /**
2549 * @tc.name : Test Flush API stability.
2550 * @tc.number: Audio_Renderer_Flush_Stability_001
2551 * @tc.desc : Test Flush interface stability.
2552 */
2553 HWTEST(AudioRendererUnitTest, Audio_Renderer_Flush_Stability_001, TestSize.Level1)
2554 {
2555 AudioRendererOptions rendererOptions;
2556
2557 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2558 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2559 ASSERT_NE(nullptr, audioRenderer);
2560
2561 bool isStarted = audioRenderer->Start();
2562 EXPECT_EQ(true, isStarted);
2563
2564 thread renderThread(StartRenderThread, audioRenderer.get(), 0);
2565
2566 for (int i = 0; i < VALUE_THOUSAND; i++) {
2567 bool isFlushed = audioRenderer->Flush();
2568 EXPECT_EQ(true, isFlushed);
2569 }
2570
2571 renderThread.join();
2572
2573 bool isStopped = audioRenderer->Stop();
2574 EXPECT_EQ(true, isStopped);
2575
2576 bool isReleased = audioRenderer->Release();
2577 EXPECT_EQ(true, isReleased);
2578 }
2579
2580 /**
2581 * @tc.name : Test Pause API.
2582 * @tc.number: Audio_Renderer_Pause_001
2583 * @tc.desc : Test Pause interface. Returns true, if the pause is successful.
2584 */
2585 HWTEST(AudioRendererUnitTest, Audio_Renderer_Pause_001, TestSize.Level1)
2586 {
2587 int32_t ret = -1;
2588 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2589 ASSERT_NE(nullptr, wavFile);
2590
2591 AudioRendererOptions rendererOptions;
2592
2593 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2594 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2595 ASSERT_NE(nullptr, audioRenderer);
2596
2597 bool isStarted = audioRenderer->Start();
2598 EXPECT_EQ(true, isStarted);
2599
2600 size_t bufferLen;
2601 ret = audioRenderer->GetBufferSize(bufferLen);
2602 EXPECT_EQ(SUCCESS, ret);
2603
2604 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2605 ASSERT_NE(nullptr, buffer);
2606
2607 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2608 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2609 EXPECT_GE(bytesWritten, VALUE_ZERO);
2610
2611 audioRenderer->Drain();
2612
2613 bool isPaused = audioRenderer->Pause();
2614 EXPECT_EQ(true, isPaused);
2615
2616 audioRenderer->Release();
2617
2618 free(buffer);
2619 fclose(wavFile);
2620 }
2621
2622 /**
2623 * @tc.name : Test Pause API via illegal state, RENDERER_NEW: call Pause without Initializing the renderer.
2624 * @tc.number: Audio_Renderer_Pause_002
2625 * @tc.desc : Test Pause interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2626 */
2627 HWTEST(AudioRendererUnitTest, Audio_Renderer_Pause_002, TestSize.Level1)
2628 {
2629 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
2630 ASSERT_NE(nullptr, audioRenderer);
2631
2632 bool isPaused = audioRenderer->Pause();
2633 EXPECT_EQ(false, isPaused);
2634 }
2635
2636 /**
2637 * @tc.name : Test Pause API via illegal state, RENDERER_PREPARED: call Pause without Start.
2638 * @tc.number: Audio_Renderer_Pause_003
2639 * @tc.desc : Test Pause interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2640 */
2641 HWTEST(AudioRendererUnitTest, Audio_Renderer_Pause_003, TestSize.Level1)
2642 {
2643 AudioRendererOptions rendererOptions;
2644
2645 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2646 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2647 ASSERT_NE(nullptr, audioRenderer);
2648
2649 bool isPaused = audioRenderer->Pause();
2650 EXPECT_EQ(false, isPaused);
2651
2652 audioRenderer->Release();
2653 }
2654
2655 /**
2656 * @tc.name : Test Pause API via illegal state, RENDERER_RELEASED: call Pause after Release.
2657 * @tc.number: Audio_Renderer_Pause_004
2658 * @tc.desc : Test Pause interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2659 */
2660 HWTEST(AudioRendererUnitTest, Audio_Renderer_Pause_004, TestSize.Level1)
2661 {
2662 AudioRendererOptions rendererOptions;
2663
2664 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2665 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2666 ASSERT_NE(nullptr, audioRenderer);
2667
2668 bool isStarted = audioRenderer->Start();
2669 EXPECT_EQ(true, isStarted);
2670
2671 bool isReleased = audioRenderer->Release();
2672 EXPECT_EQ(true, isReleased);
2673
2674 bool isPaused = audioRenderer->Pause();
2675 EXPECT_EQ(false, isPaused);
2676 }
2677
2678 /**
2679 * @tc.name : Test Pause and resume
2680 * @tc.number: Audio_Renderer_Pause_005
2681 * @tc.desc : Test Pause interface. Returns true , if the pause is successful.
2682 */
2683 HWTEST(AudioRendererUnitTest, Audio_Renderer_Pause_005, TestSize.Level1)
2684 {
2685 AudioRendererOptions rendererOptions;
2686
2687 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2688 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2689 ASSERT_NE(nullptr, audioRenderer);
2690
2691 bool isStarted = audioRenderer->Start();
2692 EXPECT_EQ(true, isStarted);
2693
2694 bool isPaused = audioRenderer->Pause();
2695 EXPECT_EQ(true, isPaused);
2696
2697 isStarted = audioRenderer->Start();
2698 EXPECT_EQ(true, isStarted);
2699
2700 audioRenderer->Stop();
2701 audioRenderer->Release();
2702 }
2703
2704 /**
2705 * @tc.name : Test Pause API via illegal state, RENDERER_STOPPED: call Pause after Stop.
2706 * @tc.number: Audio_Renderer_Pause_006
2707 * @tc.desc : Test Pause interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2708 */
2709 HWTEST(AudioRendererUnitTest, Audio_Renderer_Pause_006, TestSize.Level1)
2710 {
2711 AudioRendererOptions rendererOptions;
2712
2713 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2714 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2715 ASSERT_NE(nullptr, audioRenderer);
2716
2717 bool isStarted = audioRenderer->Start();
2718 EXPECT_EQ(true, isStarted);
2719
2720 bool isStopped = audioRenderer->Stop();
2721 EXPECT_EQ(true, isStopped);
2722
2723 bool isPaused = audioRenderer->Pause();
2724 EXPECT_EQ(false, isPaused);
2725 audioRenderer->Release();
2726 }
2727
2728 /**
2729 * @tc.name : Test Pause and resume
2730 * @tc.number: Audio_Renderer_Pause_Stability_001
2731 * @tc.desc : Test Pause interface for stability.
2732 */
2733 HWTEST(AudioRendererUnitTest, Audio_Renderer_Pause_Stability_001, TestSize.Level1)
2734 {
2735 int32_t ret = -1;
2736 AudioRendererOptions rendererOptions;
2737
2738 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2739 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2740 ASSERT_NE(nullptr, audioRenderer);
2741
2742 bool isStarted = audioRenderer->Start();
2743 EXPECT_EQ(true, isStarted);
2744
2745 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2746 ASSERT_NE(nullptr, wavFile);
2747
2748 size_t bufferLen;
2749 ret = audioRenderer->GetBufferSize(bufferLen);
2750 EXPECT_EQ(SUCCESS, ret);
2751
2752 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2753 ASSERT_NE(nullptr, buffer);
2754
2755 size_t bytesToWrite = 0;
2756 int32_t bytesWritten = 0;
2757 size_t minBytes = 4;
2758 int32_t numBuffersToRender = WRITE_BUFFERS_COUNT;
2759
2760 while (numBuffersToRender) {
2761 bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2762 bytesWritten = 0;
2763 while ((static_cast<size_t>(bytesWritten) < bytesToWrite) &&
2764 ((static_cast<size_t>(bytesToWrite) - bytesWritten) > minBytes)) {
2765 bytesWritten += audioRenderer->Write(buffer + static_cast<size_t>(bytesWritten),
2766 bytesToWrite - static_cast<size_t>(bytesWritten));
2767 EXPECT_GE(bytesWritten, VALUE_ZERO);
2768 if (bytesWritten < 0) {
2769 break;
2770 }
2771 }
2772 EXPECT_EQ(true, audioRenderer->Pause());
2773 EXPECT_EQ(true, audioRenderer->Start());
2774 numBuffersToRender--;
2775 }
2776
2777 audioRenderer->Drain();
2778
2779 free(buffer);
2780 fclose(wavFile);
2781
2782 bool isStopped = audioRenderer->Stop();
2783 EXPECT_EQ(true, isStopped);
2784
2785 bool isReleased = audioRenderer->Release();
2786 EXPECT_EQ(true, isReleased);
2787 }
2788
2789 /**
2790 * @tc.name : Test Stop API.
2791 * @tc.number: Audio_Renderer_Stop_001
2792 * @tc.desc : Test Stop interface. Returns true, if the stop is successful.
2793 */
2794 HWTEST(AudioRendererUnitTest, Audio_Renderer_Stop_001, TestSize.Level1)
2795 {
2796 int32_t ret = -1;
2797 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2798 ASSERT_NE(nullptr, wavFile);
2799
2800 AudioRendererOptions rendererOptions;
2801
2802 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2803 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2804 ASSERT_NE(nullptr, audioRenderer);
2805
2806 bool isStarted = audioRenderer->Start();
2807 EXPECT_EQ(true, isStarted);
2808
2809 size_t bufferLen;
2810 ret = audioRenderer->GetBufferSize(bufferLen);
2811 EXPECT_EQ(SUCCESS, ret);
2812
2813 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2814 ASSERT_NE(nullptr, buffer);
2815
2816 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2817 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2818 EXPECT_GE(bytesWritten, VALUE_ZERO);
2819
2820 audioRenderer->Drain();
2821
2822 bool isStopped = audioRenderer->Stop();
2823 EXPECT_EQ(true, isStopped);
2824
2825 audioRenderer->Release();
2826
2827 free(buffer);
2828 fclose(wavFile);
2829 }
2830
2831 /**
2832 * @tc.name : Test Stop API via illegal state, RENDERER_NEW: call Stop without Initializing the renderer.
2833 * @tc.number: Audio_Renderer_Stop_002
2834 * @tc.desc : Test Stop interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2835 */
2836 HWTEST(AudioRendererUnitTest, Audio_Renderer_Stop_002, TestSize.Level1)
2837 {
2838 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
2839 ASSERT_NE(nullptr, audioRenderer);
2840
2841 bool isStopped = audioRenderer->Stop();
2842 EXPECT_EQ(false, isStopped);
2843 }
2844
2845 /**
2846 * @tc.name : Test Stop API via illegal state, RENDERER_PREPARED: call Stop without Start.
2847 * @tc.number: Audio_Renderer_Stop_003
2848 * @tc.desc : Test Stop interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2849 */
2850 HWTEST(AudioRendererUnitTest, Audio_Renderer_Stop_003, TestSize.Level1)
2851 {
2852 AudioRendererOptions rendererOptions;
2853
2854 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2855 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2856 ASSERT_NE(nullptr, audioRenderer);
2857
2858 bool isStopped = audioRenderer->Stop();
2859 EXPECT_EQ(false, isStopped);
2860
2861 audioRenderer->Release();
2862 }
2863
2864 /**
2865 * @tc.name : Test Stop API via illegal state, RENDERER_RELEASED: call Stop after Release.
2866 * @tc.number: Audio_Renderer_Stop_004
2867 * @tc.desc : Test Stop interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2868 */
2869 HWTEST(AudioRendererUnitTest, Audio_Renderer_Stop_004, TestSize.Level1)
2870 {
2871 AudioRendererOptions rendererOptions;
2872
2873 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2874 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2875 ASSERT_NE(nullptr, audioRenderer);
2876
2877 bool isStarted = audioRenderer->Start();
2878 EXPECT_EQ(true, isStarted);
2879
2880 bool isReleased = audioRenderer->Release();
2881 EXPECT_EQ(true, isReleased);
2882
2883 bool isStopped = audioRenderer->Stop();
2884 EXPECT_EQ(false, isStopped);
2885 }
2886
2887 /**
2888 * @tc.name : Test Stop API via legal state. call Start, Stop, Start and Stop again
2889 * @tc.number: Audio_Renderer_Stop_005
2890 * @tc.desc : Test Stop interface. Returns true , if the stop is successful.
2891 */
2892 HWTEST(AudioRendererUnitTest, Audio_Renderer_Stop_005, TestSize.Level1)
2893 {
2894 AudioRendererOptions rendererOptions;
2895
2896 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2897 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2898 ASSERT_NE(nullptr, audioRenderer);
2899
2900 bool isStarted = audioRenderer->Start();
2901 EXPECT_EQ(true, isStarted);
2902
2903 bool isStopped = audioRenderer->Stop();
2904 EXPECT_EQ(true, isStopped);
2905
2906 isStarted = audioRenderer->Start();
2907 EXPECT_EQ(true, isStarted);
2908
2909 isStopped = audioRenderer->Stop();
2910 EXPECT_EQ(true, isStopped);
2911 audioRenderer->Release();
2912 }
2913
2914 /**
2915 * @tc.name : Test Stop API via legal state, RENDERER_PAUSED: call Stop after Pause.
2916 * @tc.number: Audio_Renderer_Stop_006
2917 * @tc.desc : Test Stop interface. Returns false, if the renderer state is not RENDERER_RUNNING or RENDERER_PAUSED.
2918 */
2919 HWTEST(AudioRendererUnitTest, Audio_Renderer_Stop_006, TestSize.Level1)
2920 {
2921 AudioRendererOptions rendererOptions;
2922
2923 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2924 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2925 ASSERT_NE(nullptr, audioRenderer);
2926
2927 bool isStarted = audioRenderer->Start();
2928 EXPECT_EQ(true, isStarted);
2929
2930 bool isPaused = audioRenderer->Pause();
2931 EXPECT_EQ(true, isPaused);
2932
2933 bool isStopped = audioRenderer->Stop();
2934 EXPECT_EQ(true, isStopped);
2935 audioRenderer->Release();
2936 }
2937
2938 /**
2939 * @tc.name : Test Release API.
2940 * @tc.number: Audio_Renderer_Release_001
2941 * @tc.desc : Test Release interface. Returns true, if the release is successful.
2942 */
2943 HWTEST(AudioRendererUnitTest, Audio_Renderer_Release_001, TestSize.Level1)
2944 {
2945 int32_t ret = -1;
2946 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2947 ASSERT_NE(nullptr, wavFile);
2948
2949 AudioRendererOptions rendererOptions;
2950
2951 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2952 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2953 ASSERT_NE(nullptr, audioRenderer);
2954
2955 bool isStarted = audioRenderer->Start();
2956 EXPECT_EQ(true, isStarted);
2957
2958 size_t bufferLen;
2959 ret = audioRenderer->GetBufferSize(bufferLen);
2960 EXPECT_EQ(SUCCESS, ret);
2961
2962 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2963 ASSERT_NE(nullptr, buffer);
2964
2965 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2966 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2967 EXPECT_GE(bytesWritten, VALUE_ZERO);
2968
2969 audioRenderer->Drain();
2970 audioRenderer->Stop();
2971
2972 bool isReleased = audioRenderer->Release();
2973 EXPECT_EQ(true, isReleased);
2974
2975 free(buffer);
2976 fclose(wavFile);
2977 }
2978
2979 /**
2980 * @tc.name : Test Release API via illegal state, RENDERER_NEW: Call Release without initializing the renderer.
2981 * @tc.number: Audio_Renderer_Release_002
2982 * @tc.desc : Test Release interface, Returns false, if the state is RENDERER_NEW.
2983 */
2984 HWTEST(AudioRendererUnitTest, Audio_Renderer_Release_002, TestSize.Level1)
2985 {
2986 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
2987 ASSERT_NE(nullptr, audioRenderer);
2988
2989 bool isReleased = audioRenderer->Release();
2990 EXPECT_EQ(false, isReleased);
2991 }
2992
2993 /**
2994 * @tc.name : Test Release API via illegal state, RENDERER_RELEASED: call Release repeatedly.
2995 * @tc.number: Audio_Renderer_Release_003
2996 * @tc.desc : Test Release interface. Returns false, if the state is already RENDERER_RELEASED.
2997 */
2998 HWTEST(AudioRendererUnitTest, Audio_Renderer_Release_003, TestSize.Level1)
2999 {
3000 AudioRendererOptions rendererOptions;
3001
3002 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3003 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3004 ASSERT_NE(nullptr, audioRenderer);
3005
3006 bool isReleased = audioRenderer->Release();
3007 EXPECT_EQ(true, isReleased);
3008
3009 isReleased = audioRenderer->Release();
3010 EXPECT_EQ(false, isReleased);
3011 }
3012
3013 /**
3014 * @tc.name : Test Release API via legal state, RENDERER_RUNNING: call Release after Start
3015 * @tc.number: Audio_Renderer_Release_004
3016 * @tc.desc : Test Release interface. Returns true, if the release is successful.
3017 */
3018 HWTEST(AudioRendererUnitTest, Audio_Renderer_Release_004, TestSize.Level1)
3019 {
3020 AudioRendererOptions rendererOptions;
3021
3022 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3023 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3024 ASSERT_NE(nullptr, audioRenderer);
3025
3026 bool isStarted = audioRenderer->Start();
3027 EXPECT_EQ(true, isStarted);
3028
3029 bool isReleased = audioRenderer->Release();
3030 EXPECT_EQ(true, isReleased);
3031 }
3032
3033 /**
3034 * @tc.name : Test Release API via legal state, RENDERER_STOPPED: call release after Start and Stop
3035 * @tc.number: Audio_Renderer_Release_005
3036 * @tc.desc : Test Release interface. Returns true, if the release is successful.
3037 */
3038 HWTEST(AudioRendererUnitTest, Audio_Renderer_Release_005, TestSize.Level1)
3039 {
3040 AudioRendererOptions rendererOptions;
3041
3042 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3043 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3044 ASSERT_NE(nullptr, audioRenderer);
3045
3046 bool isStarted = audioRenderer->Start();
3047 EXPECT_EQ(true, isStarted);
3048
3049 bool isStopped = audioRenderer->Stop();
3050 EXPECT_EQ(true, isStopped);
3051
3052 bool isReleased = audioRenderer->Release();
3053 EXPECT_EQ(true, isReleased);
3054 }
3055
3056 /**
3057 * @tc.name : Test Release API via legal state, RENDERER_PAUSED: call release after Start and Pause
3058 * @tc.number: Audio_Renderer_Release_006
3059 * @tc.desc : Test Release interface. Returns true, if the release is successful.
3060 */
3061 HWTEST(AudioRendererUnitTest, Audio_Renderer_Release_006, TestSize.Level1)
3062 {
3063 AudioRendererOptions rendererOptions;
3064
3065 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3066 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3067 ASSERT_NE(nullptr, audioRenderer);
3068
3069 bool isStarted = audioRenderer->Start();
3070 EXPECT_EQ(true, isStarted);
3071
3072 bool isPaused = audioRenderer->Pause();
3073 EXPECT_EQ(true, isPaused);
3074
3075 bool isReleased = audioRenderer->Release();
3076 EXPECT_EQ(true, isReleased);
3077 }
3078
3079 /**
3080 * @tc.name : Test GetStatus API.
3081 * @tc.number: Audio_Renderer_GetStatus_001
3082 * @tc.desc : Test GetStatus interface. Returns correct state on success.
3083 */
3084 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStatus_001, TestSize.Level1)
3085 {
3086 RendererState state = RENDERER_INVALID;
3087
3088 AudioRendererOptions rendererOptions;
3089
3090 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3091 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3092 ASSERT_NE(nullptr, audioRenderer);
3093
3094 state = audioRenderer->GetStatus();
3095 EXPECT_EQ(RENDERER_PREPARED, state);
3096
3097 bool isStarted = audioRenderer->Start();
3098 EXPECT_EQ(true, isStarted);
3099 state = audioRenderer->GetStatus();
3100 EXPECT_EQ(RENDERER_RUNNING, state);
3101
3102 bool isStopped = audioRenderer->Stop();
3103 EXPECT_EQ(true, isStopped);
3104 state = audioRenderer->GetStatus();
3105 EXPECT_EQ(RENDERER_STOPPED, state);
3106
3107 bool isReleased = audioRenderer->Release();
3108 EXPECT_EQ(true, isReleased);
3109 state = audioRenderer->GetStatus();
3110 EXPECT_EQ(RENDERER_RELEASED, state);
3111 }
3112
3113 /**
3114 * @tc.name : Test GetStatus API, call Start without Initializing the renderer
3115 * @tc.number: Audio_Renderer_GetStatus_002
3116 * @tc.desc : Test GetStatus interface. Not changes to RENDERER_RUNNING, if the current state is RENDERER_NEW.
3117 */
3118 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStatus_002, TestSize.Level1)
3119 {
3120 RendererState state = RENDERER_INVALID;
3121
3122 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
3123 ASSERT_NE(nullptr, audioRenderer);
3124
3125 bool isStarted = audioRenderer->Start();
3126 EXPECT_EQ(false, isStarted);
3127 state = audioRenderer->GetStatus();
3128 EXPECT_NE(RENDERER_RUNNING, state);
3129 EXPECT_EQ(RENDERER_NEW, state);
3130 }
3131
3132 /**
3133 * @tc.name : Test GetStatus API, call Stop without Start
3134 * @tc.number: Audio_Renderer_GetStatus_003
3135 * @tc.desc : Test GetStatus interface. Not changes to RENDERER_STOPPED, if the current state is RENDERER_PREPARED.
3136 */
3137 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStatus_003, TestSize.Level1)
3138 {
3139 RendererState state = RENDERER_INVALID;
3140 AudioRendererOptions rendererOptions;
3141
3142 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3143 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3144 ASSERT_NE(nullptr, audioRenderer);
3145
3146 bool isStopped = audioRenderer->Stop();
3147 EXPECT_EQ(false, isStopped);
3148 state = audioRenderer->GetStatus();
3149 EXPECT_NE(RENDERER_STOPPED, state);
3150 EXPECT_EQ(RENDERER_PREPARED, state);
3151
3152 audioRenderer->Release();
3153 }
3154
3155 /**
3156 * @tc.name : Test GetStatus API, call Start, Stop and then Start again
3157 * @tc.number: Audio_Renderer_GetStatus_004
3158 * @tc.desc : Test GetStatus interface. Returns correct state on success.
3159 */
3160 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStatus_004, TestSize.Level1)
3161 {
3162 RendererState state = RENDERER_INVALID;
3163
3164 AudioRendererOptions rendererOptions;
3165
3166 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3167 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3168 ASSERT_NE(nullptr, audioRenderer);
3169
3170 bool isStarted = audioRenderer->Start();
3171 EXPECT_EQ(true, isStarted);
3172 state = audioRenderer->GetStatus();
3173 EXPECT_EQ(RENDERER_RUNNING, state);
3174
3175 bool isStopped = audioRenderer->Stop();
3176 EXPECT_EQ(true, isStopped);
3177 state = audioRenderer->GetStatus();
3178 EXPECT_EQ(RENDERER_STOPPED, state);
3179
3180 isStarted = audioRenderer->Start();
3181 EXPECT_EQ(true, isStarted);
3182 state = audioRenderer->GetStatus();
3183 EXPECT_EQ(RENDERER_RUNNING, state);
3184
3185 audioRenderer->Release();
3186 }
3187
3188 /**
3189 * @tc.name : Test GetStatus API, call Release without initializing
3190 * @tc.number: Audio_Renderer_GetStatus_005
3191 * @tc.desc : Test GetStatus interface. Not changes to RENDERER_RELEASED, if the current state is RENDERER_NEW.
3192 */
3193 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStatus_005, TestSize.Level1)
3194 {
3195 RendererState state = RENDERER_INVALID;
3196
3197 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
3198 ASSERT_NE(nullptr, audioRenderer);
3199
3200 bool isReleased = audioRenderer->Release();
3201 EXPECT_EQ(false, isReleased);
3202 state = audioRenderer->GetStatus();
3203 EXPECT_NE(RENDERER_RELEASED, state);
3204 EXPECT_EQ(RENDERER_NEW, state);
3205 }
3206
3207 /**
3208 * @tc.name : Test GetLatency API.
3209 * @tc.number: Audio_Renderer_GetLatency_001
3210 * @tc.desc : Test GetLatency interface. Returns 0 {SUCCESS}, if the getting is successful.
3211 */
3212 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetLatency_001, TestSize.Level1)
3213 {
3214 int32_t ret = -1;
3215 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
3216 ASSERT_NE(nullptr, wavFile);
3217
3218 AudioRendererOptions rendererOptions;
3219
3220 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3221 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3222 ASSERT_NE(nullptr, audioRenderer);
3223
3224 bool isStarted = audioRenderer->Start();
3225 EXPECT_EQ(true, isStarted);
3226
3227 size_t bufferLen;
3228 ret = audioRenderer->GetBufferSize(bufferLen);
3229 EXPECT_EQ(SUCCESS, ret);
3230
3231 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
3232 ASSERT_NE(nullptr, buffer);
3233
3234 size_t bytesToWrite = 0;
3235 int32_t bytesWritten = 0;
3236 size_t minBytes = 4;
3237 int32_t numBuffersToRender = WRITE_BUFFERS_COUNT;
3238
3239 while (numBuffersToRender) {
3240 bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
3241 bytesWritten = 0;
3242 uint64_t latency;
3243 ret = audioRenderer->GetLatency(latency);
3244 EXPECT_EQ(SUCCESS, ret);
3245 while ((static_cast<size_t>(bytesWritten) < bytesToWrite) &&
3246 ((static_cast<size_t>(bytesToWrite) - bytesWritten) > minBytes)) {
3247 bytesWritten += audioRenderer->Write(buffer + static_cast<size_t>(bytesWritten),
3248 bytesToWrite - static_cast<size_t>(bytesWritten));
3249 EXPECT_GE(bytesWritten, VALUE_ZERO);
3250 if (bytesWritten < 0) {
3251 break;
3252 }
3253 }
3254 numBuffersToRender--;
3255 }
3256
3257 audioRenderer->Drain();
3258 audioRenderer->Release();
3259
3260 free(buffer);
3261 fclose(wavFile);
3262 }
3263
3264 /**
3265 * @tc.name : Test GetLatency API via illegal state, RENDERER_NEW: without initializing the renderer
3266 * @tc.number: Audio_Renderer_GetLatency_002
3267 * @tc.desc : Test GetLatency interface. Returns error code, if the renderer state is RENDERER_NEW.
3268 */
3269 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetLatency_002, TestSize.Level1)
3270 {
3271 int32_t ret = -1;
3272
3273 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
3274 ASSERT_NE(nullptr, audioRenderer);
3275
3276 bool isStarted = audioRenderer->Start();
3277 EXPECT_EQ(false, isStarted);
3278
3279 uint64_t latency;
3280 ret = audioRenderer->GetLatency(latency);
3281 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
3282 }
3283
3284 /**
3285 * @tc.name : Test GetLatency API via legal state, RENDERER_PREPARED
3286 * @tc.number: Audio_Renderer_GetLatency_003
3287 * @tc.desc : Test GetLatency interface. Returns 0 {SUCCESS}, if the getting is successful.
3288 */
3289 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetLatency_003, TestSize.Level1)
3290 {
3291 int32_t ret = -1;
3292 AudioRendererOptions rendererOptions;
3293
3294 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3295 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3296 ASSERT_NE(nullptr, audioRenderer);
3297
3298 uint64_t latency;
3299 ret = audioRenderer->GetLatency(latency);
3300 EXPECT_EQ(SUCCESS, ret);
3301
3302 audioRenderer->Release();
3303 }
3304
3305 /**
3306 * @tc.name : Test GetLatency API via legal state, RENDERER_STOPPED: After Stop
3307 * @tc.number: Audio_Renderer_GetLatency_004
3308 * @tc.desc : Test GetLatency interface. Returns 0 {SUCCESS}, if the getting is successful.
3309 */
3310 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetLatency_004, TestSize.Level1)
3311 {
3312 int32_t ret = -1;
3313 AudioRendererOptions rendererOptions;
3314
3315 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3316 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3317 ASSERT_NE(nullptr, audioRenderer);
3318
3319 bool isStarted = audioRenderer->Start();
3320 EXPECT_EQ(true, isStarted);
3321
3322 bool isStopped = audioRenderer->Stop();
3323 EXPECT_EQ(true, isStopped);
3324
3325 uint64_t latency;
3326 ret = audioRenderer->GetLatency(latency);
3327 EXPECT_EQ(SUCCESS, ret);
3328
3329 audioRenderer->Release();
3330 }
3331
3332 /**
3333 * @tc.name : Test GetLatency API via illegal state, RENDERER_RELEASED: After Release
3334 * @tc.number: Audio_Renderer_GetLatency_005
3335 * @tc.desc : Test GetLatency interface. Returns error code, if the renderer state is RENDERER_RELEASED.
3336 */
3337 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetLatency_005, TestSize.Level1)
3338 {
3339 int32_t ret = -1;
3340 AudioRendererOptions rendererOptions;
3341
3342 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3343 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3344 ASSERT_NE(nullptr, audioRenderer);
3345
3346 bool isStarted = audioRenderer->Start();
3347 EXPECT_EQ(true, isStarted);
3348
3349 bool isReleased = audioRenderer->Release();
3350 EXPECT_EQ(true, isReleased);
3351
3352 uint64_t latency;
3353 ret = audioRenderer->GetLatency(latency);
3354 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
3355 }
3356
3357 /**
3358 * @tc.name : Test SetRendererCallback with null pointer.
3359 * @tc.number: Audio_Renderer_SetRendererCallback_001
3360 * @tc.desc : Test SetRendererCallback interface. Returns error code, if null pointer is set.
3361 */
3362 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererCallback_001, TestSize.Level1)
3363 {
3364 int32_t ret = -1;
3365
3366 AudioRendererOptions rendererOptions;
3367 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
3368 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
3369 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
3370 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
3371 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
3372 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
3373 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
3374
3375 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3376 ASSERT_NE(nullptr, audioRenderer);
3377
3378 ret = audioRenderer->SetRendererCallback(nullptr);
3379 EXPECT_NE(SUCCESS, ret);
3380 EXPECT_EQ(ERR_INVALID_PARAM, ret);
3381 }
3382
3383 /**
3384 * @tc.name : Test SetRendererCallback with valid callback pointer.
3385 * @tc.number: Audio_Renderer_SetRendererCallback_002
3386 * @tc.desc : Test SetRendererCallback interface. Returns success, if valid callback is set.
3387 */
3388 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererCallback_002, TestSize.Level1)
3389 {
3390 int32_t ret = -1;
3391
3392 AudioRendererOptions rendererOptions;
3393 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
3394 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
3395 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
3396 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
3397 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
3398 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
3399 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
3400
3401 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3402 ASSERT_NE(nullptr, audioRenderer);
3403
3404 shared_ptr<AudioRendererCallbackTest> audioRendererCB = make_shared<AudioRendererCallbackTest>();
3405 ret = audioRenderer->SetRendererCallback(audioRendererCB);
3406 EXPECT_EQ(SUCCESS, ret);
3407 }
3408
3409 /**
3410 * @tc.name : Test SetRendererCallback via illegal state, RENDERER_RELEASED: After RELEASED
3411 * @tc.number: Audio_Renderer_SetRendererCallback_003
3412 * @tc.desc : Test SetRendererCallback interface. Returns error, if callback is set in released state.
3413 */
3414 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererCallback_003, TestSize.Level1)
3415 {
3416 int32_t ret = -1;
3417
3418 AudioRendererOptions rendererOptions;
3419 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
3420 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
3421 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
3422 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
3423 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
3424 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
3425 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
3426
3427 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3428 ASSERT_NE(nullptr, audioRenderer);
3429
3430 bool isReleased = audioRenderer->Release();
3431 EXPECT_EQ(true, isReleased);
3432
3433 RendererState state = audioRenderer->GetStatus();
3434 EXPECT_EQ(RENDERER_RELEASED, state);
3435
3436 shared_ptr<AudioRendererCallbackTest> audioRendererCB = make_shared<AudioRendererCallbackTest>();
3437 ret = audioRenderer->SetRendererCallback(audioRendererCB);
3438 EXPECT_NE(SUCCESS, ret);
3439 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
3440 }
3441
3442 /**
3443 * @tc.name : Test SetRendererCallback via legal state, RENDERER_PREPARED: After PREPARED
3444 * @tc.number: Audio_Renderer_SetRendererCallback_004
3445 * @tc.desc : Test SetRendererCallback interface. Returns success, if callback is set in proper state.
3446 */
3447 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererCallback_004, TestSize.Level1)
3448 {
3449 int32_t ret = -1;
3450
3451 AudioRendererOptions rendererOptions;
3452 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
3453 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
3454 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
3455 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
3456 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
3457 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
3458 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
3459
3460 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3461 ASSERT_NE(nullptr, audioRenderer);
3462
3463 RendererState state = audioRenderer->GetStatus();
3464 EXPECT_EQ(RENDERER_PREPARED, state);
3465
3466 shared_ptr<AudioRendererCallbackTest> audioRendererCB = make_shared<AudioRendererCallbackTest>();
3467 ret = audioRenderer->SetRendererCallback(audioRendererCB);
3468 EXPECT_EQ(SUCCESS, ret);
3469 }
3470
3471 /**
3472 * @tc.name : Test SetRenderMode via legal input, RENDER_MODE_CALLBACK
3473 * @tc.number: Audio_Renderer_SetRenderMode_001
3474 * @tc.desc : Test SetRenderMode interface. Returns SUCCESS, if the render mode is successfully set.
3475 */
3476 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRenderMode_001, TestSize.Level1)
3477 {
3478 int32_t ret = -1;
3479 AudioRendererOptions rendererOptions;
3480
3481 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3482 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3483 ASSERT_NE(nullptr, audioRenderer);
3484
3485 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3486 EXPECT_EQ(SUCCESS, ret);
3487
3488 audioRenderer->Release();
3489 }
3490
3491 /**
3492 * @tc.name : Test SetRenderMode via legal input, RENDER_MODE_NORMAL
3493 * @tc.number: Audio_Renderer_SetRenderMode_002
3494 * @tc.desc : Test SetRenderMode interface. Returns SUCCESS, if the render mode is successfully set.
3495 */
3496 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRenderMode_002, TestSize.Level1)
3497 {
3498 int32_t ret = -1;
3499 AudioRendererOptions rendererOptions;
3500
3501 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3502 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3503 ASSERT_NE(nullptr, audioRenderer);
3504
3505 ret = audioRenderer->SetRenderMode(RENDER_MODE_NORMAL);
3506 EXPECT_EQ(SUCCESS, ret);
3507
3508 audioRenderer->Release();
3509 }
3510
3511 /**
3512 * @tc.name : Test GetRenderMode with, RENDER_MODE_CALLBACK
3513 * @tc.number: Audio_Renderer_GetRenderMode_001
3514 * @tc.desc : Test GetRenderMode interface. Returns the current render mode.
3515 */
3516 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRenderMode_001, TestSize.Level1)
3517 {
3518 int32_t ret = -1;
3519 AudioRendererOptions rendererOptions;
3520
3521 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3522 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3523 ASSERT_NE(nullptr, audioRenderer);
3524
3525 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3526 EXPECT_EQ(SUCCESS, ret);
3527 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3528 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
3529
3530 audioRenderer->Release();
3531 }
3532
3533 /**
3534 * @tc.name : Test GetRenderMode with, RENDER_MODE_NORMAL
3535 * @tc.number: Audio_Renderer_GetRenderMode_002
3536 * @tc.desc : Test GetRenderMode interface. Returns the current render mode.
3537 */
3538 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRenderMode_002, TestSize.Level1)
3539 {
3540 int32_t ret = -1;
3541 AudioRendererOptions rendererOptions;
3542
3543 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3544 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3545 ASSERT_NE(nullptr, audioRenderer);
3546
3547 ret = audioRenderer->SetRenderMode(RENDER_MODE_NORMAL);
3548 EXPECT_EQ(SUCCESS, ret);
3549 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3550 EXPECT_EQ(RENDER_MODE_NORMAL, renderMode);
3551
3552 audioRenderer->Release();
3553 }
3554
3555 /**
3556 * @tc.name : Test GetRenderMode with, default renderMode
3557 * @tc.number: Audio_Renderer_GetRenderMode_003
3558 * @tc.desc : Test GetRenderMode interface. Returns the default render mode RENDER_MODE_NORMAL.
3559 */
3560 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRenderMode_003, TestSize.Level1)
3561 {
3562 AudioRendererOptions rendererOptions;
3563
3564 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3565 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3566 ASSERT_NE(nullptr, audioRenderer);
3567
3568 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3569 EXPECT_EQ(RENDER_MODE_NORMAL, renderMode);
3570
3571 audioRenderer->Release();
3572 }
3573
3574 /**
3575 * @tc.name : Test SetRendererWriteCallback via legal render mode, RENDER_MODE_CALLBACK
3576 * @tc.number: Audio_Renderer_SetRendererWriteCallback_001
3577 * @tc.desc : Test SetRendererWriteCallback interface. Returns SUCCESS, if the callback is successfully set.
3578 */
3579 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererWriteCallback_001, TestSize.Level1)
3580 {
3581 int32_t ret = -1;
3582 AudioRendererOptions rendererOptions;
3583
3584 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3585 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3586 ASSERT_NE(nullptr, audioRenderer);
3587
3588 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3589 EXPECT_EQ(SUCCESS, ret);
3590 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3591 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
3592
3593 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3594
3595 ret = audioRenderer->SetRendererWriteCallback(cb);
3596 EXPECT_EQ(SUCCESS, ret);
3597
3598 audioRenderer->Release();
3599 }
3600
3601 /**
3602 * @tc.name : Test SetRendererWriteCallback via illegal render mode, RENDER_MODE_NORMAL
3603 * @tc.number: Audio_Renderer_SetRendererWriteCallback_002
3604 * @tc.desc : Test SetRendererWriteCallback interface. Returns error code, if the render mode is not callback.
3605 */
3606 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererWriteCallback_002, TestSize.Level1)
3607 {
3608 int32_t ret = -1;
3609 AudioRendererOptions rendererOptions;
3610
3611 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3612 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3613 ASSERT_NE(nullptr, audioRenderer);
3614
3615 ret = audioRenderer->SetRenderMode(RENDER_MODE_NORMAL);
3616 EXPECT_EQ(SUCCESS, ret);
3617 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3618 EXPECT_EQ(RENDER_MODE_NORMAL, renderMode);
3619
3620 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3621
3622 ret = audioRenderer->SetRendererWriteCallback(cb);
3623 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3624
3625 audioRenderer->Release();
3626 }
3627
3628 /**
3629 * @tc.name : Test SetRendererWriteCallback via illegal render mode, default render mode RENDER_MODE_NORMAL
3630 * @tc.number: Audio_Renderer_SetRendererWriteCallback_003
3631 * @tc.desc : Test SetRendererWriteCallback interface. Returns error code, if the render mode is not callback.
3632 */
3633 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererWriteCallback_003, TestSize.Level1)
3634 {
3635 int32_t ret = -1;
3636 AudioRendererOptions rendererOptions;
3637
3638 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3639 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3640 ASSERT_NE(nullptr, audioRenderer);
3641
3642 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3643
3644 ret = audioRenderer->SetRendererWriteCallback(cb);
3645 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3646
3647 audioRenderer->Release();
3648 }
3649
3650 /**
3651 * @tc.name : Test SetRendererWriteCallback via illegal input, nullptr
3652 * @tc.number: Audio_Renderer_SetRendererWriteCallback_004
3653 * @tc.desc : Test SetRendererWriteCallback interface. Returns error code, if the callback reference is nullptr.
3654 */
3655 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererWriteCallback_004, TestSize.Level1)
3656 {
3657 int32_t ret = -1;
3658 AudioRendererOptions rendererOptions;
3659
3660 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3661 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3662 ASSERT_NE(nullptr, audioRenderer);
3663
3664 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3665 EXPECT_EQ(SUCCESS, ret);
3666 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3667 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
3668
3669 ret = audioRenderer->SetRendererWriteCallback(nullptr);
3670 EXPECT_EQ(ERR_INVALID_PARAM, ret);
3671
3672 audioRenderer->Release();
3673 }
3674
3675 /**
3676 * @tc.name : Test GetBufferDesc via legal render mode, RENDER_MODE_CALLBACK
3677 * @tc.number: Audio_Renderer_GetBufferDesc_001
3678 * @tc.desc : Test GetBufferDesc interface. Returns SUCCESS, if BufferDesc obtained successfully.
3679 */
3680 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufferDesc_001, TestSize.Level1)
3681 {
3682 int32_t ret = -1;
3683 AudioRendererOptions rendererOptions;
3684
3685 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3686 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3687 ASSERT_NE(nullptr, audioRenderer);
3688
3689 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3690 EXPECT_EQ(SUCCESS, ret);
3691 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3692 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
3693
3694 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3695
3696 ret = audioRenderer->SetRendererWriteCallback(cb);
3697 EXPECT_EQ(SUCCESS, ret);
3698
3699 BufferDesc bufDesc {};
3700 bufDesc.buffer = nullptr;
3701 bufDesc.dataLength = g_reqBufLen;
3702 ret = audioRenderer->GetBufferDesc(bufDesc);
3703 EXPECT_EQ(SUCCESS, ret);
3704 EXPECT_NE(nullptr, bufDesc.buffer);
3705
3706 audioRenderer->Release();
3707 }
3708
3709 /**
3710 * @tc.name : Test GetBufferDesc via illegal render mode, RENDER_MODE_NORMAL
3711 * @tc.number: Audio_Renderer_GetBufferDesc_002
3712 * @tc.desc : Test GetBufferDesc interface. Returns errorcode, if render mode is not callback.
3713 */
3714 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufferDesc_002, TestSize.Level1)
3715 {
3716 int32_t ret = -1;
3717 AudioRendererOptions rendererOptions;
3718
3719 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3720 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3721 ASSERT_NE(nullptr, audioRenderer);
3722
3723 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3724
3725 ret = audioRenderer->SetRendererWriteCallback(cb);
3726 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3727
3728 BufferDesc bufDesc {};
3729 bufDesc.buffer = nullptr;
3730 bufDesc.dataLength = g_reqBufLen;
3731 ret = audioRenderer->GetBufferDesc(bufDesc);
3732 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3733 EXPECT_EQ(nullptr, bufDesc.buffer);
3734
3735 audioRenderer->Release();
3736 }
3737
3738 /**
3739 * @tc.name : Test Enqueue via legal render mode, RENDER_MODE_CALLBACK
3740 * @tc.number: Audio_Renderer_Enqueue_001
3741 * @tc.desc : Test Enqueue interface. Returns SUCCESS , if the buff desc enqueued successfully.
3742 */
3743 HWTEST(AudioRendererUnitTest, Audio_Renderer_Enqueue_001, TestSize.Level1)
3744 {
3745 int32_t ret = -1;
3746 AudioRendererOptions rendererOptions;
3747
3748 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3749 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3750 ASSERT_NE(nullptr, audioRenderer);
3751
3752 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3753 EXPECT_EQ(SUCCESS, ret);
3754 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3755 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
3756
3757 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3758
3759 ret = audioRenderer->SetRendererWriteCallback(cb);
3760 EXPECT_EQ(SUCCESS, ret);
3761
3762 bool isStarted = audioRenderer->Start();
3763 EXPECT_EQ(true, isStarted);
3764
3765 BufferDesc bufDesc {};
3766 bufDesc.buffer = nullptr;
3767 bufDesc.dataLength = g_reqBufLen;
3768 ret = audioRenderer->GetBufferDesc(bufDesc);
3769 EXPECT_EQ(SUCCESS, ret);
3770 EXPECT_NE(nullptr, bufDesc.buffer);
3771
3772 ret = audioRenderer->Enqueue(bufDesc);
3773 EXPECT_EQ(SUCCESS, ret);
3774
3775 audioRenderer->Stop();
3776 audioRenderer->Release();
3777 }
3778
3779 /**
3780 * @tc.name : Test Enqueue via illegal render mode, RENDER_MODE_NORMAL
3781 * @tc.number: Audio_Renderer_Enqueue_002
3782 * @tc.desc : Test Enqueue interface. Returns error code, if the render mode is not callback.
3783 */
3784 HWTEST(AudioRendererUnitTest, Audio_Renderer_Enqueue_002, TestSize.Level1)
3785 {
3786 int32_t ret = -1;
3787 AudioRendererOptions rendererOptions;
3788
3789 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3790 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3791 ASSERT_NE(nullptr, audioRenderer);
3792
3793 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3794
3795 ret = audioRenderer->SetRendererWriteCallback(cb);
3796 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3797
3798 bool isStarted = audioRenderer->Start();
3799 EXPECT_EQ(true, isStarted);
3800
3801 BufferDesc bufDesc {};
3802 bufDesc.buffer = nullptr;
3803 bufDesc.dataLength = g_reqBufLen;
3804 ret = audioRenderer->GetBufferDesc(bufDesc);
3805 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3806
3807 ret = audioRenderer->Enqueue(bufDesc);
3808 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3809
3810 audioRenderer->Stop();
3811 audioRenderer->Release();
3812 }
3813
3814 /**
3815 * @tc.name : Test Enqueue via illegal input, buffer nullptr
3816 * @tc.number: Audio_Renderer_Enqueue_003
3817 * @tc.desc : Test Enqueue interface. Returns error code, if the buffer nullptr
3818 */
3819 HWTEST(AudioRendererUnitTest, Audio_Renderer_Enqueue_003, TestSize.Level1)
3820 {
3821 int32_t ret = -1;
3822 AudioRendererOptions rendererOptions;
3823
3824 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3825 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3826 ASSERT_NE(nullptr, audioRenderer);
3827
3828 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3829 EXPECT_EQ(SUCCESS, ret);
3830 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3831 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
3832
3833 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3834
3835 ret = audioRenderer->SetRendererWriteCallback(cb);
3836 EXPECT_EQ(SUCCESS, ret);
3837
3838 bool isStarted = audioRenderer->Start();
3839 EXPECT_EQ(true, isStarted);
3840
3841 BufferDesc bufDesc {};
3842 bufDesc.buffer = nullptr;
3843 bufDesc.dataLength = g_reqBufLen;
3844
3845 ret = audioRenderer->Enqueue(bufDesc);
3846 EXPECT_EQ(ERR_INVALID_PARAM, ret);
3847
3848 audioRenderer->Stop();
3849 audioRenderer->Release();
3850 }
3851
3852 /**
3853 * @tc.name : Test Clear via legal render mode, RENDER_MODE_CALLBACK
3854 * @tc.number: Audio_Renderer_Clear_001
3855 * @tc.desc : Test Clear interface. Returns SUCCESS , if the buff queue cleared successfully.
3856 */
3857 HWTEST(AudioRendererUnitTest, Audio_Renderer_Clear_001, TestSize.Level1)
3858 {
3859 int32_t ret = -1;
3860 AudioRendererOptions rendererOptions;
3861
3862 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3863 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3864 ASSERT_NE(nullptr, audioRenderer);
3865
3866 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3867 EXPECT_EQ(SUCCESS, ret);
3868 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3869 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
3870
3871 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3872
3873 ret = audioRenderer->SetRendererWriteCallback(cb);
3874 EXPECT_EQ(SUCCESS, ret);
3875
3876 bool isStarted = audioRenderer->Start();
3877 EXPECT_EQ(true, isStarted);
3878
3879 BufferDesc bufDesc {};
3880 bufDesc.buffer = nullptr;
3881 bufDesc.dataLength = g_reqBufLen;
3882 ret = audioRenderer->GetBufferDesc(bufDesc);
3883 EXPECT_EQ(SUCCESS, ret);
3884 EXPECT_NE(nullptr, bufDesc.buffer);
3885
3886 ret = audioRenderer->Enqueue(bufDesc);
3887 EXPECT_EQ(SUCCESS, ret);
3888
3889 ret = audioRenderer->Clear();
3890 EXPECT_EQ(SUCCESS, ret);
3891
3892 audioRenderer->Stop();
3893 audioRenderer->Release();
3894 }
3895
3896 /**
3897 * @tc.name : Test Clear via illegal render mode, RENDER_MODE_NORMAL
3898 * @tc.number: Audio_Renderer_Clear_002
3899 * @tc.desc : Test Clear interface. Returns error code, if the render mode is not callback.
3900 */
3901 HWTEST(AudioRendererUnitTest, Audio_Renderer_Clear_002, TestSize.Level1)
3902 {
3903 int32_t ret = -1;
3904 AudioRendererOptions rendererOptions;
3905
3906 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3907 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3908 ASSERT_NE(nullptr, audioRenderer);
3909
3910 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3911
3912 ret = audioRenderer->SetRendererWriteCallback(cb);
3913 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3914
3915 bool isStarted = audioRenderer->Start();
3916 EXPECT_EQ(true, isStarted);
3917
3918 BufferDesc bufDesc {};
3919 bufDesc.buffer = nullptr;
3920 bufDesc.dataLength = g_reqBufLen;
3921 ret = audioRenderer->GetBufferDesc(bufDesc);
3922 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3923
3924 ret = audioRenderer->Enqueue(bufDesc);
3925 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3926
3927 ret = audioRenderer->Clear();
3928 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3929
3930 audioRenderer->Stop();
3931 audioRenderer->Release();
3932 }
3933
3934 /**
3935 * @tc.name : Test GetRendererInfo API after calling create
3936 * @tc.number: Audio_Renderer_GetRendererInfo_001
3937 * @tc.desc : Test GetRendererInfo interface. Check whether renderer info returns proper data
3938 */
3939 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRendererInfo_001, TestSize.Level1)
3940 {
3941 AudioRendererOptions rendererOptions;
3942 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
3943 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
3944 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
3945 rendererOptions.streamInfo.channels = AudioChannel::MONO;
3946 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
3947 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
3948 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
3949
3950 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3951 EXPECT_NE(nullptr, audioRenderer);
3952
3953 AudioRendererInfo rendererInfo;
3954 audioRenderer->GetRendererInfo(rendererInfo);
3955
3956 EXPECT_EQ(ContentType::CONTENT_TYPE_MUSIC, rendererInfo.contentType);
3957 EXPECT_EQ(StreamUsage::STREAM_USAGE_MEDIA, rendererInfo.streamUsage);
3958 EXPECT_EQ(RENDERER_FLAG, rendererInfo.rendererFlags);
3959 audioRenderer->Release();
3960 }
3961
3962 /**
3963 * @tc.name : Test GetRendererInfo API via legal state, RENDERER_RUNNING: GetRendererInfo after Start.
3964 * @tc.number: Audio_Renderer_GetRendererInfo_002
3965 * @tc.desc : Test GetRendererInfo interface. Check whether renderer info returns proper data
3966 */
3967 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRendererInfo_002, TestSize.Level1)
3968 {
3969 AudioRendererOptions rendererOptions;
3970 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
3971 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
3972 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
3973 rendererOptions.streamInfo.channels = AudioChannel::MONO;
3974 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
3975 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
3976 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
3977
3978 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3979 EXPECT_NE(nullptr, audioRenderer);
3980
3981 bool isStarted = audioRenderer->Start();
3982 EXPECT_EQ(true, isStarted);
3983
3984 AudioRendererInfo rendererInfo;
3985 audioRenderer->GetRendererInfo(rendererInfo);
3986
3987 EXPECT_EQ(ContentType::CONTENT_TYPE_MUSIC, rendererInfo.contentType);
3988 EXPECT_EQ(StreamUsage::STREAM_USAGE_MEDIA, rendererInfo.streamUsage);
3989 EXPECT_EQ(RENDERER_FLAG, rendererInfo.rendererFlags);
3990
3991 audioRenderer->Stop();
3992 audioRenderer->Release();
3993 }
3994
3995 /**
3996 * @tc.name : Test GetRendererInfo API via legal state, RENDERER_RELEASED: Call GetRendererInfo after Release.
3997 * @tc.number: Audio_Renderer_GetRendererInfo_003
3998 * @tc.desc : Test GetRendererInfo interface. Check whether renderer info returns proper data
3999 */
4000 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRendererInfo_003, TestSize.Level1)
4001 {
4002 AudioRendererOptions rendererOptions;
4003 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4004 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4005 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4006 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4007 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4008 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4009 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4010
4011 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4012 EXPECT_NE(nullptr, audioRenderer);
4013
4014 bool isReleased = audioRenderer->Release();
4015 EXPECT_EQ(true, isReleased);
4016
4017 AudioRendererInfo rendererInfo;
4018 audioRenderer->GetRendererInfo(rendererInfo);
4019
4020 EXPECT_EQ(ContentType::CONTENT_TYPE_MUSIC, rendererInfo.contentType);
4021 EXPECT_EQ(StreamUsage::STREAM_USAGE_MEDIA, rendererInfo.streamUsage);
4022 EXPECT_EQ(RENDERER_FLAG, rendererInfo.rendererFlags);
4023 }
4024
4025 /**
4026 * @tc.name : Test GetRendererInfo API via legal state, RENDERER_STOPPED: Call GetRendererInfo after Stop.
4027 * @tc.number: Audio_Renderer_GetRendererInfo_004
4028 * @tc.desc : Test GetRendererInfo interface. Check whether renderer info returns proper data
4029 */
4030 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRendererInfo_004, TestSize.Level1)
4031 {
4032 AudioRendererOptions rendererOptions;
4033 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4034 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4035 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4036 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4037 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4038 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4039 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4040
4041 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4042 EXPECT_NE(nullptr, audioRenderer);
4043
4044 bool isStarted = audioRenderer->Start();
4045 EXPECT_EQ(true, isStarted);
4046
4047 bool isStopped = audioRenderer->Stop();
4048 EXPECT_EQ(true, isStopped);
4049
4050 AudioRendererInfo rendererInfo;
4051 audioRenderer->GetRendererInfo(rendererInfo);
4052
4053 EXPECT_EQ(ContentType::CONTENT_TYPE_MUSIC, rendererInfo.contentType);
4054 EXPECT_EQ(StreamUsage::STREAM_USAGE_MEDIA, rendererInfo.streamUsage);
4055 EXPECT_EQ(RENDERER_FLAG, rendererInfo.rendererFlags);
4056
4057 audioRenderer->Release();
4058 }
4059
4060 /**
4061 * @tc.name : Test GetRendererInfo API Stability
4062 * @tc.number: Audio_Renderer_GetRendererInfo_Stability_001
4063 * @tc.desc : Test GetRendererInfo interface Stability
4064 */
4065 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRendererInfo_Stability_001, TestSize.Level1)
4066 {
4067 AudioRendererOptions rendererOptions;
4068 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4069 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4070 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4071 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4072 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4073 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4074 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4075
4076 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4077 EXPECT_NE(nullptr, audioRenderer);
4078
4079 for (int i = 0; i < VALUE_THOUSAND; i++) {
4080
4081 AudioRendererInfo rendererInfo;
4082 audioRenderer->GetRendererInfo(rendererInfo);
4083
4084 EXPECT_EQ(ContentType::CONTENT_TYPE_MUSIC, rendererInfo.contentType);
4085 EXPECT_EQ(StreamUsage::STREAM_USAGE_MEDIA, rendererInfo.streamUsage);
4086 EXPECT_EQ(RENDERER_FLAG, rendererInfo.rendererFlags);
4087 }
4088 audioRenderer->Release();
4089 }
4090
4091 /**
4092 * @tc.name : Test GetStreamInfo API after calling create
4093 * @tc.number: Audio_Renderer_GetStreamInfo_001
4094 * @tc.desc : Test GetStreamInfo interface. Check whether stream related data is returned correctly
4095 */
4096 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStreamInfo_001, TestSize.Level1)
4097 {
4098 AudioRendererOptions rendererOptions;
4099 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4100 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4101 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4102 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4103 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4104 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4105 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4106
4107 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4108 EXPECT_NE(nullptr, audioRenderer);
4109
4110 AudioStreamInfo streamInfo;
4111 audioRenderer->GetStreamInfo(streamInfo);
4112
4113 EXPECT_EQ(AudioSamplingRate::SAMPLE_RATE_96000, streamInfo.samplingRate);
4114 EXPECT_EQ(AudioEncodingType::ENCODING_PCM, streamInfo.encoding);
4115 EXPECT_EQ(AudioSampleFormat::SAMPLE_U8, streamInfo.format);
4116 EXPECT_EQ(AudioChannel::MONO, streamInfo.channels);
4117 audioRenderer->Release();
4118 }
4119
4120 /**
4121 * @tc.name : Test GetStreamInfo via legal state, RENDERER_RUNNING: GetStreamInfo after Start.
4122 * @tc.number: Audio_Renderer_GetStreamInfo_002
4123 * @tc.desc : Test GetStreamInfo interface. Check whether stream related data is returned correctly
4124 */
4125 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStreamInfo_002, TestSize.Level1)
4126 {
4127 int32_t ret = -1;
4128
4129 AudioRendererOptions rendererOptions;
4130 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4131 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4132 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4133 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4134 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4135 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4136 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4137
4138 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4139 EXPECT_NE(nullptr, audioRenderer);
4140
4141 bool isStarted = audioRenderer->Start();
4142 EXPECT_EQ(true, isStarted);
4143
4144 AudioStreamInfo streamInfo;
4145 ret = audioRenderer->GetStreamInfo(streamInfo);
4146
4147 EXPECT_EQ(SUCCESS, ret);
4148 EXPECT_EQ(AudioSamplingRate::SAMPLE_RATE_96000, streamInfo.samplingRate);
4149 EXPECT_EQ(AudioEncodingType::ENCODING_PCM, streamInfo.encoding);
4150 EXPECT_EQ(AudioSampleFormat::SAMPLE_U8, streamInfo.format);
4151 EXPECT_EQ(AudioChannel::MONO, streamInfo.channels);
4152
4153 audioRenderer->Stop();
4154 audioRenderer->Release();
4155 }
4156
4157 /**
4158 * @tc.name : Test GetStreamInfo via illegal state, RENDERER_RELEASED: GetStreamInfo after Release.
4159 * @tc.number: Audio_Renderer_GetStreamInfo_003
4160 * @tc.desc : Test GetStreamInfo interface. Returns error code, if the renderer state is RENDERER_RELEASED.
4161 */
4162 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStreamInfo_003, TestSize.Level1)
4163 {
4164 int32_t ret = -1;
4165
4166 AudioRendererOptions rendererOptions;
4167 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4168 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4169 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4170 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4171 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4172 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4173 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4174
4175 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4176 EXPECT_NE(nullptr, audioRenderer);
4177
4178 bool isReleased = audioRenderer->Release();
4179 EXPECT_EQ(true, isReleased);
4180
4181 AudioStreamInfo streamInfo;
4182 ret = audioRenderer->GetStreamInfo(streamInfo);
4183
4184 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
4185 }
4186
4187 /**
4188 * @tc.name : Test GetStreamInfo via legal state, RENDERER_STOPPED: GetStreamInfo after Stop.
4189 * @tc.number: Audio_Renderer_GetStreamInfo_004
4190 * @tc.desc : Test GetStreamInfo interface. Check whether stream related data is returned correctly
4191 */
4192 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStreamInfo_004, TestSize.Level1)
4193 {
4194 int32_t ret = -1;
4195
4196 AudioRendererOptions rendererOptions;
4197 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4198 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4199 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4200 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4201 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4202 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4203 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4204
4205 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4206 EXPECT_NE(nullptr, audioRenderer);
4207
4208 bool isStarted = audioRenderer->Start();
4209 EXPECT_EQ(true, isStarted);
4210
4211 bool isStopped = audioRenderer->Stop();
4212 EXPECT_EQ(true, isStopped);
4213
4214 AudioStreamInfo streamInfo;
4215 ret = audioRenderer->GetStreamInfo(streamInfo);
4216
4217 EXPECT_EQ(SUCCESS, ret);
4218 EXPECT_EQ(AudioSamplingRate::SAMPLE_RATE_96000, streamInfo.samplingRate);
4219 EXPECT_EQ(AudioEncodingType::ENCODING_PCM, streamInfo.encoding);
4220 EXPECT_EQ(AudioSampleFormat::SAMPLE_U8, streamInfo.format);
4221 EXPECT_EQ(AudioChannel::MONO, streamInfo.channels);
4222
4223 audioRenderer->Release();
4224 }
4225
4226 /**
4227 * @tc.name : Test GetStreamInfo via legal state, RENDERER_PAUSED: GetStreamInfo after Pause.
4228 * @tc.number: Audio_Renderer_GetStreamInfo_005
4229 * @tc.desc : Test GetStreamInfo interface. Check whether stream related data is returned correctly
4230 */
4231 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStreamInfo_005, TestSize.Level1)
4232 {
4233 int32_t ret = -1;
4234
4235 AudioRendererOptions rendererOptions;
4236 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4237 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4238 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4239 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4240 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4241 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4242 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4243
4244 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4245 EXPECT_NE(nullptr, audioRenderer);
4246
4247 bool isStarted = audioRenderer->Start();
4248 EXPECT_EQ(true, isStarted);
4249
4250 bool isPaused = audioRenderer->Pause();
4251 EXPECT_EQ(true, isPaused);
4252
4253 AudioStreamInfo streamInfo;
4254 ret = audioRenderer->GetStreamInfo(streamInfo);
4255
4256 EXPECT_EQ(SUCCESS, ret);
4257 EXPECT_EQ(AudioSamplingRate::SAMPLE_RATE_96000, streamInfo.samplingRate);
4258 EXPECT_EQ(AudioEncodingType::ENCODING_PCM, streamInfo.encoding);
4259 EXPECT_EQ(AudioSampleFormat::SAMPLE_U8, streamInfo.format);
4260 EXPECT_EQ(AudioChannel::MONO, streamInfo.channels);
4261
4262 audioRenderer->Stop();
4263 audioRenderer->Release();
4264 }
4265
4266 /**
4267 * @tc.name : Test GetStreamInfo API stability.
4268 * @tc.number: Audio_Renderer_GetStreamInfo_Stability_001
4269 * @tc.desc : Test GetStreamInfo interface stability
4270 */
4271 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStreamInfo_Stability_001, TestSize.Level1)
4272 {
4273 int32_t ret = -1;
4274
4275 AudioRendererOptions rendererOptions;
4276 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4277 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4278 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4279 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4280 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4281 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4282 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4283
4284 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4285 EXPECT_NE(nullptr, audioRenderer);
4286
4287 bool isStarted = audioRenderer->Start();
4288 EXPECT_EQ(true, isStarted);
4289
4290
4291 for (int i = 0; i < VALUE_THOUSAND; i++) {
4292 AudioStreamInfo streamInfo;
4293 ret = audioRenderer->GetStreamInfo(streamInfo);
4294 EXPECT_EQ(SUCCESS, ret);
4295 }
4296
4297 audioRenderer->Stop();
4298 audioRenderer->Release();
4299 }
4300
4301 /**
4302 * @tc.name : Test SetBufferDuration API
4303 * @tc.number: Audio_Renderer_SetBufferDuration_001
4304 * @tc.desc : Test SetBufferDuration interface. Check whether valid parameters are accepted.
4305 */
4306 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetBufferDuration_001, TestSize.Level1)
4307 {
4308 int32_t ret = -1;
4309
4310 AudioRendererOptions rendererOptions;
4311 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4312 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4313 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4314 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4315 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4316 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4317 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4318
4319 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4320 EXPECT_NE(nullptr, audioRenderer);
4321
4322 ret = audioRenderer->SetBufferDuration(BUFFER_DURATION_FIVE);
4323 EXPECT_EQ(SUCCESS, ret);
4324
4325 ret = audioRenderer->SetBufferDuration(BUFFER_DURATION_TEN);
4326 EXPECT_EQ(SUCCESS, ret);
4327
4328 ret = audioRenderer->SetBufferDuration(BUFFER_DURATION_FIFTEEN);
4329 EXPECT_EQ(SUCCESS, ret);
4330
4331 ret = audioRenderer->SetBufferDuration(BUFFER_DURATION_TWENTY);
4332 EXPECT_EQ(SUCCESS, ret);
4333 }
4334
4335 /**
4336 * @tc.name : Test SetBufferDuration API
4337 * @tc.number: Audio_Renderer_SetBufferDuration_002
4338 * @tc.desc : Test SetBufferDuration interface. Check whether invalid parameters are rejected.
4339 */
4340 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetBufferDuration_002, TestSize.Level1)
4341 {
4342 int32_t ret = -1;
4343
4344 AudioRendererOptions rendererOptions;
4345 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4346 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4347 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4348 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4349 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4350 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4351 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4352
4353 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4354 EXPECT_NE(nullptr, audioRenderer);
4355
4356 ret = audioRenderer->SetBufferDuration(VALUE_NEGATIVE);
4357 EXPECT_NE(SUCCESS, ret);
4358
4359 ret = audioRenderer->SetBufferDuration(VALUE_ZERO);
4360 EXPECT_NE(SUCCESS, ret);
4361
4362 ret = audioRenderer->SetBufferDuration(VALUE_HUNDRED);
4363 EXPECT_NE(SUCCESS, ret);
4364 }
4365
4366 /**
4367 * @tc.name : Test SetRendererPositionCallback API
4368 * @tc.number: Audio_Renderer_SetRendererPositionCallback_001
4369 * @tc.desc : Test SetRendererPositionCallback interface to check set position callback is success for valid callback.
4370 */
4371 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPositionCallback_001, TestSize.Level1)
4372 {
4373 int32_t ret = -1;
4374
4375 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4376 ASSERT_NE(nullptr, audioRenderer);
4377
4378 shared_ptr<RendererPositionCallbackTest> positionCB = std::make_shared<RendererPositionCallbackTest>();
4379 ret = audioRenderer->SetRendererPositionCallback(VALUE_THOUSAND, positionCB);
4380 EXPECT_EQ(SUCCESS, ret);
4381 }
4382
4383 /**
4384 * @tc.name : Test SetRendererPositionCallback API
4385 * @tc.number: Audio_Renderer_SetRendererPositionCallback_002
4386 * @tc.desc : Test SetRendererPositionCallback interface again after unregister.
4387 */
4388 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPositionCallback_002, TestSize.Level1)
4389 {
4390 int32_t ret = -1;
4391
4392 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4393 ASSERT_NE(nullptr, audioRenderer);
4394
4395 shared_ptr<RendererPositionCallbackTest> positionCB1 = std::make_shared<RendererPositionCallbackTest>();
4396 ret = audioRenderer->SetRendererPositionCallback(VALUE_THOUSAND, positionCB1);
4397 EXPECT_EQ(SUCCESS, ret);
4398
4399 audioRenderer->UnsetRendererPositionCallback();
4400
4401 shared_ptr<RendererPositionCallbackTest> positionCB2 = std::make_shared<RendererPositionCallbackTest>();
4402 ret = audioRenderer->SetRendererPositionCallback(VALUE_THOUSAND, positionCB2);
4403 EXPECT_EQ(SUCCESS, ret);
4404 }
4405
4406 /**
4407 * @tc.name : Test SetRendererPositionCallback API
4408 * @tc.number: Audio_Renderer_SetRendererPositionCallback_003
4409 * @tc.desc : Test SetRendererPositionCallback interface with null callback.
4410 */
4411 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPositionCallback_003, TestSize.Level1)
4412 {
4413 int32_t ret = -1;
4414
4415 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4416 ASSERT_NE(nullptr, audioRenderer);
4417
4418 ret = audioRenderer->SetRendererPositionCallback(VALUE_THOUSAND, nullptr);
4419 EXPECT_NE(SUCCESS, ret);
4420 }
4421
4422 /**
4423 * @tc.name : Test SetRendererPositionCallback API
4424 * @tc.number: Audio_Renderer_SetRendererPositionCallback_004
4425 * @tc.desc : Test SetRendererPositionCallback interface with invalid parameter.
4426 */
4427 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPositionCallback_004, TestSize.Level1)
4428 {
4429 int32_t ret = -1;
4430
4431 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4432 ASSERT_NE(nullptr, audioRenderer);
4433
4434 shared_ptr<RendererPositionCallbackTest> positionCB = std::make_shared<RendererPositionCallbackTest>();
4435 ret = audioRenderer->SetRendererPositionCallback(VALUE_ZERO, positionCB);
4436 EXPECT_NE(SUCCESS, ret);
4437
4438 ret = audioRenderer->SetRendererPositionCallback(VALUE_NEGATIVE, positionCB);
4439 EXPECT_NE(SUCCESS, ret);
4440 }
4441
4442 /**
4443 * @tc.name : Test SetRendererPeriodPositionCallback API
4444 * @tc.number: Audio_Renderer_SetRendererPeriodPositionCallback_001
4445 * @tc.desc : Test SetRendererPeriodPositionCallback interface to check set period position
4446 * callback is success for valid callback.
4447 */
4448 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPeriodPositionCallback_001, TestSize.Level1)
4449 {
4450 int32_t ret = -1;
4451
4452 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4453 ASSERT_NE(nullptr, audioRenderer);
4454
4455 shared_ptr<RendererPeriodPositionCallbackTest> positionCB = std::make_shared<RendererPeriodPositionCallbackTest>();
4456 ret = audioRenderer->SetRendererPeriodPositionCallback(VALUE_THOUSAND, positionCB);
4457 EXPECT_EQ(SUCCESS, ret);
4458 }
4459
4460 /**
4461 * @tc.name : Test SetRendererPeriodPositionCallback API
4462 * @tc.number: Audio_Renderer_SetRendererPeriodPositionCallback_002
4463 * @tc.desc : Test SetRendererPeriodPositionCallback interface again after unregister.
4464 */
4465 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPeriodPositionCallback_002, TestSize.Level1)
4466 {
4467 int32_t ret = -1;
4468
4469 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4470 ASSERT_NE(nullptr, audioRenderer);
4471
4472 shared_ptr<RendererPeriodPositionCallbackTest> positionCB1 = std::make_shared<RendererPeriodPositionCallbackTest>();
4473 ret = audioRenderer->SetRendererPeriodPositionCallback(VALUE_THOUSAND, positionCB1);
4474 EXPECT_EQ(SUCCESS, ret);
4475
4476 audioRenderer->UnsetRendererPeriodPositionCallback();
4477
4478 shared_ptr<RendererPeriodPositionCallbackTest> positionCB2 = std::make_shared<RendererPeriodPositionCallbackTest>();
4479 ret = audioRenderer->SetRendererPeriodPositionCallback(VALUE_THOUSAND, positionCB2);
4480 EXPECT_EQ(SUCCESS, ret);
4481 }
4482
4483 /**
4484 * @tc.name : Test SetRendererPeriodPositionCallback API
4485 * @tc.number: Audio_Renderer_SetRendererPeriodPositionCallback_003
4486 * @tc.desc : Test SetRendererPeriodPositionCallback interface with null callback.
4487 */
4488 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPeriodPositionCallback_003, TestSize.Level1)
4489 {
4490 int32_t ret = -1;
4491
4492 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4493 ASSERT_NE(nullptr, audioRenderer);
4494
4495 ret = audioRenderer->SetRendererPeriodPositionCallback(VALUE_THOUSAND, nullptr);
4496 EXPECT_NE(SUCCESS, ret);
4497 }
4498
4499 /**
4500 * @tc.name : Test SetRendererPeriodPositionCallback API
4501 * @tc.number: Audio_Renderer_SetRendererPeriodPositionCallback_004
4502 * @tc.desc : Test SetRendererPeriodPositionCallback interface with invalid parameter.
4503 */
4504 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPeriodPositionCallback_004, TestSize.Level1)
4505 {
4506 int32_t ret = -1;
4507
4508 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4509 ASSERT_NE(nullptr, audioRenderer);
4510
4511 shared_ptr<RendererPeriodPositionCallbackTest> positionCB = std::make_shared<RendererPeriodPositionCallbackTest>();
4512 ret = audioRenderer->SetRendererPeriodPositionCallback(VALUE_ZERO, positionCB);
4513 EXPECT_NE(SUCCESS, ret);
4514
4515 ret = audioRenderer->SetRendererPeriodPositionCallback(VALUE_NEGATIVE, positionCB);
4516 EXPECT_NE(SUCCESS, ret);
4517 }
4518 } // namespace AudioStandard
4519 } // namespace OHOS
4520