1 /*
2 * Copyright (c) 2023-2025 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 "osal_mem.h"
17 #include <gtest/gtest.h>
18
19 #include "v5_0/audio_types.h"
20 #include "v5_0/iaudio_manager.h"
21 #include "v5_0/iaudio_render.h"
22
23 using namespace std;
24 using namespace testing::ext;
25
26 namespace {
27 const int BUFFER_LENTH = 1024 * 16;
28 const int DEEP_BUFFER_RENDER_PERIOD_SIZE = 4 * 1024;
29 const int32_t AUDIO_RENDER_CHANNELCOUNT = 2;
30 const int32_t AUDIO_SAMPLE_RATE_48K = 48000;
31 const int32_t MAX_AUDIO_ADAPTER_DESC = 5;
32 const uint64_t DEFAULT_BUFFER_SIZE = 16384;
33 const int32_t AUDIO_RENDER_BUF_TEST = 1024;
34
35 class AudioUtRenderTestAdditional : public testing::Test {
36 public:
37 struct IAudioManager *manager_ = nullptr;
38 struct AudioAdapterDescriptor descs_[MAX_AUDIO_ADAPTER_DESC];
39 struct AudioAdapterDescriptor *desc_;
40 struct IAudioAdapter *adapter_ = nullptr;
41 struct IAudioRender *render_ = nullptr;
42 struct AudioDeviceDescriptor devDescRender_ = {};
43 struct AudioSampleAttributes attrsRender_ = {};
44 uint32_t renderId_ = 0;
45 uint32_t size_ = MAX_AUDIO_ADAPTER_DESC;
46 virtual void SetUp();
47 virtual void TearDown();
48 uint64_t GetRenderBufferSize();
49 void InitRenderAttrs(struct AudioSampleAttributes &attrs);
50 void InitRenderDevDesc(struct AudioDeviceDescriptor &devDesc);
51 void FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf);
52 void ReleaseAllAdapterDescs(struct AudioAdapterDescriptor *descs, uint32_t descsLen);
53 };
54
RenderCallbackTest(struct IAudioCallback * self,enum AudioCallbackType type,int8_t * reserved,int8_t * cookie)55 int32_t RenderCallbackTest(struct IAudioCallback* self, enum AudioCallbackType type,
56 int8_t* reserved, int8_t* cookie)
57 {
58 (void)self;
59 (void)type;
60 (void)reserved;
61 (void)cookie;
62 return HDF_SUCCESS;
63 }
64
GetRenderBufferSize()65 uint64_t AudioUtRenderTestAdditional::GetRenderBufferSize()
66 {
67 int32_t ret = HDF_SUCCESS;
68 uint64_t frameSize = 0;
69 uint64_t frameCount = 0;
70 uint64_t bufferSize = 0;
71
72 if (render_ == nullptr) {
73 return DEFAULT_BUFFER_SIZE;
74 }
75
76 ret = render_->GetFrameSize(render_, &frameSize);
77 if (ret != HDF_SUCCESS) {
78 return DEFAULT_BUFFER_SIZE;
79 }
80
81 ret = render_->GetFrameCount(render_, &frameCount);
82 if (ret != HDF_SUCCESS) {
83 return DEFAULT_BUFFER_SIZE;
84 }
85
86 bufferSize = frameCount * frameSize;
87 if (bufferSize == 0) {
88 bufferSize = DEFAULT_BUFFER_SIZE;
89 }
90
91 return bufferSize;
92 }
93
InitRenderAttrs(struct AudioSampleAttributes & attrs)94 void AudioUtRenderTestAdditional::InitRenderAttrs(struct AudioSampleAttributes &attrs)
95 {
96 attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
97 attrs.channelCount = AUDIO_RENDER_CHANNELCOUNT;
98 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
99 attrs.interleaved = 0;
100 attrs.type = AUDIO_IN_MEDIA;
101 attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
102 attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * AUDIO_RENDER_CHANNELCOUNT;
103 attrs.isBigEndian = false;
104 attrs.isSignedData = true;
105 attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.format * attrs.channelCount);
106 attrs.stopThreshold = INT_MAX;
107 attrs.silenceThreshold = BUFFER_LENTH;
108 }
109
InitRenderDevDesc(struct AudioDeviceDescriptor & devDesc)110 void AudioUtRenderTestAdditional::InitRenderDevDesc(struct AudioDeviceDescriptor &devDesc)
111 {
112 devDesc.pins = PIN_OUT_SPEAKER;
113 devDesc.desc = strdup("cardname");
114
115 ASSERT_NE(desc_, nullptr);
116 ASSERT_NE(desc_->ports, nullptr);
117 for (uint32_t index = 0; index < desc_->portsLen; index++) {
118 if (desc_->ports[index].dir == PORT_OUT) {
119 devDesc.portId = desc_->ports[index].portId;
120 return;
121 }
122 }
123 }
124
FreeAdapterElements(struct AudioAdapterDescriptor * dataBlock,bool freeSelf)125 void AudioUtRenderTestAdditional::FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)
126 {
127 if (dataBlock == nullptr) {
128 return;
129 }
130
131 OsalMemFree(dataBlock->adapterName);
132
133 OsalMemFree(dataBlock->ports);
134
135 if (freeSelf) {
136 OsalMemFree(dataBlock);
137 }
138 }
139
ReleaseAllAdapterDescs(struct AudioAdapterDescriptor * descs,uint32_t descsLen)140 void AudioUtRenderTestAdditional::ReleaseAllAdapterDescs(struct AudioAdapterDescriptor *descs, uint32_t descsLen)
141 {
142 if (descs == nullptr || descsLen == 0) {
143 return;
144 }
145
146 for (uint32_t i = 0; i < descsLen; i++) {
147 FreeAdapterElements(&descs[i], false);
148 }
149 }
150
SetUp()151 void AudioUtRenderTestAdditional::SetUp()
152 {
153 manager_ = IAudioManagerGet(false);
154 ASSERT_NE(manager_, nullptr);
155
156 ASSERT_EQ(HDF_SUCCESS, manager_->GetAllAdapters(manager_, descs_, &size_));
157 ASSERT_NE(descs_, nullptr);
158 EXPECT_GE(MAX_AUDIO_ADAPTER_DESC, size_);
159 desc_ = &descs_[0];
160 ASSERT_EQ(HDF_SUCCESS, manager_->LoadAdapter(manager_, desc_, &adapter_));
161 ASSERT_NE(adapter_, nullptr);
162 InitRenderDevDesc(devDescRender_);
163 InitRenderAttrs(attrsRender_);
164
165 int32_t ret = adapter_->CreateRender(adapter_, &devDescRender_, &attrsRender_, &render_, &renderId_);
166 if (ret != HDF_SUCCESS) {
167 attrsRender_.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
168 ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devDescRender_, &attrsRender_, &render_, &renderId_));
169 }
170 ASSERT_NE(render_, nullptr);
171 }
172
TearDown()173 void AudioUtRenderTestAdditional::TearDown()
174 {
175 if (adapter_ != nullptr) {
176 adapter_->DestroyRender(adapter_, renderId_);
177 render_ = nullptr;
178 }
179 if (manager_ != nullptr) {
180 manager_->UnloadAdapter(manager_, desc_->adapterName);
181 adapter_ = nullptr;
182 ReleaseAllAdapterDescs(descs_, size_);
183
184 IAudioManagerRelease(manager_, false);
185 }
186 }
187
188 /**
189 * @tc.number : SUB_Driver_Audio_GetLatency_0400
190 * @tc.name : testCommonRenderGetLatency001
191 * @tc.desc : Reliability of function(GetLatency)
192 */
193 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetLatency001, Function | MediumTest | Level1)
194 {
195 uint32_t ms = 0;
196 int i, ret = 0;
197 for (i = 0; i < 1000; i++) {
198 ret |= render_->GetLatency(render_, &ms);
199 EXPECT_EQ(HDF_SUCCESS, ret);
200 }
201 }
202
203 /**
204 * @tc.number : SUB_Driver_Audio_RenderFrame_0300
205 * @tc.name : testCommonRenderRenderFrame001
206 * @tc.desc : Functionality of function(RenderFrame)
207 */
208 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRenderFrame001, Function | MediumTest | Level1)
209 {
210 uint64_t frameLen = (uint64_t)GetRenderBufferSize();
211 uint64_t requestBytes = frameLen;
212
213 int32_t ret = render_->Start(render_);
214 EXPECT_EQ(ret, HDF_SUCCESS);
215
216 int8_t *frame = (int8_t *)calloc(1, frameLen);
217 EXPECT_NE(nullptr, frame);
218
219 ret = render_->RenderFrame(render_, frame, frameLen, &requestBytes);
220 EXPECT_EQ(ret, HDF_SUCCESS);
221
222 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
223 }
224
225 /**
226 * @tc.number : SUB_Driver_Audio_RenderFrame_0400
227 * @tc.name : testCommonRenderRenderFrame002
228 * @tc.desc : Test parameters with abnormal input
229 */
230 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRenderFrame002, Function | MediumTest | Level1)
231 {
232 uint64_t frameLen = (uint64_t)GetRenderBufferSize();
233 uint64_t requestBytes = frameLen;
234
235 int32_t ret = render_->Start(render_);
236 int i = 0;
237 EXPECT_EQ(ret, HDF_SUCCESS);
238
239 int8_t *frame = (int8_t *)calloc(1, frameLen);
240 EXPECT_NE(nullptr, frame);
241 for (i = 0; i < 1000; i++) {
242 ret |= render_->RenderFrame(render_, frame, frameLen, &requestBytes);
243 EXPECT_EQ(ret, HDF_SUCCESS);
244 }
245
246 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
247 }
248
249 /**
250 * @tc.number : SUB_Driver_Audio_RenderFrame_0500
251 * @tc.name : testCommonRenderRenderFrame003
252 * @tc.desc : Test parameters with abnormal input
253 */
254 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRenderFrame003, Function | MediumTest | Level2)
255 {
256 uint64_t frameLen = (uint64_t)GetRenderBufferSize();
257 uint64_t requestBytes = frameLen;
258
259 int32_t ret = render_->Start(render_);
260 EXPECT_EQ(ret, HDF_SUCCESS);
261
262 int8_t *frame = (int8_t *)calloc(1, frameLen);
263 EXPECT_NE(nullptr, frame);
264
265 ret = render_->RenderFrame(nullptr, frame, frameLen, &requestBytes);
266 EXPECT_NE(ret, HDF_SUCCESS);
267 render_->Stop(render_);
268 }
269
270 /**
271 * @tc.number : SUB_Driver_Audio_RenderFrame_0600
272 * @tc.name : testCommonRenderRenderFrame004
273 * @tc.desc : Test parameters with abnormal input
274 */
275 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRenderFrame004, Function | MediumTest | Level2)
276 {
277 uint64_t frameLen = (uint64_t)GetRenderBufferSize();
278 uint64_t requestBytes = frameLen;
279
280 int32_t ret = render_->Start(render_);
281 EXPECT_EQ(ret, HDF_SUCCESS);
282
283 ret = render_->RenderFrame(render_, nullptr, frameLen, &requestBytes);
284 EXPECT_NE(ret, HDF_SUCCESS);
285 render_->Stop(render_);
286 }
287
288 /**
289 * @tc.number : SUB_Driver_Audio_RenderFrame_0700
290 * @tc.name : testCommonRenderRenderFrame005
291 * @tc.desc : Test parameters with abnormal input
292 */
293 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRenderFrame005, Function | MediumTest | Level2)
294 {
295 uint64_t frameLen = (uint64_t)GetRenderBufferSize();
296
297 int32_t ret = render_->Start(render_);
298 EXPECT_EQ(ret, HDF_SUCCESS);
299
300 int8_t *frame = (int8_t *)calloc(1, frameLen);
301 EXPECT_NE(nullptr, frame);
302
303 ret = render_->RenderFrame(render_, frame, frameLen, nullptr);
304 EXPECT_NE(ret, HDF_SUCCESS);
305 render_->Stop(render_);
306 }
307
308 /**
309 * @tc.number : SUB_Driver_Audio_GetRenderPosition_0600
310 * @tc.name : testCommonRenderGetRenderPosition001
311 * @tc.desc : Reliability of function(GetRenderPosition)
312 */
313 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetRenderPosition001, Function | MediumTest | Level1)
314 {
315 uint64_t frames = 0;
316 struct AudioTimeStamp time;
317 time.tvSec = 0;
318 time.tvNSec = 0;
319 int32_t ret = 0;
320 int i = 0;
321 for (i = 0; i < 1000; i++) {
322 ret |= render_->GetRenderPosition(render_, &frames, &time);
323 }
324 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
325 EXPECT_EQ(ret, HDF_SUCCESS);
326 #else
327 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
328 #endif
329 }
330
331 /**
332 * @tc.number : SUB_Driver_Audio_SetRenderSpeed_0400
333 * @tc.name : testCommonRenderSetRenderSpeed002
334 * @tc.desc : Test parameters with abnormal input
335 */
336 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetRenderSpeed002, Function | MediumTest | Level2)
337 {
338 float speed = -1.0;
339 EXPECT_NE(HDF_SUCCESS, render_->SetRenderSpeed(render_, speed));
340 }
341
342 /**
343 * @tc.number : SUB_Driver_Audio_SetRenderSpeed_0500
344 * @tc.name : testCommonRenderSetRenderSpeed003
345 * @tc.desc : Test parameters with abnormal input
346 */
347 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetRenderSpeed003, Function | MediumTest | Level2)
348 {
349 float speed = 0;
350 EXPECT_NE(HDF_SUCCESS, render_->SetRenderSpeed(render_, speed));
351 }
352
353 /**
354 * @tc.number : SUB_Driver_Audio_SetChannelMode_0600
355 * @tc.name : testCommonRenderSetChannelMode004
356 * @tc.desc : Test input param
357 */
358 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetChannelMode004, Function | MediumTest | Level1)
359 {
360 AudioChannelMode mode = AUDIO_CHANNEL_EXCHANGE;
361 int32_t ret = render_->SetChannelMode(render_, mode);
362 #if defined ALSA_LIB_MODE
363 EXPECT_EQ(ret, HDF_SUCCESS);
364 #elif defined DISPLAY_COMMUNITY
365 EXPECT_EQ(ret, HDF_FAILURE);
366 #else
367 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
368 #endif
369 }
370
371 /**
372 * @tc.number : SUB_Driver_Audio_SetChannelMode_0700
373 * @tc.name : testCommonRenderSetChannelMode005
374 * @tc.desc : Test input param
375 */
376 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetChannelMode005, Function | MediumTest | Level1)
377 {
378 AudioChannelMode mode = AUDIO_CHANNEL_MIX;
379 int32_t ret = render_->SetChannelMode(render_, mode);
380 #if defined ALSA_LIB_MODE
381 EXPECT_EQ(ret, HDF_SUCCESS);
382 #elif defined DISPLAY_COMMUNITY
383 EXPECT_EQ(ret, HDF_FAILURE);
384 #else
385 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
386 #endif
387 }
388
389 /**
390 * @tc.number : SUB_Driver_Audio_SetChannelMode_0800
391 * @tc.name : testCommonRenderSetChannelMode006
392 * @tc.desc : Test input param
393 */
394 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetChannelMode006, Function | MediumTest | Level1)
395 {
396 AudioChannelMode mode = AUDIO_CHANNEL_LEFT_MUTE;
397 int32_t ret = render_->SetChannelMode(render_, mode);
398 #if defined ALSA_LIB_MODE
399 EXPECT_EQ(ret, HDF_SUCCESS);
400 #elif defined DISPLAY_COMMUNITY
401 EXPECT_EQ(ret, HDF_FAILURE);
402 #else
403 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
404 #endif
405 }
406
407 /**
408 * @tc.number : SUB_Driver_Audio_SetChannelMode_0900
409 * @tc.name : testCommonRenderSetChannelMode007
410 * @tc.desc : Test input param
411 */
412 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetChannelMode007, Function | MediumTest | Level1)
413 {
414 AudioChannelMode mode = AUDIO_CHANNEL_RIGHT_MUTE;
415 int32_t ret = render_->SetChannelMode(render_, mode);
416 #if defined ALSA_LIB_MODE
417 EXPECT_EQ(ret, HDF_SUCCESS);
418 #elif defined DISPLAY_COMMUNITY
419 EXPECT_EQ(ret, HDF_FAILURE);
420 #else
421 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
422 #endif
423 }
424
425 /**
426 * @tc.number : SUB_Driver_Audio_SetChannelMode_1000
427 * @tc.name : testCommonRenderSetChannelMode008
428 * @tc.desc : Test input param
429 */
430 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetChannelMode008, Function | MediumTest | Level1)
431 {
432 AudioChannelMode mode = AUDIO_CHANNEL_BOTH_MUTE;
433 int32_t ret = render_->SetChannelMode(render_, mode);
434 #if defined ALSA_LIB_MODE
435 EXPECT_EQ(ret, HDF_SUCCESS);
436 #elif defined DISPLAY_COMMUNITY
437 EXPECT_EQ(ret, HDF_FAILURE);
438 #else
439 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
440 #endif
441 }
442
443 /**
444 * @tc.number : SUB_Driver_Audio_SetChannelMode_1100
445 * @tc.name : testCommonRenderSetChannelMode009
446 * @tc.desc : Test input param
447 */
448 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetChannelMode009, Function | MediumTest | Level2)
449 {
450 AudioChannelMode mode = AUDIO_CHANNEL_BOTH_MUTE;
451 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->SetChannelMode(nullptr, mode));
452 }
453
454 /**
455 * @tc.number : SUB_Driver_Audio_DrainBuffer_0300
456 * @tc.name : testCommonRenderDrainBufferk001
457 * @tc.desc : Reliability of function(DrainBuffer)
458 */
459 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderDrainBufferk001, Function | MediumTest | Level2)
460 {
461 enum AudioDrainNotifyType type = AUDIO_DRAIN_NORMAL_MODE;
462 int i = 0;
463 int32_t ret = 0;
464 for (i = 0; i < 1000; i++) {
465 ret |= render_->DrainBuffer(render_, &type);
466 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
467 }
468 }
469
470 /**
471 * @tc.number : SUB_Driver_Audio_DrainBuffer_0400
472 * @tc.name : testCommonRenderDrainBufferk002
473 * @tc.desc : Test input param
474 */
475 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderDrainBufferk002, Function | MediumTest | Level2)
476 {
477 enum AudioDrainNotifyType type = AUDIO_DRAIN_NORMAL_MODE;
478 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->DrainBuffer(render_, &type));
479 }
480
481 /**
482 * @tc.number : SUB_Driver_Audio_DrainBuffer_0500
483 * @tc.name : testCommonRenderDrainBufferk003
484 * @tc.desc : Test input param
485 */
486 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderDrainBufferk003, Function | MediumTest | Level2)
487 {
488 enum AudioDrainNotifyType type = AUDIO_DRAIN_EARLY_MODE;
489 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->DrainBuffer(render_, &type));
490 }
491
492 /**
493 * @tc.number : SUB_Driver_Audio_IsSupportsDrain_0300
494 * @tc.name : testCommonRenderIsSupportsDrain001
495 * @tc.desc : Reliability of function(IsSupportsDrain)
496 */
497 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderIsSupportsDrain001, Function | MediumTest | Level1)
498 {
499 int i = 0;
500 int32_t ret = 0;
501 bool support = false;
502 for (i = 0; i < 1000; i++) {
503 ret |= render_->IsSupportsDrain(render_, &support);
504 }
505 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
506 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
507 #else
508 EXPECT_EQ(ret, HDF_SUCCESS);
509 #endif
510 }
511
512 /**
513 * @tc.number : SUB_Driver_Audio_IsSupportsDrain_0400
514 * @tc.name : testCommonRenderIsSupportsDrain002
515 * @tc.desc : Test input param
516 */
517 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderIsSupportsDrain002, Function | MediumTest | Level2)
518 {
519 int32_t ret = render_->IsSupportsDrain(nullptr, nullptr);
520 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
521 }
522
523 /**
524 * @tc.number : SUB_Driver_Audio_CheckSceneCapability_0500
525 * @tc.name : testCommonRenderCheckSceneCapability001
526 * @tc.desc : Reliability of function(CheckSceneCapability)
527 */
528 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderCheckSceneCapability001, Function | MediumTest | Level1)
529 {
530 int i = 0;
531 int32_t ret = 0;
532 struct AudioSceneDescriptor scene;
533 bool supported = false;
534 scene.scene.id = AUDIO_IN_MEDIA;
535 scene.desc = devDescRender_;
536 for (i = 0; i < 1000; i++) {
537 ret |= render_->CheckSceneCapability(render_, &scene, &supported);
538 EXPECT_EQ(HDF_SUCCESS, ret);
539 }
540 }
541
542 /**
543 * @tc.number : SUB_Driver_Audio_CheckSceneCapability_0600
544 * @tc.name : testCommonRenderCheckSceneCapability002
545 * @tc.desc : Test input param
546 */
547 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderCheckSceneCapability002, Function | MediumTest | Level2)
548 {
549 bool supported = false;
550 EXPECT_NE(HDF_SUCCESS, render_->CheckSceneCapability(nullptr, nullptr, &supported));
551 }
552
553 /**
554 * @tc.number : SUB_Driver_Audio_CheckSceneCapability_0700
555 * @tc.name : testCommonRenderCheckSceneCapability003
556 * @tc.desc : Test input param
557 */
558 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderCheckSceneCapability003, Function | MediumTest | Level2)
559 {
560 struct AudioSceneDescriptor scene;
561 scene.scene.id = AUDIO_IN_MEDIA;
562 scene.desc = devDescRender_;
563 EXPECT_NE(HDF_SUCCESS, render_->CheckSceneCapability(nullptr, &scene, nullptr));
564 }
565
566 /**
567 * @tc.number : SUB_Driver_Audio_CheckSceneCapability_0800
568 * @tc.name : testCommonRenderCheckSceneCapability004
569 * @tc.desc : Test input param
570 */
571 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderCheckSceneCapability004, Function | MediumTest | Level2)
572 {
573 EXPECT_NE(HDF_SUCCESS, render_->CheckSceneCapability(render_, nullptr, nullptr));
574 }
575
576 /**
577 * @tc.number : SUB_Driver_Audio_CheckSceneCapability_0900
578 * @tc.name : testCommonRenderCheckSceneCapability005
579 * @tc.desc : Test input param
580 */
581 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderCheckSceneCapability005, Function | MediumTest | Level2)
582 {
583 EXPECT_NE(HDF_SUCCESS, render_->CheckSceneCapability(nullptr, nullptr, nullptr));
584 }
585
586 /**
587 * @tc.number : SUB_Driver_Audio_CheckSceneCapability_1000
588 * @tc.name : testCommonRenderCheckSceneCapability006
589 * @tc.desc : Test input param
590 */
591 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderCheckSceneCapability006, Function | MediumTest | Level1)
592 {
593 struct AudioSceneDescriptor scene;
594 scene.scene.id = AUDIO_IN_COMMUNICATION;
595 scene.desc = devDescRender_;
596 bool supported = false;
597 EXPECT_EQ(HDF_SUCCESS, render_->CheckSceneCapability(render_, &scene, &supported));
598 }
599
600 /**
601 * @tc.number : SUB_Driver_Audio_CheckSceneCapability_1100
602 * @tc.name : testCommonRenderCheckSceneCapability007
603 * @tc.desc : Test input param
604 */
605 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderCheckSceneCapability007, Function | MediumTest | Level1)
606 {
607 struct AudioSceneDescriptor scene;
608 scene.scene.id = AUDIO_IN_RINGTONE;
609 scene.desc = devDescRender_;
610 bool supported = false;
611 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
612 EXPECT_EQ(HDF_SUCCESS, render_->CheckSceneCapability(render_, &scene, &supported));
613 #else
614 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->CheckSceneCapability(render_, &scene, &supported));
615 #endif
616 }
617
618 /**
619 * @tc.number : SUB_Driver_Audio_CheckSceneCapability_1200
620 * @tc.name : testCommonRenderCheckSceneCapability008
621 * @tc.desc : Test input param
622 */
623 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderCheckSceneCapability008, Function | MediumTest | Level1)
624 {
625 struct AudioSceneDescriptor scene;
626 scene.scene.id = AUDIO_IN_CALL;
627 scene.desc = devDescRender_;
628 bool supported = false;
629 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
630 EXPECT_EQ(HDF_SUCCESS, render_->CheckSceneCapability(render_, &scene, &supported));
631 #else
632 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->CheckSceneCapability(render_, &scene, &supported));
633 #endif
634 }
635
636 /**
637 * @tc.number : SUB_Driver_Audio_SelectScene_0400
638 * @tc.name : testCommonRenderSelectScene001
639 * @tc.desc : Reliability of function(SelectScene)
640 */
641 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene001, Function | MediumTest | Level1)
642 {
643 int i = 0;
644 int32_t ret = 0;
645 struct AudioSceneDescriptor scene;
646 scene.scene.id = AUDIO_IN_MEDIA;
647 scene.desc.pins = PIN_OUT_HEADSET;
648 scene.desc.desc = strdup("mic");
649 for (i = 0; i < 1000; i++) {
650 ret |= render_->SelectScene(render_, &scene);
651 EXPECT_EQ(HDF_SUCCESS, ret);
652 }
653 free(scene.desc.desc);
654 }
655
656 /**
657 * @tc.number : SUB_Driver_Audio_SelectScene_0500
658 * @tc.name : testCommonRenderSelectScene002
659 * @tc.desc : Test input param
660 */
661 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene002, Function | MediumTest | Level2)
662 {
663 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(nullptr, nullptr));
664 }
665
666 /**
667 * @tc.number : SUB_Driver_Audio_SelectScene_0600
668 * @tc.name : testCommonRenderSelectScene003
669 * @tc.desc : Test input param
670 */
671 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene003, Function | MediumTest | Level1)
672 {
673 struct AudioSceneDescriptor scene;
674 scene.scene.id = AUDIO_IN_COMMUNICATION;
675 scene.desc.pins = PIN_OUT_HEADSET;
676 scene.desc.desc = strdup("mic");
677 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
678 free(scene.desc.desc);
679 }
680
681 /**
682 * @tc.number : SUB_Driver_Audio_SelectScene_0700
683 * @tc.name : testCommonRenderSelectScene004
684 * @tc.desc : Test input param
685 */
686 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene004, Function | MediumTest | Level1)
687 {
688 struct AudioSceneDescriptor scene;
689 scene.scene.id = AUDIO_IN_RINGTONE;
690 scene.desc.pins = PIN_OUT_HEADSET;
691 scene.desc.desc = strdup("mic");
692 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
693 free(scene.desc.desc);
694 }
695
696 /**
697 * @tc.number : SUB_Driver_Audio_SelectScene_0800
698 * @tc.name : testCommonRenderSelectScene005
699 * @tc.desc : Test input param
700 */
701 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene005, Function | MediumTest | Level1)
702 {
703 struct AudioSceneDescriptor scene;
704 scene.scene.id = AUDIO_IN_CALL;
705 scene.desc.pins = PIN_OUT_HEADSET;
706 scene.desc.desc = strdup("mic");
707 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
708 free(scene.desc.desc);
709 }
710
711 /**
712 * @tc.number SUB_Driver_Audio_SelectScene_0900
713 * @tc.name testCommonRenderSelectScene006
714 * @tc.desc Test input param
715 */
716 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene006, Function | MediumTest | Level1)
717 {
718 struct AudioSceneDescriptor scene;
719 scene.scene.id = AUDIO_IN_MEDIA;
720 scene.desc.pins = PIN_OUT_SPEAKER;
721 scene.desc.desc = strdup("mic");
722 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
723 free(scene.desc.desc);
724 }
725
726 /**
727 * @tc.number SUB_Driver_Audio_SelectScene_1000
728 * @tc.name testCommonRenderSelectScene007
729 * @tc.desc Test input param
730 */
731 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene007, Function | MediumTest | Level1)
732 {
733 struct AudioSceneDescriptor scene;
734 scene.scene.id = AUDIO_IN_COMMUNICATION;
735 scene.desc.pins = PIN_OUT_SPEAKER;
736 scene.desc.desc = strdup("mic");
737 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
738 free(scene.desc.desc);
739 }
740
741 /**
742 * @tc.number SUB_Driver_Audio_SelectScene_1100
743 * @tc.name testCommonRenderSelectScene008
744 * @tc.desc Test input param
745 */
746 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene008, Function | MediumTest | Level1)
747 {
748 struct AudioSceneDescriptor scene;
749 scene.scene.id = AUDIO_IN_RINGTONE;
750 scene.desc.pins = PIN_OUT_SPEAKER;
751 scene.desc.desc = strdup("mic");
752 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
753 free(scene.desc.desc);
754 }
755
756 /**
757 * @tc.number SUB_Driver_Audio_SelectScene_1200
758 * @tc.name testCommonRenderSelectScene009
759 * @tc.desc Test input param
760 */
761 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene009, Function | MediumTest | Level1)
762 {
763 struct AudioSceneDescriptor scene;
764 scene.scene.id = AUDIO_IN_CALL;
765 scene.desc.pins = PIN_OUT_SPEAKER;
766 scene.desc.desc = strdup("mic");
767 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
768 free(scene.desc.desc);
769 }
770
771 /**
772 * @tc.number SUB_Driver_Audio_SelectScene_1300
773 * @tc.name testCommonRenderSelectScene010
774 * @tc.desc Test input param
775 */
776 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene010, Function | MediumTest | Level1)
777 {
778 struct AudioSceneDescriptor scene;
779 scene.scene.id = AUDIO_IN_MEDIA;
780 scene.desc.pins = PIN_NONE;
781 scene.desc.desc = strdup("mic");
782 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
783 free(scene.desc.desc);
784 }
785
786 /**
787 * @tc.number SUB_Driver_Audio_SelectScene_1400
788 * @tc.name testCommonRenderSelectScene011
789 * @tc.desc Test input param
790 */
791 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene011, Function | MediumTest | Level1)
792 {
793 struct AudioSceneDescriptor scene;
794 scene.scene.id = AUDIO_IN_COMMUNICATION;
795 scene.desc.pins = PIN_NONE;
796 scene.desc.desc = strdup("mic");
797 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
798 free(scene.desc.desc);
799 }
800
801 /**
802 * @tc.number SUB_Driver_Audio_SelectScene_1500
803 * @tc.name testCommonRenderSelectScene012
804 * @tc.desc Test input param
805 */
806 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene012, Function | MediumTest | Level1)
807 {
808 struct AudioSceneDescriptor scene;
809 scene.scene.id = AUDIO_IN_RINGTONE;
810 scene.desc.pins = PIN_NONE;
811 scene.desc.desc = strdup("mic");
812 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
813 free(scene.desc.desc);
814 }
815
816 /**
817 * @tc.number SUB_Driver_Audio_SelectScene_1600
818 * @tc.name testCommonRenderSelectScene013
819 * @tc.desc Test input param
820 */
821 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene013, Function | MediumTest | Level1)
822 {
823 struct AudioSceneDescriptor scene;
824 scene.scene.id = AUDIO_IN_CALL;
825 scene.desc.pins = PIN_NONE;
826 scene.desc.desc = strdup("mic");
827 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
828 free(scene.desc.desc);
829 }
830
831 /**
832 * @tc.number SUB_Driver_Audio_SelectScene_1700
833 * @tc.name testCommonRenderSelectScene014
834 * @tc.desc Test input param
835 */
836 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene014, Function | MediumTest | Level1)
837 {
838 struct AudioSceneDescriptor scene;
839 scene.scene.id = AUDIO_IN_CALL;
840 scene.desc.pins = PIN_OUT_LINEOUT;
841 scene.desc.desc = strdup("mic");
842 #if defined ALSA_LIB_MODE
843 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
844 #elif defined DISPLAY_COMMUNITY
845 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
846 #else
847 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
848 #endif
849 free(scene.desc.desc);
850 }
851
852 /**
853 * @tc.number SUB_Driver_Audio_SelectScene_1800
854 * @tc.name testCommonRenderSelectScene015
855 * @tc.desc Test input param
856 */
857 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene015, Function | MediumTest | Level1)
858 {
859 struct AudioSceneDescriptor scene;
860 scene.scene.id = AUDIO_IN_MEDIA;
861 scene.desc.pins = PIN_OUT_LINEOUT;
862 scene.desc.desc = strdup("mic");
863 #if defined ALSA_LIB_MODE
864 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
865 #elif defined DISPLAY_COMMUNITY
866 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
867 #else
868 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
869 #endif
870 free(scene.desc.desc);
871 }
872
873 /**
874 * @tc.number SUB_Driver_Audio_SelectScene_1900
875 * @tc.name testCommonRenderSelectScene016
876 * @tc.desc Test input param
877 */
878 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene016, Function | MediumTest | Level1)
879 {
880 struct AudioSceneDescriptor scene;
881 scene.scene.id = AUDIO_IN_COMMUNICATION;
882 scene.desc.pins = PIN_OUT_LINEOUT;
883 scene.desc.desc = strdup("mic");
884 #if defined ALSA_LIB_MODE
885 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
886 #elif defined DISPLAY_COMMUNITY
887 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
888 #else
889 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
890 #endif
891 free(scene.desc.desc);
892 }
893
894 /**
895 * @tc.number SUB_Driver_Audio_SelectScene_2000
896 * @tc.name testCommonRenderSelectScene017
897 * @tc.desc Test input param
898 */
899 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene017, Function | MediumTest | Level1)
900 {
901 struct AudioSceneDescriptor scene;
902 scene.scene.id = AUDIO_IN_RINGTONE;
903 scene.desc.pins = PIN_OUT_LINEOUT;
904 scene.desc.desc = strdup("mic");
905 #if defined ALSA_LIB_MODE
906 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
907 #elif defined DISPLAY_COMMUNITY
908 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
909 #else
910 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
911 #endif
912 free(scene.desc.desc);
913 }
914
915 /**
916 * @tc.number SUB_Driver_Audio_SelectScene_2100
917 * @tc.name testCommonRenderSelectScene018
918 * @tc.desc Test input param
919 */
920 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene018, Function | MediumTest | Level1)
921 {
922 struct AudioSceneDescriptor scene;
923 scene.scene.id = AUDIO_IN_MEDIA;
924 scene.desc.pins = PIN_OUT_HDMI;
925 scene.desc.desc = strdup("mic");
926 #if defined ALSA_LIB_MODE
927 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
928 #elif defined DISPLAY_COMMUNITY
929 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
930 #else
931 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
932 #endif
933 free(scene.desc.desc);
934 }
935
936 /**
937 * @tc.number SUB_Driver_Audio_SelectScene_2200
938 * @tc.name testCommonRenderSelectScene019
939 * @tc.desc Test input param
940 */
941 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene019, Function | MediumTest | Level1)
942 {
943 struct AudioSceneDescriptor scene;
944 scene.scene.id = AUDIO_IN_COMMUNICATION;
945 scene.desc.pins = PIN_OUT_HDMI;
946 scene.desc.desc = strdup("mic");
947 #if defined ALSA_LIB_MODE
948 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
949 #elif defined DISPLAY_COMMUNITY
950 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
951 #else
952 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
953 #endif
954 free(scene.desc.desc);
955 }
956
957 /**
958 * @tc.number SUB_Driver_Audio_SelectScene_2300
959 * @tc.name testCommonRenderSelectScene020
960 * @tc.desc Test input param
961 */
962 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene020, Function | MediumTest | Level1)
963 {
964 struct AudioSceneDescriptor scene;
965 scene.scene.id = AUDIO_IN_RINGTONE;
966 scene.desc.pins = PIN_OUT_HDMI;
967 scene.desc.desc = strdup("mic");
968 #if defined ALSA_LIB_MODE
969 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
970 #elif defined DISPLAY_COMMUNITY
971 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
972 #else
973 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
974 #endif
975 free(scene.desc.desc);
976 }
977
978 /**
979 * @tc.number SUB_Driver_Audio_SelectScene_2400
980 * @tc.name testCommonRenderSelectScene021
981 * @tc.desc Test input param
982 */
983 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene021, Function | MediumTest | Level1)
984 {
985 struct AudioSceneDescriptor scene;
986 scene.scene.id = AUDIO_IN_CALL;
987 scene.desc.pins = PIN_OUT_HDMI;
988 scene.desc.desc = strdup("mic");
989 #if defined ALSA_LIB_MODE
990 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
991 #elif defined DISPLAY_COMMUNITY
992 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
993 #else
994 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
995 #endif
996 free(scene.desc.desc);
997 }
998
999 /**
1000 * @tc.number SUB_Driver_Audio_SelectScene_2500
1001 * @tc.name testCommonRenderSelectScene022
1002 * @tc.desc Test input param
1003 */
1004 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene022, Function | MediumTest | Level1)
1005 {
1006 struct AudioSceneDescriptor scene;
1007 scene.scene.id = AUDIO_IN_MEDIA;
1008 scene.desc.pins = PIN_IN_MIC;
1009 scene.desc.desc = strdup("mic");
1010 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1011 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1012 #else
1013 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1014 #endif
1015 free(scene.desc.desc);
1016 }
1017
1018 /**
1019 * @tc.number SUB_Driver_Audio_SelectScene_2600
1020 * @tc.name testCommonRenderSelectScene023
1021 * @tc.desc Test input param
1022 */
1023 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene023, Function | MediumTest | Level1)
1024 {
1025 struct AudioSceneDescriptor scene;
1026 scene.scene.id = AUDIO_IN_COMMUNICATION;
1027 scene.desc.pins = PIN_IN_MIC;
1028 scene.desc.desc = strdup("mic");
1029 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1030 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1031 #else
1032 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1033 #endif
1034 free(scene.desc.desc);
1035 }
1036
1037 /**
1038 * @tc.number SUB_Driver_Audio_SelectScene_2700
1039 * @tc.name testCommonRenderSelectScene024
1040 * @tc.desc Test input param
1041 */
1042 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene024, Function | MediumTest | Level1)
1043 {
1044 struct AudioSceneDescriptor scene;
1045 scene.scene.id = AUDIO_IN_RINGTONE;
1046 scene.desc.pins = PIN_IN_MIC;
1047 scene.desc.desc = strdup("mic");
1048 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1049 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1050 #else
1051 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1052 #endif
1053 free(scene.desc.desc);
1054 }
1055
1056 /**
1057 * @tc.number SUB_Driver_Audio_SelectScene_2800
1058 * @tc.name testCommonRenderSelectScene025
1059 * @tc.desc Test input param
1060 */
1061 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene025, Function | MediumTest | Level1)
1062 {
1063 struct AudioSceneDescriptor scene;
1064 scene.scene.id = AUDIO_IN_CALL;
1065 scene.desc.pins = PIN_IN_MIC;
1066 scene.desc.desc = strdup("mic");
1067 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1068 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1069 #else
1070 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1071 #endif
1072 free(scene.desc.desc);
1073 }
1074
1075 /**
1076 * @tc.number SUB_Driver_Audio_SelectScene_2900
1077 * @tc.name testCommonRenderSelectScene026
1078 * @tc.desc Test input param
1079 */
1080 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene026, Function | MediumTest | Level1)
1081 {
1082 struct AudioSceneDescriptor scene;
1083 scene.scene.id = AUDIO_IN_MEDIA;
1084 scene.desc.pins = PIN_IN_HS_MIC;
1085 scene.desc.desc = strdup("mic");
1086 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1087 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1088 #else
1089 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1090 #endif
1091 free(scene.desc.desc);
1092 }
1093
1094 /**
1095 * @tc.number SUB_Driver_Audio_SelectScene_3000
1096 * @tc.name testCommonRenderSelectScene027
1097 * @tc.desc Test input param
1098 */
1099 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene027, Function | MediumTest | Level1)
1100 {
1101 struct AudioSceneDescriptor scene;
1102 scene.scene.id = AUDIO_IN_COMMUNICATION;
1103 scene.desc.pins = PIN_IN_HS_MIC;
1104 scene.desc.desc = strdup("mic");
1105 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1106 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1107 #else
1108 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1109 #endif
1110 free(scene.desc.desc);
1111 }
1112
1113 /**
1114 * @tc.number SUB_Driver_Audio_SelectScene_3100
1115 * @tc.name testCommonRenderSelectScene028
1116 * @tc.desc Test input param
1117 */
1118 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene028, Function | MediumTest | Level1)
1119 {
1120 struct AudioSceneDescriptor scene;
1121 scene.scene.id = AUDIO_IN_RINGTONE;
1122 scene.desc.pins = PIN_IN_HS_MIC;
1123 scene.desc.desc = strdup("mic");
1124 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1125 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1126 #else
1127 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1128 #endif
1129 free(scene.desc.desc);
1130 }
1131
1132 /**
1133 * @tc.number SUB_Driver_Audio_SelectScene_3200
1134 * @tc.name testCommonRenderSelectScene029
1135 * @tc.desc Test input param
1136 */
1137 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene029, Function | MediumTest | Level1)
1138 {
1139 struct AudioSceneDescriptor scene;
1140 scene.scene.id = AUDIO_IN_CALL;
1141 scene.desc.pins = PIN_IN_HS_MIC;
1142 scene.desc.desc = strdup("mic");
1143 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1144 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1145 #else
1146 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1147 #endif
1148 free(scene.desc.desc);
1149 }
1150
1151 /**
1152 * @tc.number SUB_Driver_Audio_SelectScene_3300
1153 * @tc.name testCommonRenderSelectScene030
1154 * @tc.desc Test input param
1155 */
1156 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene030, Function | MediumTest | Level1)
1157 {
1158 struct AudioSceneDescriptor scene;
1159 scene.scene.id = AUDIO_IN_MEDIA;
1160 scene.desc.pins = PIN_IN_LINEIN;
1161 scene.desc.desc = strdup("mic");
1162 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1163 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1164 #else
1165 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1166 #endif
1167 free(scene.desc.desc);
1168 }
1169
1170 /**
1171 * @tc.number SUB_Driver_Audio_SelectScene_3400
1172 * @tc.name testCommonRenderSelectScene031
1173 * @tc.desc Test input param
1174 */
1175 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene031, Function | MediumTest | Level1)
1176 {
1177 struct AudioSceneDescriptor scene;
1178 scene.scene.id = AUDIO_IN_COMMUNICATION;
1179 scene.desc.pins = PIN_IN_LINEIN;
1180 scene.desc.desc = strdup("mic");
1181 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1182 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1183 #else
1184 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1185 #endif
1186 free(scene.desc.desc);
1187 }
1188
1189 /**
1190 * @tc.number SUB_Driver_Audio_SelectScene_3500
1191 * @tc.name testCommonRenderSelectScene032
1192 * @tc.desc Test input param
1193 */
1194 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene032, Function | MediumTest | Level1)
1195 {
1196 struct AudioSceneDescriptor scene;
1197 scene.scene.id = AUDIO_IN_RINGTONE;
1198 scene.desc.pins = PIN_IN_LINEIN;
1199 scene.desc.desc = strdup("mic");
1200 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1201 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1202 #else
1203 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1204 #endif
1205 free(scene.desc.desc);
1206 }
1207
1208 /**
1209 * @tc.number SUB_Driver_Audio_SelectScene_3600
1210 * @tc.name testCommonRenderSelectScene033
1211 * @tc.desc Test input param
1212 */
1213 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene033, Function | MediumTest | Level1)
1214 {
1215 struct AudioSceneDescriptor scene;
1216 scene.scene.id = AUDIO_IN_CALL;
1217 scene.desc.pins = PIN_IN_LINEIN;
1218 scene.desc.desc = strdup("mic");
1219 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1220 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1221 #else
1222 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1223 #endif
1224 free(scene.desc.desc);
1225 }
1226
1227 /**
1228 * @tc.number SUB_Driver_Audio_SelectScene_3700
1229 * @tc.name testCommonRenderSelectScene034
1230 * @tc.desc Test input param
1231 */
1232 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene034, Function | MediumTest | Level1)
1233 {
1234 struct AudioSceneDescriptor scene;
1235 scene.scene.id = AUDIO_IN_MEDIA;
1236 scene.desc.pins = PIN_IN_USB_EXT;
1237 scene.desc.desc = strdup("mic");
1238 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1239 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1240 #else
1241 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1242 #endif
1243 free(scene.desc.desc);
1244 }
1245
1246 /**
1247 * @tc.number SUB_Driver_Audio_SelectScene_3800
1248 * @tc.name testCommonRenderSelectScene035
1249 * @tc.desc Test input param
1250 */
1251 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene035, Function | MediumTest | Level1)
1252 {
1253 struct AudioSceneDescriptor scene;
1254 scene.scene.id = AUDIO_IN_COMMUNICATION;
1255 scene.desc.pins = PIN_IN_USB_EXT;
1256 scene.desc.desc = strdup("mic");
1257 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1258 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1259 #else
1260 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1261 #endif
1262 free(scene.desc.desc);
1263 }
1264
1265 /**
1266 * @tc.number SUB_Driver_Audio_SelectScene_3900
1267 * @tc.name testCommonRenderSelectScene036
1268 * @tc.desc Test input param
1269 */
1270 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene036, Function | MediumTest | Level1)
1271 {
1272 struct AudioSceneDescriptor scene;
1273 scene.scene.id = AUDIO_IN_RINGTONE;
1274 scene.desc.pins = PIN_IN_USB_EXT;
1275 scene.desc.desc = strdup("mic");
1276 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1277 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1278 #else
1279 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1280 #endif
1281 free(scene.desc.desc);
1282 }
1283
1284 /**
1285 * @tc.number SUB_Driver_Audio_SelectScene_4000
1286 * @tc.name testCommonRenderSelectScene037
1287 * @tc.desc Test input param
1288 */
1289 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSelectScene037, Function | MediumTest | Level1)
1290 {
1291 struct AudioSceneDescriptor scene;
1292 scene.scene.id = AUDIO_IN_CALL;
1293 scene.desc.pins = PIN_IN_USB_EXT;
1294 scene.desc.desc = strdup("mic");
1295 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1296 EXPECT_NE(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1297 #else
1298 EXPECT_EQ(HDF_SUCCESS, render_->SelectScene(render_, &scene));
1299 #endif
1300 free(scene.desc.desc);
1301 }
1302
1303 /**
1304 * @tc.number SUB_Driver_Audio_GetMute_0400
1305 * @tc.name testCommonRenderGetMute002
1306 * @tc.desc Test parameters with abnormal input
1307 */
1308 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetMute002, Function | MediumTest | Level2)
1309 {
1310 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetMute(nullptr, nullptr));
1311 }
1312
1313 /**
1314 * @tc.number SUB_Driver_Audio_SetVolume_0400
1315 * @tc.name testCommonRenderSetVolume002
1316 * @tc.desc Test parameters with abnormal input
1317 */
1318 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetVolume002, Function | MediumTest | Level2)
1319 {
1320 float volume = -0.1;
1321 int32_t ret = 0;
1322 int i = 0;
1323 for (i = 0; i < 1000; i++) {
1324 ret = render_->SetVolume(render_, volume);
1325 EXPECT_NE(HDF_SUCCESS, ret);
1326 }
1327 }
1328
1329 /**
1330 * @tc.number SUB_Driver_Audio_GetVolume_0400
1331 * @tc.name testCommonRenderGetVolume002
1332 * @tc.desc Test parameters with abnormal input
1333 */
1334 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetVolume002, Function | MediumTest | Level2)
1335 {
1336 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetVolume(nullptr, nullptr));
1337 }
1338
1339 /**
1340 * @tc.number SUB_Driver_Audio_GetGainThreshold_0400
1341 * @tc.name testCommonRenderGetGainThreshold002
1342 * @tc.desc Test parameters with abnormal input
1343 */
1344 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetGainThreshold002, Function | MediumTest | Level2)
1345 {
1346 float max = 1.0;
1347 EXPECT_NE(HDF_SUCCESS, render_->GetGainThreshold(nullptr, nullptr, &max));
1348 }
1349
1350 /**
1351 * @tc.number SUB_Driver_Audio_GetGainThreshold_0500
1352 * @tc.name testCommonRenderGetGainThreshold003
1353 * @tc.desc Test parameters with abnormal input
1354 */
1355 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetGainThreshold003, Function | MediumTest | Level2)
1356 {
1357 float min = 1.0;
1358 EXPECT_NE(HDF_SUCCESS, render_->GetGainThreshold(nullptr, &min, nullptr));
1359 }
1360
1361 /**
1362 * @tc.number SUB_Driver_Audio_GetGainThreshold_0600
1363 * @tc.name testCommonRenderGetGainThreshold004
1364 * @tc.desc Test parameters with abnormal input
1365 */
1366 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetGainThreshold004, Function | MediumTest | Level2)
1367 {
1368 EXPECT_NE(HDF_SUCCESS, render_->GetGainThreshold(render_, nullptr, nullptr));
1369 }
1370
1371 /**
1372 * @tc.number SUB_Driver_Audio_GetGainThreshold_0700
1373 * @tc.name testCommonRenderGetGainThreshold005
1374 * @tc.desc Test parameters with abnormal input
1375 */
1376 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetGainThreshold005, Function | MediumTest | Level2)
1377 {
1378 EXPECT_NE(HDF_SUCCESS, render_->GetGainThreshold(nullptr, nullptr, nullptr));
1379 }
1380
1381 /**
1382 * @tc.number SUB_Driver_Audio_GetGain_0400
1383 * @tc.name testCommonRenderGetGain002
1384 * @tc.desc Test parameters with abnormal input
1385 */
1386 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetGain002, Function | MediumTest | Level2)
1387 {
1388 EXPECT_NE(HDF_SUCCESS, render_->GetGain(nullptr, nullptr));
1389 }
1390
1391 /**
1392 * @tc.number SUB_Driver_Audio_GetFrameSize_0400
1393 * @tc.name testCommonRenderGetFrameSize001
1394 * @tc.desc Reliability of function(GetFrameSize)
1395 */
1396 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetFrameSize001, Function | MediumTest | Level1)
1397 {
1398 uint64_t frameSize = 0;
1399 int i = 0;
1400 int32_t ret = 0;
1401 for (i = 0; i < 1000; i++) {
1402 ret = render_->GetFrameSize(render_, &frameSize);
1403 EXPECT_EQ(HDF_SUCCESS, ret);
1404 }
1405 }
1406
1407 /**
1408 * @tc.number SUB_Driver_Audio_GetFrameCount_0400
1409 * @tc.name testCommonRenderGetFrameCount001
1410 * @tc.desc Reliability of function(GetFrameCount)
1411 */
1412 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetFrameCount001, Function | MediumTest | Level1)
1413 {
1414 uint64_t frameCount = 0;
1415 int i = 0;
1416 int32_t ret = 0;
1417 for (i = 0; i < 1000; i++) {
1418 ret = render_->GetFrameCount(render_, &frameCount);
1419 EXPECT_EQ(HDF_SUCCESS, ret);
1420 }
1421 }
1422
1423 /**
1424 * @tc.number SUB_Driver_Audio_SetSampleAttributes_0400
1425 * @tc.name testCommonRenderSetSampleAttributes001
1426 * @tc.desc Reliability of function(SetSampleAttributes)
1427 */
1428 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetSampleAttributes001, Function | MediumTest | Level1)
1429 {
1430 struct AudioSampleAttributes attrs = attrsRender_;
1431 int i = 0;
1432 int32_t ret = 0;
1433 for (i = 0; i < 1000; i++) {
1434 ret = render_->SetSampleAttributes(render_, &attrs);
1435 EXPECT_EQ(HDF_SUCCESS, ret);
1436 }
1437 }
1438
1439 /**
1440 * @tc.number SUB_Driver_Audio_SetSampleAttributes_0500
1441 * @tc.name testCommonRenderSetSampleAttributes002
1442 * @tc.desc Test parameters with abnormal input
1443 */
1444 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetSampleAttributes002, Function | MediumTest | Level2)
1445 {
1446 EXPECT_NE(HDF_SUCCESS, render_->SetSampleAttributes(nullptr, nullptr));
1447 }
1448
1449 /**
1450 * @tc.number SUB_Driver_Audio_GetSampleAttributes_0400
1451 * @tc.name testCommonRenderGetSampleAttributes001
1452 * @tc.desc Reliability of function(GetSampleAttributes)
1453 */
1454 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetSampleAttributes001, Function | MediumTest | Level1)
1455 {
1456 struct AudioSampleAttributes attrs;
1457 int i = 0;
1458 int32_t ret = 0;
1459 for (i = 0; i < 1000; i++) {
1460 ret = render_->GetSampleAttributes(render_, &attrs);
1461 EXPECT_EQ(HDF_SUCCESS, ret);
1462 }
1463 }
1464
1465 /**
1466 * @tc.number SUB_Driver_Audio_GetSampleAttributes_0500
1467 * @tc.name testCommonRenderGetSampleAttributes002
1468 * @tc.desc Test parameters with abnormal input
1469 */
1470 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetSampleAttributes002, Function | MediumTest | Level2)
1471 {
1472 EXPECT_NE(HDF_SUCCESS, render_->GetSampleAttributes(nullptr, nullptr));
1473 }
1474
1475 /**
1476 * @tc.number SUB_Driver_Audio_GetCurrentChannelId_0400
1477 * @tc.name testCommonRenderGetCurrentChannelId001
1478 * @tc.desc Reliability of function(GetCurrentChannelId)
1479 */
1480 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetCurrentChannelId001, Function | MediumTest | Level1)
1481 {
1482 uint32_t channelId;
1483 int i = 0;
1484 int32_t ret = 0;
1485 for (i = 0; i < 1000; i++) {
1486 ret = render_->GetCurrentChannelId(render_, &channelId);
1487 EXPECT_EQ(HDF_SUCCESS, ret);
1488 }
1489 }
1490
1491 /**
1492 * @tc.number SUB_Driver_Audio_GetCurrentChannelId_0500
1493 * @tc.name testCommonRenderGetCurrentChannelId002
1494 * @tc.desc Test parameters with abnormal input
1495 */
1496 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetCurrentChannelId002, Function | MediumTest | Level2)
1497 {
1498 EXPECT_NE(HDF_SUCCESS, render_->GetCurrentChannelId(nullptr, nullptr));
1499 }
1500
1501 /**
1502 * @tc.number SUB_Driver_Audio_RenderSetExtraParams_0400
1503 * @tc.name testCommonRenderSetExtraParams001
1504 * @tc.desc Reliability of function(SetExtraParams)
1505 */
1506 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetExtraParams001, Function | MediumTest | Level1)
1507 {
1508 char keyValueList[AUDIO_RENDER_BUF_TEST] =
1509 "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
1510 int i = 0;
1511 int32_t ret = 0;
1512 for (i = 0; i < 1000; i++) {
1513 ret = render_->SetExtraParams(render_, keyValueList);
1514 EXPECT_EQ(HDF_SUCCESS, ret);
1515 }
1516 }
1517
1518 /**
1519 * @tc.number SUB_Driver_Audio_RenderSetExtraParams_0500
1520 * @tc.name testCommonRenderSetExtraParams002
1521 * @tc.desc Test parameters with abnormal input
1522 */
1523 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetExtraParams002, Function | MediumTest | Level2)
1524 {
1525 EXPECT_NE(HDF_SUCCESS, render_->SetExtraParams(nullptr, nullptr));
1526 }
1527
1528 /**
1529 * @tc.number SUB_Driver_Audio_RenderGetExtraParams_0500
1530 * @tc.name testCommonRenderGetExtraParams002
1531 * @tc.desc Test parameters with abnormal input
1532 */
1533 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetExtraParams002, Function | MediumTest | Level2)
1534 {
1535 uint32_t keyValueListLen = 0;
1536 EXPECT_NE(HDF_SUCCESS, render_->GetExtraParams(nullptr, nullptr, keyValueListLen));
1537 }
1538
1539 /**
1540 * @tc.number SUB_Driver_Audio_RenderGetExtraParams_0600
1541 * @tc.name testCommonRenderGetExtraParams003
1542 * @tc.desc Test input param
1543 */
1544 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetExtraParams003, Function | MediumTest | Level2)
1545 {
1546 char keyValueList[AUDIO_RENDER_BUF_TEST] = {};
1547 uint32_t keyValueListLen = 0xffffffff;
1548 EXPECT_EQ(HDF_ERR_INVALID_PARAM, render_->GetExtraParams(render_, keyValueList, keyValueListLen));
1549 }
1550
1551 /**
1552 * @tc.number SUB_Driver_Audio_AddAudioEffect_0100
1553 * @tc.name testCommonRenderAddAudioEffect001
1554 * @tc.desc Reliability of function(AddAudioEffect)
1555 */
1556 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAddAudioEffect001, TestSize.Level2)
1557 {
1558 uint64_t effectId = 256;
1559 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AddAudioEffect(nullptr, effectId));
1560 }
1561
1562 /**
1563 * @tc.number SUB_Driver_Audio_AddAudioEffect_0200
1564 * @tc.name testCommonRenderAddAudioEffect002
1565 * @tc.desc Reliability of function(AddAudioEffect)
1566 */
1567 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAddAudioEffect002, TestSize.Level2)
1568 {
1569 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AddAudioEffect(nullptr, -256));
1570 }
1571
1572 /**
1573 * @tc.number SUB_Driver_Audio_AddAudioEffect_0300
1574 * @tc.name testCommonRenderAddAudioEffect003
1575 * @tc.desc Reliability of function(AddAudioEffect)
1576 */
1577 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAddAudioEffect003, TestSize.Level2)
1578 {
1579 uint64_t effectId = 42949672950;
1580 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AddAudioEffect(nullptr, effectId));
1581 }
1582
1583 /**
1584 * @tc.number SUB_Driver_Audio_AddAudioEffect_0400
1585 * @tc.name testCommonRenderAddAudioEffect004
1586 * @tc.desc Reliability of function(AddAudioEffect)
1587 */
1588 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAddAudioEffect004, TestSize.Level2)
1589 {
1590 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AddAudioEffect(nullptr, -42949672950));
1591 }
1592
1593 /**
1594 * @tc.number SUB_Driver_Audio_AddAudioEffect_0500
1595 * @tc.name testCommonRenderAddAudioEffect005
1596 * @tc.desc Reliability of function(AddAudioEffect)
1597 */
1598 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAddAudioEffect005, TestSize.Level2)
1599 {
1600 int32_t i;
1601 uint64_t effectId = 0;
1602 for (i = 0; i < 20; i++) {
1603 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AddAudioEffect(nullptr, effectId));
1604 }
1605 }
1606
1607 /**
1608 * @tc.number SUB_Driver_Audio_AddAudioEffect_0600
1609 * @tc.name testCommonRenderAddAudioEffect006
1610 * @tc.desc Reliability of function(AddAudioEffect)
1611 */
1612 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAddAudioEffect006, TestSize.Level2)
1613 {
1614 int32_t i;
1615 uint64_t effectId = 5;
1616 for (i = 0; i < 20; i++) {
1617 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AddAudioEffect(nullptr, effectId));
1618 }
1619 }
1620
1621 /**
1622 * @tc.number SUB_Driver_Audio_AddAudioEffect_0700
1623 * @tc.name testCommonRenderAddAudioEffect007
1624 * @tc.desc Reliability of function(AddAudioEffect)
1625 */
1626 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAddAudioEffect007, TestSize.Level2)
1627 {
1628 uint64_t effectId = 1000;
1629 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AddAudioEffect(nullptr, effectId));
1630 }
1631
1632 /**
1633 * @tc.number SUB_Driver_Audio_AddAudioEffect_0800
1634 * @tc.name testCommonRenderAddAudioEffect008
1635 * @tc.desc Reliability of function(AddAudioEffect)
1636 */
1637 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAddAudioEffect008, TestSize.Level2)
1638 {
1639 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AddAudioEffect(nullptr, 2));
1640 }
1641
1642 /**
1643 * @tc.number SUB_Driver_Audio_AddAudioEffect_0900
1644 * @tc.name testCommonRenderAddAudioEffect009
1645 * @tc.desc Reliability of function(AddAudioEffect)
1646 */
1647 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAddAudioEffect009, TestSize.Level2)
1648 {
1649 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AddAudioEffect(nullptr, 40));
1650 }
1651
1652 /**
1653 * @tc.number SUB_Driver_Audio_AddAudioEffect_1000
1654 * @tc.name testCommonRenderAddAudioEffect010
1655 * @tc.desc Reliability of function(AddAudioEffect)
1656 */
1657 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAddAudioEffect010, TestSize.Level2)
1658 {
1659 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AddAudioEffect(nullptr, -60));
1660 }
1661
1662 /**
1663 * @tc.number SUB_Driver_Audio_RemoveAudioEffect_0100
1664 * @tc.name testCommonRenderRemoveAudioEffect001
1665 * @tc.desc Reliability of function(RemoveAudioEffect)
1666 */
1667 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRemoveAudioEffect001, TestSize.Level2)
1668 {
1669 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->RemoveAudioEffect(nullptr, -256));
1670 }
1671
1672 /**
1673 * @tc.number SUB_Driver_Audio_RemoveAudioEffect_0200
1674 * @tc.name testCommonRenderRemoveAudioEffect002
1675 * @tc.desc Reliability of function(RemoveAudioEffect)
1676 */
1677 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRemoveAudioEffect002, TestSize.Level2)
1678 {
1679 uint64_t effectId = 42949672950;
1680 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->RemoveAudioEffect(nullptr, effectId));
1681 }
1682
1683 /**
1684 * @tc.number SUB_Driver_Audio_RemoveAudioEffect_0300
1685 * @tc.name testCommonRenderRemoveAudioEffect003
1686 * @tc.desc Reliability of function(RemoveAudioEffect)
1687 */
1688 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRemoveAudioEffect003, TestSize.Level2)
1689 {
1690 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->RemoveAudioEffect(nullptr, -42949672950));
1691 }
1692
1693 /**
1694 * @tc.number SUB_Driver_Audio_RemoveAudioEffect_0400
1695 * @tc.name testCommonRenderRemoveAudioEffect004
1696 * @tc.desc Reliability of function(RemoveAudioEffect)
1697 */
1698 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRemoveAudioEffect004, TestSize.Level2)
1699 {
1700 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->RemoveAudioEffect(nullptr, 6));
1701 }
1702
1703 /**
1704 * @tc.number SUB_Driver_Audio_RemoveAudioEffect_0500
1705 * @tc.name testCommonRenderRemoveAudioEffect005
1706 * @tc.desc Reliability of function(RemoveAudioEffect)
1707 */
1708 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRemoveAudioEffect005, TestSize.Level2)
1709 {
1710 int32_t i;
1711 uint64_t effectId = 0;
1712 for (i = 0; i < 20; i++) {
1713 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->RemoveAudioEffect(nullptr, effectId));
1714 }
1715 }
1716
1717 /**
1718 * @tc.number SUB_Driver_Audio_RemoveAudioEffect_0600
1719 * @tc.name testCommonRenderRemoveAudioEffect006
1720 * @tc.desc Reliability of function(RemoveAudioEffect)
1721 */
1722 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRemoveAudioEffect006, TestSize.Level2)
1723 {
1724 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->RemoveAudioEffect(nullptr, 90));
1725 }
1726
1727 /**
1728 * @tc.number SUB_Driver_Audio_RemoveAudioEffect_0700
1729 * @tc.name testCommonRenderRemoveAudioEffect007
1730 * @tc.desc Reliability of function(RemoveAudioEffect)
1731 */
1732 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRemoveAudioEffect007, TestSize.Level2)
1733 {
1734 int32_t i;
1735 for (i = 0; i < 20; i++) {
1736 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->RemoveAudioEffect(nullptr, 70));
1737 }
1738 }
1739
1740 /**
1741 * @tc.number SUB_Driver_Audio_RemoveAudioEffect_0800
1742 * @tc.name testCommonRenderRemoveAudioEffect008
1743 * @tc.desc Reliability of function(RemoveAudioEffect)
1744 */
1745 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRemoveAudioEffect008, TestSize.Level2)
1746 {
1747 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->RemoveAudioEffect(nullptr, -80));
1748 }
1749
1750 /**
1751 * @tc.number SUB_Driver_Audio_Start_0100
1752 * @tc.name testCommonRenderStart001
1753 * @tc.desc Reliability of function(Start)
1754 */
1755 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStart001, TestSize.Level2)
1756 {
1757 int32_t i;
1758 for (i = 0; i < 100; i++) {
1759 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Start(nullptr));
1760 }
1761 }
1762
1763 /**
1764 * @tc.number SUB_Driver_Audio_Start_0200
1765 * @tc.name testCommonRenderStart002
1766 * @tc.desc Reliability of function(Start)
1767 */
1768 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStart002, TestSize.Level1)
1769 {
1770 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Start(nullptr));
1771 render_->Stop(render_);
1772 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1773 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1774 }
1775
1776 /**
1777 * @tc.number SUB_Driver_Audio_Start_0300
1778 * @tc.name testCommonRenderStart003
1779 * @tc.desc Reliability of function(Start)
1780 */
1781 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStart003, TestSize.Level2)
1782 {
1783 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1784 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1785 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Start(nullptr));
1786 render_->Stop(render_);
1787 }
1788
1789 /**
1790 * @tc.number SUB_Driver_Audio_Start_0400
1791 * @tc.name testCommonRenderStart004
1792 * @tc.desc Reliability of function(Start)
1793 */
1794 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStart004, TestSize.Level2)
1795 {
1796 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Start(nullptr));
1797 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Stop(nullptr));
1798 }
1799
1800 /**
1801 * @tc.number SUB_Driver_Audio_Start_0500
1802 * @tc.name testCommonRenderStart005
1803 * @tc.desc Reliability of function(Start)
1804 */
1805 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStart005, TestSize.Level1)
1806 {
1807 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1808 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Stop(nullptr));
1809 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1810 int32_t i;
1811 for (i = 0; i < 10; i++) {
1812 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1813 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1814 }
1815 }
1816
1817 /**
1818 * @tc.number SUB_Driver_Audio_Start_0600
1819 * @tc.name testCommonRenderStart006
1820 * @tc.desc Reliability of function(Start)
1821 */
1822 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStart006, TestSize.Level1)
1823 {
1824 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1825 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1826 int32_t i;
1827 for (i = 0; i < 10; i++) {
1828 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Start(nullptr));
1829 render_->Stop(render_);
1830 }
1831 }
1832 /**
1833 * @tc.number SUB_Driver_Audio_Stop_0100
1834 * @tc.name testCommonRenderStop001
1835 * @tc.desc Reliability of function(Stop)
1836 */
1837 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStop001, TestSize.Level2)
1838 {
1839 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Stop(nullptr));
1840 }
1841
1842 /**
1843 * @tc.number SUB_Driver_Audio_Stop_0200
1844 * @tc.name testCommonRenderStop002
1845 * @tc.desc Reliability of function(Stop)
1846 */
1847 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStop002, TestSize.Level2)
1848 {
1849 int32_t i;
1850 for (i = 0; i < 100; i++) {
1851 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Stop(nullptr));
1852 }
1853 }
1854
1855 /**
1856 * @tc.number SUB_Driver_Audio_Stop_0300
1857 * @tc.name testCommonRenderStop003
1858 * @tc.desc Reliability of function(Stop)
1859 */
1860 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStop003, TestSize.Level1)
1861 {
1862 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1863 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1864 int32_t i;
1865 for (i = 0; i < 200; i++) {
1866 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1867 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1868 }
1869 }
1870
1871 /**
1872 * @tc.number SUB_Driver_Audio_Stop_0400
1873 * @tc.name testCommonRenderStop004
1874 * @tc.desc Reliability of function(Stop)
1875 */
1876 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStop004, TestSize.Level2)
1877 {
1878 int32_t i;
1879 for (i = 0; i < 150; i++) {
1880 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1881 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1882 }
1883 }
1884
1885 /**
1886 * @tc.number SUB_Driver_Audio_Stop_0500
1887 * @tc.name testCommonRenderStop005
1888 * @tc.desc Reliability of function(Stop)
1889 */
1890 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStop005, TestSize.Level1)
1891 {
1892 int32_t i;
1893 for (i = 0; i < 20; i++) {
1894 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1895 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1896 }
1897 }
1898
1899 /**
1900 * @tc.number SUB_Driver_Audio_Stop_0600
1901 * @tc.name testCommonRenderStop006
1902 * @tc.desc Reliability of function(Stop)
1903 */
1904 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStop006, TestSize.Level2)
1905 {
1906 int32_t i;
1907 for (i = 0; i < 20; i++) {
1908 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1909 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1910 }
1911 }
1912
1913 /**
1914 * @tc.number SUB_Driver_Audio_Stop_0800
1915 * @tc.name testCommonRenderStop008
1916 * @tc.desc Reliability of function(Stop)
1917 */
1918 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStop008, TestSize.Level1)
1919 {
1920 float speed = 0.0;
1921 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1922 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->GetRenderSpeed(render_, &speed));
1923 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1924 int32_t i;
1925 for (i = 0; i < 25; i++) {
1926 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1927 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1928 }
1929 }
1930
1931 /**
1932 * @tc.number SUB_Driver_Audio_Stop_0900
1933 * @tc.name testCommonRenderStop009
1934 * @tc.desc Reliability of function(Stop)
1935 */
1936 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStop009, TestSize.Level1)
1937 {
1938 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1939 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->GetRenderSpeed(nullptr, nullptr));
1940 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1941 }
1942
1943 /**
1944 * @tc.number SUB_Driver_Audio_Stop_1000
1945 * @tc.name testCommonRenderStop010
1946 * @tc.desc Reliability of function(Stop)
1947 */
1948 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStop010, TestSize.Level1)
1949 {
1950 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1951 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1952 int32_t i;
1953 for (i = 0; i < 100; i++) {
1954 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1955 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1956 }
1957 }
1958
1959 /**
1960 * @tc.number SUB_Driver_Audio_Stop_1100
1961 * @tc.name testCommonRenderStop011
1962 * @tc.desc Reliability of function(Stop)
1963 */
1964 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStop011, TestSize.Level1)
1965 {
1966 int32_t i;
1967 for (i = 0; i < 100; i++) {
1968 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1969 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1970 }
1971 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1972 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1973 }
1974
1975 /**
1976 * @tc.number SUB_Driver_Audio_Stop_1200
1977 * @tc.name testCommonRenderStop012
1978 * @tc.desc Reliability of function(Stop)
1979 */
1980 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStop012, TestSize.Level1)
1981 {
1982 int32_t i;
1983 for (i = 0; i < 100; i++) {
1984 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Stop(nullptr));
1985 }
1986 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
1987 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
1988 }
1989
1990 /**
1991 * @tc.number SUB_Driver_Audio_Stop_1300
1992 * @tc.name testCommonRenderStop013
1993 * @tc.desc Reliability of function(Stop)
1994 */
1995 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStop013, TestSize.Level2)
1996 {
1997 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Stop(nullptr));
1998 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Start(nullptr));
1999 int32_t i;
2000 for (i = 0; i < 100; i++) {
2001 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2002 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2003 }
2004 }
2005
2006 /**
2007 * @tc.number SUB_Driver_Audio_Stop_1400
2008 * @tc.name testCommonRenderStop014
2009 * @tc.desc Reliability of function(Stop)
2010 */
2011 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStop014, TestSize.Level2)
2012 {
2013 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Stop(nullptr));
2014 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Start(nullptr));
2015 int32_t i;
2016 for (i = 0; i < 100; i++) {
2017 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Stop(nullptr));
2018 }
2019 }
2020
2021 /**
2022 * @tc.number: SUB_Driver_Audio_AudioDevDump_0100
2023 * @tc.name: testCommonRenderAudioDevDump001
2024 * @tc.desc: Dumps information about the audio device.
2025 */
2026 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump001, TestSize.Level2)
2027 {
2028 ASSERT_NE(render_->AudioDevDump, nullptr);
2029 int32_t range = 1;
2030
2031 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AudioDevDump(nullptr, range, -1));
2032 }
2033
2034 /**
2035 * @tc.number: SUB_Driver_Audio_AudioDevDump_0200
2036 * @tc.name: testCommonRenderAudioDevDump002
2037 * @tc.desc: Dumps information about the audio device.
2038 */
2039 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump002, TestSize.Level2)
2040 {
2041 ASSERT_NE(render_->AudioDevDump, nullptr);
2042 int32_t range = 2;
2043
2044 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AudioDevDump(nullptr, range, -1));
2045 }
2046
2047 /**
2048 * @tc.number: SUB_Driver_Audio_AudioDevDump_0300
2049 * @tc.name: testCommonRenderAudioDevDump003
2050 * @tc.desc: Dumps information about the audio device.
2051 */
2052 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump003, TestSize.Level2)
2053 {
2054 ASSERT_NE(render_->AudioDevDump, nullptr);
2055 int32_t range = 3;
2056
2057 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AudioDevDump(nullptr, range, -1));
2058 }
2059
2060 /**
2061 * @tc.number: SUB_Driver_Audio_AudioDevDump_0400
2062 * @tc.name: testCommonRenderAudioDevDump004
2063 * @tc.desc: Dumps information about the audio device.
2064 */
2065 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump004, TestSize.Level2)
2066 {
2067 ASSERT_NE(render_->AudioDevDump, nullptr);
2068 int32_t range = 5;
2069
2070 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AudioDevDump(nullptr, range, -1));
2071 }
2072
2073 /**
2074 * @tc.number: SUB_Driver_Audio_AudioDevDump_0500
2075 * @tc.name: testCommonRenderAudioDevDump005
2076 * @tc.desc: Dumps information about the audio device.
2077 */
2078 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump005, TestSize.Level2)
2079 {
2080 ASSERT_NE(render_->AudioDevDump, nullptr);
2081 int32_t range = 6;
2082
2083 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AudioDevDump(nullptr, range, -1));
2084 }
2085
2086 /**
2087 * @tc.number: SUB_Driver_Audio_AudioDevDump_1100
2088 * @tc.name: testCommonRenderAudioDevDump011
2089 * @tc.desc: Dumps information about the audio device.
2090 */
2091 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump011, TestSize.Level2)
2092 {
2093 ASSERT_NE(render_->AudioDevDump, nullptr);
2094 int32_t range = 4;
2095
2096 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AudioDevDump(nullptr, range, 0));
2097 }
2098
2099 /**
2100 * @tc.number: SUB_Driver_Audio_AudioDevDump_1200
2101 * @tc.name: testCommonRenderAudioDevDump012
2102 * @tc.desc: Dumps information about the audio device.
2103 */
2104 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump012, TestSize.Level2)
2105 {
2106 ASSERT_NE(render_->AudioDevDump, nullptr);
2107 int32_t range = 4;
2108
2109 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AudioDevDump(nullptr, range, 1));
2110 }
2111
2112 /**
2113 * @tc.number: SUB_Driver_Audio_AudioDevDump_1300
2114 * @tc.name: testCommonRenderAudioDevDump013
2115 * @tc.desc: Dumps information about the audio device.
2116 */
2117 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump013, TestSize.Level2)
2118 {
2119 ASSERT_NE(render_->AudioDevDump, nullptr);
2120 int32_t range = 4;
2121
2122 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AudioDevDump(nullptr, range, 2));
2123 }
2124
2125 /**
2126 * @tc.number: SUB_Driver_Audio_AudioDevDump_1400
2127 * @tc.name: testCommonRenderAudioDevDump014
2128 * @tc.desc: Dumps information about the audio device.
2129 */
2130 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump014, TestSize.Level2)
2131 {
2132 ASSERT_NE(render_->AudioDevDump, nullptr);
2133 int32_t range = 4;
2134
2135 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AudioDevDump(nullptr, range, 3));
2136 }
2137
2138 /**
2139 * @tc.number: SUB_Driver_Audio_AudioDevDump_1500
2140 * @tc.name: testCommonRenderAudioDevDump015
2141 * @tc.desc: Dumps information about the audio device.
2142 */
2143 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump015, TestSize.Level2)
2144 {
2145 ASSERT_NE(render_->AudioDevDump, nullptr);
2146 int32_t range = 4;
2147
2148 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AudioDevDump(nullptr, range, 4));
2149 }
2150
2151 /**
2152 * @tc.number: SUB_Driver_Audio_AudioDevDump_1600
2153 * @tc.name: testCommonRenderAudioDevDump016
2154 * @tc.desc: Dumps information about the audio device.
2155 */
2156 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump016, TestSize.Level2)
2157 {
2158 ASSERT_NE(render_->AudioDevDump, nullptr);
2159 int32_t range = 4;
2160
2161 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->AudioDevDump(nullptr, range, -2));
2162 }
2163
2164 /**
2165 * @tc.number: SUB_Driver_Audio_Pause_0100
2166 * @tc.name: testCommonRenderPause001
2167 * @tc.desc: Pauses audio rendering or capturing.
2168 */
2169 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderPause001, TestSize.Level2)
2170 {
2171 for (int i = 0; i < 50; i++) {
2172 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Pause(nullptr));
2173 }
2174 }
2175
2176 /**
2177 * @tc.number: SUB_Driver_Audio_Pause_0200
2178 * @tc.name: testCommonRenderPause002
2179 * @tc.desc: Pauses audio rendering or capturing.
2180 */
2181 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderPause002, TestSize.Level1)
2182 {
2183 int32_t ret;
2184 for (int i = 0; i < 50; i++) {
2185 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2186 ret = render_->Pause(render_);
2187 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2188 EXPECT_EQ(ret, HDF_SUCCESS);
2189 EXPECT_EQ(HDF_SUCCESS, render_->Resume(render_));
2190 #else
2191 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2192 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Resume(render_));
2193 #endif
2194 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2195 }
2196 }
2197
2198 /**
2199 * @tc.number: SUB_Driver_Audio_Pause_0300
2200 * @tc.name: testCommonRenderPause003
2201 * @tc.desc: Pauses audio rendering or capturing.
2202 */
2203 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderPause003, TestSize.Level1)
2204 {
2205 ASSERT_NE(render_->Pause, nullptr);
2206 ASSERT_NE(render_->Start, nullptr);
2207
2208 int32_t ret = render_->Start(render_);
2209 EXPECT_EQ(ret, HDF_SUCCESS);
2210 ret = render_->Pause(render_);
2211 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2212 EXPECT_EQ(ret, HDF_SUCCESS);
2213 EXPECT_EQ(HDF_SUCCESS, render_->Resume(render_));
2214 #else
2215 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2216 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Resume(render_));
2217 #endif
2218 render_->Stop(render_);
2219 }
2220
2221 /**
2222 * @tc.number: SUB_Driver_Audio_Pause_0400
2223 * @tc.name: testCommonRenderPause004
2224 * @tc.desc: Pauses audio rendering or capturing.
2225 */
2226 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderPause004, TestSize.Level2)
2227 {
2228 ASSERT_NE(render_->Pause, nullptr);
2229 ASSERT_NE(render_->Start, nullptr);
2230 int32_t ret = render_->Start(render_);
2231 EXPECT_EQ(ret, HDF_SUCCESS);
2232 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2233 ret = render_->Pause(render_);
2234 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2235 EXPECT_EQ(ret, HDF_FAILURE);
2236 #else
2237 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2238 #endif
2239 }
2240
2241 /**
2242 * @tc.number: SUB_Driver_Audio_Pause_0500
2243 * @tc.name: testCommonRenderPause005
2244 * @tc.desc: Pauses audio rendering or capturing.
2245 */
2246 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderPause005, TestSize.Level1)
2247 {
2248 ASSERT_NE(render_->Pause, nullptr);
2249 ASSERT_NE(render_->Start, nullptr);
2250
2251 int32_t ret = render_->Start(render_);
2252 EXPECT_EQ(ret, HDF_SUCCESS);
2253 ret = render_->Pause(render_);
2254 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2255 EXPECT_EQ(ret, HDF_SUCCESS);
2256 EXPECT_EQ(HDF_SUCCESS, render_->Resume(render_));
2257 #else
2258 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2259 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Resume(render_));
2260 #endif
2261
2262 ret = render_->Pause(render_);
2263 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2264 EXPECT_EQ(ret, HDF_SUCCESS);
2265 EXPECT_EQ(HDF_SUCCESS, render_->Resume(render_));
2266 #else
2267 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2268 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Resume(render_));
2269 #endif
2270 render_->Stop(render_);
2271 }
2272
2273 /**
2274 * @tc.number: SUB_Driver_Audio_Pause_0600
2275 * @tc.name: testCommonRenderPause006
2276 * @tc.desc: Pauses audio rendering or capturing.
2277 */
2278 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderPause006, TestSize.Level1)
2279 {
2280 ASSERT_NE(render_->Pause, nullptr);
2281 ASSERT_NE(render_->Start, nullptr);
2282 int32_t ret = render_->Start(render_);
2283 EXPECT_EQ(ret, HDF_SUCCESS);
2284 ret = render_->Pause(render_);
2285 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2286 EXPECT_EQ(ret, HDF_SUCCESS);
2287 EXPECT_EQ(HDF_SUCCESS, render_->Resume(render_));
2288 #else
2289 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2290 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Resume(render_));
2291 #endif
2292 for (int i = 0; i < 50; i++) {
2293 ret = render_->Pause(render_);
2294 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2295 EXPECT_EQ(ret, HDF_SUCCESS);
2296 EXPECT_EQ(HDF_SUCCESS, render_->Resume(render_));
2297 #else
2298 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2299 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Resume(render_));
2300 #endif
2301 }
2302 render_->Stop(render_);
2303 }
2304
2305 /**
2306 * @tc.number: SUB_Driver_Audio_Pause_0700
2307 * @tc.name: testCommonRenderPause007
2308 * @tc.desc: Pauses audio rendering or capturing.
2309 */
2310 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderPause007, TestSize.Level1)
2311 {
2312 ASSERT_NE(render_->Pause, nullptr);
2313 ASSERT_NE(render_->Start, nullptr);
2314 ASSERT_NE(render_->Resume, nullptr);
2315
2316 int32_t ret = render_->Start(render_);
2317 EXPECT_EQ(ret, HDF_SUCCESS);
2318 render_->Resume(render_);
2319 ret = render_->Pause(render_);
2320 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2321 EXPECT_EQ(ret, HDF_SUCCESS);
2322 #else
2323 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2324 #endif
2325 render_->Stop(render_);
2326 }
2327
2328 /**
2329 * @tc.number: SUB_Driver_Audio_Pause_0800
2330 * @tc.name: testCommonRenderPause008
2331 * @tc.desc: Pauses audio rendering or capturing.
2332 */
2333 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderPause008, TestSize.Level1)
2334 {
2335 ASSERT_NE(render_->Pause, nullptr);
2336 ASSERT_NE(render_->Start, nullptr);
2337 ASSERT_NE(render_->Resume, nullptr);
2338
2339 int32_t ret = render_->Start(render_);
2340 EXPECT_EQ(ret, HDF_SUCCESS);
2341 for (int i = 0; i < 50; i++) {
2342 ret = render_->Pause(render_);
2343 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2344 EXPECT_EQ(ret, HDF_SUCCESS);
2345 #else
2346 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2347 #endif
2348 render_->Resume(render_);
2349 }
2350 render_->Stop(render_);
2351 }
2352
2353 /**
2354 * @tc.number: SUB_Driver_Audio_Resume_0100
2355 * @tc.name: testCommonRenderResume001
2356 * @tc.desc: Resumes audio rendering or capturing.
2357 */
2358 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderResume001, TestSize.Level2)
2359 {
2360 for (int i = 0; i < 50; i++) {
2361 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Resume(nullptr));
2362 }
2363 }
2364
2365 /**
2366 * @tc.number: SUB_Driver_Audio_Resume_0200
2367 * @tc.name: testCommonRenderResume002
2368 * @tc.desc: Resumes audio rendering or capturing.
2369 */
2370 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderResume002, TestSize.Level2)
2371 {
2372 for (int i = 0; i < 50; i++) {
2373 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Resume(render_));
2374 }
2375 }
2376
2377 /**
2378 * @tc.number: SUB_Driver_Audio_Resume_0300
2379 * @tc.name: testCommonRenderResume003
2380 * @tc.desc: Resumes audio rendering or capturing.
2381 */
2382 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderResume003, TestSize.Level1)
2383 {
2384 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2385 int32_t ret = render_->Pause(render_);
2386 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2387 EXPECT_EQ(ret, HDF_SUCCESS);
2388 #else
2389 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2390 #endif
2391
2392 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2393 EXPECT_EQ(HDF_SUCCESS, render_->Resume(render_));
2394 #else
2395 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Resume(render_));
2396 #endif
2397
2398 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2399 }
2400
2401 /**
2402 * @tc.number: SUB_Driver_Audio_Resume_0400
2403 * @tc.name: testCommonRenderResume004
2404 * @tc.desc: Resumes audio rendering or capturing.
2405 */
2406 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderResume004, TestSize.Level2)
2407 {
2408 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2409 int32_t ret = render_->Stop(render_);
2410 EXPECT_EQ(ret, HDF_SUCCESS);
2411 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Resume(render_));
2412 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2413 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Stop(render_));
2414 #else
2415 EXPECT_EQ(HDF_FAILURE, render_->Stop(render_));
2416 #endif
2417 }
2418
2419 /**
2420 * @tc.number: SUB_Driver_Audio_Resume_0500
2421 * @tc.name: testCommonRenderResume005
2422 * @tc.desc: Resumes audio rendering or capturing.
2423 */
2424 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderResume005, TestSize.Level2)
2425 {
2426 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2427 int32_t ret = render_->Stop(render_);
2428 EXPECT_EQ(ret, HDF_SUCCESS);
2429 for (int i = 0; i < 50; i++) {
2430 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Resume(render_));
2431 }
2432 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2433 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Stop(render_));
2434 #else
2435 EXPECT_EQ(HDF_FAILURE, render_->Stop(render_));
2436 #endif
2437 }
2438
2439 /**
2440 * @tc.number: SUB_Driver_Audio_Resume_0600
2441 * @tc.name: testCommonRenderResume006
2442 * @tc.desc: Resumes audio rendering or capturing.
2443 */
2444 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderResume006, TestSize.Level1)
2445 {
2446 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2447 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2448 EXPECT_EQ(HDF_SUCCESS, render_->Pause(render_));
2449 #else
2450 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Pause(render_));
2451 #endif
2452 int32_t ret = render_->Resume(render_);
2453 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2454 EXPECT_EQ(HDF_SUCCESS, ret);
2455 #else
2456 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2457 #endif
2458 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2459 }
2460
2461 /**
2462 * @tc.number: SUB_Driver_Audio_Resume_0700
2463 * @tc.name: testCommonRenderResume007
2464 * @tc.desc: Resumes audio rendering or capturing.
2465 */
2466 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderResume007, TestSize.Level1)
2467 {
2468 int32_t ret;
2469 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2470 for (int i = 0; i < 50; i++) {
2471 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2472 EXPECT_EQ(HDF_SUCCESS, render_->Pause(render_));
2473 #else
2474 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Pause(render_));
2475 #endif
2476 ret = render_->Resume(render_);
2477 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2478 EXPECT_EQ(HDF_SUCCESS, ret);
2479 #else
2480 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2481 #endif
2482 }
2483 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2484 }
2485
2486 /**
2487 * @tc.number: SUB_Driver_Audio_Resume_0800
2488 * @tc.name: testCommonRenderResume008
2489 * @tc.desc: Resumes audio rendering or capturing.
2490 */
2491 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderResume008, TestSize.Level1)
2492 {
2493 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2494 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2495 EXPECT_EQ(HDF_SUCCESS, render_->Pause(render_));
2496 #else
2497 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Pause(render_));
2498 #endif
2499 render_->Flush(render_);
2500 int32_t ret = render_->Resume(render_);
2501 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2502 EXPECT_EQ(HDF_SUCCESS, ret);
2503 #else
2504 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2505 #endif
2506 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2507 }
2508
2509 /**
2510 * @tc.number: SUB_Driver_Audio_Resume_0900
2511 * @tc.name: testCommonRenderResume009
2512 * @tc.desc: Resumes audio rendering or capturing.
2513 */
2514 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderResume009, TestSize.Level2)
2515 {
2516 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2517 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2518 EXPECT_EQ(HDF_SUCCESS, render_->Pause(render_));
2519 #else
2520 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Pause(render_));
2521 #endif
2522 int32_t ret = render_->Resume(render_);
2523 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2524 EXPECT_EQ(HDF_SUCCESS, ret);
2525 #else
2526 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2527 #endif
2528 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Resume(render_));
2529 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2530 }
2531
2532 /**
2533 * @tc.number: SUB_Driver_Audio_Resume_1000
2534 * @tc.name: testCommonRenderResume010
2535 * @tc.desc: Resumes audio rendering or capturing.
2536 */
2537 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderResume010, TestSize.Level2)
2538 {
2539 int32_t ret;
2540 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2541 for (int i = 0; i < 50; i++) {
2542 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2543 EXPECT_EQ(HDF_SUCCESS, render_->Pause(render_));
2544 #else
2545 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Pause(render_));
2546 #endif
2547 ret = render_->Resume(render_);
2548 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2549 EXPECT_EQ(HDF_SUCCESS, ret);
2550 #else
2551 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2552 #endif
2553 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Resume(render_));
2554 }
2555 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2556 }
2557
2558 /**
2559 * @tc.number: SUB_Driver_Audio_Resume_1100
2560 * @tc.name: testCommonRenderResume011
2561 * @tc.desc: Resumes audio rendering or capturing.
2562 */
2563 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderResume011, TestSize.Level2)
2564 {
2565 int32_t ret = render_->Resume(render_);
2566 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2567 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2568 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Stop(render_));
2569 #else
2570 EXPECT_EQ(HDF_FAILURE, render_->Stop(render_));
2571 #endif
2572 }
2573
2574 /**
2575 * @tc.number: SUB_Driver_Audio_Resume_1200
2576 * @tc.name: testCommonRenderResume012
2577 * @tc.desc: Resumes audio rendering or capturing.
2578 */
2579 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderResume012, TestSize.Level2)
2580 {
2581 int32_t ret;
2582 for (int i = 0; i < 50; i++) {
2583 ret = render_->Resume(render_);
2584 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2585 }
2586 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2587 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Stop(render_));
2588 #else
2589 EXPECT_EQ(HDF_FAILURE, render_->Stop(render_));
2590 #endif
2591 }
2592
2593 /**
2594 * @tc.number: SUB_Driver_Audio_Resume_1300
2595 * @tc.name: testCommonRenderResume013
2596 * @tc.desc: Resumes audio rendering or capturing.
2597 */
2598 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderResume013, TestSize.Level1)
2599 {
2600 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2601 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2602 EXPECT_EQ(HDF_SUCCESS, render_->Pause(render_));
2603 #else
2604 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Pause(render_));
2605 #endif
2606 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2607 render_->Flush(render_);
2608 int32_t ret = render_->Resume(render_);
2609 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2610 EXPECT_EQ(HDF_SUCCESS, ret);
2611 #else
2612 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2613 #endif
2614 }
2615
2616 /**
2617 * @tc.number: SUB_Driver_Audio_Flush_0100
2618 * @tc.name: testCommonRenderFlush001
2619 * @tc.desc: Flushes data in the audio buffer.
2620 */
2621 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderFlush001, TestSize.Level2)
2622 {
2623 for (int i = 0; i < 50; i++) {
2624 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->Flush(nullptr));
2625 }
2626 }
2627
2628 /**
2629 * @tc.number: SUB_Driver_Audio_Flush_0200
2630 * @tc.name: testCommonRenderFlush002
2631 * @tc.desc: Flushes data in the audio buffer.
2632 */
2633 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderFlush002, TestSize.Level2)
2634 {
2635 for (int i = 0; i < 50; i++) {
2636 EXPECT_NE(HDF_SUCCESS, render_->Flush(render_));
2637 }
2638 }
2639
2640 /**
2641 * @tc.number: SUB_Driver_Audio_Flush_0300
2642 * @tc.name: testCommonRenderFlush003
2643 * @tc.desc: Flushes data in the audio buffer.
2644 */
2645 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderFlush003, TestSize.Level2)
2646 {
2647 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2648 int32_t ret = render_->Flush(render_);
2649 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2650 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2651 }
2652
2653 /**
2654 * @tc.number: SUB_Driver_Audio_Flush_0400
2655 * @tc.name: testCommonRenderFlush004
2656 * @tc.desc: Flushes data in the audio buffer.
2657 */
2658 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderFlush004, TestSize.Level2)
2659 {
2660 int32_t ret;
2661 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2662 for (int i = 0; i < 50; i++) {
2663 ret = render_->Flush(render_);
2664 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2665 }
2666 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2667 }
2668
2669 /**
2670 * @tc.number: SUB_Driver_Audio_Flush_0500
2671 * @tc.name: testCommonRenderFlush005
2672 * @tc.desc: Flushes data in the audio buffer.
2673 */
2674 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderFlush005, TestSize.Level2)
2675 {
2676 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2677 int32_t ret = render_->Flush(render_);
2678 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2679 render_->Resume(render_);
2680 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Flush(render_));
2681 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2682 }
2683
2684 /**
2685 * @tc.number: SUB_Driver_Audio_Flush_0600
2686 * @tc.name: testCommonRenderFlush006
2687 * @tc.desc: Flushes data in the audio buffer.
2688 */
2689 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderFlush006, TestSize.Level2)
2690 {
2691 int32_t ret;
2692 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2693 for (int i = 0; i < 50; i++) {
2694 ret = render_->Flush(render_);
2695 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2696 }
2697 render_->Resume(render_);
2698 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Flush(render_));
2699 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2700 }
2701
2702 /**
2703 * @tc.number: SUB_Driver_Audio_Flush_0700
2704 * @tc.name: testCommonRenderFlush007
2705 * @tc.desc: Flushes data in the audio buffer.
2706 */
2707 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderFlush007, TestSize.Level2)
2708 {
2709 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2710 int32_t ret = render_->Flush(render_);
2711 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2712 render_->Resume(render_);
2713 for (int i = 0; i < 50; i++) {
2714 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, render_->Flush(render_));
2715 }
2716 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2717 }
2718
2719 /**
2720 * @tc.number: SUB_Driver_Audio_Flush_0800
2721 * @tc.name: testCommonRenderFlush008
2722 * @tc.desc: Flushes data in the audio buffer.
2723 */
2724 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderFlush008, TestSize.Level2)
2725 {
2726 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2727 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2728 int32_t ret = render_->Flush(render_);
2729 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2730 }
2731
2732 /**
2733 * @tc.number: SUB_Driver_Audio_Flush_0900
2734 * @tc.name: testCommonRenderFlush009
2735 * @tc.desc: Flushes data in the audio buffer.
2736 */
2737 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderFlush009, TestSize.Level2)
2738 {
2739 int32_t ret;
2740 EXPECT_EQ(HDF_SUCCESS, render_->Start(render_));
2741 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
2742 for (int i = 0; i < 50; i++) {
2743 ret = render_->Flush(render_);
2744 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2745 }
2746 }
2747
2748 /**
2749 * @tc.number: SUB_Driver_Audio_TurnStandbyMode_0100
2750 * @tc.name: testCommonRenderTurnStandbyMode001
2751 * @tc.desc: Sets or cancels the standby mode of the audio device.
2752 */
2753 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderTurnStandbyMode001, TestSize.Level2)
2754 {
2755 for (int i = 0; i < 50; i++) {
2756 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, render_->TurnStandbyMode(nullptr));
2757 }
2758 }
2759
2760 /**
2761 * @tc.number: SUB_Driver_Audio_TurnStandbyMode_0400
2762 * @tc.name: testCommonRenderTurnStandbyMode004
2763 * @tc.desc: Sets or cancels the standby mode of the audio device.
2764 */
2765 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderTurnStandbyMode004, TestSize.Level2)
2766 {
2767 int32_t ret = render_->Start(render_);
2768 EXPECT_EQ(HDF_SUCCESS, ret);
2769 ret = render_->Stop(render_);
2770 EXPECT_EQ(HDF_SUCCESS, ret);
2771 ret = render_->TurnStandbyMode(render_);
2772 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2773 EXPECT_EQ(HDF_FAILURE, ret);
2774 #else
2775 EXPECT_EQ(HDF_SUCCESS, ret);
2776 #endif
2777 }
2778
2779 /**
2780 * @tc.number: SUB_Driver_Audio_TurnStandbyMode_0500
2781 * @tc.name: testCommonRenderTurnStandbyMode005
2782 * @tc.desc: Sets or cancels the standby mode of the audio device.
2783 */
2784 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderTurnStandbyMode005, TestSize.Level2)
2785 {
2786 int32_t ret = render_->Start(render_);
2787 EXPECT_EQ(HDF_SUCCESS, ret);
2788 ret = render_->Stop(render_);
2789 EXPECT_EQ(HDF_SUCCESS, ret);
2790 for (int i = 0; i < 50; i++) {
2791 ret = render_->TurnStandbyMode(render_);
2792 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2793 EXPECT_EQ(HDF_FAILURE, ret);
2794 #else
2795 EXPECT_EQ(HDF_SUCCESS, ret);
2796 #endif
2797 }
2798 }
2799
2800 /**
2801 * @tc.number: SUB_Driver_Audio_IsSupportsPauseAndResume_0100
2802 * @tc.name: testCommonRenderIsSupportsPauseAndResume001
2803 * @tc.desc: Query whether the vendor support pause and resume.
2804 */
2805 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderIsSupportsPauseAndResume001, TestSize.Level2)
2806 {
2807 int32_t ret;
2808 bool supportPause = false;
2809 bool supportResume = false;
2810 for (int i = 0; i < 50; i++) {
2811 ret = render_->IsSupportsPauseAndResume(nullptr, &supportPause, &supportResume);
2812 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
2813
2814 ret = render_->IsSupportsPauseAndResume(render_, nullptr, &supportResume);
2815 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2816 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2817 #else
2818 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2819 #endif
2820
2821 ret = render_->IsSupportsPauseAndResume(render_, &supportPause, nullptr);
2822 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2823 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2824 #else
2825 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2826 #endif
2827 }
2828 }
2829
2830 /**
2831 * @tc.number: SUB_Driver_Audio_IsSupportsPauseAndResume_0200
2832 * @tc.name: testCommonRenderIsSupportsPauseAndResume002
2833 * @tc.desc: Query whether the vendor support pause and resume.
2834 */
2835 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderIsSupportsPauseAndResume002, TestSize.Level2)
2836 {
2837 int32_t ret;
2838 bool supportPause = false;
2839 bool supportResume = false;
2840 for (int i = 0; i < 50; i++) {
2841 ret = render_->IsSupportsPauseAndResume(render_, &supportPause, &supportResume);
2842 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2843 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2844 #else
2845 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2846 #endif
2847 }
2848 }
2849
2850 /**
2851 * @tc.number: SUB_Driver_Audio_IsSupportsPauseAndResume_0300
2852 * @tc.name: testCommonRenderIsSupportsPauseAndResume003
2853 * @tc.desc: Query whether the vendor support pause and resume.
2854 */
2855 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderIsSupportsPauseAndResume003, TestSize.Level2)
2856 {
2857 int32_t ret;
2858 bool supportPause = false;
2859 bool supportResume = true;
2860 for (int i = 0; i < 50; i++) {
2861 ret = render_->IsSupportsPauseAndResume(render_, &supportPause, &supportResume);
2862 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2863 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2864 #else
2865 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2866 #endif
2867 }
2868 }
2869
2870 /**
2871 * @tc.number: SUB_Driver_Audio_IsSupportsPauseAndResume_0400
2872 * @tc.name: testCommonRenderIsSupportsPauseAndResume004
2873 * @tc.desc: Query whether the vendor support pause and resume.
2874 */
2875 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderIsSupportsPauseAndResume004, TestSize.Level2)
2876 {
2877 bool supportPause = true;
2878 bool supportResume = false;
2879 int32_t ret = render_->IsSupportsPauseAndResume(render_, &supportPause, &supportResume);
2880 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2881 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2882 #else
2883 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2884 #endif
2885 }
2886
2887 /**
2888 * @tc.number: SUB_Driver_Audio_IsSupportsPauseAndResume_0500
2889 * @tc.name: testCommonRenderIsSupportsPauseAndResume005
2890 * @tc.desc: Query whether the vendor support pause and resume.
2891 */
2892 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderIsSupportsPauseAndResume005, TestSize.Level2)
2893 {
2894 int32_t ret;
2895 bool supportPause = true;
2896 bool supportResume = false;
2897 for (int i = 0; i < 50; i++) {
2898 ret = render_->IsSupportsPauseAndResume(render_, &supportPause, &supportResume);
2899 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2900 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2901 #else
2902 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2903 #endif
2904 }
2905 }
2906
2907 /**
2908 * @tc.number: SUB_Driver_Audio_IsSupportsPauseAndResume_0600
2909 * @tc.name: testCommonRenderIsSupportsPauseAndResume006
2910 * @tc.desc: Query whether the vendor support pause and resume.
2911 */
2912 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderIsSupportsPauseAndResume006, TestSize.Level2)
2913 {
2914 bool supportPause = true;
2915 bool supportResume = true;
2916 int32_t ret = render_->IsSupportsPauseAndResume(render_, &supportPause, &supportResume);
2917 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2918 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2919 #else
2920 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2921 #endif
2922 }
2923
2924 /**
2925 * @tc.number: SUB_Driver_Audio_IsSupportsPauseAndResume_0700
2926 * @tc.name: testCommonRenderIsSupportsPauseAndResume007
2927 * @tc.desc: Query whether the vendor support pause and resume.
2928 */
2929 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderIsSupportsPauseAndResume007, TestSize.Level2)
2930 {
2931 int32_t ret;
2932 bool supportPause = true;
2933 bool supportResume = true;
2934 for (int i = 0; i < 50; i++) {
2935 ret = render_->IsSupportsPauseAndResume(render_, &supportPause, &supportResume);
2936 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2937 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2938 #else
2939 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
2940 #endif
2941 }
2942 }
2943
2944 /**
2945 * @tc.number: SUB_Driver_Audio_IsSupportsPauseAndResume_0800
2946 * @tc.name: testCommonRenderIsSupportsPauseAndResume008
2947 * @tc.desc: Query whether the vendor support pause and resume.
2948 */
2949 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderIsSupportsPauseAndResume008, TestSize.Level2)
2950 {
2951 bool supportPause = true;
2952 bool supportResume = false;
2953 int32_t ret = render_->IsSupportsPauseAndResume(nullptr, &supportPause, &supportResume);
2954 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
2955 }
2956
2957 /**
2958 * @tc.number: SUB_Driver_Audio_IsSupportsPauseAndResume_0900
2959 * @tc.name: testCommonRenderIsSupportsPauseAndResume009
2960 * @tc.desc: Query whether the vendor support pause and resume.
2961 */
2962 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderIsSupportsPauseAndResume009, TestSize.Level2)
2963 {
2964 bool supportPause = false;
2965 bool supportResume = true;
2966 int32_t ret = render_->IsSupportsPauseAndResume(nullptr, &supportPause, &supportResume);
2967 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
2968 }
2969
2970 /**
2971 * @tc.number: SUB_Driver_Audio_IsSupportsPauseAndResume_1000
2972 * @tc.name: testCommonRenderIsSupportsPauseAndResume010
2973 * @tc.desc: Query whether the vendor support pause and resume.
2974 */
2975 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderIsSupportsPauseAndResume010, TestSize.Level2)
2976 {
2977 int32_t ret;
2978 bool supportPause = false;
2979 bool supportResume = true;
2980 for (int i = 0; i < 50; i++) {
2981 ret = render_->IsSupportsPauseAndResume(nullptr, &supportPause, &supportResume);
2982 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
2983 }
2984 }
2985
2986 /**
2987 * @tc.number: SUB_Driver_Audio_IsSupportsPauseAndResume_1100
2988 * @tc.name: testCommonRenderIsSupportsPauseAndResume011
2989 * @tc.desc: Query whether the vendor support pause and resume.
2990 */
2991 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderIsSupportsPauseAndResume011, TestSize.Level2)
2992 {
2993 bool supportPause = true;
2994 bool supportResume = true;
2995 int32_t ret = render_->IsSupportsPauseAndResume(nullptr, &supportPause, &supportResume);
2996 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
2997 }
2998
2999 /**
3000 * @tc.number: SUB_Driver_Audio_IsSupportsPauseAndResume_1200
3001 * @tc.name: testCommonRenderIsSupportsPauseAndResume012
3002 * @tc.desc: Query whether the vendor support pause and resume.
3003 */
3004 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderIsSupportsPauseAndResume012, TestSize.Level2)
3005 {
3006 int32_t ret;
3007 bool supportPause = true;
3008 bool supportResume = true;
3009 for (int i = 0; i < 50; i++) {
3010 ret = render_->IsSupportsPauseAndResume(nullptr, &supportPause, &supportResume);
3011 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
3012 }
3013 }
3014
3015 /**
3016 * @tc.number: SUB_Driver_Audio_IsSupportsPauseAndResume_1300
3017 * @tc.name: testCommonRenderIsSupportsPauseAndResume013
3018 * @tc.desc: Query whether the vendor support pause and resume.
3019 */
3020 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderIsSupportsPauseAndResume013, TestSize.Level2)
3021 {
3022 int32_t ret;
3023 bool supportPause = true;
3024 bool supportResume = false;
3025 for (int i = 0; i < 50; i++) {
3026 ret = render_->IsSupportsPauseAndResume(nullptr, &supportPause, &supportResume);
3027 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
3028 }
3029 }
3030
3031 /**
3032 * @tc.number: SUB_Driver_Audio_TurnStandbyMode_0200
3033 * @tc.name: testCommonRenderTurnStandbyMode002
3034 * @tc.desc: Sets or cancels the standby mode of the audio device.
3035 */
3036 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderTurnStandbyMode002, TestSize.Level1)
3037 {
3038 int32_t ret = render_->Start(render_);
3039 EXPECT_EQ(HDF_SUCCESS, ret);
3040
3041 ret = render_->Pause(render_);
3042 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3043 EXPECT_EQ(HDF_SUCCESS, ret);
3044 #else
3045 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
3046 #endif
3047
3048 ret = render_->TurnStandbyMode(render_);
3049 EXPECT_EQ(HDF_SUCCESS, ret);
3050
3051 ret = render_->Stop(render_);
3052 }
3053
3054 /**
3055 * @tc.number: SUB_Driver_Audio_TurnStandbyMode_0300
3056 * @tc.name: testCommonRenderTurnStandbyMode003
3057 * @tc.desc: Sets or cancels the standby mode of the audio device.
3058 */
3059 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderTurnStandbyMode003, TestSize.Level1)
3060 {
3061 int32_t ret = render_->Start(render_);
3062 EXPECT_EQ(HDF_SUCCESS, ret);
3063
3064 render_->Flush(render_);
3065
3066 ret = render_->TurnStandbyMode(render_);
3067 EXPECT_EQ(HDF_SUCCESS, ret);
3068
3069 ret = render_->Stop(render_);
3070 }
3071
3072 /**
3073 * @tc.number: SUB_Driver_Audio_TurnStandbyMode_0600
3074 * @tc.name: testCommonRenderTurnStandbyMode006
3075 * @tc.desc: Sets or cancels the standby mode of the audio device.
3076 */
3077 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderTurnStandbyMode006, TestSize.Level1)
3078 {
3079 int32_t ret = render_->Start(render_);
3080 EXPECT_EQ(HDF_SUCCESS, ret);
3081 ret = render_->Pause(render_);
3082 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3083 EXPECT_EQ(HDF_SUCCESS, ret);
3084 #else
3085 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
3086 #endif
3087 ret = render_->Resume(render_);
3088 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3089 EXPECT_EQ(HDF_SUCCESS, ret);
3090 #else
3091 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
3092 #endif
3093 ret = render_->TurnStandbyMode(render_);
3094 EXPECT_EQ(HDF_SUCCESS, ret);
3095 ret = render_->Stop(render_);
3096 }
3097
3098 /**
3099 * @tc.number : SUB_Driver_Audio_SetRenderSpeed_0300
3100 * @tc.name : testCommonRenderSetRenderSpeed001
3101 * @tc.desc : Reliability of function(SetRenderSpeed)
3102 */
3103 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetRenderSpeed001, Function | MediumTest | Level2)
3104 {
3105 float speed = 2.0;
3106 int i, ret = 0;
3107 for (i = 0; i < 1000; i++) {
3108 ret = render_->SetRenderSpeed(render_, speed);
3109 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3110 }
3111 }
3112
3113 /**
3114 * @tc.number : SUB_Driver_Audio_GetRenderSpeed_0300
3115 * @tc.name : testCommonRenderGetRenderSpeed001
3116 * @tc.desc : Reliability of function(GetRenderSpeed)
3117 */
3118 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetRenderSpeed001, Function | MediumTest | Level1)
3119 {
3120 float speed = 0.0;
3121 int32_t ret = 0;
3122 int i = 0;
3123 ASSERT_EQ(HDF_SUCCESS, render_->Start(render_));
3124 for (i = 0; i < 1000; i++) {
3125 ret = render_->GetRenderSpeed(render_, &speed);
3126 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3127 }
3128 EXPECT_EQ(HDF_SUCCESS, render_->Stop(render_));
3129 }
3130
3131 /**
3132 * @tc.number : SUB_Driver_Audio_SetChannelMode_0300
3133 * @tc.name : testCommonRenderSetChannelMode001
3134 * @tc.desc : Reliability of function(SetChannelMode)
3135 */
3136 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetChannelMode001, Function | MediumTest | Level1)
3137 {
3138 AudioChannelMode mode = AUDIO_CHANNEL_NORMAL;
3139 int i = 0;
3140 int32_t ret = 0;
3141 for (i = 0; i < 1000; i++) {
3142 ret = render_->SetChannelMode(render_, mode);
3143 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3144 ASSERT_EQ(ret, HDF_SUCCESS);
3145 #else
3146 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3147 #endif
3148 }
3149 }
3150
3151 /**
3152 * @tc.number : SUB_Driver_Audio_SetChannelMode_0400
3153 * @tc.name : testCommonRenderSetChannelMode002
3154 * @tc.desc : Test input param
3155 */
3156 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetChannelMode002, Function | MediumTest | Level1)
3157 {
3158 AudioChannelMode mode = AUDIO_CHANNEL_BOTH_LEFT;
3159 int32_t ret = render_->SetChannelMode(render_, mode);
3160 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3161 EXPECT_EQ(ret, HDF_SUCCESS);
3162 #else
3163 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3164 #endif
3165 }
3166
3167 /**
3168 * @tc.number : SUB_Driver_Audio_SetChannelMode_0500
3169 * @tc.name : testCommonRenderSetChannelMode003
3170 * @tc.desc : Test input param
3171 */
3172 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetChannelMode003, Function | MediumTest | Level1)
3173 {
3174 AudioChannelMode mode = AUDIO_CHANNEL_BOTH_RIGHT;
3175 int32_t ret = render_->SetChannelMode(render_, mode);
3176 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3177 EXPECT_EQ(ret, HDF_SUCCESS);
3178 #else
3179 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3180 #endif
3181 }
3182
3183 /**
3184 * @tc.number : SUB_Driver_Audio_GetChannelMode_0300
3185 * @tc.name : testCommonRenderGetChannelMode001
3186 * @tc.desc : Reliability of function(GetChannelMode)
3187 */
3188 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetChannelMode001, Function | MediumTest | Level1)
3189 {
3190 enum AudioChannelMode channelMode = AUDIO_CHANNEL_NORMAL;
3191 int i = 0;
3192 int32_t ret = 0;
3193 for (i = 0; i < 1000; i++) {
3194 ret = render_->GetChannelMode(render_, &channelMode);
3195 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3196 ASSERT_EQ(ret, HDF_SUCCESS);
3197 #else
3198 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3199 #endif
3200 }
3201 }
3202
3203 /**
3204 * @tc.number : SUB_Driver_Audio_RegCallback_0300
3205 * @tc.name : testCommonRenderRegCallback001
3206 * @tc.desc : Reliability of function(RegCallback)
3207 */
3208 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRegCallback001, Function | MediumTest | Level2)
3209 {
3210 int i = 0;
3211 int32_t ret = 0;
3212 int8_t cookie = 0;
3213 struct IAudioCallback audioCallback;
3214 audioCallback.RenderCallback = RenderCallbackTest;
3215 for (i = 0; i < 1000; i++) {
3216 ret = render_->RegCallback(render_, &audioCallback, cookie);
3217 #if defined ALSA_LIB_MODE || defined DISPLAY_COMMUNITY
3218 EXPECT_EQ(ret, HDF_SUCCESS);
3219 #else
3220 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3221 #endif
3222 }
3223 }
3224
3225 /**
3226 * @tc.number : SUB_Driver_Audio_RegCallback_0400
3227 * @tc.name : testCommonRenderRegCallback002
3228 * @tc.desc : Test input param
3229 */
3230 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRegCallback002, Function | MediumTest | Level2)
3231 {
3232 int32_t ret = 0;
3233 int8_t cookie = 127;
3234 struct IAudioCallback audioCallback;
3235 audioCallback.RenderCallback = RenderCallbackTest;
3236 ret = render_->RegCallback(render_, &audioCallback, cookie);
3237 #if defined ALSA_LIB_MODE || defined DISPLAY_COMMUNITY
3238 EXPECT_EQ(ret, HDF_SUCCESS);
3239 #else
3240 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3241 #endif
3242 }
3243
3244 /**
3245 * @tc.number : SUB_Driver_Audio_RegCallback_0500
3246 * @tc.name : testCommonRenderRegCallback003
3247 * @tc.desc : Test input param
3248 */
3249 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderRegCallback003, Function | MediumTest | Level2)
3250 {
3251 int32_t ret = 0;
3252 int8_t cookie = -1;
3253 struct IAudioCallback audioCallback;
3254 audioCallback.RenderCallback = RenderCallbackTest;
3255 ret = render_->RegCallback(render_, &audioCallback, cookie);
3256 #if defined ALSA_LIB_MODE || defined DISPLAY_COMMUNITY
3257 EXPECT_EQ(ret, HDF_SUCCESS);
3258 #else
3259 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3260 #endif
3261 }
3262
3263 /**
3264 * @tc.number SUB_Driver_Audio_SetMutey_0300
3265 * @tc.name testCommonRenderSetMute001
3266 * @tc.desc Reliability of function(SetMute)
3267 */
3268 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetMute001, Function | MediumTest | Level1)
3269 {
3270 bool mute = false;
3271 int32_t ret = 0;
3272 int i = 0;
3273 for (i = 0; i < 1000; i++) {
3274 ret = render_->SetMute(render_, mute);
3275 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3276 ASSERT_EQ(ret, HDF_SUCCESS);
3277 #else
3278 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3279 #endif
3280 }
3281 }
3282
3283 /**
3284 * @tc.number SUB_Driver_Audio_GetMute_0300
3285 * @tc.name testCommonRenderGetMute001
3286 * @tc.desc Reliability of function(GetMute)
3287 */
3288 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetMute001, Function | MediumTest | Level1)
3289 {
3290 bool mute = false;
3291 int32_t ret = 0;
3292 int i = 0;
3293 for (i = 0; i < 1000; i++) {
3294 ret = render_->GetMute(render_, &mute);
3295 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3296 ASSERT_EQ(ret, HDF_SUCCESS);
3297 #else
3298 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3299 #endif
3300 }
3301 }
3302
3303 /**
3304 * @tc.number SUB_Driver_Audio_SetVolume_0300
3305 * @tc.name testCommonRenderSetVolume001
3306 * @tc.desc Reliability of function(SetVolume)
3307 */
3308 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetVolume001, Function | MediumTest | Level1)
3309 {
3310 float volume = 0.2;
3311 int32_t ret = 0;
3312 int i = 0;
3313 for (i = 0; i < 1000; i++) {
3314 ret = render_->SetVolume(render_, volume);
3315 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3316 ASSERT_EQ(ret, HDF_SUCCESS);
3317 #else
3318 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3319 #endif
3320 }
3321 }
3322
3323 /**
3324 * @tc.number SUB_Driver_Audio_GetVolume_0300
3325 * @tc.name testCommonRenderGetVolume001
3326 * @tc.desc Reliability of function(GetVolume)
3327 */
3328 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetVolume001, Function | MediumTest | Level1)
3329 {
3330 float volume = 0.2;
3331 int32_t ret = 0;
3332 int i = 0;
3333 for (i = 0; i < 1000; i++) {
3334 ret = render_->GetVolume(render_, &volume);
3335 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3336 ASSERT_EQ(ret, HDF_SUCCESS);
3337 #else
3338 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3339 #endif
3340 }
3341 }
3342
3343 /**
3344 * @tc.number SUB_Driver_Audio_GetGainThreshold_0300
3345 * @tc.name testCommonRenderGetGainThreshold001
3346 * @tc.desc Reliability of function(GetGainThreshold)
3347 */
3348 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetGainThreshold001, Function | MediumTest | Level1)
3349 {
3350 int32_t ret = 0;
3351 float min = 0.0;
3352 float max = 1.0;
3353 int i = 0;
3354 for (i = 0; i < 1000; i++) {
3355 ret = render_->GetGainThreshold(render_, &min, &max);
3356 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3357 ASSERT_EQ(ret, HDF_SUCCESS);
3358 #else
3359 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3360 #endif
3361 }
3362 }
3363
3364 /**
3365 * @tc.number SUB_Driver_Audio_GetGain_0300
3366 * @tc.name testCommonRenderGetGain001
3367 * @tc.desc Reliability of function(GetGain)
3368 */
3369 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetGain001, Function | MediumTest | Level1)
3370 {
3371 int32_t ret = 0;
3372 float gain = 0.1;
3373 int i = 0;
3374 for (i = 0; i < 1000; i++) {
3375 ret = render_->GetGain(render_, &gain);
3376 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3377 ASSERT_EQ(ret, HDF_SUCCESS);
3378 #else
3379 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3380 #endif
3381 }
3382 }
3383
3384 /**
3385 * @tc.number SUB_Driver_Audio_SetGainn_0300
3386 * @tc.name testCommonRenderSetGain001
3387 * @tc.desc Reliability of function(SetGain)
3388 */
3389 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderSetGain001, Function | MediumTest | Level1)
3390 {
3391 int32_t ret = 0;
3392 float gain = 0.1;
3393 int i = 0;
3394 for (i = 0; i < 1000; i++) {
3395 ret = render_->SetGain(render_, gain);
3396 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3397 ASSERT_EQ(ret, HDF_SUCCESS);
3398 #else
3399 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3400 #endif
3401 }
3402 }
3403
3404 /**
3405 * @tc.number SUB_Driver_Audio_RenderGetExtraParams_0400
3406 * @tc.name testCommonRenderGetExtraParams001
3407 * @tc.desc Reliability of function(GetExtraParams)
3408 */
3409 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetExtraParams001, Function | MediumTest | Level1)
3410 {
3411 int i = 0;
3412 int32_t ret = 0;
3413 char keyValueList[AUDIO_RENDER_BUF_TEST];
3414 uint32_t keyValueListLen = BUFFER_LENTH;
3415 for (i = 0; i < 1000; i++) {
3416 ret = render_->GetExtraParams(render_, keyValueList, keyValueListLen);
3417 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3418 ASSERT_EQ(ret, HDF_SUCCESS);
3419 #else
3420 ASSERT_EQ(ret, HDF_ERR_INVALID_PARAM);
3421 #endif
3422 }
3423 }
3424
3425 /**
3426 * @tc.number SUB_Driver_Audio_GetFrameBufferSize_0100
3427 * @tc.name testCommonRenderGetFrameBufferSize001
3428 * @tc.desc Reliability of function(GetFrameBufferSize)
3429 */
3430 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetFrameBufferSize001, TestSize.Level2)
3431 {
3432 uint64_t bufferSize = 0;
3433 int32_t ret = render_->GetFrameBufferSize(nullptr, &bufferSize);
3434 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
3435
3436 ret = render_->GetFrameBufferSize(render_, nullptr);
3437 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3438 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3439 #else
3440 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
3441 #endif
3442 }
3443
3444 /**
3445 * @tc.number SUB_Driver_Audio_GetFrameBufferSize_0200
3446 * @tc.name testCommonRenderGetFrameBufferSize002
3447 * @tc.desc Reliability of function(GetFrameBufferSize)
3448 */
3449 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetFrameBufferSize002, TestSize.Level2)
3450 {
3451 uint64_t bufferSize = 256;
3452 int32_t ret = render_->GetFrameBufferSize(nullptr, &bufferSize);
3453 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
3454
3455 ret = render_->GetFrameBufferSize(render_, nullptr);
3456 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3457 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3458 #else
3459 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
3460 #endif
3461 }
3462
3463 /**
3464 * @tc.number SUB_Driver_Audio_GetFrameBufferSize_0300
3465 * @tc.name testCommonRenderGetFrameBufferSize003
3466 * @tc.desc Reliability of function(GetFrameBufferSize)
3467 */
3468 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetFrameBufferSize003, TestSize.Level2)
3469 {
3470 uint64_t bufferSize = 266;
3471 int32_t ret = render_->GetFrameBufferSize(nullptr, &bufferSize);
3472 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
3473
3474 ret = render_->GetFrameBufferSize(render_, nullptr);
3475 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3476 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3477 #else
3478 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
3479 #endif
3480 }
3481
3482 /**
3483 * @tc.number SUB_Driver_Audio_GetFrameBufferSize_0400
3484 * @tc.name testCommonRenderGetFrameBufferSize004
3485 * @tc.desc Reliability of function(GetFrameBufferSize)
3486 */
3487 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetFrameBufferSize004, TestSize.Level2)
3488 {
3489 uint64_t bufferSize = 1600;
3490 int32_t ret = render_->GetFrameBufferSize(nullptr, &bufferSize);
3491 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
3492
3493 ret = render_->GetFrameBufferSize(render_, nullptr);
3494 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3495 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3496 #else
3497 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
3498 #endif
3499 }
3500
3501 /**
3502 * @tc.number SUB_Driver_Audio_GetFrameBufferSize_0500
3503 * @tc.name testCommonRenderGetFrameBufferSize005
3504 * @tc.desc Reliability of function(GetFrameBufferSize)
3505 */
3506 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetFrameBufferSize005, TestSize.Level2)
3507 {
3508 uint64_t bufferSize = 300;
3509 int32_t ret = render_->GetFrameBufferSize(nullptr, &bufferSize);
3510 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
3511
3512 ret = render_->GetFrameBufferSize(render_, nullptr);
3513 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3514 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3515 #else
3516 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
3517 #endif
3518 }
3519
3520 /**
3521 * @tc.number SUB_Driver_Audio_GetFrameBufferSize_0600
3522 * @tc.name testCommonRenderGetFrameBufferSize006
3523 * @tc.desc Reliability of function(GetFrameBufferSize)
3524 */
3525 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetFrameBufferSize006, TestSize.Level2)
3526 {
3527 uint64_t bufferSize = 4294967295;
3528 int32_t ret = render_->GetFrameBufferSize(nullptr, &bufferSize);
3529 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
3530
3531 ret = render_->GetFrameBufferSize(render_, nullptr);
3532 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3533 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3534 #else
3535 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
3536 #endif
3537 }
3538
3539 /**
3540 * @tc.number SUB_Driver_Audio_GetFrameBufferSize_0700
3541 * @tc.name testCommonRenderGetFrameBufferSize007
3542 * @tc.desc Reliability of function(GetFrameBufferSize)
3543 */
3544 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetFrameBufferSize007, TestSize.Level2)
3545 {
3546 uint64_t bufferSize = 429496729500;
3547 int32_t ret = render_->GetFrameBufferSize(nullptr, &bufferSize);
3548 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
3549
3550 ret = render_->GetFrameBufferSize(render_, nullptr);
3551 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3552 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3553 #else
3554 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
3555 #endif
3556 }
3557
3558 /**
3559 * @tc.number SUB_Driver_Audio_GetFrameBufferSize_0800
3560 * @tc.name testCommonRenderGetFrameBufferSize008
3561 * @tc.desc Reliability of function(GetFrameBufferSize)
3562 */
3563 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetFrameBufferSize008, TestSize.Level2)
3564 {
3565 int32_t i;
3566 uint64_t bufferSize = 429496;
3567 int32_t ret;
3568 for (i = 0; i < 50; i++) {
3569 ret = render_->GetFrameBufferSize(nullptr, &bufferSize);
3570 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
3571 }
3572 ret = render_->GetFrameBufferSize(render_, nullptr);
3573 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3574 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3575 #else
3576 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
3577 #endif
3578 }
3579
3580 /**
3581 * @tc.number SUB_Driver_Audio_GetFrameBufferSize_0900
3582 * @tc.name testCommonRenderGetFrameBufferSize009
3583 * @tc.desc Reliability of function(GetFrameBufferSize)
3584 */
3585 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetFrameBufferSize009, TestSize.Level2)
3586 {
3587 int32_t ret = render_->GetFrameBufferSize(nullptr, nullptr);
3588 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
3589
3590 ret = render_->GetFrameBufferSize(render_, nullptr);
3591 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3592 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3593 #else
3594 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
3595 #endif
3596 }
3597
3598 /**
3599 * @tc.number SUB_Driver_Audio_GetFrameBufferSize_1000
3600 * @tc.name testCommonRenderGetFrameBufferSize010
3601 * @tc.desc Reliability of function(GetFrameBufferSize)
3602 */
3603 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetFrameBufferSize010, TestSize.Level2)
3604 {
3605 uint64_t bufferSize = 0;
3606 int32_t ret = render_->GetFrameBufferSize(nullptr, &bufferSize);
3607 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
3608
3609 ret = render_->GetFrameBufferSize(nullptr, nullptr);
3610 ASSERT_EQ(ret, HDF_ERR_INVALID_OBJECT);
3611 }
3612
3613 /**
3614 * @tc.number SUB_Driver_Audio_GetFrameBufferSize_1100
3615 * @tc.name testCommonRenderGetFrameBufferSize011
3616 * @tc.desc Reliability of function(GetFrameBufferSize)
3617 */
3618 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetFrameBufferSize011, TestSize.Level2)
3619 {
3620 uint64_t bufferSize = 1000;
3621 int32_t ret = render_->GetFrameBufferSize(render_, &bufferSize);
3622 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3623 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3624 #else
3625 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
3626 #endif
3627 }
3628
3629 /**
3630 * @tc.number SUB_Driver_Audio_GetFrameBufferSize_1200
3631 * @tc.name testCommonRenderGetFrameBufferSize012
3632 * @tc.desc Reliability of function(GetFrameBufferSize)
3633 */
3634 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetFrameBufferSize012, TestSize.Level2)
3635 {
3636 int32_t i;
3637 uint64_t bufferSize = 8000;
3638 int32_t ret;
3639 for (i = 0; i < 100; i++) {
3640 ret = render_->GetFrameBufferSize(render_, &bufferSize);
3641 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3642 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3643 #else
3644 ASSERT_EQ(ret, HDF_ERR_INVALID_PARAM);
3645 #endif
3646 }
3647 }
3648
3649 /**
3650 * @tc.number SUB_Driver_Audio_GetFrameBufferSize_1300
3651 * @tc.name testCommonRenderGetFrameBufferSize013
3652 * @tc.desc Reliability of function(GetFrameBufferSize)
3653 */
3654 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderGetFrameBufferSize013, TestSize.Level2)
3655 {
3656 int32_t ret = render_->GetFrameBufferSize(render_, nullptr);
3657 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3658 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3659 #else
3660 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
3661 #endif
3662 }
3663
3664 /**
3665 * @tc.number SUB_Driver_Audio_Stop_0700
3666 * @tc.name testCommonRenderStop007
3667 * @tc.desc Reliability of function(Stop)
3668 */
3669 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderStop007, TestSize.Level1)
3670 {
3671 int32_t ret = render_->Start(render_);
3672 EXPECT_EQ(HDF_SUCCESS, ret);
3673 ret = render_->TurnStandbyMode(render_);
3674 EXPECT_EQ(HDF_SUCCESS, ret);
3675 ret = render_->Stop(render_);
3676 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3677 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3678 #else
3679 ASSERT_EQ(ret, HDF_SUCCESS);
3680 #endif
3681 int32_t i;
3682 for (i = 0; i < 50; i++) {
3683 ret = render_->Start(render_);
3684 EXPECT_EQ(HDF_SUCCESS, ret);
3685 ret = render_->Stop(render_);
3686 EXPECT_EQ(HDF_SUCCESS, ret);
3687 }
3688 }
3689
3690 /**
3691 * @tc.number: SUB_Driver_Audio_AudioDevDump_0600
3692 * @tc.name: testCommonRenderAudioDevDump006
3693 * @tc.desc: Dumps information about the audio device.
3694 */
3695 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump006, TestSize.Level1)
3696 {
3697 int32_t range = 1;
3698 char pathBuf[] = "/data/local/tmp/RenderDump.log";
3699
3700 FILE *file = fopen(pathBuf, "wb+");
3701 ASSERT_NE(nullptr, file);
3702 int fd = fileno(file);
3703 if (fd == -1) {
3704 fclose(file);
3705 ASSERT_NE(fd, -1);
3706 }
3707
3708 int32_t ret = render_->AudioDevDump(render_, range, fd);
3709 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3710 ASSERT_EQ(ret, HDF_SUCCESS);
3711 #else
3712 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3713 #endif
3714 fclose(file);
3715 }
3716
3717 /**
3718 * @tc.number: SUB_Driver_Audio_AudioDevDump_0700
3719 * @tc.name: testCommonRenderAudioDevDump007
3720 * @tc.desc: Dumps information about the audio device.
3721 */
3722 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump007, TestSize.Level1)
3723 {
3724 int32_t range = 2;
3725 char pathBuf[] = "/data/local/tmp/RenderDump.log";
3726
3727 FILE *file = fopen(pathBuf, "wb+");
3728 ASSERT_NE(nullptr, file);
3729 int fd = fileno(file);
3730 if (fd == -1) {
3731 fclose(file);
3732 ASSERT_NE(fd, -1);
3733 }
3734
3735 int32_t ret = render_->AudioDevDump(render_, range, fd);
3736
3737 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3738 ASSERT_EQ(ret, HDF_SUCCESS);
3739 #else
3740 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3741 #endif
3742 fclose(file);
3743 }
3744
3745 /**
3746 * @tc.number: SUB_Driver_Audio_AudioDevDump_0800
3747 * @tc.name: testCommonRenderAudioDevDump008
3748 * @tc.desc: Dumps information about the audio device.
3749 */
3750 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump008, TestSize.Level1)
3751 {
3752 int32_t range = 3;
3753 char pathBuf[] = "/data/local/tmp/RenderDump.log";
3754
3755 FILE *file = fopen(pathBuf, "wb+");
3756 ASSERT_NE(nullptr, file);
3757 int fd = fileno(file);
3758 if (fd == -1) {
3759 fclose(file);
3760 ASSERT_NE(fd, -1);
3761 }
3762
3763 int32_t ret = render_->AudioDevDump(render_, range, fd);
3764
3765 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3766 ASSERT_EQ(ret, HDF_SUCCESS);
3767 #else
3768 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3769 #endif
3770 fclose(file);
3771 }
3772
3773 /**
3774 * @tc.number: SUB_Driver_Audio_AudioDevDump_0900
3775 * @tc.name: testCommonRenderAudioDevDump009
3776 * @tc.desc: Dumps information about the audio device.
3777 */
3778 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump009, TestSize.Level1)
3779 {
3780 int32_t range = 5;
3781 char pathBuf[] = "/data/local/tmp/RenderDump.log";
3782
3783 FILE *file = fopen(pathBuf, "wb+");
3784 ASSERT_NE(nullptr, file);
3785 int fd = fileno(file);
3786 if (fd == -1) {
3787 fclose(file);
3788 ASSERT_NE(fd, -1);
3789 }
3790
3791 int32_t ret = render_->AudioDevDump(render_, range, fd);
3792
3793 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3794 ASSERT_EQ(ret, HDF_SUCCESS);
3795 #else
3796 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3797 #endif
3798 fclose(file);
3799 }
3800
3801 /**
3802 * @tc.number: SUB_Driver_Audio_AudioDevDump_1000
3803 * @tc.name: testCommonRenderAudioDevDump010
3804 * @tc.desc: Dumps information about the audio device.
3805 */
3806 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump010, TestSize.Level1)
3807 {
3808 int32_t range = 6;
3809 char pathBuf[] = "/data/local/tmp/RenderDump.log";
3810
3811 FILE *file = fopen(pathBuf, "wb+");
3812 ASSERT_NE(nullptr, file);
3813 int fd = fileno(file);
3814 if (fd == -1) {
3815 fclose(file);
3816 ASSERT_NE(fd, -1);
3817 }
3818
3819 int32_t ret = render_->AudioDevDump(render_, range, fd);
3820
3821 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3822 ASSERT_EQ(ret, HDF_SUCCESS);
3823 #else
3824 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3825 #endif
3826 fclose(file);
3827 }
3828
3829 /**
3830 * @tc.number: SUB_Driver_Audio_AudioDevDump_1700
3831 * @tc.name: testCommonRenderAudioDevDump017
3832 * @tc.desc: Dumps information about the audio device.
3833 */
3834 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump017, TestSize.Level1)
3835 {
3836 int32_t range = 4;
3837 char pathBuf[] = "/data/local/tmp/RenderDump.log";
3838
3839 FILE *file = fopen(pathBuf, "wb+");
3840 ASSERT_NE(nullptr, file);
3841 int fd = 0;
3842
3843 int32_t ret = render_->AudioDevDump(render_, range, fd);
3844
3845 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3846 ASSERT_EQ(ret, HDF_SUCCESS);
3847 #else
3848 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3849 #endif
3850 fclose(file);
3851 }
3852
3853 /**
3854 * @tc.number: SUB_Driver_Audio_AudioDevDump_1800
3855 * @tc.name: testCommonRenderAudioDevDump018
3856 * @tc.desc: Dumps information about the audio device.
3857 */
3858 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump018, TestSize.Level1)
3859 {
3860 int32_t range = 4;
3861 char pathBuf[] = "/data/local/tmp/RenderDump.log";
3862
3863 FILE *file = fopen(pathBuf, "wb+");
3864 ASSERT_NE(nullptr, file);
3865 int fd = 1;
3866
3867 int32_t ret = render_->AudioDevDump(render_, range, fd);
3868
3869 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3870 ASSERT_EQ(ret, HDF_SUCCESS);
3871 #else
3872 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3873 #endif
3874 fclose(file);
3875 }
3876
3877 /**
3878 * @tc.number: SUB_Driver_Audio_AudioDevDump_1900
3879 * @tc.name: testCommonRenderAudioDevDump019
3880 * @tc.desc: Dumps information about the audio device.
3881 */
3882 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump019, TestSize.Level1)
3883 {
3884 int32_t range = 4;
3885 char pathBuf[] = "/data/local/tmp/RenderDump.log";
3886
3887 FILE *file = fopen(pathBuf, "wb+");
3888 ASSERT_NE(nullptr, file);
3889 int fd = 2;
3890
3891 int32_t ret = render_->AudioDevDump(render_, range, fd);
3892
3893 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3894 ASSERT_EQ(ret, HDF_SUCCESS);
3895 #else
3896 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3897 #endif
3898 fclose(file);
3899 }
3900
3901 /**
3902 * @tc.number: SUB_Driver_Audio_AudioDevDump_2000
3903 * @tc.name: testCommonRenderAudioDevDump020
3904 * @tc.desc: Dumps information about the audio device.
3905 */
3906 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump020, TestSize.Level1)
3907 {
3908 int32_t range = 4;
3909 char pathBuf[] = "/data/local/tmp/RenderDump.log";
3910
3911 FILE *file = fopen(pathBuf, "wb+");
3912 ASSERT_NE(nullptr, file);
3913 int fd = 3;
3914
3915 int32_t ret = render_->AudioDevDump(render_, range, fd);
3916
3917 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3918 ASSERT_EQ(ret, HDF_SUCCESS);
3919 #else
3920 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3921 #endif
3922 fclose(file);
3923 }
3924
3925 /**
3926 * @tc.number: SUB_Driver_Audio_AudioDevDump_2100
3927 * @tc.name: testCommonRenderAudioDevDump021
3928 * @tc.desc: Dumps information about the audio device.
3929 */
3930 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump021, TestSize.Level1)
3931 {
3932 int32_t range = 4;
3933 char pathBuf[] = "/data/local/tmp/RenderDump.log";
3934
3935 FILE *file = fopen(pathBuf, "wb+");
3936 ASSERT_NE(nullptr, file);
3937 int fd = 4;
3938
3939 int32_t ret = render_->AudioDevDump(render_, range, fd);
3940
3941 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3942 ASSERT_EQ(ret, HDF_SUCCESS);
3943 #else
3944 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3945 #endif
3946 fclose(file);
3947 }
3948
3949 /**
3950 * @tc.number: SUB_Driver_Audio_AudioDevDump_2200
3951 * @tc.name: testCommonRenderAudioDevDump022
3952 * @tc.desc: Dumps information about the audio device.
3953 */
3954 HWTEST_F(AudioUtRenderTestAdditional, testCommonRenderAudioDevDump022, TestSize.Level1)
3955 {
3956 int32_t range = 4;
3957 char pathBuf[] = "/data/local/tmp/RenderDump.log";
3958
3959 FILE *file = fopen(pathBuf, "wb+");
3960 ASSERT_NE(nullptr, file);
3961 int fd = -2;
3962
3963 int32_t ret = render_->AudioDevDump(render_, range, fd);
3964
3965 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
3966 ASSERT_EQ(ret, HDF_SUCCESS);
3967 #else
3968 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
3969 #endif
3970 fclose(file);
3971 }
3972 } // end of namespace