1 /*
2 * Copyright (c) 2023 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 <thread>
17 #include <chrono>
18 #include "oh_audio_render_unit_test.h"
19
20 using namespace testing::ext;
21 using namespace std::chrono;
22
23 namespace {
24 constexpr int32_t SAMPLE_RATE_48000 = 48000;
25 constexpr int32_t CHANNEL_2 = 2;
26 }
27
28 namespace OHOS {
29 namespace AudioStandard {
30
SetUpTestCase(void)31 void OHAudioRenderUnitTest::SetUpTestCase(void) { }
32
TearDownTestCase(void)33 void OHAudioRenderUnitTest::TearDownTestCase(void) { }
34
SetUp(void)35 void OHAudioRenderUnitTest::SetUp(void) { }
36
TearDown(void)37 void OHAudioRenderUnitTest::TearDown(void) { }
38
39 const int32_t SAMPLING_RATE = 48000; // 48000:SAMPLING_RATE value
40 const int32_t CHANNEL_COUNT = 2; // 2:CHANNEL_COUNT value
41 const int32_t LATENCY_FORMAT = 0;
42 const int32_t SAMPLE_FORMAT = 1;
43 const int32_t FRAME_SIZE = 240; // 240:FRAME_SIZE value
44 uint32_t g_flag = 0;
45 const float MAX_AUDIO_VOLUME = 1.0f; // volume range is between 0 to 1.
46 const float MIN_AUDIO_VOLUME = 0.0f; // volume range is between 0 to 1.
47 const int32_t DURATIONMS = 40; // 40:fade out latency ms
48
AudioRendererOnWriteData(OH_AudioRenderer * capturer,void * userData,void * buffer,int32_t bufferLen)49 static int32_t AudioRendererOnWriteData(OH_AudioRenderer* capturer,
50 void* userData,
51 void* buffer,
52 int32_t bufferLen)
53 {
54 return 0;
55 }
56
AudioRendererOnMarkReachedCb(OH_AudioRenderer * renderer,uint32_t samplePos,void * userData)57 static void AudioRendererOnMarkReachedCb(OH_AudioRenderer* renderer, uint32_t samplePos, void* userData)
58 {
59 g_flag = samplePos;
60 printf("AudioRendererOnMarkReachedCb samplePos: %d \n", samplePos);
61 }
62
63 class OHAudioRendererWriteCallbackMock {
64 public:
OnWriteData(OH_AudioRenderer * renderer,void * userData,void * buffer,int32_t bufferLen)65 void OnWriteData(OH_AudioRenderer* renderer, void* userData,
66 void* buffer,
67 int32_t bufferLen)
68 {
69 exeCount_++;
70 if (executor_) {
71 executor_(renderer, userData, buffer, bufferLen);
72 }
73 }
74
Install(std::function<void (OH_AudioRenderer *,void *,void *,int32_t)> executor)75 void Install(std::function<void(OH_AudioRenderer*, void*, void*, int32_t)> executor)
76 {
77 executor_ = executor;
78 }
79
GetExeCount()80 uint32_t GetExeCount()
81 {
82 return exeCount_;
83 }
84 private:
85 std::function<void(OH_AudioRenderer*, void*, void*, int32_t)> executor_;
86 std::atomic<uint32_t> exeCount_ = 0;
87 };
88
AudioRendererOnWriteDataMock(OH_AudioRenderer * renderer,void * userData,void * buffer,int32_t bufferLen)89 static int32_t AudioRendererOnWriteDataMock(OH_AudioRenderer* renderer,
90 void* userData,
91 void* buffer,
92 int32_t bufferLen)
93 {
94 OHAudioRendererWriteCallbackMock *mockPtr = static_cast<OHAudioRendererWriteCallbackMock*>(userData);
95 mockPtr->OnWriteData(renderer, userData, buffer, bufferLen);
96
97 return 0;
98 }
99
OnWriteDataCallbackWithValidData(OH_AudioRenderer * renderer,void * userData,void * buffer,int32_t bufferLen)100 static OH_AudioData_Callback_Result OnWriteDataCallbackWithValidData(OH_AudioRenderer* renderer,
101 void* userData,
102 void* buffer,
103 int32_t bufferLen)
104 {
105 return AUDIO_DATA_CALLBACK_RESULT_VALID;
106 }
107
OnWriteDataCallbackWithInvalidData(OH_AudioRenderer * renderer,void * userData,void * buffer,int32_t bufferLen)108 static OH_AudioData_Callback_Result OnWriteDataCallbackWithInvalidData(OH_AudioRenderer* renderer,
109 void* userData,
110 void* buffer,
111 int32_t bufferLen)
112 {
113 return AUDIO_DATA_CALLBACK_RESULT_INVALID;
114 }
115
116 struct UserData {
117 public:
118 enum {
119 WRITE_DATA_CALLBACK,
120
121 WRITE_DATA_CALLBACK_WITH_RESULT
122 } writeDataCallbackType;
123 };
124
OnWriteDataCbMock(OH_AudioRenderer * renderer,void * userData,void * buffer,int32_t bufferLer)125 static int32_t OnWriteDataCbMock(OH_AudioRenderer* renderer,
126 void* userData,
127 void* buffer,
128 int32_t bufferLer)
129 {
130 UserData *u = static_cast<UserData*>(userData);
131 u->writeDataCallbackType = UserData::WRITE_DATA_CALLBACK;
132 return 0;
133 }
134
OnWriteDataCbWithValidDataMock(OH_AudioRenderer * renderer,void * userData,void * buffer,int32_t bufferLen)135 static OH_AudioData_Callback_Result OnWriteDataCbWithValidDataMock(OH_AudioRenderer* renderer,
136 void* userData,
137 void* buffer,
138 int32_t bufferLen)
139 {
140 UserData *u = static_cast<UserData*>(userData);
141 u->writeDataCallbackType = UserData::WRITE_DATA_CALLBACK_WITH_RESULT;
142 return AUDIO_DATA_CALLBACK_RESULT_VALID;
143 }
144
OnWriteDataCbWithInvalidDataMock(OH_AudioRenderer * renderer,void * userData,void * buffer,int32_t bufferLen)145 static OH_AudioData_Callback_Result OnWriteDataCbWithInvalidDataMock(OH_AudioRenderer* renderer,
146 void* userData,
147 void* buffer,
148 int32_t bufferLen)
149 {
150 UserData *u = static_cast<UserData*>(userData);
151 u->writeDataCallbackType = UserData::WRITE_DATA_CALLBACK_WITH_RESULT;
152 return AUDIO_DATA_CALLBACK_RESULT_INVALID;
153 }
154
CreateRenderBuilder()155 OH_AudioStreamBuilder* OHAudioRenderUnitTest::CreateRenderBuilder()
156 {
157 OH_AudioStreamBuilder* builder;
158 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_RENDERER;
159 OH_AudioStreamBuilder_Create(&builder, type);
160 return builder;
161 }
162
InitRenderBuilder()163 OH_AudioStreamBuilder* InitRenderBuilder()
164 {
165 // create builder
166 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
167
168 // set params and callbacks
169 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLING_RATE);
170 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_COUNT);
171 OH_AudioStreamBuilder_SetLatencyMode(builder, (OH_AudioStream_LatencyMode)LATENCY_FORMAT);
172 OH_AudioStreamBuilder_SetSampleFormat(builder, (OH_AudioStream_SampleFormat)SAMPLE_FORMAT);
173 OH_AudioStreamBuilder_SetFrameSizeInCallback(builder, FRAME_SIZE);
174
175 return builder;
176 }
177
CleanupAudioResources(OH_AudioStreamBuilder * builder,OH_AudioRenderer * audioRenderer)178 void CleanupAudioResources(OH_AudioStreamBuilder* builder, OH_AudioRenderer* audioRenderer)
179 {
180 // stop and release client
181 OH_AudioStream_Result result = OH_AudioRenderer_Stop(audioRenderer);
182 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
183 result = OH_AudioRenderer_Release(audioRenderer);
184 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
185
186 // destroy the builder
187 OH_AudioStreamBuilder_Destroy(builder);
188 }
189
190 /**
191 * @tc.name : Test OH_AudioStreamBuilder_GenerateRenderer API via legal state.
192 * @tc.number: OH_Audio_Capture_Generate_001
193 * @tc.desc : Test OH_AudioStreamBuilder_GenerateRenderer interface. Returns true, if the result is successful.
194 */
195 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_Generate_001, TestSize.Level0)
196 {
197 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
198
199 OH_AudioRenderer* audioRenderer;
200 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
201 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
202
203 OH_AudioStreamBuilder_Destroy(builder);
204 }
205
206 /**
207 * @tc.name : Test OH_AudioStreamBuilder_GenerateRenderer API via illegal OH_AudioStream_Type.
208 * @tc.number: OH_Audio_Render_Generate_002
209 * @tc.desc : Test OH_AudioStreamBuilder_GenerateRenderer interface. Returns error code, if the stream type is
210 * AUDIOSTREAM_TYPE_CAPTURER.
211 */
212 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_Generate_002, TestSize.Level0)
213 {
214 OH_AudioStreamBuilder* builder;
215 OH_AudioStream_Type type = AUDIOSTREAM_TYPE_CAPTURER;
216 OH_AudioStream_Result result = OH_AudioStreamBuilder_Create(&builder, type);
217 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
218
219 OH_AudioRenderer* audioRenderer;
220 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
221 EXPECT_TRUE(result == AUDIOSTREAM_ERROR_INVALID_PARAM);
222 }
223
224 /**
225 * @tc.name : Test OH_AudioRenderer_Start API via legal state.
226 * @tc.number: Audio_Capturer_Start_001
227 * @tc.desc : Test OH_AudioRenderer_Start interface. Returns true if start is successful.
228 */
229 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_Start_001, TestSize.Level0)
230 {
231 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
232
233 OH_AudioRenderer* audioRenderer;
234 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
235
236 result = OH_AudioRenderer_Start(audioRenderer);
237 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
238
239 OH_AudioRenderer_Release(audioRenderer);
240 OH_AudioStreamBuilder_Destroy(builder);
241 }
242
243 /**
244 * @tc.name : Test OH_AudioRenderer_Start API via illegal state.
245 * @tc.number: Audio_Capturer_Start_002
246 * @tc.desc : Test OH_AudioRenderer_Start interface. Returns error code, if Start interface is called twice.
247 */
248 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_Start_002, TestSize.Level0)
249 {
250 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
251
252 OH_AudioRenderer* audioRenderer;
253 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
254
255 result = OH_AudioRenderer_Start(audioRenderer);
256
257 result = OH_AudioRenderer_Start(audioRenderer);
258 EXPECT_TRUE(result == AUDIOSTREAM_ERROR_ILLEGAL_STATE);
259
260 OH_AudioRenderer_Release(audioRenderer);
261 OH_AudioStreamBuilder_Destroy(builder);
262 }
263
264 /**
265 * @tc.name : Test OH_AudioRenderer_Pause API via legal state.
266 * @tc.number: OH_Audio_Render_Pause_001
267 * @tc.desc : Test OH_AudioRenderer_Pause interface. Returns true if Pause is successful.
268 */
269 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_Pause_001, TestSize.Level0)
270 {
271 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
272
273 OH_AudioRenderer* audioRenderer;
274 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
275 result = OH_AudioRenderer_Start(audioRenderer);
276
277 result = OH_AudioRenderer_Pause(audioRenderer);
278 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
279
280 OH_AudioRenderer_Release(audioRenderer);
281 OH_AudioStreamBuilder_Destroy(builder);
282 }
283
284 /**
285 * @tc.name : Test OH_AudioRenderer_Pause API via illegal state, Pause without Start first.
286 * @tc.number: OH_Audio_Render_Pause_002
287 * @tc.desc : Test OH_AudioRenderer_Pause interface. Returns error code, if Pause without Start first.
288 */
289 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_Pause_002, TestSize.Level0)
290 {
291 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
292
293 OH_AudioRenderer* audioRenderer;
294 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
295
296 result = OH_AudioRenderer_Pause(audioRenderer);
297 EXPECT_TRUE(result == AUDIOSTREAM_ERROR_ILLEGAL_STATE);
298
299 OH_AudioRenderer_Release(audioRenderer);
300 OH_AudioStreamBuilder_Destroy(builder);
301 }
302
303 /**
304 * @tc.name : Test OH_AudioRenderer_Stop API via legal state.
305 * @tc.number: OH_Audio_Render_Stop_001
306 * @tc.desc : Test OH_AudioRenderer_Stop interface. Returns true if Stop is successful.
307 */
308 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_Stop_001, TestSize.Level0)
309 {
310 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
311
312 OH_AudioRenderer* audioRenderer;
313 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
314 result = OH_AudioRenderer_Start(audioRenderer);
315
316 result = OH_AudioRenderer_Stop(audioRenderer);
317 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
318
319 OH_AudioRenderer_Release(audioRenderer);
320 OH_AudioStreamBuilder_Destroy(builder);
321 }
322
323 /**
324 * @tc.name : Test OH_AudioRenderer_Stop API via illegal state, Stop without Start first.
325 * @tc.number: OH_Audio_Render_Stop_002
326 * @tc.desc : Test OH_AudioRenderer_Stop interface. Returns error code, if Stop without Start first.
327 */
328 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_Stop_002, TestSize.Level0)
329 {
330 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
331
332 OH_AudioRenderer* audioRenderer;
333 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
334
335 result = OH_AudioRenderer_Stop(audioRenderer);
336 EXPECT_TRUE(result == AUDIOSTREAM_ERROR_ILLEGAL_STATE);
337
338 OH_AudioRenderer_Release(audioRenderer);
339 OH_AudioStreamBuilder_Destroy(builder);
340 }
341
342 /**
343 * @tc.name : Test OH_AudioRenderer_Flush API via legal state.
344 * @tc.number: OH_Audio_Render_Flush_001
345 * @tc.desc : Test OH_AudioRenderer_Flush interface. Returns true if Flush is successful.
346 */
347 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_Flush_001, TestSize.Level0)
348 {
349 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
350
351 OH_AudioRenderer* audioRenderer;
352 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
353 result = OH_AudioRenderer_Start(audioRenderer);
354
355 result = OH_AudioRenderer_Flush(audioRenderer);
356 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
357
358 OH_AudioRenderer_Release(audioRenderer);
359 OH_AudioStreamBuilder_Destroy(builder);
360 }
361
362 /**
363 * @tc.name : Test OH_AudioRenderer_Flush API via illegal state.
364 * @tc.number: OH_Audio_Render_Flush_002
365 * @tc.desc : Test OH_AudioRenderer_Flush interface. Returns error code, if Flush without Start first.
366 */
367 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_Flush_002, TestSize.Level0)
368 {
369 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
370
371 OH_AudioRenderer* audioRenderer;
372 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
373
374 result = OH_AudioRenderer_Flush(audioRenderer);
375 EXPECT_TRUE(result == AUDIOSTREAM_ERROR_ILLEGAL_STATE);
376
377 OH_AudioRenderer_Release(audioRenderer);
378 OH_AudioStreamBuilder_Destroy(builder);
379 }
380
381 /**
382 * @tc.name : Test OH_AudioRenderer_Release API via legal state.
383 * @tc.number: OH_Audio_Render_Release_001
384 * @tc.desc : Test OH_AudioRenderer_Release interface. Returns true if Release is successful.
385 */
386 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_Release_001, TestSize.Level0)
387 {
388 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
389
390 OH_AudioRenderer* audioRenderer;
391 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
392 result = OH_AudioRenderer_Start(audioRenderer);
393
394 result = OH_AudioRenderer_Release(audioRenderer);
395 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
396
397 OH_AudioStreamBuilder_Destroy(builder);
398 }
399
400 /**
401 * @tc.name : Test OH_AudioRenderer_GetCurrentState API via legal state.
402 * @tc.number: OH_AudioRenderer_GetCurrentState_001
403 * @tc.desc : Test OH_AudioRenderer_GetCurrentState interface. Return true if the result state is
404 * AUDIOSTREAM_STATE_PREPARED.
405 */
406 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetCurrentState_001, TestSize.Level0)
407 {
408 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
409 OH_AudioRenderer* audioRenderer;
410 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
411
412 OH_AudioStream_State state;
413 result = OH_AudioRenderer_GetCurrentState(audioRenderer, &state);
414 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
415 EXPECT_TRUE(state == AUDIOSTREAM_STATE_PREPARED);
416 OH_AudioStreamBuilder_Destroy(builder);
417 }
418
419 /**
420 * @tc.name : Test OH_AudioRenderer_GetCurrentState API via legal state.
421 * @tc.number: OH_AudioRenderer_GetCurrentState_002
422 * @tc.desc : Test OH_AudioRenderer_GetCurrentState interface. Return true if the result state is
423 * AUDIOSTREAM_STATE_RUNNING.
424 */
425 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetCurrentState_002, TestSize.Level0)
426 {
427 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
428 OH_AudioRenderer* audioRenderer;
429 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
430
431 OH_AudioRenderer_Start(audioRenderer);
432
433 OH_AudioStream_State state;
434 result = OH_AudioRenderer_GetCurrentState(audioRenderer, &state);
435 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
436 EXPECT_TRUE(state == AUDIOSTREAM_STATE_RUNNING);
437 OH_AudioStreamBuilder_Destroy(builder);
438 }
439
440 /**
441 * @tc.name : Test OH_AudioRenderer_GetCurrentState API via legal state.
442 * @tc.number: OH_AudioRenderer_GetCurrentState_003
443 * @tc.desc : Test OH_AudioRenderer_GetCurrentState interface. Return true if the result state is
444 * AUDIOSTREAM_STATE_PAUSED.
445 */
446 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetCurrentState_003, TestSize.Level0)
447 {
448 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
449 OH_AudioRenderer* audioRenderer;
450 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
451
452 OH_AudioRenderer_Start(audioRenderer);
453 OH_AudioRenderer_Pause(audioRenderer);
454
455 OH_AudioStream_State state;
456 result = OH_AudioRenderer_GetCurrentState(audioRenderer, &state);
457 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
458 EXPECT_TRUE(state == AUDIOSTREAM_STATE_PAUSED);
459 OH_AudioStreamBuilder_Destroy(builder);
460 }
461
462 /**
463 * @tc.name : Test OH_AudioRenderer_GetCurrentState API via legal state.
464 * @tc.number: OH_AudioRenderer_GetCurrentState_004
465 * @tc.desc : Test OH_AudioRenderer_GetCurrentState interface. Return true if the result state is
466 * AUDIOSTREAM_STATE_STOPPED.
467 */
468 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetCurrentState_004, TestSize.Level0)
469 {
470 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
471 OH_AudioRenderer* audioRenderer;
472 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
473
474 OH_AudioRenderer_Start(audioRenderer);
475 OH_AudioRenderer_Stop(audioRenderer);
476
477 OH_AudioStream_State state;
478 result = OH_AudioRenderer_GetCurrentState(audioRenderer, &state);
479 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
480 EXPECT_TRUE(state == AUDIOSTREAM_STATE_STOPPED);
481 OH_AudioStreamBuilder_Destroy(builder);
482 }
483
484 /**
485 * @tc.name : Test OH_AudioRenderer_GetLatencyMode API via legal state.
486 * @tc.number: OH_Audio_Render_GetParameter_001
487 * @tc.desc : Test OH_AudioRenderer_GetLatencyMode interface. Returns true if latencyMode is
488 * AUDIOSTREAM_LATENCY_MODE_NORMAL,because default latency mode is AUDIOSTREAM_LATENCY_MODE_NORMAL.
489 */
490 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetParameter_001, TestSize.Level0)
491 {
492 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
493 OH_AudioRenderer* audioRenderer;
494 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
495
496 OH_AudioStream_LatencyMode latencyMode = AUDIOSTREAM_LATENCY_MODE_NORMAL;
497 result = OH_AudioRenderer_GetLatencyMode(audioRenderer, &latencyMode);
498 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
499 EXPECT_TRUE(latencyMode == AUDIOSTREAM_LATENCY_MODE_NORMAL);
500 OH_AudioStreamBuilder_Destroy(builder);
501 }
502
503 /**
504 * @tc.name : Test OH_AudioRenderer_GetStreamId API via legal state.
505 * @tc.number: OH_Audio_Render_GetParameter_002
506 * @tc.desc : Test OH_AudioRenderer_GetStreamId interface. Returns true if the result is AUDIOSTREAM_SUCCESS.
507 */
508 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetParameter_002, TestSize.Level0)
509 {
510 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
511 OH_AudioRenderer* audioRenderer;
512 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
513
514 uint32_t streamId;
515 result = OH_AudioRenderer_GetStreamId(audioRenderer, &streamId);
516 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
517 OH_AudioStreamBuilder_Destroy(builder);
518 }
519
520 /**
521 * @tc.name : Test OH_AudioRenderer_GetSamplingRate API via legal state.
522 * @tc.number: OH_Audio_Render_GetSamplingRate_001
523 * @tc.desc : Test OH_AudioRenderer_GetSamplingRate interface. Returns true if samplingRate is
524 * SAMPLE_RATE_48000,because default samplingRate is SAMPLE_RATE_48000.
525 */
526 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetSamplingRate_001, TestSize.Level0)
527 {
528 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
529 OH_AudioRenderer* audioRenderer;
530 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
531
532 int32_t rate;
533 result = OH_AudioRenderer_GetSamplingRate(audioRenderer, &rate);
534 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
535 EXPECT_TRUE(rate == SAMPLE_RATE_48000);
536 OH_AudioStreamBuilder_Destroy(builder);
537 }
538
539 /**
540 * @tc.name : Test OH_AudioRenderer_GetSampleFormat API via legal state.
541 * @tc.number: OH_Audio_Render_GetSampleFormat_001
542 * @tc.desc : Test OH_AudioRenderer_GetSampleFormat interface. Returns true if sampleFormat is
543 * AUDIOSTREAM_SAMPLE_S16LE,because default sampleFormat is AUDIOSTREAM_SAMPLE_S16LE.
544 */
545 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetSampleFormat, TestSize.Level0)
546 {
547 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
548 OH_AudioRenderer* audioRenderer;
549 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
550
551 OH_AudioStream_SampleFormat sampleFormat;
552 result = OH_AudioRenderer_GetSampleFormat(audioRenderer, &sampleFormat);
553 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
554 EXPECT_TRUE(sampleFormat == AUDIOSTREAM_SAMPLE_S16LE);
555 OH_AudioStreamBuilder_Destroy(builder);
556 }
557
558 /**
559 * @tc.name : Test OH_AudioRenderer_GetEncodingType API via legal state.
560 * @tc.number: OH_Audio_Render_GetEncodingType_001
561 * @tc.desc : Test OH_AudioRenderer_GetEncodingType interface. Returns true if encodingType is
562 * ENCODING_PCM,because default encodingType is ENCODING_PCM.
563 */
564 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetEncodingType_001, TestSize.Level0)
565 {
566 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
567 OH_AudioRenderer* audioRenderer;
568 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
569
570 OH_AudioStream_EncodingType encodingType;
571 result = OH_AudioRenderer_GetEncodingType(audioRenderer, &encodingType);
572 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
573 EXPECT_TRUE(encodingType == AUDIOSTREAM_ENCODING_TYPE_RAW);
574 OH_AudioStreamBuilder_Destroy(builder);
575 }
576
577 /**
578 * @tc.name : Test OH_AudioRenderer_GetRendererInfo API via legal state.
579 * @tc.number: OH_Audio_Render_GetRendererInfo_001
580 * @tc.desc : Test OH_AudioRenderer_GetRendererInfo interface. Returns true if usage is STREAM_USAGE_MEDIA and content
581 * is CONTENT_TYPE_MUSIC.
582 */
583 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetRendererInfo_001, TestSize.Level0)
584 {
585 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
586 OH_AudioRenderer* audioRenderer;
587 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
588
589 OH_AudioStream_Usage usage;
590 result = OH_AudioRenderer_GetRendererInfo(audioRenderer, &usage);
591 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
592 EXPECT_EQ(usage, AUDIOSTREAM_USAGE_MUSIC);
593 OH_AudioStreamBuilder_Destroy(builder);
594 }
595
596 /**
597 * @tc.name : Test OH_AudioRenderer_GetRendererPrivacy API.
598 * @tc.number: OH_AudioRenderer_GetRendererPrivacy_001
599 * @tc.desc : Test OH_AudioRenderer_GetRendererPrivacy interface with default privacy AUDIO_STREAM_PRIVACY_TYPE_PUBLIC.
600 */
601 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetRendererPrivacy_001, TestSize.Level0)
602 {
603 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
604 OH_AudioRenderer* audioRenderer;
605 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
606
607 OH_AudioStream_PrivacyType privacyType;
608 result = OH_AudioRenderer_GetRendererPrivacy(audioRenderer, &privacyType);
609 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
610 EXPECT_EQ(privacyType, AUDIO_STREAM_PRIVACY_TYPE_PUBLIC);
611 OH_AudioStreamBuilder_Destroy(builder);
612 }
613
614 /**
615 * @tc.name : Test OH_AudioRenderer_GetRendererPrivacy API.
616 * @tc.number: OH_AudioRenderer_GetRendererPrivacy_002
617 * @tc.desc : Test OH_AudioRenderer_GetRendererPrivacy interface with privacy AUDIO_STREAM_PRIVACY_TYPE_PRIVATE.
618 */
619 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetRendererPrivacy_002, TestSize.Level0)
620 {
621 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
622 OH_AudioStream_Result privacyResult = OH_AudioStreamBuilder_SetRendererPrivacy(builder,
623 AUDIO_STREAM_PRIVACY_TYPE_PRIVATE);
624 EXPECT_EQ(privacyResult, AUDIOSTREAM_SUCCESS);
625 OH_AudioRenderer* audioRenderer;
626 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
627
628 OH_AudioStream_PrivacyType privacyType;
629 result = OH_AudioRenderer_GetRendererPrivacy(audioRenderer, &privacyType);
630 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
631 EXPECT_EQ(privacyType, AUDIO_STREAM_PRIVACY_TYPE_PRIVATE);
632 OH_AudioStreamBuilder_Destroy(builder);
633 }
634
635 /**
636 * @tc.name : Test OH_AudioRenderer_GetChannelLayout API via legal state.
637 * @tc.number: OH_AudioRenderer_GetChannelLayout_001
638 * @tc.desc : Test OH_AudioRenderer_GetChannelLayout interface. Returns true if channelLayout is
639 * CH_LAYOUT_UNKNOWN, because default channelLayout is CH_LAYOUT_UNKNOWN.
640 */
641 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetChannelLayout_001, TestSize.Level0)
642 {
643 OH_AudioStreamBuilder *builder = OHAudioRenderUnitTest::CreateRenderBuilder();
644 OH_AudioRenderer *audioRenderer;
645 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
646
647 OH_AudioChannelLayout channelLayout;
648 result = OH_AudioRenderer_GetChannelLayout(audioRenderer, &channelLayout);
649 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
650 EXPECT_TRUE(channelLayout == CH_LAYOUT_UNKNOWN);
651 OH_AudioStreamBuilder_Destroy(builder);
652 }
653
654 /**
655 * @tc.name : Test OH_AudioRenderer_GetEffectMode API via legal state.
656 * @tc.number: OH_AudioRenderer_GetEffectMode_001
657 * @tc.desc : Test OH_AudioRenderer_GetEffectMode interface. Returns true if effect mode is the same as set.
658 */
659 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetEffectMode_001, TestSize.Level0)
660 {
661 OH_AudioStreamBuilder *builder = OHAudioRenderUnitTest::CreateRenderBuilder();
662 OH_AudioRenderer *audioRenderer;
663 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
664
665 OH_AudioStream_AudioEffectMode effectMode;
666 result = OH_AudioRenderer_SetEffectMode(audioRenderer, EFFECT_DEFAULT);
667 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
668 result = OH_AudioRenderer_GetEffectMode(audioRenderer, &effectMode);
669 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
670 EXPECT_TRUE(effectMode == EFFECT_DEFAULT);
671 OH_AudioStreamBuilder_Destroy(builder);
672 }
673
674 /**
675 * @tc.name : Test OH_AudioRenderer_GetVolume API via illegal state.
676 * @tc.number: OH_Audio_Render_GetVolume_001
677 * @tc.desc : Test OH_AudioRenderer_GetVolume interface with nullptr audioRenderer.
678 */
679 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetVolume_001, TestSize.Level0)
680 {
681 OH_AudioRenderer* audioRenderer = nullptr;
682 float volume;
683 OH_AudioStream_Result result = OH_AudioRenderer_GetVolume(audioRenderer, &volume);
684 EXPECT_TRUE(result == AUDIOSTREAM_ERROR_INVALID_PARAM);
685 }
686
687 /**
688 * @tc.name : Test OH_AudioRenderer_GetVolume API via legal state.
689 * @tc.number: OH_Audio_Render_GetVolume_002
690 * @tc.desc : Test OH_AudioRenderer_GetVolume interface.
691 */
692 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetVolume_002, TestSize.Level0)
693 {
694 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
695 OH_AudioRenderer* audioRenderer;
696 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
697 float volume;
698 result = OH_AudioRenderer_GetVolume(audioRenderer, &volume);
699 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
700 OH_AudioStreamBuilder_Destroy(builder);
701 }
702
703 /**
704 * @tc.name : Test OH_AudioRenderer_GetVolume API via legal state.
705 * @tc.number: OH_Audio_Render_GetVolume_003
706 * @tc.desc : Test OH_AudioRenderer_GetVolume interface after set volume call.
707 */
708 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetVolume_003, TestSize.Level0)
709 {
710 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
711 OH_AudioRenderer* audioRenderer;
712 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
713 float volumeSet = 0.5;
714 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
715 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
716 float volumeGet;
717 result = OH_AudioRenderer_GetVolume(audioRenderer, &volumeGet);
718 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
719 EXPECT_EQ(volumeGet, 0.5);
720 OH_AudioStreamBuilder_Destroy(builder);
721 }
722
723 /**
724 * @tc.name : Test OH_AudioRenderer_GetVolume API via legal state.
725 * @tc.number: OH_Audio_Render_GetVolume_004
726 * @tc.desc : Test OH_AudioRenderer_GetVolume interface after set volume fails.
727 */
728 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetVolume_004, TestSize.Level0)
729 {
730 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
731 OH_AudioRenderer* audioRenderer;
732 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
733 float volumeSet = 0.5;
734 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
735 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
736 volumeSet = 1.5;
737 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
738 EXPECT_EQ(result, AUDIOSTREAM_ERROR_INVALID_PARAM);
739 float volumeGet;
740 result = OH_AudioRenderer_GetVolume(audioRenderer, &volumeGet);
741 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
742 EXPECT_EQ(volumeGet, 0.5);
743 OH_AudioStreamBuilder_Destroy(builder);
744 }
745
746 /**
747 * @tc.name : Test OH_AudioRenderer_SetVolume API via illegal state.
748 * @tc.number: OH_Audio_Render_SetVolume_001
749 * @tc.desc : Test OH_AudioRenderer_SetVolume interface with nullptr audioRenderer.
750 */
751 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetVolume_001, TestSize.Level0)
752 {
753 OH_AudioRenderer* audioRenderer = nullptr;
754 float volumeSet = 0.5;
755 OH_AudioStream_Result result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
756 EXPECT_TRUE(result == AUDIOSTREAM_ERROR_INVALID_PARAM);
757 }
758
759 /**
760 * @tc.name : Test OH_AudioRenderer_SetVolume API via legal state.
761 * @tc.number: OH_Audio_Render_SetVolume_002
762 * @tc.desc : Test OH_AudioRenderer_SetVolume interface between minimum and maximum volumes.
763 */
764 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetVolume_002, TestSize.Level0)
765 {
766 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
767 OH_AudioRenderer* audioRenderer;
768 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
769 float volumeSet = 0.5;
770 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
771 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
772 OH_AudioStreamBuilder_Destroy(builder);
773 }
774
775 /**
776 * @tc.name : Test OH_AudioRenderer_SetVolume API via legal state.
777 * @tc.number: OH_Audio_Render_SetVolume_003
778 * @tc.desc : Test OH_AudioRenderer_SetVolume interface for minimum and maximum volumes.
779 */
780 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetVolume_003, TestSize.Level0)
781 {
782 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
783 OH_AudioRenderer* audioRenderer;
784 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
785 float volumeSet = MIN_AUDIO_VOLUME;
786 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
787 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
788 volumeSet = MAX_AUDIO_VOLUME;
789 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
790 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
791 OH_AudioStreamBuilder_Destroy(builder);
792 }
793
794 /**
795 * @tc.name : Test OH_AudioRenderer_SetVolume API via illegal state.
796 * @tc.number: OH_Audio_Render_SetVolume_004
797 * @tc.desc : Test OH_AudioRenderer_SetVolume interface out of volumes range.
798 */
799 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetVolume_004, TestSize.Level0)
800 {
801 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
802 OH_AudioRenderer* audioRenderer;
803 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
804 float volumeSet = -0.5;
805 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
806 EXPECT_EQ(result, AUDIOSTREAM_ERROR_INVALID_PARAM);
807 volumeSet = -1.5;
808 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
809 EXPECT_EQ(result, AUDIOSTREAM_ERROR_INVALID_PARAM);
810 OH_AudioStreamBuilder_Destroy(builder);
811 }
812
813 /**
814 * @tc.name : Test OH_AudioRenderer_SetVolumeWithRamp API via illegal state.
815 * @tc.number: OH_Audio_Render_SetVolumeWithRamp_001
816 * @tc.desc : Test OH_AudioRenderer_SetVolumeWithRamp interface with nullptr audioRenderer.
817 */
818 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetVolumeWithRamp_001, TestSize.Level0)
819 {
820 OH_AudioRenderer* audioRenderer = nullptr;
821 float volumeSet = MIN_AUDIO_VOLUME;
822 int32_t durationMs = DURATIONMS;
823 OH_AudioStream_Result result = OH_AudioRenderer_SetVolumeWithRamp(audioRenderer, volumeSet, durationMs);
824 EXPECT_EQ(result, AUDIOSTREAM_ERROR_INVALID_PARAM);
825 }
826
827 /**
828 * @tc.name : Test OH_AudioRenderer_SetVolumeWithRamp API via legal state.
829 * @tc.number: OH_Audio_Render_SetVolumeWithRamp_002
830 * @tc.desc : Test OH_AudioRenderer_SetVolumeWithRamp interface.
831 */
832 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetVolumeWithRamp_002, TestSize.Level0)
833 {
834 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
835 OH_AudioRenderer* audioRenderer;
836 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
837 float volumeSet = MIN_AUDIO_VOLUME;
838 int32_t durationMs = DURATIONMS;
839 result = OH_AudioRenderer_SetVolumeWithRamp(audioRenderer, volumeSet, durationMs);
840 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
841 OH_AudioStreamBuilder_Destroy(builder);
842 }
843
844 /**
845 * @tc.name : Test OH_AudioRenderer_SetMarkPosition API via illegal state.
846 * @tc.number: OH_Audio_Render_SetMarkPosition_001
847 * @tc.desc : Test OH_AudioRenderer_SetMarkPosition interface with nullptr audioRenderer.
848 */
849 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetMarkPosition_001, TestSize.Level0)
850 {
851 OH_AudioRenderer* audioRenderer = nullptr;
852 uint32_t samplePos = 1;
853 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
854 OH_AudioStream_Result result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
855 EXPECT_TRUE(result == AUDIOSTREAM_ERROR_INVALID_PARAM);
856 }
857
858 /**
859 * @tc.name : Test OH_AudioRenderer_SetMarkPosition API via legal state.
860 * @tc.number: OH_Audio_Render_SetMarkPosition_002
861 * @tc.desc : Test OH_AudioRenderer_SetMarkPosition interface.
862 */
863 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetMarkPosition_002, TestSize.Level0)
864 {
865 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
866 OH_AudioRenderer* audioRenderer;
867 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
868
869 uint32_t samplePos = 1;
870 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
871 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
872 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
873 OH_AudioStreamBuilder_Destroy(builder);
874 }
875
876 /**
877 * @tc.name : Test OH_AudioRenderer_SetMarkPosition API via illegal state.
878 * @tc.number: OH_Audio_Render_SetMarkPosition_003
879 * @tc.desc : Test OH_AudioRenderer_SetMarkPosition interface with incorrect samplepos value.
880 */
881 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetMarkPosition_003, TestSize.Level0)
882 {
883 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
884 OH_AudioRenderer* audioRenderer;
885 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
886
887 uint32_t samplePos = 0;
888 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
889 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
890 EXPECT_EQ(result, AUDIOSTREAM_ERROR_INVALID_PARAM);
891 OH_AudioStreamBuilder_Destroy(builder);
892 }
893
894 /**
895 * @tc.name : Test OH_AudioRenderer_SetMarkPosition API via legal state.
896 * @tc.number: OH_Audio_Render_SetMarkPosition_004
897 * @tc.desc : Test OH_AudioRenderer_SetMarkPosition interface with callback.
898 */
899 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetMarkPosition_004, TestSize.Level0)
900 {
901 // 1. create
902 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
903
904 // 2. set params and callbacks
905 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLING_RATE);
906 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_COUNT);
907 OH_AudioStreamBuilder_SetLatencyMode(builder, (OH_AudioStream_LatencyMode)LATENCY_FORMAT);
908 OH_AudioStreamBuilder_SetSampleFormat(builder, (OH_AudioStream_SampleFormat)SAMPLE_FORMAT);
909 OH_AudioRenderer_Callbacks callbacks;
910 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteData;
911 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, nullptr);
912 // 3. set buffer size to FRAME_SIZE
913 result = OH_AudioStreamBuilder_SetFrameSizeInCallback(builder, FRAME_SIZE);
914
915 OH_AudioRenderer* audioRenderer;
916 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
917 EXPECT_EQ(g_flag, 0);
918 uint32_t samplePos = 1;
919 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
920 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
921 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
922
923 // 4. start
924 result = OH_AudioRenderer_Start(audioRenderer);
925 sleep(2);
926 EXPECT_EQ(g_flag, 1);
927 // 5. stop and release client
928 result = OH_AudioRenderer_Stop(audioRenderer);
929 result = OH_AudioRenderer_Release(audioRenderer);
930
931 // 6. destroy the builder
932 OH_AudioStreamBuilder_Destroy(builder);
933 }
934
935 /**
936 * @tc.name : Test OH_AudioRenderer_SetMarkPosition API via legal state.
937 * @tc.number: OH_Audio_Render_SetMarkPosition_005
938 * @tc.desc : Test OH_AudioRenderer_SetMarkPosition interface multiple times.
939 */
940 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetMarkPosition_005, TestSize.Level0)
941 {
942 // 1. create
943 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
944
945 // 2. set params and callbacks
946 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLING_RATE);
947 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_COUNT);
948 OH_AudioStreamBuilder_SetLatencyMode(builder, (OH_AudioStream_LatencyMode)LATENCY_FORMAT);
949 OH_AudioStreamBuilder_SetSampleFormat(builder, (OH_AudioStream_SampleFormat)SAMPLE_FORMAT);
950 OH_AudioRenderer_Callbacks callbacks;
951 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteData;
952 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, nullptr);
953 // 3. set buffer size to FRAME_SIZE
954 result = OH_AudioStreamBuilder_SetFrameSizeInCallback(builder, FRAME_SIZE);
955
956 OH_AudioRenderer* audioRenderer;
957 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
958 uint32_t samplePos = 1;
959 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
960 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
961 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
962 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
963 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
964
965 // 4. start
966 result = OH_AudioRenderer_Start(audioRenderer);
967 sleep(2);
968 EXPECT_EQ(g_flag, 1);
969 // 5. stop and release client
970 result = OH_AudioRenderer_Stop(audioRenderer);
971 result = OH_AudioRenderer_Release(audioRenderer);
972
973 // 6. destroy the builder
974 OH_AudioStreamBuilder_Destroy(builder);
975 }
976
977 /**
978 * @tc.name : Test OH_AudioRenderer_CancelMark API via illegal state.
979 * @tc.number: OH_Audio_Render_CancelMark_001
980 * @tc.desc : Test OH_AudioRenderer_CancelMark interface with nullptr audioRenderer.
981 */
982 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_CancelMark_001, TestSize.Level0)
983 {
984 OH_AudioRenderer* audioRenderer = nullptr;
985 OH_AudioStream_Result result = OH_AudioRenderer_CancelMark(audioRenderer);
986 EXPECT_TRUE(result == AUDIOSTREAM_ERROR_INVALID_PARAM);
987 }
988
989 /**
990 * @tc.name : Test OH_AudioRenderer_CancelMark API via legal state.
991 * @tc.number: OH_Audio_Render_CancelMark_002
992 * @tc.desc : Test OH_AudioRenderer_CancelMark interface without callback.
993 */
994 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_CancelMark_002, TestSize.Level0)
995 {
996 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
997 OH_AudioRenderer* audioRenderer;
998 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
999 result = OH_AudioRenderer_CancelMark(audioRenderer);
1000 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
1001 OH_AudioStreamBuilder_Destroy(builder);
1002 }
1003
1004 /**
1005 * @tc.name : Test OH_AudioRenderer_CancelMark API via legal state.
1006 * @tc.number: OH_Audio_Render_CancelMark_003
1007 * @tc.desc : Test OH_AudioRenderer_CancelMark interface with callback.
1008 */
1009 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_CancelMark_003, TestSize.Level0)
1010 {
1011 // 1. create
1012 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
1013
1014 // 2. set params and callbacks
1015 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLING_RATE);
1016 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_COUNT);
1017 OH_AudioStreamBuilder_SetLatencyMode(builder, (OH_AudioStream_LatencyMode)LATENCY_FORMAT);
1018 OH_AudioStreamBuilder_SetSampleFormat(builder, (OH_AudioStream_SampleFormat)SAMPLE_FORMAT);
1019 OH_AudioRenderer_Callbacks callbacks;
1020 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteData;
1021 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, nullptr);
1022 // 3. set buffer size to FRAME_SIZE
1023 result = OH_AudioStreamBuilder_SetFrameSizeInCallback(builder, FRAME_SIZE);
1024
1025 OH_AudioRenderer* audioRenderer;
1026 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1027 uint32_t samplePos = 2;
1028 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
1029 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1030 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1031
1032 // 4. start
1033 result = OH_AudioRenderer_Start(audioRenderer);
1034 sleep(2);
1035 EXPECT_EQ(g_flag, 2);
1036
1037 // CancelMark
1038 result = OH_AudioRenderer_CancelMark(audioRenderer);
1039 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1040
1041 // 5. stop and release client
1042 result = OH_AudioRenderer_Stop(audioRenderer);
1043 result = OH_AudioRenderer_Release(audioRenderer);
1044
1045 // 6. destroy the builder
1046 OH_AudioStreamBuilder_Destroy(builder);
1047 }
1048
1049 /**
1050 * @tc.name : Test OH_AudioRenderer_GetUnderflowCount API.
1051 * @tc.number: OH_AudioRenderer_GetUnderflowCount_001
1052 * @tc.desc : Test OH_AudioRenderer_GetUnderflowCount interface.
1053 */
1054 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetUnderflowCount_001, TestSize.Level0)
1055 {
1056 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
1057
1058 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLE_RATE_48000);
1059 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_2);
1060 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_VOICE_COMMUNICATION;
1061 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
1062
1063 OHAudioRendererWriteCallbackMock writeCallbackMock;
1064
1065 OH_AudioRenderer_Callbacks callbacks;
1066 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteDataMock;
1067 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &writeCallbackMock);
1068
1069 OH_AudioRenderer* audioRenderer;
1070 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1071 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1072
1073 std::mutex mutex;
1074 std::condition_variable cv;
1075 int32_t count = 0;
1076 writeCallbackMock.Install([&count, &mutex, &cv](OH_AudioRenderer* renderer, void* userData,
1077 void* buffer,
__anon9beed3990302(OH_AudioRenderer* renderer, void* userData, void* buffer, int32_t bufferLen) 1078 int32_t bufferLen) {
1079 std::lock_guard lock(mutex);
1080 cv.notify_one();
1081
1082 // sleep time trigger underflow
1083 if (count == 1) {
1084 std::this_thread::sleep_for(200ms);
1085 }
1086 count++;
1087 });
1088
1089 result = OH_AudioRenderer_Start(audioRenderer);
1090 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1091
1092 std::unique_lock lock(mutex);
__anon9beed3990402null1093 cv.wait_for(lock, 1s, [&count] {
1094 // count > 1 ensure sleeped
1095 return count > 1;
1096 });
1097 lock.unlock();
1098
1099 uint32_t underFlowCount;
1100 result = OH_AudioRenderer_GetUnderflowCount(audioRenderer, &underFlowCount);
1101 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1102 EXPECT_GE(underFlowCount, 1);
1103
1104 OH_AudioRenderer_Stop(audioRenderer);
1105 OH_AudioRenderer_Release(audioRenderer);
1106
1107 OH_AudioStreamBuilder_Destroy(builder);
1108 }
1109
1110 /**
1111 * @tc.name : Test OH_AudioRenderer_GetUnderflowCount API.
1112 * @tc.number: OH_AudioRenderer_GetUnderflowCount_002
1113 * @tc.desc : Test OH_AudioRenderer_GetUnderflowCount interface.
1114 */
1115 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetUnderflowCount_002, TestSize.Level0)
1116 {
1117 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
1118
1119 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLE_RATE_48000);
1120 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_2);
1121 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_VOICE_COMMUNICATION;
1122 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
1123
1124 OHAudioRendererWriteCallbackMock writeCallbackMock;
1125
1126 OH_AudioRenderer_Callbacks callbacks;
1127 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteDataMock;
1128 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &writeCallbackMock);
1129
1130 OH_AudioRenderer* audioRenderer;
1131 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1132 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1133
1134 std::mutex mutex;
1135 std::condition_variable cv;
1136 int32_t count = 0;
1137 writeCallbackMock.Install([&count, &mutex, &cv](OH_AudioRenderer* renderer, void* userData,
1138 void* buffer,
__anon9beed3990502(OH_AudioRenderer* renderer, void* userData, void* buffer, int32_t bufferLen) 1139 int32_t bufferLen) {
1140 std::lock_guard lock(mutex);
1141 cv.notify_one();
1142
1143 // sleep time trigger underflow
1144 if (count == 0) {
1145 std::this_thread::sleep_for(200ms);
1146 }
1147 count++;
1148 });
1149
1150 result = OH_AudioRenderer_Start(audioRenderer);
1151 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1152
1153 std::unique_lock lock(mutex);
__anon9beed3990602null1154 cv.wait_for(lock, 1s, [&count] {
1155 // count > 1 ensure sleeped
1156 return count > 1;
1157 });
1158 lock.unlock();
1159
1160 uint32_t underFlowCount;
1161 result = OH_AudioRenderer_GetUnderflowCount(audioRenderer, &underFlowCount);
1162 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1163 EXPECT_EQ(underFlowCount, 0);
1164
1165 OH_AudioRenderer_Stop(audioRenderer);
1166 OH_AudioRenderer_Release(audioRenderer);
1167
1168 OH_AudioStreamBuilder_Destroy(builder);
1169 }
1170
1171 /**
1172 * @tc.name : Test OH_AudioRenderer_GetUnderflowCount API.
1173 * @tc.number: OH_AudioRenderer_GetUnderflowCount_003
1174 * @tc.desc : Test OH_AudioRenderer_GetUnderflowCount interface.
1175 */
1176 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetUnderflowCount_003, TestSize.Level0)
1177 {
1178 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
1179
1180 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLE_RATE_48000);
1181 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_2);
1182 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_VOICE_COMMUNICATION;
1183 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
1184
1185 OHAudioRendererWriteCallbackMock writeCallbackMock;
1186
1187 OH_AudioRenderer_Callbacks callbacks;
1188 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteDataMock;
1189 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &writeCallbackMock);
1190
1191 OH_AudioRenderer* audioRenderer;
1192 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1193 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1194
1195 result = OH_AudioRenderer_Start(audioRenderer);
1196 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1197
1198 uint32_t underFlowCount;
1199 result = OH_AudioRenderer_GetUnderflowCount(audioRenderer, &underFlowCount);
1200 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1201 EXPECT_EQ(underFlowCount, 0);
1202
1203 OH_AudioRenderer_Stop(audioRenderer);
1204 OH_AudioRenderer_Release(audioRenderer);
1205
1206 OH_AudioStreamBuilder_Destroy(builder);
1207 }
1208
1209 /**
1210 * @tc.name : Test OH_AudioRenderer_GetUnderflowCount API.
1211 * @tc.number: OH_AudioRenderer_GetUnderflowCount_004
1212 * @tc.desc : Test OH_AudioRenderer_GetUnderflowCount interface.
1213 */
1214 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetUnderflowCount_004, TestSize.Level0)
1215 {
1216 uint32_t lastUnderFlowCount = 0;
1217 for (auto sleepTimes : {200ms, 400ms, 600ms}) {
1218 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
1219
1220 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLE_RATE_48000);
1221 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_2);
1222 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_VOICE_COMMUNICATION;
1223 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
1224
1225 OHAudioRendererWriteCallbackMock writeCallbackMock;
1226
1227 OH_AudioRenderer_Callbacks callbacks;
1228 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteDataMock;
1229 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &writeCallbackMock);
1230
1231 OH_AudioRenderer* audioRenderer;
1232 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1233 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1234
1235 std::mutex mutex;
1236 std::condition_variable cv;
1237 int32_t count = 0;
1238 writeCallbackMock.Install([&count, &mutex, &cv, sleepTimes](OH_AudioRenderer* renderer, void* userData,
1239 void* buffer,
__anon9beed3990702(OH_AudioRenderer* renderer, void* userData, void* buffer, int32_t bufferLen) 1240 int32_t bufferLen) {
1241 std::lock_guard lock(mutex);
1242 cv.notify_one();
1243
1244 // sleep time trigger underflow
1245 if (count == 1) {
1246 std::this_thread::sleep_for(sleepTimes);
1247 }
1248 count++;
1249 });
1250
1251 result = OH_AudioRenderer_Start(audioRenderer);
1252 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1253
1254 std::unique_lock lock(mutex);
__anon9beed3990802null1255 cv.wait_for(lock, 1s, [&count] {
1256 // count > 1 ensure sleeped
1257 return count > 10;
1258 });
1259 lock.unlock();
1260
1261 uint32_t underFlowCount = 0;
1262 result = OH_AudioRenderer_GetUnderflowCount(audioRenderer, &underFlowCount);
1263 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1264 EXPECT_GT(underFlowCount, lastUnderFlowCount);
1265 lastUnderFlowCount = underFlowCount;
1266
1267 OH_AudioRenderer_Stop(audioRenderer);
1268 OH_AudioRenderer_Release(audioRenderer);
1269
1270 OH_AudioStreamBuilder_Destroy(builder);
1271 }
1272 }
1273
1274 /**
1275 * @tc.name : Test OH_AudioRenderer_GetUnderflowCount API.
1276 * @tc.number: OH_AudioRenderer_GetUnderflowCount_005
1277 * @tc.desc : Test OH_AudioRenderer_GetUnderflowCount interface.
1278 */
1279 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetUnderflowCount_005, TestSize.Level0)
1280 {
1281 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
1282
1283 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLE_RATE_48000);
1284 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_2);
1285 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_VOICE_COMMUNICATION;
1286 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
1287
1288 OHAudioRendererWriteCallbackMock writeCallbackMock;
1289
1290 OH_AudioRenderer_Callbacks callbacks;
1291 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteDataMock;
1292 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &writeCallbackMock);
1293
1294 OH_AudioRenderer* audioRenderer;
1295 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1296 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1297
1298 result = OH_AudioRenderer_Start(audioRenderer);
1299 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1300
1301 std::this_thread::sleep_for(1s);
1302
1303 uint32_t underFlowCount;
1304 result = OH_AudioRenderer_GetUnderflowCount(audioRenderer, &underFlowCount);
1305 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1306 EXPECT_EQ(underFlowCount, 0);
1307
1308 OH_AudioRenderer_Stop(audioRenderer);
1309 OH_AudioRenderer_Release(audioRenderer);
1310
1311 OH_AudioStreamBuilder_Destroy(builder);
1312 }
1313
1314 /**
1315 * @tc.name : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback API via legal state.
1316 * @tc.number: OH_Audio_Render_WriteDataCallback_001
1317 * @tc.desc : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback interface with VALID result.
1318 * Returns true if result is successful.
1319 */
1320 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_WriteDataCallback_001, TestSize.Level0)
1321 {
1322 OH_AudioStreamBuilder* builder = InitRenderBuilder();
1323
1324 OH_AudioRenderer_OnWriteDataCallback callback = OnWriteDataCallbackWithValidData;
1325 OH_AudioStreamBuilder_SetRendererWriteDataCallback(builder, callback, nullptr);
1326
1327 OH_AudioRenderer* audioRenderer;
1328 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1329 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1330
1331 result = OH_AudioRenderer_Start(audioRenderer);
1332 sleep(2);
1333 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1334
1335 CleanupAudioResources(builder, audioRenderer);
1336 }
1337
1338 /**
1339 * @tc.name : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback API via legal state.
1340 * @tc.number: OH_Audio_Render_WriteDataCallback_002
1341 * @tc.desc : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback interface with INVALID result.
1342 * Returns true if result is successful.
1343 */
1344 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_WriteDataCallback_002, TestSize.Level0)
1345 {
1346 OH_AudioStreamBuilder* builder = InitRenderBuilder();
1347
1348 OH_AudioRenderer_OnWriteDataCallback callback = OnWriteDataCallbackWithInvalidData;
1349 OH_AudioStreamBuilder_SetRendererWriteDataCallback(builder, callback, nullptr);
1350
1351 OH_AudioRenderer* audioRenderer;
1352 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1353 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1354
1355 result = OH_AudioRenderer_Start(audioRenderer);
1356 sleep(2);
1357 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1358
1359 CleanupAudioResources(builder, audioRenderer);
1360 }
1361
1362 /**
1363 * @tc.name : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback API via legal state.
1364 * @tc.number: OH_Audio_Render_WriteDataCallback_003
1365 * @tc.desc : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback interface with VALID result
1366 * overwrites OH_AudioStreamBuilder_SetRendererCallback interface.
1367 * Returns true if result is successful.
1368 */
1369 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_WriteDataCallback_003, TestSize.Level0)
1370 {
1371 OH_AudioStreamBuilder* builder = InitRenderBuilder();
1372
1373 UserData userData;
1374 OH_AudioRenderer_Callbacks callbacks;
1375 callbacks.OH_AudioRenderer_OnWriteData = OnWriteDataCbMock;
1376 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &userData);
1377
1378 OH_AudioRenderer_OnWriteDataCallback callback = OnWriteDataCbWithValidDataMock;
1379 OH_AudioStreamBuilder_SetRendererWriteDataCallback(builder, callback, &userData);
1380
1381 OH_AudioRenderer* audioRenderer;
1382 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1383 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1384
1385 result = OH_AudioRenderer_Start(audioRenderer);
1386 sleep(2);
1387 EXPECT_TRUE(userData.writeDataCallbackType == UserData::WRITE_DATA_CALLBACK_WITH_RESULT);
1388
1389 CleanupAudioResources(builder, audioRenderer);
1390 }
1391
1392 /**
1393 * @tc.name : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback API via legal state.
1394 * @tc.number: OH_Audio_Render_WriteDataCallback_004
1395 * @tc.desc : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback interface with INVALID result
1396 * overwrites OH_AudioStreamBuilder_SetRendererCallback interface.
1397 * Returns true if result is successful.
1398 */
1399 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_WriteDataCallback_004, TestSize.Level0)
1400 {
1401 OH_AudioStreamBuilder* builder = InitRenderBuilder();
1402
1403 UserData userData;
1404 OH_AudioRenderer_Callbacks callbacks;
1405 callbacks.OH_AudioRenderer_OnWriteData = OnWriteDataCbMock;
1406 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &userData);
1407
1408 OH_AudioRenderer_OnWriteDataCallback callback = OnWriteDataCbWithInvalidDataMock;
1409 OH_AudioStreamBuilder_SetRendererWriteDataCallback(builder, callback, &userData);
1410
1411 OH_AudioRenderer* audioRenderer;
1412 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1413 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1414
1415 result = OH_AudioRenderer_Start(audioRenderer);
1416 sleep(2);
1417 EXPECT_TRUE(userData.writeDataCallbackType == UserData::WRITE_DATA_CALLBACK_WITH_RESULT);
1418
1419 CleanupAudioResources(builder, audioRenderer);
1420 }
1421
1422 /**
1423 * @tc.name : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback API via legal state.
1424 * @tc.number: OH_Audio_Render_WriteDataCallback_005
1425 * @tc.desc : Test OH_AudioStreamBuilder_SetRendererCallback interface
1426 * overwrites OH_AudioStreamBuilder_SetRendererWriteDataCallback interface with VALID result.
1427 * Returns true if result is successful.
1428 */
1429 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_WriteDataCallback_005, TestSize.Level0)
1430 {
1431 OH_AudioStreamBuilder* builder = InitRenderBuilder();
1432
1433 UserData userData;
1434 OH_AudioRenderer_OnWriteDataCallback callback = OnWriteDataCbWithValidDataMock;
1435 OH_AudioStreamBuilder_SetRendererWriteDataCallback(builder, callback, &userData);
1436
1437 OH_AudioRenderer_Callbacks callbacks;
1438 callbacks.OH_AudioRenderer_OnWriteData = OnWriteDataCbMock;
1439 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &userData);
1440
1441 OH_AudioRenderer* audioRenderer;
1442 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1443 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1444
1445 result = OH_AudioRenderer_Start(audioRenderer);
1446 sleep(2);
1447 EXPECT_TRUE(userData.writeDataCallbackType == UserData::WRITE_DATA_CALLBACK);
1448
1449 CleanupAudioResources(builder, audioRenderer);
1450 }
1451
1452 /**
1453 * @tc.name : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback API via legal state.
1454 * @tc.number: OH_Audio_Render_WriteDataCallback_006
1455 * @tc.desc : Test OH_AudioStreamBuilder_SetRendererCallback interface
1456 * overwrites OH_AudioStreamBuilder_SetRendererWriteDataCallback interface with INVALID result.
1457 * Returns true if result is successful.
1458 */
1459 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_WriteDataCallback_006, TestSize.Level0)
1460 {
1461 OH_AudioStreamBuilder* builder = InitRenderBuilder();
1462
1463 UserData userData;
1464 OH_AudioRenderer_OnWriteDataCallback callback = OnWriteDataCbWithInvalidDataMock;
1465 OH_AudioStreamBuilder_SetRendererWriteDataCallback(builder, callback, &userData);
1466 OH_AudioRenderer_Callbacks callbacks;
1467 callbacks.OH_AudioRenderer_OnWriteData = OnWriteDataCbMock;
1468 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &userData);
1469
1470 OH_AudioRenderer* audioRenderer;
1471 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1472 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1473
1474 result = OH_AudioRenderer_Start(audioRenderer);
1475 sleep(2);
1476 EXPECT_TRUE(userData.writeDataCallbackType == UserData::WRITE_DATA_CALLBACK);
1477
1478 CleanupAudioResources(builder, audioRenderer);
1479 }
1480 } // namespace AudioStandard
1481 } // namespace OHOS
1482