1 /*
2 * Copyright (c) 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 #include <gtest/gtest.h>
17 #include "hdi_service_common.h"
18
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Audio;
22
23 namespace {
24 const int BUFFER_SIZE = 16384;
25 const int BUFFER_SIZE_LITTLE = 0;
26 const uint64_t FILESIZE = 1024;
27
28 class AudioIdlHdiCaptureTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34 struct IAudioAdapter *adapter = nullptr;
35 struct IAudioCapture *capture = nullptr;
36 static TestAudioManager *manager;
37 };
38
39 TestAudioManager *AudioIdlHdiCaptureTest::manager = nullptr;
40 using THREAD_FUNC = void *(*)(void *);
41
SetUpTestCase(void)42 void AudioIdlHdiCaptureTest::SetUpTestCase(void)
43 {
44 manager = IAudioManagerGet(IS_STUB);
45 ASSERT_NE(nullptr, manager);
46 }
47
TearDownTestCase(void)48 void AudioIdlHdiCaptureTest::TearDownTestCase(void)
49 {
50 if (manager != nullptr) {
51 (void)IAudioManagerRelease(manager, IS_STUB);
52 }
53 }
54
SetUp(void)55 void AudioIdlHdiCaptureTest::SetUp(void)
56 {
57 ASSERT_NE(nullptr, manager);
58 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
59 ASSERT_EQ(HDF_SUCCESS, ret);
60 }
61
TearDown(void)62 void AudioIdlHdiCaptureTest::TearDown(void)
63 {
64 int32_t ret = ReleaseCaptureSource(manager, adapter, capture);
65 ASSERT_EQ(HDF_SUCCESS, ret);
66 }
67
68 /**
69 * @tc.name AudioCaptureFrame_001
70 * @tc.desc test AudioCaptureCaptureFrame interface,Returns 0 if the input data is read successfully
71 * @tc.type: FUNC
72 */
73 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureFrame_001, TestSize.Level1)
74 {
75 int32_t ret;
76 uint32_t replyBytes = BUFFER_SIZE;
77 uint64_t requestBytes = BUFFER_SIZE;
78 ASSERT_NE(nullptr, capture);
79 ret = capture->Start(capture);
80 EXPECT_EQ(HDF_SUCCESS, ret);
81 int8_t *frame = (int8_t *)calloc(1, BUFFER_SIZE);
82 EXPECT_NE(nullptr, frame);
83 ret = capture->CaptureFrame(capture, frame, &replyBytes, requestBytes);
84 EXPECT_EQ(HDF_SUCCESS, ret);
85 capture->Stop(capture);
86
87 if (frame != nullptr) {
88 free(frame);
89 frame = nullptr;
90 }
91 }
92 /**
93 * @tc.name AudioCaptureFrameNull_002
94 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -3 if the incoming parameter frame is nullptr
95 * @tc.type: FUNC
96 */
97 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureFrameNull_002, TestSize.Level1)
98 {
99 int32_t ret;
100 uint32_t replyBytes = BUFFER_SIZE;
101 uint64_t requestBytes = BUFFER_SIZE;
102 int8_t *frame = nullptr;
103 ASSERT_NE(nullptr, capture);
104 ret = capture->Start(capture);
105 EXPECT_EQ(HDF_SUCCESS, ret);
106 ret = capture->CaptureFrame(capture, frame, &replyBytes, requestBytes);
107 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
108 capture->Stop(capture);
109 }
110 #ifdef AUDIO_ADM_PASSTHROUGH
111 /**
112 * @tc.name AudioCaptureFrameNull_003
113 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -3 if the incoming parameter replyBytes is nullptr
114 * @tc.type: FUNC
115 */
116 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureFrameNull_003, TestSize.Level1)
117 {
118 int32_t ret;
119 uint64_t requestBytes = BUFFER_SIZE;
120 uint32_t *replyBytes = nullptr;
121 ASSERT_NE(nullptr, capture);
122 ret = capture->Start(capture);
123 EXPECT_EQ(HDF_SUCCESS, ret);
124 int8_t *frame = (int8_t *)calloc(1, BUFFER_SIZE);
125 EXPECT_NE(nullptr, frame);
126 ret = capture->CaptureFrame(capture, frame, replyBytes, requestBytes);
127 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
128
129 capture->Stop(capture);
130
131 if (frame != nullptr) {
132 free(frame);
133 frame = nullptr;
134 }
135 }
136 #endif
137 /**
138 * @tc.name AudioCaptureFrameNull_004
139 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -3/-4 if the incoming parameter capture is nullptr
140 * @tc.type: FUNC
141 */
142 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureFrameNull_004, TestSize.Level1)
143 {
144 int32_t ret;
145 uint64_t requestBytes = BUFFER_SIZE;
146 uint32_t replyBytes = BUFFER_SIZE;
147 struct IAudioCapture *captureNull = nullptr;
148 ASSERT_NE(nullptr, capture);
149 ret = capture->Start(capture);
150 EXPECT_EQ(HDF_SUCCESS, ret);
151 int8_t *frame = (int8_t *)calloc(1, BUFFER_SIZE);
152 EXPECT_NE(nullptr, frame);
153 ret = capture->CaptureFrame(captureNull, frame, &replyBytes, requestBytes);
154 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
155
156 capture->Stop(capture);
157
158 if (frame != nullptr) {
159 free(frame);
160 frame = nullptr;
161 }
162 }
163 /**
164 * @tc.name AudioCaptureFrame_005
165 * @tc.desc Test AudioCaptureFrame interface,Returns -3 if without calling interface capturestart
166 * @tc.type: FUNC
167 */
168 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureFrame_005, TestSize.Level1)
169 {
170 int32_t ret;
171 uint64_t requestBytes = BUFFER_SIZE;
172 uint32_t replyBytes = BUFFER_SIZE;
173 ASSERT_NE(nullptr, capture);
174 int8_t *frame = (int8_t *)calloc(1, BUFFER_SIZE);
175 EXPECT_NE(nullptr, frame);
176 ret = capture->CaptureFrame(capture, frame, &replyBytes, requestBytes);
177 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
178
179 if (frame != nullptr) {
180 free(frame);
181 frame = nullptr;
182 }
183 }
184 /**
185 less than interface requirements
186 * @tc.name AudioCaptureFrame_006
187 * @tc.desc test AudioCaptureCaptureFrame interface,Returns -1 if the incoming parameter
188 requestBytes less than interface requirements
189 * @tc.type: FUNC
190 */
191 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureFrame_006, TestSize.Level1)
192 {
193 int32_t ret;
194 uint64_t requestBytes = BUFFER_SIZE_LITTLE;
195 uint32_t replyBytes = BUFFER_SIZE;
196
197 ASSERT_NE(nullptr, capture);
198 ret = capture->Start(capture);
199 EXPECT_EQ(HDF_SUCCESS, ret);
200 int8_t *frame = (int8_t *)calloc(1, BUFFER_SIZE);
201 EXPECT_NE(nullptr, frame);
202 ret = capture->CaptureFrame(capture, frame, &replyBytes, requestBytes);
203 EXPECT_EQ(HDF_FAILURE, ret);
204
205 capture->Stop(capture);
206
207 if (frame != nullptr) {
208 free(frame);
209 frame = nullptr;
210 }
211 }
212 /**
213 * @tc.name AudioCaptureGetCapturePosition_001
214 * @tc.desc Test AudioCaptureGetCapturePosition interface,Returns 0 if get CapturePosition during playing.
215 * @tc.type: FUNC
216 */
217 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureGetCapturePosition_001, TestSize.Level1)
218 {
219 int32_t ret;
220 uint64_t frames = 0;
221 int64_t timeExp = 0;
222 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
223 ASSERT_NE(nullptr, capture);
224 struct PrepareAudioPara audiopara = {
225 .capture = capture, .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC,
226 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
227 };
228
229 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
230 ASSERT_EQ(HDF_SUCCESS, ret);
231 sleep(1);
232 if (audiopara.capture != nullptr) {
233 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &time);
234 EXPECT_EQ(HDF_SUCCESS, ret);
235 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
236 EXPECT_GT(frames, INITIAL_VALUE);
237 }
238
239 ret = ThreadRelease(audiopara);
240 EXPECT_EQ(HDF_SUCCESS, ret);
241 }
242 /**
243 * @tc.name AudioCaptureGetCapturePosition_002
244 * @tc.desc Test GetCapturePosition interface,Returns 0 if get Position after Pause and resume during playing
245 * @tc.type: FUNC
246 */
247 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureGetCapturePosition_002, TestSize.Level1)
248 {
249 int32_t ret;
250 int64_t timeExp = 0;
251 uint64_t frames = 0;
252 struct AudioTimeStamp timeCount = {.tvSec = 0, .tvNSec = 0};
253 ASSERT_NE(nullptr, capture);
254 struct PrepareAudioPara audiopara = {
255 .capture = capture, .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC,
256 .path = AUDIO_CAPTURE_FILE.c_str(), .fileSize = FILESIZE
257 };
258
259 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
260 ASSERT_EQ(HDF_SUCCESS, ret);
261 sleep(1);
262 if (audiopara.capture != nullptr) {
263 ret = audiopara.capture->Pause(audiopara.capture);
264 EXPECT_EQ(HDF_SUCCESS, ret);
265 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &timeCount);
266 EXPECT_EQ(HDF_SUCCESS, ret);
267 EXPECT_GT((timeCount.tvSec) * SECTONSEC + (timeCount.tvNSec), timeExp);
268 EXPECT_GT(frames, INITIAL_VALUE);
269 ret = audiopara.capture->Resume(audiopara.capture);
270 EXPECT_EQ(HDF_SUCCESS, ret);
271 ret = audiopara.capture->GetCapturePosition(audiopara.capture, &frames, &timeCount);
272 EXPECT_EQ(HDF_SUCCESS, ret);
273 EXPECT_GT((timeCount.tvSec) * SECTONSEC + (timeCount.tvNSec), timeExp);
274 EXPECT_GT(frames, INITIAL_VALUE);
275 }
276
277 ret = ThreadRelease(audiopara);
278 EXPECT_EQ(HDF_SUCCESS, ret);
279 }
280 /**
281 * @tc.name AudioCaptureGetCapturePosition_003
282 * @tc.desc Test GetCapturePosition interface,Returns 0 if get CapturePosition after stop during playing
283 * @tc.type: FUNC
284 */
285 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureGetCapturePosition_003, TestSize.Level1)
286 {
287 int32_t ret;
288 uint64_t frames = 0;
289 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
290 int64_t timeExp = 0;
291 ASSERT_NE(nullptr, capture);
292 ret = AudioCaptureStartAndOneFrame(capture);
293 ASSERT_EQ(HDF_SUCCESS, ret);
294 ret = capture->Stop(capture);
295 EXPECT_EQ(HDF_SUCCESS, ret);
296 ret = capture->GetCapturePosition(capture, &frames, &time);
297 EXPECT_EQ(HDF_SUCCESS, ret);
298 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
299 EXPECT_GT(frames, INITIAL_VALUE);
300 }
301 /**
302 * @tc.name AudioCaptureGetCapturePosition_004
303 * @tc.desc Test GetCapturePosition interface, return 0 if get CapturePosition after the object is created
304 * @tc.type: FUNC
305 */
306 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureGetCapturePosition_004, TestSize.Level1)
307 {
308 int32_t ret;
309 uint64_t frames = 0;
310 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
311 int64_t timeExp = 0;
312 ASSERT_NE(nullptr, capture);
313 ret = capture->GetCapturePosition(capture, &frames, &time);
314 EXPECT_EQ(HDF_SUCCESS, ret);
315 EXPECT_EQ((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
316 }
317 /**
318 * @tc.name AudioCaptureGetCapturePositionNull_005
319 * @tc.desc Test GetCapturePosition interface, return -3/-4 if setting the parameter Capture is nullptr
320 * @tc.type: FUNC
321 */
322 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureGetCapturePositionNull_005, TestSize.Level1)
323 {
324 int32_t ret;
325 struct IAudioCapture *captureNull = nullptr;
326 uint64_t frames = 0;
327 struct AudioTimeStamp time = {};
328 ASSERT_NE(nullptr, capture);
329 ret = AudioCaptureStartAndOneFrame(capture);
330 ASSERT_EQ(HDF_SUCCESS, ret);
331 ret = capture->GetCapturePosition(captureNull, &frames, &time);
332 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
333 capture->Stop(capture);
334 }
335 /**
336 * @tc.name AudioCaptureGetCapturePositionNull_006
337 * @tc.desc Test GetCapturePosition interface, return -3 if setting the parameter frames is nullptr
338 * @tc.type: FUNC
339 */
340 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureGetCapturePositionNull_006, TestSize.Level1)
341 {
342 int32_t ret;
343 uint64_t *framesNull = nullptr;
344 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
345 ASSERT_NE(nullptr, capture);
346 ret = AudioCaptureStartAndOneFrame(capture);
347 ASSERT_EQ(HDF_SUCCESS, ret);
348 ret = capture->GetCapturePosition(capture, framesNull, &time);
349 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
350 capture->Stop(capture);
351 }
352 /**
353 * @tc.name AudioCaptureGetCapturePositionNull_007
354 * @tc.desc Test GetCapturePosition interface, return -3 if setting the parameter time is nullptr
355 * @tc.type: FUNC
356 */
357 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureGetCapturePositionNull_007, TestSize.Level1)
358 {
359 int32_t ret;
360 uint64_t frames = 0;
361 struct AudioTimeStamp *timeNull = nullptr;
362 ASSERT_NE(nullptr, capture);
363 ret = AudioCaptureStartAndOneFrame(capture);
364 ASSERT_EQ(HDF_SUCCESS, ret);
365 ret = capture->GetCapturePosition(capture, &frames, timeNull);
366 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
367 capture->Stop(capture);
368 }
369 /**
370 * @tc.name AudioCaptureGetCapturePosition_008
371 * @tc.desc Test GetCapturePosition interface, return 0 if the GetCapturePosition was called twice
372 * @tc.type: FUNC
373 */
374 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureGetCapturePosition_008, TestSize.Level1)
375 {
376 int32_t ret;
377 uint64_t frames = 0;
378 struct AudioTimeStamp time = {.tvSec = 0, .tvNSec = 0};
379 struct AudioTimeStamp timeSec = {.tvSec = 0, .tvNSec = 0};
380 int64_t timeExp = 0;
381 ASSERT_NE(nullptr, capture);
382 ret = AudioCaptureStartAndOneFrame(capture);
383 ASSERT_EQ(HDF_SUCCESS, ret);
384 ret = capture->GetCapturePosition(capture, &frames, &time);
385 EXPECT_EQ(HDF_SUCCESS, ret);
386 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
387 EXPECT_GT(frames, INITIAL_VALUE);
388 ret = capture->GetCapturePosition(capture, &frames, &timeSec);
389 EXPECT_EQ(HDF_SUCCESS, ret);
390 EXPECT_GT((time.tvSec) * SECTONSEC + (time.tvNSec), timeExp);
391 EXPECT_GT(frames, INITIAL_VALUE);
392 capture->Stop(capture);
393 }
394 /**
395 * @tc.name AudioCaptureReqMmapBuffer_001
396 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully
397 * @tc.type: FUNC
398 */
399 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureReqMmapBuffer_001, TestSize.Level1)
400 {
401 bool isRender = false;
402 int32_t reqSize = 0;
403 struct AudioMmapBufferDescripter desc = {};
404 ASSERT_NE(nullptr, capture);
405 int32_t ret = InitMmapDesc(AUDIO_LOW_LATENCY_CAPTURE_FILE, desc, reqSize, isRender);
406 EXPECT_EQ(HDF_SUCCESS, ret);
407 ret = capture->Start(capture);
408 EXPECT_EQ(HDF_SUCCESS, ret);
409 ret = capture->ReqMmapBuffer(capture, reqSize, &desc);
410 EXPECT_EQ(HDF_SUCCESS, ret);
411 if (ret == 0) {
412 munmap(desc.memoryAddress, reqSize);
413 }
414 capture->Stop(capture);
415 }
416 /**
417 the size of actual audio file
418 * @tc.name AudioRenderReqMmapBuffer_002
419 * @tc.desc Test ReqMmapBuffer interface,return -1 if call ReqMmapBuffer interface unsuccessful when setting the
420 incoming parameter reqSize is bigger than the size of actual audio file
421 * @tc.type: FUNC
422 */
423 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureReqMmapBuffer_002, TestSize.Level1)
424 {
425 int32_t ret;
426 bool isRender = false;
427 int32_t reqSize = 0;
428 struct AudioMmapBufferDescripter desc = {};
429 ASSERT_NE(nullptr, capture);
430 ret = InitMmapDesc(AUDIO_LOW_LATENCY_CAPTURE_FILE, desc, reqSize, isRender);
431 EXPECT_EQ(HDF_SUCCESS, ret);
432 reqSize = reqSize + BUFFER_LENTH;
433 ret = capture->Start(capture);
434 EXPECT_EQ(HDF_SUCCESS, ret);
435 ret = capture->ReqMmapBuffer(capture, reqSize, &desc);
436 EXPECT_EQ(HDF_FAILURE, ret);
437 capture->Stop(capture);
438 }
439 /**
440 the size of actual audio file
441 * @tc.name AudioCaptureReqMmapBuffer_003
442 * @tc.desc Test ReqMmapBuffer interface,return 0 if call ReqMmapBuffer interface successfully when setting the
443 incoming parameter reqSize is smaller than the size of actual audio file
444 * @tc.type: FUNC
445 */
446 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureReqMmapBuffer_003, TestSize.Level1)
447 {
448 int32_t ret;
449 bool isRender = false;
450 int32_t reqSize = 0;
451 struct AudioMmapBufferDescripter desc = {};
452 ASSERT_NE(nullptr, capture);
453 ret = InitMmapDesc(AUDIO_LOW_LATENCY_CAPTURE_FILE, desc, reqSize, isRender);
454 EXPECT_EQ(HDF_SUCCESS, ret);
455 reqSize = reqSize / 2;
456 ret = capture->Start(capture);
457 EXPECT_EQ(HDF_SUCCESS, ret);
458 ret = capture->ReqMmapBuffer(capture, reqSize, &desc);
459 EXPECT_EQ(HDF_SUCCESS, ret);
460 if (ret == 0) {
461 munmap(desc.memoryAddress, reqSize);
462 }
463 capture->Stop(capture);
464 }
465 /**
466 * @tc.name AudioCaptureReqMmapBuffer_004
467 * @tc.desc Test ReqMmapBuffer interface,return -1 if call ReqMmapBuffer interface unsuccessful when setting the
468 incoming parameter reqSize is zero
469 * @tc.type: FUNC
470 */
471 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureReqMmapBuffer_004, TestSize.Level1)
472 {
473 int32_t ret;
474 bool isRender = false;
475 int32_t reqSize = 0;
476 struct AudioMmapBufferDescripter desc = {};
477 ASSERT_NE(nullptr, capture);
478 ret = InitMmapDesc(AUDIO_LOW_LATENCY_CAPTURE_FILE, desc, reqSize, isRender);
479 EXPECT_EQ(HDF_SUCCESS, ret);
480 reqSize = 0;
481 ret = capture->Start(capture);
482 EXPECT_EQ(HDF_SUCCESS, ret);
483 ret = capture->ReqMmapBuffer(capture, reqSize, &desc);
484 EXPECT_EQ(HDF_FAILURE, ret);
485 capture->Stop(capture);
486 }
487 /**
488 * @tc.name AudioCaptureReqMmapBuffer_005
489 * @tc.desc Test ReqMmapBuffer interface,return -1 if call ReqMmapBuffer interface unsuccessful when setting the
490 incoming parameter memoryFd of desc is illegal
491 * @tc.type: FUNC
492 */
493 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureReqMmapBuffer_005, TestSize.Level1)
494 {
495 bool isRender = false;
496 int32_t reqSize = 0;
497 struct AudioMmapBufferDescripter desc = {};
498 ASSERT_NE(nullptr, capture);
499 int32_t ret = InitMmapDesc(AUDIO_LOW_LATENCY_CAPTURE_FILE, desc, reqSize, isRender);
500 EXPECT_EQ(HDF_SUCCESS, ret);
501 ret = capture->Start(capture);
502 EXPECT_EQ(HDF_SUCCESS, ret);
503 free(desc.filePath);
504 desc.filePath = strdup("/audiotest/audio.wav");
505 ret = capture->ReqMmapBuffer(capture, reqSize, &desc);
506 EXPECT_EQ(HDF_FAILURE, ret);
507 capture->Stop(capture);
508 }
509 /**
510 * @tc.name AudioCaptureReqMmapBufferNull_006
511 * @tc.desc Test ReqMmapBuffer interface,return -3/-4 if call ReqMmapBuffer interface unsuccessful when setting the
512 incoming parameter handle is nullptr
513 * @tc.type: FUNC
514 */
515 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureReqMmapBufferNull_006, TestSize.Level1)
516 {
517 int32_t ret;
518 bool isRender = false;
519 int32_t reqSize = 0;
520 struct AudioMmapBufferDescripter desc = {};
521 struct IAudioCapture *captureNull = nullptr;
522 ASSERT_NE(nullptr, capture);
523 ret = InitMmapDesc(AUDIO_LOW_LATENCY_CAPTURE_FILE, desc, reqSize, isRender);
524 EXPECT_EQ(HDF_SUCCESS, ret);
525 ret = capture->Start(capture);
526 EXPECT_EQ(HDF_SUCCESS, ret);
527 ret = capture->ReqMmapBuffer(captureNull, reqSize, &desc);
528 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
529 capture->Stop(capture);
530 }
531 /**
532 * @tc.name AudioCaptureReqMmapBufferNull_007
533 * @tc.desc Test ReqMmapBuffer interface,return -3 if call ReqMmapBuffer interface unsuccessful when setting the
534 incoming parameter desc is nullptr
535 * @tc.type: FUNC
536 */
537 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureReqMmapBufferNull_007, TestSize.Level1)
538 {
539 int32_t ret;
540 uint32_t reqSize = 0;
541 struct AudioMmapBufferDescripter *descNull = nullptr;
542 ASSERT_NE(nullptr, capture);
543 reqSize = FILE_CAPTURE_SIZE;
544 ret = capture->Start(capture);
545 EXPECT_EQ(HDF_SUCCESS, ret);
546 ret = capture->ReqMmapBuffer(capture, reqSize, descNull);
547 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
548 capture->Stop(capture);
549 }
550 /**
551 * @tc.name AudioCaptureGetMmapPosition_001
552 * @tc.desc Test GetMmapPosition interface,return 0 if Getting position successfully.
553 * @tc.type: FUNC
554 */
555 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureGetMmapPosition_001, TestSize.Level1)
556 {
557 int32_t ret;
558 uint64_t frames = 0;
559 uint64_t framesCapturing = 0;
560 uint64_t framesExpCapture = 0;
561 int64_t timeExp = 0;
562 int64_t timeExpCaptureing = 0;
563 ASSERT_NE(nullptr, capture);
564 struct PrepareAudioPara audiopara = {
565 .capture = capture, .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC,
566 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
567 };
568
569 ret = audiopara.capture->GetMmapPosition(audiopara.capture, &frames, &(audiopara.time));
570 EXPECT_EQ(HDF_SUCCESS, ret);
571 EXPECT_EQ((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
572 EXPECT_EQ(frames, INITIAL_VALUE);
573 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordMapAudio, &audiopara);
574 ASSERT_EQ(HDF_SUCCESS, ret);
575
576 sleep(1);
577 ret = audiopara.capture->GetMmapPosition(audiopara.capture, &framesCapturing, &(audiopara.time));
578 EXPECT_EQ(HDF_SUCCESS, ret);
579 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExp);
580 EXPECT_GT(framesCapturing, INITIAL_VALUE);
581 timeExpCaptureing = (audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec);
582 void *result = nullptr;
583 pthread_join(audiopara.tids, &result);
584 EXPECT_EQ(HDF_SUCCESS, (intptr_t)result);
585 ret = audiopara.capture->GetMmapPosition(audiopara.capture, &framesExpCapture, &(audiopara.time));
586 EXPECT_EQ(HDF_SUCCESS, ret);
587 EXPECT_GT((audiopara.time.tvSec) * SECTONSEC + (audiopara.time.tvNSec), timeExpCaptureing);
588 EXPECT_GT(framesExpCapture, framesCapturing);
589
590 audiopara.capture->Stop(audiopara.capture);
591 }
592
593 /**
594 * @tc.name AudioCaptureGetMmapPositionNull_003
595 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
596 * @tc.type: FUNC
597 */
598 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureGetMmapPositionNull_003, TestSize.Level1)
599 {
600 int32_t ret;
601 uint64_t *frames = nullptr;
602 ASSERT_NE(nullptr, capture);
603 struct PrepareAudioPara audiopara = {
604 .capture = capture, .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC,
605 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
606 };
607
608 ret = audiopara.capture->GetMmapPosition(audiopara.capture, frames, &(audiopara.time));
609 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
610 }
611 /**
612 * @tc.name AudioCaptureGetMmapPositionNull_004
613 * @tc.desc Test GetMmapPosition interface,return -3 if Error in incoming parameter.
614 * @tc.type: FUNC
615 */
616 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureGetMmapPositionNull_004, TestSize.Level1)
617 {
618 int32_t ret;
619 uint64_t frames = 0;
620 struct AudioTimeStamp *time = nullptr;
621 ASSERT_NE(nullptr, capture);
622 struct PrepareAudioPara audiopara = {
623 .capture = capture, .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC,
624 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
625 };
626
627 ret = audiopara.capture->GetMmapPosition(audiopara.capture, &frames, time);
628 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
629 }
630 /**
631 * @tc.name AudioCaptureGetMmapPositionNull_005
632 * @tc.desc Test GetMmapPosition interface,return -3/-4 if Error in incoming parameter.
633 * @tc.type: FUNC
634 */
635 HWTEST_F(AudioIdlHdiCaptureTest, AudioCaptureGetMmapPositionNull_005, TestSize.Level1)
636 {
637 int32_t ret;
638 uint64_t frames = 0;
639 struct IAudioCapture *captureNull = nullptr;
640 ASSERT_NE(nullptr, capture);
641 struct PrepareAudioPara audiopara = {
642 .capture = capture, .portType = PORT_IN, .adapterName = ADAPTER_NAME.c_str(), .pins = PIN_IN_MIC,
643 .path = AUDIO_LOW_LATENCY_CAPTURE_FILE.c_str()
644 };
645
646 ret = audiopara.capture->GetMmapPosition(captureNull, &frames, &(audiopara.time));
647 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
648 }
649 }
650