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