1 /*
2 * Copyright (c) 2021 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 /**
17 * @addtogroup Audio
18 * @{
19 *
20 * @brief Defines audio-related APIs, including custom data types and functions for capture drivers function.
21 * accessing a driver adapter, and capturing audios.
22 *
23 * @since 1.0
24 * @version 1.0
25 */
26
27 /**
28 * @file audio_hdi_common.h
29 *
30 * @brief Declares APIs for operations related to the capturing audio adapter.
31 *
32 * @since 1.0
33 * @version 1.0
34 */
35
36 #include "audio_hdi_common.h"
37 #include "audio_hdicapture_test.h"
38
39 using namespace std;
40 using namespace testing::ext;
41 using namespace HMOS::Audio;
42
43 namespace {
44 const string ADAPTER_NAME_HDMI = "hdmi";
45 const string ADAPTER_NAME_USB = "usb";
46 const string ADAPTER_NAME_INTERNAL = "internal";
47 const int BUFFER_SIZE = 16384;
48 const int BUFFER_SIZE_LITTLE = 0;
49 const uint64_t FILESIZE = 1024;
50
51 class AudioHdiCaptureTest : public testing::Test {
52 public:
53 static void SetUpTestCase(void);
54 static void TearDownTestCase(void);
55 void SetUp();
56 void TearDown();
57 static TestAudioManager *(*GetAudioManager)();
58 static void *handleSo;
59 #ifdef AUDIO_MPI_SO
60 static int32_t (*SdkInit)();
61 static void (*SdkExit)();
62 static void *sdkSo;
63 #endif
64
65 static int32_t GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara);
66 };
67
68 using THREAD_FUNC = void *(*)(void *);
69
70 TestAudioManager *(*AudioHdiCaptureTest::GetAudioManager)() = nullptr;
71 void *AudioHdiCaptureTest::handleSo = nullptr;
72 #ifdef AUDIO_MPI_SO
73 int32_t (*AudioHdiCaptureTest::SdkInit)() = nullptr;
74 void (*AudioHdiCaptureTest::SdkExit)() = nullptr;
75 void *AudioHdiCaptureTest::sdkSo = nullptr;
76 #endif
77
SetUpTestCase(void)78 void AudioHdiCaptureTest::SetUpTestCase(void)
79 {
80 #ifdef AUDIO_MPI_SO
81 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
82 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
83 if (sdkSo == nullptr) {
84 return;
85 }
86 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
87 if (SdkInit == nullptr) {
88 return;
89 }
90 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
91 if (SdkExit == nullptr) {
92 return;
93 }
94 SdkInit();
95 #endif
96 char absPath[PATH_MAX] = {0};
97 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
98 return;
99 }
100 handleSo = dlopen(absPath, RTLD_LAZY);
101 if (handleSo == nullptr) {
102 return;
103 }
104 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
105 if (GetAudioManager == nullptr) {
106 return;
107 }
108 }
109
TearDownTestCase(void)110 void AudioHdiCaptureTest::TearDownTestCase(void)
111 {
112 #ifdef AUDIO_MPI_SO
113 SdkExit();
114 if (sdkSo != nullptr) {
115 dlclose(sdkSo);
116 sdkSo = nullptr;
117 }
118 if (SdkInit != nullptr) {
119 SdkInit = nullptr;
120 }
121 if (SdkExit != nullptr) {
122 SdkExit = nullptr;
123 }
124 #endif
125 if (handleSo != nullptr) {
126 dlclose(handleSo);
127 handleSo = nullptr;
128 }
129 if (GetAudioManager != nullptr) {
130 GetAudioManager = nullptr;
131 }
132 }
133
134
SetUp(void)135 void AudioHdiCaptureTest::SetUp(void) {}
136
TearDown(void)137 void AudioHdiCaptureTest::TearDown(void) {}
138
139
GetLoadAdapterAudioPara(struct PrepareAudioPara & audiopara)140 int32_t AudioHdiCaptureTest::GetLoadAdapterAudioPara(struct PrepareAudioPara& audiopara)
141 {
142 int32_t ret = -1;
143 int size = 0;
144 auto *inst = (AudioHdiCaptureTest *)audiopara.self;
145 if (inst != nullptr && inst->GetAudioManager != nullptr) {
146 audiopara.manager = inst->GetAudioManager();
147 }
148 if (audiopara.manager == nullptr) {
149 return AUDIO_HAL_ERR_INVALID_PARAM;
150 }
151 ret = audiopara.manager->GetAllAdapters(audiopara.manager, &audiopara.descs, &size);
152 if (ret < 0) {
153 return ret;
154 }
155 if (audiopara.descs == nullptr || size == 0) {
156 return AUDIO_HAL_ERR_INTERNAL;
157 }
158 int index = SwitchAdapter(audiopara.descs, audiopara.adapterName,
159 audiopara.portType, audiopara.audioPort, size);
160 if (index < 0) {
161 return AUDIO_HAL_ERR_INTERNAL;
162 } else {
163 audiopara.desc = &audiopara.descs[index];
164 }
165 if (audiopara.desc == nullptr) {
166 return AUDIO_HAL_ERR_INVALID_PARAM;
167 } else {
168 ret = audiopara.manager->LoadAdapter(audiopara.manager, audiopara.desc, &audiopara.adapter);
169 }
170 if (ret < 0) {
171 return ret;
172 }
173 if (audiopara.adapter == nullptr) {
174 return AUDIO_HAL_ERR_INVALID_PARAM;
175 }
176 return HDF_SUCCESS;
177 }
178
179
180 /**
181 * @tc.name Test AudioCaptureCaptureFrame API via legal input
182 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0001
183 * @tc.desc test AudioCaptureCaptureFrame interface,Returns 0 if the input data is read successfully
184 */
185 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0001, Function | MediumTest | Level1)
186 {
187 int32_t ret = -1;
188 uint64_t replyBytes = 0;
189 uint64_t requestBytes = BUFFER_SIZE;
190 struct AudioAdapter *adapter = nullptr;
191 struct AudioCapture *capture = nullptr;
192
193 TestAudioManager* manager = GetAudioManager();
194 ASSERT_NE(nullptr, GetAudioManager);
195 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
196 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
197 ret = capture->control.Start((AudioHandle)capture);
198 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
199 char *frame = (char *)calloc(1, BUFFER_SIZE);
200 EXPECT_NE(nullptr, frame);
201 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
202 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
203
204 capture->control.Stop((AudioHandle)capture);
205 adapter->DestroyCapture(adapter, capture);
206 manager->UnloadAdapter(manager, adapter);
207 if (frame != nullptr) {
208 free(frame);
209 frame = nullptr;
210 }
211 }
212 /**
213 * @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter frame is nullptr
214 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0002
215 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter frame is nullptr
216 */
217 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0002, Function | MediumTest | Level1)
218 {
219 int32_t ret = -1;
220 uint64_t replyBytes = 0;
221 uint64_t requestBytes = BUFFER_SIZE;
222 struct AudioAdapter *adapter = nullptr;
223 struct AudioCapture *capture = nullptr;
224 char *frame = nullptr;
225
226 TestAudioManager* manager = GetAudioManager();
227 ASSERT_NE(nullptr, GetAudioManager);
228 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
229 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
230 ret = capture->control.Start((AudioHandle)capture);
231 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
232 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
233 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
234
235 capture->control.Stop((AudioHandle)capture);
236 adapter->DestroyCapture(adapter, capture);
237 manager->UnloadAdapter(manager, adapter);
238 }
239 /**
240 * @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter replyBytes is nullptr
241 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0003
242 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter replyBytes is nullptr
243 */
244 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0003, Function | MediumTest | Level1)
245 {
246 int32_t ret = -1;
247 uint64_t requestBytes = BUFFER_SIZE;
248 struct AudioAdapter *adapter = nullptr;
249 struct AudioCapture *capture = nullptr;
250 uint64_t *replyBytes = nullptr;
251
252 TestAudioManager* manager = GetAudioManager();
253 ASSERT_NE(nullptr, GetAudioManager);
254 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
255 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
256 ret = capture->control.Start((AudioHandle)capture);
257 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
258 char *frame = (char *)calloc(1, BUFFER_SIZE);
259 EXPECT_NE(nullptr, frame);
260 ret = capture->CaptureFrame(capture, frame, requestBytes, replyBytes);
261 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
262
263 capture->control.Stop((AudioHandle)capture);
264 adapter->DestroyCapture(adapter, capture);
265 manager->UnloadAdapter(manager, adapter);
266 if (frame != nullptr) {
267 free(frame);
268 frame = nullptr;
269 }
270 }
271 /**
272 * @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter capture is nullptr
273 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0004
274 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter capture is nullptr
275 */
276 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0004, Function | MediumTest | Level1)
277 {
278 int32_t ret = -1;
279 uint64_t requestBytes = BUFFER_SIZE;
280 uint64_t replyBytes = 0;
281 struct AudioAdapter *adapter = nullptr;
282 struct AudioCapture *capture = nullptr;
283 struct AudioCapture *captureNull = nullptr;
284
285 TestAudioManager* manager = GetAudioManager();
286 ASSERT_NE(nullptr, GetAudioManager);
287 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
288 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
289 ret = capture->control.Start((AudioHandle)capture);
290 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
291 char *frame = (char *)calloc(1, BUFFER_SIZE);
292 EXPECT_NE(nullptr, frame);
293 ret = capture->CaptureFrame(captureNull, frame, requestBytes, &replyBytes);
294 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
295
296 capture->control.Stop((AudioHandle)capture);
297 adapter->DestroyCapture(adapter, capture);
298 manager->UnloadAdapter(manager, adapter);
299 if (frame != nullptr) {
300 free(frame);
301 frame = nullptr;
302 }
303 }
304 /**
305 * @tc.name Test AudioCaptureFrame API without calling interface capturestart
306 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0005
307 * @tc.desc Test AudioCaptureFrame interface,Returns -1 if without calling interface capturestart
308 */
309 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0005, Function | MediumTest | Level1)
310 {
311 int32_t ret = -1;
312 uint64_t requestBytes = BUFFER_SIZE;
313 struct AudioAdapter *adapter = nullptr;
314 struct AudioCapture *capture = nullptr;
315 uint64_t replyBytes = 0;
316
317 TestAudioManager* manager = GetAudioManager();
318 ASSERT_NE(nullptr, GetAudioManager);
319 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
320 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
321 char *frame = (char *)calloc(1, BUFFER_SIZE);
322 EXPECT_NE(nullptr, frame);
323 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
324 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
325
326 adapter->DestroyCapture(adapter, capture);
327 manager->UnloadAdapter(manager, adapter);
328 if (frame != nullptr) {
329 free(frame);
330 frame = nullptr;
331 }
332 }
333 /**
334 * @tc.name Test AudioCaptureCaptureFrame API via setting the incoming parameter requestBytes
335 less than interface requirements
336 * @tc.number SUB_Audio_HDI_AudioCaptureFrame_0006
337 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter
338 requestBytes less than interface requirements
339 */
340 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureFrame_0006, Function | MediumTest | Level1)
341 {
342 int32_t ret = -1;
343 uint64_t requestBytes = BUFFER_SIZE_LITTLE;
344 uint64_t replyBytes = 0;
345 struct AudioAdapter *adapter = nullptr;
346 struct AudioCapture *capture = nullptr;
347
348 TestAudioManager* manager = GetAudioManager();
349 ASSERT_NE(nullptr, GetAudioManager);
350 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
351 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
352 ret = capture->control.Start((AudioHandle)capture);
353 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
354 char *frame = (char *)calloc(1, BUFFER_SIZE);
355 EXPECT_NE(nullptr, frame);
356 ret = capture->CaptureFrame(capture, frame, requestBytes, &replyBytes);
357 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
358
359 capture->control.Stop((AudioHandle)capture);
360 adapter->DestroyCapture(adapter, capture);
361 manager->UnloadAdapter(manager, adapter);
362 if (frame != nullptr) {
363 free(frame);
364 frame = nullptr;
365 }
366 }
367 /**
368 * @tc.name Test AudioCaptureGetCapturePosition API via legal input
369 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0001
370 * @tc.desc Test AudioCaptureGetCapturePosition interface,Returns 0 if get CapturePosition during playing.
371 */
372 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0001, Function | MediumTest | Level1)
373 {
374 int32_t ret = -1;
375 uint64_t frames = 0;
376 int64_t timeExp = 0;
377 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
378 struct PrepareAudioPara audiopara = {
379 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC,
380 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
381 };
382 ASSERT_NE(nullptr, GetAudioManager);
383 audiopara.manager = GetAudioManager();
384 ASSERT_NE(nullptr, audiopara.manager);
385
386 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
387 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
388 sleep(1);
389 if (audiopara.capture != nullptr) {
390 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time);
391 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
392 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
393 EXPECT_GT(frames, INITIAL_VALUE);
394 }
395
396 ret = ThreadRelease(audiopara);
397 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
398 }
399 /**
400 * @tc.name Test GetCapturePosition API via get CapturePosition after the audiois Paused and resumed
401 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0002
402 * @tc.desc Test GetCapturePosition interface,Returns 0 if get Position after Pause and resume during playing
403 */
404 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0002, Function | MediumTest | Level1)
405 {
406 int32_t ret = -1;
407 int64_t timeExp = 0;
408 uint64_t frames = 0;
409 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
410 struct PrepareAudioPara audiopara = {
411 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC,
412 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
413 };
414 ASSERT_NE(nullptr, GetAudioManager);
415 audiopara.manager = GetAudioManager();
416 ASSERT_NE(nullptr, audiopara.manager);
417
418 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
419 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
420 sleep(1);
421 if (audiopara.capture != nullptr) {
422 ret = audiopara.capture->control.Pause((AudioHandle)(audiopara.capture));
423 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
424 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time);
425 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
426 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
427 EXPECT_GT(frames, INITIAL_VALUE);
428 ret = audiopara.capture->control.Resume((AudioHandle)(audiopara.capture));
429 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
430 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time);
431 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
432 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
433 EXPECT_GT(frames, INITIAL_VALUE);
434 }
435
436 ret = ThreadRelease(audiopara);
437 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
438 }
439 /**
440 * @tc.name Test GetCapturePosition API via get CapturePosition after the audio file is stopped
441 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0003
442 * @tc.desc Test GetCapturePosition interface,Returns 0 if get CapturePosition after stop during playing
443 */
444 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0003, Function | MediumTest | Level1)
445 {
446 int32_t ret = -1;
447 TestAudioManager* manager = {};
448 struct AudioAdapter *adapter = {};
449 struct AudioCapture *capture = nullptr;
450 uint64_t frames = 0;
451 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
452 int64_t timeExp = 0;
453
454 manager = GetAudioManager();
455 ASSERT_NE(nullptr, GetAudioManager);
456 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
457 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
458 ret = capture->control.Stop((AudioHandle)capture);
459 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
460 ret = capture->GetCapturePosition(capture, &frames, &time);
461 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
462 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
463 EXPECT_GT(frames, INITIAL_VALUE);
464
465 adapter->DestroyCapture(adapter, capture);
466 manager->UnloadAdapter(manager, adapter);
467 }
468 /**
469 * @tc.name Test GetCapturePosition API via get CapturePosition after the object is created
470 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0004
471 * @tc.desc Test GetCapturePosition interface, return 0 if get CapturePosition after the object is created
472 */
473 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0004, Function | MediumTest | Level1)
474 {
475 int32_t ret = -1;
476 enum AudioPortPin pins = PIN_IN_MIC;
477 struct AudioAdapter *adapter = {};
478 struct AudioCapture *capture = nullptr;
479 uint64_t frames = 0;
480 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
481 int64_t timeExp = 0;
482
483 TestAudioManager* manager = GetAudioManager();
484 ASSERT_NE(nullptr, GetAudioManager);
485 ret = AudioCreateCapture(manager, pins, ADAPTER_NAME_USB, &adapter, &capture);
486 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
487 ret = capture->GetCapturePosition(capture, &frames, &time);
488 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
489 EXPECT_EQ((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
490
491 adapter->DestroyCapture(adapter, capture);
492 manager->UnloadAdapter(manager, adapter);
493 }
494 /**
495 * @tc.name Test GetCapturePosition API via setting the parameter Capture is nullptr
496 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0005
497 * @tc.desc Test GetCapturePosition interface, return -1 if setting the parameter Capture is nullptr
498 */
499 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0005, Function | MediumTest | Level1)
500 {
501 int32_t ret = -1;
502 TestAudioManager* manager = {};
503 struct AudioAdapter *adapter = {};
504 struct AudioCapture *capture = nullptr;
505 struct AudioCapture *captureNull = nullptr;
506 uint64_t frames = 0;
507 struct AudioTimeStamp time = {};
508
509 manager = GetAudioManager();
510 ASSERT_NE(nullptr, GetAudioManager);
511 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
512 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
513 ret = capture->GetCapturePosition(captureNull, &frames, &time);
514 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
515
516 capture->control.Stop((AudioHandle)capture);
517 adapter->DestroyCapture(adapter, capture);
518 manager->UnloadAdapter(manager, adapter);
519 }
520 /**
521 * @tc.name Test GetCapturePosition API via setting the parameter frames is nullptr
522 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0006
523 * @tc.desc Test GetCapturePosition interface, return -1 if setting the parameter frames is nullptr
524 */
525 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0006, Function | MediumTest | Level1)
526 {
527 int32_t ret = -1;
528 TestAudioManager* manager = {};
529 struct AudioAdapter *adapter = {};
530 struct AudioCapture *capture = nullptr;
531 uint64_t *framesNull = nullptr;
532 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
533
534 manager = GetAudioManager();
535 ASSERT_NE(nullptr, GetAudioManager);
536 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
537 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
538 ret = capture->GetCapturePosition(capture, framesNull, &time);
539 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
540
541 capture->control.Stop((AudioHandle)capture);
542 adapter->DestroyCapture(adapter, capture);
543 manager->UnloadAdapter(manager, adapter);
544 }
545 /**
546 * @tc.name Test GetCapturePosition API via setting the parameter time is nullptr
547 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0007
548 * @tc.desc Test GetCapturePosition interface, return -1 if setting the parameter time is nullptr
549 */
550 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0007, Function | MediumTest | Level1)
551 {
552 int32_t ret = -1;
553 TestAudioManager* manager = {};
554 struct AudioAdapter *adapter = {};
555 struct AudioCapture *capture = nullptr;
556 uint64_t frames = 0;
557 struct AudioTimeStamp *timeNull = nullptr;
558
559 manager = GetAudioManager();
560 ASSERT_NE(nullptr, GetAudioManager);
561 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
562 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
563 ret = capture->GetCapturePosition(capture, &frames, timeNull);
564 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
565
566 capture->control.Stop((AudioHandle)capture);
567 adapter->DestroyCapture(adapter, capture);
568 manager->UnloadAdapter(manager, adapter);
569 }
570 /**
571 * @tc.name Test GetCapturePosition API via get CapturePosition continuously
572 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0008
573 * @tc.desc Test GetCapturePosition interface, return 0 if the GetCapturePosition was called twice
574 */
575 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0008, Function | MediumTest | Level1)
576 {
577 int32_t ret = -1;
578 TestAudioManager* manager = {};
579 struct AudioAdapter *adapter = {};
580 struct AudioCapture *capture = nullptr;
581 uint64_t frames = 0;
582 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
583 struct AudioTimeStamp timeSec = {.tvSec = 0, .tvNSec = 0};
584 int64_t timeExp = 0;
585
586 manager = GetAudioManager();
587 ASSERT_NE(nullptr, GetAudioManager);
588 ret = AudioCreateStartCapture(manager, &capture, &adapter, ADAPTER_NAME_USB);
589 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
590 ret = capture->GetCapturePosition(capture, &frames, &time);
591 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
592 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
593 EXPECT_GT(frames, INITIAL_VALUE);
594 ret = capture->GetCapturePosition(capture, &frames, &timeSec);
595 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
596 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
597 EXPECT_GT(frames, INITIAL_VALUE);
598
599 capture->control.Stop((AudioHandle)capture);
600 adapter->DestroyCapture(adapter, capture);
601 manager->UnloadAdapter(manager, adapter);
602 }
603 /**
604 * @tc.name Test GetCapturePosition API via define format to AUDIO_FORMAT_PCM_16_BIT
605 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0009
606 * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_16_BIT
607 */
608 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0009, Function | MediumTest | Level1)
609 {
610 int32_t ret = -1;
611 uint64_t channelCountExp = 2;
612 uint32_t sampleRateExp = 48000;
613 uint64_t frames = 0;
614 int64_t timeExp = 0;
615 struct AudioAdapter *adapter = nullptr;
616 struct AudioCapture *capture = nullptr;
617 struct AudioSampleAttributes attrs = {};
618 struct AudioSampleAttributes attrsValue = {};
619 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
620 TestAudioManager* manager = GetAudioManager();
621 ASSERT_NE(nullptr, GetAudioManager);
622 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
623 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
624 InitAttrs(attrs);
625 attrs.type = AUDIO_IN_MEDIA;
626 attrs.interleaved = false;
627 attrs.format = AUDIO_FORMAT_PCM_16_BIT;
628 attrs.sampleRate = 48000;
629 attrs.channelCount = 2;
630 ret = capture->attr.SetSampleAttributes(capture, &attrs);
631 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
632 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
633 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
634 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
635 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
636 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
637
638 ret = AudioCaptureStartAndOneFrame(capture);
639 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
640 ret = capture->GetCapturePosition(capture, &frames, &time);
641 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
642 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
643 EXPECT_GT(frames, INITIAL_VALUE);
644
645 capture->control.Stop((AudioHandle)capture);
646 adapter->DestroyCapture(adapter, capture);
647 manager->UnloadAdapter(manager, adapter);
648 }
649 /**
650 * @tc.name Test GetCapturePosition API via define format to AUDIO_FORMAT_PCM_24_BIT
651 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0010
652 * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define format to AUDIO_FORMAT_PCM_24_BIT
653 */
654 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0010, Function | MediumTest | Level1)
655 {
656 int32_t ret = -1;
657 struct AudioSampleAttributes attrs = {};
658 struct AudioSampleAttributes attrsValue = {};
659 struct AudioAdapter *adapter = nullptr;
660 struct AudioCapture *capture = nullptr;
661 uint64_t channelCountExp = 2;
662 uint32_t sampleRateExp = 48000;
663 uint64_t frames = 0;
664 int64_t timeExp = 0;
665 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
666 TestAudioManager* manager = GetAudioManager();
667 ASSERT_NE(nullptr, GetAudioManager);
668 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
669 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
670 InitAttrs(attrs);
671 attrs.type = AUDIO_IN_MEDIA;
672 attrs.interleaved = false;
673 attrs.format = AUDIO_FORMAT_PCM_24_BIT;
674 attrs.sampleRate = 48000;
675 attrs.channelCount = 2;
676 ret = capture->attr.SetSampleAttributes(capture, &attrs);
677 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
678 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
679 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
680 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
681 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
682 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
683
684 ret = AudioCaptureStartAndOneFrame(capture);
685 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
686 ret = capture->GetCapturePosition(capture, &frames, &time);
687 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
688 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
689 EXPECT_GT(frames, INITIAL_VALUE);
690
691 capture->control.Stop((AudioHandle)capture);
692 adapter->DestroyCapture(adapter, capture);
693 manager->UnloadAdapter(manager, adapter);
694 }
695 /**
696 * @tc.name Test GetCapturePosition API via define sampleRate and channelCount to different value
697 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0011
698 * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define channelCount as different values
699 */
700 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0011, Function | MediumTest | Level1)
701 {
702 int32_t ret = -1;
703 struct AudioCapture *capture = nullptr;
704 struct AudioAdapter *adapter = nullptr;
705 struct AudioSampleAttributes attrs = {};
706 struct AudioSampleAttributes attrsValue = {};
707 uint64_t channelCountExp = 1;
708 uint32_t sampleRateExp = 48000;
709 uint64_t frames = 0;
710 int64_t timeExp = 0;
711 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
712 TestAudioManager* manager = GetAudioManager();
713 ASSERT_NE(nullptr, GetAudioManager);
714 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
715 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
716 InitAttrs(attrs);
717 attrs.type = AUDIO_IN_MEDIA;
718 attrs.interleaved = false;
719 attrs.format = AUDIO_FORMAT_PCM_16_BIT;
720 attrs.sampleRate = 48000;
721 attrs.channelCount = 1;
722 ret = capture->attr.SetSampleAttributes(capture, &attrs);
723 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
724 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
725 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
726 EXPECT_EQ(AUDIO_FORMAT_PCM_16_BIT, attrsValue.format);
727 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
728 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
729
730 ret = AudioCaptureStartAndOneFrame(capture);
731 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
732 ret = capture->GetCapturePosition(capture, &frames, &time);
733 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
734 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
735 EXPECT_GT(frames, INITIAL_VALUE);
736
737 capture->control.Stop((AudioHandle)capture);
738 adapter->DestroyCapture(adapter, capture);
739 manager->UnloadAdapter(manager, adapter);
740 }
741 /**
742 * @tc.name Test GetCapturePosition API via define sampleRate and channelCount to 1
743 * @tc.number SUB_Audio_HDI_AudioCaptureGetCapturePosition_0012
744 * @tc.desc Test GetCapturePosition interface,return 0 if get framesize define channelCount to 1
745 */
746 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_AudioCaptureGetCapturePosition_0012, Function | MediumTest | Level1)
747 {
748 int32_t ret = -1;
749 uint64_t channelCountExp = 1;
750 uint32_t sampleRateExp = 48000;
751 uint64_t frames = 0;
752 int64_t timeExp = 0;
753 struct AudioAdapter *adapter = nullptr;
754 struct AudioCapture *capture = nullptr;
755 struct AudioSampleAttributes attrs = {};
756 struct AudioSampleAttributes attrsValue = {};
757 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
758 TestAudioManager* manager = GetAudioManager();
759 ASSERT_NE(nullptr, GetAudioManager);
760 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
761 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
762 InitAttrs(attrs);
763 attrs.type = AUDIO_IN_MEDIA;
764 attrs.interleaved = false;
765 attrs.format = AUDIO_FORMAT_PCM_24_BIT;
766 attrs.sampleRate = 48000;
767 attrs.channelCount = 1;
768 ret = capture->attr.SetSampleAttributes(capture, &attrs);
769 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
770 ret = capture->attr.GetSampleAttributes(capture, &attrsValue);
771 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
772 EXPECT_EQ(channelCountExp, attrsValue.channelCount);
773 EXPECT_EQ(AUDIO_FORMAT_PCM_24_BIT, attrsValue.format);
774 EXPECT_EQ(sampleRateExp, attrsValue.sampleRate);
775
776 ret = AudioCaptureStartAndOneFrame(capture);
777 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
778 ret = capture->GetCapturePosition(capture, &frames, &time);
779 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
780 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
781 EXPECT_GT(frames, INITIAL_VALUE);
782
783 capture->control.Stop((AudioHandle)capture);
784 adapter->DestroyCapture(adapter, capture);
785 manager->UnloadAdapter(manager, adapter);
786 }
787 /**
788 * @tc.name Test ReqMmapBuffer API via legal input
789 * @tc.number SUB_Audio_HDI_CaptureReqMmapBuffer_0001
790 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully
791 */
792 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureReqMmapBuffer_0001, Function | MediumTest | Level1)
793 {
794 int32_t ret = -1;
795 bool isRender = false;
796 int32_t reqSize = 0;
797 struct AudioMmapBufferDescripter desc = {};
798 struct AudioCapture *capture = nullptr;
799 struct AudioAdapter *adapter = nullptr;
800 ASSERT_NE(nullptr, GetAudioManager);
801 TestAudioManager* manager = GetAudioManager();
802 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
803 ASSERT_NE(nullptr, fp);
804 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
805 if (ret < 0 || capture == nullptr) {
806 (void)fclose(fp);
807 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
808 ASSERT_EQ(nullptr, capture);
809 }
810 ret = InitMmapDesc(fp, desc, reqSize, isRender);
811 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
812 ret = capture->control.Start((AudioHandle)capture);
813 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
814 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
815 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
816 (void)fclose(fp);
817 if (ret == 0) {
818 munmap(desc.memoryAddress, reqSize);
819 }
820 capture->control.Stop((AudioHandle)capture);
821 adapter->DestroyCapture(adapter, capture);
822 manager->UnloadAdapter(manager, adapter);
823 }
824 /**
825 * @tc.name Test ReqMmapBuffer API via setting the incoming parameter reqSize is bigger than
826 the size of actual audio file
827 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0002
828 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessful when setting the
829 incoming parameter reqSize is bigger than the size of actual audio file
830 */
831 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureReqMmapBuffer_0002, Function | MediumTest | Level1)
832 {
833 int32_t ret = -1;
834 bool isRender = false;
835 int32_t reqSize = 0;
836 struct AudioMmapBufferDescripter desc = {};
837 struct AudioCapture *capture = nullptr;
838 struct AudioAdapter *adapter = nullptr;
839 ASSERT_NE(nullptr, GetAudioManager);
840 TestAudioManager *manager = GetAudioManager();
841 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
842 ASSERT_NE(nullptr, fp);
843 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
844 if (ret < 0 || capture == nullptr) {
845 (void)fclose(fp);
846 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
847 ASSERT_EQ(nullptr, capture);
848 }
849 ret = InitMmapDesc(fp, desc, reqSize, isRender);
850 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
851 reqSize = reqSize + BUFFER_LENTH;
852 ret = capture->control.Start((AudioHandle)capture);
853 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
854 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
855 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
856 (void)fclose(fp);
857 capture->control.Stop((AudioHandle)capture);
858 adapter->DestroyCapture(adapter, capture);
859 manager->UnloadAdapter(manager, adapter);
860 }
861 /**
862 * @tc.name Test ReqMmapBuffer API via setting the incoming parameter reqSize is smaller than
863 the size of actual audio file
864 * @tc.number SUB_Audio_HDI_CaptureReqMmapBuffer_0003
865 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully when setting the
866 incoming parameter reqSize is smaller than the size of actual audio file
867 */
868 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureReqMmapBuffer_0003, Function | MediumTest | Level1)
869 {
870 int32_t ret = -1;
871 bool isRender = false;
872 int32_t reqSize = 0;
873 struct AudioMmapBufferDescripter desc = {};
874 struct AudioCapture *capture = nullptr;
875 struct AudioAdapter *adapter = nullptr;
876 ASSERT_NE(nullptr, GetAudioManager);
877 TestAudioManager *manager = GetAudioManager();
878 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
879 ASSERT_NE(nullptr, fp);
880 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
881 if (ret < 0 || capture == nullptr) {
882 (void)fclose(fp);
883 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
884 ASSERT_EQ(nullptr, capture);
885 }
886 ret = InitMmapDesc(fp, desc, reqSize, isRender);
887 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
888 reqSize = reqSize / 2;
889 ret = capture->control.Start((AudioHandle)capture);
890 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
891 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
892 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
893 (void)fclose(fp);
894 if (ret == 0) {
895 munmap(desc.memoryAddress, reqSize);
896 }
897 capture->control.Stop((AudioHandle)capture);
898 adapter->DestroyCapture(adapter, capture);
899 manager->UnloadAdapter(manager, adapter);
900 }
901 /**
902 * @tc.name Test ReqMmapBuffer API via setting the incoming parameter reqSize is zero
903 * @tc.number SUB_Audio_HDI_CaptureReqMmapBuffer_0004
904 * @tc.desc Test ReqMmapBuffer interface,return -1 if call ReqMmapBuffer interface unsuccessful when setting the
905 incoming parameter reqSize is zero
906 */
907 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureReqMmapBuffer_0004, Function | MediumTest | Level1)
908 {
909 int32_t ret = -1;
910 bool isRender = false;
911 int32_t reqSize = 0;
912 struct AudioMmapBufferDescripter desc = {};
913 struct AudioCapture *capture = nullptr;
914 struct AudioAdapter *adapter = nullptr;
915 ASSERT_NE(nullptr, GetAudioManager);
916 TestAudioManager *manager = GetAudioManager();
917 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
918 ASSERT_NE(nullptr, fp);
919 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
920 if (ret < 0 || capture == nullptr) {
921 (void)fclose(fp);
922 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
923 ASSERT_EQ(nullptr, capture);
924 }
925 ret = InitMmapDesc(fp, desc, reqSize, isRender);
926 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
927 reqSize = 0;
928 ret = capture->control.Start((AudioHandle)capture);
929 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
930 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
931 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
932 (void)fclose(fp);
933 capture->control.Stop((AudioHandle)capture);
934 adapter->DestroyCapture(adapter, capture);
935 manager->UnloadAdapter(manager, adapter);
936 }
937 /**
938 * @tc.name Test ReqMmapBuffer API via setting the incoming parameter memoryFd of desc is illegal
939 * @tc.number SUB_Audio_HDI_CaptureReqMmapBuffer_0005
940 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessful when setting the
941 incoming parameter memoryFd of desc is illegal
942 */
943 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureReqMmapBuffer_0005, Function | MediumTest | Level1)
944 {
945 int32_t ret = -1;
946 bool isRender = false;
947 int32_t reqSize = 0;
948 struct AudioMmapBufferDescripter desc = {};
949 struct AudioCapture *capture = nullptr;
950 struct AudioAdapter *adapter = nullptr;
951 ASSERT_NE(nullptr, GetAudioManager);
952 TestAudioManager *manager = GetAudioManager();
953 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
954 ASSERT_NE(nullptr, fp);
955 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
956 if (ret < 0 || capture == nullptr) {
957 (void)fclose(fp);
958 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
959 ASSERT_EQ(nullptr, capture);
960 }
961 ret = InitMmapDesc(fp, desc, reqSize, isRender);
962 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
963 desc.memoryFd = 1;
964 ret = capture->control.Start((AudioHandle)capture);
965 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
966 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, &desc);
967 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
968 (void)fclose(fp);
969 capture->control.Stop((AudioHandle)capture);
970 adapter->DestroyCapture(adapter, capture);
971 manager->UnloadAdapter(manager, adapter);
972 }
973 /**
974 * @tc.name Test ReqMmapBuffer API via the incoming parameter handle is nullptr
975 * @tc.number SUB_Audio_HDI_CaptureReqMmapBuffer_0006
976 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessful when setting the
977 incoming parameter handle is nullptr
978 */
979 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureReqMmapBuffer_0006, Function | MediumTest | Level1)
980 {
981 int32_t ret = -1;
982 bool isRender = false;
983 int32_t reqSize = 0;
984 struct AudioMmapBufferDescripter desc = {};
985 struct AudioCapture *capture = nullptr;
986 struct AudioCapture *captureNull = nullptr;
987 struct AudioAdapter *adapter = nullptr;
988 ASSERT_NE(nullptr, GetAudioManager);
989 TestAudioManager* manager = GetAudioManager();
990 FILE *fp = fopen(AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str(), "wb+");
991 ASSERT_NE(nullptr, fp);
992 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
993 if (ret < 0 || capture == nullptr) {
994 (void)fclose(fp);
995 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
996 ASSERT_EQ(nullptr, capture);
997 }
998 ret = InitMmapDesc(fp, desc, reqSize, isRender);
999 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1000 ret = capture->control.Start((AudioHandle)capture);
1001 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1002 ret = capture->attr.ReqMmapBuffer((AudioHandle)captureNull, reqSize, &desc);
1003 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1004 (void)fclose(fp);
1005 capture->control.Stop((AudioHandle)capture);
1006 adapter->DestroyCapture(adapter, capture);
1007 manager->UnloadAdapter(manager, adapter);
1008 }
1009 /**
1010 * @tc.name Test ReqMmapBuffer API via the incoming parameter desc is nullptr
1011 * @tc.number SUB_Audio_HDI_CaptureReqMmapBuffer_0007
1012 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessful when setting the
1013 incoming parameter desc is nullptr
1014 */
1015 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureReqMmapBuffer_0007, Function | MediumTest | Level1)
1016 {
1017 int32_t ret = -1;
1018 uint32_t reqSize = 0;
1019 struct AudioMmapBufferDescripter *descNull = nullptr;
1020 struct AudioCapture *capture = nullptr;
1021 struct AudioAdapter *adapter = nullptr;
1022 ASSERT_NE(nullptr, GetAudioManager);
1023 TestAudioManager* manager = GetAudioManager();
1024 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_USB, &adapter, &capture);
1025 if (ret < 0 || capture == nullptr) {
1026 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1027 ASSERT_EQ(nullptr, capture);
1028 }
1029 reqSize = FILE_CAPTURE_SIZE;
1030 ret = capture->control.Start((AudioHandle)capture);
1031 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1032 ret = capture->attr.ReqMmapBuffer((AudioHandle)capture, reqSize, descNull);
1033 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1034 capture->control.Stop((AudioHandle)capture);
1035 adapter->DestroyCapture(adapter, capture);
1036 manager->UnloadAdapter(manager, adapter);
1037 }
1038
1039 /**
1040 * @tc.name Test GetMmapPosition API via Getting position is normal in Before recording , recording and after recording
1041 * @tc.number SUB_Audio_HDI_CaptureGetMmapPosition_0001
1042 * @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully.
1043 */
1044 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureGetMmapPosition_0001, Function | MediumTest | Level1)
1045 {
1046 int32_t ret = -1;
1047 uint64_t frames = 0;
1048 uint64_t framesCapturing = 0;
1049 uint64_t framesExpCapture = 0;
1050 int64_t timeExp = 0;
1051 int64_t timeExpCaptureing = 0;
1052 struct PrepareAudioPara audiopara = {
1053 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC,
1054 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
1055 };
1056 ASSERT_NE(nullptr, GetAudioManager);
1057 audiopara.manager = GetAudioManager();
1058 ASSERT_NE(nullptr, audiopara.manager);
1059 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1060 &audiopara.capture);
1061 if (ret < 0 || audiopara.capture == nullptr) {
1062 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1063 ASSERT_EQ(nullptr, audiopara.capture);
1064 }
1065 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &frames, &(audiopara.time));
1066 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1067 EXPECT_EQ((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1068 EXPECT_EQ(frames, INITIAL_VALUE);
1069 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordMapAudio, &audiopara);
1070 if (ret != 0) {
1071 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1072 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1073 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1074 }
1075 sleep(1);
1076 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &framesCapturing, &(audiopara.time));
1077 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1078 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1079 EXPECT_GT(framesCapturing, INITIAL_VALUE);
1080 timeExpCaptureing = (audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec);
1081 void *result = nullptr;
1082 pthread_join(audiopara.tids, &result);
1083 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
1084 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &framesExpCapture, &(audiopara.time));
1085 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1086 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExpCaptureing);
1087 EXPECT_GT(framesExpCapture, framesCapturing);
1088
1089 audiopara.capture->control.Stop((AudioHandle)audiopara.capture);
1090 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1091 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1092 }
1093 /**
1094 * @tc.name Test GetMmapPosition API via SetSampleAttributes and Getting position is normal.
1095 * @tc.number SUB_Audio_HDI_CaptureGetMmapPosition_0002
1096 * @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully.
1097 */
1098 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureGetMmapPosition_0002, Function | MediumTest | Level1)
1099 {
1100 int32_t ret = -1;
1101 uint64_t frames = 0;
1102 int64_t timeExp = 0;
1103 struct PrepareAudioPara audiopara = {
1104 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC,
1105 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
1106 };
1107 ASSERT_NE(nullptr, GetAudioManager);
1108 audiopara.manager = GetAudioManager();
1109 ASSERT_NE(nullptr, audiopara.manager);
1110 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1111 &audiopara.capture);
1112 if (ret < 0 || audiopara.capture == nullptr) {
1113 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1114 ASSERT_EQ(nullptr, audiopara.capture);
1115 }
1116 InitAttrs(audiopara.attrs);
1117 audiopara.attrs.format = AUDIO_FORMAT_PCM_24_BIT;
1118 audiopara.attrs.channelCount = 1;
1119 ret = audiopara.capture->attr.SetSampleAttributes(audiopara.capture, &(audiopara.attrs));
1120 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1121
1122 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordMapAudio, &audiopara);
1123 if (ret != 0) {
1124 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1125 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1126 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1127 }
1128
1129 void *result = nullptr;
1130 pthread_join(audiopara.tids, &result);
1131 EXPECT_EQ(AUDIO_HAL_SUCCESS, (intptr_t)result);
1132
1133 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &frames, &(audiopara.time));
1134 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1135 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
1136 EXPECT_GT(frames, INITIAL_VALUE);
1137
1138 audiopara.capture->control.Stop((AudioHandle)audiopara.capture);
1139 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1140 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1141 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
1142 }
1143 /**
1144 * @tc.name Test ReqMmapBuffer API via inputtint frames is nullptr.
1145 * @tc.number SUB_Audio_HDI_CaptureGetMmapPosition_0003
1146 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
1147 */
1148 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureGetMmapPosition_0003, Function | MediumTest | Level1)
1149 {
1150 int32_t ret = -1;
1151 uint64_t *frames = nullptr;
1152 struct PrepareAudioPara audiopara = {
1153 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC,
1154 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
1155 };
1156 ASSERT_NE(nullptr, GetAudioManager);
1157 audiopara.manager = GetAudioManager();
1158 ASSERT_NE(nullptr, audiopara.manager);
1159 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1160 &audiopara.capture);
1161 if (ret < 0 || audiopara.capture == nullptr) {
1162 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1163 ASSERT_EQ(nullptr, audiopara.capture);
1164 }
1165
1166 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, frames, &(audiopara.time));
1167 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1168
1169 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1170 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1171 }
1172 /**
1173 * @tc.name Test ReqMmapBuffer API via inputtint time is nullptr.
1174 * @tc.number SUB_Audio_HDI_CaptureGetMmapPosition_0004
1175 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
1176 */
1177 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureGetMmapPosition_0004, Function | MediumTest | Level1)
1178 {
1179 int32_t ret = -1;
1180 uint64_t frames = 0;
1181 struct AudioTimeStamp *time = nullptr;
1182 struct PrepareAudioPara audiopara = {
1183 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .pins = PIN_IN_MIC,
1184 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
1185 };
1186 ASSERT_NE(nullptr, GetAudioManager);
1187 audiopara.manager = GetAudioManager();
1188 ASSERT_NE(nullptr, audiopara.manager);
1189 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1190 &audiopara.capture);
1191 if (ret < 0 || audiopara.capture == nullptr) {
1192 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1193 ASSERT_EQ(nullptr, audiopara.capture);
1194 }
1195
1196 ret = audiopara.capture->attr.GetMmapPosition(audiopara.capture, &frames, time);
1197 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1198
1199 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1200 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1201 }
1202 /**
1203 * @tc.name Test ReqMmapBuffer API via inputtint capture is nullptr.
1204 * @tc.number SUB_Audio_HDI_RenderReqMmapBuffer_0005
1205 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
1206 */
1207 HWTEST_F(AudioHdiCaptureTest, SUB_Audio_HDI_CaptureGetMmapPosition_0005, Function | MediumTest | Level1)
1208 {
1209 int32_t ret = -1;
1210 uint64_t frames = 0;
1211 struct AudioCapture *captureNull = nullptr;
1212 struct PrepareAudioPara audiopara = {
1213 .portType = PORT_IN, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_IN_MIC,
1214 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
1215 };
1216 ASSERT_NE(nullptr, GetAudioManager);
1217 audiopara.manager = GetAudioManager();
1218 ASSERT_NE(nullptr, audiopara.manager);
1219 ret = AudioCreateCapture(audiopara.manager, audiopara.pins, audiopara.adapterName, &audiopara.adapter,
1220 &audiopara.capture);
1221 if (ret < 0 || audiopara.capture == nullptr) {
1222 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
1223 ASSERT_EQ(nullptr, audiopara.capture);
1224 }
1225
1226 ret = audiopara.capture->attr.GetMmapPosition(captureNull, &frames, &(audiopara.time));
1227 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
1228
1229 audiopara.adapter->DestroyCapture(audiopara.adapter, audiopara.capture);
1230 audiopara.manager->UnloadAdapter(audiopara.manager, audiopara.adapter);
1231 }
1232 }