1 /*
2 * Copyright (c) 2023-2024 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 "v4_0/iaudio_capture.h"
18 #include "v4_0/iaudio_manager.h"
19 #include <climits>
20 #include <gtest/gtest.h>
21
22 using namespace std;
23 using namespace testing::ext;
24 namespace {
25 static const uint32_t MAX_AUDIO_ADAPTER_NUM = 5;
26 const int BUFFER_LENTH = 1024 * 16;
27 const int DEEP_BUFFER_CAPTURE_PERIOD_SIZE = 4 * 1024;
28 const int DEFAULT_BUFFER_SIZE = 16384;
29 const float HALF_OF_MAX_VOLUME = 0.5;
30 const int TEST_SAMPLE_RATE_MASK_48000 = 48000;
31 const int TEST_CHANNEL_COUNT = 2;
32 const int32_t MMAP_SUGGUEST_REQ_SIZE = 1920;
33
34 class AudioUtCaptureTestAdditional : public testing::Test {
35 public:
36 struct IAudioManager *manager_ = nullptr;
37 struct IAudioAdapter *adapter_ = nullptr;
38 struct IAudioCapture *capture_ = nullptr;
39 uint32_t captureId_ = 0;
40 struct AudioAdapterDescriptor *adapterDescs_ = nullptr;
41 virtual void SetUp();
42 virtual void TearDown();
43 uint64_t GetCaptureBufferSize();
44 void InitCaptureDevDesc(struct AudioDeviceDescriptor &devDesc);
45 void InitCaptureAttrs(struct AudioSampleAttributes &attrs);
46 void FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf);
47 void ReleaseAllAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen);
48 };
49
50 /* common method for capture ceate */
GetCaptureBufferSize()51 uint64_t AudioUtCaptureTestAdditional::GetCaptureBufferSize()
52 {
53 int32_t ret = HDF_SUCCESS;
54 uint64_t frameSize = 0;
55 uint64_t frameCount = 0;
56 uint64_t bufferSize = 0;
57
58 if (capture_ == nullptr) {
59 return DEFAULT_BUFFER_SIZE;
60 }
61
62 ret = capture_->GetFrameSize(capture_, &frameSize);
63 if (ret != HDF_SUCCESS) {
64 return DEFAULT_BUFFER_SIZE;
65 }
66
67 ret = capture_->GetFrameCount(capture_, &frameCount);
68 if (ret != HDF_SUCCESS) {
69 return DEFAULT_BUFFER_SIZE;
70 }
71
72 bufferSize = frameCount * frameSize;
73 if (bufferSize == 0) {
74 bufferSize = DEFAULT_BUFFER_SIZE;
75 }
76
77 return bufferSize;
78 }
79
InitCaptureDevDesc(struct AudioDeviceDescriptor &devDesc)80 void AudioUtCaptureTestAdditional::InitCaptureDevDesc(struct AudioDeviceDescriptor &devDesc)
81 {
82 devDesc.pins = (enum AudioPortPin)PIN_IN_MIC;
83 devDesc.desc = strdup("cardname");
84
85 ASSERT_NE(adapterDescs_, nullptr);
86 ASSERT_NE(adapterDescs_->ports, nullptr);
87 for (uint32_t index = 0; index < adapterDescs_->portsLen; index++) {
88 if (adapterDescs_->ports[index].dir == PORT_IN) {
89 devDesc.portId = adapterDescs_->ports[index].portId;
90 return;
91 }
92 }
93 }
94
InitCaptureAttrs(struct AudioSampleAttributes &attrs)95 void AudioUtCaptureTestAdditional::InitCaptureAttrs(struct AudioSampleAttributes &attrs)
96 {
97 attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
98 attrs.channelCount = TEST_CHANNEL_COUNT;
99 attrs.sampleRate = TEST_SAMPLE_RATE_MASK_48000;
100 attrs.interleaved = 0;
101 attrs.type = AUDIO_IN_MEDIA;
102 attrs.period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE;
103 attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT;
104 attrs.isBigEndian = false;
105 attrs.isSignedData = true;
106 attrs.startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount);
107 attrs.stopThreshold = INT_MAX;
108 attrs.silenceThreshold = BUFFER_LENTH;
109 }
110
FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)111 void AudioUtCaptureTestAdditional::FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)
112 {
113 if (dataBlock == nullptr) {
114 return;
115 }
116
117 if (dataBlock->adapterName != nullptr) {
118 OsalMemFree(dataBlock->adapterName);
119 dataBlock->adapterName = nullptr;
120 }
121
122 if (dataBlock->ports != nullptr) {
123 OsalMemFree(dataBlock->ports);
124 }
125
126 if (freeSelf) {
127 OsalMemFree(dataBlock);
128 }
129 }
130
ReleaseAllAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen)131 void AudioUtCaptureTestAdditional::ReleaseAllAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen)
132 {
133 if ((descsLen > 0) && (descs != nullptr) && ((*descs) != nullptr)) {
134 for (uint32_t i = 0; i < descsLen; i++) {
135 FreeAdapterElements(&(*descs)[i], false);
136 }
137 OsalMemFree(*descs);
138 *descs = nullptr;
139 }
140 }
141
SetUp()142 void AudioUtCaptureTestAdditional::SetUp()
143 {
144 uint32_t size = MAX_AUDIO_ADAPTER_NUM;
145 struct AudioDeviceDescriptor devDesc = {};
146 struct AudioSampleAttributes attrs = {};
147
148 manager_ = IAudioManagerGet(false);
149 ASSERT_NE(manager_, nullptr);
150
151 adapterDescs_ =
152 (struct AudioAdapterDescriptor *)OsalMemCalloc(sizeof(struct AudioAdapterDescriptor) * (MAX_AUDIO_ADAPTER_NUM));
153 ASSERT_NE(adapterDescs_, nullptr);
154
155 EXPECT_EQ(HDF_SUCCESS, manager_->GetAllAdapters(manager_, adapterDescs_, &size));
156 if (size > MAX_AUDIO_ADAPTER_NUM) {
157 ReleaseAllAdapterDescs(&adapterDescs_, MAX_AUDIO_ADAPTER_NUM);
158 ASSERT_LT(size, MAX_AUDIO_ADAPTER_NUM);
159 }
160
161 EXPECT_EQ(HDF_SUCCESS, manager_->LoadAdapter(manager_, &adapterDescs_[0], &adapter_));
162 if (adapter_ == nullptr) {
163 ReleaseAllAdapterDescs(&adapterDescs_, MAX_AUDIO_ADAPTER_NUM);
164 EXPECT_NE(adapter_, nullptr);
165 }
166
167 InitCaptureDevDesc(devDesc);
168 InitCaptureAttrs(attrs);
169 EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devDesc, &attrs, &capture_, &captureId_));
170 if (capture_ == nullptr) {
171 (void)manager_->UnloadAdapter(manager_, adapterDescs_[0].adapterName);
172 ReleaseAllAdapterDescs(&adapterDescs_, MAX_AUDIO_ADAPTER_NUM);
173 }
174 ASSERT_NE(capture_, nullptr);
175 }
176
TearDown()177 void AudioUtCaptureTestAdditional::TearDown()
178 {
179 ASSERT_NE(capture_, nullptr);
180 EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
181
182 ASSERT_NE(manager_, nullptr);
183 EXPECT_EQ(HDF_SUCCESS, manager_->UnloadAdapter(manager_, adapterDescs_[0].adapterName));
184 ReleaseAllAdapterDescs(&adapterDescs_, MAX_AUDIO_ADAPTER_NUM);
185
186 IAudioManagerRelease(manager_, false);
187 }
188 /**
189 * @tc.number : SUB_Driver_Audio_CaptureSetVolume_0400
190 * @tc.name : testAudioCaptureSetVolume001
191 * @tc.desc : test API SetVolume input parameter volume = 0.0
192 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetVolume001, TestSize.Level1)193 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetVolume001, TestSize.Level1)
194 {
195 float volume = 0.0;
196 EXPECT_NE(capture_->SetVolume, nullptr);
197
198 int32_t ret = capture_->SetVolume(capture_, volume);
199 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
200 EXPECT_EQ(ret, HDF_SUCCESS);
201 #else
202 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
203 #endif
204 }
205 /**
206 * @tc.number : SUB_Driver_Audio_CaptureSetVolume_0500
207 * @tc.name : testAudioCaptureSetVolume002
208 * @tc.desc : test API SetVolume input parameter volume = 1.0
209 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetVolume002, TestSize.Level1)210 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetVolume002, TestSize.Level1)
211 {
212 float volume = 1.0;
213 EXPECT_NE(capture_->SetVolume, nullptr);
214
215 int32_t ret = capture_->SetVolume(capture_, volume);
216 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
217 EXPECT_EQ(ret, HDF_SUCCESS);
218 #else
219 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
220 #endif
221 }
222 /**
223 * @tc.number : SUB_Driver_Audio_CaptureSetVolume_0600
224 * @tc.name : testAudioCaptureSetVolume003
225 * @tc.desc : test API SetVolume input parameter volume = -0.1
226 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetVolume003, TestSize.Level2)227 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetVolume003, TestSize.Level2)
228 {
229 float volume = -0.1;
230 EXPECT_NE(capture_->SetVolume, nullptr);
231
232 int32_t ret = capture_->SetVolume(capture_, volume);
233 EXPECT_NE(ret, HDF_SUCCESS);
234 }
235 /**
236 * @tc.number : SUB_Driver_Audio_CaptureSetVolume_0700
237 * @tc.name : testAudioCaptureSetVolume004
238 * @tc.desc : test API SetVolume input parameter volume = 1.1
239 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetVolume004, TestSize.Level2)240 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetVolume004, TestSize.Level2)
241 {
242 float volume = 1.1;
243 EXPECT_NE(capture_->SetVolume, nullptr);
244
245 int32_t ret = capture_->SetVolume(capture_, volume);
246 EXPECT_NE(ret, HDF_SUCCESS);
247 }
248 /**
249 * @tc.number : SUB_Driver_Audio_CaptureSetVolume_0800
250 * @tc.name : testAudioCaptureSetVolume005
251 * @tc.desc : test API SetVolume 1000 times
252 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetVolume005, TestSize.Level1)253 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetVolume005, TestSize.Level1)
254 {
255 float volume = 0.8;
256 int i = 0;
257 int32_t ret = HDF_ERR_NOT_SUPPORT;
258 EXPECT_NE(capture_->SetVolume, nullptr);
259 for (i = 0; i < 1000; i++) {
260 ret = capture_->SetVolume(capture_, volume);
261 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
262 EXPECT_EQ(ret, HDF_SUCCESS);
263 #else
264 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
265 #endif
266 }
267 }
268 /**
269 * @tc.number : SUB_Driver_Audio_CaptureGetVolume_0300
270 * @tc.name : testAudioCaptureGetVolume001
271 * @tc.desc : test API GetVolume 1000 times
272 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetVolume001, TestSize.Level1)273 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetVolume001, TestSize.Level1)
274 {
275 float volume = HALF_OF_MAX_VOLUME;
276 int i = 0;
277 EXPECT_NE(capture_->SetVolume, nullptr);
278
279 int32_t ret = capture_->SetVolume(capture_, volume);
280 if (ret == HDF_SUCCESS) {
281 for (i = 0; i < 1000; i++) {
282 ret = capture_->GetVolume(capture_, &volume);
283 ASSERT_EQ(volume, HALF_OF_MAX_VOLUME);
284 }
285 } else if (ret == HDF_ERR_NOT_SUPPORT) {
286 ASSERT_TRUE(true);
287 } else {
288 ASSERT_TRUE(false);
289 }
290 }
291 /**
292 * @tc.number : SUB_Driver_Audio_CaptureSetMute_0400
293 * @tc.name : testAudioCaptureSetMute001
294 * @tc.desc : test API GetMute SetMute
295 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetMute001, TestSize.Level1)296 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetMute001, TestSize.Level1)
297 {
298 bool isSupport = true;
299 ASSERT_NE(capture_->SetMute, nullptr);
300 ASSERT_NE(capture_->GetMute, nullptr);
301
302 int32_t ret = capture_->SetMute(capture_, isSupport);
303 if (ret == HDF_SUCCESS) {
304 ret = capture_->GetMute(capture_, &isSupport);
305 ASSERT_EQ(isSupport, true);
306 } else if (ret == HDF_ERR_NOT_SUPPORT) {
307 ASSERT_TRUE(true);
308 } else {
309 ASSERT_TRUE(false);
310 }
311
312 isSupport = false;
313 ret = capture_->SetMute(capture_, isSupport);
314 if (ret == HDF_SUCCESS) {
315 ret = capture_->GetMute(capture_, &isSupport);
316 ASSERT_EQ(isSupport, false);
317 } else if (ret == HDF_ERR_NOT_SUPPORT) {
318 ASSERT_TRUE(true);
319 } else {
320 ASSERT_TRUE(false);
321 }
322 isSupport = true;
323 ret = capture_->GetMute(capture_, &isSupport);
324 if (ret == HDF_SUCCESS) {
325 ASSERT_EQ(isSupport, false);
326 }
327 }
328 /**
329 * @tc.number : SUB_Driver_Audio_CaptureSetMute_0500
330 * @tc.name : testAudioCaptureSetMute002
331 * @tc.desc : test API SetMute Audio Handle is nullptr
332 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetMute002, TestSize.Level2)333 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetMute002, TestSize.Level2)
334 {
335 EXPECT_NE(capture_->SetMute, nullptr);
336
337 int32_t ret = capture_->SetMute(nullptr, false);
338 EXPECT_NE(ret, HDF_SUCCESS);
339 }
340 /**
341 * @tc.number : SUB_Driver_Audio_CaptureSetMute_0600
342 * @tc.name : testAudioCaptureSetMute003
343 * @tc.desc : test API SetMute 1000times
344 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetMute003, TestSize.Level1)345 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetMute003, TestSize.Level1)
346 {
347 int i = 0;
348 int32_t ret = HDF_ERR_NOT_SUPPORT;
349 EXPECT_NE(capture_->SetMute, nullptr);
350 for (i = 0; i < 1000; i++) {
351 ret = capture_->SetMute(capture_, false);
352 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
353 EXPECT_EQ(ret, HDF_SUCCESS);
354 #else
355 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
356 #endif
357 }
358 }
359 /**
360 * @tc.number : SUB_Driver_Audio_CaptureGetMute_0300
361 * @tc.name : testAudioCaptureGetMute001
362 * @tc.desc : test API GetMute Audio Handle is nullptr
363 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetMute001, TestSize.Level2)364 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetMute001, TestSize.Level2)
365 {
366 bool isSupport = false;
367 EXPECT_NE(capture_->GetMute, nullptr);
368
369 int32_t ret = capture_->GetMute(nullptr, &isSupport);
370 EXPECT_NE(ret, HDF_SUCCESS);
371 }
372 /**
373 * @tc.number : SUB_Driver_Audio_CaptureGetMute_0400
374 * @tc.name : testAudioCaptureGetMute002
375 * @tc.desc : test API GetMute Audio Handle is nullptr
376 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetMute002, TestSize.Level2)377 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetMute002, TestSize.Level2)
378 {
379 bool isSupport = true;
380 EXPECT_NE(capture_->GetMute, nullptr);
381
382 int32_t ret = capture_->GetMute(nullptr, &isSupport);
383 EXPECT_NE(ret, HDF_SUCCESS);
384 }
385 /**
386 * @tc.number : SUB_Driver_Audio_CaptureGetMute_0500
387 * @tc.name : testAudioCaptureGetMute003
388 * @tc.desc : test API GetMute 1000 times
389 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetMute003, TestSize.Level1)390 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetMute003, TestSize.Level1)
391 {
392 int i = 0;
393 bool isSupport = false;
394 EXPECT_NE(capture_->SetMute, nullptr);
395 EXPECT_NE(capture_->GetMute, nullptr);
396
397 int32_t ret = capture_->SetMute(capture_, true);
398 if (ret == HDF_SUCCESS) {
399 for (i = 0; i < 1000; i++) {
400 ret = capture_->GetMute(capture_, &isSupport);
401 ASSERT_EQ(isSupport, true);
402 }
403 } else if (ret == HDF_ERR_NOT_SUPPORT) {
404 ASSERT_TRUE(true);
405 } else {
406 ASSERT_TRUE(false);
407 }
408 }
409 /**
410 * @tc.number : SUB_Driver_Audio_CaptureGetMute_0600
411 * @tc.name : testAudioCaptureGetMute004
412 * @tc.desc : test API GetMute 1000 times
413 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetMute004, TestSize.Level1)414 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetMute004, TestSize.Level1)
415 {
416 int i = 0;
417 bool isSupport = true;
418 EXPECT_NE(capture_->SetMute, nullptr);
419 EXPECT_NE(capture_->GetMute, nullptr);
420
421 int32_t ret = capture_->SetMute(capture_, false);
422 if (ret == HDF_SUCCESS) {
423 for (i = 0; i < 1000; i++) {
424 ret = capture_->GetMute(capture_, &isSupport);
425 ASSERT_EQ(isSupport, false);
426 }
427 } else if (ret == HDF_ERR_NOT_SUPPORT) {
428 ASSERT_TRUE(true);
429 } else {
430 ASSERT_TRUE(false);
431 }
432 }
433 /**
434 * @tc.number : SUB_Driver_Audio_CaptureSetGain_0300
435 * @tc.name : testAudioCaptureSetGain001
436 * @tc.desc : test API SetGain param is 0
437 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetGain001, TestSize.Level1)438 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetGain001, TestSize.Level1)
439 {
440 float mute = 0;
441 EXPECT_NE(capture_->SetGain, nullptr);
442
443 int32_t ret = capture_->SetGain(capture_, mute);
444 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
445 EXPECT_EQ(ret, HDF_SUCCESS);
446 #else
447 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
448 #endif
449 }
450 /**
451 * @tc.number : SUB_Driver_Audio_CaptureSetGain_0400
452 * @tc.name : testAudioCaptureSetGain002
453 * @tc.desc : test API SetGain param is 1.0
454 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetGain002, TestSize.Level1)455 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetGain002, TestSize.Level1)
456 {
457 float mute = 1.0;
458 EXPECT_NE(capture_->SetGain, nullptr);
459
460 int32_t ret = capture_->SetGain(capture_, mute);
461 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
462 EXPECT_EQ(ret, HDF_SUCCESS);
463 #else
464 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
465 #endif
466 }
467 /**
468 * @tc.number : SUB_Driver_Audio_CaptureSetGain_0500
469 * @tc.name : testAudioCaptureSetGain003
470 * @tc.desc : test API SetGain param is -0.1
471 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetGain003, TestSize.Level2)472 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetGain003, TestSize.Level2)
473 {
474 float mute = -0.1;
475 EXPECT_NE(capture_->SetGain, nullptr);
476
477 int32_t ret = capture_->SetGain(capture_, mute);
478 EXPECT_NE(ret, HDF_SUCCESS);
479 }
480 /**
481 * @tc.number : SUB_Driver_Audio_CaptureSetGain_0600
482 * @tc.name : testAudioCaptureSetGain004
483 * @tc.desc : test API SetGain param is 1.1
484 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetGain004, TestSize.Level1)485 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetGain004, TestSize.Level1)
486 {
487 float gain = 1.1;
488 EXPECT_NE(capture_->SetGain, nullptr);
489
490 int32_t ret = capture_->SetGain(capture_, gain);
491 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
492 EXPECT_EQ(ret, HDF_SUCCESS);
493 #else
494 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
495 #endif
496 }
497 /**
498 * @tc.number : SUB_Driver_Audio_CaptureSetGain_0700
499 * @tc.name : testAudioCaptureSetGain005
500 * @tc.desc : test API SetGain param is 2.0
501 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetGain005, TestSize.Level1)502 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetGain005, TestSize.Level1)
503 {
504 float gain = 2.0;
505 EXPECT_NE(capture_->SetGain, nullptr);
506
507 int32_t ret = capture_->SetGain(capture_, gain);
508 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
509 EXPECT_EQ(ret, HDF_SUCCESS);
510 #else
511 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
512 #endif
513 }
514 /**
515 * @tc.number : SUB_Driver_Audio_CaptureSetGain_0800
516 * @tc.name : testAudioCaptureSetGain006
517 * @tc.desc : test API SetGain 1000times
518 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetGain006, TestSize.Level1)519 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetGain006, TestSize.Level1)
520 {
521 float mute = 0.5;
522 int i = 0;
523 int32_t ret = HDF_ERR_NOT_SUPPORT;
524
525 EXPECT_NE(capture_->SetGain, nullptr);
526 for (i = 0; i < 1000; i++) {
527 ret = capture_->SetGain(capture_, mute);
528 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
529 EXPECT_EQ(ret, HDF_SUCCESS);
530 #else
531 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
532 #endif
533 }
534 }
535 /**
536 * @tc.number : SUB_Driver_Audio_CaptureSetGain_0900
537 * @tc.name : testAudioCaptureSetGain007
538 * @tc.desc : test API SetGain Audio Handle is nullptr
539 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetGain007, TestSize.Level2)540 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSetGain007, TestSize.Level2)
541 {
542 float mute = 0.5;
543 EXPECT_NE(capture_->SetGain, nullptr);
544
545 int32_t ret = capture_->SetGain(nullptr, mute);
546 EXPECT_NE(ret, HDF_SUCCESS);
547 }
548 /**
549 * @tc.number : SUB_Driver_Audio_CaptureGetGain_0300
550 * @tc.name : testAudioCaptureGetGain001
551 * @tc.desc : test API GetGain 1000times
552 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetGain001, TestSize.Level1)553 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetGain001, TestSize.Level1)
554 {
555 float gain = 2.0;
556 int i = 0;
557 int32_t ret = 0;
558 EXPECT_NE(capture_->SetGain, nullptr);
559 for (i = 0; i < 1000; i++) {
560 ret = capture_->GetGain(capture_, &gain);
561 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
562 EXPECT_EQ(ret, HDF_SUCCESS);
563 #else
564 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
565 #endif
566 }
567 }
568 /**
569 * @tc.number : SUB_Driver_Audio_CaptureGetGainThreshold_0300
570 * @tc.name : testAudioCaptureGetGainThreshold001
571 * @tc.desc : test API GetGainThreshold
572 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetGainThreshold001, TestSize.Level2)573 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetGainThreshold001, TestSize.Level2)
574 {
575 float top = 0;
576 EXPECT_NE(capture_->GetGainThreshold, nullptr);
577
578 int32_t ret = capture_->GetGainThreshold(nullptr, nullptr, &top);
579 EXPECT_NE(ret, HDF_SUCCESS);
580 }
581 /**
582 * @tc.number : SUB_Driver_Audio_CaptureGetGainThreshold_0400
583 * @tc.name : testAudioCaptureGetGainThreshold002
584 * @tc.desc : test API GetGainThreshold
585 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetGainThreshold002, TestSize.Level2)586 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetGainThreshold002, TestSize.Level2)
587 {
588 float bottom = 0;
589 EXPECT_NE(capture_->GetGainThreshold, nullptr);
590
591 int32_t ret = capture_->GetGainThreshold(capture_, &bottom, nullptr);
592 EXPECT_NE(ret, HDF_SUCCESS);
593 }
594 /**
595 * @tc.number : SUB_Driver_Audio_CaptureGetGainThreshold_0500
596 * @tc.name : testAudioCaptureGetGainThreshold003
597 * @tc.desc : test API GetGainThreshold
598 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetGainThreshold003, TestSize.Level2)599 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetGainThreshold003, TestSize.Level2)
600 {
601 float top = 0;
602 EXPECT_NE(capture_->GetGainThreshold, nullptr);
603
604 int32_t ret = capture_->GetGainThreshold(capture_, nullptr, &top);
605 EXPECT_NE(ret, HDF_SUCCESS);
606 }
607 /**
608 * @tc.number : SUB_Driver_Audio_CaptureGetGainThreshold_0600
609 * @tc.name : testAudioCaptureGetGainThreshold004
610 * @tc.desc : test API GetGainThreshold
611 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetGainThreshold004, TestSize.Level2)612 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetGainThreshold004, TestSize.Level2)
613 {
614 float bottom = 0;
615 EXPECT_NE(capture_->GetGainThreshold, nullptr);
616
617 int32_t ret = capture_->GetGainThreshold(nullptr, &bottom, nullptr);
618 EXPECT_NE(ret, HDF_SUCCESS);
619 }
620 /**
621 * @tc.number : SUB_Driver_Audio_CaptureGetGainThreshold_0700
622 * @tc.name : testAudioCaptureGetGainThreshold005
623 * @tc.desc : test API GetGainThreshold
624 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetGainThreshold005, TestSize.Level1)625 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetGainThreshold005, TestSize.Level1)
626 {
627 float bottom = 0;
628 float top = 0;
629 int32_t ret = HDF_ERR_NOT_SUPPORT;
630 int i = 0;
631 EXPECT_NE(capture_->GetGainThreshold, nullptr);
632 for (i = 0; i < 1000; i++) {
633 ret = capture_->GetGainThreshold(capture_, &bottom, &top);
634 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
635 EXPECT_EQ(ret, HDF_SUCCESS);
636 #else
637 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
638 #endif
639 }
640 }
641 /**
642 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_0300
643 * @tc.name : testAudioCaptureSelectScene001
644 * @tc.desc : test API SelectScene
645 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene001, TestSize.Level1)646 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene001, TestSize.Level1)
647 {
648 ASSERT_NE(capture_->SelectScene, nullptr);
649 struct AudioSceneDescriptor sceneDesc = {};
650 sceneDesc.desc.pins = PIN_IN_MIC;
651 sceneDesc.desc.desc = strdup("mic");
652 sceneDesc.scene.id = AUDIO_IN_MEDIA;
653
654 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
655 EXPECT_EQ(ret, HDF_SUCCESS);
656 free(sceneDesc.desc.desc);
657 }
658 /**
659 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_0400
660 * @tc.name : testAudioCaptureSelectScene002
661 * @tc.desc : test API SelectScene
662 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene002, TestSize.Level1)663 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene002, TestSize.Level1)
664 {
665 ASSERT_NE(capture_->SelectScene, nullptr);
666 struct AudioSceneDescriptor sceneDesc = {};
667 sceneDesc.desc.pins = PIN_IN_MIC;
668 sceneDesc.desc.desc = strdup("mic");
669 sceneDesc.scene.id = AUDIO_IN_COMMUNICATION;
670
671 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
672 EXPECT_EQ(ret, HDF_SUCCESS);
673 free(sceneDesc.desc.desc);
674 }
675 /**
676 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_0500
677 * @tc.name : testAudioCaptureSelectScene003
678 * @tc.desc : test API SelectScene
679 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene003, TestSize.Level2)680 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene003, TestSize.Level2)
681 {
682 ASSERT_NE(capture_->SelectScene, nullptr);
683 struct AudioSceneDescriptor sceneDesc = {};
684 sceneDesc.desc.pins = PIN_IN_MIC;
685 sceneDesc.desc.desc = strdup("mic");
686 sceneDesc.scene.id = AUDIO_IN_RINGTONE;
687
688 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
689 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
690 EXPECT_NE(ret, HDF_SUCCESS);
691 #else
692 EXPECT_EQ(ret, HDF_SUCCESS);
693 #endif
694 free(sceneDesc.desc.desc);
695 }
696 /**
697 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_0600
698 * @tc.name : testAudioCaptureSelectScene004
699 * @tc.desc : test API SelectScene
700 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene004, TestSize.Level1)701 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene004, TestSize.Level1)
702 {
703 ASSERT_NE(capture_->SelectScene, nullptr);
704 struct AudioSceneDescriptor sceneDesc = {};
705 sceneDesc.desc.pins = PIN_IN_MIC;
706 sceneDesc.desc.desc = strdup("speaker");
707 sceneDesc.scene.id = AUDIO_IN_MEDIA;
708
709 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
710 EXPECT_EQ(ret, HDF_SUCCESS);
711 free(sceneDesc.desc.desc);
712 }
713 /**
714 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_0700
715 * @tc.name : testAudioCaptureSelectScene005
716 * @tc.desc : test API SelectScene
717 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene005, TestSize.Level1)718 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene005, TestSize.Level1)
719 {
720 ASSERT_NE(capture_->SelectScene, nullptr);
721 struct AudioSceneDescriptor sceneDesc = {};
722 sceneDesc.desc.pins = PIN_IN_MIC;
723 sceneDesc.desc.desc = strdup("speaker");
724 sceneDesc.scene.id = AUDIO_IN_COMMUNICATION;
725
726 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
727 EXPECT_EQ(ret, HDF_SUCCESS);
728 free(sceneDesc.desc.desc);
729 }
730 /**
731 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_0800
732 * @tc.name : testAudioCaptureSelectScene006
733 * @tc.desc : test API SelectScene
734 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene006, TestSize.Level2)735 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene006, TestSize.Level2)
736 {
737 ASSERT_NE(capture_->SelectScene, nullptr);
738 struct AudioSceneDescriptor sceneDesc = {};
739 sceneDesc.desc.pins = PIN_IN_MIC;
740 sceneDesc.desc.desc = strdup("speaker");
741 sceneDesc.scene.id = AUDIO_IN_RINGTONE;
742
743 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
744 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
745 EXPECT_NE(ret, HDF_SUCCESS);
746 #else
747 EXPECT_EQ(ret, HDF_SUCCESS);
748 #endif
749 free(sceneDesc.desc.desc);
750 }
751 /**
752 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_0900
753 * @tc.name : testAudioCaptureSelectScene007
754 * @tc.desc : test API SelectScene
755 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene007, TestSize.Level1)756 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene007, TestSize.Level1)
757 {
758 ASSERT_NE(capture_->SelectScene, nullptr);
759 struct AudioSceneDescriptor sceneDesc = {};
760 sceneDesc.desc.pins = PIN_IN_MIC;
761 sceneDesc.desc.desc = strdup("speaker");
762 sceneDesc.scene.id = AUDIO_IN_CALL;
763
764 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
765 EXPECT_EQ(ret, HDF_SUCCESS);
766 free(sceneDesc.desc.desc);
767 }
768 /**
769 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_1000
770 * @tc.name : testAudioCaptureSelectScene008
771 * @tc.desc : test API SelectScene
772 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene008, TestSize.Level2)773 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene008, TestSize.Level2)
774 {
775 ASSERT_NE(capture_->SelectScene, nullptr);
776 struct AudioSceneDescriptor sceneDesc = {};
777 sceneDesc.desc.desc = strdup("mic");
778 sceneDesc.scene.id = AUDIO_IN_MEDIA;
779
780 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
781 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
782 EXPECT_NE(ret, HDF_SUCCESS);
783 #else
784 EXPECT_EQ(ret, HDF_SUCCESS);
785 #endif
786 free(sceneDesc.desc.desc);
787 }
788 /**
789 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_1100
790 * @tc.name : testAudioCaptureSelectScene009
791 * @tc.desc : test API SelectScene
792 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene009, TestSize.Level2)793 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene009, TestSize.Level2)
794 {
795 ASSERT_NE(capture_->SelectScene, nullptr);
796 struct AudioSceneDescriptor sceneDesc = {};
797 sceneDesc.desc.desc = strdup("mic");
798 sceneDesc.scene.id = AUDIO_IN_COMMUNICATION;
799
800 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
801 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
802 EXPECT_NE(ret, HDF_SUCCESS);
803 #else
804 EXPECT_EQ(ret, HDF_SUCCESS);
805 #endif
806 free(sceneDesc.desc.desc);
807 }
808 /**
809 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_1200
810 * @tc.name : testAudioCaptureSelectScene010
811 * @tc.desc : test API SelectScene
812 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene010, TestSize.Level2)813 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene010, TestSize.Level2)
814 {
815 ASSERT_NE(capture_->SelectScene, nullptr);
816 struct AudioSceneDescriptor sceneDesc = {};
817 sceneDesc.desc.desc = strdup("mic");
818 sceneDesc.scene.id = AUDIO_IN_RINGTONE;
819
820 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
821 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
822 EXPECT_NE(ret, HDF_SUCCESS);
823 #else
824 EXPECT_EQ(ret, HDF_SUCCESS);
825 #endif
826 free(sceneDesc.desc.desc);
827 }
828 /**
829 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_1300
830 * @tc.name : testAudioCaptureSelectScene011
831 * @tc.desc : test API SelectScene
832 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene011, TestSize.Level2)833 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene011, TestSize.Level2)
834 {
835 ASSERT_NE(capture_->SelectScene, nullptr);
836 struct AudioSceneDescriptor sceneDesc = {};
837 sceneDesc.desc.desc = strdup("mic");
838 sceneDesc.scene.id = AUDIO_IN_CALL;
839
840 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
841 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
842 EXPECT_NE(ret, HDF_SUCCESS);
843 #else
844 EXPECT_EQ(ret, HDF_SUCCESS);
845 #endif
846 free(sceneDesc.desc.desc);
847 }
848 /**
849 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_1400
850 * @tc.name : testAudioCaptureSelectScene012
851 * @tc.desc : test API SelectScene
852 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene012, TestSize.Level1)853 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene012, TestSize.Level1)
854 {
855 ASSERT_NE(capture_->SelectScene, nullptr);
856 struct AudioSceneDescriptor sceneDesc = {};
857 int i = 0;
858 int32_t ret = HDF_ERR_NOT_SUPPORT;
859 sceneDesc.desc.pins = PIN_IN_MIC;
860 sceneDesc.desc.desc = strdup("mic");
861 sceneDesc.scene.id = AUDIO_IN_CALL;
862 for (i = 0; i < 1000; i++) {
863 ret = capture_->SelectScene(capture_, &sceneDesc);
864 EXPECT_EQ(ret, HDF_SUCCESS);
865 }
866 free(sceneDesc.desc.desc);
867 }
868 /**
869 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_1500
870 * @tc.name : testAudioCaptureSelectScene013
871 * @tc.desc : test API SelectScene
872 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene013, TestSize.Level2)873 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene013, TestSize.Level2)
874 {
875 ASSERT_NE(capture_->SelectScene, nullptr);
876 struct AudioSceneDescriptor sceneDesc = {};
877 sceneDesc.desc.pins = PIN_OUT_SPEAKER;
878 sceneDesc.desc.desc = strdup("speaker");
879 sceneDesc.scene.id = AUDIO_IN_MEDIA;
880
881 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
882 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
883 EXPECT_NE(ret, HDF_SUCCESS);
884 #else
885 EXPECT_EQ(ret, HDF_SUCCESS);
886 #endif
887 free(sceneDesc.desc.desc);
888 }
889 /**
890 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_1600
891 * @tc.name : testAudioCaptureSelectScene014
892 * @tc.desc : test API SelectScene
893 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene014, TestSize.Level2)894 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene014, TestSize.Level2)
895 {
896 ASSERT_NE(capture_->SelectScene, nullptr);
897 struct AudioSceneDescriptor sceneDesc = {};
898 sceneDesc.desc.pins = PIN_OUT_SPEAKER;
899 sceneDesc.desc.desc = strdup("speaker");
900 sceneDesc.scene.id = AUDIO_IN_COMMUNICATION;
901
902 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
903 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
904 EXPECT_NE(ret, HDF_SUCCESS);
905 #else
906 EXPECT_EQ(ret, HDF_SUCCESS);
907 #endif
908 free(sceneDesc.desc.desc);
909 }
910 /**
911 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_1700
912 * @tc.name : testAudioCaptureSelectScene015
913 * @tc.desc : test API SelectScene
914 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene015, TestSize.Level2)915 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene015, TestSize.Level2)
916 {
917 ASSERT_NE(capture_->SelectScene, nullptr);
918 struct AudioSceneDescriptor sceneDesc = {};
919 sceneDesc.desc.pins = PIN_OUT_SPEAKER;
920 sceneDesc.desc.desc = strdup("speaker");
921 sceneDesc.scene.id = AUDIO_IN_RINGTONE;
922
923 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
924 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
925 EXPECT_NE(ret, HDF_SUCCESS);
926 #else
927 EXPECT_EQ(ret, HDF_SUCCESS);
928 #endif
929 free(sceneDesc.desc.desc);
930 }
931 /**
932 * @tc.number : SUB_Driver_Audio_CaptureSelectScene_1800
933 * @tc.name : testAudioCaptureSelectScene016
934 * @tc.desc : test API SelectScene
935 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene016, TestSize.Level2)936 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureSelectScene016, TestSize.Level2)
937 {
938 ASSERT_NE(capture_->SelectScene, nullptr);
939 struct AudioSceneDescriptor sceneDesc = {};
940 sceneDesc.desc.pins = PIN_OUT_SPEAKER;
941 sceneDesc.desc.desc = strdup("speaker");
942 sceneDesc.scene.id = AUDIO_IN_CALL;
943
944 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
945 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
946 EXPECT_NE(ret, HDF_SUCCESS);
947 #else
948 EXPECT_EQ(ret, HDF_SUCCESS);
949 #endif
950 free(sceneDesc.desc.desc);
951 }
952 /**
953 * @tc.number : SUB_Driver_Audio_CaptureCheckSceneCapability_0300
954 * @tc.name : testAudioCaptureCheckSceneCapability001
955 * @tc.desc : test API CheckSceneCapability
956 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCheckSceneCapability001, TestSize.Level1)957 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCheckSceneCapability001, TestSize.Level1)
958 {
959 ASSERT_NE(capture_->CheckSceneCapability, nullptr);
960 struct AudioSceneDescriptor sceneDesc = {};
961 sceneDesc.desc.pins = PIN_IN_MIC;
962 sceneDesc.desc.desc = strdup("mic");
963 sceneDesc.scene.id = AUDIO_IN_MEDIA;
964 bool isSupport = false;
965
966 int32_t ret = capture_->CheckSceneCapability(capture_, &sceneDesc, &isSupport);
967 EXPECT_EQ(ret, HDF_SUCCESS);
968 free(sceneDesc.desc.desc);
969 }
970 /**
971 * @tc.number : SUB_Driver_Audio_CaptureCheckSceneCapability_0400
972 * @tc.name : testAudioCaptureCheckSceneCapability002
973 * @tc.desc : test API CheckSceneCapability
974 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCheckSceneCapability002, TestSize.Level1)975 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCheckSceneCapability002, TestSize.Level1)
976 {
977 ASSERT_NE(capture_->CheckSceneCapability, nullptr);
978 struct AudioSceneDescriptor sceneDesc = {};
979 int i = 0;
980 int32_t ret;
981
982 sceneDesc.desc.pins = PIN_IN_MIC;
983 sceneDesc.desc.desc = strdup("mic");
984 sceneDesc.scene.id = AUDIO_IN_MEDIA;
985 bool isSupport = false;
986 for (i = 0; i < 1000; i++) {
987 ret = capture_->CheckSceneCapability(capture_, &sceneDesc, &isSupport);
988 EXPECT_EQ(ret, HDF_SUCCESS);
989 }
990 free(sceneDesc.desc.desc);
991 }
992 /**
993 * @tc.number : SUB_Driver_Audio_CaptureCheckSceneCapability_0500
994 * @tc.name : testAudioCaptureCheckSceneCapability003
995 * @tc.desc : test API CheckSceneCapability
996 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCheckSceneCapability003, TestSize.Level1)997 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCheckSceneCapability003, TestSize.Level1)
998 {
999 ASSERT_NE(capture_->CheckSceneCapability, nullptr);
1000 struct AudioSceneDescriptor sceneDesc = {};
1001 sceneDesc.desc.pins = PIN_IN_MIC;
1002 sceneDesc.desc.desc = strdup("mic");
1003 sceneDesc.scene.id = AUDIO_IN_CALL;
1004 bool isSupport = false;
1005
1006 int32_t ret = capture_->CheckSceneCapability(capture_, &sceneDesc, &isSupport);
1007 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1008 EXPECT_EQ(ret, HDF_SUCCESS);
1009 #else
1010 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1011 #endif
1012 free(sceneDesc.desc.desc);
1013 }
1014 /**
1015 * @tc.number : SUB_Driver_Audio_CaptureCaptureFrame_0300
1016 * @tc.name : testAudioCaptureCaptureFrame001
1017 * @tc.desc : test API CaptureFrame 1000times
1018 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame001, TestSize.Level1)1019 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame001, TestSize.Level1)
1020 {
1021 uint32_t frameLen = (uint64_t)GetCaptureBufferSize();
1022 uint64_t requestBytes = frameLen;
1023 ASSERT_NE(capture_->CaptureFrame, nullptr);
1024 int i = 0;
1025
1026 int32_t ret = capture_->Start(capture_);
1027 EXPECT_EQ(ret, HDF_SUCCESS);
1028
1029 int8_t *frame = (int8_t *)calloc(1, frameLen);
1030 EXPECT_NE(nullptr, frame);
1031 for (i = 0; i < 1000; i++) {
1032 ret = capture_->CaptureFrame(capture_, frame, &frameLen, &requestBytes);
1033 EXPECT_EQ(ret, HDF_SUCCESS);
1034 }
1035 capture_->Stop(capture_);
1036
1037 if (frame != nullptr) {
1038 free(frame);
1039 frame = nullptr;
1040 }
1041 }
1042 /**
1043 * @tc.number : SUB_Driver_Audio_CaptureCaptureFrame_0400
1044 * @tc.name : testAudioCaptureCaptureFrame002
1045 * @tc.desc : test API CaptureFrame parameter is nullptr
1046 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame002, TestSize.Level2)1047 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame002, TestSize.Level2)
1048 {
1049 uint32_t frameLen = (uint64_t)GetCaptureBufferSize();
1050 uint64_t requestBytes = frameLen;
1051 ASSERT_NE(capture_->CaptureFrame, nullptr);
1052
1053 int32_t ret = capture_->Start(capture_);
1054 EXPECT_EQ(ret, HDF_SUCCESS);
1055
1056 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(nullptr, nullptr, nullptr, &requestBytes));
1057 capture_->Stop(capture_);
1058 }
1059 /**
1060 * @tc.number : SUB_Driver_Audio_CaptureCaptureFrame_0500
1061 * @tc.name : testAudioCaptureCaptureFrame003
1062 * @tc.desc : test API CaptureFrame parameter is nullptr
1063 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame003, TestSize.Level2)1064 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame003, TestSize.Level2)
1065 {
1066 uint32_t frameLen = (uint64_t)GetCaptureBufferSize();
1067 ASSERT_NE(capture_->CaptureFrame, nullptr);
1068
1069 int32_t ret = capture_->Start(capture_);
1070 EXPECT_EQ(ret, HDF_SUCCESS);
1071
1072 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(nullptr, nullptr, &frameLen, nullptr));
1073 capture_->Stop(capture_);
1074 }
1075 /**
1076 * @tc.number : SUB_Driver_Audio_CaptureCaptureFrame_0600
1077 * @tc.name : testAudioCaptureCaptureFrame004
1078 * @tc.desc : test API CaptureFrame parameter is nullptr
1079 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame004, TestSize.Level2)1080 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame004, TestSize.Level2)
1081 {
1082 uint32_t frameLen = (uint64_t)GetCaptureBufferSize();
1083 uint64_t requestBytes = frameLen;
1084 ASSERT_NE(capture_->CaptureFrame, nullptr);
1085
1086 int32_t ret = capture_->Start(capture_);
1087 EXPECT_EQ(ret, HDF_SUCCESS);
1088
1089 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(nullptr, nullptr, &frameLen, &requestBytes));
1090 capture_->Stop(capture_);
1091 }
1092 /**
1093 * @tc.number : SUB_Driver_Audio_CaptureCaptureFrame_0700
1094 * @tc.name : testAudioCaptureCaptureFrame005
1095 * @tc.desc : test API CaptureFrame parameter is nullptr
1096 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame005, TestSize.Level2)1097 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame005, TestSize.Level2)
1098 {
1099 ASSERT_NE(capture_->CaptureFrame, nullptr);
1100
1101 int32_t ret = capture_->Start(capture_);
1102 EXPECT_EQ(ret, HDF_SUCCESS);
1103
1104 int8_t *frame = (int8_t *)calloc(1, sizeof(int));
1105 EXPECT_NE(nullptr, frame);
1106
1107 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(nullptr, frame, nullptr, nullptr));
1108 capture_->Stop(capture_);
1109 if (frame != nullptr) {
1110 free(frame);
1111 frame = nullptr;
1112 }
1113 }
1114 /**
1115 * @tc.number : SUB_Driver_Audio_CaptureCaptureFrame_0800
1116 * @tc.name : testAudioCaptureCaptureFrame006
1117 * @tc.desc : test API CaptureFrame parameter is nullptr
1118 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame006, TestSize.Level2)1119 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame006, TestSize.Level2)
1120 {
1121 uint32_t frameLen = (uint64_t)GetCaptureBufferSize();
1122 uint64_t requestBytes = frameLen;
1123 ASSERT_NE(capture_->CaptureFrame, nullptr);
1124
1125 int32_t ret = capture_->Start(capture_);
1126 EXPECT_EQ(ret, HDF_SUCCESS);
1127
1128 int8_t *frame = (int8_t *)calloc(1, sizeof(int));
1129 EXPECT_NE(nullptr, frame);
1130
1131 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(nullptr, frame, nullptr, &requestBytes));
1132 capture_->Stop(capture_);
1133 if (frame != nullptr) {
1134 free(frame);
1135 frame = nullptr;
1136 }
1137 }
1138 /**
1139 * @tc.number : SUB_Driver_Audio_CaptureCaptureFrame_0900
1140 * @tc.name : testAudioCaptureCaptureFrame007
1141 * @tc.desc : test API CaptureFrame parameter is nullptr
1142 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame007, TestSize.Level2)1143 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame007, TestSize.Level2)
1144 {
1145 uint32_t frameLen = (uint64_t)GetCaptureBufferSize();
1146 ASSERT_NE(capture_->CaptureFrame, nullptr);
1147
1148 int32_t ret = capture_->Start(capture_);
1149 EXPECT_EQ(ret, HDF_SUCCESS);
1150
1151 int8_t *frame = (int8_t *)calloc(1, sizeof(int));
1152 EXPECT_NE(nullptr, frame);
1153
1154 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(nullptr, frame, &frameLen, nullptr));
1155 capture_->Stop(capture_);
1156 if (frame != nullptr) {
1157 free(frame);
1158 frame = nullptr;
1159 }
1160 }
1161 /**
1162 * @tc.number : SUB_Driver_Audio_CaptureCaptureFrame_1000
1163 * @tc.name : testAudioCaptureCaptureFrame008
1164 * @tc.desc : test API CaptureFrame parameter is nullptr
1165 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame008, TestSize.Level2)1166 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame008, TestSize.Level2)
1167 {
1168 ASSERT_NE(capture_->CaptureFrame, nullptr);
1169
1170 int32_t ret = capture_->Start(capture_);
1171 EXPECT_EQ(ret, HDF_SUCCESS);
1172
1173 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(capture_, nullptr, nullptr, nullptr));
1174 capture_->Stop(capture_);
1175 }
1176 /**
1177 * @tc.number : SUB_Driver_Audio_CaptureCaptureFrame_1100
1178 * @tc.name : testAudioCaptureCaptureFrame009
1179 * @tc.desc : test API CaptureFrame parameter is nullptr
1180 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame009, TestSize.Level2)1181 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame009, TestSize.Level2)
1182 {
1183 uint32_t frameLen = (uint64_t)GetCaptureBufferSize();
1184 uint64_t requestBytes = frameLen;
1185 ASSERT_NE(capture_->CaptureFrame, nullptr);
1186
1187 int32_t ret = capture_->Start(capture_);
1188 EXPECT_EQ(ret, HDF_SUCCESS);
1189
1190 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(capture_, nullptr, nullptr, &requestBytes));
1191 capture_->Stop(capture_);
1192 }
1193 /**
1194 * @tc.number : SUB_Driver_Audio_CaptureCaptureFrame_1200
1195 * @tc.name : testAudioCaptureCaptureFrame010
1196 * @tc.desc : test API CaptureFrame parameter is nullptr
1197 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame010, TestSize.Level2)1198 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame010, TestSize.Level2)
1199 {
1200 uint32_t frameLen = (uint64_t)GetCaptureBufferSize();
1201 ASSERT_NE(capture_->CaptureFrame, nullptr);
1202
1203 int32_t ret = capture_->Start(capture_);
1204 EXPECT_EQ(ret, HDF_SUCCESS);
1205
1206 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(capture_, nullptr, &frameLen, nullptr));
1207 capture_->Stop(capture_);
1208 }
1209 /**
1210 * @tc.number : SUB_Driver_Audio_CaptureCaptureFrame_1300
1211 * @tc.name : testAudioCaptureCaptureFrame011
1212 * @tc.desc : test API CaptureFrame parameter is nullptr
1213 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame011, TestSize.Level2)1214 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame011, TestSize.Level2)
1215 {
1216 uint32_t frameLen = (uint64_t)GetCaptureBufferSize();
1217 uint64_t requestBytes = frameLen;
1218 ASSERT_NE(capture_->CaptureFrame, nullptr);
1219
1220 int32_t ret = capture_->Start(capture_);
1221 EXPECT_EQ(ret, HDF_SUCCESS);
1222
1223 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(capture_, nullptr, &frameLen, &requestBytes));
1224 capture_->Stop(capture_);
1225 }
1226 /**
1227 * @tc.number : SUB_Driver_Audio_CaptureCaptureFrame_1400
1228 * @tc.name : testAudioCaptureCaptureFrame012
1229 * @tc.desc : test API CaptureFrame parameter is nullptr
1230 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame012, TestSize.Level2)1231 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureCaptureFrame012, TestSize.Level2)
1232 {
1233 uint32_t frameLen = (uint64_t)GetCaptureBufferSize();
1234 uint64_t requestBytes = frameLen;
1235 ASSERT_NE(capture_->CaptureFrame, nullptr);
1236
1237 int32_t ret = capture_->Start(capture_);
1238 EXPECT_EQ(ret, HDF_SUCCESS);
1239
1240 int8_t *frame = (int8_t *)calloc(1, sizeof(int));
1241 EXPECT_NE(nullptr, frame);
1242
1243 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(capture_, frame, nullptr, &requestBytes));
1244 capture_->Stop(capture_);
1245 if (frame != nullptr) {
1246 free(frame);
1247 frame = nullptr;
1248 }
1249 }
1250 /**
1251 * @tc.number : SUB_Driver_Audio_CaptureGetCapturePosition_0400
1252 * @tc.name : testAudioCaptureGetCapturePosition002
1253 * @tc.desc : test API GetCapturePosition All parameters are nullptr
1254 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetCapturePosition002, TestSize.Level2)1255 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetCapturePosition002, TestSize.Level2)
1256 {
1257 int32_t ret;
1258 ASSERT_NE(capture_->GetCapturePosition, nullptr);
1259 ret = capture_->GetCapturePosition(nullptr, nullptr, nullptr);
1260 EXPECT_NE(ret, HDF_SUCCESS);
1261 }
1262 /**
1263 * @tc.number : SUB_Driver_Audio_CaptureGetCapturePosition_0500
1264 * @tc.name : testAudioCaptureGetCapturePosition003
1265 * @tc.desc : test API GetCapturePosition input capture and frames are nullptr
1266 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetCapturePosition003, TestSize.Level2)1267 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetCapturePosition003, TestSize.Level2)
1268 {
1269 int32_t ret;
1270 struct AudioTimeStamp time;
1271 ASSERT_NE(capture_->GetCapturePosition, nullptr);
1272 ret = capture_->GetCapturePosition(nullptr, nullptr, &time);
1273 EXPECT_NE(ret, HDF_SUCCESS);
1274 }
1275 /**
1276 * @tc.number : SUB_Driver_Audio_CaptureGetCapturePosition_0600
1277 * @tc.name : testAudioCaptureGetCapturePosition004
1278 * @tc.desc : test API GetCapturePosition input capture and time are nullptr
1279 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetCapturePosition004, TestSize.Level2)1280 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetCapturePosition004, TestSize.Level2)
1281 {
1282 int32_t ret;
1283 uint64_t frames;
1284 ASSERT_NE(capture_->GetCapturePosition, nullptr);
1285
1286 ret = capture_->GetCapturePosition(nullptr, &frames, nullptr);
1287 EXPECT_NE(ret, HDF_SUCCESS);
1288 }
1289 /**
1290 * @tc.number : SUB_Driver_Audio_CaptureGetCapturePosition_0700
1291 * @tc.name : testAudioCaptureGetCapturePosition005
1292 * @tc.desc : test API GetCapturePosition input capture is nullptr
1293 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetCapturePosition005, TestSize.Level2)1294 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetCapturePosition005, TestSize.Level2)
1295 {
1296 int32_t ret;
1297 uint64_t frames;
1298 struct AudioTimeStamp time;
1299 ASSERT_NE(capture_->GetCapturePosition, nullptr);
1300
1301 ret = capture_->GetCapturePosition(nullptr, &frames, &time);
1302 EXPECT_NE(ret, HDF_SUCCESS);
1303 }
1304 /**
1305 * @tc.number : SUB_Driver_Audio_CaptureGetCapturePosition_0800
1306 * @tc.name : testAudioCaptureGetCapturePosition006
1307 * @tc.desc : test API GetCapturePosition input frames is nullptr
1308 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetCapturePosition006, TestSize.Level2)1309 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetCapturePosition006, TestSize.Level2)
1310 {
1311 int32_t ret;
1312 struct AudioTimeStamp time;
1313 ASSERT_NE(capture_->GetCapturePosition, nullptr);
1314
1315 ret = capture_->GetCapturePosition(capture_, nullptr, &time);
1316 EXPECT_NE(ret, HDF_SUCCESS);
1317 }
1318
1319 /**
1320 * @tc.number : SUB_Driver_Audio_Capture_GetFrameSize_0100
1321 * @tc.name : testCaptureGetFrameSize001
1322 * @tc.desc : ret = HDF_SUCCESS
1323 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameSize001, Function | MediumTest | Level1)1324 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameSize001, Function | MediumTest | Level1)
1325 {
1326 uint64_t frameSize = 0;
1327 int32_t ret = 0;
1328
1329 ret = capture_->GetFrameSize(capture_, &frameSize);
1330 EXPECT_EQ(ret, HDF_SUCCESS);
1331 }
1332
1333 /**
1334 * @tc.number : SUB_Driver_Audio_Capture_GetFrameSize_0200
1335 * @tc.name : testCaptureGetFrameSize002
1336 * @tc.desc : Call 1000 times
1337 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameSize002, Function | MediumTest | Level1)1338 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameSize002, Function | MediumTest | Level1)
1339 {
1340 uint64_t frameSize = 0;
1341 int32_t ret = 0;
1342
1343 for (int i = 0; i < 1000; i++) {
1344 ret = capture_->GetFrameSize(capture_, &frameSize);
1345 EXPECT_EQ(ret, HDF_SUCCESS);
1346 }
1347 }
1348
1349 /**
1350 * @tc.number : SUB_Driver_Audio_Capture_GetFrameSize_0300
1351 * @tc.name : testCaptureGetFrameSize003
1352 * @tc.desc : capture_ is nullptr
1353 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameSize003, Function | MediumTest | Level2)1354 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameSize003, Function | MediumTest | Level2)
1355 {
1356 uint64_t frameSize = 0;
1357 int32_t ret = 0;
1358
1359 ret = capture_->GetFrameSize(nullptr, &frameSize);
1360 EXPECT_EQ(ret, HDF_ERR_INVALID_OBJECT);
1361 }
1362
1363 /**
1364 * @tc.number : SUB_Driver_Audio_Capture_GetFrameSize_0400
1365 * @tc.name : testCaptureGetFrameSize004
1366 * @tc.desc : &frameSize is nullptr
1367 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameSize004, Function | MediumTest | Level2)1368 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameSize004, Function | MediumTest | Level2)
1369 {
1370 int32_t ret = 0;
1371
1372 ret = capture_->GetFrameSize(capture_, nullptr);
1373 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
1374 }
1375
1376 /**
1377 * @tc.number : SUB_Driver_Audio_Capture_GetFrameCount_0100
1378 * @tc.name : testCaptureGetFrameCount001
1379 * @tc.desc : ret = HDF_SUCCESS
1380 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameCount001, Function | MediumTest | Level1)1381 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameCount001, Function | MediumTest | Level1)
1382 {
1383 uint64_t frameCount = 0;
1384 int32_t ret = 0;
1385
1386 ret = capture_->GetFrameCount(capture_, &frameCount);
1387 EXPECT_EQ(ret, HDF_SUCCESS);
1388 }
1389
1390 /**
1391 * @tc.number : SUB_Driver_Audio_Capture_GetFrameCount_0200
1392 * @tc.name : testCaptureGetFrameCount002
1393 * @tc.desc : Call 1000 times
1394 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameCount002, Function | MediumTest | Level1)1395 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameCount002, Function | MediumTest | Level1)
1396 {
1397 uint64_t frameCount = 0;
1398 int32_t ret = 0;
1399
1400 for (int i = 0; i < 1000; i++) {
1401 ret = capture_->GetFrameCount(capture_, &frameCount);
1402 EXPECT_EQ(ret, HDF_SUCCESS);
1403 }
1404 }
1405
1406 /**
1407 * @tc.number : SUB_Driver_Audio_Capture_GetFrameCount_0300
1408 * @tc.name : testCaptureGetFrameCount003
1409 * @tc.desc : capture_ is nullptr
1410 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameCount003, Function | MediumTest | Level2)1411 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameCount003, Function | MediumTest | Level2)
1412 {
1413 uint64_t frameCount = 0;
1414 int32_t ret = 0;
1415
1416 ret = capture_->GetFrameCount(nullptr, &frameCount);
1417 EXPECT_EQ(ret, HDF_ERR_INVALID_OBJECT);
1418 }
1419
1420 /**
1421 * @tc.number : SUB_Driver_Audio_Capture_GetFrameCount_0400
1422 * @tc.name : testCaptureGetFrameCount004
1423 * @tc.desc : &frameCount is nullptr
1424 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameCount004, Function | MediumTest | Level2)1425 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameCount004, Function | MediumTest | Level2)
1426 {
1427 int32_t ret = 0;
1428
1429 ret = capture_->GetFrameCount(capture_, nullptr);
1430 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
1431 }
1432
1433 /**
1434 * @tc.number : SUB_Driver_Audio_Capture_SetSampleAttributes_0200
1435 * @tc.name : testCaptureSetSampleAttributes001
1436 * @tc.desc : ret = success
1437 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes001, Function | MediumTest | Level1)1438 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes001, Function | MediumTest | Level1)
1439 {
1440 struct AudioSampleAttributes attrs = {
1441 .type = AUDIO_IN_MEDIA,
1442 .interleaved = 0,
1443 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
1444 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
1445 .channelCount = TEST_CHANNEL_COUNT,
1446 .period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE,
1447 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT,
1448 .isBigEndian = false,
1449 .isSignedData = true,
1450 .startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount),
1451 .stopThreshold = INT_MAX,
1452 .silenceThreshold = BUFFER_LENTH,
1453 };
1454 int32_t ret = 0;
1455
1456 ret = capture_->SetSampleAttributes(capture_, &attrs);
1457 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1458 EXPECT_EQ(ret, HDF_SUCCESS);
1459 #else
1460 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1461 #endif
1462 }
1463
1464 /**
1465 * @tc.number : SUB_Driver_Audio_Capture_SetSampleAttributes_0300
1466 * @tc.name : testCaptureSetSampleAttributes002
1467 * @tc.desc : format is AUDIO_FORMAT_TYPE_PCM_8_BIT
1468 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes002, Function | MediumTest | Level2)1469 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes002, Function | MediumTest | Level2)
1470 {
1471 struct AudioSampleAttributes attrs = {
1472 .type = AUDIO_IN_MEDIA,
1473 .interleaved = 0,
1474 .format = AUDIO_FORMAT_TYPE_PCM_8_BIT,
1475 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
1476 .channelCount = TEST_CHANNEL_COUNT,
1477 .period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE,
1478 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT,
1479 .isBigEndian = false,
1480 .isSignedData = true,
1481 .startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount),
1482 .stopThreshold = INT_MAX,
1483 .silenceThreshold = BUFFER_LENTH,
1484 };
1485 int32_t ret = 0;
1486
1487 ret = capture_->SetSampleAttributes(capture_, &attrs);
1488 #if defined ALSA_LIB_MODE
1489 EXPECT_EQ(ret, HDF_SUCCESS);
1490 #elif defined DISPLAY_COMMUNITY
1491 EXPECT_EQ(ret, HDF_FAILURE);
1492 #else
1493 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1494 #endif
1495 }
1496
1497 /**
1498 * @tc.number : SUB_Driver_Audio_Capture_SetSampleAttributes_0400
1499 * @tc.name : testCaptureSetSampleAttributes003
1500 * @tc.desc : sampleRate is 44000
1501 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes003, Function | MediumTest | Level2)1502 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes003, Function | MediumTest | Level2)
1503 {
1504 struct AudioSampleAttributes attrs = {
1505 .type = AUDIO_IN_MEDIA,
1506 .interleaved = 0,
1507 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
1508 .sampleRate = 44000,
1509 .channelCount = TEST_CHANNEL_COUNT,
1510 .period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE,
1511 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT,
1512 .isBigEndian = false,
1513 .isSignedData = true,
1514 .startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount),
1515 .stopThreshold = INT_MAX,
1516 .silenceThreshold = BUFFER_LENTH,
1517 };
1518 int32_t ret = 0;
1519
1520 ret = capture_->SetSampleAttributes(capture_, &attrs);
1521 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1522 }
1523
1524 /**
1525 * @tc.number : SUB_Driver_Audio_Capture_SetSampleAttributes_0500
1526 * @tc.name : testCaptureSetSampleAttributes004
1527 * @tc.desc : channelCount is 3
1528 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes004, Function | MediumTest | Level2)1529 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes004, Function | MediumTest | Level2)
1530 {
1531 struct AudioSampleAttributes attrs = {
1532 .type = AUDIO_IN_MEDIA,
1533 .interleaved = 0,
1534 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
1535 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
1536 .channelCount = 3,
1537 .period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE,
1538 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT,
1539 .isBigEndian = false,
1540 .isSignedData = true,
1541 .startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount),
1542 .stopThreshold = INT_MAX,
1543 .silenceThreshold = BUFFER_LENTH,
1544 };
1545 int32_t ret = 0;
1546
1547 ret = capture_->SetSampleAttributes(capture_, &attrs);
1548 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1549 EXPECT_EQ(ret, HDF_FAILURE);
1550 #else
1551 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1552 #endif
1553 }
1554
1555 /**
1556 * @tc.number : SUB_Driver_Audio_Capture_SetSampleAttributes_0600
1557 * @tc.name : testCaptureSetSampleAttributes005
1558 * @tc.desc : channelCount is 1
1559 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes005, Function | MediumTest | Level2)1560 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes005, Function | MediumTest | Level2)
1561 {
1562 struct AudioSampleAttributes attrs = {
1563 .type = AUDIO_IN_MEDIA,
1564 .interleaved = 0,
1565 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
1566 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
1567 .channelCount = 1,
1568 .period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE,
1569 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT,
1570 .isBigEndian = false,
1571 .isSignedData = true,
1572 .startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount),
1573 .stopThreshold = INT_MAX,
1574 .silenceThreshold = BUFFER_LENTH,
1575 };
1576 int32_t ret = 0;
1577
1578 ret = capture_->SetSampleAttributes(capture_, &attrs);
1579 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1580 EXPECT_EQ(ret, HDF_FAILURE);
1581 #else
1582 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1583 #endif
1584 }
1585
1586 /**
1587 * @tc.number : SUB_Driver_Audio_Capture_SetSampleAttributes_0700
1588 * @tc.name : testCaptureSetSampleAttributes006
1589 * @tc.desc : channelCount is 0
1590 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes006, Function | MediumTest | Level2)1591 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes006, Function | MediumTest | Level2)
1592 {
1593 struct AudioSampleAttributes attrs = {
1594 .type = AUDIO_IN_MEDIA,
1595 .interleaved = 0,
1596 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
1597 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
1598 .channelCount = 0,
1599 .period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE,
1600 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT,
1601 .isBigEndian = false,
1602 .isSignedData = true,
1603 .startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount),
1604 .stopThreshold = INT_MAX,
1605 .silenceThreshold = BUFFER_LENTH,
1606 };
1607 int32_t ret = 0;
1608
1609 ret = capture_->SetSampleAttributes(capture_, &attrs);
1610 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1611 EXPECT_EQ(ret, HDF_FAILURE);
1612 #else
1613 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1614 #endif
1615 }
1616 /**
1617 * @tc.number : SUB_Driver_Audio_Capture_SetSampleAttributes_0800
1618 * @tc.name : testCaptureSetSampleAttributes007
1619 * @tc.desc : period is 3 * 1024
1620 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes007, Function | MediumTest | Level1)1621 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes007, Function | MediumTest | Level1)
1622 {
1623 struct AudioSampleAttributes attrs = {
1624 .type = AUDIO_IN_COMMUNICATION,
1625 .interleaved = 0,
1626 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
1627 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
1628 .channelCount = TEST_CHANNEL_COUNT,
1629 .period = 3 * 1024,
1630 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT,
1631 .isBigEndian = false,
1632 .isSignedData = true,
1633 .startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount),
1634 .stopThreshold = INT_MAX,
1635 .silenceThreshold = BUFFER_LENTH,
1636 };
1637 int32_t ret = 0;
1638
1639 ret = capture_->SetSampleAttributes(capture_, &attrs);
1640 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1641 EXPECT_EQ(ret, HDF_SUCCESS);
1642 #else
1643 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1644 #endif
1645 }
1646
1647 /**
1648 * @tc.number : SUB_Driver_Audio_Capture_SetSampleAttributes_0900
1649 * @tc.name : testCaptureSetSampleAttributes008
1650 * @tc.desc : period is 5 * 1024
1651 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes008, Function | MediumTest | Level1)1652 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes008, Function | MediumTest | Level1)
1653 {
1654 struct AudioSampleAttributes attrs = {
1655 .type = AUDIO_IN_MEDIA,
1656 .interleaved = 0,
1657 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
1658 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
1659 .channelCount = TEST_CHANNEL_COUNT,
1660 .period = 5 * 1024,
1661 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT,
1662 .isBigEndian = false,
1663 .isSignedData = true,
1664 .startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount),
1665 .stopThreshold = INT_MAX,
1666 .silenceThreshold = BUFFER_LENTH,
1667 };
1668 int32_t ret = 0;
1669
1670 ret = capture_->SetSampleAttributes(capture_, &attrs);
1671 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1672 EXPECT_EQ(ret, HDF_SUCCESS);
1673 #else
1674 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1675 #endif
1676 }
1677
1678 /**
1679 * @tc.number : SUB_Driver_Audio_Capture_SetSampleAttributes_1000
1680 * @tc.name : testCaptureSetSampleAttributes009
1681 * @tc.desc : frameSize is AUDIO_FORMAT_TYPE_PCM_16_BIT * 3
1682 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes009, Function | MediumTest | Level1)1683 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes009, Function | MediumTest | Level1)
1684 {
1685 struct AudioSampleAttributes attrs = {
1686 .type = AUDIO_IN_MEDIA,
1687 .interleaved = 0,
1688 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
1689 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
1690 .channelCount = TEST_CHANNEL_COUNT,
1691 .period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE,
1692 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * 3,
1693 .isBigEndian = false,
1694 .isSignedData = true,
1695 .startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount),
1696 .stopThreshold = INT_MAX,
1697 .silenceThreshold = BUFFER_LENTH,
1698 };
1699 int32_t ret = 0;
1700
1701 ret = capture_->SetSampleAttributes(capture_, &attrs);
1702 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1703 EXPECT_EQ(ret, HDF_SUCCESS);
1704 #else
1705 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1706 #endif
1707 }
1708
1709 /**
1710 * @tc.number : SUB_Driver_Audio_Capture_SetSampleAttributes_1100
1711 * @tc.name : testCaptureSetSampleAttributes010
1712 * @tc.desc : isBigEndian is true
1713 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes010, Function | MediumTest | Level1)1714 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes010, Function | MediumTest | Level1)
1715 {
1716 struct AudioSampleAttributes attrs = {
1717 .type = AUDIO_IN_MEDIA,
1718 .interleaved = 0,
1719 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
1720 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
1721 .channelCount = TEST_CHANNEL_COUNT,
1722 .period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE,
1723 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT,
1724 .isBigEndian = true,
1725 .isSignedData = true,
1726 .startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount),
1727 .stopThreshold = INT_MAX,
1728 .silenceThreshold = BUFFER_LENTH,
1729 };
1730 int32_t ret = 0;
1731
1732 ret = capture_->SetSampleAttributes(capture_, &attrs);
1733 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1734 EXPECT_EQ(ret, HDF_SUCCESS);
1735 #else
1736 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1737 #endif
1738 }
1739
1740 /**
1741 * @tc.number : SUB_Driver_Audio_Capture_SetSampleAttributes_1200
1742 * @tc.name : testCaptureSetSampleAttributes011
1743 * @tc.desc : isSignedData is false
1744 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes011, Function | MediumTest | Level1)1745 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes011, Function | MediumTest | Level1)
1746 {
1747 struct AudioSampleAttributes attrs = {
1748 .type = AUDIO_IN_MEDIA,
1749 .interleaved = 0,
1750 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
1751 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
1752 .channelCount = TEST_CHANNEL_COUNT,
1753 .period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE,
1754 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT,
1755 .isBigEndian = false,
1756 .isSignedData = false,
1757 .startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount),
1758 .stopThreshold = INT_MAX,
1759 .silenceThreshold = BUFFER_LENTH,
1760 };
1761 int32_t ret = 0;
1762
1763 ret = capture_->SetSampleAttributes(capture_, &attrs);
1764 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1765 EXPECT_EQ(ret, HDF_SUCCESS);
1766 #else
1767 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1768 #endif
1769 }
1770
1771 /**
1772 * @tc.number : SUB_Driver_Audio_Capture_SetSampleAttributes_1300
1773 * @tc.name : testCaptureSetSampleAttributes012
1774 * @tc.desc : startThreshold is (5 * 1024) / (attrs.format * attrs.channelCount)
1775 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes012, Function | MediumTest | Level1)1776 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes012, Function | MediumTest | Level1)
1777 {
1778 struct AudioSampleAttributes attrs = {
1779 .type = AUDIO_IN_MEDIA,
1780 .interleaved = 0,
1781 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
1782 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
1783 .channelCount = TEST_CHANNEL_COUNT,
1784 .period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE,
1785 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT,
1786 .isBigEndian = false,
1787 .isSignedData = true,
1788 .startThreshold = (5 * 1024) / (attrs.format * attrs.channelCount),
1789 .stopThreshold = INT_MAX,
1790 .silenceThreshold = BUFFER_LENTH,
1791 };
1792 int32_t ret = 0;
1793
1794 ret = capture_->SetSampleAttributes(capture_, &attrs);
1795 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1796 EXPECT_EQ(ret, HDF_SUCCESS);
1797 #else
1798 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1799 #endif
1800 }
1801
1802 /**
1803 * @tc.number : SUB_Driver_Audio_Capture_SetSampleAttributes_1400
1804 * @tc.name : testCaptureSetSampleAttributes013
1805 * @tc.desc : stopThreshold is INT_MAX - 1024
1806 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes013, Function | MediumTest | Level1)1807 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes013, Function | MediumTest | Level1)
1808 {
1809 struct AudioSampleAttributes attrs = {
1810 .type = AUDIO_IN_MEDIA,
1811 .interleaved = 0,
1812 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
1813 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
1814 .channelCount = TEST_CHANNEL_COUNT,
1815 .period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE,
1816 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT,
1817 .isBigEndian = false,
1818 .isSignedData = true,
1819 .startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount),
1820 .stopThreshold = INT_MAX - 1024,
1821 .silenceThreshold = BUFFER_LENTH,
1822 };
1823 int32_t ret = 0;
1824
1825 ret = capture_->SetSampleAttributes(capture_, &attrs);
1826 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1827 EXPECT_EQ(ret, HDF_SUCCESS);
1828 #else
1829 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1830 #endif
1831 }
1832
1833 /**
1834 * @tc.number : SUB_Driver_Audio_Capture_SetSampleAttributes_1500
1835 * @tc.name : testCaptureSetSampleAttributes014
1836 * @tc.desc : silenceThreshold is 1024
1837 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes014, Function | MediumTest | Level2)1838 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetSampleAttributes014, Function | MediumTest | Level2)
1839 {
1840 struct AudioSampleAttributes attrs = {
1841 .type = AUDIO_IN_MEDIA,
1842 .interleaved = 0,
1843 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
1844 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
1845 .channelCount = TEST_CHANNEL_COUNT,
1846 .period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE,
1847 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT,
1848 .isBigEndian = false,
1849 .isSignedData = true,
1850 .startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount),
1851 .stopThreshold = INT_MAX,
1852 .silenceThreshold = 1024,
1853 };
1854 int32_t ret = 0;
1855
1856 ret = capture_->SetSampleAttributes(capture_, &attrs);
1857 #if defined ALSA_LIB_MODE
1858 EXPECT_EQ(ret, HDF_SUCCESS);
1859 #elif defined DISPLAY_COMMUNITY
1860 EXPECT_EQ(ret, HDF_FAILURE);
1861 #else
1862 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1863 #endif
1864 }
1865
1866 /**
1867 * @tc.number : SUB_Driver_Audio_Capture_GetSampleAttributes_0300
1868 * @tc.name : testCaptureGetSampleAttributes001
1869 * @tc.desc : ret = success, the obtained property values are correct
1870 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetSampleAttributes001, Function | MediumTest | Level1)1871 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetSampleAttributes001, Function | MediumTest | Level1)
1872 {
1873 struct AudioSampleAttributes attrs = {
1874 .type = AUDIO_IN_MEDIA,
1875 .interleaved = 0,
1876 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
1877 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
1878 .channelCount = TEST_CHANNEL_COUNT,
1879 .period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE,
1880 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT,
1881 .isBigEndian = false,
1882 .isSignedData = true,
1883 .startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount),
1884 .stopThreshold = INT_MAX,
1885 .silenceThreshold = BUFFER_LENTH,
1886 };
1887 int32_t ret = 0;
1888
1889 ret = capture_->SetSampleAttributes(capture_, &attrs);
1890 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1891 EXPECT_EQ(ret, HDF_SUCCESS);
1892 #else
1893 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1894 #endif
1895 if (ret == HDF_SUCCESS) {
1896 ret = capture_->GetSampleAttributes(capture_, &attrs);
1897 EXPECT_EQ(ret, HDF_SUCCESS);
1898 EXPECT_EQ(attrs.format, AUDIO_FORMAT_TYPE_PCM_16_BIT);
1899 EXPECT_EQ(attrs.sampleRate, TEST_SAMPLE_RATE_MASK_48000);
1900 EXPECT_EQ(attrs.channelCount, TEST_CHANNEL_COUNT);
1901 EXPECT_EQ(attrs.interleaved, 0);
1902 EXPECT_EQ(attrs.type, AUDIO_IN_MEDIA);
1903 EXPECT_EQ(attrs.period, DEEP_BUFFER_CAPTURE_PERIOD_SIZE);
1904 EXPECT_EQ(attrs.frameSize, AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT);
1905 EXPECT_EQ(attrs.isBigEndian, false);
1906 EXPECT_EQ(attrs.isSignedData, true);
1907 EXPECT_EQ(attrs.startThreshold,
1908 DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount));
1909 EXPECT_EQ(attrs.stopThreshold, INT_MAX);
1910 EXPECT_EQ(attrs.silenceThreshold, BUFFER_LENTH);
1911 }
1912 }
1913
1914 /**
1915 * @tc.number : SUB_Driver_Audio_Capture_GetSampleAttributes_0400
1916 * @tc.name : testCaptureGetSampleAttributes002
1917 * @tc.desc : Change the isBigEndian, isSignedData, and stopThreshold attribute values to get attribute values correct
1918 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetSampleAttributes002, Function | MediumTest | Level1)1919 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetSampleAttributes002, Function | MediumTest | Level1)
1920 {
1921 struct AudioSampleAttributes attrsGet = {};
1922 struct AudioSampleAttributes attrsSet = {
1923 .type = AUDIO_IN_MEDIA,
1924 .interleaved = 0,
1925 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
1926 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
1927 .channelCount = TEST_CHANNEL_COUNT,
1928 .period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE,
1929 .frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT,
1930 .isBigEndian = true,
1931 .isSignedData = false,
1932 .startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrsSet.format * attrsSet.channelCount),
1933 .stopThreshold = 15 * 1024,
1934 .silenceThreshold = BUFFER_LENTH,
1935 };
1936 int32_t ret = 0;
1937
1938 ret = capture_->SetSampleAttributes(capture_, &attrsSet);
1939 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
1940 EXPECT_EQ(ret, HDF_SUCCESS);
1941 #else
1942 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
1943 #endif
1944
1945 if (ret == HDF_SUCCESS) {
1946 ret = capture_->GetSampleAttributes(capture_, &attrsGet);
1947 EXPECT_EQ(ret, HDF_SUCCESS);
1948 EXPECT_EQ(attrsGet.isBigEndian, true);
1949 EXPECT_EQ(attrsGet.isSignedData, false);
1950 EXPECT_EQ(attrsGet.stopThreshold, 15 * 1024);
1951 }
1952 }
1953
1954 /**
1955 * @tc.number : SUB_Driver_Audio_Capture_ReqMmapBuffer_0200
1956 * @tc.name : testCaptureReqMmapBuffer002
1957 * @tc.desc : capture_ is nullptr
1958 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureReqMmapBuffer002, Function | MediumTest | Level2)1959 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureReqMmapBuffer002, Function | MediumTest | Level2)
1960 {
1961 int32_t ret = 0;
1962 struct AudioMmapBufferDescriptor desc = {};
1963
1964 ret = capture_->ReqMmapBuffer(nullptr, MMAP_SUGGUEST_REQ_SIZE, &desc);
1965 EXPECT_NE(ret, HDF_SUCCESS);
1966 }
1967
1968 /**
1969 * @tc.number : SUB_Driver_Audio_Capture_ReqMmapBuffer_0300
1970 * @tc.name : testCaptureReqMmapBuffer003
1971 * @tc.desc : MMAP_SUGGUEST_REQ_SIZE is 0
1972 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureReqMmapBuffer003, Function | MediumTest | Level2)1973 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureReqMmapBuffer003, Function | MediumTest | Level2)
1974 {
1975 int32_t ret = 0;
1976 struct AudioMmapBufferDescriptor desc = {};
1977
1978 ret = capture_->ReqMmapBuffer(capture_, 0, &desc);
1979 EXPECT_NE(ret, HDF_SUCCESS);
1980 }
1981
1982 /**
1983 * @tc.number : SUB_Driver_Audio_Capture_ReqMmapBuffer_0400
1984 * @tc.name : testCaptureReqMmapBuffer004
1985 * @tc.desc : MMAP_SUGGUEST_REQ_SIZE is -1
1986 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureReqMmapBuffer004, Function | MediumTest | Level2)1987 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureReqMmapBuffer004, Function | MediumTest | Level2)
1988 {
1989 int32_t ret = 0;
1990 struct AudioMmapBufferDescriptor desc = {};
1991
1992 ret = capture_->ReqMmapBuffer(capture_, -1, &desc);
1993 EXPECT_NE(ret, HDF_SUCCESS);
1994 }
1995
1996 /**
1997 * @tc.number : SUB_Driver_Audio_Capture_ReqMmapBuffer_0500
1998 * @tc.name : testCaptureReqMmapBuffer005
1999 * @tc.desc : MMAP_SUGGUEST_REQ_SIZE is 2147483647
2000 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureReqMmapBuffer005, Function | MediumTest | Level2)2001 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureReqMmapBuffer005, Function | MediumTest | Level2)
2002 {
2003 int32_t ret = 0;
2004 struct AudioMmapBufferDescriptor desc = {};
2005
2006 ret = capture_->ReqMmapBuffer(capture_, 2147483647, &desc);
2007 EXPECT_NE(ret, HDF_SUCCESS);
2008 }
2009
2010 /**
2011 * @tc.number : SUB_Driver_Audio_Capture_ReqMmapBuffer_0600
2012 * @tc.name : testCaptureReqMmapBuffer006
2013 * @tc.desc : &desc is nullptr
2014 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureReqMmapBuffer006, Function | MediumTest | Level2)2015 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureReqMmapBuffer006, Function | MediumTest | Level2)
2016 {
2017 int32_t ret = 0;
2018
2019 ret = capture_->ReqMmapBuffer(capture_, MMAP_SUGGUEST_REQ_SIZE, nullptr);
2020 EXPECT_NE(ret, HDF_SUCCESS);
2021 }
2022
2023 /**
2024 * @tc.number : SUB_Driver_Audio_Capture_GetMmapPosition_0100
2025 * @tc.name : testCaptureGetMmapPosition001
2026 * @tc.desc : capture_ is nullptr
2027 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetMmapPosition001, Function | MediumTest | Level2)2028 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetMmapPosition001, Function | MediumTest | Level2)
2029 {
2030 int32_t ret = 0;
2031 uint64_t frames = 0;
2032 struct AudioTimeStamp time = {0};
2033
2034 ret = capture_->GetMmapPosition(nullptr, &frames, &time);
2035 EXPECT_NE(ret, HDF_SUCCESS);
2036 }
2037
2038 /**
2039 * @tc.number : SUB_Driver_Audio_Capture_GetMmapPosition_0200
2040 * @tc.name : testCaptureGetMmapPosition002
2041 * @tc.desc : &frames is nullptr
2042 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetMmapPosition002, Function | MediumTest | Level2)2043 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetMmapPosition002, Function | MediumTest | Level2)
2044 {
2045 int32_t ret = 0;
2046 struct AudioTimeStamp time = {0};
2047
2048 ret = capture_->GetMmapPosition(capture_, nullptr, &time);
2049 EXPECT_NE(ret, HDF_SUCCESS);
2050 }
2051
2052 /**
2053 * @tc.number : SUB_Driver_Audio_Capture_GetMmapPosition_0300
2054 * @tc.name : testCaptureGetMmapPosition003
2055 * @tc.desc : &time is nullptr
2056 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetMmapPosition003, Function | MediumTest | Level2)2057 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetMmapPosition003, Function | MediumTest | Level2)
2058 {
2059 int32_t ret = 0;
2060 uint64_t frames = 0;
2061
2062 ret = capture_->GetMmapPosition(capture_, &frames, nullptr);
2063 EXPECT_NE(ret, HDF_SUCCESS);
2064 }
2065
2066 /**
2067 * @tc.number : SUB_Driver_Audio_Capture_Pause_0500
2068 * @tc.name : testCapturePause001
2069 * @tc.desc : Direct call, ret != success
2070 */
HWTEST_F(AudioUtCaptureTestAdditional, testCapturePause001, Function | MediumTest | Level2)2071 HWTEST_F(AudioUtCaptureTestAdditional, testCapturePause001, Function | MediumTest | Level2)
2072 {
2073 int32_t ret = 0;
2074
2075 ret = capture_->Pause(capture_);
2076 EXPECT_NE(ret, HDF_SUCCESS);
2077 }
2078
2079 /**
2080 * @tc.number : SUB_Driver_Audio_Capture_Pause_0600
2081 * @tc.name : testCapturePause002
2082 * @tc.desc : After calling start and stop, pause is called
2083 */
HWTEST_F(AudioUtCaptureTestAdditional, testCapturePause002, Function | MediumTest | Level1)2084 HWTEST_F(AudioUtCaptureTestAdditional, testCapturePause002, Function | MediumTest | Level1)
2085 {
2086 int32_t ret = 0;
2087
2088 ret = capture_->Start(capture_);
2089 EXPECT_EQ(ret, HDF_SUCCESS);
2090 ret = capture_->Pause(capture_);
2091 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2092 EXPECT_EQ(ret, HDF_SUCCESS);
2093 #else
2094 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2095 #endif
2096 ret = capture_->Stop(capture_);
2097 EXPECT_EQ(ret, HDF_SUCCESS);
2098 }
2099
2100 /**
2101 * @tc.number : SUB_Driver_Audio_Capture_Stop_0300
2102 * @tc.name : testCaptureStop001
2103 * @tc.desc : Direct call, ret = success
2104 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureStop001, Function | MediumTest | Level1)2105 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureStop001, Function | MediumTest | Level1)
2106 {
2107 int32_t ret = 0;
2108
2109 ret = capture_->Stop(capture_);
2110 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2111 EXPECT_EQ(ret, HDF_SUCCESS);
2112 #else
2113 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2114 #endif
2115 }
2116
2117 /**
2118 * @tc.number : SUB_Driver_Audio_Capture_Stop_0400
2119 * @tc.name : testCaptureStop002
2120 * @tc.desc : Loop through start and stop 1000 times
2121 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureStop002, Function | MediumTest | Level1)2122 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureStop002, Function | MediumTest | Level1)
2123 {
2124 int32_t ret = 0;
2125
2126 for (int32_t i = 0; i < 1000; i++) {
2127 ret = capture_->Start(capture_);
2128 EXPECT_EQ(ret, HDF_SUCCESS);
2129 ret = capture_->Stop(capture_);
2130 EXPECT_EQ(ret, HDF_SUCCESS);
2131 }
2132 }
2133
2134 /**
2135 * @tc.number : SUB_Driver_Audio_Capture_Resume_0400
2136 * @tc.name : testCaptureResume001
2137 * @tc.desc : Loop through Pause and Resume 1000 times
2138 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureResume001, Function | MediumTest | Level1)2139 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureResume001, Function | MediumTest | Level1)
2140 {
2141 int32_t ret = 0;
2142
2143 ret = capture_->Start(capture_);
2144 EXPECT_EQ(ret, HDF_SUCCESS);
2145 for (int32_t i = 0; i < 1000; i++) {
2146 ret = capture_->Pause(capture_);
2147 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2148 EXPECT_EQ(ret, HDF_SUCCESS);
2149 #else
2150 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2151 #endif
2152 ret = capture_->Resume(capture_);
2153 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2154 EXPECT_EQ(ret, HDF_SUCCESS);
2155 #else
2156 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2157 #endif
2158 }
2159 ret = capture_->Stop(capture_);
2160 }
2161
2162 /**
2163 * @tc.number : SUB_Driver_Audio_Capture_TurnStandbyMode_0400
2164 * @tc.name : testCaptureTurnStandbyMode001
2165 * @tc.desc : Call start, then call TurnStandbyMode
2166 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureTurnStandbyMode001, Function | MediumTest | Level1)2167 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureTurnStandbyMode001, Function | MediumTest | Level1)
2168 {
2169 int32_t ret = 0;
2170
2171 ret = capture_->Start(capture_);
2172 EXPECT_EQ(ret, HDF_SUCCESS);
2173 sleep(1);
2174 ret = capture_->TurnStandbyMode(capture_);
2175 EXPECT_EQ(ret, HDF_SUCCESS);
2176 ret = capture_->Stop(capture_);
2177 EXPECT_EQ(ret, HDF_SUCCESS);
2178 }
2179
2180 /**
2181 * @tc.number : SUB_Driver_Audio_Capture_TurnStandbyMode_0500
2182 * @tc.name : testCaptureTurnStandbyMode002
2183 * @tc.desc : Call TurnStandbyMode first, then start and stop
2184 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureTurnStandbyMode002, Function | MediumTest | Level1)2185 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureTurnStandbyMode002, Function | MediumTest | Level1)
2186 {
2187 int32_t ret = 0;
2188
2189 ret = capture_->TurnStandbyMode(capture_);
2190 EXPECT_EQ(ret, HDF_SUCCESS);
2191 ret = capture_->Start(capture_);
2192 EXPECT_EQ(ret, HDF_SUCCESS);
2193 ret = capture_->Stop(capture_);
2194 }
2195
2196 /**
2197 * @tc.number : SUB_Driver_Audio_Capture_TurnStandbyMode_0600
2198 * @tc.name : testCaptureTurnStandbyMode003
2199 * @tc.desc : Loop call 1000 times
2200 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureTurnStandbyMode003, Function | MediumTest | Level1)2201 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureTurnStandbyMode003, Function | MediumTest | Level1)
2202 {
2203 int32_t ret = 0;
2204 for (int32_t i = 0; i < 1000; i++) {
2205 ret = capture_->TurnStandbyMode(capture_);
2206 EXPECT_EQ(ret, HDF_SUCCESS);
2207 }
2208 }
2209
2210 /**
2211 * @tc.number : SUB_Driver_Audio_Capture_AudioDevDump_0300
2212 * @tc.name : testCaptureAudioDevDump001
2213 * @tc.desc : Dump to binary file
2214 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump001, Function | MediumTest | Level1)2215 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump001, Function | MediumTest | Level1)
2216 {
2217 int32_t range = 3;
2218 int32_t ret = 0;
2219
2220 FILE *file = fopen("/data/local/tmp/CaptureDump.log", "wb+");
2221 ASSERT_NE(nullptr, file);
2222 int32_t fd = fileno(file);
2223 if (fd == -1) {
2224 fclose(file);
2225 ASSERT_NE(fd, -1);
2226 }
2227
2228 ret = capture_->AudioDevDump(capture_, range, fd);
2229 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2230 EXPECT_EQ(ret, HDF_SUCCESS);
2231 #else
2232 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2233 #endif
2234 fclose(file);
2235 }
2236
2237 /**
2238 * @tc.number : SUB_Driver_Audio_Capture_AudioDevDump_0400
2239 * @tc.name : testCaptureAudioDevDump002
2240 * @tc.desc : Dump to a text file
2241 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump002, Function | MediumTest | Level1)2242 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump002, Function | MediumTest | Level1)
2243 {
2244 int32_t range = 3;
2245 int32_t ret = 0;
2246
2247 FILE *file = fopen("/data/local/tmp/CaptureDump.log", "w+");
2248 ASSERT_NE(nullptr, file);
2249 int32_t fd = fileno(file);
2250 if (fd == -1) {
2251 fclose(file);
2252 ASSERT_NE(fd, -1);
2253 }
2254
2255 ret = capture_->AudioDevDump(capture_, range, fd);
2256 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2257 EXPECT_EQ(ret, HDF_SUCCESS);
2258 #else
2259 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2260 #endif
2261 fclose(file);
2262 }
2263
2264 /**
2265 * @tc.number : SUB_Driver_Audio_Capture_AudioDevDump_0500
2266 * @tc.name : testCaptureAudioDevDump003
2267 * @tc.desc : Dump to a read-only file
2268 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump003, Function | MediumTest | Level1)2269 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump003, Function | MediumTest | Level1)
2270 {
2271 int32_t range = 3;
2272 int32_t ret = 0;
2273
2274 FILE *file = fopen("/data/local/tmp/CaptureDump.log", "w");
2275 ASSERT_NE(nullptr, file);
2276 ret = fclose(file);
2277 ASSERT_EQ(0, ret);
2278
2279 file = fopen("/data/local/tmp/CaptureDump.log", "r");
2280 int32_t fd = fileno(file);
2281 if (fd == -1) {
2282 fclose(file);
2283 ASSERT_NE(fd, -1);
2284 }
2285
2286 ret = capture_->AudioDevDump(capture_, range, fd);
2287 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2288 EXPECT_EQ(ret, HDF_SUCCESS);
2289 #else
2290 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2291 #endif
2292 fclose(file);
2293 }
2294
2295 /**
2296 * @tc.number : SUB_Driver_Audio_Capture_AudioDevDump_0700
2297 * @tc.name : testCaptureAudioDevDump005
2298 * @tc.desc : capture_ is nullptr
2299 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump005, Function | MediumTest | Level2)2300 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump005, Function | MediumTest | Level2)
2301 {
2302 int32_t range = 4;
2303 int32_t ret = 0;
2304
2305 FILE *file = fopen("/data/local/tmp/CaptureDump.log", "wb+");
2306 ASSERT_NE(nullptr, file);
2307 int32_t fd = fileno(file);
2308 if (fd == -1) {
2309 fclose(file);
2310 ASSERT_NE(fd, -1);
2311 }
2312 ret = capture_->AudioDevDump(nullptr, range, fd);
2313 EXPECT_NE(ret, HDF_SUCCESS);
2314 fclose(file);
2315 }
2316
2317 /**
2318 * @tc.number : SUB_Driver_Audio_Capture_AudioDevDump_0800
2319 * @tc.name : testCaptureAudioDevDump006
2320 * @tc.desc : range is 2
2321 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump006, Function | MediumTest | Level1)2322 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump006, Function | MediumTest | Level1)
2323 {
2324 int32_t ret = 0;
2325
2326 FILE *file = fopen("/data/local/tmp/CaptureDump.log", "wb+");
2327 ASSERT_NE(nullptr, file);
2328 int32_t fd = fileno(file);
2329 if (fd == -1) {
2330 fclose(file);
2331 ASSERT_NE(fd, -1);
2332 }
2333 ret = capture_->AudioDevDump(capture_, 2, fd);
2334 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2335 EXPECT_EQ(ret, HDF_SUCCESS);
2336 #else
2337 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2338 #endif
2339 fclose(file);
2340 }
2341
2342 /**
2343 * @tc.number : SUB_Driver_Audio_Capture_AudioDevDump_0900
2344 * @tc.name : testCaptureAudioDevDump007
2345 * @tc.desc : range is -1
2346 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump007, Function | MediumTest | Level1)2347 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump007, Function | MediumTest | Level1)
2348 {
2349 int32_t ret = 0;
2350
2351 FILE *file = fopen("/data/local/tmp/CaptureDump.log", "wb+");
2352 ASSERT_NE(nullptr, file);
2353 int fd = fileno(file);
2354 if (fd == -1) {
2355 fclose(file);
2356 ASSERT_NE(fd, -1);
2357 }
2358 ret = capture_->AudioDevDump(capture_, -1, fd);
2359 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2360 EXPECT_EQ(ret, HDF_SUCCESS);
2361 #else
2362 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2363 #endif
2364 fclose(file);
2365 }
2366
2367 /**
2368 * @tc.number : SUB_Driver_Audio_Capture_AudioDevDump_1000
2369 * @tc.name : testCaptureAudioDevDump008
2370 * @tc.desc : range is 2147483647
2371 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump008, Function | MediumTest | Level1)2372 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump008, Function | MediumTest | Level1)
2373 {
2374 int32_t ret = 0;
2375
2376 FILE *file = fopen("/data/local/tmp/CaptureDump.log", "wb+");
2377 ASSERT_NE(nullptr, file);
2378 int32_t fd = fileno(file);
2379 if (fd == -1) {
2380 fclose(file);
2381 ASSERT_NE(fd, -1);
2382 }
2383 ret = capture_->AudioDevDump(capture_, 2147483647, fd);
2384 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2385 EXPECT_EQ(ret, HDF_SUCCESS);
2386 #else
2387 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2388 #endif
2389 fclose(file);
2390 }
2391
2392 /**
2393 * @tc.number : SUB_Driver_Audio_Capture_AudioDevDump_1100
2394 * @tc.name : testCaptureAudioDevDump009
2395 * @tc.desc : fd is -1
2396 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump009, Function | MediumTest | Level1)2397 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump009, Function | MediumTest | Level1)
2398 {
2399 int32_t range = 4;
2400 int32_t ret = 0;
2401
2402 ret = capture_->AudioDevDump(capture_, range, -1);
2403 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2404 EXPECT_EQ(ret, HDF_SUCCESS);
2405 #else
2406 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2407 #endif
2408 }
2409
2410 /**
2411 * @tc.number : SUB_Driver_Audio_Capture_AudioDevDump_1200
2412 * @tc.name : testCaptureAudioDevDump010
2413 * @tc.desc : fd is 2147483647
2414 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump010, Function | MediumTest | Level1)2415 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump010, Function | MediumTest | Level1)
2416 {
2417 int32_t range = 4;
2418 int32_t ret = 0;
2419
2420 ret = capture_->AudioDevDump(capture_, range, 2147483647);
2421 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2422 EXPECT_EQ(ret, HDF_SUCCESS);
2423 #else
2424 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2425 #endif
2426 }
2427
2428 /**
2429 * @tc.number : SUB_Driver_Audio_Capture_GetCurrentChannelId_0300
2430 * @tc.name : testCaptureGetCurrentChannelId001
2431 * @tc.desc : GetCurrentChannelId, Loop call 1000 times
2432 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetCurrentChannelId001, Function | MediumTest | Level1)2433 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetCurrentChannelId001, Function | MediumTest | Level1)
2434 {
2435 int32_t ret = HDF_SUCCESS;
2436 uint32_t channelId = 0;
2437 EXPECT_NE(capture_->GetCurrentChannelId, nullptr);
2438 for (int64_t i = 0; i < 1000; i++) {
2439 ret = capture_->GetCurrentChannelId(capture_, &channelId);
2440 EXPECT_EQ(ret, HDF_SUCCESS);
2441 }
2442 EXPECT_EQ(TEST_CHANNEL_COUNT, channelId);
2443 }
2444
2445 /**
2446 * @tc.number : SUB_Driver_Audio_Capture_SetExtraParams_0300
2447 * @tc.name : testCaptureSetExtraParams001
2448 * @tc.desc : SetExtraParams, Loop call 1000 times
2449 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetExtraParams001, Function | MediumTest | Level2)2450 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureSetExtraParams001, Function | MediumTest | Level2)
2451 {
2452 ASSERT_NE(capture_->SetExtraParams, nullptr);
2453
2454 int32_t ret = HDF_SUCCESS;
2455 for (int64_t i = 0; i < 1000; i++) {
2456 ret = capture_->SetExtraParams(nullptr, nullptr);
2457 EXPECT_NE(ret, HDF_SUCCESS);
2458 }
2459 }
2460
2461 /**
2462 * @tc.number : SUB_Driver_Audio_Capture_GetExtraParams_0300
2463 * @tc.name : testCaptureGetExtraParams001
2464 * @tc.desc : GetExtraParams, Loop call 1000 times
2465 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetExtraParams001, Function | MediumTest | Level2)2466 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetExtraParams001, Function | MediumTest | Level2)
2467 {
2468 ASSERT_NE(capture_->GetExtraParams, nullptr);
2469 char keyValueListReply[256] = {};
2470 uint32_t listLenth = 256;
2471
2472 int32_t ret = HDF_SUCCESS;
2473 for (int64_t i = 0; i < 1000; i++) {
2474 ret = capture_->GetExtraParams(nullptr, keyValueListReply, listLenth);
2475 EXPECT_NE(ret, HDF_SUCCESS);
2476
2477 ret = capture_->GetExtraParams(capture_, nullptr, listLenth);
2478 EXPECT_NE(ret, HDF_SUCCESS);
2479 }
2480 }
2481
2482 /**
2483 * @tc.number : SUB_Driver_Audio_Capture_Start_0300
2484 * @tc.name : testCaptureStart001
2485 * @tc.desc : Start, Loop call 1000 times
2486 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureStart001, Function | MediumTest | Level1)2487 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureStart001, Function | MediumTest | Level1)
2488 {
2489 ASSERT_NE(capture_->Start, nullptr);
2490
2491 int32_t ret = HDF_SUCCESS;
2492 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2493 for (int64_t i = 0; i < 1000; i++) {
2494 ret = capture_->Start(capture_);
2495 EXPECT_EQ(ret, HDF_SUCCESS);
2496 }
2497 #else
2498 ret = capture_->Start(capture_);
2499 EXPECT_EQ(ret, HDF_SUCCESS);
2500 for (int64_t i = 0; i < 999; i++) {
2501 ret = capture_->Start(capture_);
2502 EXPECT_EQ(ret, HDF_FAILURE);
2503 }
2504 #endif
2505 capture_->Stop(capture_);
2506 }
2507
2508 /**
2509 * @tc.number : SUB_Driver_Audio_Capture_Flush_0300
2510 * @tc.name : testCaptureFlush001
2511 * @tc.desc : Flush, Loop call 1000 times
2512 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureFlush001, Function | MediumTest | Level1)2513 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureFlush001, Function | MediumTest | Level1)
2514 {
2515 ASSERT_NE(capture_->Flush, nullptr);
2516
2517 int32_t ret = HDF_SUCCESS;
2518 for (int64_t i = 0; i < 1000; i++) {
2519 ret = capture_->Flush(capture_);
2520 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
2521 }
2522 }
2523
2524 /**
2525 * @tc.number : SUB_Driver_Audio_CaptureGetCapturePosition_0300
2526 * @tc.name : testAudioCaptureGetCapturePosition001
2527 * @tc.desc : test API GetCapturePosition 1000times
2528 */
HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetCapturePosition001, TestSize.Level1)2529 HWTEST_F(AudioUtCaptureTestAdditional, testAudioCaptureGetCapturePosition001, TestSize.Level1)
2530 {
2531 uint64_t frames;
2532 struct AudioTimeStamp time;
2533 uint32_t frameLen = (uint64_t)GetCaptureBufferSize();
2534 uint64_t requestBytes = frameLen;
2535 int i = 0;
2536 ASSERT_NE(capture_->CaptureFrame, nullptr);
2537 ASSERT_NE(capture_->GetCapturePosition, nullptr);
2538
2539 int32_t ret = capture_->Start(capture_);
2540 EXPECT_EQ(ret, HDF_SUCCESS);
2541
2542 int8_t *frame = (int8_t *)calloc(1, frameLen);
2543 EXPECT_NE(nullptr, frame);
2544
2545 ret = capture_->CaptureFrame(capture_, frame, &frameLen, &requestBytes);
2546 EXPECT_EQ(ret, HDF_SUCCESS);
2547 for (i = 0; i < 1000; i++) {
2548 ret = capture_->GetCapturePosition(capture_, &frames, &time);
2549 ASSERT_TRUE(ret == HDF_SUCCESS);
2550 }
2551
2552 capture_->Stop(capture_);
2553 if (frame != nullptr) {
2554 free(frame);
2555 frame = nullptr;
2556 }
2557 }
2558
2559 /**
2560 * @tc.number : SUB_Driver_Audio_Capture_GetFrameBufferSize_0300
2561 * @tc.name : testCaptureGetFrameBufferSize001
2562 * @tc.desc : GetFrameBufferSize, Loop call 1000 times
2563 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameBufferSize001, Function | MediumTest | Level2)2564 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureGetFrameBufferSize001, Function | MediumTest | Level2)
2565 {
2566 ASSERT_NE(capture_->GetFrameBufferSize, nullptr);
2567 uint64_t bufferSize = 0;
2568
2569 int32_t ret = HDF_SUCCESS;
2570 for (int64_t i = 0; i < 1000; i++) {
2571 ret = capture_->GetFrameBufferSize(capture_, &bufferSize);
2572 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2573 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2574 #else
2575 ASSERT_EQ(ret, HDF_ERR_INVALID_PARAM);
2576 #endif
2577 }
2578 }
2579
2580 /**
2581 * @tc.number : SUB_Driver_Audio_Capture_IsSupportsPauseAndResume_0300
2582 * @tc.name : testCaptureIsSupportsPauseAndResume001
2583 * @tc.desc : IsSupportsPauseAndResume, Loop call 1000 times
2584 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureIsSupportsPauseAndResume001, Function | MediumTest | Level2)2585 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureIsSupportsPauseAndResume001, Function | MediumTest | Level2)
2586 {
2587 ASSERT_NE(capture_->GetVersion, nullptr);
2588 bool supportPause = false;
2589 bool supportResume = false;
2590
2591 int32_t ret = HDF_SUCCESS;
2592 for (int64_t i = 0; i < 1000; i++) {
2593 ret = capture_->IsSupportsPauseAndResume(capture_, &supportPause, &supportResume);
2594 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2595 ASSERT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2596 #else
2597 ASSERT_EQ(ret, HDF_ERR_INVALID_PARAM);
2598 #endif
2599 }
2600 }
2601
2602 /**
2603 * @tc.number : SUB_Driver_Audio_Capture_ReqMmapBuffer_0100
2604 * @tc.name : testCaptureReqMmapBuffer001
2605 * @tc.desc : ret = success or ret = not_support
2606 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureReqMmapBuffer001, Function | MediumTest | Level2)2607 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureReqMmapBuffer001, Function | MediumTest | Level2)
2608 {
2609 int32_t ret = 0;
2610 struct AudioMmapBufferDescriptor desc = {};
2611
2612 ret = capture_->ReqMmapBuffer(capture_, MMAP_SUGGUEST_REQ_SIZE, &desc);
2613 EXPECT_NE(ret, HDF_SUCCESS);
2614 }
2615
2616 /**
2617 * @tc.number : SUB_Driver_Audio_Capture_AudioDevDump_0600
2618 * @tc.name : testCaptureAudioDevDump004
2619 * @tc.desc : range is 5
2620 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump004, Function | MediumTest | Level1)2621 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAudioDevDump004, Function | MediumTest | Level1)
2622 {
2623 int32_t range = 5;
2624 int32_t ret = 0;
2625
2626 FILE *file = fopen("/data/local/tmp/CaptureDump.log", "wb+");
2627 ASSERT_NE(nullptr, file);
2628 int32_t fd = fileno(file);
2629 if (fd == -1) {
2630 fclose(file);
2631 ASSERT_NE(fd, -1);
2632 }
2633
2634 ret = capture_->AudioDevDump(capture_, range, fd);
2635 #if defined DISPLAY_COMMUNITY || defined ALSA_LIB_MODE
2636 EXPECT_EQ(ret, HDF_SUCCESS);
2637 #else
2638 EXPECT_EQ(ret, HDF_ERR_NOT_SUPPORT);
2639 #endif
2640 fclose(file);
2641 }
2642
2643 /**
2644 * @tc.number : SUB_Driver_Audio_Capture_AddAudioEffect_0300
2645 * @tc.name : testCaptureAddAudioEffect001
2646 * @tc.desc : AddAudioEffect, Loop call 1000 times
2647 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAddAudioEffect001, Function | MediumTest | Level2)2648 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureAddAudioEffect001, Function | MediumTest | Level2)
2649 {
2650 ASSERT_NE(capture_->AddAudioEffect, nullptr);
2651 uint64_t effectId = 0;
2652
2653 int32_t ret = HDF_SUCCESS;
2654 for (int64_t i = 0; i < 1000; i++) {
2655 ret = capture_->AddAudioEffect(capture_, effectId);
2656 ASSERT_NE(ret, HDF_SUCCESS);
2657 }
2658 }
2659
2660 /**
2661 * @tc.number : SUB_Driver_Audio_Capture_RemoveAudioEffect_0300
2662 * @tc.name : testCaptureRemoveAudioEffect001
2663 * @tc.desc : RemoveAudioEffect, Loop call 1000 times
2664 */
HWTEST_F(AudioUtCaptureTestAdditional, testCaptureRemoveAudioEffect001, Function | MediumTest | Level2)2665 HWTEST_F(AudioUtCaptureTestAdditional, testCaptureRemoveAudioEffect001, Function | MediumTest | Level2)
2666 {
2667 ASSERT_NE(capture_->RemoveAudioEffect, nullptr);
2668 uint64_t effectId = 0;
2669
2670 int32_t ret = HDF_SUCCESS;
2671 for (int64_t i = 0; i < 1000; i++) {
2672 ret = capture_->RemoveAudioEffect(capture_, effectId);
2673 EXPECT_NE(ret, HDF_SUCCESS);
2674 }
2675 }
2676 } // namespace
2677