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 "v1_0/iaudio_capture.h"
20 #include "v1_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 if (frame != nullptr) {
237 free(frame);
238 frame = nullptr;
239 }
240 }
241
242 /* capture getposition cases */
243 HWTEST_F(AudioUtCaptureTest, HdfAudioGetCapturePosition001, TestSize.Level1)
244 {
245 uint64_t frames;
246 struct AudioTimeStamp time;
247 uint32_t frameLen = (uint64_t)GetCaptureBufferSize();
248 uint64_t requestBytes = frameLen;
249 ASSERT_NE(capture_->CaptureFrame, nullptr);
250 ASSERT_NE(capture_->GetCapturePosition, nullptr);
251
252 int32_t ret = capture_->Start(capture_);
253 EXPECT_EQ(ret, HDF_SUCCESS);
254
255 int8_t *frame = (int8_t *)calloc(1, frameLen);
256 EXPECT_NE(nullptr, frame);
257
258 ret = capture_->CaptureFrame(capture_, frame, &frameLen, &requestBytes);
259 EXPECT_EQ(ret, HDF_SUCCESS);
260
261 ret = capture_->GetCapturePosition(capture_, &frames, &time);
262 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
263
264 capture_->Stop(capture_);
265 if (frame != nullptr) {
266 free(frame);
267 frame = nullptr;
268 }
269 }
270
271 HWTEST_F(AudioUtCaptureTest, HdfAudioGetCapturePositionExceptions001, TestSize.Level1)
272 {
273 int32_t ret;
274 uint64_t frames;
275 struct AudioTimeStamp time;
276 ASSERT_NE(capture_->GetCapturePosition, nullptr);
277
278 ret = capture_->GetCapturePosition(capture_, &frames, &time);
279 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
280
281 ret = capture_->GetCapturePosition(capture_, nullptr, nullptr);
282 EXPECT_NE(ret, HDF_SUCCESS);
283
284 ret = capture_->GetCapturePosition(capture_, &frames, nullptr);
285 EXPECT_NE(ret, HDF_SUCCESS);
286 }
287
288 /**
289 * @brief from here starts the control tests
290 */
291
292 /* capture start cases */
293 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureStart001, TestSize.Level1)
294 {
295 ASSERT_NE(capture_->Start, nullptr);
296
297 int32_t ret = capture_->Start(capture_);
298 EXPECT_EQ(ret, HDF_SUCCESS);
299 }
300
301 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureException001, TestSize.Level1)
302 {
303 ASSERT_NE(capture_->Start, nullptr);
304
305 int32_t ret = capture_->Start(nullptr);
306 EXPECT_NE(ret, HDF_SUCCESS);
307 }
308
309 /* capture stop cases */
310 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureStop001, TestSize.Level1)
311 {
312 ASSERT_NE(capture_->Start, nullptr);
313 ASSERT_NE(capture_->Stop, nullptr);
314
315 int32_t ret = capture_->Start(capture_);
316 EXPECT_EQ(ret, HDF_SUCCESS);
317
318 ret = capture_->Stop(capture_);
319 EXPECT_EQ(ret, HDF_SUCCESS);
320 }
321
322 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureStopException002, TestSize.Level1)
323 {
324 ASSERT_NE(capture_->Stop, nullptr);
325
326 int32_t ret = capture_->Stop(nullptr);
327 EXPECT_NE(ret, HDF_SUCCESS);
328 }
329
330 /* capture pause cases */
331 HWTEST_F(AudioUtCaptureTest, HdfAudioCapturePause001, TestSize.Level1)
332 {
333 ASSERT_NE(capture_->Pause, nullptr);
334 ASSERT_NE(capture_->Start, nullptr);
335
336 int32_t ret = capture_->Start(capture_);
337 EXPECT_EQ(ret, HDF_SUCCESS);
338
339 ret = capture_->Pause(capture_);
340 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
341 }
342
343 HWTEST_F(AudioUtCaptureTest, HdfAudioCapturePauseException001, TestSize.Level1)
344 {
345 ASSERT_NE(capture_->Pause, nullptr);
346
347 int32_t ret = capture_->Pause(nullptr);
348 EXPECT_NE(ret, HDF_SUCCESS);
349 }
350
351 HWTEST_F(AudioUtCaptureTest, HdfAudioCapturePauseException002, TestSize.Level1)
352 {
353 ASSERT_NE(capture_->Pause, nullptr);
354 ASSERT_NE(capture_->Start, nullptr);
355
356 int32_t ret = capture_->Start(capture_);
357 EXPECT_EQ(ret, HDF_SUCCESS);
358
359 ret = capture_->Pause(capture_);
360 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
361
362 ret = capture_->Pause(capture_);
363 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
364 }
365
366 /* capture resume cases */
367 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureResume001, TestSize.Level1)
368 {
369 ASSERT_NE(capture_->Pause, nullptr);
370 ASSERT_NE(capture_->Resume, nullptr);
371 ASSERT_NE(capture_->Start, nullptr);
372 ASSERT_NE(capture_->Stop, nullptr);
373
374 int32_t ret = capture_->Start(capture_);
375 ASSERT_EQ(ret, HDF_SUCCESS);
376
377 ret = capture_->Pause(capture_);
378 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
379
380 ret = capture_->Resume(capture_);
381 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
382
383 ret = capture_->Stop(capture_);
384 ASSERT_EQ(ret, HDF_SUCCESS);
385 }
386
387 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureResumeException001, TestSize.Level1)
388 {
389 ASSERT_NE(capture_->Resume, nullptr);
390
391 int32_t ret = capture_->Resume(capture_);
392 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
393 }
394
395 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureResumeException002, TestSize.Level1)
396 {
397 ASSERT_NE(capture_->Resume, nullptr);
398
399 int32_t ret = capture_->Resume(nullptr);
400 EXPECT_NE(ret, HDF_SUCCESS);
401 }
402
403 /* capture flush cases */
404 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureFlush001, TestSize.Level1)
405 {
406 ASSERT_NE(capture_->Flush, nullptr);
407
408 int32_t ret = capture_->Flush(capture_);
409 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
410 }
411
412 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureFlushException001, TestSize.Level1)
413 {
414 ASSERT_NE(capture_->Flush, nullptr);
415
416 int32_t ret = capture_->Flush(nullptr);
417 EXPECT_NE(ret, HDF_SUCCESS);
418 }
419
420 /* capture TurnStandbyMode cases */
421 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureTurnStandbyMode001, TestSize.Level1)
422 {
423 ASSERT_NE(capture_->TurnStandbyMode, nullptr);
424 ASSERT_NE(capture_->Start, nullptr);
425
426 int32_t ret = capture_->Start(capture_);
427 EXPECT_EQ(ret, HDF_SUCCESS);
428
429 ret = capture_->TurnStandbyMode(capture_);
430 EXPECT_EQ(ret, HDF_SUCCESS);
431 }
432
433 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureTurnStandbyModeException001, TestSize.Level1)
434 {
435 ASSERT_NE(capture_->TurnStandbyMode, nullptr);
436
437 int32_t ret = capture_->TurnStandbyMode(nullptr);
438 EXPECT_NE(ret, HDF_SUCCESS);
439 }
440
441 /* capture AudioDevDump cases */
442 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureAudioDevDump001, TestSize.Level1)
443 {
444 ASSERT_NE(capture_->AudioDevDump, nullptr);
445
446 int32_t range = 4;
447 char pathBuf[] = "/data/CaptureDump.log";
448
449 FILE *file = fopen(pathBuf, "wb+");
450 ASSERT_NE(nullptr, file);
451 int fd = fileno(file);
452 if (fd == -1) {
453 fclose(file);
454 ASSERT_NE(fd, -1);
455 }
456
457 int32_t ret = capture_->AudioDevDump(capture_, range, fd);
458 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
459 fclose(file);
460 }
461
462 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureAudioDevDumpExption001, TestSize.Level1)
463 {
464 ASSERT_NE(capture_->AudioDevDump, nullptr);
465 int32_t range = 4;
466
467 int32_t ret = capture_->AudioDevDump(nullptr, range, -1);
468 EXPECT_NE(ret, HDF_SUCCESS);
469 }
470
471 /**
472 * @brief here starts the volume test cases
473 */
474 /* capture SetMute cases */
475 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureSetMute001, TestSize.Level1)
476 {
477 bool isSupport = false;
478 ASSERT_NE(capture_->SetMute, nullptr);
479 ASSERT_NE(capture_->GetMute, nullptr);
480
481 int32_t ret = capture_->SetMute(capture_, isSupport);
482 if (ret == HDF_SUCCESS) {
483 ret = capture_->GetMute(capture_, &isSupport);
484 ASSERT_EQ(isSupport, false);
485 } else if (ret == HDF_ERR_NOT_SUPPORT) {
486 ASSERT_TRUE(true);
487 } else {
488 ASSERT_TRUE(false);
489 }
490
491 isSupport = true;
492 ret = capture_->SetMute(capture_, isSupport);
493 if (ret == HDF_SUCCESS) {
494 ret = capture_->GetMute(capture_, &isSupport);
495 ASSERT_EQ(isSupport, true);
496 } else if (ret == HDF_ERR_NOT_SUPPORT) {
497 ASSERT_TRUE(true);
498 } else {
499 ASSERT_TRUE(false);
500 }
501 }
502
503 // set twice
504 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureSetMuteException001, TestSize.Level1)
505 {
506 bool isSupport = true;
507 ASSERT_NE(capture_->SetMute, nullptr);
508 ASSERT_NE(capture_->GetMute, nullptr);
509
510 int32_t ret = capture_->SetMute(capture_, isSupport);
511 if (ret == HDF_SUCCESS) {
512 ret = capture_->GetMute(capture_, &isSupport);
513 ASSERT_EQ(isSupport, true);
514 } else if (ret == HDF_ERR_NOT_SUPPORT) {
515 ASSERT_TRUE(true);
516 } else {
517 ASSERT_TRUE(false);
518 }
519
520 ret = capture_->SetMute(capture_, isSupport);
521 if (ret == HDF_SUCCESS) {
522 ret = capture_->GetMute(capture_, &isSupport);
523 ASSERT_EQ(isSupport, true);
524 } else if (ret == HDF_ERR_NOT_SUPPORT) {
525 ASSERT_TRUE(true);
526 } else {
527 ASSERT_TRUE(false);
528 }
529 }
530
531 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureSetMuteException002, TestSize.Level1)
532 {
533 EXPECT_NE(capture_->SetMute, nullptr);
534
535 int32_t ret = capture_->SetMute(nullptr, true);
536 EXPECT_NE(ret, HDF_SUCCESS);
537 }
538
539 /* capture GetMute cases */
540 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetMute001, TestSize.Level1)
541 {
542 bool isSupport = true;
543 EXPECT_NE(capture_->GetMute, nullptr);
544
545 int32_t ret = capture_->GetMute(capture_, &isSupport);
546 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
547 }
548
549 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetMuteException001, TestSize.Level1)
550 {
551 EXPECT_NE(capture_->GetMute, nullptr);
552
553 int32_t ret = capture_->GetMute(nullptr, nullptr);
554 EXPECT_NE(ret, HDF_SUCCESS);
555
556 ret = capture_->GetMute(capture_, nullptr);
557 EXPECT_NE(ret, HDF_SUCCESS);
558 }
559
560 /* capture SetVolume cases */
561 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureSetVolume001, TestSize.Level1)
562 {
563 float volume = 0.0;
564 EXPECT_NE(capture_->SetVolume, nullptr);
565 EXPECT_NE(capture_->GetVolume, nullptr);
566
567 int32_t ret = capture_->SetVolume(capture_, HALF_OF_MAX_VOLUME);
568 if (ret == HDF_SUCCESS) {
569 ret = capture_->GetVolume(capture_, &volume);
570 ASSERT_EQ(volume, HALF_OF_MAX_VOLUME);
571 } else if (ret == HDF_ERR_NOT_SUPPORT) {
572 ASSERT_TRUE(true);
573 } else {
574 ASSERT_TRUE(false);
575 }
576 }
577
578 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureSetVolumeException001, TestSize.Level1)
579 {
580 float exceptionVolume = 2.0;
581 EXPECT_NE(capture_->SetVolume, nullptr);
582
583 int32_t ret = capture_->SetVolume(capture_, exceptionVolume);
584 EXPECT_NE(ret, HDF_SUCCESS);
585
586 exceptionVolume = -3.0;
587 ret = capture_->SetVolume(capture_, exceptionVolume);
588 EXPECT_NE(ret, HDF_SUCCESS);
589 }
590
591 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureSetVolumeException002, TestSize.Level1)
592 {
593 EXPECT_NE(capture_->SetVolume, nullptr);
594
595 int32_t ret = capture_->SetVolume(nullptr, HALF_OF_MAX_VOLUME);
596 EXPECT_NE(ret, HDF_SUCCESS);
597 }
598
599 /* capture GetVolume cases */
600 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetVolume001, TestSize.Level1)
601 {
602 float volume = 0.0;
603 EXPECT_NE(capture_->GetVolume, nullptr);
604
605 int32_t ret = capture_->GetVolume(capture_, &volume);
606 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
607 }
608
609 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetVolumeException001, TestSize.Level1)
610 {
611 float volume = 0.0;
612 EXPECT_NE(capture_->GetVolume, nullptr);
613
614 int32_t ret = capture_->GetVolume(nullptr, nullptr);
615 EXPECT_NE(ret, HDF_SUCCESS);
616
617 ret = capture_->GetVolume(capture_, nullptr);
618 EXPECT_NE(ret, HDF_SUCCESS);
619
620 ret = capture_->GetVolume(nullptr, &volume);
621 EXPECT_NE(ret, HDF_SUCCESS);
622 }
623
624 /* capture GetGainThreshold cases */
625 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetGainThreshold001, TestSize.Level1)
626 {
627 float bottom = 0;
628 float top = 0;
629 EXPECT_NE(capture_->GetGainThreshold, nullptr);
630
631 int32_t ret = capture_->GetGainThreshold(capture_, &bottom, &top);
632 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
633 }
634
635 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetGainThresholdException002, TestSize.Level1)
636 {
637 float bottom = 0;
638 float top = 0;
639 EXPECT_NE(capture_->GetGainThreshold, nullptr);
640
641 int32_t ret = capture_->GetGainThreshold(nullptr, &bottom, &top);
642 EXPECT_NE(ret, HDF_SUCCESS);
643
644 ret = capture_->GetGainThreshold(nullptr, nullptr, nullptr);
645 EXPECT_NE(ret, HDF_SUCCESS);
646
647 ret = capture_->GetGainThreshold(capture_, nullptr, nullptr);
648 EXPECT_NE(ret, HDF_SUCCESS);
649 }
650
651 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureSetGain001, TestSize.Level1)
652 {
653 EXPECT_NE(capture_->SetGain, nullptr);
654
655 int32_t ret = capture_->SetGain(capture_, HALF_OF_MAX_VOLUME);
656 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
657 }
658
659 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureSetGainException001, TestSize.Level1)
660 {
661 EXPECT_NE(capture_->SetGain, nullptr);
662 float exceptionGain = -3.0;
663
664 int32_t ret = capture_->SetGain(capture_, exceptionGain);
665 EXPECT_NE(ret, HDF_SUCCESS);
666
667 ret = capture_->SetGain(nullptr, HALF_OF_MAX_VOLUME);
668 EXPECT_NE(ret, HDF_SUCCESS);
669 }
670
671 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetGain001, TestSize.Level1)
672 {
673 EXPECT_NE(capture_->GetGain, nullptr);
674 float getGain;
675
676 int32_t ret = capture_->GetGain(capture_, &getGain);
677 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
678 }
679
680 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetGainException001, TestSize.Level1)
681 {
682 EXPECT_NE(capture_->SetGain, nullptr);
683 float exceptionGain = 2.0;
684
685 int32_t ret = capture_->GetGain(capture_, nullptr);
686 EXPECT_NE(ret, HDF_SUCCESS);
687
688 ret = capture_->GetGain(nullptr, &exceptionGain);
689 EXPECT_NE(ret, HDF_SUCCESS);
690 }
691
692 /**
693 * @brief here starts the attributes cases
694 */
695 /* capture GetSampleAttributes cases */
696 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetSampleAttributes001, TestSize.Level1)
697 {
698 struct AudioSampleAttributes attrs = {};
699 EXPECT_NE(capture_->GetSampleAttributes, nullptr);
700
701 int32_t ret = capture_->GetSampleAttributes(capture_, &attrs);
702 EXPECT_EQ(ret, HDF_SUCCESS);
703 }
704
705 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetSampleAttributesException001, TestSize.Level1)
706 {
707 struct AudioSampleAttributes attrs = {};
708 EXPECT_NE(capture_->GetSampleAttributes, nullptr);
709
710 int32_t ret = capture_->GetSampleAttributes(nullptr, &attrs);
711 EXPECT_NE(ret, HDF_SUCCESS);
712
713 ret = capture_->GetSampleAttributes(capture_, nullptr);
714 EXPECT_NE(ret, HDF_SUCCESS);
715 }
716
717 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureSetSampleAttributes001, TestSize.Level1)
718 {
719 struct AudioSampleAttributes attrs = {
720 .format = AUDIO_FORMAT_TYPE_PCM_16_BIT,
721 .sampleRate = TEST_SAMPLE_RATE_MASK_48000,
722 .channelCount = TEST_CHANNEL_COUNT,
723 };
724 EXPECT_NE(capture_->SetSampleAttributes, nullptr);
725
726 int32_t ret = capture_->SetSampleAttributes(capture_, &attrs);
727 EXPECT_NE(ret, HDF_SUCCESS);
728
729 ret = capture_->SetSampleAttributes(capture_, nullptr);
730 EXPECT_NE(ret, HDF_SUCCESS);
731
732 ret = capture_->SetSampleAttributes(nullptr, &attrs);
733 EXPECT_NE(ret, HDF_SUCCESS);
734 }
735
736 /* capture GetCurrentChannelId cases */
737 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetCurrentChannelId001, TestSize.Level1)
738 {
739 int32_t ret = HDF_SUCCESS;
740 uint32_t channelId = 0;
741 EXPECT_NE(capture_->GetCurrentChannelId, nullptr);
742
743 ret = capture_->GetCurrentChannelId(capture_, &channelId);
744 EXPECT_EQ(ret, HDF_SUCCESS);
745 EXPECT_EQ(TEST_CHANNEL_COUNT, channelId);
746 }
747
748 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetCurrentChannelIdException001, TestSize.Level1)
749 {
750 int32_t ret = HDF_SUCCESS;
751 uint32_t channelId = 0;
752 EXPECT_NE(capture_->GetCurrentChannelId, nullptr);
753
754 ret = capture_->GetCurrentChannelId(capture_, nullptr);
755 EXPECT_NE(ret, HDF_SUCCESS);
756
757 ret = capture_->GetCurrentChannelId(nullptr, &channelId);
758 EXPECT_NE(ret, HDF_SUCCESS);
759 }
760
761 /* capture SetExtraParams cases */
762 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureSetExtraParams001, TestSize.Level1)
763 {
764 EXPECT_NE(capture_->SetExtraParams, nullptr);
765 EXPECT_NE(capture_->GetExtraParams, nullptr);
766
767 char kvList[] = "attr-route=1;attr-format=32;attr-channels=2;attr-frame-count=82;attr-sampling-rate=48000";
768 char keyValueListReply[256] = {};
769 uint32_t listLenth = 256;
770 size_t index = 1;
771
772 int32_t ret = capture_->SetExtraParams(capture_, kvList);
773 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
774
775 ret = capture_->GetExtraParams(capture_, keyValueListReply, listLenth);
776 // the vendor can not supply this method，one it not supply returns HDF_ERR_INVALID_PARAM
777 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
778
779 std::string strGetValue = keyValueListReply;
780 size_t indexAttr = strGetValue.find("attr-frame-count");
781 size_t indexFlag = strGetValue.rfind(";");
782
783 if (indexAttr != string::npos && indexFlag != string::npos) {
784 strGetValue.replace(indexAttr, indexFlag - indexAttr + index, "");
785 }
786 }
787
788 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureSetExtraParamsException001, TestSize.Level1)
789 {
790 ASSERT_NE(capture_->SetExtraParams, nullptr);
791
792 int32_t ret = capture_->SetExtraParams(nullptr, nullptr);
793 EXPECT_NE(ret, HDF_SUCCESS);
794 }
795
796 /* capture GetExtraParams cases */
797 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetExtraParams001, TestSize.Level1)
798 {
799 ASSERT_NE(capture_->GetExtraParams, nullptr);
800 char keyValueListReply[256] = {};
801 uint32_t listLenth = 256;
802
803 int32_t ret = capture_->GetExtraParams(capture_, keyValueListReply, listLenth);
804 // the vendor can not supply this method，one it not supply returns HDF_ERR_INVALID_PARAM
805 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_INVALID_PARAM);
806 }
807
808 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetExtraParamsException001, TestSize.Level1)
809 {
810 ASSERT_NE(capture_->GetExtraParams, nullptr);
811 char keyValueListReply[256] = {};
812 uint32_t listLenth = 256;
813
814 int32_t ret = capture_->GetExtraParams(nullptr, keyValueListReply, listLenth);
815 EXPECT_NE(ret, HDF_SUCCESS);
816
817 ret = capture_->GetExtraParams(capture_, nullptr, listLenth);
818 EXPECT_NE(ret, HDF_SUCCESS);
819 }
820
821 /* capture selectsene cases */
822 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureSelectScene001, TestSize.Level1)
823 {
824 ASSERT_NE(capture_->SelectScene, nullptr);
825 struct AudioSceneDescriptor sceneDesc = {};
826 sceneDesc.desc.pins = PIN_IN_MIC;
827 sceneDesc.desc.desc = strdup("mic");
828 sceneDesc.scene.id = AUDIO_IN_CALL;
829
830 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
831 EXPECT_EQ(ret, HDF_SUCCESS);
832 free(sceneDesc.desc.desc);
833 }
834
835 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureSelectSceneException001, TestSize.Level1)
836 {
837 ASSERT_NE(capture_->SelectScene, nullptr);
838 struct AudioSceneDescriptor sceneDesc = {};
839 sceneDesc.scene.id = AUDIO_IN_CALL;
840
841 int32_t ret = capture_->SelectScene(capture_, nullptr);
842 ASSERT_NE(ret, HDF_SUCCESS);
843
844 ret = capture_->SelectScene(nullptr, &sceneDesc);
845 ASSERT_NE(ret, HDF_SUCCESS);
846 }
847
848 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureSelectSceneInValid001, TestSize.Level1)
849 {
850 ASSERT_NE(capture_->SelectScene, nullptr);
851 struct AudioSceneDescriptor sceneDesc = {};
852 sceneDesc.scene.id = INVALID_SCENE_ID;
853 sceneDesc.desc.pins = PIN_IN_MIC;
854 sceneDesc.desc.desc = strdup("mic");
855
856 int32_t ret = capture_->SelectScene(capture_, &sceneDesc);
857 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_NOT_SUPPORT);
858 free(sceneDesc.desc.desc);
859 }
860
861 /* capture get version cases */
862 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetVersion001, TestSize.Level1)
863 {
864 ASSERT_NE(capture_->GetVersion, nullptr);
865 uint32_t majorVer;
866 uint32_t minorVer;
867 ASSERT_EQ(HDF_SUCCESS, capture_->GetVersion(capture_, &majorVer, &minorVer));
868 EXPECT_EQ(IAUDIO_MANAGER_MAJOR_VERSION, majorVer);
869 EXPECT_EQ(IAUDIO_MANAGER_MINOR_VERSION, minorVer);
870 }
871
872 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetVersionException001, TestSize.Level1)
873 {
874 ASSERT_NE(capture_->GetVersion, nullptr);
875 uint32_t majorVer;
876 uint32_t minorVer;
877 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, capture_->GetVersion(nullptr, &majorVer, &minorVer));
878 }
879
880 /* capture support pause and resume cases */
881 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureIsSupportsPauseAndResume001, TestSize.Level1)
882 {
883 ASSERT_NE(capture_->GetVersion, nullptr);
884 bool supportPause = false;
885 bool supportResume = false;
886
887 int32_t ret = capture_->IsSupportsPauseAndResume(capture_, &supportPause, &supportResume);
888 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
889 }
890
891 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureIsSupportsPauseAndResumeException001, TestSize.Level1)
892 {
893 ASSERT_NE(capture_->IsSupportsPauseAndResume, nullptr);
894 bool supportPause = false;
895 bool supportResume = false;
896
897 int32_t ret = capture_->IsSupportsPauseAndResume(nullptr, &supportPause, &supportResume);
898 ASSERT_NE(ret, HDF_SUCCESS);
899
900 ret = capture_->IsSupportsPauseAndResume(capture_, nullptr, &supportResume);
901 ASSERT_NE(ret, HDF_SUCCESS);
902
903 ret = capture_->IsSupportsPauseAndResume(capture_, &supportPause, nullptr);
904 ASSERT_NE(ret, HDF_SUCCESS);
905 }
906
907 /* capture GetFrameBufferSize cases */
908 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetFrameBufferSize001, TestSize.Level1)
909 {
910 ASSERT_NE(capture_->GetFrameBufferSize, nullptr);
911 uint64_t bufferSize = 0;
912
913 int32_t ret = capture_->GetFrameBufferSize(capture_, &bufferSize);
914 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
915 }
916
917 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureGetFrameBufferSizeException001, TestSize.Level1)
918 {
919 ASSERT_NE(capture_->GetFrameBufferSize, nullptr);
920 uint64_t bufferSize = 0;
921
922 int32_t ret = capture_->GetFrameBufferSize(nullptr, &bufferSize);
923 ASSERT_NE(ret, HDF_SUCCESS);
924
925 ret = capture_->GetFrameBufferSize(capture_, nullptr);
926 ASSERT_NE(ret, HDF_SUCCESS);
927 }
928
929 /* capture AddAudioEffect cases */
930 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureAddAudioEffect001, TestSize.Level1)
931 {
932 ASSERT_NE(capture_->AddAudioEffect, nullptr);
933 uint64_t effectId = 0;
934
935 int32_t ret = capture_->AddAudioEffect(capture_, effectId);
936 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
937 }
938
939 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureAddAudioEffectException001, TestSize.Level1)
940 {
941 ASSERT_NE(capture_->AddAudioEffect, nullptr);
942 uint64_t effectId = -1;
943
944 int32_t ret = capture_->AddAudioEffect(nullptr, effectId);
945 ASSERT_NE(ret, HDF_SUCCESS);
946
947 ret = capture_->AddAudioEffect(capture_, effectId);
948 ASSERT_NE(ret, HDF_SUCCESS);
949 }
950
951 /* capture RemoveAudioEffect cases */
952 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureRemoveAudioEffect001, TestSize.Level1)
953 {
954 ASSERT_NE(capture_->RemoveAudioEffect, nullptr);
955 uint64_t effectId = 0;
956
957 int32_t ret = capture_->RemoveAudioEffect(capture_, effectId);
958 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT || ret == HDF_ERR_INVALID_PARAM);
959 }
960
961 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureRemoveAudioEffectException001, TestSize.Level1)
962 {
963 ASSERT_NE(capture_->RemoveAudioEffect, nullptr);
964 uint64_t effectId = -1;
965
966 int32_t ret = capture_->RemoveAudioEffect(nullptr, effectId);
967 ASSERT_NE(ret, HDF_SUCCESS);
968
969 ret = capture_->RemoveAudioEffect(capture_, effectId);
970 ASSERT_NE(ret, HDF_SUCCESS);
971 }
972
973 /* capture CheckSceneCapability cases */
974 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureCheckSceneCapabilityException001, TestSize.Level1)
975 {
976 ASSERT_NE(capture_->CheckSceneCapability, nullptr);
977 struct AudioSceneDescriptor sceneDesc = {};
978 sceneDesc.desc.pins = PIN_IN_MIC;
979 sceneDesc.desc.desc = strdup("mic");
980 sceneDesc.scene.id = AUDIO_IN_COMMUNICATION;
981 bool isSupport = false;
982
983 int32_t ret = capture_->CheckSceneCapability(capture_, &sceneDesc, &isSupport);
984 EXPECT_EQ(ret, HDF_SUCCESS);
985 free(sceneDesc.desc.desc);
986 }
987
988 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureCheckSceneCapabilityInValid001, TestSize.Level1)
989 {
990 ASSERT_NE(capture_->CheckSceneCapability, nullptr);
991 struct AudioSceneDescriptor sceneDesc = {};
992 sceneDesc.desc.pins = PIN_IN_MIC;
993 sceneDesc.desc.desc = strdup("mic");
994 sceneDesc.scene.id = INVALID_SCENE_ID;
995 bool isSupport = false;
996
997 int32_t ret = capture_->CheckSceneCapability(capture_, &sceneDesc, &isSupport);
998 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_NOT_SUPPORT);
999 free(sceneDesc.desc.desc);
1000 }
1001
1002 HWTEST_F(AudioUtCaptureTest, HdfAudioCaptureCheckSceneCapability001, TestSize.Level1)
1003 {
1004 ASSERT_NE(capture_->CheckSceneCapability, nullptr);
1005 struct AudioSceneDescriptor sceneDesc = {};
1006 sceneDesc.scene.id = AUDIO_IN_COMMUNICATION;
1007 bool isSupport = false;
1008
1009 int32_t ret = capture_->CheckSceneCapability(nullptr, &sceneDesc, &isSupport);
1010 ASSERT_NE(ret, HDF_SUCCESS);
1011
1012 ret = capture_->CheckSceneCapability(capture_, nullptr, &isSupport);
1013 ASSERT_NE(ret, HDF_SUCCESS);
1014
1015 ret = capture_->CheckSceneCapability(capture_, &sceneDesc, nullptr);
1016 ASSERT_NE(ret, HDF_SUCCESS);
1017 }
1018
1019 } // end of name space