1 /*
2 * Copyright (c) 2023-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <climits>
18 #include "osal_mem.h"
19 #include "v5_0/iaudio_capture.h"
20 #include "v5_0/iaudio_manager.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
33 class AudioUtCaptureTest : public testing::Test {
34 public:
35 struct IAudioManager *manager_ = nullptr;;
36 struct IAudioAdapter *adapter_ = nullptr;
37 struct IAudioCapture *capture_ = nullptr;
38 uint32_t captureId_ = 0;
39 char *devDescriptorName_ = nullptr;
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 AudioUtCaptureTest::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 AudioUtCaptureTest::InitCaptureDevDesc(struct AudioDeviceDescriptor &devDesc)
81 {
82 devDesc.pins = (enum AudioPortPin)PIN_IN_MIC;
83 devDescriptorName_ = strdup("cardname");
84 devDesc.desc = devDescriptorName_;
85
86 ASSERT_NE(adapterDescs_, nullptr);
87 ASSERT_NE(adapterDescs_->ports, nullptr);
88 for (uint32_t index = 0; index < adapterDescs_->portsLen; index++) {
89 if (adapterDescs_->ports[index].dir == PORT_IN) {
90 devDesc.portId = adapterDescs_->ports[index].portId;
91 return;
92 }
93 }
94 }
95
InitCaptureAttrs(struct AudioSampleAttributes & attrs)96 void AudioUtCaptureTest::InitCaptureAttrs(struct AudioSampleAttributes &attrs)
97 {
98 attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
99 attrs.channelCount = TEST_CHANNEL_COUNT;
100 attrs.sampleRate = TEST_SAMPLE_RATE_MASK_48000;
101 attrs.interleaved = 0;
102 attrs.type = AUDIO_IN_MEDIA;
103 attrs.period = DEEP_BUFFER_CAPTURE_PERIOD_SIZE;
104 attrs.frameSize = AUDIO_FORMAT_TYPE_PCM_16_BIT * TEST_CHANNEL_COUNT;
105 attrs.isBigEndian = false;
106 attrs.isSignedData = true;
107 attrs.startThreshold = DEEP_BUFFER_CAPTURE_PERIOD_SIZE / (attrs.format * attrs.channelCount);
108 attrs.stopThreshold = INT_MAX;
109 attrs.silenceThreshold = BUFFER_LENTH;
110 }
111
FreeAdapterElements(struct AudioAdapterDescriptor * dataBlock,bool freeSelf)112 void AudioUtCaptureTest::FreeAdapterElements(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)
113 {
114 if (dataBlock == nullptr) {
115 return;
116 }
117
118 if (dataBlock->adapterName != nullptr) {
119 OsalMemFree(dataBlock->adapterName);
120 dataBlock->adapterName = nullptr;
121 }
122
123 if (dataBlock->ports != nullptr) {
124 OsalMemFree(dataBlock->ports);
125 }
126
127 if (freeSelf) {
128 OsalMemFree(dataBlock);
129 }
130 }
131
ReleaseAllAdapterDescs(struct AudioAdapterDescriptor ** descs,uint32_t descsLen)132 void AudioUtCaptureTest::ReleaseAllAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen)
133 {
134 if ((descsLen > 0) && (descs != nullptr) && ((*descs) != nullptr)) {
135 for (uint32_t i = 0; i < descsLen; i++) {
136 FreeAdapterElements(&(*descs)[i], false);
137 }
138 OsalMemFree(*descs);
139 *descs = nullptr;
140 }
141 }
142
SetUp()143 void AudioUtCaptureTest::SetUp()
144 {
145 uint32_t size = MAX_AUDIO_ADAPTER_NUM;
146 struct AudioDeviceDescriptor devDesc = {};
147 struct AudioSampleAttributes attrs = {};
148
149 manager_ = IAudioManagerGet(false);
150 ASSERT_NE(manager_, nullptr);
151
152 adapterDescs_ = (struct AudioAdapterDescriptor *)OsalMemCalloc(
153 sizeof(struct AudioAdapterDescriptor) * (MAX_AUDIO_ADAPTER_NUM));
154 ASSERT_NE(adapterDescs_, nullptr);
155
156 EXPECT_EQ(HDF_SUCCESS, manager_->GetAllAdapters(manager_, adapterDescs_, &size));
157 if (size > MAX_AUDIO_ADAPTER_NUM) {
158 ReleaseAllAdapterDescs(&adapterDescs_, MAX_AUDIO_ADAPTER_NUM);
159 ASSERT_LT(size, MAX_AUDIO_ADAPTER_NUM);
160 }
161
162 EXPECT_EQ(HDF_SUCCESS, manager_->LoadAdapter(manager_, &adapterDescs_[0], &adapter_));
163 if (adapter_ == nullptr) {
164 ReleaseAllAdapterDescs(&adapterDescs_, MAX_AUDIO_ADAPTER_NUM);
165 EXPECT_NE(adapter_, nullptr);
166 }
167
168 InitCaptureDevDesc(devDesc);
169 InitCaptureAttrs(attrs);
170 EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devDesc, &attrs, &capture_, &captureId_));
171 if (capture_ == nullptr) {
172 (void)manager_->UnloadAdapter(manager_, adapterDescs_[0].adapterName);
173 ReleaseAllAdapterDescs(&adapterDescs_, MAX_AUDIO_ADAPTER_NUM);
174 }
175 ASSERT_NE(capture_, nullptr);
176 }
177
TearDown()178 void AudioUtCaptureTest::TearDown()
179 {
180 ASSERT_NE(devDescriptorName_, nullptr);
181 free(devDescriptorName_);
182
183 ASSERT_NE(capture_, nullptr);
184 EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
185
186 ASSERT_NE(manager_, nullptr);
187 EXPECT_EQ(HDF_SUCCESS, manager_->UnloadAdapter(manager_, adapterDescs_[0].adapterName));
188 ReleaseAllAdapterDescs(&adapterDescs_, MAX_AUDIO_ADAPTER_NUM);
189
190 IAudioManagerRelease(manager_, false);
191 }
192
193 /* capture frame cases */
194 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_0100, TestSize.Level1)
195 {
196 uint32_t frameLen = (uint64_t)GetCaptureBufferSize();
197 uint64_t requestBytes = frameLen;
198 ASSERT_NE(capture_->CaptureFrame, nullptr);
199
200 int32_t ret = capture_->Start(capture_);
201 EXPECT_EQ(ret, HDF_SUCCESS);
202
203 int8_t *frame = (int8_t *)calloc(1, frameLen);
204 EXPECT_NE(nullptr, frame);
205
206 ret = capture_->CaptureFrame(capture_, frame, &frameLen, &requestBytes);
207 EXPECT_EQ(ret, HDF_SUCCESS);
208 capture_->Stop(capture_);
209
210 if (frame != nullptr) {
211 free(frame);
212 frame = nullptr;
213 }
214 }
215
216 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_0200, TestSize.Level1)
217 {
218 uint32_t invalidLen = -1;
219 uint64_t requestBytes = invalidLen;
220 ASSERT_NE(capture_->CaptureFrame, nullptr);
221
222 int32_t ret = capture_->Start(capture_);
223 EXPECT_EQ(ret, HDF_SUCCESS);
224
225 int8_t *frame = (int8_t *)calloc(1, sizeof(int));
226 EXPECT_NE(nullptr, frame);
227
228 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(nullptr, nullptr, nullptr, nullptr));
229 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(capture_, frame, nullptr, nullptr));
230 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(capture_, frame, &invalidLen, nullptr));
231 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(nullptr, frame, &invalidLen, &requestBytes));
232 EXPECT_NE(HDF_SUCCESS, capture_->CaptureFrame(capture_, frame, &invalidLen, &requestBytes));
233
234 capture_->Stop(capture_);
235 if (frame != nullptr) {
236 free(frame);
237 frame = nullptr;
238 }
239 }
240
241 /* capture getposition cases */
242 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_0300, TestSize.Level1)
243 {
244 uint64_t frames;
245 struct AudioTimeStamp time;
246 uint32_t frameLen = (uint64_t)GetCaptureBufferSize();
247 uint64_t requestBytes = frameLen;
248 ASSERT_NE(capture_->CaptureFrame, nullptr);
249 ASSERT_NE(capture_->GetCapturePosition, nullptr);
250
251 int32_t ret = capture_->Start(capture_);
252 EXPECT_EQ(ret, HDF_SUCCESS);
253
254 int8_t *frame = (int8_t *)calloc(1, frameLen);
255 EXPECT_NE(nullptr, frame);
256
257 ret = capture_->CaptureFrame(capture_, frame, &frameLen, &requestBytes);
258 EXPECT_EQ(ret, HDF_SUCCESS);
259
260 ret = capture_->GetCapturePosition(capture_, &frames, &time);
261 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
262
263 capture_->Stop(capture_);
264 if (frame != nullptr) {
265 free(frame);
266 frame = nullptr;
267 }
268 }
269
270 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_0400, TestSize.Level1)
271 {
272 int32_t ret;
273 uint64_t frames;
274 struct AudioTimeStamp time;
275 ASSERT_NE(capture_->GetCapturePosition, nullptr);
276
277 ret = capture_->GetCapturePosition(capture_, &frames, &time);
278 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
279
280 ret = capture_->GetCapturePosition(capture_, nullptr, nullptr);
281 EXPECT_NE(ret, HDF_SUCCESS);
282
283 ret = capture_->GetCapturePosition(capture_, &frames, nullptr);
284 EXPECT_NE(ret, HDF_SUCCESS);
285 }
286
287 /**
288 * @brief from here starts the control tests
289 */
290
291 /* capture start cases */
292 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_0500, TestSize.Level1)
293 {
294 ASSERT_NE(capture_->Start, nullptr);
295
296 int32_t ret = capture_->Start(capture_);
297 EXPECT_EQ(ret, HDF_SUCCESS);
298 capture_->Stop(capture_);
299 }
300
301 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_0600, TestSize.Level1)
302 {
303 ASSERT_NE(capture_->Start, nullptr);
304
305 int32_t ret = capture_->Start(nullptr);
306 EXPECT_NE(ret, HDF_SUCCESS);
307 capture_->Stop(capture_);
308 }
309
310 /* capture stop cases */
311 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_0700, TestSize.Level1)
312 {
313 ASSERT_NE(capture_->Start, nullptr);
314 ASSERT_NE(capture_->Stop, nullptr);
315
316 int32_t ret = capture_->Start(capture_);
317 EXPECT_EQ(ret, HDF_SUCCESS);
318
319 ret = capture_->Stop(capture_);
320 EXPECT_EQ(ret, HDF_SUCCESS);
321 }
322
323 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureStopException001, TestSize.Level1)
324 {
325 ASSERT_NE(capture_->Stop, nullptr);
326
327 int32_t ret = capture_->Stop(capture_);
328 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
329 }
330
331 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_0800, TestSize.Level1)
332 {
333 ASSERT_NE(capture_->Stop, nullptr);
334
335 int32_t ret = capture_->Stop(nullptr);
336 EXPECT_NE(ret, HDF_SUCCESS);
337 }
338
339 /* capture pause cases */
340 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_0900, TestSize.Level1)
341 {
342 ASSERT_NE(capture_->Pause, nullptr);
343 ASSERT_NE(capture_->Start, nullptr);
344
345 int32_t ret = capture_->Start(capture_);
346 EXPECT_EQ(ret, HDF_SUCCESS);
347
348 ret = capture_->Pause(capture_);
349 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
350 capture_->Stop(capture_);
351 }
352
353 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_1000, TestSize.Level1)
354 {
355 ASSERT_NE(capture_->Pause, nullptr);
356
357 int32_t ret = capture_->Pause(nullptr);
358 EXPECT_NE(ret, HDF_SUCCESS);
359 }
360
361 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_1100, TestSize.Level1)
362 {
363 ASSERT_NE(capture_->Pause, nullptr);
364 ASSERT_NE(capture_->Start, nullptr);
365
366 int32_t ret = capture_->Start(capture_);
367 EXPECT_EQ(ret, HDF_SUCCESS);
368
369 ret = capture_->Pause(capture_);
370 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
371
372 ret = capture_->Pause(capture_);
373 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
374 capture_->Stop(capture_);
375 }
376
377 /* capture resume cases */
378 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_1200, TestSize.Level1)
379 {
380 ASSERT_NE(capture_->Pause, nullptr);
381 ASSERT_NE(capture_->Resume, nullptr);
382 ASSERT_NE(capture_->Start, nullptr);
383 ASSERT_NE(capture_->Stop, nullptr);
384
385 int32_t ret = capture_->Start(capture_);
386 EXPECT_EQ(ret, HDF_SUCCESS);
387
388 ret = capture_->Pause(capture_);
389 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
390
391 ret = capture_->Resume(capture_);
392 EXPECT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
393
394 ret = capture_->Stop(capture_);
395 ASSERT_EQ(ret, HDF_SUCCESS);
396 }
397
398 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_1300, TestSize.Level1)
399 {
400 ASSERT_NE(capture_->Resume, nullptr);
401
402 int32_t ret = capture_->Resume(capture_);
403 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
404 }
405
406 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_1400, TestSize.Level1)
407 {
408 ASSERT_NE(capture_->Resume, nullptr);
409
410 int32_t ret = capture_->Resume(nullptr);
411 EXPECT_NE(ret, HDF_SUCCESS);
412 }
413
414 /* capture flush cases */
415 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_1500, TestSize.Level1)
416 {
417 ASSERT_NE(capture_->Flush, nullptr);
418
419 int32_t ret = capture_->Flush(capture_);
420 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
421 }
422
423 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_1600, TestSize.Level1)
424 {
425 ASSERT_NE(capture_->Flush, nullptr);
426
427 int32_t ret = capture_->Flush(nullptr);
428 EXPECT_NE(ret, HDF_SUCCESS);
429 }
430
431 /* capture TurnStandbyMode cases */
432 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_1700, TestSize.Level1)
433 {
434 ASSERT_NE(capture_->TurnStandbyMode, nullptr);
435 ASSERT_NE(capture_->Start, nullptr);
436
437 int32_t ret = capture_->Start(capture_);
438 EXPECT_EQ(ret, HDF_SUCCESS);
439
440 ret = capture_->TurnStandbyMode(capture_);
441 EXPECT_EQ(ret, HDF_SUCCESS);
442 capture_->Stop(capture_);
443 }
444
445 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_1800, TestSize.Level1)
446 {
447 ASSERT_NE(capture_->TurnStandbyMode, nullptr);
448
449 int32_t ret = capture_->TurnStandbyMode(nullptr);
450 EXPECT_NE(ret, HDF_SUCCESS);
451 }
452
453 /* capture AudioDevDump cases */
454 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_1900, TestSize.Level1)
455 {
456 ASSERT_NE(capture_->AudioDevDump, nullptr);
457
458 int32_t range = 4;
459 char pathBuf[] = "/data/local/tmp/CaptureDump.log";
460
461 FILE *file = fopen(pathBuf, "wb+");
462 ASSERT_NE(nullptr, file);
463 int fd = fileno(file);
464 if (fd == -1) {
465 fclose(file);
466 ASSERT_NE(fd, -1);
467 }
468
469 int32_t ret = capture_->AudioDevDump(capture_, range, fd);
470 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
471 fclose(file);
472 }
473
474 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_2000, TestSize.Level1)
475 {
476 ASSERT_NE(capture_->AudioDevDump, nullptr);
477 int32_t range = 4;
478
479 int32_t ret = capture_->AudioDevDump(nullptr, range, -1);
480 EXPECT_NE(ret, HDF_SUCCESS);
481 }
482
483 /**
484 * @brief here starts the volume test cases
485 */
486 /* capture SetMute cases */
487 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_2100, TestSize.Level1)
488 {
489 bool isSupport = false;
490 ASSERT_NE(capture_->SetMute, nullptr);
491 ASSERT_NE(capture_->GetMute, nullptr);
492
493 int32_t ret = capture_->SetMute(capture_, isSupport);
494 if (ret == HDF_SUCCESS) {
495 ret = capture_->GetMute(capture_, &isSupport);
496 ASSERT_EQ(isSupport, false);
497 } else if (ret == HDF_ERR_NOT_SUPPORT) {
498 ASSERT_TRUE(true);
499 } else {
500 ASSERT_TRUE(false);
501 }
502
503 isSupport = true;
504 ret = capture_->SetMute(capture_, isSupport);
505 if (ret == HDF_SUCCESS) {
506 ret = capture_->GetMute(capture_, &isSupport);
507 ASSERT_EQ(isSupport, true);
508 } else if (ret == HDF_ERR_NOT_SUPPORT) {
509 ASSERT_TRUE(true);
510 } else {
511 ASSERT_TRUE(false);
512 }
513 }
514
515 // set twice
516 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_2200, TestSize.Level1)
517 {
518 bool isSupport = true;
519 ASSERT_NE(capture_->SetMute, nullptr);
520 ASSERT_NE(capture_->GetMute, nullptr);
521
522 int32_t ret = capture_->SetMute(capture_, isSupport);
523 if (ret == HDF_SUCCESS) {
524 ret = capture_->GetMute(capture_, &isSupport);
525 ASSERT_EQ(isSupport, true);
526 } else if (ret == HDF_ERR_NOT_SUPPORT) {
527 ASSERT_TRUE(true);
528 } else {
529 ASSERT_TRUE(false);
530 }
531
532 ret = capture_->SetMute(capture_, isSupport);
533 if (ret == HDF_SUCCESS) {
534 ret = capture_->GetMute(capture_, &isSupport);
535 ASSERT_EQ(isSupport, true);
536 } else if (ret == HDF_ERR_NOT_SUPPORT) {
537 ASSERT_TRUE(true);
538 } else {
539 ASSERT_TRUE(false);
540 }
541 }
542
543 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_2300, TestSize.Level1)
544 {
545 EXPECT_NE(capture_->SetMute, nullptr);
546
547 int32_t ret = capture_->SetMute(nullptr, true);
548 EXPECT_NE(ret, HDF_SUCCESS);
549 }
550
551 /* capture GetMute cases */
552 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_2400, TestSize.Level1)
553 {
554 bool isSupport = true;
555 EXPECT_NE(capture_->GetMute, nullptr);
556
557 int32_t ret = capture_->GetMute(capture_, &isSupport);
558 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
559 }
560
561 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_2500, TestSize.Level1)
562 {
563 EXPECT_NE(capture_->GetMute, nullptr);
564
565 int32_t ret = capture_->GetMute(nullptr, nullptr);
566 EXPECT_NE(ret, HDF_SUCCESS);
567
568 ret = capture_->GetMute(capture_, nullptr);
569 EXPECT_NE(ret, HDF_SUCCESS);
570 }
571
572 /* capture SetVolume cases */
573 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_2600, TestSize.Level1)
574 {
575 float volume = 0.0;
576 EXPECT_NE(capture_->SetVolume, nullptr);
577 EXPECT_NE(capture_->GetVolume, nullptr);
578
579 int32_t ret = capture_->SetVolume(capture_, HALF_OF_MAX_VOLUME);
580 if (ret == HDF_SUCCESS) {
581 ret = capture_->GetVolume(capture_, &volume);
582 ASSERT_EQ(volume, HALF_OF_MAX_VOLUME);
583 } else if (ret == HDF_ERR_NOT_SUPPORT) {
584 ASSERT_TRUE(true);
585 } else {
586 ASSERT_TRUE(false);
587 }
588 }
589
590 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_2700, TestSize.Level1)
591 {
592 float exceptionVolume = 2.0;
593 EXPECT_NE(capture_->SetVolume, nullptr);
594
595 int32_t ret = capture_->SetVolume(capture_, exceptionVolume);
596 EXPECT_NE(ret, HDF_SUCCESS);
597
598 exceptionVolume = -3.0;
599 ret = capture_->SetVolume(capture_, exceptionVolume);
600 EXPECT_NE(ret, HDF_SUCCESS);
601 }
602
603 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_2800, TestSize.Level1)
604 {
605 EXPECT_NE(capture_->SetVolume, nullptr);
606
607 int32_t ret = capture_->SetVolume(nullptr, HALF_OF_MAX_VOLUME);
608 EXPECT_NE(ret, HDF_SUCCESS);
609 }
610
611 /* capture GetVolume cases */
612 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_2900, TestSize.Level1)
613 {
614 float volume = 0.0;
615 EXPECT_NE(capture_->GetVolume, nullptr);
616
617 int32_t ret = capture_->GetVolume(capture_, &volume);
618 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
619 }
620
621 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_3000, TestSize.Level1)
622 {
623 float volume = 0.0;
624 EXPECT_NE(capture_->GetVolume, nullptr);
625
626 int32_t ret = capture_->GetVolume(nullptr, nullptr);
627 EXPECT_NE(ret, HDF_SUCCESS);
628
629 ret = capture_->GetVolume(capture_, nullptr);
630 EXPECT_NE(ret, HDF_SUCCESS);
631
632 ret = capture_->GetVolume(nullptr, &volume);
633 EXPECT_NE(ret, HDF_SUCCESS);
634 }
635
636 /* capture GetGainThreshold cases */
637 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_3100, TestSize.Level1)
638 {
639 float bottom = 0;
640 float top = 0;
641 EXPECT_NE(capture_->GetGainThreshold, nullptr);
642
643 int32_t ret = capture_->GetGainThreshold(capture_, &bottom, &top);
644 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
645 }
646
647 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_3200, TestSize.Level1)
648 {
649 float bottom = 0;
650 float top = 0;
651 EXPECT_NE(capture_->GetGainThreshold, nullptr);
652
653 int32_t ret = capture_->GetGainThreshold(nullptr, &bottom, &top);
654 EXPECT_NE(ret, HDF_SUCCESS);
655
656 ret = capture_->GetGainThreshold(nullptr, nullptr, nullptr);
657 EXPECT_NE(ret, HDF_SUCCESS);
658
659 ret = capture_->GetGainThreshold(capture_, nullptr, nullptr);
660 EXPECT_NE(ret, HDF_SUCCESS);
661 }
662
663 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_3300, TestSize.Level1)
664 {
665 EXPECT_NE(capture_->SetGain, nullptr);
666
667 int32_t ret = capture_->SetGain(capture_, HALF_OF_MAX_VOLUME);
668 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
669 }
670
671 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_3400, TestSize.Level1)
672 {
673 EXPECT_NE(capture_->SetGain, nullptr);
674 float exceptionGain = -3.0;
675
676 int32_t ret = capture_->SetGain(capture_, exceptionGain);
677 EXPECT_NE(ret, HDF_SUCCESS);
678
679 ret = capture_->SetGain(nullptr, HALF_OF_MAX_VOLUME);
680 EXPECT_NE(ret, HDF_SUCCESS);
681 }
682
683 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_3500, TestSize.Level1)
684 {
685 EXPECT_NE(capture_->GetGain, nullptr);
686 float getGain;
687
688 int32_t ret = capture_->GetGain(capture_, &getGain);
689 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
690 }
691
692 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_3600, TestSize.Level1)
693 {
694 EXPECT_NE(capture_->SetGain, nullptr);
695 float exceptionGain = 2.0;
696
697 int32_t ret = capture_->GetGain(capture_, nullptr);
698 EXPECT_NE(ret, HDF_SUCCESS);
699
700 ret = capture_->GetGain(nullptr, &exceptionGain);
701 EXPECT_NE(ret, HDF_SUCCESS);
702 }
703
704 /**
705 * @brief here starts the attributes cases
706 */
707 /* capture GetSampleAttributes cases */
708 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_3700, TestSize.Level1)
709 {
710 struct AudioSampleAttributes attrs = {};
711 EXPECT_NE(capture_->GetSampleAttributes, nullptr);
712
713 int32_t ret = capture_->GetSampleAttributes(capture_, &attrs);
714 EXPECT_EQ(ret, HDF_SUCCESS);
715 }
716
717 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_3800, TestSize.Level1)
718 {
719 struct AudioSampleAttributes attrs = {};
720 EXPECT_NE(capture_->GetSampleAttributes, nullptr);
721
722 int32_t ret = capture_->GetSampleAttributes(nullptr, &attrs);
723 EXPECT_NE(ret, HDF_SUCCESS);
724
725 ret = capture_->GetSampleAttributes(capture_, nullptr);
726 EXPECT_NE(ret, HDF_SUCCESS);
727 }
728
729 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_3900, TestSize.Level1)
730 {
731 struct AudioSampleAttributes attrs = {
732 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
733 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
734 .channelCount = TEST_CHANNEL_COUNT,
735 };
736 EXPECT_NE(capture_->SetSampleAttributes, nullptr);
737
738 int32_t ret = capture_->SetSampleAttributes(capture_, &attrs);
739 #if defined ALSA_LIB_MODE
740 EXPECT_EQ(ret, HDF_SUCCESS);
741 #else
742 EXPECT_NE(ret, HDF_SUCCESS);
743 #endif
744 ret = capture_->SetSampleAttributes(capture_, nullptr);
745 EXPECT_NE(ret, HDF_SUCCESS);
746
747 ret = capture_->SetSampleAttributes(nullptr, &attrs);
748 EXPECT_NE(ret, HDF_SUCCESS);
749 }
750
751 /* capture GetCurrentChannelId cases */
752 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_4000, TestSize.Level1)
753 {
754 int32_t ret = HDF_SUCCESS;
755 uint32_t channelId = 0;
756 EXPECT_NE(capture_->GetCurrentChannelId, nullptr);
757
758 ret = capture_->GetCurrentChannelId(capture_, &channelId);
759 EXPECT_EQ(ret, HDF_SUCCESS);
760 EXPECT_EQ(TEST_CHANNEL_COUNT, channelId);
761 }
762
763 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_4100, TestSize.Level1)
764 {
765 int32_t ret = HDF_SUCCESS;
766 uint32_t channelId = 0;
767 EXPECT_NE(capture_->GetCurrentChannelId, nullptr);
768
769 ret = capture_->GetCurrentChannelId(capture_, nullptr);
770 EXPECT_NE(ret, HDF_SUCCESS);
771
772 ret = capture_->GetCurrentChannelId(nullptr, &channelId);
773 EXPECT_NE(ret, HDF_SUCCESS);
774 }
775
776 /* capture SetExtraParams cases */
777 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_4200, TestSize.Level1)
778 {
779 EXPECT_NE(capture_->SetExtraParams, nullptr);
780 EXPECT_NE(capture_->GetExtraParams, nullptr);
781
782 char kvList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
783 char keyValueListReply[256] = {};
784 uint32_t listLenth = 256;
785 size_t index = 1;
786
787 int32_t ret = capture_->SetExtraParams(capture_, kvList);
788 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
789
790 ret = capture_->GetExtraParams(capture_, keyValueListReply, listLenth);
791 // the vendor can not supply this method，one it not supply returns HDF_ERR_INVALID_PARAM
792 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
793
794 std::string strGetValue = keyValueListReply;
795 size_t indexAttr = strGetValue.find("attr-frame-count");
796 size_t indexFlag = strGetValue.rfind(";");
797
798 if (indexAttr != string::npos && indexFlag != string::npos) {
799 strGetValue.replace(indexAttr, indexFlag - indexAttr + index, "");
800 }
801 }
802
803 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_4300, TestSize.Level1)
804 {
805 ASSERT_NE(capture_->SetExtraParams, nullptr);
806
807 int32_t ret = capture_->SetExtraParams(nullptr, nullptr);
808 EXPECT_NE(ret, HDF_SUCCESS);
809 }
810
811 /* capture GetExtraParams cases */
812 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_4400, TestSize.Level1)
813 {
814 ASSERT_NE(capture_->GetExtraParams, nullptr);
815 char keyValueListReply[256] = {};
816 uint32_t listLenth = 256;
817
818 int32_t ret = capture_->GetExtraParams(capture_, keyValueListReply, listLenth);
819 // the vendor can not supply this method，one it not supply returns HDF_ERR_INVALID_PARAM
820 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
821 }
822
823 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_4500, TestSize.Level1)
824 {
825 ASSERT_NE(capture_->GetExtraParams, nullptr);
826 char keyValueListReply[256] = {};
827 uint32_t listLenth = 256;
828
829 int32_t ret = capture_->GetExtraParams(nullptr, keyValueListReply, listLenth);
830 EXPECT_NE(ret, HDF_SUCCESS);
831
832 ret = capture_->GetExtraParams(capture_, nullptr, listLenth);
833 EXPECT_NE(ret, HDF_SUCCESS);
834 }
835
836 /* capture selectsene cases */
837 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_4600, TestSize.Level1)
838 {
839 ASSERT_NE(capture_->SelectScene, nullptr);
840 struct AudioSceneDescriptor sceneDesc = {};
841 sceneDesc.desc.pins = PIN_IN_MIC;
842 sceneDesc.desc.desc = strdup("mic");
843 sceneDesc.scene.id = AUDIO_IN_CALL;
844
845 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
846 EXPECT_EQ(ret, HDF_SUCCESS);
847 free(sceneDesc.desc.desc);
848 }
849
850 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_4700, TestSize.Level1)
851 {
852 ASSERT_NE(capture_->SelectScene, nullptr);
853 struct AudioSceneDescriptor sceneDesc = {};
854 sceneDesc.scene.id = AUDIO_IN_CALL;
855
856 int32_t ret = capture_->SelectScene(capture_, nullptr);
857 ASSERT_NE(ret, HDF_SUCCESS);
858
859 ret = capture_->SelectScene(nullptr, &sceneDesc);
860 ASSERT_NE(ret, HDF_SUCCESS);
861 }
862
863 /* capture get version cases */
864 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_4800, TestSize.Level1)
865 {
866 ASSERT_NE(capture_->GetVersion, nullptr);
867 uint32_t majorVer;
868 uint32_t minorVer;
869 ASSERT_EQ(HDF_SUCCESS, capture_->GetVersion(capture_, &majorVer, &minorVer));
870 EXPECT_EQ(IAUDIO_MANAGER_MAJOR_VERSION, majorVer);
871 EXPECT_EQ(IAUDIO_MANAGER_MINOR_VERSION, minorVer);
872 }
873
874 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_4900, TestSize.Level1)
875 {
876 ASSERT_NE(capture_->GetVersion, nullptr);
877 uint32_t majorVer;
878 uint32_t minorVer;
879 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, capture_->GetVersion(nullptr, &majorVer, &minorVer));
880 }
881
882 /* capture support pause and resume cases */
883 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_5000, TestSize.Level1)
884 {
885 ASSERT_NE(capture_->GetVersion, nullptr);
886 bool supportPause = false;
887 bool supportResume = false;
888
889 int32_t ret = capture_->IsSupportsPauseAndResume(capture_, &supportPause, &supportResume);
890 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
891 }
892
893 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_5100, TestSize.Level1)
894 {
895 ASSERT_NE(capture_->IsSupportsPauseAndResume, nullptr);
896 bool supportPause = false;
897 bool supportResume = false;
898
899 int32_t ret = capture_->IsSupportsPauseAndResume(nullptr, &supportPause, &supportResume);
900 ASSERT_NE(ret, HDF_SUCCESS);
901
902 ret = capture_->IsSupportsPauseAndResume(capture_, nullptr, &supportResume);
903 ASSERT_NE(ret, HDF_SUCCESS);
904
905 ret = capture_->IsSupportsPauseAndResume(capture_, &supportPause, nullptr);
906 ASSERT_NE(ret, HDF_SUCCESS);
907 }
908
909 /* capture GetFrameBufferSize cases */
910 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_5200, TestSize.Level1)
911 {
912 ASSERT_NE(capture_->GetFrameBufferSize, nullptr);
913 uint64_t bufferSize = 0;
914
915 int32_t ret = capture_->GetFrameBufferSize(capture_, &bufferSize);
916 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
917 }
918
919 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_5300, TestSize.Level1)
920 {
921 ASSERT_NE(capture_->GetFrameBufferSize, nullptr);
922 uint64_t bufferSize = 0;
923
924 int32_t ret = capture_->GetFrameBufferSize(nullptr, &bufferSize);
925 ASSERT_NE(ret, HDF_SUCCESS);
926
927 ret = capture_->GetFrameBufferSize(capture_, nullptr);
928 ASSERT_NE(ret, HDF_SUCCESS);
929 }
930
931 /* capture AddAudioEffect cases */
932 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_5400, TestSize.Level1)
933 {
934 ASSERT_NE(capture_->AddAudioEffect, nullptr);
935 uint64_t effectId = 0;
936
937 int32_t ret = capture_->AddAudioEffect(capture_, effectId);
938 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
939 }
940
941 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_5500, TestSize.Level1)
942 {
943 ASSERT_NE(capture_->AddAudioEffect, nullptr);
944 uint64_t effectId = -1;
945
946 int32_t ret = capture_->AddAudioEffect(nullptr, effectId);
947 ASSERT_NE(ret, HDF_SUCCESS);
948
949 ret = capture_->AddAudioEffect(capture_, effectId);
950 ASSERT_NE(ret, HDF_SUCCESS);
951 }
952
953 /* capture RemoveAudioEffect cases */
954 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_5600, TestSize.Level1)
955 {
956 ASSERT_NE(capture_->RemoveAudioEffect, nullptr);
957 uint64_t effectId = 0;
958
959 int32_t ret = capture_->RemoveAudioEffect(capture_, effectId);
960 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
961 }
962
963 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_5700, TestSize.Level1)
964 {
965 ASSERT_NE(capture_->RemoveAudioEffect, nullptr);
966 uint64_t effectId = -1;
967
968 int32_t ret = capture_->RemoveAudioEffect(nullptr, effectId);
969 ASSERT_NE(ret, HDF_SUCCESS);
970
971 ret = capture_->RemoveAudioEffect(capture_, effectId);
972 ASSERT_NE(ret, HDF_SUCCESS);
973 }
974
975 /* capture CheckSceneCapability cases */
976 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_5800, TestSize.Level1)
977 {
978 ASSERT_NE(capture_->CheckSceneCapability, nullptr);
979 struct AudioSceneDescriptor sceneDesc = {};
980 sceneDesc.desc.pins = PIN_IN_MIC;
981 sceneDesc.desc.desc = strdup("mic");
982 sceneDesc.scene.id = AUDIO_IN_COMMUNICATION;
983 bool isSupport = false;
984
985 int32_t ret = capture_->CheckSceneCapability(capture_, &sceneDesc, &isSupport);
986 EXPECT_EQ(ret, HDF_SUCCESS);
987 free(sceneDesc.desc.desc);
988 }
989
990 HWTEST_F(AudioUtCaptureTest, SUB_Driver_Audio_CaptureHdi_5900, TestSize.Level1)
991 {
992 ASSERT_NE(capture_->CheckSceneCapability, nullptr);
993 struct AudioSceneDescriptor sceneDesc = {};
994 sceneDesc.scene.id = AUDIO_IN_COMMUNICATION;
995 bool isSupport = false;
996
997 int32_t ret = capture_->CheckSceneCapability(nullptr, &sceneDesc, &isSupport);
998 ASSERT_NE(ret, HDF_SUCCESS);
999
1000 ret = capture_->CheckSceneCapability(capture_, nullptr, &isSupport);
1001 ASSERT_NE(ret, HDF_SUCCESS);
1002
1003 ret = capture_->CheckSceneCapability(capture_, &sceneDesc, nullptr);
1004 ASSERT_NE(ret, HDF_SUCCESS);
1005 }
1006 } // end of name space
1007