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