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