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