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 #include "audio_renderer_proxy_obj.h"
25 #include "audio_policy_manager.h"
26 #include "audio_stream.h"
27 #include "audio_renderer_private.h"
28
29
30 using namespace std;
31 using namespace std::chrono;
32 using namespace testing::ext;
33
34 namespace OHOS {
35 namespace AudioStandard {
36 namespace {
37 const string AUDIORENDER_TEST_FILE_PATH = "/data/test_44100_2.wav";
38 const int32_t VALUE_NEGATIVE = -1;
39 const int32_t VALUE_ZERO = 0;
40 const int32_t VALUE_INVALID = -2;
41 const int32_t VALUE_HUNDRED = 100;
42 const int32_t VALUE_THOUSAND = 1000;
43 const int32_t VALUE_ERROR = -62980098;
44 const int32_t RENDERER_FLAG = 0;
45 // Writing only 500 buffers of data for test
46 const int32_t WRITE_BUFFERS_COUNT = 500;
47 constexpr int32_t PAUSE_BUFFER_POSITION = 400000;
48 constexpr int32_t PAUSE_RENDER_TIME_SECONDS = 1;
49
50 constexpr uint64_t BUFFER_DURATION_FIVE = 5;
51 constexpr uint64_t BUFFER_DURATION_TEN = 10;
52 constexpr uint64_t BUFFER_DURATION_FIFTEEN = 15;
53 constexpr uint64_t BUFFER_DURATION_TWENTY = 20;
54 constexpr uint32_t PLAYBACK_DURATION = 2;
55
56 static size_t g_reqBufLen = 0;
57 } // namespace
58
SetUpTestCase(void)59 void AudioRendererUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)60 void AudioRendererUnitTest::TearDownTestCase(void) {}
SetUp(void)61 void AudioRendererUnitTest::SetUp(void) {}
TearDown(void)62 void AudioRendererUnitTest::TearDown(void) {}
63
OnWriteData(size_t length)64 void AudioRenderModeCallbackTest::OnWriteData(size_t length)
65 {
66 g_reqBufLen = length;
67 }
68
InitializeRenderer(unique_ptr<AudioRenderer> & audioRenderer)69 int32_t AudioRendererUnitTest::InitializeRenderer(unique_ptr<AudioRenderer> &audioRenderer)
70 {
71 AudioRendererParams rendererParams;
72 rendererParams.sampleFormat = SAMPLE_S16LE;
73 rendererParams.sampleRate = SAMPLE_RATE_44100;
74 rendererParams.channelCount = STEREO;
75 rendererParams.encodingType = ENCODING_PCM;
76
77 return audioRenderer->SetParams(rendererParams);
78 }
79
InitializeRendererOptions(AudioRendererOptions & rendererOptions)80 void AudioRendererUnitTest::InitializeRendererOptions(AudioRendererOptions &rendererOptions)
81 {
82 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
83 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
84 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
85 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
86 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
87 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
88 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
89
90 return;
91 }
92
StartRenderThread(AudioRenderer * audioRenderer,uint32_t limit)93 void StartRenderThread(AudioRenderer *audioRenderer, uint32_t limit)
94 {
95 int32_t ret = -1;
96 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
97 ASSERT_NE(nullptr, wavFile);
98
99 size_t bufferLen;
100 ret = audioRenderer->GetBufferSize(bufferLen);
101 EXPECT_EQ(SUCCESS, ret);
102
103 auto buffer = std::make_unique<uint8_t[]>(bufferLen);
104 ASSERT_NE(nullptr, buffer);
105
106 size_t bytesToWrite = 0;
107 int32_t bytesWritten = 0;
108 size_t minBytes = 4;
109 int32_t numBuffersToRender = WRITE_BUFFERS_COUNT;
110 auto start = chrono::system_clock::now();
111
112 while (numBuffersToRender) {
113 bytesToWrite = fread(buffer.get(), 1, bufferLen, wavFile);
114 bytesWritten = 0;
115 while ((static_cast<size_t>(bytesWritten) < bytesToWrite) &&
116 ((static_cast<size_t>(bytesToWrite) - bytesWritten) > minBytes)) {
117 bytesWritten += audioRenderer->Write(buffer.get() + static_cast<size_t>(bytesWritten),
118 bytesToWrite - static_cast<size_t>(bytesWritten));
119 EXPECT_GE(bytesWritten, VALUE_ZERO);
120 if (bytesWritten < 0) {
121 break;
122 }
123 }
124 numBuffersToRender--;
125
126 if ((limit > 0) && (duration_cast<seconds>(system_clock::now() - start).count() > limit)) {
127 break;
128 }
129 }
130
131 audioRenderer->Drain();
132
133 fclose(wavFile);
134 }
135
136 /**
137 * @tc.name : Test GetSupportedFormats API
138 * @tc.number: Audio_Renderer_GetSupportedFormats_001
139 * @tc.desc : Test GetSupportedFormats interface. Returns supported Formats on success.
140 */
141 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetSupportedFormats_001, TestSize.Level0)
142 {
143 vector<AudioSampleFormat> supportedFormatList = AudioRenderer::GetSupportedFormats();
144 EXPECT_EQ(AUDIO_SUPPORTED_FORMATS.size(), supportedFormatList.size());
145 }
146
147 /**
148 * @tc.name : Test GetSupportedChannels API
149 * @tc.number: Audio_Renderer_GetSupportedChannels_001
150 * @tc.desc : Test GetSupportedChannels interface. Returns supported Channels on success.
151 */
152 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetSupportedChannels_001, TestSize.Level0)
153 {
154 vector<AudioChannel> supportedChannelList = AudioRenderer::GetSupportedChannels();
155 EXPECT_EQ(RENDERER_SUPPORTED_CHANNELS.size(), supportedChannelList.size());
156 }
157
158 /**
159 * @tc.name : Test GetSupportedEncodingTypes API
160 * @tc.number: Audio_Renderer_GetSupportedEncodingTypes_001
161 * @tc.desc : Test GetSupportedEncodingTypes interface. Returns supported Encoding types on success.
162 */
163 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetSupportedEncodingTypes_001, TestSize.Level0)
164 {
165 vector<AudioEncodingType> supportedEncodingTypes
166 = AudioRenderer::GetSupportedEncodingTypes();
167 EXPECT_EQ(AUDIO_SUPPORTED_ENCODING_TYPES.size(), supportedEncodingTypes.size());
168 }
169
170 /**
171 * @tc.name : Test GetSupportedSamplingRates API
172 * @tc.number: Audio_Renderer_GetSupportedSamplingRates_001
173 * @tc.desc : Test GetSupportedSamplingRates interface. Returns supported Sampling rates on success.
174 */
175 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetSupportedSamplingRates_001, TestSize.Level0)
176 {
177 vector<AudioSamplingRate> supportedSamplingRates = AudioRenderer::GetSupportedSamplingRates();
178 EXPECT_EQ(AUDIO_SUPPORTED_SAMPLING_RATES.size(), supportedSamplingRates.size());
179 }
180
181 /**
182 * @tc.name : Test Create API via legal input.
183 * @tc.number: Audio_Renderer_Create_001
184 * @tc.desc : Test Create interface with STREAM_MUSIC. Returns audioRenderer instance, if create is successful.
185 */
186 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_001, TestSize.Level0)
187 {
188 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
189 EXPECT_NE(nullptr, audioRenderer);
190 }
191
192 /**
193 * @tc.name : Test Create API via legal input.
194 * @tc.number: Audio_Renderer_Create_002
195 * @tc.desc : Test Create interface with STREAM_RING. Returns audioRenderer instance, if create is successful.
196 */
197 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_002, TestSize.Level0)
198 {
199 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_RING);
200 EXPECT_NE(nullptr, audioRenderer);
201 }
202
203 /**
204 * @tc.name : Test Create API via legal input.
205 * @tc.number: Audio_Renderer_Create_003
206 * @tc.desc : Test Create interface with STREAM_VOICE_CALL. Returns audioRenderer instance if create is successful.
207 * Note: instance will be created but functional support for STREAM_VOICE_CALL not available yet.
208 */
209 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_003, TestSize.Level0)
210 {
211 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_VOICE_CALL);
212 EXPECT_NE(nullptr, audioRenderer);
213 }
214
215 /**
216 * @tc.name : Test Create API via legal input.
217 * @tc.number: Audio_Renderer_Create_004
218 * @tc.desc : Test Create interface with STREAM_SYSTEM. Returns audioRenderer instance, if create is successful.
219 * Note: instance will be created but functional support for STREAM_SYSTEM not available yet.
220 */
221 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_004, TestSize.Level0)
222 {
223 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_SYSTEM);
224 EXPECT_NE(nullptr, audioRenderer);
225 }
226
227 /**
228 * @tc.name : Test Create API via legal input.
229 * @tc.number: Audio_Renderer_Create_005
230 * @tc.desc : Test Create interface with STREAM_BLUETOOTH_SCO. Returns audioRenderer instance, if create is successful.
231 * Note: instance will be created but functional support for STREAM_BLUETOOTH_SCO not available yet
232 */
233 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_005, TestSize.Level0)
234 {
235 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_BLUETOOTH_SCO);
236 EXPECT_NE(nullptr, audioRenderer);
237 }
238
239 /**
240 * @tc.name : Test Create API via legal input.
241 * @tc.number: Audio_Renderer_Create_006
242 * @tc.desc : Test Create interface with STREAM_ALARM. Returns audioRenderer instance, if create is successful.
243 * Note: instance will be created but functional support for STREAM_ALARM not available yet.
244 */
245 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_006, TestSize.Level0)
246 {
247 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_ALARM);
248 EXPECT_NE(nullptr, audioRenderer);
249 }
250
251 /**
252 * @tc.name : Test Create API via legal input.
253 * @tc.number: Audio_Renderer_Create_007
254 * @tc.desc : Test Create interface with STREAM_NOTIFICATION. Returns audioRenderer instance, if create is successful.
255 * Note: instance will be created but functional support for STREAM_NOTIFICATION not available yet.
256 */
257 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_007, TestSize.Level0)
258 {
259 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_NOTIFICATION);
260 EXPECT_NE(nullptr, audioRenderer);
261 }
262
263 /**
264 * @tc.name : Test Create API via legal input.
265 * @tc.number: Audio_Renderer_Create_008
266 * @tc.desc : Test Create interface with AudioRendererOptions below.
267 * Returns audioRenderer instance, if create is successful.
268 * rendererOptions.streamInfo.samplingRate = SAMPLE_RATE_96000;
269 * rendererOptions.streamInfo.encoding = ENCODING_PCM;
270 * rendererOptions.streamInfo.format = SAMPLE_U8;
271 * rendererOptions.streamInfo.channels = MONO;
272 * rendererOptions.rendererInfo.contentType = CONTENT_TYPE_MUSIC;
273 * rendererOptions.rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
274 * rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
275 */
276 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_008, TestSize.Level0)
277 {
278 AudioRendererOptions rendererOptions;
279 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
280 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
281 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
282 rendererOptions.streamInfo.channels = AudioChannel::MONO;
283 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
284 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
285 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
286
287 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
288 ASSERT_NE(nullptr, audioRenderer);
289 audioRenderer->Release();
290 }
291
292 /**
293 * @tc.name : Test Create API via legal input.
294 * @tc.number: Audio_Renderer_Create_009
295 * @tc.desc : Test Create interface with AudioRendererOptions below.
296 * Returns audioRenderer instance, if create is successful.
297 * rendererOptions.streamInfo.samplingRate = SAMPLE_RATE_96000;
298 * rendererOptions.streamInfo.encoding = ENCODING_PCM;
299 * rendererOptions.streamInfo.format = SAMPLE_U8;
300 * rendererOptions.streamInfo.channels = STEREO;
301 * rendererOptions.rendererInfo.contentType = CONTENT_TYPE_MOVIE;
302 * rendererOptions.rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
303 * rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
304 */
305 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_009, TestSize.Level0)
306 {
307 AudioRendererOptions rendererOptions;
308 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
309 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
310 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
311 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
312 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MOVIE;
313 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
314 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
315
316 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
317 ASSERT_NE(nullptr, audioRenderer);
318 audioRenderer->Release();
319 }
320
321 /**
322 * @tc.name : Test Create API via legal input.
323 * @tc.number: Audio_Renderer_Create_010
324 * @tc.desc : Test Create interface with AudioRendererOptions below.
325 * Returns audioRenderer instance, if create is successful.
326 * rendererOptions.streamInfo.samplingRate = SAMPLE_RATE_64000;
327 * rendererOptions.streamInfo.encoding = ENCODING_PCM;
328 * rendererOptions.streamInfo.format = SAMPLE_S32LE;
329 * rendererOptions.streamInfo.channels = MONO;
330 * rendererOptions.rendererInfo.contentType = CONTENT_TYPE_RINGTONE;
331 * rendererOptions.rendererInfo.streamUsage = STREAM_USAGE_NOTIFICATION_RINGTONE;
332 * rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
333 */
334 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_010, TestSize.Level0)
335 {
336 AudioRendererOptions rendererOptions;
337 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_64000;
338 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
339 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S32LE;
340 rendererOptions.streamInfo.channels = AudioChannel::MONO;
341 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_RINGTONE;
342 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_NOTIFICATION_RINGTONE;
343 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
344
345 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
346 ASSERT_NE(nullptr, audioRenderer);
347 audioRenderer->Release();
348 }
349
350 /**
351 * @tc.name : Test Create API via legal input.
352 * @tc.number: Audio_Renderer_Create_011
353 * @tc.desc : Test Create interface with AudioRendererOptions below.
354 * Returns audioRenderer instance, if create is successful.
355 * rendererOptions.streamInfo.samplingRate = SAMPLE_RATE_48000;
356 * rendererOptions.streamInfo.encoding = ENCODING_PCM;
357 * rendererOptions.streamInfo.format = SAMPLE_S24LE;
358 * rendererOptions.streamInfo.channels = STEREO;
359 * rendererOptions.rendererInfo.contentType = CONTENT_TYPE_MOVIE;
360 * rendererOptions.rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
361 * rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
362 */
363 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_011, TestSize.Level0)
364 {
365 AudioRendererOptions rendererOptions;
366 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
367 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
368 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S24LE;
369 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
370 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MOVIE;
371 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
372 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
373
374 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
375 ASSERT_NE(nullptr, audioRenderer);
376 audioRenderer->Release();
377 }
378
379 /**
380 * @tc.name : Test Create API via legal input.
381 * @tc.number: Audio_Renderer_Create_012
382 * @tc.desc : Test Create interface with AudioRendererOptions below.
383 * Returns audioRenderer instance, if create is successful.
384 * rendererOptions.streamInfo.samplingRate = SAMPLE_RATE_44100;
385 * rendererOptions.streamInfo.encoding = ENCODING_PCM;
386 * rendererOptions.streamInfo.format = SAMPLE_S16LE;
387 * rendererOptions.streamInfo.channels = MONO;
388 * rendererOptions.rendererInfo.contentType = CONTENT_TYPE_SONIFICATION;
389 * rendererOptions.rendererInfo.streamUsage = STREAM_USAGE_VOICE_ASSISTANT;
390 * rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
391 */
392 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_012, TestSize.Level0)
393 {
394 AudioRendererOptions rendererOptions;
395 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
396 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
397 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
398 rendererOptions.streamInfo.channels = AudioChannel::MONO;
399 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_SONIFICATION;
400 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_VOICE_ASSISTANT;
401 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
402
403 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
404 ASSERT_NE(nullptr, audioRenderer);
405 audioRenderer->Release();
406 }
407
408 /**
409 * @tc.name : Test Create API via legal input.
410 * @tc.number: Audio_Renderer_Create_013
411 * @tc.desc : Test Create interface with AudioRendererOptions below.
412 * Returns audioRenderer instance, if create is successful.
413 * rendererOptions.streamInfo.samplingRate = SAMPLE_RATE_22050;
414 * rendererOptions.streamInfo.encoding = ENCODING_PCM;
415 * rendererOptions.streamInfo.format = SAMPLE_S24LE;
416 * rendererOptions.streamInfo.channels = STEREO;
417 * rendererOptions.rendererInfo.contentType = CONTENT_TYPE_SPEECH;
418 * rendererOptions.rendererInfo.streamUsage = STREAM_USAGE_VOICE_COMMUNICATION;
419 * rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
420 */
421 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_013, TestSize.Level0)
422 {
423 AudioRendererOptions rendererOptions;
424 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_22050;
425 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
426 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S24LE;
427 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
428 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_SPEECH;
429 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION;
430 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
431
432 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
433 ASSERT_NE(nullptr, audioRenderer);
434 audioRenderer->Release();
435 }
436
437 /**
438 * @tc.name : Test Create API via legal input.
439 * @tc.number: Audio_Renderer_Create_014
440 * @tc.desc : Test Create interface with AudioRendererOptions below.
441 * Returns audioRenderer instance, if create is successful.
442 * rendererOptions.streamInfo.samplingRate = SAMPLE_RATE_12000;
443 * rendererOptions.streamInfo.encoding = ENCODING_PCM;
444 * rendererOptions.streamInfo.format = SAMPLE_S24LE;
445 * rendererOptions.streamInfo.channels = MONO;
446 * rendererOptions.rendererInfo.contentType = CONTENT_TYPE_MUSIC;
447 * rendererOptions.rendererInfo.streamUsage = STREAM_USAGE_VOICE_ASSISTANT;
448 * rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
449 */
450 HWTEST(AudioRendererUnitTest, Audio_Renderer_Create_014, TestSize.Level0)
451 {
452 AudioRendererOptions rendererOptions;
453 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_12000;
454 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
455 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S24LE;
456 rendererOptions.streamInfo.channels = AudioChannel::MONO;
457 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
458 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_VOICE_ASSISTANT;
459 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
460
461 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
462 ASSERT_NE(nullptr, audioRenderer);
463 audioRenderer->Release();
464 }
465
466 /**
467 * @tc.name : Test Renderer playback
468 * @tc.number: Audio_Renderer_Playback_001
469 * @tc.desc : Test normal playback for 2 sec
470 */
471 HWTEST(AudioRendererUnitTest, Audio_Renderer_Playback_001, TestSize.Level0)
472 {
473 AudioRendererOptions rendererOptions;
474 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
475 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
476 ASSERT_NE(nullptr, audioRenderer);
477
478 bool isStarted = audioRenderer->Start();
479 EXPECT_EQ(true, isStarted);
480
481 thread renderThread(StartRenderThread, audioRenderer.get(), PLAYBACK_DURATION);
482
483 renderThread.join();
484
485 bool isStopped = audioRenderer->Stop();
486 EXPECT_EQ(true, isStopped);
487
488 bool isReleased = audioRenderer->Release();
489 EXPECT_EQ(true, isReleased);
490 }
491
492 /**
493 * @tc.name : Test SetParams API via legal input
494 * @tc.number: Audio_Renderer_SetParams_001
495 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
496 * rendererParams.sampleFormat = SAMPLE_S16LE;
497 * rendererParams.sampleRate = SAMPLE_RATE_44100;
498 * rendererParams.channelCount = STEREO;
499 * rendererParams.encodingType = ENCODING_PCM;
500 */
501 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_001, TestSize.Level1)
502 {
503 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
504 ASSERT_NE(nullptr, audioRenderer);
505
506 AudioRendererParams rendererParams;
507 rendererParams.sampleFormat = SAMPLE_S16LE;
508 rendererParams.sampleRate = SAMPLE_RATE_44100;
509 rendererParams.channelCount = STEREO;
510 rendererParams.encodingType = ENCODING_PCM;
511
512 int32_t ret = audioRenderer->SetParams(rendererParams);
513 EXPECT_EQ(SUCCESS, ret);
514 audioRenderer->Release();
515 }
516
517 /**
518 * @tc.name : Test SetParams API via legal input.
519 * @tc.number: Audio_Renderer_SetParams_002
520 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
521 * rendererParams.sampleFormat = SAMPLE_S16LE;
522 * rendererParams.sampleRate = SAMPLE_RATE_8000;
523 * rendererParams.channelCount = MONO;
524 * rendererParams.encodingType = ENCODING_PCM;
525 */
526 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_002, TestSize.Level1)
527 {
528 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
529 ASSERT_NE(nullptr, audioRenderer);
530
531 AudioRendererParams rendererParams;
532 rendererParams.sampleFormat = SAMPLE_S16LE;
533 rendererParams.sampleRate = SAMPLE_RATE_8000;
534 rendererParams.channelCount = MONO;
535 rendererParams.encodingType = ENCODING_PCM;
536
537 int32_t ret = audioRenderer->SetParams(rendererParams);
538 EXPECT_EQ(SUCCESS, ret);
539 audioRenderer->Release();
540 }
541
542 /**
543 * @tc.name : Test SetParams API via legal input.
544 * @tc.number: Audio_Renderer_SetParams_003
545 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
546 * rendererParams.sampleFormat = SAMPLE_S16LE;
547 * rendererParams.sampleRate = SAMPLE_RATE_11025;
548 * rendererParams.channelCount = STEREO;
549 * rendererParams.encodingType = ENCODING_PCM;
550 */
551 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_003, TestSize.Level1)
552 {
553 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
554 ASSERT_NE(nullptr, audioRenderer);
555
556 AudioRendererParams rendererParams;
557 rendererParams.sampleFormat = SAMPLE_S16LE;
558 rendererParams.sampleRate = SAMPLE_RATE_11025;
559 rendererParams.channelCount = STEREO;
560 rendererParams.encodingType = ENCODING_PCM;
561
562 int32_t ret = audioRenderer->SetParams(rendererParams);
563 EXPECT_EQ(SUCCESS, ret);
564 audioRenderer->Release();
565 }
566
567 /**
568 * @tc.name : Test SetParams API via legal input.
569 * @tc.number: Audio_Renderer_SetParams_004
570 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
571 * rendererParams.sampleFormat = SAMPLE_S16LE;
572 * rendererParams.sampleRate = SAMPLE_RATE_22050;
573 * rendererParams.channelCount = MONO;
574 * rendererParams.encodingType = ENCODING_PCM;
575 */
576 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_004, TestSize.Level1)
577 {
578 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
579 ASSERT_NE(nullptr, audioRenderer);
580
581 AudioRendererParams rendererParams;
582 rendererParams.sampleFormat = SAMPLE_S16LE;
583 rendererParams.sampleRate = SAMPLE_RATE_22050;
584 rendererParams.channelCount = MONO;
585 rendererParams.encodingType = ENCODING_PCM;
586
587 int32_t ret = audioRenderer->SetParams(rendererParams);
588 EXPECT_EQ(SUCCESS, ret);
589 audioRenderer->Release();
590 }
591
592 /**
593 * @tc.name : Test SetParams API via legal input.
594 * @tc.number: Audio_Renderer_SetParams_005
595 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
596 * rendererParams.sampleFormat = SAMPLE_S16LE;
597 * rendererParams.sampleRate = SAMPLE_RATE_96000;
598 * rendererParams.channelCount = MONO;
599 * rendererParams.encodingType = ENCODING_PCM;
600 */
601 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_005, TestSize.Level1)
602 {
603 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
604 ASSERT_NE(nullptr, audioRenderer);
605
606 AudioRendererParams rendererParams;
607 rendererParams.sampleFormat = SAMPLE_S16LE;
608 rendererParams.sampleRate = SAMPLE_RATE_96000;
609 rendererParams.channelCount = MONO;
610 rendererParams.encodingType = ENCODING_PCM;
611
612 int32_t ret = audioRenderer->SetParams(rendererParams);
613 EXPECT_EQ(SUCCESS, ret);
614 }
615
616 /**
617 * @tc.name : Test SetParams API via legal input.
618 * @tc.number: Audio_Renderer_SetParams_006
619 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
620 * rendererParams.sampleFormat = SAMPLE_S24LE;
621 * rendererParams.sampleRate = SAMPLE_RATE_64000;
622 * rendererParams.channelCount = MONO;
623 * rendererParams.encodingType = ENCODING_PCM;
624 */
625 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_006, TestSize.Level1)
626 {
627 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
628 ASSERT_NE(nullptr, audioRenderer);
629
630 AudioRendererParams rendererParams;
631 rendererParams.sampleFormat = SAMPLE_S24LE;
632 rendererParams.sampleRate = SAMPLE_RATE_64000;
633 rendererParams.channelCount = MONO;
634 rendererParams.encodingType = ENCODING_PCM;
635
636 int32_t ret = audioRenderer->SetParams(rendererParams);
637 EXPECT_EQ(SUCCESS, ret);
638 }
639
640 /**
641 * @tc.name : Test SetParams API via illegal input.
642 * @tc.number: Audio_Renderer_SetParams_007
643 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
644 * rendererParams.sampleFormat = SAMPLE_S16LE;
645 * rendererParams.sampleRate = SAMPLE_RATE_16000;
646 * rendererParams.channelCount = STEREO;
647 * rendererParams.encodingType = ENCODING_PCM;
648 */
649 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_007, TestSize.Level1)
650 {
651 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
652 ASSERT_NE(nullptr, audioRenderer);
653
654 AudioRendererParams rendererParams;
655 rendererParams.sampleFormat = SAMPLE_S16LE;
656 rendererParams.sampleRate = SAMPLE_RATE_16000;
657 rendererParams.channelCount = STEREO;
658 rendererParams.encodingType = ENCODING_PCM;
659
660 int32_t ret = audioRenderer->SetParams(rendererParams);
661 EXPECT_EQ(SUCCESS, ret);
662 audioRenderer->Release();
663 }
664
665 /**
666 * @tc.name : Test SetParams API stability.
667 * @tc.number: Audio_Renderer_SetParams_Stability_001
668 * @tc.desc : Test SetParams interface stability.
669 */
670 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetParams_Stability_001, TestSize.Level1)
671 {
672 int32_t ret = -1;
673 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
674 ASSERT_NE(nullptr, audioRenderer);
675
676 AudioRendererParams rendererParams;
677 rendererParams.sampleFormat = SAMPLE_S16LE;
678 rendererParams.sampleRate = SAMPLE_RATE_44100;
679 rendererParams.channelCount = STEREO;
680 rendererParams.encodingType = ENCODING_PCM;
681
682 for (int i = 0; i < VALUE_HUNDRED; i++) {
683 ret = audioRenderer->SetParams(rendererParams);
684 EXPECT_EQ(SUCCESS, ret);
685
686 AudioRendererParams getRendererParams;
687 ret = audioRenderer->GetParams(getRendererParams);
688 EXPECT_EQ(SUCCESS, ret);
689 }
690
691 audioRenderer->Release();
692 }
693
694 /**
695 * @tc.name : Test GetParams API via legal input.
696 * @tc.number: Audio_Renderer_GetParams_001
697 * @tc.desc : Test GetParams interface. Returns 0 {SUCCESS}, if the getting is successful.
698 */
699 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_001, TestSize.Level1)
700 {
701 int32_t ret = -1;
702 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
703 ASSERT_NE(nullptr, audioRenderer);
704
705 AudioRendererParams rendererParams;
706 rendererParams.sampleFormat = SAMPLE_S16LE;
707 rendererParams.sampleRate = SAMPLE_RATE_44100;
708 rendererParams.channelCount = STEREO;
709 rendererParams.encodingType = ENCODING_PCM;
710 ret = audioRenderer->SetParams(rendererParams);
711 EXPECT_EQ(SUCCESS, ret);
712
713 AudioRendererParams getRendererParams;
714 ret = audioRenderer->GetParams(getRendererParams);
715 EXPECT_EQ(SUCCESS, ret);
716 EXPECT_EQ(rendererParams.sampleFormat, getRendererParams.sampleFormat);
717 EXPECT_EQ(rendererParams.sampleRate, getRendererParams.sampleRate);
718 EXPECT_EQ(rendererParams.channelCount, getRendererParams.channelCount);
719 EXPECT_EQ(rendererParams.encodingType, getRendererParams.encodingType);
720
721 audioRenderer->Release();
722 }
723
724 /**
725 * @tc.name : Test GetParams API via legal state, RENDERER_RUNNING: GetParams after Start.
726 * @tc.number: Audio_Renderer_GetParams_002
727 * @tc.desc : Test GetParams interface. Returns 0 {SUCCESS} if the getting is successful.
728 */
729 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_002, TestSize.Level1)
730 {
731 int32_t ret = -1;
732 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
733 ASSERT_NE(nullptr, audioRenderer);
734
735 AudioRendererParams rendererParams;
736 rendererParams.sampleFormat = SAMPLE_S16LE;
737 rendererParams.sampleRate = SAMPLE_RATE_44100;
738 rendererParams.channelCount = MONO;
739 rendererParams.encodingType = ENCODING_PCM;
740 ret = audioRenderer->SetParams(rendererParams);
741 EXPECT_EQ(SUCCESS, ret);
742
743 bool isStarted = audioRenderer->Start();
744 EXPECT_EQ(true, isStarted);
745
746 AudioRendererParams getRendererParams;
747 ret = audioRenderer->GetParams(getRendererParams);
748 EXPECT_EQ(SUCCESS, ret);
749
750 audioRenderer->Release();
751 }
752
753 /**
754 * @tc.name : Test GetParams API via illegal state, RENDERER_NEW: Call GetParams without SetParams.
755 * @tc.number: Audio_Renderer_GetParams_003
756 * @tc.desc : Test GetParams interface. Returns error code, if the renderer state is RENDERER_NEW.
757 */
758 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_003, TestSize.Level1)
759 {
760 int32_t ret = -1;
761 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
762 ASSERT_NE(nullptr, audioRenderer);
763
764 AudioRendererParams rendererParams;
765 rendererParams.sampleFormat = SAMPLE_S16LE;
766 rendererParams.sampleRate = SAMPLE_RATE_44100;
767 rendererParams.channelCount = MONO;
768 rendererParams.encodingType = ENCODING_PCM;
769
770 AudioRendererParams getRendererParams;
771 ret = audioRenderer->GetParams(getRendererParams);
772 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
773 }
774
775 /**
776 * @tc.name : Test GetParams API via illegal state, RENDERER_RELEASED: Call GetParams after Release.
777 * @tc.number: Audio_Renderer_GetParams_004
778 * @tc.desc : Test GetParams interface. Returns error code, if the renderer state is RENDERER_RELEASED.
779 */
780 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_004, TestSize.Level1)
781 {
782 int32_t ret = -1;
783 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
784 ASSERT_NE(nullptr, audioRenderer);
785
786 ret = AudioRendererUnitTest::InitializeRenderer(audioRenderer);
787 EXPECT_EQ(SUCCESS, ret);
788
789 bool isReleased = audioRenderer->Release();
790 EXPECT_EQ(true, isReleased);
791
792 AudioRendererParams getRendererParams;
793 ret = audioRenderer->GetParams(getRendererParams);
794 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
795 }
796
797 /**
798 * @tc.name : Test GetParams API via legal state, RENDERER_STOPPED: GetParams after Stop.
799 * @tc.number: Audio_Renderer_GetParams_005
800 * @tc.desc : Test GetParams interface. Returns 0 {SUCCESS}, if the getting is successful.
801 */
802 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_005, TestSize.Level1)
803 {
804 int32_t ret = -1;
805 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
806 ASSERT_NE(nullptr, audioRenderer);
807
808 ret = AudioRendererUnitTest::InitializeRenderer(audioRenderer);
809 EXPECT_EQ(SUCCESS, ret);
810
811 bool isStarted = audioRenderer->Start();
812 EXPECT_EQ(true, isStarted);
813
814 bool isStopped = audioRenderer->Stop();
815 EXPECT_EQ(true, isStopped);
816
817 AudioRendererParams getRendererParams;
818 ret = audioRenderer->GetParams(getRendererParams);
819 EXPECT_EQ(SUCCESS, ret);
820
821 audioRenderer->Release();
822 }
823
824 /**
825 * @tc.name : Test GetParams API via legal input.
826 * @tc.number: Audio_Renderer_GetParams_006
827 * @tc.desc : Test GetParams interface. Returns 0 {SUCCESS}, if the getting is successful.
828 */
829 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_006, TestSize.Level1)
830 {
831 int32_t ret = -1;
832 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
833 ASSERT_NE(nullptr, audioRenderer);
834
835 AudioRendererParams rendererParams;
836 rendererParams.sampleFormat = SAMPLE_S24LE;
837 rendererParams.sampleRate = SAMPLE_RATE_44100;
838 rendererParams.channelCount = STEREO;
839 rendererParams.encodingType = ENCODING_PCM;
840 ret = audioRenderer->SetParams(rendererParams);
841 EXPECT_EQ(SUCCESS, ret);
842
843 AudioRendererParams getRendererParams;
844 ret = audioRenderer->GetParams(getRendererParams);
845 EXPECT_EQ(SUCCESS, ret);
846 EXPECT_EQ(rendererParams.sampleFormat, getRendererParams.sampleFormat);
847 EXPECT_EQ(rendererParams.sampleRate, getRendererParams.sampleRate);
848 EXPECT_EQ(rendererParams.channelCount, getRendererParams.channelCount);
849 EXPECT_EQ(rendererParams.encodingType, getRendererParams.encodingType);
850
851 audioRenderer->Release();
852 }
853
854 /**
855 * @tc.name : Test GetParams API via legal input.
856 * @tc.number: Audio_Renderer_GetParams_007
857 * @tc.desc : Test GetParams interface. Returns 0 {SUCCESS}, if the getting is successful.
858 */
859 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_007, TestSize.Level1)
860 {
861 int32_t ret = -1;
862 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
863 ASSERT_NE(nullptr, audioRenderer);
864
865 AudioRendererParams rendererParams;
866 rendererParams.sampleFormat = SAMPLE_S32LE;
867 rendererParams.sampleRate = SAMPLE_RATE_44100;
868 rendererParams.channelCount = STEREO;
869 rendererParams.encodingType = ENCODING_PCM;
870 ret = audioRenderer->SetParams(rendererParams);
871 EXPECT_EQ(SUCCESS, ret);
872
873 AudioRendererParams getRendererParams;
874 ret = audioRenderer->GetParams(getRendererParams);
875 EXPECT_EQ(SUCCESS, ret);
876 EXPECT_EQ(rendererParams.sampleFormat, getRendererParams.sampleFormat);
877 EXPECT_EQ(rendererParams.sampleRate, getRendererParams.sampleRate);
878 EXPECT_EQ(rendererParams.channelCount, getRendererParams.channelCount);
879 EXPECT_EQ(rendererParams.encodingType, getRendererParams.encodingType);
880
881 audioRenderer->Release();
882 }
883
884 /**
885 * @tc.name : Test GetParams API via legal input.
886 * @tc.number: Audio_Renderer_GetParams_008
887 * @tc.desc : Test GetParams interface. Returns 0 {SUCCESS}, if the getting is successful.
888 */
889 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_008, TestSize.Level1)
890 {
891 int32_t ret = -1;
892 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
893 ASSERT_NE(nullptr, audioRenderer);
894
895 AudioRendererParams getRendererParams;
896 getRendererParams.sampleFormat = AudioSampleFormat::INVALID_WIDTH;
897 ret = audioRenderer->GetParams(getRendererParams);
898 EXPECT_EQ(true, ret < 0);
899 audioRenderer->Release();
900 }
901
902 /**
903 * @tc.name : Test SetInterruptMode API via legal input
904 * @tc.number: Audio_Renderer_SetInterruptMode_001
905 * @tc.desc : Test SetInterruptMode interface. Returns 0 {SUCCESS}, if the setting is successful.
906 */
907 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetInterruptMode_001, TestSize.Level1)
908 {
909 int32_t ret = -1;
910 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
911 ASSERT_NE(nullptr, audioRenderer);
912
913 ret = AudioRendererUnitTest::InitializeRenderer(audioRenderer);
914 EXPECT_EQ(SUCCESS, ret);
915
916 audioRenderer->SetInterruptMode(SHARE_MODE);
917
918 bool isStarted = audioRenderer->Start();
919 EXPECT_EQ(true, isStarted);
920
921 bool isStopped = audioRenderer->Stop();
922 EXPECT_EQ(true, isStopped);
923 audioRenderer->Release();
924 }
925
926 /**
927 * @tc.name : Test SetInterruptMode API via legal input
928 * @tc.number: Audio_Renderer_SetInterruptMode_002
929 * @tc.desc : Test SetInterruptMode interface. Returns 0 {SUCCESS}, if the setting is successful.
930 */
931 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetInterruptMode_002, TestSize.Level1)
932 {
933 int32_t ret = -1;
934 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
935 ASSERT_NE(nullptr, audioRenderer);
936
937 ret = AudioRendererUnitTest::InitializeRenderer(audioRenderer);
938 EXPECT_EQ(SUCCESS, ret);
939
940 audioRenderer->SetInterruptMode(INDEPENDENT_MODE);
941
942 bool isStarted = audioRenderer->Start();
943 EXPECT_EQ(true, isStarted);
944
945 bool isStopped = audioRenderer->Stop();
946 EXPECT_EQ(true, isStopped);
947 audioRenderer->Release();
948 }
949
950 /**
951 * @tc.name : Test GetBufQueueState
952 * @tc.number: Audio_Renderer_GetBufQueueState_001
953 * @tc.desc : Test GetBufQueueState interface. Returns BufferQueueState, if obtained successfully.
954 */
955 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufQueueState_001, TestSize.Level1)
956 {
957 int32_t ret = -1;
958 AudioRendererOptions rendererOptions;
959
960 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
961 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
962 ASSERT_NE(nullptr, audioRenderer);
963
964 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
965 EXPECT_EQ(SUCCESS, ret);
966 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
967 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
968
969 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
970
971 ret = audioRenderer->SetRendererWriteCallback(cb);
972 EXPECT_EQ(SUCCESS, ret);
973
974 BufferQueueState bQueueSate {};
975 bQueueSate.currentIndex = 1;
976 bQueueSate.numBuffers = 1;
977
978 ret = audioRenderer->GetBufQueueState(bQueueSate);
979 EXPECT_EQ(SUCCESS, ret);
980 audioRenderer->Release();
981 }
982
983 /**
984 * @tc.name : Test GetParams API stability.
985 * @tc.number: Audio_Renderer_GetParams_Stability_001
986 * @tc.desc : Test GetParams interface stability.
987 */
988 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetParams_Stability_001, TestSize.Level1)
989 {
990 int32_t ret = -1;
991 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
992 ASSERT_NE(nullptr, audioRenderer);
993
994 AudioRendererParams rendererParams;
995 rendererParams.sampleFormat = SAMPLE_S16LE;
996 rendererParams.sampleRate = SAMPLE_RATE_44100;
997 rendererParams.channelCount = STEREO;
998 rendererParams.encodingType = ENCODING_PCM;
999
1000 ret = audioRenderer->SetParams(rendererParams);
1001 EXPECT_EQ(SUCCESS, ret);
1002
1003 for (int i = 0; i < VALUE_THOUSAND; i++) {
1004 AudioRendererParams getRendererParams;
1005 ret = audioRenderer->GetParams(getRendererParams);
1006 EXPECT_EQ(SUCCESS, ret);
1007 }
1008
1009 audioRenderer->Release();
1010 }
1011
1012 /**
1013 * @tc.name : Test GetBufferSize API via legal input.
1014 * @tc.number: Audio_Renderer_GetBufferSize_001
1015 * @tc.desc : Test GetBufferSize interface. Returns 0 {SUCCESS}, if the getting is successful.
1016 */
1017 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufferSize_001, TestSize.Level1)
1018 {
1019 int32_t ret = -1;
1020 AudioRendererOptions rendererOptions;
1021
1022 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1023 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1024 ASSERT_NE(nullptr, audioRenderer);
1025
1026 size_t bufferLen;
1027 ret = audioRenderer->GetBufferSize(bufferLen);
1028 EXPECT_EQ(SUCCESS, ret);
1029
1030 audioRenderer->Release();
1031 }
1032
1033 /**
1034 * @tc.name : Test GetBufferSize API via illegal state, RENDERER_NEW: without initializing the renderer.
1035 * @tc.number: Audio_Renderer_GetBufferSize_002
1036 * @tc.desc : Test GetBufferSize interface. Returns error code, if the renderer state is RENDERER_NEW.
1037 */
1038 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufferSize_002, TestSize.Level1)
1039 {
1040 int32_t ret = -1;
1041 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
1042 ASSERT_NE(nullptr, audioRenderer);
1043
1044 size_t bufferLen;
1045 ret = audioRenderer->GetBufferSize(bufferLen);
1046 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
1047 }
1048
1049 /**
1050 * @tc.name : Test GetBufferSize API via illegal state, RENDERER_RELEASED: call Release before GetBufferSize
1051 * @tc.number: Audio_Renderer_GetBufferSize_003
1052 * @tc.desc : Test GetBufferSize interface. Returns error code, if the renderer state is RENDERER_RELEASED.
1053 */
1054 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufferSize_003, TestSize.Level1)
1055 {
1056 int32_t ret = -1;
1057 AudioRendererOptions rendererOptions;
1058
1059 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1060 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1061 ASSERT_NE(nullptr, audioRenderer);
1062
1063 bool isReleased = audioRenderer->Release();
1064 EXPECT_EQ(true, isReleased);
1065
1066 size_t bufferLen;
1067 ret = audioRenderer->GetBufferSize(bufferLen);
1068 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
1069 }
1070
1071 /**
1072 * @tc.name : Test GetBufferSize API via legal state, RENDERER_STOPPED: call Stop before GetBufferSize
1073 * @tc.number: Audio_Renderer_GetBufferSize_004
1074 * @tc.desc : Test GetBufferSize interface. Returns 0 {SUCCESS}, if the getting is successful.
1075 */
1076 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufferSize_004, TestSize.Level1)
1077 {
1078 int32_t ret = -1;
1079 AudioRendererOptions rendererOptions;
1080
1081 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1082 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1083 ASSERT_NE(nullptr, audioRenderer);
1084
1085 bool isStarted = audioRenderer->Start();
1086 EXPECT_EQ(true, isStarted);
1087
1088 bool isStopped = audioRenderer->Stop();
1089 EXPECT_EQ(true, isStopped);
1090
1091 size_t bufferLen;
1092 ret = audioRenderer->GetBufferSize(bufferLen);
1093 EXPECT_EQ(SUCCESS, ret);
1094
1095 audioRenderer->Release();
1096 }
1097
1098 /**
1099 * @tc.name : Test GetBufferSize API via legal state, RENDERER_RUNNING: call Start before GetBufferSize
1100 * @tc.number: Audio_Renderer_GetBufferSize_005
1101 * @tc.desc : test GetBufferSize interface. Returns 0 {SUCCESS}, if the getting is successful.
1102 */
1103 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufferSize_005, TestSize.Level1)
1104 {
1105 int32_t ret = -1;
1106 AudioRendererOptions rendererOptions;
1107
1108 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1109 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1110 ASSERT_NE(nullptr, audioRenderer);
1111
1112 bool isStarted = audioRenderer->Start();
1113 EXPECT_EQ(true, isStarted);
1114
1115 size_t bufferLen;
1116 ret = audioRenderer->GetBufferSize(bufferLen);
1117 EXPECT_EQ(SUCCESS, ret);
1118
1119 audioRenderer->Release();
1120 }
1121
1122 /**
1123 * @tc.name : Test GetAudioStreamId API stability.
1124 * @tc.number: Audio_Renderer_GetAudioStreamId_001
1125 * @tc.desc : Test GetAudioStreamId interface stability.
1126 */
1127 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioStreamId_001, TestSize.Level1)
1128 {
1129 int32_t ret = -1;
1130 AudioRendererOptions rendererOptions;
1131
1132 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1133 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1134 ASSERT_NE(nullptr, audioRenderer);
1135
1136 uint32_t sessionID;
1137 ret = audioRenderer->GetAudioStreamId(sessionID);
1138 EXPECT_EQ(SUCCESS, ret);
1139
1140 audioRenderer->Release();
1141 }
1142
1143 /**
1144 * @tc.name : Test SetAudioRendererDesc API stability.
1145 * @tc.number: Audio_Renderer_SetAudioRendererDesc_001
1146 * @tc.desc : Test SetAudioRendererDesc interface stability.
1147 */
1148 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetAudioRendererDesc_001, TestSize.Level1)
1149 {
1150 int32_t ret = -1;
1151 AudioRendererOptions rendererOptions;
1152
1153 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1154 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1155 ASSERT_NE(nullptr, audioRenderer);
1156
1157 AudioRendererDesc audioRD = {CONTENT_TYPE_MUSIC, STREAM_USAGE_VOICE_COMMUNICATION};
1158 ret = audioRenderer->SetAudioRendererDesc(audioRD);
1159 EXPECT_EQ(SUCCESS, ret);
1160
1161 audioRenderer->Release();
1162 }
1163
1164 /**
1165 * @tc.name : Test SetStreamType API stability.
1166 * @tc.number: Audio_Renderer_SetStreamType_001
1167 * @tc.desc : Test SetStreamType interface stability.
1168 */
1169 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetStreamType_001, TestSize.Level1)
1170 {
1171 int32_t ret = -1;
1172 AudioRendererOptions rendererOptions;
1173
1174 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1175 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1176 ASSERT_NE(nullptr, audioRenderer);
1177
1178 AudioStreamType audioStreamType = STREAM_MUSIC;
1179 ret = audioRenderer->SetStreamType(audioStreamType);
1180 EXPECT_EQ(SUCCESS, ret);
1181
1182 audioRenderer->Release();
1183 }
1184
1185 /**
1186 * @tc.name : Test GetFrameCount API via legal input.
1187 * @tc.number: Audio_Renderer_GetFrameCount_001
1188 * @tc.desc : test GetFrameCount interface, Returns 0 {SUCCESS}, if the getting is successful.
1189 */
1190 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetFrameCount_001, TestSize.Level1)
1191 {
1192 int32_t ret = -1;
1193 AudioRendererOptions rendererOptions;
1194
1195 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1196 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1197 ASSERT_NE(nullptr, audioRenderer);
1198
1199 uint32_t frameCount;
1200 ret = audioRenderer->GetFrameCount(frameCount);
1201 EXPECT_EQ(SUCCESS, ret);
1202
1203 audioRenderer->Release();
1204 }
1205
1206 /**
1207 * @tc.name : Test GetFrameCount API via illegal state, RENDERER_NEW: without initialiing the renderer.
1208 * @tc.number: Audio_Renderer_GetFrameCount_002
1209 * @tc.desc : Test GetFrameCount interface. Returns error code, if the renderer state is RENDERER_NEW.
1210 */
1211 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetFrameCount_002, TestSize.Level1)
1212 {
1213 int32_t ret = -1;
1214 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
1215 ASSERT_NE(nullptr, audioRenderer);
1216
1217 uint32_t frameCount;
1218 ret = audioRenderer->GetFrameCount(frameCount);
1219 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
1220 }
1221
1222 /**
1223 * @tc.name : Test GetFrameCount API via legal state, RENDERER_RUNNING: call Start before GetFrameCount.
1224 * @tc.number: Audio_Renderer_GetFrameCount_003
1225 * @tc.desc : Test GetFrameCount interface. Returns 0 {SUCCESS}, if the getting is successful.
1226 */
1227 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetFrameCount_003, TestSize.Level1)
1228 {
1229 int32_t ret = -1;
1230 AudioRendererOptions rendererOptions;
1231
1232 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1233 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1234 ASSERT_NE(nullptr, audioRenderer);
1235
1236 bool isStarted = audioRenderer->Start();
1237 EXPECT_EQ(true, isStarted);
1238
1239 uint32_t frameCount;
1240 ret = audioRenderer->GetFrameCount(frameCount);
1241 EXPECT_EQ(SUCCESS, ret);
1242
1243 audioRenderer->Release();
1244 }
1245
1246 /**
1247 * @tc.name : Test GetFrameCount API via legal state, RENDERER_STOPPED: call Stop before GetFrameCount
1248 * @tc.number: Audio_Renderer_GetFrameCount_004
1249 * @tc.desc : Test GetFrameCount interface. Returns 0 {SUCCESS}, if the getting is successful.
1250 */
1251 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetFrameCount_004, TestSize.Level1)
1252 {
1253 int32_t ret = -1;
1254 AudioRendererOptions rendererOptions;
1255
1256 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1257 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1258 ASSERT_NE(nullptr, audioRenderer);
1259
1260 bool isStarted = audioRenderer->Start();
1261 EXPECT_EQ(true, isStarted);
1262
1263 bool isStopped = audioRenderer->Stop();
1264 EXPECT_EQ(true, isStopped);
1265
1266 uint32_t frameCount;
1267 ret = audioRenderer->GetFrameCount(frameCount);
1268 EXPECT_EQ(SUCCESS, ret);
1269
1270 audioRenderer->Release();
1271 }
1272
1273 /**
1274 * @tc.name : Test GetFrameCount API via illegal state, RENDERER_RELEASED: call Release before GetFrameCount
1275 * @tc.number: Audio_Renderer_GetFrameCount_005
1276 * @tc.desc : Test GetFrameCount interface. Returns error code, if the state is RENDERER_RELEASED.
1277 */
1278 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetFrameCount_005, TestSize.Level1)
1279 {
1280 int32_t ret = -1;
1281 AudioRendererOptions rendererOptions;
1282
1283 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1284 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1285 ASSERT_NE(nullptr, audioRenderer);
1286
1287 bool isReleased = audioRenderer->Release();
1288 EXPECT_EQ(true, isReleased);
1289
1290 uint32_t frameCount;
1291 ret = audioRenderer->GetFrameCount(frameCount);
1292 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
1293 }
1294
1295 /**
1296 * @tc.name : Test GetFrameCount API via legal state, RENDERER_PAUSED: call Pause before GetFrameCount
1297 * @tc.number: Audio_Renderer_GetFrameCount_006
1298 * @tc.desc : Test GetFrameCount interface. Returns 0 {SUCCESS}, if the getting is successful.
1299 */
1300 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetFrameCount_006, TestSize.Level1)
1301 {
1302 int32_t ret = -1;
1303 AudioRendererOptions rendererOptions;
1304
1305 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1306 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1307 ASSERT_NE(nullptr, audioRenderer);
1308
1309 bool isStarted = audioRenderer->Start();
1310 EXPECT_EQ(true, isStarted);
1311
1312 bool isPaused = audioRenderer->Pause();
1313 EXPECT_EQ(true, isPaused);
1314
1315 uint32_t frameCount;
1316 ret = audioRenderer->GetFrameCount(frameCount);
1317 EXPECT_EQ(SUCCESS, ret);
1318
1319 audioRenderer->Release();
1320 }
1321
1322 /**
1323 * @tc.name : Test SetVolume
1324 * @tc.number: Audio_Renderer_SetVolume_001
1325 * @tc.desc : Test SetVolume interface, Returns 0 {SUCCESS}, if the track volume is set.
1326 */
1327 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetVolume_001, TestSize.Level1)
1328 {
1329 int32_t ret = -1;
1330 AudioRendererOptions rendererOptions;
1331
1332 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1333 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1334 ASSERT_NE(nullptr, audioRenderer);
1335
1336 ret = audioRenderer->SetVolume(0.5);
1337 EXPECT_EQ(SUCCESS, ret);
1338
1339 bool isReleased = audioRenderer->Release();
1340 EXPECT_EQ(true, isReleased);
1341 }
1342
1343 /**
1344 * @tc.name : Test SetVolume
1345 * @tc.number: Audio_Renderer_SetVolume_002
1346 * @tc.desc : Test SetVolume interface for minimum and maximum volumes.
1347 */
1348 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetVolume_002, TestSize.Level1)
1349 {
1350 int32_t ret = -1;
1351 AudioRendererOptions rendererOptions;
1352
1353 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1354 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1355 ASSERT_NE(nullptr, audioRenderer);
1356
1357 ret = audioRenderer->SetVolume(0);
1358 EXPECT_EQ(SUCCESS, ret);
1359
1360 ret = audioRenderer->SetVolume(1.0);
1361 EXPECT_EQ(SUCCESS, ret);
1362
1363 bool isReleased = audioRenderer->Release();
1364 EXPECT_EQ(true, isReleased);
1365 }
1366
1367 /**
1368 * @tc.name : Test SetVolume
1369 * @tc.number: Audio_Renderer_SetVolume_003
1370 * @tc.desc : Test SetVolume interface for out of range values.
1371 */
1372 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetVolume_003, TestSize.Level1)
1373 {
1374 int32_t ret = -1;
1375 AudioRendererOptions rendererOptions;
1376
1377 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1378 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1379 ASSERT_NE(nullptr, audioRenderer);
1380
1381 ret = audioRenderer->SetVolume(-0.5);
1382 EXPECT_NE(SUCCESS, ret);
1383
1384 ret = audioRenderer->SetVolume(1.5);
1385 EXPECT_NE(SUCCESS, ret);
1386
1387 bool isReleased = audioRenderer->Release();
1388 EXPECT_EQ(true, isReleased);
1389 }
1390
1391 /**
1392 * @tc.name : Test SetVolume
1393 * @tc.number: Audio_Renderer_SetVolume_Stability_001
1394 * @tc.desc : Test SetVolume interface stability.
1395 */
1396 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetVolume_Stability_001, TestSize.Level1)
1397 {
1398 AudioRendererOptions rendererOptions;
1399
1400 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1401 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1402 ASSERT_NE(nullptr, audioRenderer);
1403
1404 bool isStarted = audioRenderer->Start();
1405 EXPECT_EQ(true, isStarted);
1406
1407 thread renderThread(StartRenderThread, audioRenderer.get(), 0);
1408
1409 for (int i = 0; i < VALUE_HUNDRED; i++) {
1410 audioRenderer->SetVolume(0.1);
1411 audioRenderer->SetVolume(1.0);
1412 }
1413
1414 renderThread.join();
1415
1416 bool isStopped = audioRenderer->Stop();
1417 EXPECT_EQ(true, isStopped);
1418
1419 bool isReleased = audioRenderer->Release();
1420 EXPECT_EQ(true, isReleased);
1421 }
1422
1423 /**
1424 * @tc.name : Test GetVolume
1425 * @tc.number: Audio_Renderer_GetVolume_001
1426 * @tc.desc : Test GetVolume interface to get the default value.
1427 */
1428 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetVolume_001, TestSize.Level1)
1429 {
1430 AudioRendererOptions rendererOptions;
1431
1432 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1433 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1434 ASSERT_NE(nullptr, audioRenderer);
1435
1436 float volume = audioRenderer->GetVolume();
1437 EXPECT_EQ(1.0, volume);
1438
1439 bool isReleased = audioRenderer->Release();
1440 EXPECT_EQ(true, isReleased);
1441 }
1442
1443 /**
1444 * @tc.name : Test GetVolume
1445 * @tc.number: Audio_Renderer_GetVolume_002
1446 * @tc.desc : Test GetVolume interface after set volume call.
1447 */
1448 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetVolume_002, TestSize.Level1)
1449 {
1450 int32_t ret = -1;
1451 AudioRendererOptions rendererOptions;
1452
1453 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1454 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1455 ASSERT_NE(nullptr, audioRenderer);
1456
1457 ret = audioRenderer->SetVolume(0.5);
1458 EXPECT_EQ(SUCCESS, ret);
1459
1460 float volume = audioRenderer->GetVolume();
1461 EXPECT_EQ(0.5, volume);
1462
1463 bool isReleased = audioRenderer->Release();
1464 EXPECT_EQ(true, isReleased);
1465 }
1466
1467 /**
1468 * @tc.name : Test GetVolume
1469 * @tc.number: Audio_Renderer_GetVolume_003
1470 * @tc.desc : Test GetVolume interface after set volume fails.
1471 */
1472 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetVolume_003, TestSize.Level1)
1473 {
1474 int32_t ret = -1;
1475 AudioRendererOptions rendererOptions;
1476
1477 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1478 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1479 ASSERT_NE(nullptr, audioRenderer);
1480
1481 ret = audioRenderer->SetVolume(0.5);
1482 EXPECT_EQ(SUCCESS, ret);
1483
1484 ret = audioRenderer->SetVolume(1.5);
1485 EXPECT_NE(SUCCESS, ret);
1486
1487 float volume = audioRenderer->GetVolume();
1488 EXPECT_EQ(0.5, volume);
1489
1490 bool isReleased = audioRenderer->Release();
1491 EXPECT_EQ(true, isReleased);
1492 }
1493
1494 /**
1495 * @tc.name : Test SetRenderRate
1496 * @tc.number: Audio_Renderer_SetRenderRate_001
1497 * @tc.desc : Test SetRenderRate interface after set volume fails.
1498 */
1499 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRenderRate_001, TestSize.Level1)
1500 {
1501 int32_t ret = -1;
1502 AudioRendererOptions rendererOptions;
1503
1504 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1505 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1506 ASSERT_NE(nullptr, audioRenderer);
1507
1508 AudioRendererRate renderRate = RENDER_RATE_NORMAL;
1509 ret = audioRenderer->SetRenderRate(renderRate);
1510 EXPECT_EQ(SUCCESS, ret);
1511 audioRenderer->Release();
1512 }
1513
1514 /**
1515 * @tc.name : Test GetRenderRate
1516 * @tc.number: Audio_Renderer_GetRenderRate_001
1517 * @tc.desc : Test GetRenderRate interface after set volume fails.
1518 */
1519 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRenderRate_001, TestSize.Level1)
1520 {
1521 int32_t ret = -1;
1522 AudioRendererOptions rendererOptions;
1523
1524 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1525 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1526 ASSERT_NE(nullptr, audioRenderer);
1527
1528 ret = audioRenderer->SetRenderRate(RENDER_RATE_DOUBLE);
1529 EXPECT_EQ(SUCCESS, ret);
1530
1531 AudioRendererRate renderRate = audioRenderer->GetRenderRate();
1532 EXPECT_EQ(RENDER_RATE_DOUBLE, renderRate);
1533 audioRenderer->Release();
1534 }
1535
1536 /**
1537 * @tc.name : Test Start API via legal state, RENDERER_PREPARED.
1538 * @tc.number: Audio_Renderer_Start_001
1539 * @tc.desc : Test Start interface. Returns true if start is successful.
1540 */
1541 HWTEST(AudioRendererUnitTest, Audio_Renderer_Start_001, TestSize.Level1)
1542 {
1543 AudioRendererOptions rendererOptions;
1544
1545 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1546 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1547 ASSERT_NE(nullptr, audioRenderer);
1548
1549 bool isStarted = audioRenderer->Start();
1550 EXPECT_EQ(true, isStarted);
1551
1552 audioRenderer->Release();
1553 }
1554
1555 /**
1556 * @tc.name : Test Start API via illegal state, RENDERER_NEW: without initializing the renderer.
1557 * @tc.number: Audio_Renderer_Start_002
1558 * @tc.desc : Test Start interface. Returns false, if the renderer state is RENDERER_NEW.
1559 */
1560 HWTEST(AudioRendererUnitTest, Audio_Renderer_Start_002, TestSize.Level1)
1561 {
1562 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
1563 ASSERT_NE(nullptr, audioRenderer);
1564
1565 bool isStarted = audioRenderer->Start();
1566 EXPECT_EQ(false, isStarted);
1567 }
1568
1569 /**
1570 * @tc.name : Test Start API via illegal state, RENDERER_RELEASED: call Start after Release
1571 * @tc.number: Audio_Renderer_Start_003
1572 * @tc.desc : Test Start interface. Returns false, if the renderer state is RENDERER_RELEASED.
1573 */
1574 HWTEST(AudioRendererUnitTest, Audio_Renderer_Start_003, TestSize.Level1)
1575 {
1576 AudioRendererOptions rendererOptions;
1577
1578 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1579 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1580 ASSERT_NE(nullptr, audioRenderer);
1581
1582 bool isReleased = audioRenderer->Release();
1583 EXPECT_EQ(true, isReleased);
1584
1585 bool isStarted = audioRenderer->Start();
1586 EXPECT_EQ(false, isStarted);
1587
1588 audioRenderer->Release();
1589 }
1590
1591 /**
1592 * @tc.name : Test Start API via legal state, RENDERER_STOPPED: Start Stop and then Start again
1593 * @tc.number: Audio_Renderer_Start_004
1594 * @tc.desc : Test Start interface. Returns true, if the start is successful.
1595 */
1596 HWTEST(AudioRendererUnitTest, Audio_Renderer_Start_004, TestSize.Level1)
1597 {
1598 AudioRendererOptions rendererOptions;
1599
1600 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1601 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1602 ASSERT_NE(nullptr, audioRenderer);
1603
1604 bool isStarted = audioRenderer->Start();
1605 EXPECT_EQ(true, isStarted);
1606
1607 bool isStopped = audioRenderer->Stop();
1608 EXPECT_EQ(true, isStopped);
1609
1610 isStarted = audioRenderer->Start();
1611 EXPECT_EQ(true, isStarted);
1612
1613 audioRenderer->Release();
1614 }
1615
1616 /**
1617 * @tc.name : Test Start API via illegal state, RENDERER_RUNNING : call Start repeatedly
1618 * @tc.number: Audio_Renderer_Start_005
1619 * @tc.desc : Test Start interface. Returns false, if the renderer state is RENDERER_RUNNING.
1620 */
1621 HWTEST(AudioRendererUnitTest, Audio_Renderer_Start_005, TestSize.Level1)
1622 {
1623 AudioRendererOptions rendererOptions;
1624
1625 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1626 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1627 ASSERT_NE(nullptr, audioRenderer);
1628
1629 bool isStarted = audioRenderer->Start();
1630 EXPECT_EQ(true, isStarted);
1631
1632 isStarted = audioRenderer->Start();
1633 EXPECT_EQ(false, isStarted);
1634
1635 audioRenderer->Release();
1636 }
1637
1638 /**
1639 * @tc.name : Test Start API via legal state, RENDERER_PAUSED : call Start after pause
1640 * @tc.number: Audio_Renderer_Start_005
1641 * @tc.desc : Test Start interface. Returns false, if the renderer state is RENDERER_PAUSED.
1642 */
1643 HWTEST(AudioRendererUnitTest, Audio_Renderer_Start_006, TestSize.Level1)
1644 {
1645 AudioRendererOptions rendererOptions;
1646
1647 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1648 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1649 ASSERT_NE(nullptr, audioRenderer);
1650
1651 bool isStarted = audioRenderer->Start();
1652 EXPECT_EQ(true, isStarted);
1653
1654 bool isPaused = audioRenderer->Pause();
1655 EXPECT_EQ(true, isPaused);
1656
1657 isStarted = audioRenderer->Start();
1658 EXPECT_EQ(true, isStarted);
1659
1660 audioRenderer->Release();
1661 }
1662
1663 /**
1664 * @tc.name : Test Write API.
1665 * @tc.number: Audio_Renderer_Write_001
1666 * @tc.desc : Test Write interface. Returns number of bytes written, if the write is successful.
1667 */
1668
1669 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_001, TestSize.Level1)
1670 {
1671 int32_t ret = -1;
1672 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1673 ASSERT_NE(nullptr, wavFile);
1674
1675 AudioRendererOptions rendererOptions;
1676 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1677 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1678 ASSERT_NE(nullptr, audioRenderer);
1679
1680 bool isStarted = audioRenderer->Start();
1681 EXPECT_EQ(true, isStarted);
1682
1683 size_t bufferLen;
1684 ret = audioRenderer->GetBufferSize(bufferLen);
1685 EXPECT_EQ(SUCCESS, ret);
1686
1687 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1688 ASSERT_NE(nullptr, buffer);
1689
1690 size_t bytesToWrite = 0;
1691 int32_t bytesWritten = 0;
1692 size_t minBytes = 4;
1693 int32_t numBuffersToRender = WRITE_BUFFERS_COUNT;
1694
1695 while (numBuffersToRender) {
1696 bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1697 bytesWritten = 0;
1698 while ((static_cast<size_t>(bytesWritten) < bytesToWrite) &&
1699 ((static_cast<size_t>(bytesToWrite) - bytesWritten) > minBytes)) {
1700 bytesWritten += audioRenderer->Write(buffer + static_cast<size_t>(bytesWritten),
1701 bytesToWrite - static_cast<size_t>(bytesWritten));
1702 EXPECT_GE(bytesWritten, VALUE_ZERO);
1703 if (bytesWritten < 0) {
1704 break;
1705 }
1706 }
1707 numBuffersToRender--;
1708 }
1709
1710 audioRenderer->Drain();
1711 audioRenderer->Stop();
1712 audioRenderer->Release();
1713
1714 free(buffer);
1715 fclose(wavFile);
1716 }
1717
1718 /**
1719 * @tc.name : Test Write API via illegl state, RENDERER_NEW : without Initializing the renderer.
1720 * @tc.number: Audio_Renderer_Write_002
1721 * @tc.desc : Test Write interface. Returns error code, if the renderer state is RENDERER_NEW.
1722 * : bufferLen is invalid here, firstly bufferLen is validated in Write. So it returns ERR_INVALID_PARAM.
1723 */
1724 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_002, TestSize.Level1)
1725 {
1726 int32_t ret = -1;
1727 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1728 ASSERT_NE(nullptr, wavFile);
1729
1730 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
1731 ASSERT_NE(nullptr, audioRenderer);
1732
1733 bool isStarted = audioRenderer->Start();
1734 EXPECT_EQ(false, isStarted);
1735
1736 size_t bufferLen;
1737 ret = audioRenderer->GetBufferSize(bufferLen);
1738 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
1739
1740 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1741 ASSERT_NE(nullptr, buffer);
1742
1743 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1744 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
1745 EXPECT_EQ(ERR_INVALID_PARAM, bytesWritten);
1746
1747 free(buffer);
1748 fclose(wavFile);
1749 }
1750
1751 /**
1752 * @tc.name : Test Write API via illegl state, RENDERER_PREPARED : Write without Start.
1753 * @tc.number: Audio_Renderer_Write_003
1754 * @tc.desc : Test Write interface. Returns error code, if the renderer state is not RENDERER_RUNNING.
1755 */
1756 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_003, TestSize.Level1)
1757 {
1758 int32_t ret = -1;
1759 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1760 ASSERT_NE(nullptr, wavFile);
1761
1762 AudioRendererOptions rendererOptions;
1763
1764 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1765 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1766 ASSERT_NE(nullptr, audioRenderer);
1767
1768 size_t bufferLen;
1769 ret = audioRenderer->GetBufferSize(bufferLen);
1770 EXPECT_EQ(SUCCESS, ret);
1771
1772 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1773 ASSERT_NE(nullptr, buffer);
1774
1775 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1776 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
1777 EXPECT_EQ(ERR_ILLEGAL_STATE, bytesWritten);
1778
1779 audioRenderer->Release();
1780
1781 free(buffer);
1782 fclose(wavFile);
1783 }
1784
1785 /**
1786 * @tc.name : Test Write API via illegal input, bufferLength = 0.
1787 * @tc.number: Audio_Renderer_Write_004
1788 * @tc.desc : Test Write interface. Returns error code, if the bufferLength <= 0.
1789 */
1790 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_004, TestSize.Level1)
1791 {
1792 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1793 ASSERT_NE(nullptr, wavFile);
1794
1795 AudioRendererOptions rendererOptions;
1796
1797 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1798 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1799 ASSERT_NE(nullptr, audioRenderer);
1800
1801 bool isStarted = audioRenderer->Start();
1802 EXPECT_EQ(true, isStarted);
1803
1804 size_t bufferLen = 0;
1805
1806 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1807 ASSERT_NE(nullptr, buffer);
1808
1809 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1810 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
1811 EXPECT_EQ(ERR_INVALID_PARAM, bytesWritten);
1812
1813 audioRenderer->Stop();
1814 audioRenderer->Release();
1815
1816 free(buffer);
1817 fclose(wavFile);
1818 }
1819
1820 /**
1821 * @tc.name : Test Write API via illegal input, buffer = nullptr.
1822 * @tc.number: Audio_Renderer_Write_005
1823 * @tc.desc : Test Write interface. Returns error code, if the buffer = nullptr.
1824 */
1825 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_005, TestSize.Level1)
1826 {
1827 int32_t ret = -1;
1828 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1829 ASSERT_NE(nullptr, wavFile);
1830
1831 AudioRendererOptions rendererOptions;
1832
1833 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1834 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1835 ASSERT_NE(nullptr, audioRenderer);
1836
1837 bool isStarted = audioRenderer->Start();
1838 EXPECT_EQ(true, isStarted);
1839
1840 size_t bufferLen;
1841 ret = audioRenderer->GetBufferSize(bufferLen);
1842 EXPECT_EQ(SUCCESS, ret);
1843
1844 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1845 ASSERT_NE(nullptr, buffer);
1846
1847 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1848 uint8_t *buffer_null = nullptr;
1849 int32_t bytesWritten = audioRenderer->Write(buffer_null, bytesToWrite);
1850 EXPECT_EQ(ERR_INVALID_PARAM, bytesWritten);
1851
1852 audioRenderer->Stop();
1853 audioRenderer->Release();
1854
1855 free(buffer);
1856 fclose(wavFile);
1857 }
1858
1859 /**
1860 * @tc.name : Test Write API via illegal state, RENDERER_STOPPED: Write after Stop
1861 * @tc.number: Audio_Renderer_Write_006
1862 * @tc.desc : Test Write interface. Returns error code, if the renderer state is not RENDERER_RUNNING
1863 */
1864 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_006, TestSize.Level1)
1865 {
1866 int32_t ret = -1;
1867 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1868 ASSERT_NE(nullptr, wavFile);
1869
1870 AudioRendererOptions rendererOptions;
1871
1872 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1873 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1874 ASSERT_NE(nullptr, audioRenderer);
1875
1876 bool isStarted = audioRenderer->Start();
1877 EXPECT_EQ(true, isStarted);
1878
1879 size_t bufferLen;
1880 ret = audioRenderer->GetBufferSize(bufferLen);
1881 EXPECT_EQ(SUCCESS, ret);
1882
1883 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1884 ASSERT_NE(nullptr, buffer);
1885
1886 bool isStopped = audioRenderer->Stop();
1887 EXPECT_EQ(true, isStopped);
1888
1889 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1890 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
1891 EXPECT_EQ(ERR_ILLEGAL_STATE, bytesWritten);
1892
1893 audioRenderer->Release();
1894
1895 free(buffer);
1896 fclose(wavFile);
1897 }
1898
1899 /**
1900 * @tc.name : Test Write API via illegal state, RENDERER_RELEASED: Write after Release
1901 * @tc.number: Audio_Renderer_Write_007
1902 * @tc.desc : Test Write interface. Returns error code, if the renderer state is not RENDERER_RUNNING
1903 */
1904 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_007, TestSize.Level1)
1905 {
1906 int32_t ret = -1;
1907 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1908 ASSERT_NE(nullptr, wavFile);
1909
1910 AudioRendererOptions rendererOptions;
1911
1912 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1913 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1914 ASSERT_NE(nullptr, audioRenderer);
1915
1916 bool isStarted = audioRenderer->Start();
1917 EXPECT_EQ(true, isStarted);
1918
1919 size_t bufferLen;
1920 ret = audioRenderer->GetBufferSize(bufferLen);
1921 EXPECT_EQ(SUCCESS, ret);
1922
1923 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1924 ASSERT_NE(nullptr, buffer);
1925
1926 bool isReleased = audioRenderer->Release();
1927 EXPECT_EQ(true, isReleased);
1928
1929 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1930 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
1931 EXPECT_EQ(ERR_ILLEGAL_STATE, bytesWritten);
1932
1933 free(buffer);
1934 fclose(wavFile);
1935 }
1936
1937 /**
1938 * @tc.name : Test Write API.
1939 * @tc.number: Audio_Renderer_Write_008
1940 * @tc.desc : Test Write interface after pause and resume. Returns number of bytes written, if the write is successful.
1941 */
1942
1943 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_008, TestSize.Level1)
1944 {
1945 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
1946 ASSERT_NE(nullptr, wavFile);
1947
1948 AudioRendererOptions rendererOptions;
1949
1950 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
1951 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
1952 ASSERT_NE(nullptr, audioRenderer);
1953
1954 bool isStarted = audioRenderer->Start();
1955 EXPECT_EQ(true, isStarted);
1956
1957 size_t bufferLen;
1958 int32_t ret = audioRenderer->GetBufferSize(bufferLen);
1959 EXPECT_EQ(SUCCESS, ret);
1960
1961 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1962 ASSERT_NE(nullptr, buffer);
1963
1964 size_t bytesToWrite = 0;
1965 int32_t bytesWritten = 0;
1966 size_t minBytes = 4;
1967 int32_t numBuffersToRender = WRITE_BUFFERS_COUNT;
1968 bool pauseTested = false;
1969
1970 while (numBuffersToRender) {
1971 bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
1972 bytesWritten = 0;
1973 uint64_t currFilePos = ftell(wavFile);
1974 if (!pauseTested && (currFilePos > PAUSE_BUFFER_POSITION) && audioRenderer->Pause()) {
1975 pauseTested = true;
1976 sleep(PAUSE_RENDER_TIME_SECONDS);
1977 isStarted = audioRenderer->Start();
1978 EXPECT_EQ(true, isStarted);
1979
1980 ret = audioRenderer->SetVolume(0.5);
1981 EXPECT_EQ(SUCCESS, ret);
1982 float volume = audioRenderer->GetVolume();
1983 EXPECT_EQ(0.5, volume);
1984 }
1985
1986 while ((static_cast<size_t>(bytesWritten) < bytesToWrite) &&
1987 ((static_cast<size_t>(bytesToWrite) - bytesWritten) > minBytes)) {
1988 bytesWritten += audioRenderer->Write(buffer + static_cast<size_t>(bytesWritten),
1989 bytesToWrite - static_cast<size_t>(bytesWritten));
1990 EXPECT_GE(bytesWritten, VALUE_ZERO);
1991 if (bytesWritten < 0) {
1992 break;
1993 }
1994 }
1995 numBuffersToRender--;
1996 }
1997
1998 audioRenderer->Drain();
1999 audioRenderer->Stop();
2000 audioRenderer->Release();
2001
2002 free(buffer);
2003 fclose(wavFile);
2004 }
2005
2006 /**
2007 * @tc.name : Test Write API via illegl render mode, RENDER_MODE_CALLBACK.
2008 * @tc.number: Audio_Renderer_Write_009
2009 * @tc.desc : Test Write interface. Returns error code, if the render mode is RENDER_MODE_CALLBACK.
2010 * : In RENDER_MODE_CALLBACK Write API call not supported. By default render mode is RENDER_MODE_NORMAL.
2011 */
2012 HWTEST(AudioRendererUnitTest, Audio_Renderer_Write_009, TestSize.Level1)
2013 {
2014 int32_t ret = -1;
2015 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2016 ASSERT_NE(nullptr, wavFile);
2017
2018 AudioRendererOptions rendererOptions;
2019
2020 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2021 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2022 ASSERT_NE(nullptr, audioRenderer);
2023
2024 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
2025 EXPECT_EQ(SUCCESS, ret);
2026
2027 size_t bufferLen;
2028 ret = audioRenderer->GetBufferSize(bufferLen);
2029 EXPECT_EQ(SUCCESS, ret);
2030
2031 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2032 ASSERT_NE(nullptr, buffer);
2033
2034 bool isStarted = audioRenderer->Start();
2035 EXPECT_EQ(true, isStarted);
2036
2037 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2038 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2039 EXPECT_EQ(ERR_INCORRECT_MODE, bytesWritten);
2040
2041 audioRenderer->Release();
2042
2043 free(buffer);
2044 fclose(wavFile);
2045 }
2046
2047 /**
2048 * @tc.name : Test GetAudioTime API via legal input.
2049 * @tc.number: Audio_Renderer_GetAudioTime_001
2050 * @tc.desc : Test GetAudioTime interface. Returns true, if the getting is successful.
2051 */
2052 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioTime_001, TestSize.Level1)
2053 {
2054 int32_t ret = -1;
2055 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2056 ASSERT_NE(nullptr, wavFile);
2057
2058 AudioRendererOptions rendererOptions;
2059
2060 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2061 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2062 ASSERT_NE(nullptr, audioRenderer);
2063
2064 bool isStarted = audioRenderer->Start();
2065 EXPECT_EQ(true, isStarted);
2066
2067 size_t bufferLen;
2068 ret = audioRenderer->GetBufferSize(bufferLen);
2069 EXPECT_EQ(SUCCESS, ret);
2070
2071 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2072 ASSERT_NE(nullptr, buffer);
2073
2074 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2075 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2076 EXPECT_GE(bytesWritten, VALUE_ZERO);
2077
2078 Timestamp timeStamp;
2079 bool getAudioTime = audioRenderer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
2080 EXPECT_EQ(true, getAudioTime);
2081 EXPECT_GE(timeStamp.time.tv_sec, (const long)VALUE_ZERO);
2082 EXPECT_GE(timeStamp.time.tv_nsec, (const long)VALUE_ZERO);
2083
2084 audioRenderer->Drain();
2085 audioRenderer->Stop();
2086 audioRenderer->Release();
2087
2088 free(buffer);
2089 fclose(wavFile);
2090 }
2091
2092 /**
2093 * @tc.name : Test GetAudioTime API via illegal state, RENDERER_NEW: GetAudioTime without initializing the renderer.
2094 * @tc.number: Audio_Renderer_GetAudioTime_002
2095 * @tc.desc : Test GetAudioTime interface. Returns false, if the renderer state is RENDERER_NEW
2096 */
2097 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioTime_002, TestSize.Level1)
2098 {
2099 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
2100 ASSERT_NE(nullptr, audioRenderer);
2101
2102 Timestamp timeStamp;
2103 bool getAudioTime = audioRenderer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
2104 EXPECT_EQ(false, getAudioTime);
2105 }
2106
2107 /**
2108 * @tc.name : Test GetAudioTime API via legal state, RENDERER_RUNNING.
2109 * @tc.number: Audio_Renderer_GetAudioTime_003
2110 * @tc.desc : test GetAudioTime interface. Returns true, if the getting is successful.
2111 */
2112 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioTime_003, TestSize.Level1)
2113 {
2114 AudioRendererOptions rendererOptions;
2115
2116 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2117 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2118 ASSERT_NE(nullptr, audioRenderer);
2119
2120 bool isStarted = audioRenderer->Start();
2121 EXPECT_EQ(true, isStarted);
2122
2123 Timestamp timeStamp;
2124 bool getAudioTime = audioRenderer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
2125 EXPECT_EQ(true, getAudioTime);
2126
2127 audioRenderer->Release();
2128 }
2129
2130 /**
2131 * @tc.name : Test GetAudioTime API via legal state, RENDERER_STOPPED.
2132 * @tc.number: Audio_Renderer_GetAudioTime_004
2133 * @tc.desc : Test GetAudioTime interface. Returns true, if the getting is successful.
2134 */
2135 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioTime_004, TestSize.Level1)
2136 {
2137 AudioRendererOptions rendererOptions;
2138
2139 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2140 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2141 ASSERT_NE(nullptr, audioRenderer);
2142
2143 bool isStarted = audioRenderer->Start();
2144 EXPECT_EQ(true, isStarted);
2145
2146 bool isStopped = audioRenderer->Stop();
2147 EXPECT_EQ(true, isStopped);
2148
2149 Timestamp timeStamp;
2150 bool getAudioTime = audioRenderer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
2151 EXPECT_EQ(false, getAudioTime);
2152
2153 audioRenderer->Release();
2154 }
2155
2156 /**
2157 * @tc.name : Test GetAudioTime API via illegal state, RENDERER_RELEASED: GetAudioTime after Release.
2158 * @tc.number: Audio_Renderer_GetAudioTime_005
2159 * @tc.desc : Test GetAudioTime interface. Returns false, if the renderer state is RENDERER_RELEASED
2160 */
2161 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioTime_005, TestSize.Level1)
2162 {
2163 AudioRendererOptions rendererOptions;
2164
2165 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2166 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2167 ASSERT_NE(nullptr, audioRenderer);
2168
2169 bool isStarted = audioRenderer->Start();
2170 EXPECT_EQ(true, isStarted);
2171
2172 bool isStopped = audioRenderer->Stop();
2173 EXPECT_EQ(true, isStopped);
2174
2175 bool isReleased = audioRenderer->Release();
2176 EXPECT_EQ(true, isReleased);
2177
2178 Timestamp timeStamp;
2179 bool getAudioTime = audioRenderer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
2180 EXPECT_EQ(false, getAudioTime);
2181 }
2182
2183 /**
2184 * @tc.name : Test GetAudioTime API via legal state, RENDERER_PAUSED.
2185 * @tc.number: Audio_Renderer_GetAudioTime_006
2186 * @tc.desc : Test GetAudioTime interface. Returns true, if the getting is successful.
2187 */
2188 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioTime_006, TestSize.Level1)
2189 {
2190 AudioRendererOptions rendererOptions;
2191
2192 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2193 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2194 ASSERT_NE(nullptr, audioRenderer);
2195
2196 bool isStarted = audioRenderer->Start();
2197 EXPECT_EQ(true, isStarted);
2198
2199 bool isPaused = audioRenderer->Pause();
2200 EXPECT_EQ(true, isPaused);
2201
2202 Timestamp timeStamp;
2203 bool getAudioTime = audioRenderer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
2204 EXPECT_EQ(true, getAudioTime);
2205
2206 audioRenderer->Release();
2207 }
2208
2209 /**
2210 * @tc.name : Test Drain API.
2211 * @tc.number: Audio_Renderer_Drain_001
2212 * @tc.desc : Test Drain interface. Returns true, if the flush is successful.
2213 */
2214 HWTEST(AudioRendererUnitTest, Audio_Renderer_Drain_001, TestSize.Level1)
2215 {
2216 int32_t ret = -1;
2217 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2218 ASSERT_NE(nullptr, wavFile);
2219
2220 AudioRendererOptions rendererOptions;
2221
2222 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2223 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2224 ASSERT_NE(nullptr, audioRenderer);
2225
2226 bool isStarted = audioRenderer->Start();
2227 EXPECT_EQ(true, isStarted);
2228
2229 size_t bufferLen;
2230 ret = audioRenderer->GetBufferSize(bufferLen);
2231 EXPECT_EQ(SUCCESS, ret);
2232
2233 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2234 ASSERT_NE(nullptr, buffer);
2235
2236 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2237 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2238 EXPECT_GE(bytesWritten, VALUE_ZERO);
2239
2240 bool isDrained = audioRenderer->Drain();
2241 EXPECT_EQ(true, isDrained);
2242
2243 audioRenderer->Stop();
2244 audioRenderer->Release();
2245
2246 free(buffer);
2247 fclose(wavFile);
2248 }
2249
2250 /**
2251 * @tc.name : Test Drain API via illegal state, RENDERER_NEW: Without initializing the renderer.
2252 * @tc.number: Audio_Renderer_Drain_002
2253 * @tc.desc : Test Drain interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2254 */
2255 HWTEST(AudioRendererUnitTest, Audio_Renderer_Drain_002, TestSize.Level1)
2256 {
2257 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
2258 ASSERT_NE(nullptr, audioRenderer);
2259
2260 bool isDrained = audioRenderer->Drain();
2261 EXPECT_EQ(false, isDrained);
2262
2263 audioRenderer->Release();
2264 }
2265
2266 /**
2267 * @tc.name : Test Drain API via illegal state, RENDERER_PREPARED: Without Start.
2268 * @tc.number: Audio_Renderer_Drain_003
2269 * @tc.desc : Test Drain interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2270 */
2271 HWTEST(AudioRendererUnitTest, Audio_Renderer_Drain_003, TestSize.Level1)
2272 {
2273 AudioRendererOptions rendererOptions;
2274
2275 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2276 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2277 ASSERT_NE(nullptr, audioRenderer);
2278
2279 bool isDrained = audioRenderer->Drain();
2280 EXPECT_EQ(false, isDrained);
2281
2282 audioRenderer->Release();
2283 }
2284
2285 /**
2286 * @tc.name : Test Drain API via illegal state, RENDERER_STOPPED: call Stop before Drain.
2287 * @tc.number: Audio_Renderer_Drain_004
2288 * @tc.desc : Test Drain interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2289 */
2290 HWTEST(AudioRendererUnitTest, Audio_Renderer_Drain_004, TestSize.Level1)
2291 {
2292 AudioRendererOptions rendererOptions;
2293
2294 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2295 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2296 ASSERT_NE(nullptr, audioRenderer);
2297
2298 bool isStarted = audioRenderer->Start();
2299 EXPECT_EQ(true, isStarted);
2300
2301 bool isStopped = audioRenderer->Stop();
2302 EXPECT_EQ(true, isStopped);
2303
2304 bool isDrained = audioRenderer->Drain();
2305 EXPECT_EQ(false, isDrained);
2306
2307 audioRenderer->Release();
2308 }
2309
2310 /**
2311 * @tc.name : Test Drain API via illegal state, RENDERER_RELEASED: call Release before Drain.
2312 * @tc.number: Audio_Renderer_Drain_005
2313 * @tc.desc : Test Drain interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2314 */
2315 HWTEST(AudioRendererUnitTest, Audio_Renderer_Drain_005, TestSize.Level1)
2316 {
2317 AudioRendererOptions rendererOptions;
2318
2319 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2320 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2321 ASSERT_NE(nullptr, audioRenderer);
2322
2323 bool isStarted = audioRenderer->Start();
2324 EXPECT_EQ(true, isStarted);
2325
2326 bool isReleased = audioRenderer->Release();
2327 EXPECT_EQ(true, isReleased);
2328
2329 bool isDrained = audioRenderer->Drain();
2330 EXPECT_EQ(false, isDrained);
2331
2332 audioRenderer->Release();
2333 }
2334
2335 /**
2336 * @tc.name : Test Drain API via illegal state, RENDERER_PAUSED: call Pause before Drain.
2337 * @tc.number: Audio_Renderer_Drain_006
2338 * @tc.desc : Test Drain interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2339 */
2340 HWTEST(AudioRendererUnitTest, Audio_Renderer_Drain_006, TestSize.Level1)
2341 {
2342 AudioRendererOptions rendererOptions;
2343
2344 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2345 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2346 ASSERT_NE(nullptr, audioRenderer);
2347
2348 bool isStarted = audioRenderer->Start();
2349 EXPECT_EQ(true, isStarted);
2350
2351 bool isPaused = audioRenderer->Pause();
2352 EXPECT_EQ(true, isPaused);
2353
2354 bool isDrained = audioRenderer->Drain();
2355 EXPECT_EQ(false, isDrained);
2356
2357 audioRenderer->Release();
2358 }
2359
2360 /**
2361 * @tc.name : Test Drain API stability.
2362 * @tc.number: Audio_Renderer_Drain_Stability_001
2363 * @tc.desc : Test Drain interface stability.
2364 */
2365 HWTEST(AudioRendererUnitTest, Audio_Renderer_Drain_Stability_001, TestSize.Level1)
2366 {
2367 AudioRendererOptions rendererOptions;
2368
2369 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2370 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2371 ASSERT_NE(nullptr, audioRenderer);
2372
2373 bool isStarted = audioRenderer->Start();
2374 EXPECT_EQ(true, isStarted);
2375
2376 thread renderThread(StartRenderThread, audioRenderer.get(), 0);
2377
2378 for (int i = 0; i < VALUE_THOUSAND; i++) {
2379 bool isDrained = audioRenderer->Drain();
2380 EXPECT_EQ(true, isDrained);
2381 }
2382
2383 renderThread.join();
2384
2385 bool isStopped = audioRenderer->Stop();
2386 EXPECT_EQ(true, isStopped);
2387
2388 bool isReleased = audioRenderer->Release();
2389 EXPECT_EQ(true, isReleased);
2390 }
2391
2392 /**
2393 * @tc.name : Test Flush API.
2394 * @tc.number: Audio_Renderer_Flush_001
2395 * @tc.desc : Test Flush interface. Returns true, if the flush is successful.
2396 */
2397 HWTEST(AudioRendererUnitTest, Audio_Renderer_Flush_001, TestSize.Level1)
2398 {
2399 int32_t ret = -1;
2400 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2401 ASSERT_NE(nullptr, wavFile);
2402
2403 AudioRendererOptions rendererOptions;
2404
2405 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2406 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2407 ASSERT_NE(nullptr, audioRenderer);
2408
2409 bool isStarted = audioRenderer->Start();
2410 EXPECT_EQ(true, isStarted);
2411
2412 size_t bufferLen;
2413 ret = audioRenderer->GetBufferSize(bufferLen);
2414 EXPECT_EQ(SUCCESS, ret);
2415
2416 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2417 ASSERT_NE(nullptr, buffer);
2418
2419 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2420 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2421 EXPECT_GE(bytesWritten, VALUE_ZERO);
2422
2423 bool isFlushed = audioRenderer->Flush();
2424 EXPECT_EQ(true, isFlushed);
2425
2426 audioRenderer->Release();
2427
2428 free(buffer);
2429 fclose(wavFile);
2430 }
2431
2432 /**
2433 * @tc.name : Test Flush API.
2434 * @tc.number: Audio_Renderer_Flush_002
2435 * @tc.desc : Test Flush interface after Pause call. Returns true, if the flush is successful.
2436 */
2437 HWTEST(AudioRendererUnitTest, Audio_Renderer_Flush_002, TestSize.Level1)
2438 {
2439 int32_t ret = -1;
2440 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2441 ASSERT_NE(nullptr, wavFile);
2442
2443 AudioRendererOptions rendererOptions;
2444
2445 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2446 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2447 ASSERT_NE(nullptr, audioRenderer);
2448
2449 bool isStarted = audioRenderer->Start();
2450 EXPECT_EQ(true, isStarted);
2451
2452 size_t bufferLen;
2453 ret = audioRenderer->GetBufferSize(bufferLen);
2454 EXPECT_EQ(SUCCESS, ret);
2455
2456 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2457 ASSERT_NE(nullptr, buffer);
2458
2459 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2460 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2461 EXPECT_GE(bytesWritten, VALUE_ZERO);
2462
2463 audioRenderer->Pause();
2464
2465 bool isFlushed = audioRenderer->Flush();
2466 EXPECT_EQ(true, isFlushed);
2467
2468 audioRenderer->Release();
2469
2470 free(buffer);
2471 fclose(wavFile);
2472 }
2473
2474 /**
2475 * @tc.name : Test Flush API via illegal state, RENDERER_NEW: Without initializing the renderer.
2476 * @tc.number: Audio_Renderer_Flush_003
2477 * @tc.desc : Test Flush interface. Returns false, if the renderer state is not RENDERER_RUNNING or RENDERER_PAUSED.
2478 */
2479 HWTEST(AudioRendererUnitTest, Audio_Renderer_Flush_003, TestSize.Level1)
2480 {
2481 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
2482 ASSERT_NE(nullptr, audioRenderer);
2483
2484 bool isFlushed = audioRenderer->Flush();
2485 EXPECT_EQ(false, isFlushed);
2486 }
2487
2488 /**
2489 * @tc.name : Test Flush API via illegal state, RENDERER_PREPARED: Without Start.
2490 * @tc.number: Audio_Renderer_Flush_004
2491 * @tc.desc : Test Flush interface. Returns false, if the renderer state is not RENDERER_RUNNING or RENDERER_PAUSED.
2492 */
2493 HWTEST(AudioRendererUnitTest, Audio_Renderer_Flush_004, TestSize.Level1)
2494 {
2495 AudioRendererOptions rendererOptions;
2496
2497 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2498 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2499 ASSERT_NE(nullptr, audioRenderer);
2500
2501 bool isFlushed = audioRenderer->Flush();
2502 EXPECT_EQ(false, isFlushed);
2503
2504 audioRenderer->Release();
2505 }
2506
2507 /**
2508 * @tc.name : Test Flush API: call Stop before Flush.
2509 * @tc.number: Audio_Renderer_Flush_005
2510 * @tc.desc : Test Flush interface. Returns true, if the renderer state is RENDERER_STOPPED.
2511 */
2512 HWTEST(AudioRendererUnitTest, Audio_Renderer_Flush_005, TestSize.Level1)
2513 {
2514 AudioRendererOptions rendererOptions;
2515
2516 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2517 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2518 ASSERT_NE(nullptr, audioRenderer);
2519
2520 bool isStarted = audioRenderer->Start();
2521 EXPECT_EQ(true, isStarted);
2522
2523 bool isStopped = audioRenderer->Stop();
2524 EXPECT_EQ(true, isStopped);
2525
2526 bool isFlushed = audioRenderer->Flush();
2527 EXPECT_EQ(true, isFlushed);
2528
2529 audioRenderer->Release();
2530 }
2531
2532 /**
2533 * @tc.name : Test Flush API via illegal state, RENDERER_RELEASED: call Release before Flush.
2534 * @tc.number: Audio_Renderer_Flush_006
2535 * @tc.desc : Test Flush interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2536 */
2537 HWTEST(AudioRendererUnitTest, Audio_Renderer_Flush_006, TestSize.Level1)
2538 {
2539 AudioRendererOptions rendererOptions;
2540
2541 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2542 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2543 ASSERT_NE(nullptr, audioRenderer);
2544
2545 bool isStarted = audioRenderer->Start();
2546 EXPECT_EQ(true, isStarted);
2547
2548 bool isReleased = audioRenderer->Release();
2549 EXPECT_EQ(true, isReleased);
2550
2551 bool isFlushed = audioRenderer->Flush();
2552 EXPECT_EQ(false, isFlushed);
2553 }
2554
2555 /**
2556 * @tc.name : Test Flush API stability.
2557 * @tc.number: Audio_Renderer_Flush_Stability_001
2558 * @tc.desc : Test Flush interface stability.
2559 */
2560 HWTEST(AudioRendererUnitTest, Audio_Renderer_Flush_Stability_001, TestSize.Level1)
2561 {
2562 AudioRendererOptions rendererOptions;
2563
2564 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2565 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2566 ASSERT_NE(nullptr, audioRenderer);
2567
2568 bool isStarted = audioRenderer->Start();
2569 EXPECT_EQ(true, isStarted);
2570
2571 thread renderThread(StartRenderThread, audioRenderer.get(), 0);
2572
2573 for (int i = 0; i < VALUE_THOUSAND; i++) {
2574 bool isFlushed = audioRenderer->Flush();
2575 EXPECT_EQ(true, isFlushed);
2576 }
2577
2578 renderThread.join();
2579
2580 bool isStopped = audioRenderer->Stop();
2581 EXPECT_EQ(true, isStopped);
2582
2583 bool isReleased = audioRenderer->Release();
2584 EXPECT_EQ(true, isReleased);
2585 }
2586
2587 /**
2588 * @tc.name : Test Pause API.
2589 * @tc.number: Audio_Renderer_Pause_001
2590 * @tc.desc : Test Pause interface. Returns true, if the pause is successful.
2591 */
2592 HWTEST(AudioRendererUnitTest, Audio_Renderer_Pause_001, TestSize.Level1)
2593 {
2594 int32_t ret = -1;
2595 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2596 ASSERT_NE(nullptr, wavFile);
2597
2598 AudioRendererOptions rendererOptions;
2599
2600 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2601 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2602 ASSERT_NE(nullptr, audioRenderer);
2603
2604 bool isStarted = audioRenderer->Start();
2605 EXPECT_EQ(true, isStarted);
2606
2607 size_t bufferLen;
2608 ret = audioRenderer->GetBufferSize(bufferLen);
2609 EXPECT_EQ(SUCCESS, ret);
2610
2611 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2612 ASSERT_NE(nullptr, buffer);
2613
2614 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2615 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2616 EXPECT_GE(bytesWritten, VALUE_ZERO);
2617
2618 audioRenderer->Drain();
2619
2620 bool isPaused = audioRenderer->Pause();
2621 EXPECT_EQ(true, isPaused);
2622
2623 audioRenderer->Release();
2624
2625 free(buffer);
2626 fclose(wavFile);
2627 }
2628
2629 /**
2630 * @tc.name : Test Pause API via illegal state, RENDERER_NEW: call Pause without Initializing the renderer.
2631 * @tc.number: Audio_Renderer_Pause_002
2632 * @tc.desc : Test Pause interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2633 */
2634 HWTEST(AudioRendererUnitTest, Audio_Renderer_Pause_002, TestSize.Level1)
2635 {
2636 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
2637 ASSERT_NE(nullptr, audioRenderer);
2638
2639 bool isPaused = audioRenderer->Pause();
2640 EXPECT_EQ(false, isPaused);
2641 }
2642
2643 /**
2644 * @tc.name : Test Pause API via illegal state, RENDERER_PREPARED: call Pause without Start.
2645 * @tc.number: Audio_Renderer_Pause_003
2646 * @tc.desc : Test Pause interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2647 */
2648 HWTEST(AudioRendererUnitTest, Audio_Renderer_Pause_003, TestSize.Level1)
2649 {
2650 AudioRendererOptions rendererOptions;
2651
2652 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2653 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2654 ASSERT_NE(nullptr, audioRenderer);
2655
2656 bool isPaused = audioRenderer->Pause();
2657 EXPECT_EQ(false, isPaused);
2658
2659 audioRenderer->Release();
2660 }
2661
2662 /**
2663 * @tc.name : Test Pause API via illegal state, RENDERER_RELEASED: call Pause after Release.
2664 * @tc.number: Audio_Renderer_Pause_004
2665 * @tc.desc : Test Pause interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2666 */
2667 HWTEST(AudioRendererUnitTest, Audio_Renderer_Pause_004, TestSize.Level1)
2668 {
2669 AudioRendererOptions rendererOptions;
2670
2671 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2672 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2673 ASSERT_NE(nullptr, audioRenderer);
2674
2675 bool isStarted = audioRenderer->Start();
2676 EXPECT_EQ(true, isStarted);
2677
2678 bool isReleased = audioRenderer->Release();
2679 EXPECT_EQ(true, isReleased);
2680
2681 bool isPaused = audioRenderer->Pause();
2682 EXPECT_EQ(false, isPaused);
2683 }
2684
2685 /**
2686 * @tc.name : Test Pause and resume
2687 * @tc.number: Audio_Renderer_Pause_005
2688 * @tc.desc : Test Pause interface. Returns true , if the pause is successful.
2689 */
2690 HWTEST(AudioRendererUnitTest, Audio_Renderer_Pause_005, TestSize.Level1)
2691 {
2692 AudioRendererOptions rendererOptions;
2693
2694 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2695 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2696 ASSERT_NE(nullptr, audioRenderer);
2697
2698 bool isStarted = audioRenderer->Start();
2699 EXPECT_EQ(true, isStarted);
2700
2701 bool isPaused = audioRenderer->Pause();
2702 EXPECT_EQ(true, isPaused);
2703
2704 isStarted = audioRenderer->Start();
2705 EXPECT_EQ(true, isStarted);
2706
2707 audioRenderer->Stop();
2708 audioRenderer->Release();
2709 }
2710
2711 /**
2712 * @tc.name : Test Pause API via illegal state, RENDERER_STOPPED: call Pause after Stop.
2713 * @tc.number: Audio_Renderer_Pause_006
2714 * @tc.desc : Test Pause interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2715 */
2716 HWTEST(AudioRendererUnitTest, Audio_Renderer_Pause_006, TestSize.Level1)
2717 {
2718 AudioRendererOptions rendererOptions;
2719
2720 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2721 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2722 ASSERT_NE(nullptr, audioRenderer);
2723
2724 bool isStarted = audioRenderer->Start();
2725 EXPECT_EQ(true, isStarted);
2726
2727 bool isStopped = audioRenderer->Stop();
2728 EXPECT_EQ(true, isStopped);
2729
2730 bool isPaused = audioRenderer->Pause();
2731 EXPECT_EQ(false, isPaused);
2732 audioRenderer->Release();
2733 }
2734
2735 /**
2736 * @tc.name : Test Pause and resume
2737 * @tc.number: Audio_Renderer_Pause_Stability_001
2738 * @tc.desc : Test Pause interface for stability.
2739 */
2740 HWTEST(AudioRendererUnitTest, Audio_Renderer_Pause_Stability_001, TestSize.Level1)
2741 {
2742 int32_t ret = -1;
2743 AudioRendererOptions rendererOptions;
2744
2745 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2746 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2747 ASSERT_NE(nullptr, audioRenderer);
2748
2749 bool isStarted = audioRenderer->Start();
2750 EXPECT_EQ(true, isStarted);
2751
2752 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2753 ASSERT_NE(nullptr, wavFile);
2754
2755 size_t bufferLen;
2756 ret = audioRenderer->GetBufferSize(bufferLen);
2757 EXPECT_EQ(SUCCESS, ret);
2758
2759 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2760 ASSERT_NE(nullptr, buffer);
2761
2762 size_t bytesToWrite = 0;
2763 int32_t bytesWritten = 0;
2764 size_t minBytes = 4;
2765 int32_t numBuffersToRender = WRITE_BUFFERS_COUNT;
2766
2767 while (numBuffersToRender) {
2768 bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2769 bytesWritten = 0;
2770 while ((static_cast<size_t>(bytesWritten) < bytesToWrite) &&
2771 ((static_cast<size_t>(bytesToWrite) - bytesWritten) > minBytes)) {
2772 bytesWritten += audioRenderer->Write(buffer + static_cast<size_t>(bytesWritten),
2773 bytesToWrite - static_cast<size_t>(bytesWritten));
2774 EXPECT_GE(bytesWritten, VALUE_ZERO);
2775 if (bytesWritten < 0) {
2776 break;
2777 }
2778 }
2779 EXPECT_EQ(true, audioRenderer->Pause());
2780 EXPECT_EQ(true, audioRenderer->Start());
2781 numBuffersToRender--;
2782 }
2783
2784 audioRenderer->Drain();
2785
2786 free(buffer);
2787 fclose(wavFile);
2788
2789 bool isStopped = audioRenderer->Stop();
2790 EXPECT_EQ(true, isStopped);
2791
2792 bool isReleased = audioRenderer->Release();
2793 EXPECT_EQ(true, isReleased);
2794 }
2795
2796 /**
2797 * @tc.name : Test Stop API.
2798 * @tc.number: Audio_Renderer_Stop_001
2799 * @tc.desc : Test Stop interface. Returns true, if the stop is successful.
2800 */
2801 HWTEST(AudioRendererUnitTest, Audio_Renderer_Stop_001, TestSize.Level1)
2802 {
2803 int32_t ret = -1;
2804 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2805 ASSERT_NE(nullptr, wavFile);
2806
2807 AudioRendererOptions rendererOptions;
2808
2809 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2810 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2811 ASSERT_NE(nullptr, audioRenderer);
2812
2813 bool isStarted = audioRenderer->Start();
2814 EXPECT_EQ(true, isStarted);
2815
2816 size_t bufferLen;
2817 ret = audioRenderer->GetBufferSize(bufferLen);
2818 EXPECT_EQ(SUCCESS, ret);
2819
2820 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2821 ASSERT_NE(nullptr, buffer);
2822
2823 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2824 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2825 EXPECT_GE(bytesWritten, VALUE_ZERO);
2826
2827 audioRenderer->Drain();
2828
2829 bool isStopped = audioRenderer->Stop();
2830 EXPECT_EQ(true, isStopped);
2831
2832 audioRenderer->Release();
2833
2834 free(buffer);
2835 fclose(wavFile);
2836 }
2837
2838 /**
2839 * @tc.name : Test Stop API via illegal state, RENDERER_NEW: call Stop without Initializing the renderer.
2840 * @tc.number: Audio_Renderer_Stop_002
2841 * @tc.desc : Test Stop interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2842 */
2843 HWTEST(AudioRendererUnitTest, Audio_Renderer_Stop_002, TestSize.Level1)
2844 {
2845 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
2846 ASSERT_NE(nullptr, audioRenderer);
2847
2848 bool isStopped = audioRenderer->Stop();
2849 EXPECT_EQ(false, isStopped);
2850 }
2851
2852 /**
2853 * @tc.name : Test Stop API via illegal state, RENDERER_PREPARED: call Stop without Start.
2854 * @tc.number: Audio_Renderer_Stop_003
2855 * @tc.desc : Test Stop interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2856 */
2857 HWTEST(AudioRendererUnitTest, Audio_Renderer_Stop_003, TestSize.Level1)
2858 {
2859 AudioRendererOptions rendererOptions;
2860
2861 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2862 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2863 ASSERT_NE(nullptr, audioRenderer);
2864
2865 bool isStopped = audioRenderer->Stop();
2866 EXPECT_EQ(false, isStopped);
2867
2868 audioRenderer->Release();
2869 }
2870
2871 /**
2872 * @tc.name : Test Stop API via illegal state, RENDERER_RELEASED: call Stop after Release.
2873 * @tc.number: Audio_Renderer_Stop_004
2874 * @tc.desc : Test Stop interface. Returns false, if the renderer state is not RENDERER_RUNNING.
2875 */
2876 HWTEST(AudioRendererUnitTest, Audio_Renderer_Stop_004, TestSize.Level1)
2877 {
2878 AudioRendererOptions rendererOptions;
2879
2880 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2881 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2882 ASSERT_NE(nullptr, audioRenderer);
2883
2884 bool isStarted = audioRenderer->Start();
2885 EXPECT_EQ(true, isStarted);
2886
2887 bool isReleased = audioRenderer->Release();
2888 EXPECT_EQ(true, isReleased);
2889
2890 bool isStopped = audioRenderer->Stop();
2891 EXPECT_EQ(false, isStopped);
2892 }
2893
2894 /**
2895 * @tc.name : Test Stop API via legal state. call Start, Stop, Start and Stop again
2896 * @tc.number: Audio_Renderer_Stop_005
2897 * @tc.desc : Test Stop interface. Returns true , if the stop is successful.
2898 */
2899 HWTEST(AudioRendererUnitTest, Audio_Renderer_Stop_005, TestSize.Level1)
2900 {
2901 AudioRendererOptions rendererOptions;
2902
2903 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2904 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2905 ASSERT_NE(nullptr, audioRenderer);
2906
2907 bool isStarted = audioRenderer->Start();
2908 EXPECT_EQ(true, isStarted);
2909
2910 bool isStopped = audioRenderer->Stop();
2911 EXPECT_EQ(true, isStopped);
2912
2913 isStarted = audioRenderer->Start();
2914 EXPECT_EQ(true, isStarted);
2915
2916 isStopped = audioRenderer->Stop();
2917 EXPECT_EQ(true, isStopped);
2918 audioRenderer->Release();
2919 }
2920
2921 /**
2922 * @tc.name : Test Stop API via legal state, RENDERER_PAUSED: call Stop after Pause.
2923 * @tc.number: Audio_Renderer_Stop_006
2924 * @tc.desc : Test Stop interface. Returns false, if the renderer state is not RENDERER_RUNNING or RENDERER_PAUSED.
2925 */
2926 HWTEST(AudioRendererUnitTest, Audio_Renderer_Stop_006, TestSize.Level1)
2927 {
2928 AudioRendererOptions rendererOptions;
2929
2930 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2931 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2932 ASSERT_NE(nullptr, audioRenderer);
2933
2934 bool isStarted = audioRenderer->Start();
2935 EXPECT_EQ(true, isStarted);
2936
2937 bool isPaused = audioRenderer->Pause();
2938 EXPECT_EQ(true, isPaused);
2939
2940 bool isStopped = audioRenderer->Stop();
2941 EXPECT_EQ(true, isStopped);
2942 audioRenderer->Release();
2943 }
2944
2945 /**
2946 * @tc.name : Test Release API.
2947 * @tc.number: Audio_Renderer_Release_001
2948 * @tc.desc : Test Release interface. Returns true, if the release is successful.
2949 */
2950 HWTEST(AudioRendererUnitTest, Audio_Renderer_Release_001, TestSize.Level1)
2951 {
2952 int32_t ret = -1;
2953 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
2954 ASSERT_NE(nullptr, wavFile);
2955
2956 AudioRendererOptions rendererOptions;
2957
2958 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
2959 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
2960 ASSERT_NE(nullptr, audioRenderer);
2961
2962 bool isStarted = audioRenderer->Start();
2963 EXPECT_EQ(true, isStarted);
2964
2965 size_t bufferLen;
2966 ret = audioRenderer->GetBufferSize(bufferLen);
2967 EXPECT_EQ(SUCCESS, ret);
2968
2969 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
2970 ASSERT_NE(nullptr, buffer);
2971
2972 size_t bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
2973 int32_t bytesWritten = audioRenderer->Write(buffer, bytesToWrite);
2974 EXPECT_GE(bytesWritten, VALUE_ZERO);
2975
2976 audioRenderer->Drain();
2977 audioRenderer->Stop();
2978
2979 bool isReleased = audioRenderer->Release();
2980 EXPECT_EQ(true, isReleased);
2981
2982 free(buffer);
2983 fclose(wavFile);
2984 }
2985
2986 /**
2987 * @tc.name : Test Release API via illegal state, RENDERER_NEW: Call Release without initializing the renderer.
2988 * @tc.number: Audio_Renderer_Release_002
2989 * @tc.desc : Test Release interface, Returns false, if the state is RENDERER_NEW.
2990 */
2991 HWTEST(AudioRendererUnitTest, Audio_Renderer_Release_002, TestSize.Level1)
2992 {
2993 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
2994 ASSERT_NE(nullptr, audioRenderer);
2995
2996 bool isReleased = audioRenderer->Release();
2997 EXPECT_EQ(false, isReleased);
2998 }
2999
3000 /**
3001 * @tc.name : Test Release API via illegal state, RENDERER_RELEASED: call Release repeatedly.
3002 * @tc.number: Audio_Renderer_Release_003
3003 * @tc.desc : Test Release interface. Returns false, if the state is already RENDERER_RELEASED.
3004 */
3005 HWTEST(AudioRendererUnitTest, Audio_Renderer_Release_003, TestSize.Level1)
3006 {
3007 AudioRendererOptions rendererOptions;
3008
3009 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3010 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3011 ASSERT_NE(nullptr, audioRenderer);
3012
3013 bool isReleased = audioRenderer->Release();
3014 EXPECT_EQ(true, isReleased);
3015
3016 isReleased = audioRenderer->Release();
3017 EXPECT_EQ(false, isReleased);
3018 }
3019
3020 /**
3021 * @tc.name : Test Release API via legal state, RENDERER_RUNNING: call Release after Start
3022 * @tc.number: Audio_Renderer_Release_004
3023 * @tc.desc : Test Release interface. Returns true, if the release is successful.
3024 */
3025 HWTEST(AudioRendererUnitTest, Audio_Renderer_Release_004, TestSize.Level1)
3026 {
3027 AudioRendererOptions rendererOptions;
3028
3029 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3030 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3031 ASSERT_NE(nullptr, audioRenderer);
3032
3033 bool isStarted = audioRenderer->Start();
3034 EXPECT_EQ(true, isStarted);
3035
3036 bool isReleased = audioRenderer->Release();
3037 EXPECT_EQ(true, isReleased);
3038 }
3039
3040 /**
3041 * @tc.name : Test Release API via legal state, RENDERER_STOPPED: call release after Start and Stop
3042 * @tc.number: Audio_Renderer_Release_005
3043 * @tc.desc : Test Release interface. Returns true, if the release is successful.
3044 */
3045 HWTEST(AudioRendererUnitTest, Audio_Renderer_Release_005, TestSize.Level1)
3046 {
3047 AudioRendererOptions rendererOptions;
3048
3049 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3050 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3051 ASSERT_NE(nullptr, audioRenderer);
3052
3053 bool isStarted = audioRenderer->Start();
3054 EXPECT_EQ(true, isStarted);
3055
3056 bool isStopped = audioRenderer->Stop();
3057 EXPECT_EQ(true, isStopped);
3058
3059 bool isReleased = audioRenderer->Release();
3060 EXPECT_EQ(true, isReleased);
3061 }
3062
3063 /**
3064 * @tc.name : Test Release API via legal state, RENDERER_PAUSED: call release after Start and Pause
3065 * @tc.number: Audio_Renderer_Release_006
3066 * @tc.desc : Test Release interface. Returns true, if the release is successful.
3067 */
3068 HWTEST(AudioRendererUnitTest, Audio_Renderer_Release_006, TestSize.Level1)
3069 {
3070 AudioRendererOptions rendererOptions;
3071
3072 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3073 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3074 ASSERT_NE(nullptr, audioRenderer);
3075
3076 bool isStarted = audioRenderer->Start();
3077 EXPECT_EQ(true, isStarted);
3078
3079 bool isPaused = audioRenderer->Pause();
3080 EXPECT_EQ(true, isPaused);
3081
3082 bool isReleased = audioRenderer->Release();
3083 EXPECT_EQ(true, isReleased);
3084 }
3085
3086 /**
3087 * @tc.name : Test GetStatus API.
3088 * @tc.number: Audio_Renderer_GetStatus_001
3089 * @tc.desc : Test GetStatus interface. Returns correct state on success.
3090 */
3091 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStatus_001, TestSize.Level1)
3092 {
3093 RendererState state = RENDERER_INVALID;
3094
3095 AudioRendererOptions rendererOptions;
3096
3097 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3098 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3099 ASSERT_NE(nullptr, audioRenderer);
3100
3101 state = audioRenderer->GetStatus();
3102 EXPECT_EQ(RENDERER_PREPARED, state);
3103
3104 bool isStarted = audioRenderer->Start();
3105 EXPECT_EQ(true, isStarted);
3106 state = audioRenderer->GetStatus();
3107 EXPECT_EQ(RENDERER_RUNNING, state);
3108
3109 bool isStopped = audioRenderer->Stop();
3110 EXPECT_EQ(true, isStopped);
3111 state = audioRenderer->GetStatus();
3112 EXPECT_EQ(RENDERER_STOPPED, state);
3113
3114 bool isReleased = audioRenderer->Release();
3115 EXPECT_EQ(true, isReleased);
3116 state = audioRenderer->GetStatus();
3117 EXPECT_EQ(RENDERER_RELEASED, state);
3118 }
3119
3120 /**
3121 * @tc.name : Test GetStatus API, call Start without Initializing the renderer
3122 * @tc.number: Audio_Renderer_GetStatus_002
3123 * @tc.desc : Test GetStatus interface. Not changes to RENDERER_RUNNING, if the current state is RENDERER_NEW.
3124 */
3125 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStatus_002, TestSize.Level1)
3126 {
3127 RendererState state = RENDERER_INVALID;
3128
3129 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
3130 ASSERT_NE(nullptr, audioRenderer);
3131
3132 bool isStarted = audioRenderer->Start();
3133 EXPECT_EQ(false, isStarted);
3134 state = audioRenderer->GetStatus();
3135 EXPECT_NE(RENDERER_RUNNING, state);
3136 EXPECT_EQ(RENDERER_NEW, state);
3137 }
3138
3139 /**
3140 * @tc.name : Test GetStatus API, call Stop without Start
3141 * @tc.number: Audio_Renderer_GetStatus_003
3142 * @tc.desc : Test GetStatus interface. Not changes to RENDERER_STOPPED, if the current state is RENDERER_PREPARED.
3143 */
3144 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStatus_003, TestSize.Level1)
3145 {
3146 RendererState state = RENDERER_INVALID;
3147 AudioRendererOptions rendererOptions;
3148
3149 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3150 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3151 ASSERT_NE(nullptr, audioRenderer);
3152
3153 bool isStopped = audioRenderer->Stop();
3154 EXPECT_EQ(false, isStopped);
3155 state = audioRenderer->GetStatus();
3156 EXPECT_NE(RENDERER_STOPPED, state);
3157 EXPECT_EQ(RENDERER_PREPARED, state);
3158
3159 audioRenderer->Release();
3160 }
3161
3162 /**
3163 * @tc.name : Test GetStatus API, call Start, Stop and then Start again
3164 * @tc.number: Audio_Renderer_GetStatus_004
3165 * @tc.desc : Test GetStatus interface. Returns correct state on success.
3166 */
3167 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStatus_004, TestSize.Level1)
3168 {
3169 RendererState state = RENDERER_INVALID;
3170
3171 AudioRendererOptions rendererOptions;
3172
3173 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3174 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3175 ASSERT_NE(nullptr, audioRenderer);
3176
3177 bool isStarted = audioRenderer->Start();
3178 EXPECT_EQ(true, isStarted);
3179 state = audioRenderer->GetStatus();
3180 EXPECT_EQ(RENDERER_RUNNING, state);
3181
3182 bool isStopped = audioRenderer->Stop();
3183 EXPECT_EQ(true, isStopped);
3184 state = audioRenderer->GetStatus();
3185 EXPECT_EQ(RENDERER_STOPPED, state);
3186
3187 isStarted = audioRenderer->Start();
3188 EXPECT_EQ(true, isStarted);
3189 state = audioRenderer->GetStatus();
3190 EXPECT_EQ(RENDERER_RUNNING, state);
3191
3192 audioRenderer->Release();
3193 }
3194
3195 /**
3196 * @tc.name : Test GetStatus API, call Release without initializing
3197 * @tc.number: Audio_Renderer_GetStatus_005
3198 * @tc.desc : Test GetStatus interface. Not changes to RENDERER_RELEASED, if the current state is RENDERER_NEW.
3199 */
3200 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStatus_005, TestSize.Level1)
3201 {
3202 RendererState state = RENDERER_INVALID;
3203
3204 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
3205 ASSERT_NE(nullptr, audioRenderer);
3206
3207 bool isReleased = audioRenderer->Release();
3208 EXPECT_EQ(false, isReleased);
3209 state = audioRenderer->GetStatus();
3210 EXPECT_NE(RENDERER_RELEASED, state);
3211 EXPECT_EQ(RENDERER_NEW, state);
3212 }
3213
3214 /**
3215 * @tc.name : Test GetLatency API.
3216 * @tc.number: Audio_Renderer_GetLatency_001
3217 * @tc.desc : Test GetLatency interface. Returns 0 {SUCCESS}, if the getting is successful.
3218 */
3219 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetLatency_001, TestSize.Level1)
3220 {
3221 int32_t ret = -1;
3222 FILE *wavFile = fopen(AUDIORENDER_TEST_FILE_PATH.c_str(), "rb");
3223 ASSERT_NE(nullptr, wavFile);
3224
3225 AudioRendererOptions rendererOptions;
3226
3227 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3228 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3229 ASSERT_NE(nullptr, audioRenderer);
3230
3231 bool isStarted = audioRenderer->Start();
3232 EXPECT_EQ(true, isStarted);
3233
3234 size_t bufferLen;
3235 ret = audioRenderer->GetBufferSize(bufferLen);
3236 EXPECT_EQ(SUCCESS, ret);
3237
3238 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
3239 ASSERT_NE(nullptr, buffer);
3240
3241 size_t bytesToWrite = 0;
3242 int32_t bytesWritten = 0;
3243 size_t minBytes = 4;
3244 int32_t numBuffersToRender = WRITE_BUFFERS_COUNT;
3245
3246 while (numBuffersToRender) {
3247 bytesToWrite = fread(buffer, 1, bufferLen, wavFile);
3248 bytesWritten = 0;
3249 uint64_t latency;
3250 ret = audioRenderer->GetLatency(latency);
3251 EXPECT_EQ(SUCCESS, ret);
3252 while ((static_cast<size_t>(bytesWritten) < bytesToWrite) &&
3253 ((static_cast<size_t>(bytesToWrite) - bytesWritten) > minBytes)) {
3254 bytesWritten += audioRenderer->Write(buffer + static_cast<size_t>(bytesWritten),
3255 bytesToWrite - static_cast<size_t>(bytesWritten));
3256 EXPECT_GE(bytesWritten, VALUE_ZERO);
3257 if (bytesWritten < 0) {
3258 break;
3259 }
3260 }
3261 numBuffersToRender--;
3262 }
3263
3264 audioRenderer->Drain();
3265 audioRenderer->Release();
3266
3267 free(buffer);
3268 fclose(wavFile);
3269 }
3270
3271 /**
3272 * @tc.name : Test GetLatency API via illegal state, RENDERER_NEW: without initializing the renderer
3273 * @tc.number: Audio_Renderer_GetLatency_002
3274 * @tc.desc : Test GetLatency interface. Returns error code, if the renderer state is RENDERER_NEW.
3275 */
3276 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetLatency_002, TestSize.Level1)
3277 {
3278 int32_t ret = -1;
3279
3280 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
3281 ASSERT_NE(nullptr, audioRenderer);
3282
3283 bool isStarted = audioRenderer->Start();
3284 EXPECT_EQ(false, isStarted);
3285
3286 uint64_t latency;
3287 ret = audioRenderer->GetLatency(latency);
3288 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
3289 }
3290
3291 /**
3292 * @tc.name : Test GetLatency API via legal state, RENDERER_PREPARED
3293 * @tc.number: Audio_Renderer_GetLatency_003
3294 * @tc.desc : Test GetLatency interface. Returns 0 {SUCCESS}, if the getting is successful.
3295 */
3296 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetLatency_003, TestSize.Level1)
3297 {
3298 int32_t ret = -1;
3299 AudioRendererOptions rendererOptions;
3300
3301 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3302 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3303 ASSERT_NE(nullptr, audioRenderer);
3304
3305 uint64_t latency;
3306 ret = audioRenderer->GetLatency(latency);
3307 EXPECT_EQ(SUCCESS, ret);
3308
3309 audioRenderer->Release();
3310 }
3311
3312 /**
3313 * @tc.name : Test GetLatency API via legal state, RENDERER_STOPPED: After Stop
3314 * @tc.number: Audio_Renderer_GetLatency_004
3315 * @tc.desc : Test GetLatency interface. Returns 0 {SUCCESS}, if the getting is successful.
3316 */
3317 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetLatency_004, TestSize.Level1)
3318 {
3319 int32_t ret = -1;
3320 AudioRendererOptions rendererOptions;
3321
3322 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3323 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3324 ASSERT_NE(nullptr, audioRenderer);
3325
3326 bool isStarted = audioRenderer->Start();
3327 EXPECT_EQ(true, isStarted);
3328
3329 bool isStopped = audioRenderer->Stop();
3330 EXPECT_EQ(true, isStopped);
3331
3332 uint64_t latency;
3333 ret = audioRenderer->GetLatency(latency);
3334 EXPECT_EQ(SUCCESS, ret);
3335
3336 audioRenderer->Release();
3337 }
3338
3339 /**
3340 * @tc.name : Test GetLatency API via illegal state, RENDERER_RELEASED: After Release
3341 * @tc.number: Audio_Renderer_GetLatency_005
3342 * @tc.desc : Test GetLatency interface. Returns error code, if the renderer state is RENDERER_RELEASED.
3343 */
3344 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetLatency_005, TestSize.Level1)
3345 {
3346 int32_t ret = -1;
3347 AudioRendererOptions rendererOptions;
3348
3349 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3350 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3351 ASSERT_NE(nullptr, audioRenderer);
3352
3353 bool isStarted = audioRenderer->Start();
3354 EXPECT_EQ(true, isStarted);
3355
3356 bool isReleased = audioRenderer->Release();
3357 EXPECT_EQ(true, isReleased);
3358
3359 uint64_t latency;
3360 ret = audioRenderer->GetLatency(latency);
3361 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
3362 }
3363
3364 /**
3365 * @tc.name : Test SetRendererCallback with null pointer.
3366 * @tc.number: Audio_Renderer_SetRendererCallback_001
3367 * @tc.desc : Test SetRendererCallback interface. Returns error code, if null pointer is set.
3368 */
3369 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererCallback_001, TestSize.Level1)
3370 {
3371 int32_t ret = -1;
3372
3373 AudioRendererOptions rendererOptions;
3374 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
3375 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
3376 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
3377 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
3378 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
3379 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
3380 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
3381
3382 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3383 ASSERT_NE(nullptr, audioRenderer);
3384
3385 ret = audioRenderer->SetRendererCallback(nullptr);
3386 EXPECT_NE(SUCCESS, ret);
3387 EXPECT_EQ(ERR_INVALID_PARAM, ret);
3388 }
3389
3390 /**
3391 * @tc.name : Test SetRendererCallback with valid callback pointer.
3392 * @tc.number: Audio_Renderer_SetRendererCallback_002
3393 * @tc.desc : Test SetRendererCallback interface. Returns success, if valid callback is set.
3394 */
3395 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererCallback_002, TestSize.Level1)
3396 {
3397 int32_t ret = -1;
3398
3399 AudioRendererOptions rendererOptions;
3400 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
3401 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
3402 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
3403 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
3404 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
3405 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
3406 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
3407
3408 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3409 ASSERT_NE(nullptr, audioRenderer);
3410
3411 shared_ptr<AudioRendererCallbackTest> audioRendererCB = make_shared<AudioRendererCallbackTest>();
3412 ret = audioRenderer->SetRendererCallback(audioRendererCB);
3413 EXPECT_EQ(SUCCESS, ret);
3414 }
3415
3416 /**
3417 * @tc.name : Test SetRendererCallback via illegal state, RENDERER_RELEASED: After RELEASED
3418 * @tc.number: Audio_Renderer_SetRendererCallback_003
3419 * @tc.desc : Test SetRendererCallback interface. Returns error, if callback is set in released state.
3420 */
3421 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererCallback_003, TestSize.Level1)
3422 {
3423 int32_t ret = -1;
3424
3425 AudioRendererOptions rendererOptions;
3426 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
3427 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
3428 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
3429 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
3430 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
3431 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
3432 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
3433
3434 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3435 ASSERT_NE(nullptr, audioRenderer);
3436
3437 bool isReleased = audioRenderer->Release();
3438 EXPECT_EQ(true, isReleased);
3439
3440 RendererState state = audioRenderer->GetStatus();
3441 EXPECT_EQ(RENDERER_RELEASED, state);
3442
3443 shared_ptr<AudioRendererCallbackTest> audioRendererCB = make_shared<AudioRendererCallbackTest>();
3444 ret = audioRenderer->SetRendererCallback(audioRendererCB);
3445 EXPECT_NE(SUCCESS, ret);
3446 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
3447 }
3448
3449 /**
3450 * @tc.name : Test SetRendererCallback via legal state, RENDERER_PREPARED: After PREPARED
3451 * @tc.number: Audio_Renderer_SetRendererCallback_004
3452 * @tc.desc : Test SetRendererCallback interface. Returns success, if callback is set in proper state.
3453 */
3454 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererCallback_004, TestSize.Level1)
3455 {
3456 int32_t ret = -1;
3457
3458 AudioRendererOptions rendererOptions;
3459 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
3460 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
3461 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
3462 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
3463 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
3464 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
3465 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
3466
3467 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3468 ASSERT_NE(nullptr, audioRenderer);
3469
3470 RendererState state = audioRenderer->GetStatus();
3471 EXPECT_EQ(RENDERER_PREPARED, state);
3472
3473 shared_ptr<AudioRendererCallbackTest> audioRendererCB = make_shared<AudioRendererCallbackTest>();
3474 ret = audioRenderer->SetRendererCallback(audioRendererCB);
3475 EXPECT_EQ(SUCCESS, ret);
3476 }
3477
3478 /**
3479 * @tc.name : Test SetRenderMode via legal input, RENDER_MODE_CALLBACK
3480 * @tc.number: Audio_Renderer_SetRenderMode_001
3481 * @tc.desc : Test SetRenderMode interface. Returns SUCCESS, if the render mode is successfully set.
3482 */
3483 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRenderMode_001, TestSize.Level1)
3484 {
3485 int32_t ret = -1;
3486 AudioRendererOptions rendererOptions;
3487
3488 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3489 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3490 ASSERT_NE(nullptr, audioRenderer);
3491
3492 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3493 EXPECT_EQ(SUCCESS, ret);
3494
3495 audioRenderer->Release();
3496 }
3497
3498 /**
3499 * @tc.name : Test SetRenderMode via legal input, RENDER_MODE_NORMAL
3500 * @tc.number: Audio_Renderer_SetRenderMode_002
3501 * @tc.desc : Test SetRenderMode interface. Returns SUCCESS, if the render mode is successfully set.
3502 */
3503 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRenderMode_002, TestSize.Level1)
3504 {
3505 int32_t ret = -1;
3506 AudioRendererOptions rendererOptions;
3507
3508 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3509 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3510 ASSERT_NE(nullptr, audioRenderer);
3511
3512 ret = audioRenderer->SetRenderMode(RENDER_MODE_NORMAL);
3513 EXPECT_EQ(SUCCESS, ret);
3514
3515 audioRenderer->Release();
3516 }
3517
3518 /**
3519 * @tc.name : Test GetRenderMode with, RENDER_MODE_CALLBACK
3520 * @tc.number: Audio_Renderer_GetRenderMode_001
3521 * @tc.desc : Test GetRenderMode interface. Returns the current render mode.
3522 */
3523 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRenderMode_001, TestSize.Level1)
3524 {
3525 int32_t ret = -1;
3526 AudioRendererOptions rendererOptions;
3527
3528 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3529 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3530 ASSERT_NE(nullptr, audioRenderer);
3531
3532 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3533 EXPECT_EQ(SUCCESS, ret);
3534 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3535 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
3536
3537 audioRenderer->Release();
3538 }
3539
3540 /**
3541 * @tc.name : Test GetRenderMode with, RENDER_MODE_NORMAL
3542 * @tc.number: Audio_Renderer_GetRenderMode_002
3543 * @tc.desc : Test GetRenderMode interface. Returns the current render mode.
3544 */
3545 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRenderMode_002, TestSize.Level1)
3546 {
3547 int32_t ret = -1;
3548 AudioRendererOptions rendererOptions;
3549
3550 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3551 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3552 ASSERT_NE(nullptr, audioRenderer);
3553
3554 ret = audioRenderer->SetRenderMode(RENDER_MODE_NORMAL);
3555 EXPECT_EQ(SUCCESS, ret);
3556 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3557 EXPECT_EQ(RENDER_MODE_NORMAL, renderMode);
3558
3559 audioRenderer->Release();
3560 }
3561
3562 /**
3563 * @tc.name : Test GetRenderMode with, default renderMode
3564 * @tc.number: Audio_Renderer_GetRenderMode_003
3565 * @tc.desc : Test GetRenderMode interface. Returns the default render mode RENDER_MODE_NORMAL.
3566 */
3567 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRenderMode_003, TestSize.Level1)
3568 {
3569 AudioRendererOptions rendererOptions;
3570
3571 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3572 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3573 ASSERT_NE(nullptr, audioRenderer);
3574
3575 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3576 EXPECT_EQ(RENDER_MODE_NORMAL, renderMode);
3577
3578 audioRenderer->Release();
3579 }
3580
3581 /**
3582 * @tc.name : Test SetRendererWriteCallback via legal render mode, RENDER_MODE_CALLBACK
3583 * @tc.number: Audio_Renderer_SetRendererWriteCallback_001
3584 * @tc.desc : Test SetRendererWriteCallback interface. Returns SUCCESS, if the callback is successfully set.
3585 */
3586 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererWriteCallback_001, TestSize.Level1)
3587 {
3588 int32_t ret = -1;
3589 AudioRendererOptions rendererOptions;
3590
3591 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3592 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3593 ASSERT_NE(nullptr, audioRenderer);
3594
3595 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3596 EXPECT_EQ(SUCCESS, ret);
3597 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3598 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
3599
3600 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3601
3602 ret = audioRenderer->SetRendererWriteCallback(cb);
3603 EXPECT_EQ(SUCCESS, ret);
3604
3605 audioRenderer->Release();
3606 }
3607
3608 /**
3609 * @tc.name : Test SetRendererWriteCallback via illegal render mode, RENDER_MODE_NORMAL
3610 * @tc.number: Audio_Renderer_SetRendererWriteCallback_002
3611 * @tc.desc : Test SetRendererWriteCallback interface. Returns error code, if the render mode is not callback.
3612 */
3613 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererWriteCallback_002, TestSize.Level1)
3614 {
3615 int32_t ret = -1;
3616 AudioRendererOptions rendererOptions;
3617
3618 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3619 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3620 ASSERT_NE(nullptr, audioRenderer);
3621
3622 ret = audioRenderer->SetRenderMode(RENDER_MODE_NORMAL);
3623 EXPECT_EQ(SUCCESS, ret);
3624 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3625 EXPECT_EQ(RENDER_MODE_NORMAL, renderMode);
3626
3627 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3628
3629 ret = audioRenderer->SetRendererWriteCallback(cb);
3630 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3631
3632 audioRenderer->Release();
3633 }
3634
3635 /**
3636 * @tc.name : Test SetRendererWriteCallback via illegal render mode, default render mode RENDER_MODE_NORMAL
3637 * @tc.number: Audio_Renderer_SetRendererWriteCallback_003
3638 * @tc.desc : Test SetRendererWriteCallback interface. Returns error code, if the render mode is not callback.
3639 */
3640 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererWriteCallback_003, TestSize.Level1)
3641 {
3642 int32_t ret = -1;
3643 AudioRendererOptions rendererOptions;
3644
3645 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3646 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3647 ASSERT_NE(nullptr, audioRenderer);
3648
3649 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3650
3651 ret = audioRenderer->SetRendererWriteCallback(cb);
3652 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3653
3654 audioRenderer->Release();
3655 }
3656
3657 /**
3658 * @tc.name : Test SetRendererWriteCallback via illegal input, nullptr
3659 * @tc.number: Audio_Renderer_SetRendererWriteCallback_004
3660 * @tc.desc : Test SetRendererWriteCallback interface. Returns error code, if the callback reference is nullptr.
3661 */
3662 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererWriteCallback_004, TestSize.Level1)
3663 {
3664 int32_t ret = -1;
3665 AudioRendererOptions rendererOptions;
3666
3667 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3668 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3669 ASSERT_NE(nullptr, audioRenderer);
3670
3671 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3672 EXPECT_EQ(SUCCESS, ret);
3673 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3674 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
3675
3676 ret = audioRenderer->SetRendererWriteCallback(nullptr);
3677 EXPECT_EQ(ERR_INVALID_PARAM, ret);
3678
3679 audioRenderer->Release();
3680 }
3681
3682 /**
3683 * @tc.name : Test GetBufferDesc via legal render mode, RENDER_MODE_CALLBACK
3684 * @tc.number: Audio_Renderer_GetBufferDesc_001
3685 * @tc.desc : Test GetBufferDesc interface. Returns SUCCESS, if BufferDesc obtained successfully.
3686 */
3687 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufferDesc_001, TestSize.Level1)
3688 {
3689 int32_t ret = -1;
3690 AudioRendererOptions rendererOptions;
3691
3692 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3693 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3694 ASSERT_NE(nullptr, audioRenderer);
3695
3696 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3697 EXPECT_EQ(SUCCESS, ret);
3698 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3699 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
3700
3701 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3702
3703 ret = audioRenderer->SetRendererWriteCallback(cb);
3704 EXPECT_EQ(SUCCESS, ret);
3705
3706 BufferDesc bufDesc {};
3707 bufDesc.buffer = nullptr;
3708 bufDesc.dataLength = g_reqBufLen;
3709 ret = audioRenderer->GetBufferDesc(bufDesc);
3710 EXPECT_EQ(SUCCESS, ret);
3711 EXPECT_NE(nullptr, bufDesc.buffer);
3712
3713 audioRenderer->Release();
3714 }
3715
3716 /**
3717 * @tc.name : Test GetBufferDesc via illegal render mode, RENDER_MODE_NORMAL
3718 * @tc.number: Audio_Renderer_GetBufferDesc_002
3719 * @tc.desc : Test GetBufferDesc interface. Returns errorcode, if render mode is not callback.
3720 */
3721 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetBufferDesc_002, TestSize.Level1)
3722 {
3723 int32_t ret = -1;
3724 AudioRendererOptions rendererOptions;
3725
3726 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3727 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3728 ASSERT_NE(nullptr, audioRenderer);
3729
3730 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3731
3732 ret = audioRenderer->SetRendererWriteCallback(cb);
3733 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3734
3735 BufferDesc bufDesc {};
3736 bufDesc.buffer = nullptr;
3737 bufDesc.dataLength = g_reqBufLen;
3738 ret = audioRenderer->GetBufferDesc(bufDesc);
3739 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3740 EXPECT_EQ(nullptr, bufDesc.buffer);
3741
3742 audioRenderer->Release();
3743 }
3744
3745 /**
3746 * @tc.name : Test Enqueue via legal render mode, RENDER_MODE_CALLBACK
3747 * @tc.number: Audio_Renderer_Enqueue_001
3748 * @tc.desc : Test Enqueue interface. Returns SUCCESS , if the buff desc enqueued successfully.
3749 */
3750 HWTEST(AudioRendererUnitTest, Audio_Renderer_Enqueue_001, TestSize.Level1)
3751 {
3752 int32_t ret = -1;
3753 AudioRendererOptions rendererOptions;
3754
3755 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3756 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3757 ASSERT_NE(nullptr, audioRenderer);
3758
3759 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3760 EXPECT_EQ(SUCCESS, ret);
3761 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3762 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
3763
3764 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3765
3766 ret = audioRenderer->SetRendererWriteCallback(cb);
3767 EXPECT_EQ(SUCCESS, ret);
3768
3769 bool isStarted = audioRenderer->Start();
3770 EXPECT_EQ(true, isStarted);
3771
3772 BufferDesc bufDesc {};
3773 bufDesc.buffer = nullptr;
3774 bufDesc.dataLength = g_reqBufLen;
3775 ret = audioRenderer->GetBufferDesc(bufDesc);
3776 EXPECT_EQ(SUCCESS, ret);
3777 EXPECT_NE(nullptr, bufDesc.buffer);
3778
3779 ret = audioRenderer->Enqueue(bufDesc);
3780 EXPECT_EQ(SUCCESS, ret);
3781
3782 audioRenderer->Stop();
3783 audioRenderer->Release();
3784 }
3785
3786 /**
3787 * @tc.name : Test Enqueue via illegal render mode, RENDER_MODE_NORMAL
3788 * @tc.number: Audio_Renderer_Enqueue_002
3789 * @tc.desc : Test Enqueue interface. Returns error code, if the render mode is not callback.
3790 */
3791 HWTEST(AudioRendererUnitTest, Audio_Renderer_Enqueue_002, TestSize.Level1)
3792 {
3793 int32_t ret = -1;
3794 AudioRendererOptions rendererOptions;
3795
3796 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3797 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3798 ASSERT_NE(nullptr, audioRenderer);
3799
3800 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3801
3802 ret = audioRenderer->SetRendererWriteCallback(cb);
3803 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3804
3805 bool isStarted = audioRenderer->Start();
3806 EXPECT_EQ(true, isStarted);
3807
3808 BufferDesc bufDesc {};
3809 bufDesc.buffer = nullptr;
3810 bufDesc.dataLength = g_reqBufLen;
3811 ret = audioRenderer->GetBufferDesc(bufDesc);
3812 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3813
3814 ret = audioRenderer->Enqueue(bufDesc);
3815 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3816
3817 audioRenderer->Stop();
3818 audioRenderer->Release();
3819 }
3820
3821 /**
3822 * @tc.name : Test Enqueue via illegal input, buffer nullptr
3823 * @tc.number: Audio_Renderer_Enqueue_003
3824 * @tc.desc : Test Enqueue interface. Returns error code, if the buffer nullptr
3825 */
3826 HWTEST(AudioRendererUnitTest, Audio_Renderer_Enqueue_003, TestSize.Level1)
3827 {
3828 int32_t ret = -1;
3829 AudioRendererOptions rendererOptions;
3830
3831 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3832 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3833 ASSERT_NE(nullptr, audioRenderer);
3834
3835 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3836 EXPECT_EQ(SUCCESS, ret);
3837 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3838 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
3839
3840 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3841
3842 ret = audioRenderer->SetRendererWriteCallback(cb);
3843 EXPECT_EQ(SUCCESS, ret);
3844
3845 bool isStarted = audioRenderer->Start();
3846 EXPECT_EQ(true, isStarted);
3847
3848 BufferDesc bufDesc {};
3849 bufDesc.buffer = nullptr;
3850 bufDesc.dataLength = g_reqBufLen;
3851
3852 ret = audioRenderer->Enqueue(bufDesc);
3853 EXPECT_EQ(ERR_INVALID_PARAM, ret);
3854
3855 audioRenderer->Stop();
3856 audioRenderer->Release();
3857 }
3858
3859 /**
3860 * @tc.name : Test Clear via legal render mode, RENDER_MODE_CALLBACK
3861 * @tc.number: Audio_Renderer_Clear_001
3862 * @tc.desc : Test Clear interface. Returns SUCCESS , if the buff queue cleared successfully.
3863 */
3864 HWTEST(AudioRendererUnitTest, Audio_Renderer_Clear_001, TestSize.Level1)
3865 {
3866 int32_t ret = -1;
3867 AudioRendererOptions rendererOptions;
3868
3869 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3870 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3871 ASSERT_NE(nullptr, audioRenderer);
3872
3873 ret = audioRenderer->SetRenderMode(RENDER_MODE_CALLBACK);
3874 EXPECT_EQ(SUCCESS, ret);
3875 AudioRenderMode renderMode = audioRenderer->GetRenderMode();
3876 EXPECT_EQ(RENDER_MODE_CALLBACK, renderMode);
3877
3878 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3879
3880 ret = audioRenderer->SetRendererWriteCallback(cb);
3881 EXPECT_EQ(SUCCESS, ret);
3882
3883 bool isStarted = audioRenderer->Start();
3884 EXPECT_EQ(true, isStarted);
3885
3886 BufferDesc bufDesc {};
3887 bufDesc.buffer = nullptr;
3888 bufDesc.dataLength = g_reqBufLen;
3889 ret = audioRenderer->GetBufferDesc(bufDesc);
3890 EXPECT_EQ(SUCCESS, ret);
3891 EXPECT_NE(nullptr, bufDesc.buffer);
3892
3893 ret = audioRenderer->Enqueue(bufDesc);
3894 EXPECT_EQ(SUCCESS, ret);
3895
3896 ret = audioRenderer->Clear();
3897 EXPECT_EQ(SUCCESS, ret);
3898
3899 audioRenderer->Stop();
3900 audioRenderer->Release();
3901 }
3902
3903 /**
3904 * @tc.name : Test Clear via illegal render mode, RENDER_MODE_NORMAL
3905 * @tc.number: Audio_Renderer_Clear_002
3906 * @tc.desc : Test Clear interface. Returns error code, if the render mode is not callback.
3907 */
3908 HWTEST(AudioRendererUnitTest, Audio_Renderer_Clear_002, TestSize.Level1)
3909 {
3910 int32_t ret = -1;
3911 AudioRendererOptions rendererOptions;
3912
3913 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
3914 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3915 ASSERT_NE(nullptr, audioRenderer);
3916
3917 shared_ptr<AudioRendererWriteCallback> cb = make_shared<AudioRenderModeCallbackTest>();
3918
3919 ret = audioRenderer->SetRendererWriteCallback(cb);
3920 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3921
3922 bool isStarted = audioRenderer->Start();
3923 EXPECT_EQ(true, isStarted);
3924
3925 BufferDesc bufDesc {};
3926 bufDesc.buffer = nullptr;
3927 bufDesc.dataLength = g_reqBufLen;
3928 ret = audioRenderer->GetBufferDesc(bufDesc);
3929 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3930
3931 ret = audioRenderer->Enqueue(bufDesc);
3932 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3933
3934 ret = audioRenderer->Clear();
3935 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
3936
3937 audioRenderer->Stop();
3938 audioRenderer->Release();
3939 }
3940
3941 /**
3942 * @tc.name : Test GetRendererInfo API after calling create
3943 * @tc.number: Audio_Renderer_GetRendererInfo_001
3944 * @tc.desc : Test GetRendererInfo interface. Check whether renderer info returns proper data
3945 */
3946 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRendererInfo_001, TestSize.Level1)
3947 {
3948 AudioRendererOptions rendererOptions;
3949 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
3950 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
3951 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
3952 rendererOptions.streamInfo.channels = AudioChannel::MONO;
3953 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
3954 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
3955 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
3956
3957 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3958 EXPECT_NE(nullptr, audioRenderer);
3959
3960 AudioRendererInfo rendererInfo;
3961 audioRenderer->GetRendererInfo(rendererInfo);
3962
3963 EXPECT_EQ(ContentType::CONTENT_TYPE_MUSIC, rendererInfo.contentType);
3964 EXPECT_EQ(StreamUsage::STREAM_USAGE_MEDIA, rendererInfo.streamUsage);
3965 EXPECT_EQ(RENDERER_FLAG, rendererInfo.rendererFlags);
3966 audioRenderer->Release();
3967 }
3968
3969 /**
3970 * @tc.name : Test GetRendererInfo API via legal state, RENDERER_RUNNING: GetRendererInfo after Start.
3971 * @tc.number: Audio_Renderer_GetRendererInfo_002
3972 * @tc.desc : Test GetRendererInfo interface. Check whether renderer info returns proper data
3973 */
3974 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRendererInfo_002, TestSize.Level1)
3975 {
3976 AudioRendererOptions rendererOptions;
3977 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
3978 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
3979 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
3980 rendererOptions.streamInfo.channels = AudioChannel::MONO;
3981 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
3982 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
3983 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
3984
3985 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
3986 EXPECT_NE(nullptr, audioRenderer);
3987
3988 bool isStarted = audioRenderer->Start();
3989 EXPECT_EQ(true, isStarted);
3990
3991 AudioRendererInfo rendererInfo;
3992 audioRenderer->GetRendererInfo(rendererInfo);
3993
3994 EXPECT_EQ(ContentType::CONTENT_TYPE_MUSIC, rendererInfo.contentType);
3995 EXPECT_EQ(StreamUsage::STREAM_USAGE_MEDIA, rendererInfo.streamUsage);
3996 EXPECT_EQ(RENDERER_FLAG, rendererInfo.rendererFlags);
3997
3998 audioRenderer->Stop();
3999 audioRenderer->Release();
4000 }
4001
4002 /**
4003 * @tc.name : Test GetRendererInfo API via legal state, RENDERER_RELEASED: Call GetRendererInfo after Release.
4004 * @tc.number: Audio_Renderer_GetRendererInfo_003
4005 * @tc.desc : Test GetRendererInfo interface. Check whether renderer info returns proper data
4006 */
4007 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRendererInfo_003, TestSize.Level1)
4008 {
4009 AudioRendererOptions rendererOptions;
4010 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4011 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4012 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4013 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4014 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4015 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4016 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4017
4018 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4019 EXPECT_NE(nullptr, audioRenderer);
4020
4021 bool isReleased = audioRenderer->Release();
4022 EXPECT_EQ(true, isReleased);
4023
4024 AudioRendererInfo rendererInfo;
4025 audioRenderer->GetRendererInfo(rendererInfo);
4026
4027 EXPECT_EQ(ContentType::CONTENT_TYPE_MUSIC, rendererInfo.contentType);
4028 EXPECT_EQ(StreamUsage::STREAM_USAGE_MEDIA, rendererInfo.streamUsage);
4029 EXPECT_EQ(RENDERER_FLAG, rendererInfo.rendererFlags);
4030 }
4031
4032 /**
4033 * @tc.name : Test GetRendererInfo API via legal state, RENDERER_STOPPED: Call GetRendererInfo after Stop.
4034 * @tc.number: Audio_Renderer_GetRendererInfo_004
4035 * @tc.desc : Test GetRendererInfo interface. Check whether renderer info returns proper data
4036 */
4037 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRendererInfo_004, TestSize.Level1)
4038 {
4039 AudioRendererOptions rendererOptions;
4040 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4041 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4042 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4043 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4044 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4045 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4046 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4047
4048 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4049 EXPECT_NE(nullptr, audioRenderer);
4050
4051 bool isStarted = audioRenderer->Start();
4052 EXPECT_EQ(true, isStarted);
4053
4054 bool isStopped = audioRenderer->Stop();
4055 EXPECT_EQ(true, isStopped);
4056
4057 AudioRendererInfo rendererInfo;
4058 audioRenderer->GetRendererInfo(rendererInfo);
4059
4060 EXPECT_EQ(ContentType::CONTENT_TYPE_MUSIC, rendererInfo.contentType);
4061 EXPECT_EQ(StreamUsage::STREAM_USAGE_MEDIA, rendererInfo.streamUsage);
4062 EXPECT_EQ(RENDERER_FLAG, rendererInfo.rendererFlags);
4063
4064 audioRenderer->Release();
4065 }
4066
4067 /**
4068 * @tc.name : Test GetRendererInfo API Stability
4069 * @tc.number: Audio_Renderer_GetRendererInfo_Stability_001
4070 * @tc.desc : Test GetRendererInfo interface Stability
4071 */
4072 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRendererInfo_Stability_001, TestSize.Level1)
4073 {
4074 AudioRendererOptions rendererOptions;
4075 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4076 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4077 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4078 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4079 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4080 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4081 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4082
4083 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4084 EXPECT_NE(nullptr, audioRenderer);
4085
4086 for (int i = 0; i < VALUE_THOUSAND; i++) {
4087
4088 AudioRendererInfo rendererInfo;
4089 audioRenderer->GetRendererInfo(rendererInfo);
4090
4091 EXPECT_EQ(ContentType::CONTENT_TYPE_MUSIC, rendererInfo.contentType);
4092 EXPECT_EQ(StreamUsage::STREAM_USAGE_MEDIA, rendererInfo.streamUsage);
4093 EXPECT_EQ(RENDERER_FLAG, rendererInfo.rendererFlags);
4094 }
4095 audioRenderer->Release();
4096 }
4097
4098 /**
4099 * @tc.name : Test GetStreamInfo API after calling create
4100 * @tc.number: Audio_Renderer_GetStreamInfo_001
4101 * @tc.desc : Test GetStreamInfo interface. Check whether stream related data is returned correctly
4102 */
4103 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStreamInfo_001, TestSize.Level1)
4104 {
4105 AudioRendererOptions rendererOptions;
4106 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4107 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4108 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4109 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4110 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4111 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4112 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4113
4114 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4115 EXPECT_NE(nullptr, audioRenderer);
4116
4117 AudioStreamInfo streamInfo;
4118 audioRenderer->GetStreamInfo(streamInfo);
4119
4120 EXPECT_EQ(AudioSamplingRate::SAMPLE_RATE_96000, streamInfo.samplingRate);
4121 EXPECT_EQ(AudioEncodingType::ENCODING_PCM, streamInfo.encoding);
4122 EXPECT_EQ(AudioSampleFormat::SAMPLE_U8, streamInfo.format);
4123 EXPECT_EQ(AudioChannel::MONO, streamInfo.channels);
4124 audioRenderer->Release();
4125 }
4126
4127 /**
4128 * @tc.name : Test GetStreamInfo via legal state, RENDERER_RUNNING: GetStreamInfo after Start.
4129 * @tc.number: Audio_Renderer_GetStreamInfo_002
4130 * @tc.desc : Test GetStreamInfo interface. Check whether stream related data is returned correctly
4131 */
4132 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStreamInfo_002, TestSize.Level1)
4133 {
4134 int32_t ret = -1;
4135
4136 AudioRendererOptions rendererOptions;
4137 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4138 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4139 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4140 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4141 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4142 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4143 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4144
4145 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4146 EXPECT_NE(nullptr, audioRenderer);
4147
4148 bool isStarted = audioRenderer->Start();
4149 EXPECT_EQ(true, isStarted);
4150
4151 AudioStreamInfo streamInfo;
4152 ret = audioRenderer->GetStreamInfo(streamInfo);
4153
4154 EXPECT_EQ(SUCCESS, ret);
4155 EXPECT_EQ(AudioSamplingRate::SAMPLE_RATE_96000, streamInfo.samplingRate);
4156 EXPECT_EQ(AudioEncodingType::ENCODING_PCM, streamInfo.encoding);
4157 EXPECT_EQ(AudioSampleFormat::SAMPLE_U8, streamInfo.format);
4158 EXPECT_EQ(AudioChannel::MONO, streamInfo.channels);
4159
4160 audioRenderer->Stop();
4161 audioRenderer->Release();
4162 }
4163
4164 /**
4165 * @tc.name : Test GetStreamInfo via illegal state, RENDERER_RELEASED: GetStreamInfo after Release.
4166 * @tc.number: Audio_Renderer_GetStreamInfo_003
4167 * @tc.desc : Test GetStreamInfo interface. Returns error code, if the renderer state is RENDERER_RELEASED.
4168 */
4169 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStreamInfo_003, TestSize.Level1)
4170 {
4171 int32_t ret = -1;
4172
4173 AudioRendererOptions rendererOptions;
4174 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4175 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4176 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4177 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4178 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4179 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4180 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4181
4182 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4183 EXPECT_NE(nullptr, audioRenderer);
4184
4185 bool isReleased = audioRenderer->Release();
4186 EXPECT_EQ(true, isReleased);
4187
4188 AudioStreamInfo streamInfo;
4189 ret = audioRenderer->GetStreamInfo(streamInfo);
4190
4191 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
4192 }
4193
4194 /**
4195 * @tc.name : Test GetStreamInfo via legal state, RENDERER_STOPPED: GetStreamInfo after Stop.
4196 * @tc.number: Audio_Renderer_GetStreamInfo_004
4197 * @tc.desc : Test GetStreamInfo interface. Check whether stream related data is returned correctly
4198 */
4199 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStreamInfo_004, TestSize.Level1)
4200 {
4201 int32_t ret = -1;
4202
4203 AudioRendererOptions rendererOptions;
4204 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4205 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4206 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4207 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4208 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4209 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4210 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4211
4212 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4213 EXPECT_NE(nullptr, audioRenderer);
4214
4215 bool isStarted = audioRenderer->Start();
4216 EXPECT_EQ(true, isStarted);
4217
4218 bool isStopped = audioRenderer->Stop();
4219 EXPECT_EQ(true, isStopped);
4220
4221 AudioStreamInfo streamInfo;
4222 ret = audioRenderer->GetStreamInfo(streamInfo);
4223
4224 EXPECT_EQ(SUCCESS, ret);
4225 EXPECT_EQ(AudioSamplingRate::SAMPLE_RATE_96000, streamInfo.samplingRate);
4226 EXPECT_EQ(AudioEncodingType::ENCODING_PCM, streamInfo.encoding);
4227 EXPECT_EQ(AudioSampleFormat::SAMPLE_U8, streamInfo.format);
4228 EXPECT_EQ(AudioChannel::MONO, streamInfo.channels);
4229
4230 audioRenderer->Release();
4231 }
4232
4233 /**
4234 * @tc.name : Test GetStreamInfo via legal state, RENDERER_PAUSED: GetStreamInfo after Pause.
4235 * @tc.number: Audio_Renderer_GetStreamInfo_005
4236 * @tc.desc : Test GetStreamInfo interface. Check whether stream related data is returned correctly
4237 */
4238 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStreamInfo_005, TestSize.Level1)
4239 {
4240 int32_t ret = -1;
4241
4242 AudioRendererOptions rendererOptions;
4243 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4244 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4245 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4246 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4247 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4248 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4249 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4250
4251 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4252 EXPECT_NE(nullptr, audioRenderer);
4253
4254 bool isStarted = audioRenderer->Start();
4255 EXPECT_EQ(true, isStarted);
4256
4257 bool isPaused = audioRenderer->Pause();
4258 EXPECT_EQ(true, isPaused);
4259
4260 AudioStreamInfo streamInfo;
4261 ret = audioRenderer->GetStreamInfo(streamInfo);
4262
4263 EXPECT_EQ(SUCCESS, ret);
4264 EXPECT_EQ(AudioSamplingRate::SAMPLE_RATE_96000, streamInfo.samplingRate);
4265 EXPECT_EQ(AudioEncodingType::ENCODING_PCM, streamInfo.encoding);
4266 EXPECT_EQ(AudioSampleFormat::SAMPLE_U8, streamInfo.format);
4267 EXPECT_EQ(AudioChannel::MONO, streamInfo.channels);
4268
4269 audioRenderer->Stop();
4270 audioRenderer->Release();
4271 }
4272
4273 /**
4274 * @tc.name : Test GetStreamInfo API stability.
4275 * @tc.number: Audio_Renderer_GetStreamInfo_Stability_001
4276 * @tc.desc : Test GetStreamInfo interface stability
4277 */
4278 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetStreamInfo_Stability_001, TestSize.Level1)
4279 {
4280 int32_t ret = -1;
4281
4282 AudioRendererOptions rendererOptions;
4283 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4284 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4285 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4286 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4287 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4288 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4289 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4290
4291 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4292 EXPECT_NE(nullptr, audioRenderer);
4293
4294 bool isStarted = audioRenderer->Start();
4295 EXPECT_EQ(true, isStarted);
4296
4297
4298 for (int i = 0; i < VALUE_THOUSAND; i++) {
4299 AudioStreamInfo streamInfo;
4300 ret = audioRenderer->GetStreamInfo(streamInfo);
4301 EXPECT_EQ(SUCCESS, ret);
4302 }
4303
4304 audioRenderer->Stop();
4305 audioRenderer->Release();
4306 }
4307
4308 /**
4309 * @tc.name : Test SetBufferDuration API
4310 * @tc.number: Audio_Renderer_SetBufferDuration_001
4311 * @tc.desc : Test SetBufferDuration interface. Check whether valid parameters are accepted.
4312 */
4313 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetBufferDuration_001, TestSize.Level1)
4314 {
4315 int32_t ret = -1;
4316
4317 AudioRendererOptions rendererOptions;
4318 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4319 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4320 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4321 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4322 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4323 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4324 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4325
4326 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4327 EXPECT_NE(nullptr, audioRenderer);
4328
4329 ret = audioRenderer->SetBufferDuration(BUFFER_DURATION_FIVE);
4330 EXPECT_EQ(SUCCESS, ret);
4331
4332 ret = audioRenderer->SetBufferDuration(BUFFER_DURATION_TEN);
4333 EXPECT_EQ(SUCCESS, ret);
4334
4335 ret = audioRenderer->SetBufferDuration(BUFFER_DURATION_FIFTEEN);
4336 EXPECT_EQ(SUCCESS, ret);
4337
4338 ret = audioRenderer->SetBufferDuration(BUFFER_DURATION_TWENTY);
4339 EXPECT_EQ(SUCCESS, ret);
4340 }
4341
4342 /**
4343 * @tc.name : Test SetBufferDuration API
4344 * @tc.number: Audio_Renderer_SetBufferDuration_002
4345 * @tc.desc : Test SetBufferDuration interface. Check whether invalid parameters are rejected.
4346 */
4347 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetBufferDuration_002, TestSize.Level1)
4348 {
4349 int32_t ret = -1;
4350
4351 AudioRendererOptions rendererOptions;
4352 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
4353 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4354 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4355 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4356 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
4357 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
4358 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4359
4360 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4361 EXPECT_NE(nullptr, audioRenderer);
4362
4363 ret = audioRenderer->SetBufferDuration(VALUE_NEGATIVE);
4364 EXPECT_NE(SUCCESS, ret);
4365
4366 ret = audioRenderer->SetBufferDuration(VALUE_ZERO);
4367 EXPECT_NE(SUCCESS, ret);
4368
4369 ret = audioRenderer->SetBufferDuration(VALUE_HUNDRED);
4370 EXPECT_NE(SUCCESS, ret);
4371 }
4372
4373 /**
4374 * @tc.name : Test SetRendererPositionCallback API
4375 * @tc.number: Audio_Renderer_SetRendererPositionCallback_001
4376 * @tc.desc : Test SetRendererPositionCallback interface to check set position callback is success for valid callback.
4377 */
4378 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPositionCallback_001, TestSize.Level1)
4379 {
4380 int32_t ret = -1;
4381
4382 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4383 ASSERT_NE(nullptr, audioRenderer);
4384
4385 shared_ptr<RendererPositionCallbackTest> positionCB = std::make_shared<RendererPositionCallbackTest>();
4386 ret = audioRenderer->SetRendererPositionCallback(VALUE_THOUSAND, positionCB);
4387 EXPECT_EQ(SUCCESS, ret);
4388 }
4389
4390 /**
4391 * @tc.name : Test SetRendererPositionCallback API
4392 * @tc.number: Audio_Renderer_SetRendererPositionCallback_002
4393 * @tc.desc : Test SetRendererPositionCallback interface again after unregister.
4394 */
4395 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPositionCallback_002, TestSize.Level1)
4396 {
4397 int32_t ret = -1;
4398
4399 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4400 ASSERT_NE(nullptr, audioRenderer);
4401
4402 shared_ptr<RendererPositionCallbackTest> positionCB1 = std::make_shared<RendererPositionCallbackTest>();
4403 ret = audioRenderer->SetRendererPositionCallback(VALUE_THOUSAND, positionCB1);
4404 EXPECT_EQ(SUCCESS, ret);
4405
4406 audioRenderer->UnsetRendererPositionCallback();
4407
4408 shared_ptr<RendererPositionCallbackTest> positionCB2 = std::make_shared<RendererPositionCallbackTest>();
4409 ret = audioRenderer->SetRendererPositionCallback(VALUE_THOUSAND, positionCB2);
4410 EXPECT_EQ(SUCCESS, ret);
4411 }
4412
4413 /**
4414 * @tc.name : Test SetRendererPositionCallback API
4415 * @tc.number: Audio_Renderer_SetRendererPositionCallback_003
4416 * @tc.desc : Test SetRendererPositionCallback interface with null callback.
4417 */
4418 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPositionCallback_003, TestSize.Level1)
4419 {
4420 int32_t ret = -1;
4421
4422 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4423 ASSERT_NE(nullptr, audioRenderer);
4424
4425 ret = audioRenderer->SetRendererPositionCallback(VALUE_THOUSAND, nullptr);
4426 EXPECT_NE(SUCCESS, ret);
4427 }
4428
4429 /**
4430 * @tc.name : Test SetRendererPositionCallback API
4431 * @tc.number: Audio_Renderer_SetRendererPositionCallback_004
4432 * @tc.desc : Test SetRendererPositionCallback interface with invalid parameter.
4433 */
4434 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPositionCallback_004, TestSize.Level1)
4435 {
4436 int32_t ret = -1;
4437
4438 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4439 ASSERT_NE(nullptr, audioRenderer);
4440
4441 shared_ptr<RendererPositionCallbackTest> positionCB = std::make_shared<RendererPositionCallbackTest>();
4442 ret = audioRenderer->SetRendererPositionCallback(VALUE_ZERO, positionCB);
4443 EXPECT_NE(SUCCESS, ret);
4444
4445 ret = audioRenderer->SetRendererPositionCallback(VALUE_NEGATIVE, positionCB);
4446 EXPECT_NE(SUCCESS, ret);
4447 }
4448
4449 /**
4450 * @tc.name : Test SetRendererPeriodPositionCallback API
4451 * @tc.number: Audio_Renderer_SetRendererPeriodPositionCallback_001
4452 * @tc.desc : Test SetRendererPeriodPositionCallback interface to check set period position
4453 * callback is success for valid callback.
4454 */
4455 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPeriodPositionCallback_001, TestSize.Level1)
4456 {
4457 int32_t ret = -1;
4458
4459 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4460 ASSERT_NE(nullptr, audioRenderer);
4461
4462 shared_ptr<RendererPeriodPositionCallbackTest> positionCB = std::make_shared<RendererPeriodPositionCallbackTest>();
4463 ret = audioRenderer->SetRendererPeriodPositionCallback(VALUE_THOUSAND, positionCB);
4464 EXPECT_EQ(SUCCESS, ret);
4465 }
4466
4467 /**
4468 * @tc.name : Test SetRendererPeriodPositionCallback API
4469 * @tc.number: Audio_Renderer_SetRendererPeriodPositionCallback_002
4470 * @tc.desc : Test SetRendererPeriodPositionCallback interface again after unregister.
4471 */
4472 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPeriodPositionCallback_002, TestSize.Level1)
4473 {
4474 int32_t ret = -1;
4475
4476 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4477 ASSERT_NE(nullptr, audioRenderer);
4478
4479 shared_ptr<RendererPeriodPositionCallbackTest> positionCB1 = std::make_shared<RendererPeriodPositionCallbackTest>();
4480 ret = audioRenderer->SetRendererPeriodPositionCallback(VALUE_THOUSAND, positionCB1);
4481 EXPECT_EQ(SUCCESS, ret);
4482
4483 audioRenderer->UnsetRendererPeriodPositionCallback();
4484
4485 shared_ptr<RendererPeriodPositionCallbackTest> positionCB2 = std::make_shared<RendererPeriodPositionCallbackTest>();
4486 ret = audioRenderer->SetRendererPeriodPositionCallback(VALUE_THOUSAND, positionCB2);
4487 EXPECT_EQ(SUCCESS, ret);
4488 }
4489
4490 /**
4491 * @tc.name : Test SetRendererPeriodPositionCallback API
4492 * @tc.number: Audio_Renderer_SetRendererPeriodPositionCallback_003
4493 * @tc.desc : Test SetRendererPeriodPositionCallback interface with null callback.
4494 */
4495 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPeriodPositionCallback_003, TestSize.Level1)
4496 {
4497 int32_t ret = -1;
4498
4499 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4500 ASSERT_NE(nullptr, audioRenderer);
4501
4502 ret = audioRenderer->SetRendererPeriodPositionCallback(VALUE_THOUSAND, nullptr);
4503 EXPECT_NE(SUCCESS, ret);
4504 }
4505
4506 /**
4507 * @tc.name : Test SetRendererPeriodPositionCallback API
4508 * @tc.number: Audio_Renderer_SetRendererPeriodPositionCallback_004
4509 * @tc.desc : Test SetRendererPeriodPositionCallback interface with invalid parameter.
4510 */
4511 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererPeriodPositionCallback_004, TestSize.Level1)
4512 {
4513 int32_t ret = -1;
4514
4515 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(STREAM_MUSIC);
4516 ASSERT_NE(nullptr, audioRenderer);
4517
4518 shared_ptr<RendererPeriodPositionCallbackTest> positionCB =
4519 std::make_shared<RendererPeriodPositionCallbackTest>();
4520 ret = audioRenderer->SetRendererPeriodPositionCallback(VALUE_ZERO, positionCB);
4521 EXPECT_NE(SUCCESS, ret);
4522
4523 ret = audioRenderer->SetRendererPeriodPositionCallback(VALUE_NEGATIVE, positionCB);
4524 EXPECT_NE(SUCCESS, ret);
4525 }
4526
4527 /**
4528 * @tc.name : Test max renderer instances.
4529 * @tc.number: Audio_Renderer_Max_Renderer_Instances_001
4530 * @tc.desc : Test creating maximum configured audio renderer instances.
4531 */
4532 HWTEST(AudioRendererUnitTest, Audio_Renderer_Max_Renderer_Instances_001, TestSize.Level1)
4533 {
4534 AudioRendererOptions rendererOptions;
4535 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
4536 vector<unique_ptr<AudioRenderer>> rendererList;
4537 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos = {};
4538 AudioPolicyManager::GetInstance().GetCurrentRendererChangeInfos(audioRendererChangeInfos);
4539 int32_t maxRendererInstances = 0;
4540 maxRendererInstances = AudioPolicyManager::GetInstance().GetMaxRendererInstances();
4541
4542 // Create renderer instance with the maximum number of configured instances
4543 while (audioRendererChangeInfos.size() < static_cast<size_t>(maxRendererInstances)) {
4544 auto audioRenderer = AudioRenderer::Create(rendererOptions);
4545 EXPECT_NE(nullptr, audioRenderer);
4546 rendererList.push_back(std::move(audioRenderer));
4547 audioRendererChangeInfos.clear();
4548 AudioPolicyManager::GetInstance().GetCurrentRendererChangeInfos(audioRendererChangeInfos);
4549 }
4550
4551 // When the number of renderer instances equals the number of configurations, creating another one should fail
4552 auto audioRenderer = AudioRenderer::Create(rendererOptions);
4553 EXPECT_EQ(nullptr, audioRenderer);
4554
4555 // Release a renderer and create one, which should be successfully created
4556 auto it = rendererList.begin();
4557 bool isReleased = (*it)->Release();
4558 EXPECT_EQ(true, isReleased);
4559 rendererList.erase(it);
4560 audioRenderer = AudioRenderer::Create(rendererOptions);
4561 EXPECT_NE(nullptr, audioRenderer);
4562
4563 for (auto it = rendererList.begin(); it != rendererList.end();) {
4564 bool isReleased = (*it)->Release();
4565 EXPECT_EQ(true, isReleased);
4566 it = rendererList.erase(it);
4567 }
4568 EXPECT_EQ(rendererList.size(), 0);
4569 }
4570
4571 /**
4572 * @tc.name : Test set renderer samplingrate.
4573 * @tc.number: Audio_Renderer_Set_Renderer_SamplingRate_001
4574 * @tc.desc : Test SetRendererSamplingRate and GetRendererSamplingRate.
4575 */
4576 HWTEST(AudioRendererUnitTest, Audio_Renderer_Set_Renderer_SamplingRate_001, TestSize.Level1)
4577 {
4578 int32_t ret = -1;
4579 AudioRendererOptions rendererOptions;
4580 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
4581 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4582 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
4583 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4584 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_SONIFICATION;
4585 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_VOICE_ASSISTANT;
4586 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4587
4588 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4589 ASSERT_NE(nullptr, audioRenderer);
4590
4591 uint32_t sampleRate = AudioSamplingRate::SAMPLE_RATE_48000;
4592 ret = audioRenderer->SetRendererSamplingRate(sampleRate);
4593 EXPECT_EQ(SUCCESS, ret);
4594
4595 uint32_t sampleRateRet = audioRenderer->GetRendererSamplingRate();
4596 EXPECT_EQ(sampleRate, sampleRateRet);
4597 audioRenderer->Release();
4598 }
4599
4600 /**
4601 * @tc.name : Test set renderer Interrupt.
4602 * @tc.number: Audio_Renderer_Set_Renderer_Interrupt_002
4603 * @tc.desc : Test AudioRendererInterruptCallbackImpl SaveCallback and OnInterrupt.
4604 */
4605 HWTEST(AudioRendererUnitTest, Audio_Renderer_Set_Renderer_Interrupt_002, TestSize.Level1)
4606 {
4607 shared_ptr<AudioRendererCallbackTest> audioRendererCB = make_shared<AudioRendererCallbackTest>();
4608 uint32_t invalidSessionID = static_cast<uint32_t>(-1);
4609 AudioInterrupt audioInterrupt = {STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN,
4610 {AudioStreamType::STREAM_DEFAULT, SourceType::SOURCE_TYPE_INVALID, true}, invalidSessionID};
4611 AppInfo appInfo_;
4612 if (!(appInfo_.appPid)) {
4613 appInfo_.appPid = getpid();
4614 }
4615
4616 if (appInfo_.appUid < 0) {
4617 appInfo_.appUid = static_cast<int32_t>(getuid());
4618 }
4619 const std::shared_ptr<AudioStream> audioStream_ = std::make_shared<AudioStream>(AudioStreamType::STREAM_MEDIA,
4620 AUDIO_MODE_PLAYBACK, appInfo_.appUid);
4621 ASSERT_NE(nullptr, audioStream_);
4622
4623 shared_ptr<AudioRendererInterruptCallbackImpl> interruptCallbackImpl =
4624 make_shared<AudioRendererInterruptCallbackImpl>(audioStream_, audioInterrupt);
4625 EXPECT_NE(nullptr, interruptCallbackImpl);
4626
4627 interruptCallbackImpl->SaveCallback(audioRendererCB);
4628
4629 InterruptEventInternal interruptEvent = {};
4630 interruptEvent.eventType = INTERRUPT_TYPE_END;
4631 interruptEvent.forceType = INTERRUPT_SHARE;
4632 interruptEvent.hintType = INTERRUPT_HINT_NONE;
4633 interruptEvent.duckVolume = 0;
4634 interruptCallbackImpl->OnInterrupt(interruptEvent);
4635
4636 interruptEvent.forceType = INTERRUPT_FORCE;
4637 interruptEvent.hintType = INTERRUPT_HINT_RESUME;
4638 interruptCallbackImpl->OnInterrupt(interruptEvent);
4639
4640 interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
4641 interruptCallbackImpl->OnInterrupt(interruptEvent);
4642
4643 interruptEvent.hintType = INTERRUPT_HINT_STOP;
4644 interruptCallbackImpl->OnInterrupt(interruptEvent);
4645
4646 interruptEvent.hintType = INTERRUPT_HINT_DUCK;
4647 interruptCallbackImpl->OnInterrupt(interruptEvent);
4648
4649 interruptEvent.duckVolume = 5;
4650 interruptCallbackImpl->OnInterrupt(interruptEvent);
4651
4652 interruptEvent.duckVolume = 15;
4653 interruptCallbackImpl->OnInterrupt(interruptEvent);
4654
4655 interruptEvent.hintType = INTERRUPT_HINT_UNDUCK;
4656 interruptCallbackImpl->OnInterrupt(interruptEvent);
4657
4658 interruptEvent.hintType = INTERRUPT_HINT_NONE;
4659 interruptCallbackImpl->OnInterrupt(interruptEvent);
4660
4661 EXPECT_EQ(interruptEvent.hintType, INTERRUPT_HINT_NONE);
4662 }
4663
4664 /**
4665 * @tc.name : Test set renderer instance.
4666 * @tc.number: Audio_Renderer_Set_Renderer_Instance_001
4667 * @tc.desc : Test renderer instance GetMinStreamVolume,GetMaxStreamVolume,GetCurrentOutputDevices,GetUnderflowCount
4668 */
4669 HWTEST(AudioRendererUnitTest, Audio_Renderer_Set_Renderer_Instance_001, TestSize.Level1)
4670 {
4671 int32_t ret = -1;
4672 AudioRendererOptions rendererOptions;
4673 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
4674 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4675 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
4676 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4677 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_SONIFICATION;
4678 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_VOICE_ASSISTANT;
4679 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4680
4681 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4682 ASSERT_NE(nullptr, audioRenderer);
4683
4684 float minVolume = audioRenderer->GetMinStreamVolume();
4685 float maxVolume = audioRenderer->GetMaxStreamVolume();
4686 EXPECT_LT(minVolume, maxVolume);
4687
4688 DeviceInfo deviceInfo;
4689 ret = audioRenderer->GetCurrentOutputDevices(deviceInfo);
4690 EXPECT_EQ(SUCCESS, ret);
4691
4692 float count = audioRenderer->GetUnderflowCount();
4693 EXPECT_GE(count, 0);
4694
4695 AppInfo appInfo = {};
4696 std::unique_ptr<AudioRendererPrivate> audioRendererPrivate =
4697 std::make_unique<AudioRendererPrivate>(AudioStreamType::STREAM_MEDIA, appInfo);
4698
4699 bool isDeviceChanged = audioRendererPrivate->IsDeviceChanged(deviceInfo);
4700 EXPECT_EQ(false, isDeviceChanged);
4701
4702 deviceInfo.deviceType = DEVICE_TYPE_EARPIECE;
4703 isDeviceChanged = audioRendererPrivate->IsDeviceChanged(deviceInfo);
4704 EXPECT_EQ(false, isDeviceChanged);
4705
4706 audioRenderer->Release();
4707 }
4708
4709 /**
4710 * @tc.name : Test set renderer instance.
4711 * @tc.number: Audio_Renderer_Set_Renderer_Instance_002
4712 * @tc.desc : Test renderer instance RegisterAudioRendererEventListener,DestroyAudioRendererStateCallback
4713 */
4714 HWTEST(AudioRendererUnitTest, Audio_Renderer_Set_Renderer_Instance_002, TestSize.Level1)
4715 {
4716 int32_t ret = -1;
4717 AudioRendererOptions rendererOptions;
4718 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
4719 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4720 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
4721 rendererOptions.streamInfo.channels = AudioChannel::MONO;
4722 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_SONIFICATION;
4723 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_VOICE_ASSISTANT;
4724 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4725
4726 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4727 ASSERT_NE(nullptr, audioRenderer);
4728
4729 int32_t clientPid = getpid();
4730 const std::shared_ptr<AudioRendererDeviceChangeCallback> callback =
4731 std::make_shared<AudioRendererDeviceChangeCallbackTest>();
4732 ret = audioRenderer->RegisterAudioRendererEventListener(clientPid, nullptr);
4733 EXPECT_EQ(ERR_INVALID_PARAM, ret);
4734 ret = audioRenderer->RegisterAudioRendererEventListener(clientPid, callback);
4735 EXPECT_EQ(SUCCESS, ret);
4736
4737 ret = audioRenderer->UnregisterAudioRendererEventListener(clientPid);
4738 EXPECT_EQ(SUCCESS, ret);
4739
4740 clientPid = -1;
4741 ret = audioRenderer->UnregisterAudioRendererEventListener(clientPid);
4742 EXPECT_EQ(SUCCESS, ret);
4743 audioRenderer->Release();
4744 }
4745
4746 /**
4747 * @tc.name : Test set renderer instance.
4748 * @tc.number: Audio_Renderer_Set_Renderer_Instance_003
4749 * @tc.desc : Test renderer instance RegisterAudioRendererEventListener,DestroyAudioRendererStateCallback
4750 */
4751 HWTEST(AudioRendererUnitTest, Audio_Renderer_Set_Renderer_Instance_003, TestSize.Level1)
4752 {
4753 int32_t ret = -1;
4754 AudioRendererOptions rendererOptions;
4755 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
4756 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4757 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
4758 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
4759 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_SONIFICATION;
4760 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_VOICE_ASSISTANT;
4761 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4762
4763 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4764 ASSERT_NE(nullptr, audioRenderer);
4765
4766 int32_t clientPid = getpid();
4767 const std::shared_ptr<AudioRendererPolicyServiceDiedCallback> serviceCallback =
4768 std::make_shared<AudioRendererPolicyServiceDiedCallbackTest>();
4769 ret = audioRenderer->RegisterAudioPolicyServerDiedCb(clientPid, serviceCallback);
4770 EXPECT_EQ(SUCCESS, ret);
4771
4772 ret = audioRenderer->RegisterAudioPolicyServerDiedCb(clientPid, nullptr);
4773 EXPECT_EQ(ERR_INVALID_PARAM, ret);
4774
4775 ret = audioRenderer->UnregisterAudioPolicyServerDiedCb(clientPid);
4776 EXPECT_EQ(SUCCESS, ret);
4777
4778 audioRenderer->Release();
4779 }
4780
4781 /**
4782 * @tc.name : Test set renderer instance.
4783 * @tc.number: Audio_Renderer_Set_Renderer_Instance_004
4784 * @tc.desc : Test SaveCallback and setAudioRendererObj on audioRendererStateChangeCallbackImpl
4785 */
4786 HWTEST(AudioRendererUnitTest, Audio_Renderer_Set_Renderer_Instance_004, TestSize.Level1)
4787 {
4788 int32_t ret = -1;
4789 AudioRendererOptions rendererOptions;
4790 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
4791 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
4792 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
4793 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
4794 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_SONIFICATION;
4795 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_VOICE_ASSISTANT;
4796 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
4797
4798 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4799 ASSERT_NE(nullptr, audioRenderer);
4800
4801 unique_ptr<AudioRendererStateChangeCallbackImpl> audioRendererStateChangeCallbackImpl =
4802 std::make_unique<AudioRendererStateChangeCallbackImpl>();
4803 std::weak_ptr<AudioRendererDeviceChangeCallback> callback =
4804 std::make_shared<AudioRendererDeviceChangeCallbackTest>();
4805 audioRendererStateChangeCallbackImpl->SaveCallback(callback);
4806
4807 AppInfo appInfo = {};
4808 std::unique_ptr<AudioRendererPrivate> audioRendererPrivate =
4809 std::make_unique<AudioRendererPrivate>(AudioStreamType::STREAM_MEDIA, appInfo);
4810
4811 audioRendererStateChangeCallbackImpl->setAudioRendererObj(audioRendererPrivate.get());
4812
4813 std::vector<std::unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
4814 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
4815 EXPECT_EQ(SUCCESS, ret);
4816 audioRendererStateChangeCallbackImpl->OnRendererStateChange(audioRendererChangeInfos);
4817 audioRenderer->Release();
4818 }
4819
4820 /**
4821 * @tc.name : Test set renderer instance.
4822 * @tc.number: Audio_Renderer_Set_Renderer_Instance_005
4823 * @tc.desc : Test ResumeStreamImpl and PausedStreamImpl on AudioRendererProxyObj
4824 */
4825 HWTEST(AudioRendererUnitTest, Audio_Renderer_Set_Renderer_Instance_005, TestSize.Level1)
4826 {
4827 AppInfo appInfo = {};
4828 std::unique_ptr<AudioRendererPrivate> audioRendererPrivate =
4829 std::make_unique<AudioRendererPrivate>(AudioStreamType::STREAM_MEDIA, appInfo);
4830
4831 unique_ptr<AudioRendererProxyObj> audioRendererProxyObj = std::make_unique<AudioRendererProxyObj>();
4832
4833 audioRendererProxyObj->SaveRendererObj(audioRendererPrivate.get());
4834 const StreamSetStateEventInternal streamSetStateEventInternal = {};
4835 audioRendererProxyObj->ResumeStreamImpl(streamSetStateEventInternal);
4836 audioRendererProxyObj->PausedStreamImpl(streamSetStateEventInternal);
4837 ASSERT_NE(nullptr, audioRendererPrivate);
4838 }
4839
4840 /**
4841 * @tc.name : Test SetAudioEffectMode via legal input, EFFECT_NONE
4842 * @tc.number: Audio_Renderer_SetAudioEffectMode_001
4843 * @tc.desc : Test SetAudioEffectMode interface. Returns SUCCESS, if the effect mode is successfully set.
4844 */
4845 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetAudioEffectMode_001, TestSize.Level1)
4846 {
4847 int32_t ret = -1;
4848 AudioRendererOptions rendererOptions;
4849
4850 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
4851 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4852 ASSERT_NE(nullptr, audioRenderer);
4853
4854 ret = audioRenderer->SetAudioEffectMode(EFFECT_NONE);
4855 EXPECT_EQ(SUCCESS, ret);
4856 audioRenderer->Release();
4857 }
4858
4859 /**
4860 * @tc.name : Test SetAudioEffectMode via legal input, EFFECT_DEFAULT
4861 * @tc.number: Audio_Renderer_SetAudioEffectMode_002
4862 * @tc.desc : Test SetAudioEffectMode interface. Returns SUCCESS, if the effect mode is successfully set.
4863 */
4864 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetAudioEffectMode_002, TestSize.Level1)
4865 {
4866 int32_t ret = -1;
4867 AudioRendererOptions rendererOptions;
4868
4869 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
4870 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4871 ASSERT_NE(nullptr, audioRenderer);
4872
4873 ret = audioRenderer->SetAudioEffectMode(EFFECT_DEFAULT);
4874 EXPECT_EQ(SUCCESS, ret);
4875 audioRenderer->Release();
4876 }
4877
4878 /**
4879 * @tc.name : Test GetAudioEffectMode with, EFFECT_NONE
4880 * @tc.number: Audio_Renderer_GetAudioEffectMode_001
4881 * @tc.desc : Test GetAudioEffectMode interface. Returns the current effect mode.
4882 */
4883 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioEffectMode_001, TestSize.Level1)
4884 {
4885 int32_t ret = -1;
4886 AudioRendererOptions rendererOptions;
4887
4888 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
4889 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4890 ASSERT_NE(nullptr, audioRenderer);
4891
4892 ret = audioRenderer->SetAudioEffectMode(EFFECT_NONE);
4893 EXPECT_EQ(SUCCESS, ret);
4894
4895 AudioEffectMode effectMode = audioRenderer->GetAudioEffectMode();
4896 EXPECT_EQ(EFFECT_NONE, effectMode);
4897 audioRenderer->Release();
4898 }
4899
4900 /**
4901 * @tc.name : Test GetAudioEffectMode with, EFFECT_DEFAULT
4902 * @tc.number: Audio_Renderer_GetAudioEffectMode_002
4903 * @tc.desc : Test GetAudioEffectMode interface. Returns the current effect mode.
4904 */
4905 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioEffectMode_002, TestSize.Level1)
4906 {
4907 int32_t ret = -1;
4908 AudioRendererOptions rendererOptions;
4909
4910 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
4911 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4912 ASSERT_NE(nullptr, audioRenderer);
4913
4914 ret = audioRenderer->SetAudioEffectMode(EFFECT_DEFAULT);
4915 EXPECT_EQ(SUCCESS, ret);
4916
4917 AudioEffectMode effectMode = audioRenderer->GetAudioEffectMode();
4918 EXPECT_EQ(EFFECT_DEFAULT, effectMode);
4919 audioRenderer->Release();
4920 }
4921
4922 /**
4923 * @tc.name : Test GetAudioEffectMode with, default effectMode
4924 * @tc.number: Audio_Renderer_GetAudioEffectMode_003
4925 * @tc.desc : Test GetAudioEffectMode interface. Returns the default effect mode EFFECT_DEFAULT.
4926 */
4927 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetAudioEffectMode_003, TestSize.Level1)
4928 {
4929 AudioRendererOptions rendererOptions;
4930
4931 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
4932 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4933 ASSERT_NE(nullptr, audioRenderer);
4934
4935 AudioEffectMode effectMode = audioRenderer->GetAudioEffectMode();
4936 EXPECT_EQ(EFFECT_DEFAULT, effectMode);
4937 audioRenderer->Release();
4938 }
4939
4940 /**
4941 * @tc.name : Test GetMinStreamVolume
4942 * @tc.number: Audio_Renderer_GetMinStreamVolume_001
4943 * @tc.desc : Test GetMinStreamVolume interface to get the min volume value.
4944 */
4945 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetMinStreamVolume_001, TestSize.Level1)
4946 {
4947 AudioRendererOptions rendererOptions;
4948
4949 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
4950 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4951 ASSERT_NE(nullptr, audioRenderer);
4952
4953 float volume = audioRenderer->GetMinStreamVolume();
4954 EXPECT_EQ(0.0, volume);
4955
4956 bool isReleased = audioRenderer->Release();
4957 EXPECT_EQ(true, isReleased);
4958 }
4959
4960 /**
4961 * @tc.name : Test GetMinStreamVolume
4962 * @tc.number: Audio_Renderer_GetMinStreamVolume_Stability_001
4963 * @tc.desc : Test GetMinStreamVolume interface to get the min volume value for 1000 times.
4964 */
4965 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetMinStreamVolume_Stability_001, TestSize.Level1)
4966 {
4967 AudioRendererOptions rendererOptions;
4968
4969 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
4970 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4971 ASSERT_NE(nullptr, audioRenderer);
4972
4973 for (int i = 0; i < VALUE_THOUSAND; i++) {
4974 float volume = audioRenderer->GetMinStreamVolume();
4975 EXPECT_EQ(0.0, volume);
4976 }
4977
4978 bool isReleased = audioRenderer->Release();
4979 EXPECT_EQ(true, isReleased);
4980 }
4981
4982 /**
4983 * @tc.name : Test GetMaxStreamVolume
4984 * @tc.number: Audio_Renderer_GetMaxStreamVolume_001
4985 * @tc.desc : Test GetMaxStreamVolume interface to get the max volume value.
4986 */
4987 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetMaxStreamVolume_001, TestSize.Level1)
4988 {
4989 AudioRendererOptions rendererOptions;
4990
4991 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
4992 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
4993 ASSERT_NE(nullptr, audioRenderer);
4994
4995 float volume = audioRenderer->GetMaxStreamVolume();
4996 EXPECT_EQ(1.0, volume);
4997
4998 bool isReleased = audioRenderer->Release();
4999 EXPECT_EQ(true, isReleased);
5000 }
5001
5002 /**
5003 * @tc.name : Test GetMaxStreamVolume
5004 * @tc.number: Audio_Renderer_GetMaxStreamVolume_Stability_001
5005 * @tc.desc : Test GetMaxStreamVolume interface to get the max volume value for 1000 times.
5006 */
5007 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetMaxStreamVolume_Stability_001, TestSize.Level1)
5008 {
5009 AudioRendererOptions rendererOptions;
5010
5011 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5012 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5013 ASSERT_NE(nullptr, audioRenderer);
5014
5015 for (int i = 0; i < VALUE_THOUSAND; i++) {
5016 float volume = audioRenderer->GetMaxStreamVolume();
5017 EXPECT_EQ(1.0, volume);
5018 }
5019
5020 bool isReleased = audioRenderer->Release();
5021 EXPECT_EQ(true, isReleased);
5022 }
5023
5024 /**
5025 * @tc.name : Test GetUnderflowCount
5026 * @tc.number: Audio_Renderer_GetUnderflowCount_001
5027 * @tc.desc : Test GetUnderflowCount interface get underflow value.
5028 */
5029 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetUnderflowCount_001, TestSize.Level1)
5030 {
5031 int32_t ret = -1;
5032 AudioRendererOptions rendererOptions;
5033
5034 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5035 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5036 ASSERT_NE(nullptr, audioRenderer);
5037
5038 ret = audioRenderer->GetUnderflowCount();
5039 EXPECT_GE(ret, SUCCESS);
5040
5041 audioRenderer->Release();
5042 }
5043
5044 /**
5045 * @tc.name : Test GetUnderflowCount
5046 * @tc.number: Audio_Renderer_GetUnderflowCount_Stability_001
5047 * @tc.desc : Test GetUnderflowCount interface get underflow value for 1000 times.
5048 */
5049 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetUnderflowCount_Stability_001, TestSize.Level1)
5050 {
5051 int32_t ret = -1;
5052 AudioRendererOptions rendererOptions;
5053
5054 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5055 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5056 ASSERT_NE(nullptr, audioRenderer);
5057
5058 for (int i = 0; i < VALUE_THOUSAND; i++) {
5059 ret = audioRenderer->GetUnderflowCount();
5060 EXPECT_GE(ret, SUCCESS);
5061 }
5062
5063 audioRenderer->Release();
5064 }
5065 /**
5066 * @tc.name : Test SetRendererSamplingRate
5067 * @tc.number: Audio_Renderer_SetRendererSamplingRate_001
5068 * @tc.desc : Test SetRendererSamplingRate interface for valid samplingRate.
5069 */
5070 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererSamplingRate_001, TestSize.Level1)
5071 {
5072 int32_t ret = -1;
5073 AudioRendererOptions rendererOptions;
5074
5075 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5076 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5077 ASSERT_NE(nullptr, audioRenderer);
5078
5079 uint32_t samplingRate = 44100;
5080 ret = audioRenderer->SetRendererSamplingRate(samplingRate);
5081 EXPECT_EQ(SUCCESS, ret);
5082 audioRenderer->Release();
5083 }
5084
5085 /**
5086 * @tc.name : Test SetRendererSamplingRate
5087 * @tc.number: Audio_Renderer_SetRendererSamplingRate_002
5088 * @tc.desc : Test SetRendererSamplingRate interface for invalid samplingRate.
5089 */
5090
5091
5092 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererSamplingRate_002, TestSize.Level1)
5093 {
5094 int32_t ret = -1;
5095 AudioRendererOptions rendererOptions;
5096
5097 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5098 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5099 ASSERT_NE(nullptr, audioRenderer);
5100
5101 uint32_t invalidRate_1 = 0;
5102 ret = audioRenderer->SetRendererSamplingRate(invalidRate_1);
5103 EXPECT_EQ(VALUE_INVALID, ret);
5104
5105 audioRenderer->Release();
5106 }
5107
5108 /**
5109 * @tc.name : Test SetRendererSamplingRate
5110 * @tc.number: Audio_Renderer_SetRendererSamplingRate_Stability_001
5111 * @tc.desc : Test SetRendererSamplingRate interface with valid samplingRate for 1000 times.
5112 */
5113 HWTEST(AudioRendererUnitTest, Audio_Renderer_SetRendererSamplingRate_Stability_001, TestSize.Level1)
5114 {
5115 int32_t ret = -1;
5116 AudioRendererOptions rendererOptions;
5117
5118 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5119 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5120 ASSERT_NE(nullptr, audioRenderer);
5121
5122 uint32_t samplingRate = 44100;
5123
5124 for (int i = 0; i < VALUE_THOUSAND; i++) {
5125 ret = audioRenderer->SetRendererSamplingRate(samplingRate);
5126 EXPECT_EQ(SUCCESS, ret);
5127 }
5128
5129 audioRenderer->Release();
5130 }
5131
5132 /**
5133 * @tc.name : Test GetRendererSamplingRate
5134 * @tc.number: Audio_Renderer_GetRendererSamplingRate_001
5135 * @tc.desc : Test GetRendererSamplingRate get default samplingRate.
5136 */
5137 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRendererSamplingRate_001, TestSize.Level1)
5138 {
5139 AudioRendererOptions rendererOptions;
5140
5141 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5142 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5143 ASSERT_NE(nullptr, audioRenderer);
5144
5145 uint32_t ret = audioRenderer->GetRendererSamplingRate();
5146 EXPECT_EQ(SAMPLE_RATE_44100, ret);
5147 audioRenderer->Release();
5148 }
5149
5150 /**
5151 * @tc.name : Test GetRendererSamplingRate
5152 * @tc.number: Audio_Renderer_GetRendererSamplingRate_002
5153 * @tc.desc : Test GetRendererSamplingRate get valid samplingRate after set valid samplingRate.
5154 */
5155 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRendererSamplingRate_002, TestSize.Level1)
5156 {
5157 int32_t ret = -1;
5158 AudioRendererOptions rendererOptions;
5159
5160 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5161 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5162 ASSERT_NE(nullptr, audioRenderer);
5163
5164 uint32_t samplingRate = 48000;
5165 ret = audioRenderer->SetRendererSamplingRate(samplingRate);
5166 EXPECT_EQ(SUCCESS, ret);
5167
5168 uint32_t retSamplerate = audioRenderer->GetRendererSamplingRate();
5169 EXPECT_EQ(samplingRate, retSamplerate);
5170 audioRenderer->Release();
5171 }
5172
5173 /**
5174 * @tc.name : Test GetRendererSamplingRate
5175 * @tc.number: Audio_Renderer_GetRendererSamplingRate_003
5176 * @tc.desc : Test GetRendererSamplingRate get default samplingRate after set invalid samplingRate.
5177 */
5178
5179 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRendererSamplingRate_003, TestSize.Level1)
5180 {
5181 int32_t ret = -1;
5182 AudioRendererOptions rendererOptions;
5183
5184 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5185 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5186 ASSERT_NE(nullptr, audioRenderer);
5187
5188 uint32_t samplingRate = 0;
5189 ret = audioRenderer->SetRendererSamplingRate(samplingRate);
5190 EXPECT_EQ(VALUE_INVALID, ret);
5191
5192 uint32_t retSamplerate = audioRenderer->GetRendererSamplingRate();
5193 EXPECT_EQ(SAMPLE_RATE_44100, retSamplerate);
5194 audioRenderer->Release();
5195 }
5196
5197 /**
5198 * @tc.name : Test GetRendererSamplingRate
5199 * @tc.number: Audio_Renderer_GetRendererSamplingRate_004
5200 * @tc.desc : Test GetRendererSamplingRate get valid samplingRate after set invalid samplingRate.
5201 */
5202
5203 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRendererSamplingRate_004, TestSize.Level1)
5204 {
5205 int32_t ret = -1;
5206 AudioRendererOptions rendererOptions;
5207
5208 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5209 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5210 ASSERT_NE(nullptr, audioRenderer);
5211
5212 uint32_t validRate = 48000;
5213 ret = audioRenderer->SetRendererSamplingRate(validRate);
5214 EXPECT_EQ(SUCCESS, ret);
5215
5216 uint32_t invalidRate = 0;
5217 ret = audioRenderer->SetRendererSamplingRate(invalidRate);
5218 EXPECT_EQ(VALUE_INVALID, ret);
5219
5220 uint32_t retSampleRate = audioRenderer->GetRendererSamplingRate();
5221 EXPECT_EQ(validRate, retSampleRate);
5222 audioRenderer->Release();
5223 }
5224
5225 /**
5226 * @tc.name : Test GetRendererSamplingRate
5227 * @tc.number: Audio_Renderer_GetRendererSamplingRate_Stability_001
5228 * @tc.desc : Test GetRendererSamplingRate get valid samplingRate 1000 times after set valid samplingRate.
5229 */
5230 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetRendererSamplingRate_Stability_001, TestSize.Level1)
5231 {
5232 int32_t ret = -1;
5233 AudioRendererOptions rendererOptions;
5234
5235 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5236 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5237 ASSERT_NE(nullptr, audioRenderer);
5238
5239 for (int i = 0; i < VALUE_THOUSAND; i++) {
5240 uint32_t samplingRate = 48000;
5241 ret = audioRenderer->SetRendererSamplingRate(samplingRate);
5242 EXPECT_EQ(SUCCESS, ret);
5243
5244 uint32_t retSampleRate = audioRenderer->GetRendererSamplingRate();
5245 EXPECT_EQ(samplingRate, retSampleRate);
5246 }
5247
5248 audioRenderer->Release();
5249 }
5250
5251 /**
5252 * @tc.name : Test RegisterAudioRendererEventListener via legal state
5253 * @tc.number: Audio_Renderer_RegisterAudioRendererEventListener_001
5254 * @tc.desc : Test registerAudioRendererEventListener interface. Returns success.
5255 */
5256 HWTEST(AudioRendererUnitTest, Audio_Renderer_RegisterAudioRendererEventListener_001, TestSize.Level1)
5257 {
5258 AudioRendererOptions rendererOptions;
5259
5260 int32_t clientId = getpid();
5261 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5262 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5263 ASSERT_NE(nullptr, audioRenderer);
5264
5265 shared_ptr<AudioRendererDeviceChangeCallbackTest> callback =
5266 make_shared<AudioRendererDeviceChangeCallbackTest>();
5267 int32_t ret = audioRenderer->RegisterAudioRendererEventListener(clientId, callback);
5268 EXPECT_EQ(SUCCESS, ret);
5269
5270 ret = audioRenderer->UnregisterAudioRendererEventListener(clientId);
5271 EXPECT_EQ(SUCCESS, ret);
5272 }
5273
5274 /**
5275 * @tc.name : Test RegisterAudioRendererEventListener via legal state
5276 * @tc.number: Audio_Renderer_RegisterAudioRendererEventListener_002
5277 * @tc.desc : Test registerAudioRendererEventListener interface. Returns ERR_INVALID_PARAM.
5278 */
5279 HWTEST(AudioRendererUnitTest, Audio_Renderer_RegisterAudioRendererEventListener_002, TestSize.Level1)
5280 {
5281 AudioRendererOptions rendererOptions;
5282
5283 int32_t clientId = getpid();
5284 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5285 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5286 ASSERT_NE(nullptr, audioRenderer);
5287
5288 int32_t ret = audioRenderer->RegisterAudioRendererEventListener(clientId, nullptr);
5289 EXPECT_EQ(VALUE_ERROR, ret);
5290 }
5291
5292 /**
5293 * @tc.name : Test RegisterAudioRendererEventListener via legal state
5294 * @tc.number: Audio_Renderer_RegisterAudioRendererEventListener_Stability_001
5295 * @tc.desc : Test registerAudioRendererEventListener interface valid callback 1000 times.
5296 */
5297 HWTEST(AudioRendererUnitTest, Audio_Renderer_RegisterAudioRendererEventListener_Stability_001, TestSize.Level1)
5298 {
5299 AudioRendererOptions rendererOptions;
5300
5301 int32_t clientId = getpid();
5302 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5303 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5304 ASSERT_NE(nullptr, audioRenderer);
5305 for (int i = 0; i < VALUE_THOUSAND; i++) {
5306 shared_ptr<AudioRendererDeviceChangeCallbackTest> callback =
5307 make_shared<AudioRendererDeviceChangeCallbackTest>();
5308 int32_t ret = audioRenderer->RegisterAudioRendererEventListener(clientId, callback);
5309 EXPECT_EQ(SUCCESS, ret);
5310
5311 ret = audioRenderer->UnregisterAudioRendererEventListener(clientId);
5312 EXPECT_EQ(SUCCESS, ret);
5313 }
5314 }
5315
5316 /**
5317 * @tc.name : Test RegisterAudioRendererEventListener via legal state
5318 * @tc.number: Audio_Renderer_RegisterAudioRendererEventListener_Stability_002
5319 * @tc.desc : Test registerAudioRendererEventListener interface valid callback 1000 times.
5320 */
5321 HWTEST(AudioRendererUnitTest, Audio_Renderer_RegisterAudioRendererEventListener_Stability_002, TestSize.Level1)
5322 {
5323 AudioRendererOptions rendererOptions;
5324
5325 int32_t clientId = getpid();
5326 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5327 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5328 ASSERT_NE(nullptr, audioRenderer);
5329 for (int i = 0; i < VALUE_THOUSAND; i++) {
5330 int32_t ret = audioRenderer->RegisterAudioRendererEventListener(clientId, nullptr);
5331 EXPECT_EQ(VALUE_ERROR, ret);
5332 }
5333 }
5334
5335 /**
5336 * @tc.name : Test UnregisterAudioRendererEventListener via legal state
5337 * @tc.number: Audio_Renderer_UnregisterAudioRendererEventListener_001
5338 * @tc.desc : Test UnregisterAudioRendererEventListener interface. Returns success.
5339 */
5340 HWTEST(AudioRendererUnitTest, Audio_Renderer_UnregisterAudioRendererEventListener_001, TestSize.Level1)
5341 {
5342 AudioRendererOptions rendererOptions;
5343
5344 int32_t clientId = getpid();
5345 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5346 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5347 ASSERT_NE(nullptr, audioRenderer);
5348
5349 shared_ptr<AudioRendererDeviceChangeCallbackTest> callback =
5350 make_shared<AudioRendererDeviceChangeCallbackTest>();
5351 int32_t ret = audioRenderer->RegisterAudioRendererEventListener(clientId, callback);
5352 EXPECT_EQ(SUCCESS, ret);
5353
5354 ret = audioRenderer->UnregisterAudioRendererEventListener(clientId);
5355 EXPECT_EQ(SUCCESS, ret);
5356 }
5357
5358
5359 /**
5360 * @tc.name : Test UnregisterAudioRendererEventListener via legal state
5361 * @tc.number: Audio_Renderer_UnregisterAudioRendererEventListener_Stability_00
5362 * @tc.desc : Test UnregisterAudioRendererEventListener interface valid callback 1000 times.
5363 */
5364 HWTEST(AudioRendererUnitTest, Audio_Renderer_UnregisterAudioRendererEventListener_Stability_001, TestSize.Level1)
5365 {
5366 AudioRendererOptions rendererOptions;
5367
5368 int32_t clientId = getpid();
5369 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5370 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5371 ASSERT_NE(nullptr, audioRenderer);
5372 for (int i = 0; i < VALUE_THOUSAND; i++) {
5373 shared_ptr<AudioRendererDeviceChangeCallbackTest> callback =
5374 make_shared<AudioRendererDeviceChangeCallbackTest>();
5375 int32_t ret = audioRenderer->RegisterAudioRendererEventListener(clientId, callback);
5376 EXPECT_EQ(SUCCESS, ret);
5377
5378 ret = audioRenderer->UnregisterAudioRendererEventListener(clientId);
5379 EXPECT_EQ(SUCCESS, ret);
5380 }
5381 }
5382
5383 /**
5384 * @tc.name : Test RegisterAudioPolicyServerDiedCb via legal state
5385 * @tc.number: Audio_Renderer_RegisterAudioPolicyServerDiedCb_001
5386 * @tc.desc : Test registerAudioRendererEventListener interface. Returns success.
5387 */
5388 HWTEST(AudioRendererUnitTest, Audio_Renderer_RegisterAudioPolicyServerDiedCb_001, TestSize.Level1)
5389 {
5390 AudioRendererOptions rendererOptions;
5391
5392 int32_t clientId = getpid();
5393 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5394 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5395 ASSERT_NE(nullptr, audioRenderer);
5396
5397 shared_ptr<AudioRendererPolicyServiceDiedCallbackTest> callback =
5398 make_shared<AudioRendererPolicyServiceDiedCallbackTest>();
5399 int32_t ret = audioRenderer->RegisterAudioPolicyServerDiedCb(clientId, callback);
5400 EXPECT_EQ(SUCCESS, ret);
5401
5402 ret = audioRenderer->UnregisterAudioPolicyServerDiedCb(clientId);
5403 EXPECT_EQ(SUCCESS, ret);
5404 }
5405
5406 /**
5407 * @tc.name : Test RegisterAudioPolicyServerDiedCb via legal state
5408 * @tc.number: Audio_Renderer_RegisterAudioPolicyServerDiedCb_002
5409 * @tc.desc : Test registerAudioRendererEventListener interface. Returns ERR_INVALID_PARAM.
5410 */
5411 HWTEST(AudioRendererUnitTest, Audio_Renderer_RegisterAudioPolicyServerDiedCb_002, TestSize.Level1)
5412 {
5413 AudioRendererOptions rendererOptions;
5414
5415 int32_t clientId = getpid();
5416 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5417 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5418 ASSERT_NE(nullptr, audioRenderer);
5419
5420 int32_t ret = audioRenderer->RegisterAudioPolicyServerDiedCb(clientId, nullptr);
5421 EXPECT_EQ(VALUE_ERROR, ret);
5422 }
5423
5424 /**
5425 * @tc.name : Test RegisterAudioPolicyServerDiedCb via legal state
5426 * @tc.number: Audio_Renderer_RegisterAudioPolicyServerDiedCb_Stability_001
5427 * @tc.desc : Test registerAudioRendererEventListener interface valid callback 1000 times.
5428 */
5429 HWTEST(AudioRendererUnitTest, Audio_Renderer_RegisterAudioPolicyServerDiedCb_Stability_001, TestSize.Level1)
5430 {
5431 AudioRendererOptions rendererOptions;
5432
5433 int32_t clientId = getpid();
5434 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5435 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5436 ASSERT_NE(nullptr, audioRenderer);
5437 for (int i = 0; i < VALUE_THOUSAND; i++) {
5438 shared_ptr<AudioRendererPolicyServiceDiedCallbackTest> callback =
5439 make_shared<AudioRendererPolicyServiceDiedCallbackTest>();
5440 int32_t ret = audioRenderer->RegisterAudioPolicyServerDiedCb(clientId, callback);
5441 EXPECT_EQ(SUCCESS, ret);
5442
5443 ret = audioRenderer->UnregisterAudioPolicyServerDiedCb(clientId);
5444 EXPECT_EQ(SUCCESS, ret);
5445 }
5446 }
5447
5448 /**
5449 * @tc.name : Test RegisterAudioPolicyServerDiedCb via legal state
5450 * @tc.number: Audio_Renderer_RegisterAudioPolicyServerDiedCb_002
5451 * @tc.desc : Test registerAudioRendererEventListener interface invalid callback 1000 times.
5452 */
5453 HWTEST(AudioRendererUnitTest, Audio_Renderer_RegisterAudioPolicyServerDiedCb_Stability_002, TestSize.Level1)
5454 {
5455 AudioRendererOptions rendererOptions;
5456
5457 int32_t clientId = getpid();
5458 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5459 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5460 ASSERT_NE(nullptr, audioRenderer);
5461 for (int i = 0; i < VALUE_THOUSAND; i++) {
5462 int32_t ret = audioRenderer->RegisterAudioPolicyServerDiedCb(clientId, nullptr);
5463 EXPECT_EQ(VALUE_ERROR, ret);
5464 }
5465 }
5466
5467 /**
5468 * @tc.name : Test UnregisterAudioPolicyServerDiedCb via legal state
5469 * @tc.number: Audio_Renderer_UnregisterAudioPolicyServerDiedCb_001
5470 * @tc.desc : Test UnregisterAudioPolicyServerDiedCb interface. Returns success.
5471 */
5472 HWTEST(AudioRendererUnitTest, Audio_Renderer_UnregisterAudioPolicyServerDiedCb_001, TestSize.Level1)
5473 {
5474 AudioRendererOptions rendererOptions;
5475
5476 int32_t clientId = getpid();
5477 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5478 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5479 ASSERT_NE(nullptr, audioRenderer);
5480
5481 shared_ptr<AudioRendererPolicyServiceDiedCallbackTest> callback =
5482 make_shared<AudioRendererPolicyServiceDiedCallbackTest>();
5483 int32_t ret = audioRenderer->RegisterAudioPolicyServerDiedCb(clientId, callback);
5484 EXPECT_EQ(SUCCESS, ret);
5485
5486 ret = audioRenderer->UnregisterAudioPolicyServerDiedCb(clientId);
5487 EXPECT_EQ(SUCCESS, ret);
5488 }
5489
5490 /**
5491 * @tc.name : Test UnregisterAudioPolicyServerDiedCb via legal state
5492 * @tc.number: Audio_Renderer_UnregisterAudioPolicyServerDiedCb_Stability_001
5493 * @tc.desc : Test UnregisterAudioPolicyServerDiedCb interface valid callback 1000 times.
5494 */
5495 HWTEST(AudioRendererUnitTest, Audio_Renderer_UnregisterAudioPolicyServerDiedCb_Stability_001, TestSize.Level1)
5496 {
5497 AudioRendererOptions rendererOptions;
5498
5499 int32_t clientId = getpid();
5500 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5501 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5502 ASSERT_NE(nullptr, audioRenderer);
5503 for (int i = 0; i < VALUE_THOUSAND; i++) {
5504 shared_ptr<AudioRendererPolicyServiceDiedCallbackTest> callback =
5505 make_shared<AudioRendererPolicyServiceDiedCallbackTest>();
5506 int32_t ret = audioRenderer->RegisterAudioPolicyServerDiedCb(clientId, callback);
5507 EXPECT_EQ(SUCCESS, ret);
5508
5509 ret = audioRenderer->UnregisterAudioPolicyServerDiedCb(clientId);
5510 EXPECT_EQ(SUCCESS, ret);
5511 }
5512 }
5513
5514 /**
5515 * @tc.name : Test GetCurrentOutputDevices API after calling create
5516 * @tc.number: Audio_Renderer_GetCurrentOutputDevices_001
5517 * @tc.desc : Test GetCurrentOutputDevices interface. Check whether renderer info returns proper data
5518 */
5519 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetCurrentOutputDevices_001, TestSize.Level1)
5520 {
5521 int32_t ret = -1;
5522 AudioRendererOptions rendererOptions;
5523
5524 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5525 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5526 EXPECT_NE(nullptr, audioRenderer);
5527
5528 DeviceInfo deviceInfo;
5529 ret = audioRenderer->GetCurrentOutputDevices(deviceInfo);
5530 EXPECT_EQ(SUCCESS, ret);
5531
5532 audioRenderer->Release();
5533 }
5534
5535 /**
5536 * @tc.name : Test GetCurrentOutputDevices API after calling create
5537 * @tc.number: Audio_Renderer_GetCurrentOutputDevices_002
5538 * @tc.desc : Test GetCurrentOutputDevices interface.Check the deviceinfo is proper data when using speaker.
5539 */
5540 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetCurrentOutputDevices_002, TestSize.Level1)
5541 {
5542 AudioRendererOptions rendererOptions;
5543
5544 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5545 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5546 EXPECT_NE(nullptr, audioRenderer);
5547
5548 DeviceInfo deviceInfo;
5549 audioRenderer->GetCurrentOutputDevices(deviceInfo);
5550
5551 EXPECT_EQ(OUTPUT_DEVICE, deviceInfo.deviceRole);
5552 EXPECT_EQ(DEVICE_TYPE_SPEAKER, deviceInfo.deviceType);
5553
5554 audioRenderer->Release();
5555 }
5556
5557 /**
5558 * @tc.name : Test GetCurrentOutputDevices API after calling create
5559 * @tc.number: Audio_Renderer_GetCurrentOutputDevices_001
5560 * @tc.desc : Test GetCurrentOutputDevices interface check if it is success for 1000 times
5561 */
5562 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetCurrentOutputDevices_Stability_001, TestSize.Level1)
5563 {
5564 int32_t ret = -1;
5565 AudioRendererOptions rendererOptions;
5566
5567 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5568 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5569 EXPECT_NE(nullptr, audioRenderer);
5570
5571 for (int i = 0; i < VALUE_THOUSAND; i++) {
5572 DeviceInfo deviceInfo;
5573 ret = audioRenderer->GetCurrentOutputDevices(deviceInfo);
5574 EXPECT_EQ(SUCCESS, ret);
5575 }
5576
5577 audioRenderer->Release();
5578 }
5579
5580 /**
5581 * @tc.name : Test GetCurrentOutputDevices API after calling create
5582 * @tc.number: Audio_Renderer_GetCurrentOutputDevices_001
5583 * @tc.desc : Test GetCurrentOutputDevices interface check proper data when using speaker for 1000 times
5584 */
5585 HWTEST(AudioRendererUnitTest, Audio_Renderer_GetCurrentOutputDevices_Stability_002, TestSize.Level1)
5586 {
5587 AudioRendererOptions rendererOptions;
5588
5589 AudioRendererUnitTest::InitializeRendererOptions(rendererOptions);
5590 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
5591 EXPECT_NE(nullptr, audioRenderer);
5592
5593 for (int i = 0; i < VALUE_THOUSAND; i++) {
5594 DeviceInfo deviceInfo;
5595 audioRenderer->GetCurrentOutputDevices(deviceInfo);
5596
5597 EXPECT_EQ(OUTPUT_DEVICE, deviceInfo.deviceRole);
5598 EXPECT_EQ(DEVICE_TYPE_SPEAKER, deviceInfo.deviceType);
5599 }
5600
5601 audioRenderer->Release();
5602 }
5603 } // namespace AudioStandard
5604 } // namespace OHOS