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_GAME;
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,
__anon9acfe6bb0302(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);
__anon9acfe6bb0402null1093 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_GAME;
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,
__anon9acfe6bb0502(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);
__anon9acfe6bb0602null1154 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_GT(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_GAME;
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_GAME;
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,
__anon9acfe6bb0702(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);
__anon9acfe6bb0802null1255 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_GAME;
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
1481 /**
1482 * @tc.name : OH_AudioRenderer_SetLoudnessGain_001
1483 * @tc.number: OH_AudioRenderer_SetLoudnessGain_001
1484 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1485 * overwrites OH_AudioRenderer_SetLoudnessGain interface'right test.
1486 * loudness is -90.0 and streamtype is music.
1487 * Returns AUDIOSTREAM_SUCCESS if result is successful.
1488 */
1489 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_001, TestSize.Level0)
1490 {
1491 OH_AudioStreamBuilder* builder = nullptr;
1492 OH_AudioRenderer* audioRenderer = nullptr;
1493 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
1494 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1495
1496 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
1497
1498 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_MUSIC);
1499
1500 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1501 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1502
1503 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, -90.0f);
1504 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1505 sleep(1);
1506
1507 float loudnessGain = 0;
1508 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
1509 EXPECT_TRUE(AUDIOSTREAM_SUCCESS == result && -90.0f == loudnessGain);
1510 result = OH_AudioRenderer_Release(audioRenderer);
1511 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1512 OH_AudioStreamBuilder_Destroy(builder);
1513 }
1514
1515 /**
1516 * @tc.name : OH_AudioRenderer_SetLoudnessGain_002
1517 * @tc.number: OH_AudioRenderer_SetLoudnessGain_002
1518 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1519 * overwrites OH_AudioRenderer_SetLoudnessGain interface'right test.
1520 * loudness is -89.9 and streamtype is music.
1521 * Returns AUDIOSTREAM_SUCCESS if result is successful.
1522 */
1523 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_002, TestSize.Level0)
1524 {
1525 OH_AudioStreamBuilder* builder = nullptr;
1526 OH_AudioRenderer* audioRenderer = nullptr;
1527 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
1528 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1529
1530 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
1531
1532 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_MUSIC);
1533
1534 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1535 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1536
1537 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, -89.9f);
1538 sleep(1);
1539 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1540
1541 float loudnessGain = 0;
1542 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
1543 EXPECT_TRUE((AUDIOSTREAM_SUCCESS == result) && (-89.9 - loudnessGain < 0.1 || loudnessGain + 89.9 < 0.1));
1544 result = OH_AudioRenderer_Release(audioRenderer);
1545 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1546 OH_AudioStreamBuilder_Destroy(builder);
1547 }
1548
1549 /**
1550 * @tc.name : OH_AudioRenderer_SetLoudnessGain_003
1551 * @tc.number: OH_AudioRenderer_SetLoudnessGain_003
1552 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1553 * overwrites OH_AudioRenderer_SetLoudnessGain interface'right test.
1554 * loudness is 24.0 and streamtype is movie.
1555 * Returns AUDIOSTREAM_SUCCESS if result is successful.
1556 */
1557 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_003, TestSize.Level0)
1558 {
1559 OH_AudioStreamBuilder* builder = nullptr;
1560 OH_AudioRenderer* audioRenderer = nullptr;
1561 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
1562 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1563
1564 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
1565
1566 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_MOVIE);
1567
1568 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1569 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1570
1571 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 24.0f);
1572 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1573 sleep(1);
1574
1575 float loudnessGain = 0;
1576 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
1577 EXPECT_TRUE(AUDIOSTREAM_SUCCESS == result && 24.0f == loudnessGain);
1578 result = OH_AudioRenderer_Release(audioRenderer);
1579 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1580 OH_AudioStreamBuilder_Destroy(builder);
1581 }
1582
1583 /**
1584 * @tc.name : OH_AudioRenderer_SetLoudnessGain_004
1585 * @tc.number: OH_AudioRenderer_SetLoudnessGain_004
1586 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1587 * overwrites OH_AudioRenderer_SetLoudnessGain interface'right test.
1588 * loudness is 23.9 and streamtype is audiobook.
1589 * Returns AUDIOSTREAM_SUCCESS if result is successful.
1590 */
1591 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_004, TestSize.Level0)
1592 {
1593 OH_AudioStreamBuilder* builder = nullptr;
1594 OH_AudioRenderer* audioRenderer = nullptr;
1595 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
1596 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1597
1598 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
1599
1600 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_AUDIOBOOK);
1601
1602 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1603 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1604
1605 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 23.9f);
1606 sleep(1);
1607 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1608
1609 float loudnessGain = 0;
1610 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
1611 EXPECT_TRUE((AUDIOSTREAM_SUCCESS == result) && (23.9 - loudnessGain < 0.1 || loudnessGain - 23.9 < 0.1));
1612 result = OH_AudioRenderer_Release(audioRenderer);
1613 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1614 OH_AudioStreamBuilder_Destroy(builder);
1615 }
1616
1617 /**
1618 * @tc.name : OH_AudioRenderer_SetLoudnessGain_005
1619 * @tc.number: OH_AudioRenderer_SetLoudnessGain_005
1620 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1621 * overwrites OH_AudioRenderer_SetLoudnessGain interface'right test.
1622 * super low-power.
1623 * Returns AUDIOSTREAM_SUCCESS if result is successful.
1624 */
1625 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_005, TestSize.Level0)
1626 {
1627 OH_AudioStreamBuilder* builder = nullptr;
1628 OH_AudioRenderer* audioRenderer = nullptr;
1629 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
1630 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1631
1632 OH_AudioStreamBuilder_SetLatencyMode(builder, (OH_AudioStream_LatencyMode)5);
1633
1634 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_MOVIE);
1635
1636 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1637 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1638
1639 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 24.0f);
1640 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1641 sleep(1);
1642
1643 float loudnessGain = 0;
1644 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
1645 EXPECT_TRUE(AUDIOSTREAM_SUCCESS == result && 24.0f == loudnessGain);
1646 result = OH_AudioRenderer_Release(audioRenderer);
1647 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1648 OH_AudioStreamBuilder_Destroy(builder);
1649 }
1650
1651 /**
1652 * @tc.name : OH_AudioRenderer_SetLoudnessGain_006
1653 * @tc.number: OH_AudioRenderer_SetLoudnessGain_006
1654 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1655 * overwrites OH_AudioRenderer_SetLoudnessGain interface'back test.
1656 * loudness is -90.1.
1657 * Returns AUDIOSTREAM_ERROR_INVALID_PARAM if result is fail.
1658 */
1659 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_006, TestSize.Level1)
1660 {
1661 OH_AudioStreamBuilder* builder = nullptr;
1662 OH_AudioRenderer* audioRenderer = nullptr;
1663 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
1664 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1665
1666 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
1667
1668 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_AUDIOBOOK);
1669
1670 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1671 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1672
1673 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, -90.1f);
1674 sleep(1);
1675 EXPECT_TRUE(AUDIOSTREAM_ERROR_INVALID_PARAM == result);
1676 result = OH_AudioRenderer_Release(audioRenderer);
1677 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1678 OH_AudioStreamBuilder_Destroy(builder);
1679 }
1680
1681 /**
1682 * @tc.name : OH_AudioRenderer_SetLoudnessGain_007
1683 * @tc.number: OH_AudioRenderer_SetLoudnessGain_007
1684 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1685 * overwrites OH_AudioRenderer_SetLoudnessGain interface'back test.
1686 * loudness is 24.1.
1687 * Returns AUDIOSTREAM_ERROR_INVALID_PARAM if result is fail.
1688 */
1689 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_007, TestSize.Level1)
1690 {
1691 OH_AudioStreamBuilder* builder = nullptr;
1692 OH_AudioRenderer* audioRenderer = nullptr;
1693 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
1694 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1695
1696 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
1697
1698 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_AUDIOBOOK);
1699
1700 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1701 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1702
1703 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 24.1f);
1704 sleep(1);
1705 EXPECT_TRUE(AUDIOSTREAM_ERROR_INVALID_PARAM == result);
1706 result = OH_AudioRenderer_Release(audioRenderer);
1707 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1708 OH_AudioStreamBuilder_Destroy(builder);
1709 }
1710
1711 /**
1712 * @tc.name : OH_AudioRenderer_SetLoudnessGain_008
1713 * @tc.number: OH_AudioRenderer_SetLoudnessGain_008
1714 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1715 * overwrites OH_AudioRenderer_SetLoudnessGain interface'back test.
1716 * OH_AudioRenderer_SetLoudnessGain'renderer is nullptr.
1717 * Returns AUDIOSTREAM_ERROR_INVALID_PARAM if result is fail.
1718 */
1719 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_008, TestSize.Level2)
1720 {
1721 OH_AudioStreamBuilder* builder = nullptr;
1722 OH_AudioRenderer* audioRenderer = nullptr;
1723 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
1724 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1725
1726 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
1727
1728 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_AUDIOBOOK);
1729
1730 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1731 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1732
1733 result = OH_AudioRenderer_SetLoudnessGain(nullptr, 24.0f);
1734 sleep(1);
1735
1736 EXPECT_TRUE(AUDIOSTREAM_ERROR_INVALID_PARAM == result);
1737 result = OH_AudioRenderer_Release(audioRenderer);
1738 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1739 OH_AudioStreamBuilder_Destroy(builder);
1740 }
1741
1742 /**
1743 * @tc.name : OH_AudioRenderer_SetLoudnessGain_010
1744 * @tc.number: OH_AudioRenderer_SetLoudnessGain_010
1745 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1746 * overwrites OH_AudioRenderer_SetLoudnessGain interface'back test.
1747 * streamtype is AUDIOSTREAM_USAGE_VOICE_COMMUNICATION.
1748 * Returns AUDIOSTREAM_ERROR_INVALID_PARAM if result is fail.
1749 */
1750 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_010, TestSize.Level2)
1751 {
1752 OH_AudioStreamBuilder* builder = nullptr;
1753 OH_AudioRenderer* audioRenderer = nullptr;
1754 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
1755 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1756
1757 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
1758
1759 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_VOICE_COMMUNICATION);
1760
1761 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1762 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1763
1764 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 24.0f);
1765 EXPECT_TRUE(AUDIOSTREAM_ERROR_INVALID_PARAM == result);
1766 sleep(1);
1767
1768 float loudnessGain = 1;
1769 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
1770 EXPECT_TRUE((AUDIOSTREAM_SUCCESS == result) && (loudnessGain == 0));
1771
1772 result = OH_AudioRenderer_Release(audioRenderer);
1773 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1774 OH_AudioStreamBuilder_Destroy(builder);
1775 }
1776
1777 /**
1778 * @tc.name : OH_AudioRenderer_SetLoudnessGain_011
1779 * @tc.number: OH_AudioRenderer_SetLoudnessGain_011
1780 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1781 * overwrites OH_AudioRenderer_SetLoudnessGain interface'back test.
1782 * streamtype is AUDIOSTREAM_USAGE_VOICE_ASSISTANT.
1783 * Returns AUDIOSTREAM_ERROR_INVALID_PARAM if result is fail.
1784 */
1785 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_011, TestSize.Level2)
1786 {
1787 OH_AudioStreamBuilder* builder = nullptr;
1788 OH_AudioRenderer* audioRenderer = nullptr;
1789 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
1790 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1791
1792 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
1793
1794 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_VOICE_ASSISTANT);
1795
1796 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1797 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1798
1799 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 24.0f);
1800 EXPECT_TRUE(AUDIOSTREAM_ERROR_INVALID_PARAM == result);
1801 sleep(1);
1802
1803 float loudnessGain = 1;
1804 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
1805 EXPECT_TRUE((AUDIOSTREAM_SUCCESS == result) && (loudnessGain == 0));
1806
1807 result = OH_AudioRenderer_Release(audioRenderer);
1808 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1809 OH_AudioStreamBuilder_Destroy(builder);
1810 }
1811
1812 /**
1813 * @tc.name : OH_AudioRenderer_SetLoudnessGain_012
1814 * @tc.number: OH_AudioRenderer_SetLoudnessGain_012
1815 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1816 * overwrites OH_AudioRenderer_SetLoudnessGain interface'back test.
1817 * streamtype is AUDIOSTREAM_USAGE_ALARM.
1818 * Returns AUDIOSTREAM_ERROR_INVALID_PARAM if result is fail.
1819 */
1820 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_012, TestSize.Level2)
1821 {
1822 OH_AudioStreamBuilder* builder = nullptr;
1823 OH_AudioRenderer* audioRenderer = nullptr;
1824 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
1825 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1826
1827 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
1828
1829 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_ALARM);
1830
1831 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1832 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1833
1834 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 24.0f);
1835 EXPECT_TRUE(AUDIOSTREAM_ERROR_INVALID_PARAM == result);
1836 sleep(1);
1837
1838 float loudnessGain = 1;
1839 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
1840 EXPECT_TRUE((AUDIOSTREAM_SUCCESS == result) && (loudnessGain == 0));
1841
1842 result = OH_AudioRenderer_Release(audioRenderer);
1843 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1844 OH_AudioStreamBuilder_Destroy(builder);
1845 }
1846
1847 /**
1848 * @tc.name : OH_AudioRenderer_SetLoudnessGain_013
1849 * @tc.number: OH_AudioRenderer_SetLoudnessGain_013
1850 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1851 * overwrites OH_AudioRenderer_SetLoudnessGain interface'back test.
1852 * streamtype is AUDIOSTREAM_USAGE_VOICE_MESSAGE.
1853 * Returns AUDIOSTREAM_ERROR_INVALID_PARAM if result is fail.
1854 */
1855 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_013, TestSize.Level2)
1856 {
1857 OH_AudioStreamBuilder* builder = nullptr;
1858 OH_AudioRenderer* audioRenderer = nullptr;
1859 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
1860 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1861
1862 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
1863
1864 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_VOICE_MESSAGE);
1865
1866 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1867 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1868
1869 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 24.0f);
1870 EXPECT_TRUE(AUDIOSTREAM_ERROR_INVALID_PARAM == result);
1871 sleep(1);
1872
1873 float loudnessGain = 1;
1874 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
1875 EXPECT_TRUE((AUDIOSTREAM_SUCCESS == result) && (loudnessGain == 0));
1876
1877 result = OH_AudioRenderer_Release(audioRenderer);
1878 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1879 OH_AudioStreamBuilder_Destroy(builder);
1880 }
1881
1882 /**
1883 * @tc.name : OH_AudioRenderer_SetLoudnessGain_014
1884 * @tc.number: OH_AudioRenderer_SetLoudnessGain_014
1885 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1886 * overwrites OH_AudioRenderer_SetLoudnessGain interface'back test.
1887 * streamtype is AUDIOSTREAM_USAGE_RINGTONE.
1888 * Returns AUDIOSTREAM_ERROR_INVALID_PARAM if result is fail.
1889 */
1890 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_014, TestSize.Level2)
1891 {
1892 OH_AudioStreamBuilder* builder = nullptr;
1893 OH_AudioRenderer* audioRenderer = nullptr;
1894 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
1895 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1896
1897 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
1898
1899 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_RINGTONE);
1900
1901 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1902 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1903
1904 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 24.0f);
1905 EXPECT_TRUE(AUDIOSTREAM_ERROR_INVALID_PARAM == result);
1906 sleep(1);
1907
1908 float loudnessGain = 1;
1909 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
1910 EXPECT_TRUE((AUDIOSTREAM_SUCCESS == result) && (loudnessGain == 0));
1911
1912 result = OH_AudioRenderer_Release(audioRenderer);
1913 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1914 OH_AudioStreamBuilder_Destroy(builder);
1915 }
1916
1917 /**
1918 * @tc.name : OH_AudioRenderer_SetLoudnessGain_015
1919 * @tc.number: OH_AudioRenderer_SetLoudnessGain_015
1920 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1921 * overwrites OH_AudioRenderer_SetLoudnessGain interface'back test.
1922 * streamtype is AUDIOSTREAM_USAGE_NOTIFICATION.
1923 * Returns AUDIOSTREAM_ERROR_INVALID_PARAM if result is fail.
1924 */
1925 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_015, TestSize.Level2)
1926 {
1927 OH_AudioStreamBuilder* builder = nullptr;
1928 OH_AudioRenderer* audioRenderer = nullptr;
1929 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
1930 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1931
1932 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
1933
1934 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_NOTIFICATION);
1935
1936 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1937 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1938
1939 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 24.0f);
1940 EXPECT_TRUE(AUDIOSTREAM_ERROR_INVALID_PARAM == result);
1941 sleep(1);
1942
1943 float loudnessGain = 1;
1944 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
1945 EXPECT_TRUE((AUDIOSTREAM_SUCCESS == result) && (loudnessGain == 0));
1946
1947 result = OH_AudioRenderer_Release(audioRenderer);
1948 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1949 OH_AudioStreamBuilder_Destroy(builder);
1950 }
1951
1952 /**
1953 * @tc.name : OH_AudioRenderer_SetLoudnessGain_017
1954 * @tc.number: OH_AudioRenderer_SetLoudnessGain_017
1955 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1956 * overwrites OH_AudioRenderer_SetLoudnessGain interface'back test.
1957 * streamtype is AUDIOSTREAM_USAGE_GAME.
1958 * Returns AUDIOSTREAM_ERROR_INVALID_PARAM if result is fail.
1959 */
1960 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_017, TestSize.Level2)
1961 {
1962 OH_AudioStreamBuilder* builder = nullptr;
1963 OH_AudioRenderer* audioRenderer = nullptr;
1964 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
1965 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1966
1967 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
1968
1969 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_GAME);
1970
1971 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
1972 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1973
1974 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 24.0f);
1975 EXPECT_TRUE(AUDIOSTREAM_ERROR_INVALID_PARAM == result);
1976 sleep(1);
1977
1978 float loudnessGain = 1;
1979 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
1980 EXPECT_TRUE((AUDIOSTREAM_SUCCESS == result) && (loudnessGain == 0));
1981
1982 result = OH_AudioRenderer_Release(audioRenderer);
1983 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
1984 OH_AudioStreamBuilder_Destroy(builder);
1985 }
1986
1987 /**
1988 * @tc.name : OH_AudioRenderer_SetLoudnessGain_018
1989 * @tc.number: OH_AudioRenderer_SetLoudnessGain_018
1990 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
1991 * overwrites OH_AudioRenderer_SetLoudnessGain interface'back test.
1992 * streamtype is AUDIOSTREAM_USAGE_NAVIGATION.
1993 * Returns AUDIOSTREAM_ERROR_INVALID_PARAM if result is fail.
1994 */
1995 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_018, TestSize.Level2)
1996 {
1997 OH_AudioStreamBuilder* builder = nullptr;
1998 OH_AudioRenderer* audioRenderer = nullptr;
1999 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
2000 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2001
2002 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
2003
2004 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_NAVIGATION);
2005
2006 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
2007 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2008
2009 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 24.0f);
2010 EXPECT_TRUE(AUDIOSTREAM_ERROR_INVALID_PARAM == result);
2011 sleep(1);
2012
2013 float loudnessGain = 1;
2014 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
2015 EXPECT_TRUE((AUDIOSTREAM_SUCCESS == result) && (loudnessGain == 0));
2016
2017 result = OH_AudioRenderer_Release(audioRenderer);
2018 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2019 OH_AudioStreamBuilder_Destroy(builder);
2020 }
2021
2022 /**
2023 * @tc.name : OH_AudioRenderer_SetLoudnessGain_019
2024 * @tc.number: OH_AudioRenderer_SetLoudnessGain_019
2025 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
2026 * overwrites OH_AudioRenderer_SetLoudnessGain interface'back test.
2027 * streamtype is AUDIOSTREAM_USAGE_VIDEO_COMMUNICATION.
2028 * Returns AUDIOSTREAM_ERROR_INVALID_PARAM if result is fail.
2029 */
2030 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_019, TestSize.Level2)
2031 {
2032 OH_AudioStreamBuilder* builder = nullptr;
2033 OH_AudioRenderer* audioRenderer = nullptr;
2034 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
2035 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2036
2037 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
2038
2039 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_VIDEO_COMMUNICATION);
2040
2041 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
2042 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2043
2044 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 24.0f);
2045 EXPECT_TRUE(AUDIOSTREAM_ERROR_INVALID_PARAM == result);
2046 sleep(1);
2047
2048 float loudnessGain = 1;
2049 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
2050 EXPECT_TRUE((AUDIOSTREAM_SUCCESS == result) && (loudnessGain == 0));
2051
2052 result = OH_AudioRenderer_Release(audioRenderer);
2053 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2054 OH_AudioStreamBuilder_Destroy(builder);
2055 }
2056 /**
2057 * @tc.name : OH_AudioRenderer_SetLoudnessGain_021
2058 * @tc.number: OH_AudioRenderer_SetLoudnessGain_021
2059 * @tc.desc : Test OH_AudioRenderer_SetLoudnessGain interface
2060 * overwrites OH_AudioRenderer_SetLoudnessGain interface' stability_test.
2061 * Returns AUDIOSTREAM_SUCCESS if result is success.
2062 */
2063 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_SetLoudnessGain_021, TestSize.Level0)
2064 {
2065 OH_AudioStreamBuilder* builder = nullptr;
2066 OH_AudioRenderer* audioRenderer = nullptr;
2067 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
2068 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2069
2070 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
2071
2072 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_MOVIE);
2073
2074 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
2075 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2076
2077 int i = 0;
2078 float loudnessGain = 0;
2079
2080 while (i < 2000) {
2081 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 10.0f);
2082 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2083
2084 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
2085 EXPECT_TRUE(AUDIOSTREAM_SUCCESS == result && 10.0f == loudnessGain);
2086
2087 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, -10.0f);
2088 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2089
2090 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, &loudnessGain);
2091 EXPECT_TRUE(AUDIOSTREAM_SUCCESS == result && -10.0f == loudnessGain);
2092
2093 i++;
2094 }
2095
2096 result = OH_AudioRenderer_Release(audioRenderer);
2097 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2098 OH_AudioStreamBuilder_Destroy(builder);
2099 }
2100
2101 /**
2102 * @tc.name : OH_AudioRenderer_GetLoudnessGain_001
2103 * @tc.number: OH_AudioRenderer_GetLoudnessGain_001
2104 * @tc.desc : Test OH_AudioRenderer_GetLoudnessGain interface
2105 * overwrites OH_AudioRenderer_GetLoudnessGain interface'back test.
2106 * renderer is nullptr.
2107 * Returns AUDIOSTREAM_ERROR_INVALID_PARAM if result is fail.
2108 */
2109 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetLoudnessGain_001, TestSize.Level2)
2110 {
2111 OH_AudioStreamBuilder* builder = nullptr;
2112 OH_AudioRenderer* audioRenderer = nullptr;
2113 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
2114 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2115
2116 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
2117
2118 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_MOVIE);
2119
2120 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
2121 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2122
2123 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 24.0f);
2124 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2125 sleep(1);
2126
2127 float loudnessGain = 0;
2128 result = OH_AudioRenderer_GetLoudnessGain(nullptr, &loudnessGain);
2129 EXPECT_TRUE(AUDIOSTREAM_ERROR_INVALID_PARAM == result);
2130 result = OH_AudioRenderer_Release(audioRenderer);
2131 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2132 OH_AudioStreamBuilder_Destroy(builder);
2133 }
2134
2135 /**
2136 * @tc.name : OH_AudioRenderer_GetLoudnessGain_002
2137 * @tc.number: OH_AudioRenderer_GetLoudnessGain_002
2138 * @tc.desc : Test OH_AudioRenderer_GetLoudnessGain interface
2139 * overwrites OH_AudioRenderer_GetLoudnessGain interface'back test.
2140 * renderer is nullptr.
2141 * Returns AUDIOSTREAM_ERROR_INVALID_PARAM if result is fail.
2142 */
2143 HWTEST(OHAudioRenderUnitTest, OH_Audio_Render_GetLoudnessGain_002, TestSize.Level2)
2144 {
2145 OH_AudioStreamBuilder* builder = nullptr;
2146 OH_AudioRenderer* audioRenderer = nullptr;
2147 auto result = OH_AudioStreamBuilder_Create(&builder, AUDIOSTREAM_TYPE_RENDERER);
2148 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2149
2150 OH_AudioStreamBuilder_SetLatencyMode(builder, AUDIOSTREAM_LATENCY_MODE_NORMAL);
2151
2152 OH_AudioStreamBuilder_SetRendererInfo(builder, AUDIOSTREAM_USAGE_MOVIE);
2153
2154 result = OH_AudioStreamBuilder_GenerateRenderer(builder, &audioRenderer);
2155 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2156
2157 result = OH_AudioRenderer_SetLoudnessGain(audioRenderer, 24.0f);
2158 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2159 sleep(1);
2160
2161 result = OH_AudioRenderer_GetLoudnessGain(audioRenderer, nullptr);
2162 EXPECT_TRUE(AUDIOSTREAM_ERROR_INVALID_PARAM == result);
2163 result = OH_AudioRenderer_Release(audioRenderer);
2164 EXPECT_EQ(result, AUDIOSTREAM_SUCCESS);
2165 OH_AudioStreamBuilder_Destroy(builder);
2166 }
2167
2168 /**
2169 * @tc.name : OH_AudioStreamManager_IsAcousticEchoCancelerSupported_001
2170 * @tc.number: OH_AudioStreamManager_IsAcousticEchoCancelerSupported_001
2171 * @tc.desc : null check
2172 */
2173 HWTEST(OHAudioRenderUnitTest, OH_AudioStreamManager_IsAcousticEchoCancelerSupported_001, TestSize.Level2)
2174 {
2175 OH_AudioStreamManager* streamManager = nullptr;
2176 OH_AudioCommon_Result ret = OH_AudioManager_GetAudioStreamManager(&streamManager);
2177
2178 EXPECT_EQ(ret, AUDIOCOMMON_RESULT_SUCCESS);
2179 EXPECT_NE(streamManager, nullptr);
2180
2181 bool supported;
2182 ret = OH_AudioStreamManager_IsAcousticEchoCancelerSupported(nullptr, AUDIOSTREAM_SOURCE_TYPE_MIC, &supported);
2183 EXPECT_EQ(ret, AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM);
2184
2185 ret = OH_AudioStreamManager_IsAcousticEchoCancelerSupported(streamManager, AUDIOSTREAM_SOURCE_TYPE_MIC, nullptr);
2186 EXPECT_EQ(ret, AUDIOCOMMON_RESULT_ERROR_INVALID_PARAM);
2187 }
2188
2189 /**
2190 * @tc.name : OH_AudioStreamManager_IsAcousticEchoCancelerSupported_002
2191 * @tc.number: OH_AudioStreamManager_IsAcousticEchoCancelerSupported_002
2192 * @tc.desc : IsAcousticEchoCancelerSupported
2193 */
2194 HWTEST(OHAudioRenderUnitTest, OH_AudioStreamManager_IsAcousticEchoCancelerSupported_002, TestSize.Level2)
2195 {
2196 OH_AudioStreamManager* streamManager = nullptr;
2197 OH_AudioCommon_Result ret = OH_AudioManager_GetAudioStreamManager(&streamManager);
2198
2199 EXPECT_EQ(ret, AUDIOCOMMON_RESULT_SUCCESS);
2200 EXPECT_NE(streamManager, nullptr);
2201
2202 bool supported;
2203 ret = OH_AudioStreamManager_IsAcousticEchoCancelerSupported(streamManager, AUDIOSTREAM_SOURCE_TYPE_MIC, &supported);
2204 EXPECT_EQ(ret, AUDIOCOMMON_RESULT_SUCCESS);
2205 EXPECT_EQ(supported, false);
2206 }
2207
2208 } // namespace AudioStandard
2209 } // namespace OHOS
2210