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_Release API via illegal state.
402 * @tc.number: OH_Audio_Render_Release_002
403 * @tc.desc : Test OH_AudioRenderer_Release interface. Returns error code, if stream is released twice.
404 */
405 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_Release_002, TestSize.Level0)
406 {
407 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
408
409 OH_AudioRenderer* audioRenderer;
410 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
411
412 OH_AudioRenderer_Release(audioRenderer);
413 result = OH_AudioRenderer_Release(audioRenderer);
414 EXPECT_TRUE(result == AUDIOSTREAM_ERROR_ILLEGAL_STATE);
415
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_001
422 * @tc.desc : Test OH_AudioRenderer_GetCurrentState interface. Return true if the result state is
423 * AUDIOSTREAM_STATE_PREPARED.
424 */
425 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetCurrentState_001, 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_AudioStream_State state;
432 result = OH_AudioRenderer_GetCurrentState(audioRenderer, &state);
433 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
434 EXPECT_TRUE(state == AUDIOSTREAM_STATE_PREPARED);
435 OH_AudioStreamBuilder_Destroy(builder);
436 }
437
438 /**
439 * @tc.name : Test OH_AudioRenderer_GetCurrentState API via legal state.
440 * @tc.number: OH_AudioRenderer_GetCurrentState_002
441 * @tc.desc : Test OH_AudioRenderer_GetCurrentState interface. Return true if the result state is
442 * AUDIOSTREAM_STATE_RUNNING.
443 */
444 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetCurrentState_002, TestSize.Level0)
445 {
446 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
447 OH_AudioRenderer* audioRenderer;
448 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
449
450 OH_AudioRenderer_Start(audioRenderer);
451
452 OH_AudioStream_State state;
453 result = OH_AudioRenderer_GetCurrentState(audioRenderer, &state);
454 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
455 EXPECT_TRUE(state == AUDIOSTREAM_STATE_RUNNING);
456 OH_AudioStreamBuilder_Destroy(builder);
457 }
458
459 /**
460 * @tc.name : Test OH_AudioRenderer_GetCurrentState API via legal state.
461 * @tc.number: OH_AudioRenderer_GetCurrentState_003
462 * @tc.desc : Test OH_AudioRenderer_GetCurrentState interface. Return true if the result state is
463 * AUDIOSTREAM_STATE_PAUSED.
464 */
465 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetCurrentState_003, TestSize.Level0)
466 {
467 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
468 OH_AudioRenderer* audioRenderer;
469 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
470
471 OH_AudioRenderer_Start(audioRenderer);
472 OH_AudioRenderer_Pause(audioRenderer);
473
474 OH_AudioStream_State state;
475 result = OH_AudioRenderer_GetCurrentState(audioRenderer, &state);
476 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
477 EXPECT_TRUE(state == AUDIOSTREAM_STATE_PAUSED);
478 OH_AudioStreamBuilder_Destroy(builder);
479 }
480
481 /**
482 * @tc.name : Test OH_AudioRenderer_GetCurrentState API via legal state.
483 * @tc.number: OH_AudioRenderer_GetCurrentState_004
484 * @tc.desc : Test OH_AudioRenderer_GetCurrentState interface. Return true if the result state is
485 * AUDIOSTREAM_STATE_STOPPED.
486 */
487 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetCurrentState_004, TestSize.Level0)
488 {
489 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
490 OH_AudioRenderer* audioRenderer;
491 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
492
493 OH_AudioRenderer_Start(audioRenderer);
494 OH_AudioRenderer_Stop(audioRenderer);
495
496 OH_AudioStream_State state;
497 result = OH_AudioRenderer_GetCurrentState(audioRenderer, &state);
498 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
499 EXPECT_TRUE(state == AUDIOSTREAM_STATE_STOPPED);
500 OH_AudioStreamBuilder_Destroy(builder);
501 }
502
503 /**
504 * @tc.name : Test OH_AudioRenderer_GetCurrentState API via legal state.
505 * @tc.number: OH_AudioRenderer_GetCurrentState_005
506 * @tc.desc : Test OH_AudioRenderer_GetCurrentState interface. Return true if the result state is
507 * AUDIOSTREAM_STATE_RELEASED.
508 */
509 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetCurrentState_005, TestSize.Level0)
510 {
511 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
512 OH_AudioRenderer* audioRenderer;
513 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
514
515 OH_AudioRenderer_Start(audioRenderer);
516 OH_AudioRenderer_Release(audioRenderer);
517
518 OH_AudioStream_State state;
519 result = OH_AudioRenderer_GetCurrentState(audioRenderer, &state);
520 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
521 EXPECT_EQ(state, AUDIOSTREAM_STATE_INVALID);
522 OH_AudioStreamBuilder_Destroy(builder);
523 }
524
525 /**
526 * @tc.name : Test OH_AudioRenderer_GetLatencyMode API via legal state.
527 * @tc.number: OH_Audio_Render_GetParameter_001
528 * @tc.desc : Test OH_AudioRenderer_GetLatencyMode interface. Returns true if latencyMode is
529 * AUDIOSTREAM_LATENCY_MODE_NORMAL,because default latency mode is AUDIOSTREAM_LATENCY_MODE_NORMAL.
530 */
531 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetParameter_001, TestSize.Level0)
532 {
533 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
534 OH_AudioRenderer* audioRenderer;
535 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
536
537 OH_AudioStream_LatencyMode latencyMode = AUDIOSTREAM_LATENCY_MODE_NORMAL;
538 result = OH_AudioRenderer_GetLatencyMode(audioRenderer, &latencyMode);
539 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
540 EXPECT_TRUE(latencyMode == AUDIOSTREAM_LATENCY_MODE_NORMAL);
541 OH_AudioStreamBuilder_Destroy(builder);
542 }
543
544 /**
545 * @tc.name : Test OH_AudioRenderer_GetStreamId API via legal state.
546 * @tc.number: OH_Audio_Render_GetParameter_002
547 * @tc.desc : Test OH_AudioRenderer_GetStreamId interface. Returns true if the result is AUDIOSTREAM_SUCCESS.
548 */
549 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetParameter_002, TestSize.Level0)
550 {
551 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
552 OH_AudioRenderer* audioRenderer;
553 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
554
555 uint32_t streamId;
556 result = OH_AudioRenderer_GetStreamId(audioRenderer, &streamId);
557 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
558 OH_AudioStreamBuilder_Destroy(builder);
559 }
560
561 /**
562 * @tc.name : Test OH_AudioRenderer_GetSamplingRate API via legal state.
563 * @tc.number: OH_Audio_Render_GetSamplingRate_001
564 * @tc.desc : Test OH_AudioRenderer_GetSamplingRate interface. Returns true if samplingRate is
565 * SAMPLE_RATE_48000,because default samplingRate is SAMPLE_RATE_48000.
566 */
567 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetSamplingRate_001, TestSize.Level0)
568 {
569 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
570 OH_AudioRenderer* audioRenderer;
571 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
572
573 int32_t rate;
574 result = OH_AudioRenderer_GetSamplingRate(audioRenderer, &rate);
575 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
576 EXPECT_TRUE(rate == SAMPLE_RATE_48000);
577 OH_AudioStreamBuilder_Destroy(builder);
578 }
579
580 /**
581 * @tc.name : Test OH_AudioRenderer_GetSampleFormat API via legal state.
582 * @tc.number: OH_Audio_Render_GetSampleFormat_001
583 * @tc.desc : Test OH_AudioRenderer_GetSampleFormat interface. Returns true if sampleFormat is
584 * AUDIOSTREAM_SAMPLE_S16LE,because default sampleFormat is AUDIOSTREAM_SAMPLE_S16LE.
585 */
586 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetSampleFormat, TestSize.Level0)
587 {
588 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
589 OH_AudioRenderer* audioRenderer;
590 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
591
592 OH_AudioStream_SampleFormat sampleFormat;
593 result = OH_AudioRenderer_GetSampleFormat(audioRenderer, &sampleFormat);
594 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
595 EXPECT_TRUE(sampleFormat == AUDIOSTREAM_SAMPLE_S16LE);
596 OH_AudioStreamBuilder_Destroy(builder);
597 }
598
599 /**
600 * @tc.name : Test OH_AudioRenderer_GetEncodingType API via legal state.
601 * @tc.number: OH_Audio_Render_GetEncodingType_001
602 * @tc.desc : Test OH_AudioRenderer_GetEncodingType interface. Returns true if encodingType is
603 * ENCODING_PCM,because default encodingType is ENCODING_PCM.
604 */
605 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetEncodingType_001, TestSize.Level0)
606 {
607 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
608 OH_AudioRenderer* audioRenderer;
609 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
610
611 OH_AudioStream_EncodingType encodingType;
612 result = OH_AudioRenderer_GetEncodingType(audioRenderer, &encodingType);
613 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
614 EXPECT_TRUE(encodingType == AUDIOSTREAM_ENCODING_TYPE_RAW);
615 OH_AudioStreamBuilder_Destroy(builder);
616 }
617
618 /**
619 * @tc.name : Test OH_AudioRenderer_GetRendererInfo API via legal state.
620 * @tc.number: OH_Audio_Render_GetRendererInfo_001
621 * @tc.desc : Test OH_AudioRenderer_GetRendererInfo interface. Returns true if usage is STREAM_USAGE_MEDIA and content
622 * is CONTENT_TYPE_MUSIC.
623 */
624 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetRendererInfo_001, TestSize.Level0)
625 {
626 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
627 OH_AudioRenderer* audioRenderer;
628 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
629
630 OH_AudioStream_Usage usage;
631 result = OH_AudioRenderer_GetRendererInfo(audioRenderer, &usage);
632 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
633 EXPECT_EQ(usage, AUDIOSTREAM_USAGE_MUSIC);
634 OH_AudioStreamBuilder_Destroy(builder);
635 }
636
637 /**
638 * @tc.name : Test OH_AudioRenderer_GetRendererPrivacy API.
639 * @tc.number: OH_AudioRenderer_GetRendererPrivacy_001
640 * @tc.desc : Test OH_AudioRenderer_GetRendererPrivacy interface with default privacy AUDIO_STREAM_PRIVACY_TYPE_PUBLIC.
641 */
642 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetRendererPrivacy_001, TestSize.Level0)
643 {
644 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
645 OH_AudioRenderer* audioRenderer;
646 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
647
648 OH_AudioStream_PrivacyType privacyType;
649 result = OH_AudioRenderer_GetRendererPrivacy(audioRenderer, &privacyType);
650 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
651 EXPECT_EQ(privacyType, AUDIO_STREAM_PRIVACY_TYPE_PUBLIC);
652 OH_AudioStreamBuilder_Destroy(builder);
653 }
654
655 /**
656 * @tc.name : Test OH_AudioRenderer_GetRendererPrivacy API.
657 * @tc.number: OH_AudioRenderer_GetRendererPrivacy_002
658 * @tc.desc : Test OH_AudioRenderer_GetRendererPrivacy interface with privacy AUDIO_STREAM_PRIVACY_TYPE_PRIVATE.
659 */
660 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetRendererPrivacy_002, TestSize.Level0)
661 {
662 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
663 OH_AudioStream_Result privacyResult = OH_AudioStreamBuilder_SetRendererPrivacy(builder,
664 AUDIO_STREAM_PRIVACY_TYPE_PRIVATE);
665 EXPECT_EQ(privacyResult, AUDIOSTREAM_SUCCESS);
666 OH_AudioRenderer* audioRenderer;
667 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
668
669 OH_AudioStream_PrivacyType privacyType;
670 result = OH_AudioRenderer_GetRendererPrivacy(audioRenderer, &privacyType);
671 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
672 EXPECT_EQ(privacyType, AUDIO_STREAM_PRIVACY_TYPE_PRIVATE);
673 OH_AudioStreamBuilder_Destroy(builder);
674 }
675
676 /**
677 * @tc.name : Test OH_AudioRenderer_GetChannelLayout API via legal state.
678 * @tc.number: OH_AudioRenderer_GetChannelLayout_001
679 * @tc.desc : Test OH_AudioRenderer_GetChannelLayout interface. Returns true if channelLayout is
680 * CH_LAYOUT_UNKNOWN, because default channelLayout is CH_LAYOUT_UNKNOWN.
681 */
682 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetChannelLayout_001, TestSize.Level0)
683 {
684 OH_AudioStreamBuilder *builder = OHAudioRenderUnitTest::CreateRenderBuilder();
685 OH_AudioRenderer *audioRenderer;
686 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
687
688 OH_AudioChannelLayout channelLayout;
689 result = OH_AudioRenderer_GetChannelLayout(audioRenderer, &channelLayout);
690 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
691 EXPECT_TRUE(channelLayout == CH_LAYOUT_UNKNOWN);
692 OH_AudioStreamBuilder_Destroy(builder);
693 }
694
695 /**
696 * @tc.name : Test OH_AudioRenderer_GetEffectMode API via legal state.
697 * @tc.number: OH_AudioRenderer_GetEffectMode_001
698 * @tc.desc : Test OH_AudioRenderer_GetEffectMode interface. Returns true if effect mode is the same as set.
699 */
700 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetEffectMode_001, TestSize.Level0)
701 {
702 OH_AudioStreamBuilder *builder = OHAudioRenderUnitTest::CreateRenderBuilder();
703 OH_AudioRenderer *audioRenderer;
704 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
705
706 OH_AudioStream_AudioEffectMode effectMode;
707 result = OH_AudioRenderer_SetEffectMode(audioRenderer, EFFECT_DEFAULT);
708 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
709 result = OH_AudioRenderer_GetEffectMode(audioRenderer, &effectMode);
710 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
711 EXPECT_TRUE(effectMode == EFFECT_DEFAULT);
712 OH_AudioStreamBuilder_Destroy(builder);
713 }
714
715 /**
716 * @tc.name : Test OH_AudioRenderer_GetVolume API via illegal state.
717 * @tc.number: OH_Audio_Render_GetVolume_001
718 * @tc.desc : Test OH_AudioRenderer_GetVolume interface with nullptr audioRenderer.
719 */
720 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetVolume_001, TestSize.Level0)
721 {
722 OH_AudioRenderer* audioRenderer = nullptr;
723 float volume;
724 OH_AudioStream_Result result = OH_AudioRenderer_GetVolume(audioRenderer, &volume);
725 EXPECT_TRUE(result == AUDIOSTREAM_ERROR_INVALID_PARAM);
726 }
727
728 /**
729 * @tc.name : Test OH_AudioRenderer_GetVolume API via legal state.
730 * @tc.number: OH_Audio_Render_GetVolume_002
731 * @tc.desc : Test OH_AudioRenderer_GetVolume interface.
732 */
733 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetVolume_002, TestSize.Level0)
734 {
735 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
736 OH_AudioRenderer* audioRenderer;
737 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
738 float volume;
739 result = OH_AudioRenderer_GetVolume(audioRenderer, &volume);
740 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
741 OH_AudioStreamBuilder_Destroy(builder);
742 }
743
744 /**
745 * @tc.name : Test OH_AudioRenderer_GetVolume API via legal state.
746 * @tc.number: OH_Audio_Render_GetVolume_003
747 * @tc.desc : Test OH_AudioRenderer_GetVolume interface after set volume call.
748 */
749 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetVolume_003, TestSize.Level0)
750 {
751 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
752 OH_AudioRenderer* audioRenderer;
753 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
754 float volumeSet = 0.5;
755 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
756 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
757 float volumeGet;
758 result = OH_AudioRenderer_GetVolume(audioRenderer, &volumeGet);
759 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
760 EXPECT_EQ(volumeGet, 0.5);
761 OH_AudioStreamBuilder_Destroy(builder);
762 }
763
764 /**
765 * @tc.name : Test OH_AudioRenderer_GetVolume API via legal state.
766 * @tc.number: OH_Audio_Render_GetVolume_004
767 * @tc.desc : Test OH_AudioRenderer_GetVolume interface after set volume fails.
768 */
769 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetVolume_004, TestSize.Level0)
770 {
771 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
772 OH_AudioRenderer* audioRenderer;
773 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
774 float volumeSet = 0.5;
775 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
776 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
777 volumeSet = 1.5;
778 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
779 EXPECT_EQ(result, AUDIOSTREAM_ERROR_INVALID_PARAM);
780 float volumeGet;
781 result = OH_AudioRenderer_GetVolume(audioRenderer, &volumeGet);
782 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
783 EXPECT_EQ(volumeGet, 0.5);
784 OH_AudioStreamBuilder_Destroy(builder);
785 }
786
787 /**
788 * @tc.name : Test OH_AudioRenderer_SetVolume API via illegal state.
789 * @tc.number: OH_Audio_Render_SetVolume_001
790 * @tc.desc : Test OH_AudioRenderer_SetVolume interface with nullptr audioRenderer.
791 */
792 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetVolume_001, TestSize.Level0)
793 {
794 OH_AudioRenderer* audioRenderer = nullptr;
795 float volumeSet = 0.5;
796 OH_AudioStream_Result result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
797 EXPECT_TRUE(result == AUDIOSTREAM_ERROR_INVALID_PARAM);
798 }
799
800 /**
801 * @tc.name : Test OH_AudioRenderer_SetVolume API via legal state.
802 * @tc.number: OH_Audio_Render_SetVolume_002
803 * @tc.desc : Test OH_AudioRenderer_SetVolume interface between minimum and maximum volumes.
804 */
805 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetVolume_002, TestSize.Level0)
806 {
807 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
808 OH_AudioRenderer* audioRenderer;
809 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
810 float volumeSet = 0.5;
811 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
812 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
813 OH_AudioStreamBuilder_Destroy(builder);
814 }
815
816 /**
817 * @tc.name : Test OH_AudioRenderer_SetVolume API via legal state.
818 * @tc.number: OH_Audio_Render_SetVolume_003
819 * @tc.desc : Test OH_AudioRenderer_SetVolume interface for minimum and maximum volumes.
820 */
821 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetVolume_003, TestSize.Level0)
822 {
823 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
824 OH_AudioRenderer* audioRenderer;
825 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
826 float volumeSet = MIN_AUDIO_VOLUME;
827 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
828 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
829 volumeSet = MAX_AUDIO_VOLUME;
830 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
831 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
832 OH_AudioStreamBuilder_Destroy(builder);
833 }
834
835 /**
836 * @tc.name : Test OH_AudioRenderer_SetVolume API via illegal state.
837 * @tc.number: OH_Audio_Render_SetVolume_004
838 * @tc.desc : Test OH_AudioRenderer_SetVolume interface out of volumes range.
839 */
840 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetVolume_004, TestSize.Level0)
841 {
842 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
843 OH_AudioRenderer* audioRenderer;
844 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
845 float volumeSet = -0.5;
846 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
847 EXPECT_EQ(result, AUDIOSTREAM_ERROR_INVALID_PARAM);
848 volumeSet = -1.5;
849 result = OH_AudioRenderer_SetVolume(audioRenderer, volumeSet);
850 EXPECT_EQ(result, AUDIOSTREAM_ERROR_INVALID_PARAM);
851 OH_AudioStreamBuilder_Destroy(builder);
852 }
853
854 /**
855 * @tc.name : Test OH_AudioRenderer_SetVolumeWithRamp API via illegal state.
856 * @tc.number: OH_Audio_Render_SetVolumeWithRamp_001
857 * @tc.desc : Test OH_AudioRenderer_SetVolumeWithRamp interface with nullptr audioRenderer.
858 */
859 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetVolumeWithRamp_001, TestSize.Level0)
860 {
861 OH_AudioRenderer* audioRenderer = nullptr;
862 float volumeSet = MIN_AUDIO_VOLUME;
863 int32_t durationMs = DURATIONMS;
864 OH_AudioStream_Result result = OH_AudioRenderer_SetVolumeWithRamp(audioRenderer, volumeSet, durationMs);
865 EXPECT_EQ(result, AUDIOSTREAM_ERROR_INVALID_PARAM);
866 }
867
868 /**
869 * @tc.name : Test OH_AudioRenderer_SetVolumeWithRamp API via legal state.
870 * @tc.number: OH_Audio_Render_SetVolumeWithRamp_002
871 * @tc.desc : Test OH_AudioRenderer_SetVolumeWithRamp interface.
872 */
873 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetVolumeWithRamp_002, TestSize.Level0)
874 {
875 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
876 OH_AudioRenderer* audioRenderer;
877 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
878 float volumeSet = MIN_AUDIO_VOLUME;
879 int32_t durationMs = DURATIONMS;
880 result = OH_AudioRenderer_SetVolumeWithRamp(audioRenderer, volumeSet, durationMs);
881 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
882 OH_AudioStreamBuilder_Destroy(builder);
883 }
884
885 /**
886 * @tc.name : Test OH_AudioRenderer_SetMarkPosition API via illegal state.
887 * @tc.number: OH_Audio_Render_SetMarkPosition_001
888 * @tc.desc : Test OH_AudioRenderer_SetMarkPosition interface with nullptr audioRenderer.
889 */
890 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetMarkPosition_001, TestSize.Level0)
891 {
892 OH_AudioRenderer* audioRenderer = nullptr;
893 uint32_t samplePos = 1;
894 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
895 OH_AudioStream_Result result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
896 EXPECT_TRUE(result == AUDIOSTREAM_ERROR_INVALID_PARAM);
897 }
898
899 /**
900 * @tc.name : Test OH_AudioRenderer_SetMarkPosition API via legal state.
901 * @tc.number: OH_Audio_Render_SetMarkPosition_002
902 * @tc.desc : Test OH_AudioRenderer_SetMarkPosition interface.
903 */
904 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetMarkPosition_002, TestSize.Level0)
905 {
906 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
907 OH_AudioRenderer* audioRenderer;
908 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
909
910 uint32_t samplePos = 1;
911 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
912 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
913 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
914 OH_AudioStreamBuilder_Destroy(builder);
915 }
916
917 /**
918 * @tc.name : Test OH_AudioRenderer_SetMarkPosition API via illegal state.
919 * @tc.number: OH_Audio_Render_SetMarkPosition_003
920 * @tc.desc : Test OH_AudioRenderer_SetMarkPosition interface with incorrect samplepos value.
921 */
922 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetMarkPosition_003, TestSize.Level0)
923 {
924 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
925 OH_AudioRenderer* audioRenderer;
926 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
927
928 uint32_t samplePos = 0;
929 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
930 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
931 EXPECT_EQ(result, AUDIOSTREAM_ERROR_INVALID_PARAM);
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_004
938 * @tc.desc : Test OH_AudioRenderer_SetMarkPosition interface with callback.
939 */
940 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetMarkPosition_004, 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 EXPECT_EQ(g_flag, 0);
959 uint32_t samplePos = 1;
960 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
961 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
962 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
963
964 // 4. start
965 result = OH_AudioRenderer_Start(audioRenderer);
966 sleep(2);
967 EXPECT_EQ(g_flag, 1);
968 // 5. stop and release client
969 result = OH_AudioRenderer_Stop(audioRenderer);
970 result = OH_AudioRenderer_Release(audioRenderer);
971
972 // 6. destroy the builder
973 OH_AudioStreamBuilder_Destroy(builder);
974 }
975
976 /**
977 * @tc.name : Test OH_AudioRenderer_SetMarkPosition API via legal state.
978 * @tc.number: OH_Audio_Render_SetMarkPosition_005
979 * @tc.desc : Test OH_AudioRenderer_SetMarkPosition interface multiple times.
980 */
981 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetMarkPosition_005, TestSize.Level0)
982 {
983 // 1. create
984 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
985
986 // 2. set params and callbacks
987 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLING_RATE);
988 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_COUNT);
989 OH_AudioStreamBuilder_SetLatencyMode(builder, (OH_AudioStream_LatencyMode)LATENCY_FORMAT);
990 OH_AudioStreamBuilder_SetSampleFormat(builder, (OH_AudioStream_SampleFormat)SAMPLE_FORMAT);
991 OH_AudioRenderer_Callbacks callbacks;
992 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteData;
993 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, nullptr);
994 // 3. set buffer size to FRAME_SIZE
995 result = OH_AudioStreamBuilder_SetFrameSizeInCallback(builder, FRAME_SIZE);
996
997 OH_AudioRenderer* audioRenderer;
998 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
999 uint32_t samplePos = 1;
1000 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
1001 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1002 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1003 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1004 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1005
1006 // 4. start
1007 result = OH_AudioRenderer_Start(audioRenderer);
1008 sleep(2);
1009 EXPECT_EQ(g_flag, 1);
1010 // 5. stop and release client
1011 result = OH_AudioRenderer_Stop(audioRenderer);
1012 result = OH_AudioRenderer_Release(audioRenderer);
1013
1014 // 6. destroy the builder
1015 OH_AudioStreamBuilder_Destroy(builder);
1016 }
1017
1018 /**
1019 * @tc.name : Test OH_AudioRenderer_CancelMark API via illegal state.
1020 * @tc.number: OH_Audio_Render_CancelMark_001
1021 * @tc.desc : Test OH_AudioRenderer_CancelMark interface with nullptr audioRenderer.
1022 */
1023 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_CancelMark_001, TestSize.Level0)
1024 {
1025 OH_AudioRenderer* audioRenderer = nullptr;
1026 OH_AudioStream_Result result = OH_AudioRenderer_CancelMark(audioRenderer);
1027 EXPECT_TRUE(result == AUDIOSTREAM_ERROR_INVALID_PARAM);
1028 }
1029
1030 /**
1031 * @tc.name : Test OH_AudioRenderer_CancelMark API via legal state.
1032 * @tc.number: OH_Audio_Render_CancelMark_002
1033 * @tc.desc : Test OH_AudioRenderer_CancelMark interface without callback.
1034 */
1035 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_CancelMark_002, TestSize.Level0)
1036 {
1037 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
1038 OH_AudioRenderer* audioRenderer;
1039 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1040 result = OH_AudioRenderer_CancelMark(audioRenderer);
1041 EXPECT_TRUE(result == AUDIOSTREAM_SUCCESS);
1042 OH_AudioStreamBuilder_Destroy(builder);
1043 }
1044
1045 /**
1046 * @tc.name : Test OH_AudioRenderer_CancelMark API via legal state.
1047 * @tc.number: OH_Audio_Render_CancelMark_003
1048 * @tc.desc : Test OH_AudioRenderer_CancelMark interface with callback.
1049 */
1050 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_CancelMark_003, TestSize.Level0)
1051 {
1052 // 1. create
1053 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
1054
1055 // 2. set params and callbacks
1056 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLING_RATE);
1057 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_COUNT);
1058 OH_AudioStreamBuilder_SetLatencyMode(builder, (OH_AudioStream_LatencyMode)LATENCY_FORMAT);
1059 OH_AudioStreamBuilder_SetSampleFormat(builder, (OH_AudioStream_SampleFormat)SAMPLE_FORMAT);
1060 OH_AudioRenderer_Callbacks callbacks;
1061 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteData;
1062 OH_AudioStream_Result result = OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, nullptr);
1063 // 3. set buffer size to FRAME_SIZE
1064 result = OH_AudioStreamBuilder_SetFrameSizeInCallback(builder, FRAME_SIZE);
1065
1066 OH_AudioRenderer* audioRenderer;
1067 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1068 uint32_t samplePos = 2;
1069 OH_AudioRenderer_OnMarkReachedCallback callback = AudioRendererOnMarkReachedCb;
1070 result = OH_AudioRenderer_SetMarkPosition(audioRenderer, samplePos, callback, nullptr);
1071 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1072
1073 // 4. start
1074 result = OH_AudioRenderer_Start(audioRenderer);
1075 sleep(2);
1076 EXPECT_EQ(g_flag, 2);
1077
1078 // CancelMark
1079 result = OH_AudioRenderer_CancelMark(audioRenderer);
1080 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1081
1082 // 5. stop and release client
1083 result = OH_AudioRenderer_Stop(audioRenderer);
1084 result = OH_AudioRenderer_Release(audioRenderer);
1085
1086 // 6. destroy the builder
1087 OH_AudioStreamBuilder_Destroy(builder);
1088 }
1089
1090 /**
1091 * @tc.name : Test OH_AudioRenderer_GetUnderflowCount API.
1092 * @tc.number: OH_AudioRenderer_GetUnderflowCount_001
1093 * @tc.desc : Test OH_AudioRenderer_GetUnderflowCount interface.
1094 */
1095 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetUnderflowCount_001, TestSize.Level0)
1096 {
1097 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
1098
1099 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLE_RATE_48000);
1100 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_2);
1101 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_VOICE_COMMUNICATION;
1102 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
1103
1104 OHAudioRendererWriteCallbackMock writeCallbackMock;
1105
1106 OH_AudioRenderer_Callbacks callbacks;
1107 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteDataMock;
1108 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &writeCallbackMock);
1109
1110 OH_AudioRenderer* audioRenderer;
1111 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1112 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1113
1114 std::mutex mutex;
1115 std::condition_variable cv;
1116 int32_t count = 0;
1117 writeCallbackMock.Install([&count, &mutex, &cv](OH_AudioRenderer* renderer, void* userData,
1118 void* buffer,
__anonfc19bf590302(OH_AudioRenderer* renderer, void* userData, void* buffer, int32_t bufferLen) 1119 int32_t bufferLen) {
1120 std::lock_guard lock(mutex);
1121 cv.notify_one();
1122
1123 // sleep time trigger underflow
1124 if (count == 1) {
1125 std::this_thread::sleep_for(200ms);
1126 }
1127 count++;
1128 });
1129
1130 result = OH_AudioRenderer_Start(audioRenderer);
1131 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1132
1133 std::unique_lock lock(mutex);
__anonfc19bf590402null1134 cv.wait_for(lock, 1s, [&count] {
1135 // count > 1 ensure sleeped
1136 return count > 1;
1137 });
1138 lock.unlock();
1139
1140 uint32_t underFlowCount;
1141 result = OH_AudioRenderer_GetUnderflowCount(audioRenderer, &underFlowCount);
1142 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1143 EXPECT_GE(underFlowCount, 1);
1144
1145 OH_AudioRenderer_Stop(audioRenderer);
1146 OH_AudioRenderer_Release(audioRenderer);
1147
1148 OH_AudioStreamBuilder_Destroy(builder);
1149 }
1150
1151 /**
1152 * @tc.name : Test OH_AudioRenderer_GetUnderflowCount API.
1153 * @tc.number: OH_AudioRenderer_GetUnderflowCount_002
1154 * @tc.desc : Test OH_AudioRenderer_GetUnderflowCount interface.
1155 */
1156 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetUnderflowCount_002, TestSize.Level0)
1157 {
1158 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
1159
1160 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLE_RATE_48000);
1161 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_2);
1162 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_VOICE_COMMUNICATION;
1163 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
1164
1165 OHAudioRendererWriteCallbackMock writeCallbackMock;
1166
1167 OH_AudioRenderer_Callbacks callbacks;
1168 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteDataMock;
1169 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &writeCallbackMock);
1170
1171 OH_AudioRenderer* audioRenderer;
1172 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1173 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1174
1175 std::mutex mutex;
1176 std::condition_variable cv;
1177 int32_t count = 0;
1178 writeCallbackMock.Install([&count, &mutex, &cv](OH_AudioRenderer* renderer, void* userData,
1179 void* buffer,
__anonfc19bf590502(OH_AudioRenderer* renderer, void* userData, void* buffer, int32_t bufferLen) 1180 int32_t bufferLen) {
1181 std::lock_guard lock(mutex);
1182 cv.notify_one();
1183
1184 // sleep time trigger underflow
1185 if (count == 0) {
1186 std::this_thread::sleep_for(200ms);
1187 }
1188 count++;
1189 });
1190
1191 result = OH_AudioRenderer_Start(audioRenderer);
1192 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1193
1194 std::unique_lock lock(mutex);
__anonfc19bf590602null1195 cv.wait_for(lock, 1s, [&count] {
1196 // count > 1 ensure sleeped
1197 return count > 1;
1198 });
1199 lock.unlock();
1200
1201 uint32_t underFlowCount;
1202 result = OH_AudioRenderer_GetUnderflowCount(audioRenderer, &underFlowCount);
1203 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1204 EXPECT_EQ(underFlowCount, 0);
1205
1206 OH_AudioRenderer_Stop(audioRenderer);
1207 OH_AudioRenderer_Release(audioRenderer);
1208
1209 OH_AudioStreamBuilder_Destroy(builder);
1210 }
1211
1212 /**
1213 * @tc.name : Test OH_AudioRenderer_GetUnderflowCount API.
1214 * @tc.number: OH_AudioRenderer_GetUnderflowCount_003
1215 * @tc.desc : Test OH_AudioRenderer_GetUnderflowCount interface.
1216 */
1217 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetUnderflowCount_003, TestSize.Level0)
1218 {
1219 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
1220
1221 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLE_RATE_48000);
1222 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_2);
1223 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_VOICE_COMMUNICATION;
1224 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
1225
1226 OHAudioRendererWriteCallbackMock writeCallbackMock;
1227
1228 OH_AudioRenderer_Callbacks callbacks;
1229 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteDataMock;
1230 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &writeCallbackMock);
1231
1232 OH_AudioRenderer* audioRenderer;
1233 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1234 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1235
1236 result = OH_AudioRenderer_Start(audioRenderer);
1237 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1238
1239 uint32_t underFlowCount;
1240 result = OH_AudioRenderer_GetUnderflowCount(audioRenderer, &underFlowCount);
1241 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1242 EXPECT_EQ(underFlowCount, 0);
1243
1244 OH_AudioRenderer_Stop(audioRenderer);
1245 OH_AudioRenderer_Release(audioRenderer);
1246
1247 OH_AudioStreamBuilder_Destroy(builder);
1248 }
1249
1250 /**
1251 * @tc.name : Test OH_AudioRenderer_GetUnderflowCount API.
1252 * @tc.number: OH_AudioRenderer_GetUnderflowCount_004
1253 * @tc.desc : Test OH_AudioRenderer_GetUnderflowCount interface.
1254 */
1255 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetUnderflowCount_004, TestSize.Level0)
1256 {
1257 uint32_t lastUnderFlowCount = 0;
1258 for (auto sleepTimes : {200ms, 400ms, 600ms}) {
1259 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
1260
1261 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLE_RATE_48000);
1262 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_2);
1263 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_VOICE_COMMUNICATION;
1264 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
1265
1266 OHAudioRendererWriteCallbackMock writeCallbackMock;
1267
1268 OH_AudioRenderer_Callbacks callbacks;
1269 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteDataMock;
1270 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &writeCallbackMock);
1271
1272 OH_AudioRenderer* audioRenderer;
1273 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1274 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1275
1276 std::mutex mutex;
1277 std::condition_variable cv;
1278 int32_t count = 0;
1279 writeCallbackMock.Install([&count, &mutex, &cv, sleepTimes](OH_AudioRenderer* renderer, void* userData,
1280 void* buffer,
__anonfc19bf590702(OH_AudioRenderer* renderer, void* userData, void* buffer, int32_t bufferLen) 1281 int32_t bufferLen) {
1282 std::lock_guard lock(mutex);
1283 cv.notify_one();
1284
1285 // sleep time trigger underflow
1286 if (count == 1) {
1287 std::this_thread::sleep_for(sleepTimes);
1288 }
1289 count++;
1290 });
1291
1292 result = OH_AudioRenderer_Start(audioRenderer);
1293 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1294
1295 std::unique_lock lock(mutex);
__anonfc19bf590802null1296 cv.wait_for(lock, 1s, [&count] {
1297 // count > 1 ensure sleeped
1298 return count > 10;
1299 });
1300 lock.unlock();
1301
1302 uint32_t underFlowCount = 0;
1303 result = OH_AudioRenderer_GetUnderflowCount(audioRenderer, &underFlowCount);
1304 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1305 EXPECT_GT(underFlowCount, lastUnderFlowCount);
1306 lastUnderFlowCount = underFlowCount;
1307
1308 OH_AudioRenderer_Stop(audioRenderer);
1309 OH_AudioRenderer_Release(audioRenderer);
1310
1311 OH_AudioStreamBuilder_Destroy(builder);
1312 }
1313 }
1314
1315 /**
1316 * @tc.name : Test OH_AudioRenderer_GetUnderflowCount API.
1317 * @tc.number: OH_AudioRenderer_GetUnderflowCount_005
1318 * @tc.desc : Test OH_AudioRenderer_GetUnderflowCount interface.
1319 */
1320 HWTEST(OHAudioRenderUnitTest, OH_AudioRenderer_GetUnderflowCount_005, TestSize.Level0)
1321 {
1322 OH_AudioStreamBuilder* builder = OHAudioRenderUnitTest::CreateRenderBuilder();
1323
1324 OH_AudioStreamBuilder_SetSamplingRate(builder, SAMPLE_RATE_48000);
1325 OH_AudioStreamBuilder_SetChannelCount(builder, CHANNEL_2);
1326 OH_AudioStream_Usage usage = AUDIOSTREAM_USAGE_VOICE_COMMUNICATION;
1327 OH_AudioStreamBuilder_SetRendererInfo(builder, usage);
1328
1329 OHAudioRendererWriteCallbackMock writeCallbackMock;
1330
1331 OH_AudioRenderer_Callbacks callbacks;
1332 callbacks.OH_AudioRenderer_OnWriteData = AudioRendererOnWriteDataMock;
1333 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &writeCallbackMock);
1334
1335 OH_AudioRenderer* audioRenderer;
1336 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1337 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1338
1339 result = OH_AudioRenderer_Start(audioRenderer);
1340 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1341
1342 std::this_thread::sleep_for(1s);
1343
1344 uint32_t underFlowCount;
1345 result = OH_AudioRenderer_GetUnderflowCount(audioRenderer, &underFlowCount);
1346 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1347 EXPECT_EQ(underFlowCount, 0);
1348
1349 OH_AudioRenderer_Stop(audioRenderer);
1350 OH_AudioRenderer_Release(audioRenderer);
1351
1352 OH_AudioStreamBuilder_Destroy(builder);
1353 }
1354
1355 /**
1356 * @tc.name : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback API via legal state.
1357 * @tc.number: OH_Audio_Render_WriteDataCallback_001
1358 * @tc.desc : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback interface with VALID result.
1359 * Returns true if result is successful.
1360 */
1361 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_WriteDataCallback_001, TestSize.Level0)
1362 {
1363 OH_AudioStreamBuilder* builder = InitRenderBuilder();
1364
1365 OH_AudioRenderer_OnWriteDataCallback callback = OnWriteDataCallbackWithValidData;
1366 OH_AudioStreamBuilder_SetRendererWriteDataCallback(builder, callback, nullptr);
1367
1368 OH_AudioRenderer* audioRenderer;
1369 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1370 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1371
1372 result = OH_AudioRenderer_Start(audioRenderer);
1373 sleep(2);
1374 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1375
1376 CleanupAudioResources(builder, audioRenderer);
1377 }
1378
1379 /**
1380 * @tc.name : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback API via legal state.
1381 * @tc.number: OH_Audio_Render_WriteDataCallback_002
1382 * @tc.desc : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback interface with INVALID result.
1383 * Returns true if result is successful.
1384 */
1385 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_WriteDataCallback_002, TestSize.Level0)
1386 {
1387 OH_AudioStreamBuilder* builder = InitRenderBuilder();
1388
1389 OH_AudioRenderer_OnWriteDataCallback callback = OnWriteDataCallbackWithInvalidData;
1390 OH_AudioStreamBuilder_SetRendererWriteDataCallback(builder, callback, nullptr);
1391
1392 OH_AudioRenderer* audioRenderer;
1393 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1394 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1395
1396 result = OH_AudioRenderer_Start(audioRenderer);
1397 sleep(2);
1398 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1399
1400 CleanupAudioResources(builder, audioRenderer);
1401 }
1402
1403 /**
1404 * @tc.name : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback API via legal state.
1405 * @tc.number: OH_Audio_Render_WriteDataCallback_003
1406 * @tc.desc : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback interface with VALID result
1407 * overwrites OH_AudioStreamBuilder_SetRendererCallback interface.
1408 * Returns true if result is successful.
1409 */
1410 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_WriteDataCallback_003, TestSize.Level0)
1411 {
1412 OH_AudioStreamBuilder* builder = InitRenderBuilder();
1413
1414 UserData userData;
1415 OH_AudioRenderer_Callbacks callbacks;
1416 callbacks.OH_AudioRenderer_OnWriteData = OnWriteDataCbMock;
1417 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &userData);
1418
1419 OH_AudioRenderer_OnWriteDataCallback callback = OnWriteDataCbWithValidDataMock;
1420 OH_AudioStreamBuilder_SetRendererWriteDataCallback(builder, callback, &userData);
1421
1422 OH_AudioRenderer* audioRenderer;
1423 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1424 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1425
1426 result = OH_AudioRenderer_Start(audioRenderer);
1427 sleep(2);
1428 EXPECT_TRUE(userData.writeDataCallbackType == UserData::WRITE_DATA_CALLBACK_WITH_RESULT);
1429
1430 CleanupAudioResources(builder, audioRenderer);
1431 }
1432
1433 /**
1434 * @tc.name : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback API via legal state.
1435 * @tc.number: OH_Audio_Render_WriteDataCallback_004
1436 * @tc.desc : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback interface with INVALID result
1437 * overwrites OH_AudioStreamBuilder_SetRendererCallback interface.
1438 * Returns true if result is successful.
1439 */
1440 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_WriteDataCallback_004, TestSize.Level0)
1441 {
1442 OH_AudioStreamBuilder* builder = InitRenderBuilder();
1443
1444 UserData userData;
1445 OH_AudioRenderer_Callbacks callbacks;
1446 callbacks.OH_AudioRenderer_OnWriteData = OnWriteDataCbMock;
1447 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &userData);
1448
1449 OH_AudioRenderer_OnWriteDataCallback callback = OnWriteDataCbWithInvalidDataMock;
1450 OH_AudioStreamBuilder_SetRendererWriteDataCallback(builder, callback, &userData);
1451
1452 OH_AudioRenderer* audioRenderer;
1453 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1454 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1455
1456 result = OH_AudioRenderer_Start(audioRenderer);
1457 sleep(2);
1458 EXPECT_TRUE(userData.writeDataCallbackType == UserData::WRITE_DATA_CALLBACK_WITH_RESULT);
1459
1460 CleanupAudioResources(builder, audioRenderer);
1461 }
1462
1463 /**
1464 * @tc.name : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback API via legal state.
1465 * @tc.number: OH_Audio_Render_WriteDataCallback_005
1466 * @tc.desc : Test OH_AudioStreamBuilder_SetRendererCallback interface
1467 * overwrites OH_AudioStreamBuilder_SetRendererWriteDataCallback interface with VALID result.
1468 * Returns true if result is successful.
1469 */
1470 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_WriteDataCallback_005, TestSize.Level0)
1471 {
1472 OH_AudioStreamBuilder* builder = InitRenderBuilder();
1473
1474 UserData userData;
1475 OH_AudioRenderer_OnWriteDataCallback callback = OnWriteDataCbWithValidDataMock;
1476 OH_AudioStreamBuilder_SetRendererWriteDataCallback(builder, callback, &userData);
1477
1478 OH_AudioRenderer_Callbacks callbacks;
1479 callbacks.OH_AudioRenderer_OnWriteData = OnWriteDataCbMock;
1480 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &userData);
1481
1482 OH_AudioRenderer* audioRenderer;
1483 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1484 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1485
1486 result = OH_AudioRenderer_Start(audioRenderer);
1487 sleep(2);
1488 EXPECT_TRUE(userData.writeDataCallbackType == UserData::WRITE_DATA_CALLBACK);
1489
1490 CleanupAudioResources(builder, audioRenderer);
1491 }
1492
1493 /**
1494 * @tc.name : Test OH_AudioStreamBuilder_SetRendererWriteDataCallback API via legal state.
1495 * @tc.number: OH_Audio_Render_WriteDataCallback_006
1496 * @tc.desc : Test OH_AudioStreamBuilder_SetRendererCallback interface
1497 * overwrites OH_AudioStreamBuilder_SetRendererWriteDataCallback interface with INVALID result.
1498 * Returns true if result is successful.
1499 */
1500 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_WriteDataCallback_006, TestSize.Level0)
1501 {
1502 OH_AudioStreamBuilder* builder = InitRenderBuilder();
1503
1504 UserData userData;
1505 OH_AudioRenderer_OnWriteDataCallback callback = OnWriteDataCbWithInvalidDataMock;
1506 OH_AudioStreamBuilder_SetRendererWriteDataCallback(builder, callback, &userData);
1507 OH_AudioRenderer_Callbacks callbacks;
1508 callbacks.OH_AudioRenderer_OnWriteData = OnWriteDataCbMock;
1509 OH_AudioStreamBuilder_SetRendererCallback(builder, callbacks, &userData);
1510
1511 OH_AudioRenderer* audioRenderer;
1512 OH_AudioStream_Result result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1513 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1514
1515 result = OH_AudioRenderer_Start(audioRenderer);
1516 sleep(2);
1517 EXPECT_TRUE(userData.writeDataCallbackType == UserData::WRITE_DATA_CALLBACK);
1518
1519 CleanupAudioResources(builder, audioRenderer);
1520 }
1521 } // namespace AudioStandard
1522 } // namespace OHOS
1523