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 class AudioIdlHdiCaptureControlTest : public testing::Test {
25 public:
26 static void SetUpTestCase(void);
27 static void TearDownTestCase(void);
28 void SetUp();
29 void TearDown();
30 struct IAudioCapture *capture = nullptr;
31 struct IAudioAdapter *adapter = nullptr;
32 static TestAudioManager *manager;
33 };
34
35 TestAudioManager *AudioIdlHdiCaptureControlTest::manager = nullptr;
36 using THREAD_FUNC = void *(*)(void *);
37
SetUpTestCase(void)38 void AudioIdlHdiCaptureControlTest::SetUpTestCase(void)
39 {
40 manager = IAudioManagerGet(IS_STUB);
41 ASSERT_NE(nullptr, manager);
42 }
43
TearDownTestCase(void)44 void AudioIdlHdiCaptureControlTest::TearDownTestCase(void)
45 {
46 if (manager != nullptr) {
47 (void)IAudioManagerRelease(manager, IS_STUB);
48 }
49 }
50
SetUp(void)51 void AudioIdlHdiCaptureControlTest::SetUp(void)
52 {
53 ASSERT_NE(nullptr, manager);
54 int32_t ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
55 ASSERT_EQ(HDF_SUCCESS, ret);
56 }
57
TearDown(void)58 void AudioIdlHdiCaptureControlTest::TearDown(void)
59 {
60 int32_t ret = ReleaseCaptureSource(manager, adapter, capture);
61 ASSERT_EQ(HDF_SUCCESS, ret);
62 }
63
64 /**
65 * @tc.name AudioStartCapture_001
66 * @tc.desc Test AudioCaptureStart interface,return 0 if the audiocapture object is started successfully
67 * @tc.type: FUNC
68 */
69 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureStart_001, TestSize.Level1)
70 {
71 int32_t ret = -1;
72 ASSERT_NE(nullptr, capture);
73 ret = capture->Start(capture);
74 EXPECT_EQ(HDF_SUCCESS, ret);
75 capture->Stop(capture);
76 }
77 /**
78 * @tc.name AudioCaptureStartNull_002
79 * @tc.desc Test CaptureStart interface,return -3/-4 if the incoming parameter handle is nullptr
80 * @tc.type: FUNC
81 */
82 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureStartNull_002, TestSize.Level1)
83 {
84 int32_t ret = -1;
85 struct IAudioCapture *captureNull = nullptr;
86 ASSERT_NE(nullptr, capture);
87 ret = capture->Start(captureNull);
88 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
89 capture->Stop(capture);
90 }
91 /**
92 * @tc.name AudioCaptureStart_003
93 * @tc.desc Test AudioCaptureStart interface,return 0 if the Audiocapturestart was successfully called twice
94 * @tc.type: FUNC
95 */
96 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureStart_003, TestSize.Level1)
97 {
98 int32_t ret = -1;
99 ASSERT_NE(nullptr, capture);
100 ret = capture->Start(capture);
101 EXPECT_EQ(HDF_SUCCESS, ret);
102 ret = capture->Start(capture);
103 EXPECT_EQ(AUDIO_HAL_ERR_AI_BUSY, ret);
104 capture->Stop(capture);
105 }
106 /**
107 * @tc.name AudioCaptureStop_001
108 * @tc.desc Test AudioCaptureStop interface,return 0 if the audiocapture object is stopped successfully
109 * @tc.type: FUNC
110 */
111 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureStop_001, TestSize.Level1)
112 {
113 int32_t ret = -1;
114 ASSERT_NE(nullptr, capture);
115 ret = AudioCaptureStartAndOneFrame(capture);
116 EXPECT_EQ(HDF_SUCCESS, ret);
117 ret = capture->Stop(capture);
118 EXPECT_EQ(HDF_SUCCESS, ret);
119 }
120 /**
121 * @tc.name AudioCaptureStop_002
122 * @tc.desc Test AudioCaptureStop interface,return -2 if Audiocapturestop was successfully called twice
123 * @tc.type: FUNC
124 */
125 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureStop_002, TestSize.Level1)
126 {
127 int32_t ret = -1;
128 ASSERT_NE(nullptr, capture);
129 ret = AudioCaptureStartAndOneFrame(capture);
130 EXPECT_EQ(HDF_SUCCESS, ret);
131 ret = capture->Stop(capture);
132 EXPECT_EQ(HDF_SUCCESS, ret);
133 ret = capture->Stop(capture);
134 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
135 }
136 /**
137 * @tc.name AudioCaptureStop_003
138 * @tc.desc Test AudioCaptureStop interface,return 0 if stop and start an audio capture successfully
139 * @tc.type: FUNC
140 */
141 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureStop_003, TestSize.Level1)
142 {
143 int32_t ret = -1;
144 ASSERT_NE(nullptr, capture);
145 ret = AudioCaptureStartAndOneFrame(capture);
146 EXPECT_EQ(HDF_SUCCESS, ret);
147 ret = capture->Stop(capture);
148 EXPECT_EQ(HDF_SUCCESS, ret);
149 ret = capture->Start(capture);
150 EXPECT_EQ(HDF_SUCCESS, ret);
151 capture->Stop(capture);
152 }
153 /**
154 * @tc.name AudioCaptureStop_004
155 * @tc.desc Test AudioCaptureStop interface,return -2 if the capture does not start and stop only
156 * @tc.type: FUNC
157 */
158 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureStop_004, TestSize.Level1)
159 {
160 int32_t ret = -1;
161 ASSERT_NE(nullptr, capture);
162 ret = capture->Stop(capture);
163 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
164 }
165 /**
166 * @tc.name AudioCaptureStopNull_005
167 * @tc.desc Test CaptureStop interface, return -3/-4 if the incoming parameter handle is nullptr
168 * @tc.type: FUNC
169 */
170 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureStopNull_005, TestSize.Level1)
171 {
172 int32_t ret = -1;
173 struct IAudioCapture *captureNull = nullptr;
174 ASSERT_NE(nullptr, capture);
175 ret = AudioCaptureStartAndOneFrame(capture);
176 EXPECT_EQ(HDF_SUCCESS, ret);
177 ret = capture->Stop(captureNull);
178 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
179 }
180 /**
181 * @tc.name AudioCapturePause_001
182 * @tc.desc test HDI CapturePause interface, return 0 if the capture is paused after start
183 * @tc.type: FUNC
184 */
185 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCapturePause_001, TestSize.Level1)
186 {
187 int32_t ret = -1;
188 ASSERT_NE(nullptr, capture);
189 ret = AudioCaptureStartAndOneFrame(capture);
190 EXPECT_EQ(HDF_SUCCESS, ret);
191 ret = capture->Pause(capture);
192 EXPECT_EQ(HDF_SUCCESS, ret);
193 ret = capture->Stop(capture);
194 EXPECT_EQ(HDF_SUCCESS, ret);
195 }
196 /**
197 * @tc.name AudioCapturePause_002
198 * @tc.desc Test CapturePause interface, return -2 the second time if CapturePause is called twice
199 * @tc.type: FUNC
200 */
201 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCapturePause_002, TestSize.Level1)
202 {
203 int32_t ret = -1;
204 ASSERT_NE(nullptr, capture);
205 ret = AudioCaptureStartAndOneFrame(capture);
206 EXPECT_EQ(HDF_SUCCESS, ret);
207 ret = capture->Pause(capture);
208 EXPECT_EQ(HDF_SUCCESS, ret);
209 ret = capture->Pause(capture);
210 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
211 ret = capture->Stop(capture);
212 EXPECT_EQ(HDF_SUCCESS, ret);
213 }
214 /**
215 * @tc.name AudioCapturePauseNull_003
216 * @tc.desc Test CapturePause interface,return -3/-4 if the incoming parameter handle is nullptr
217 * @tc.type: FUNC
218 */
219 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCapturePauseNull_003, TestSize.Level1)
220 {
221 int32_t ret = -1;
222 struct IAudioCapture *captureNull = nullptr;
223 ASSERT_NE(nullptr, capture);
224 ret = AudioCaptureStartAndOneFrame(capture);
225 EXPECT_EQ(HDF_SUCCESS, ret);
226 ret = capture->Pause(captureNull);
227 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
228 ret = capture->Stop(capture);
229 EXPECT_EQ(HDF_SUCCESS, ret);
230 }
231 /**
232 * @tc.name AudioCapturePause_004
233 * @tc.desc Test AudioCapturePause interface,return -1 if the capture is not Started and paused only.
234 * @tc.type: FUNC
235 */
236 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCapturePause_004, TestSize.Level1)
237 {
238 int32_t ret = -1;
239 ASSERT_NE(nullptr, capture);
240 ret = capture->Pause(capture);
241 EXPECT_EQ(HDF_FAILURE, ret);
242 }
243 /**
244 * @tc.name AudioCapturePause_005
245 * @tc.desc Test CapturePause interface, return -1 the capture is paused after stopped.
246 * @tc.type: FUNC
247 */
248 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCapturePause_005, TestSize.Level1)
249 {
250 int32_t ret = -1;
251 ASSERT_NE(nullptr, capture);
252 ret = AudioCaptureStartAndOneFrame(capture);
253 ASSERT_EQ(HDF_SUCCESS, ret);
254 ret = capture->Stop(capture);
255 EXPECT_EQ(HDF_SUCCESS, ret);
256 ret = capture->Pause(capture);
257 EXPECT_EQ(HDF_FAILURE, ret);
258 }
259 /**
260 * @tc.name AudioCaptureResume_001
261 * @tc.desc Test CaptureResume interface,return 0 if the capture is resumed after paused
262 * @tc.type: FUNC
263 */
264 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureResume_001, TestSize.Level1)
265 {
266 int32_t ret = -1;
267 ASSERT_NE(nullptr, capture);
268 ret = AudioCaptureStartAndOneFrame(capture);
269 EXPECT_EQ(HDF_SUCCESS, ret);
270 ret = capture->Pause(capture);
271 EXPECT_EQ(HDF_SUCCESS, ret);
272 ret = capture->Resume(capture);
273 EXPECT_EQ(HDF_SUCCESS, ret);
274 ret = capture->Stop(capture);
275 EXPECT_EQ(HDF_SUCCESS, ret);
276 }
277 /**
278 * @tc.name AudioCaptureResume_002
279 * @tc.desc Test CaptureResume interface,return -2 the second time if the CaptureResume is called twice
280 * @tc.type: FUNC
281 */
282 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureResume_002, TestSize.Level1)
283 {
284 int32_t ret = -1;
285 ASSERT_NE(nullptr, capture);
286 ret = AudioCaptureStartAndOneFrame(capture);
287 EXPECT_EQ(HDF_SUCCESS, ret);
288 ret = capture->Pause(capture);
289 EXPECT_EQ(HDF_SUCCESS, ret);
290 ret = capture->Resume(capture);
291 EXPECT_EQ(HDF_SUCCESS, ret);
292 ret = capture->Resume(capture);
293 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
294 ret = capture->Stop(capture);
295 EXPECT_EQ(HDF_SUCCESS, ret);
296 }
297
298 /**
299 * @tc.name AudioCaptureResume_003
300 * @tc.desc test HDI CaptureResume interface,return -2 if the capture is resumed after started
301 * @tc.type: FUNC
302 */
303 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureResume_003, TestSize.Level1)
304 {
305 int32_t ret = -1;
306 ASSERT_NE(nullptr, capture);
307 ret = AudioCaptureStartAndOneFrame(capture);
308 EXPECT_EQ(HDF_SUCCESS, ret);
309 ret = capture->Resume(capture);
310 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
311 ret = capture->Stop(capture);
312 EXPECT_EQ(HDF_SUCCESS, ret);
313 }
314 /**
315 * @tc.name AudioCaptureResumeNull_004
316 * @tc.desc Test CaptureResume interface, return -3/-4 if the incoming parameter handle is nullptr
317 * @tc.type: FUNC
318 */
319 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureResumeNull_004, TestSize.Level1)
320 {
321 int32_t ret = -1;
322 struct IAudioCapture *captureNull = nullptr;
323 ASSERT_NE(nullptr, capture);
324 ret = AudioCaptureStartAndOneFrame(capture);
325 EXPECT_EQ(HDF_SUCCESS, ret);
326 ret = capture->Pause(capture);
327 EXPECT_EQ(HDF_SUCCESS, ret);
328 ret = capture->Resume(captureNull);
329 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
330 ret = capture->Stop(capture);
331 EXPECT_EQ(HDF_SUCCESS, ret);
332 }
333 /**
334 * @tc.name AudioCaptureResume_005
335 * @tc.desc test HDI CaptureResume interface,return -2 if the capture is resumed after stopped
336 * @tc.type: FUNC
337 */
338 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureResume_005, TestSize.Level1)
339 {
340 int32_t ret = -1;
341 ASSERT_NE(nullptr, capture);
342 ret = AudioCaptureStartAndOneFrame(capture);
343 EXPECT_EQ(HDF_SUCCESS, ret);
344 ret = capture->Stop(capture);
345 EXPECT_EQ(HDF_SUCCESS, ret);
346 ret = capture->Resume(capture);
347 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
348 }
349 /**
350 * @tc.name AudioCaptureResume_006
351 * @tc.desc test HDI CaptureResume interface,return -1 if the capture Continue to start after resume
352 * @tc.type: FUNC
353 */
354 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureResume_006, TestSize.Level1)
355 {
356 int32_t ret = -1;
357 ASSERT_NE(nullptr, capture);
358 ret = AudioCaptureStartAndOneFrame(capture);
359 EXPECT_EQ(HDF_SUCCESS, ret);
360 ret = capture->Pause(capture);
361 EXPECT_EQ(HDF_SUCCESS, ret);
362 ret = capture->Resume(capture);
363 EXPECT_EQ(HDF_SUCCESS, ret);
364 ret = capture->Start(capture);
365 EXPECT_EQ(AUDIO_HAL_ERR_AI_BUSY, ret);
366 capture->Stop(capture);
367 }
368
369 /**
370 * @tc.name AudioCaptureFlush_001
371 * @tc.desc Test CaptureFlush interface,return -2 if the data in the buffer is flushed successfully after stop
372 * @tc.type: FUNC
373 */
374 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureFlush_001, TestSize.Level1)
375 {
376 int32_t ret = -1;
377 ASSERT_NE(nullptr, capture);
378 ret = AudioCaptureStartAndOneFrame(capture);
379 EXPECT_EQ(HDF_SUCCESS, ret);
380 ret = capture->Stop(capture);
381 EXPECT_EQ(HDF_SUCCESS, ret);
382 ret = capture->Flush(capture);
383 EXPECT_EQ(HDF_ERR_NOT_SUPPORT, ret);
384 }
385 /**
386 * @tc.name AudioCaptureFlushNull_002
387 * @tc.desc Test CaptureFlush, return -3/-4 if the data in the buffer is flushed when handle is nullptr
388 * @tc.type: FUNC
389 */
390 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureFlushNull_002, TestSize.Level1)
391 {
392 int32_t ret = -1;
393 struct IAudioCapture *captureNull = nullptr;
394 ASSERT_NE(nullptr, capture);
395 ret = AudioCaptureStartAndOneFrame(capture);
396 EXPECT_EQ(HDF_SUCCESS, ret);
397 ret = capture->Stop(capture);
398 EXPECT_EQ(HDF_SUCCESS, ret);
399 ret = capture->Flush(captureNull);
400 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
401 }
402 /**
403 * @tc.name AudioCaptureTurnStandbyMode_001
404 * @tc.desc Test CaptureTurnStandbyMode interface,return 0 if the interface use correctly.
405 * @tc.type: FUNC
406 */
407 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureTurnStandbyMode_001, TestSize.Level1)
408 {
409 int32_t ret = -1;
410
411 ASSERT_NE(nullptr, capture);
412 ret = AudioCaptureStartAndOneFrame(capture);
413 EXPECT_EQ(HDF_SUCCESS, ret);
414
415 ret = capture->TurnStandbyMode(capture);
416 EXPECT_EQ(HDF_SUCCESS, ret);
417 }
418 /**
419 * @tc.name AudioCaptureTurnStandbyModeNull_002
420 * @tc.desc Test CaptureTurnStandbyMode interface,return -3/-4 setting the incoming parameter self is nullptr.
421 * @tc.type: FUNC
422 */
423 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureTurnStandbyModeNull_002, TestSize.Level1)
424 {
425 int32_t ret = -1;
426 struct IAudioCapture *captureNull = nullptr;
427
428 ASSERT_NE(nullptr, capture);
429 ret = AudioCaptureStartAndOneFrame(capture);
430 EXPECT_EQ(HDF_SUCCESS, ret);
431
432 ret = capture->TurnStandbyMode(captureNull);
433 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
434 capture->Stop(capture);
435 }
436
437 /**
438 * @tc.name AudioCaptureAudioDevDump_001
439 * @tc.desc Test CaptureAudioDevDump interface,return 0 if the interface use correctly.
440 * @tc.type: FUNC
441 */
442 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureAudioDevDump_001, TestSize.Level1)
443 {
444 int32_t ret = -1;
445 char pathBuf[] = "./DevDump.log";
446 ASSERT_NE(nullptr, capture);
447 FILE *fp = fopen(pathBuf, "wb+");
448 ASSERT_NE(nullptr, fp);
449 int fd = fileno(fp);
450 if (fd == -1) {
451 fclose(fp);
452 ASSERT_NE(fd, -1);
453 }
454 struct PrepareAudioPara audiopara = {
455 .capture = capture, .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(),
456 .pins = PIN_OUT_SPEAKER, .path = AUDIO_CAPTURE_FILE.c_str()
457 };
458 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
459 if (ret < 0) {
460 fclose(fp);
461 ASSERT_EQ(HDF_SUCCESS, ret);
462 }
463 sleep(1);
464 ret = audiopara.capture->Pause(audiopara.capture);
465 EXPECT_EQ(HDF_SUCCESS, ret);
466 ret = audiopara.capture->AudioDevDump(audiopara.capture, RANGE, fd);
467 EXPECT_EQ(HDF_SUCCESS, ret);
468 sleep(1);
469 ret = audiopara.capture->Resume(audiopara.capture);
470 EXPECT_EQ(HDF_SUCCESS, ret);
471 fclose(fp);
472 ret = ThreadRelease(audiopara);
473 EXPECT_EQ(HDF_SUCCESS, ret);
474 }
475 /**
476 * @tc.name AudioCaptureAudioDevDump_002
477 * @tc.desc Test CaptureAudioDevDump interface,return 0 if the interface use correctly.
478 * @tc.type: FUNC
479 */
480 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureAudioDevDump_002, TestSize.Level1)
481 {
482 int32_t ret = -1;
483 char path[] = "./DevDump.log";
484 ASSERT_NE(nullptr, capture);
485 FILE *file = fopen(path, "wb+");
486 ASSERT_NE(nullptr, file);
487 int fd = fileno(file);
488 if (fd == -1) {
489 fclose(file);
490 ASSERT_NE(fd, -1);
491 }
492 struct PrepareAudioPara audiopara = {
493 .capture = capture, .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(),
494 .pins = PIN_OUT_SPEAKER, .path = AUDIO_CAPTURE_FILE.c_str()
495 };
496 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)RecordAudio, &audiopara);
497 if (ret < 0) {
498 fclose(file);
499 ASSERT_EQ(HDF_SUCCESS, ret);
500 }
501 sleep(1);
502 ret = audiopara.capture->Pause(audiopara.capture);
503 EXPECT_EQ(HDF_SUCCESS, ret);
504 ret = audiopara.capture->AudioDevDump(audiopara.capture, OUT_OF_RANGE-1, fd);
505 EXPECT_EQ(HDF_SUCCESS, ret);
506 sleep(1);
507 ret = audiopara.capture->Resume(audiopara.capture);
508 EXPECT_EQ(HDF_SUCCESS, ret);
509 fclose(file);
510 ret = ThreadRelease(audiopara);
511 EXPECT_EQ(HDF_SUCCESS, ret);
512 }
513
514 /**
515 * @tc.name AudioCaptureAudioDevDump_003
516 * @tc.desc Test CaptureAudioDevDump interface,return -3 if setting the incoming parameter range is out of range
517 * @tc.type: FUNC
518 */
519 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureAudioDevDump_003, TestSize.Level1)
520 {
521 int32_t ret = -1;
522 char pathBuf[] = "./DevDump.log";
523 ASSERT_NE(nullptr, capture);
524 FILE *file = fopen(pathBuf, "wb+");
525 ASSERT_NE(nullptr, file);
526 int fd = fileno(file);
527 if (fd == -1) {
528 fclose(file);
529 ASSERT_NE(fd, -1);
530 }
531 ret = capture->AudioDevDump(capture, RANGE-1, fd);
532 EXPECT_EQ(HDF_SUCCESS, ret);
533 ret = capture->AudioDevDump(capture, OUT_OF_RANGE, fd);
534 EXPECT_EQ(HDF_SUCCESS, ret);
535 fclose(file);
536 }
537 /**
538 * @tc.name AudioCaptureAudioDevDumpNull_004
539 * @tc.desc Test CaptureAudioDevDump interface,return -3/-4 if setting the incoming parameter self is nullptr
540 * @tc.type: FUNC
541 */
542 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureAudioDevDumpNull_004, TestSize.Level1)
543 {
544 int32_t ret = -1;
545 struct IAudioCapture *captureNull = nullptr;
546 char pathBuf[] = "./DevDump.log";
547 ASSERT_NE(nullptr, capture);
548 FILE *fp = fopen(pathBuf, "wb+");
549 ASSERT_NE(nullptr, fp);
550 int fd = fileno(fp);
551 if (fd == -1) {
552 fclose(fp);
553 ASSERT_NE(fd, -1);
554 }
555 ret = capture->AudioDevDump(captureNull, RANGE, fd);
556 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
557 fclose(fp);
558 }
559 /**
560 * @tc.name AudioCaptureAudioDevDump_005
561 * @tc.desc Test CaptureAudioDevDump interface,return -3 if setting the incoming parameter fd is illegal
562 * @tc.type: FUNC
563 */
564 HWTEST_F(AudioIdlHdiCaptureControlTest, AudioCaptureAudioDevDump_005, TestSize.Level1)
565 {
566 int32_t ret = -1;
567
568 ASSERT_NE(nullptr, capture);
569 int fd = 3;
570 ret = capture->AudioDevDump(capture, RANGE, fd);
571 EXPECT_EQ(HDF_SUCCESS, ret);
572 }
573 }
574