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