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