1 /*
2 * Copyright (c) 2024 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 "pa_capturer_stream_impl.h"
18 #include "audio_errors.h"
19 #include "pa_adapter_manager.h"
20 #include <pulse/pulseaudio.h>
21 #include "pulse/stream.h"
22 #include "audio_system_manager.h"
23
24 using namespace testing::ext;
25 namespace OHOS {
26 namespace AudioStandard {
27 const int32_t CAPTURER_FLAG = 10;
28 static std::shared_ptr<PaAdapterManager> adapterManager;
29
30 class PaCapturerStreamUnitTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp();
35 void TearDown();
36 std::shared_ptr<PaCapturerStreamImpl> CreatePaCapturerStreamImpl();
37 };
38
SetUpTestCase(void)39 void PaCapturerStreamUnitTest::SetUpTestCase(void)
40 {
41 // input testsuit setup step，setup invoked before all testcases
42 }
43
TearDownTestCase(void)44 void PaCapturerStreamUnitTest::TearDownTestCase(void)
45 {
46 // input testsuit teardown step，teardown invoked after all testcases
47 }
48
SetUp(void)49 void PaCapturerStreamUnitTest::SetUp(void)
50 {
51 // input testcase setup step，setup invoked before each testcases
52 }
53
TearDown(void)54 void PaCapturerStreamUnitTest::TearDown(void)
55 {
56 // input testcase teardown step，teardown invoked after each testcases
57 }
58
59 #ifdef HAS_FEATURE_INNERCAPTURER
LoadPaPort()60 void LoadPaPort()
61 {
62 AudioPlaybackCaptureConfig checkConfig;
63 int32_t checkInnerCapId = 0;
64 AudioSystemManager::GetInstance()->CheckCaptureLimit(checkConfig, checkInnerCapId);
65 }
66
ReleasePaPort()67 void ReleasePaPort()
68 {
69 AudioSystemManager::GetInstance()->ReleaseCaptureLimit(1);
70 }
71 #endif
72
GetInnerCapConfig()73 static AudioProcessConfig GetInnerCapConfig()
74 {
75 AudioProcessConfig config;
76 config.appInfo.appUid = CAPTURER_FLAG;
77 config.appInfo.appPid = CAPTURER_FLAG;
78 config.streamInfo.format = SAMPLE_S32LE;
79 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
80 config.streamInfo.channels = STEREO;
81 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
82 config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
83 config.streamType = AudioStreamType::STREAM_MUSIC;
84 config.deviceType = DEVICE_TYPE_USB_HEADSET;
85 config.capturerInfo.sourceType = SOURCE_TYPE_WAKEUP;
86 config.innerCapId = 1;
87 return config;
88 }
89
CreatePaCapturerStreamImpl()90 std::shared_ptr<PaCapturerStreamImpl> PaCapturerStreamUnitTest::CreatePaCapturerStreamImpl()
91 {
92 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
93 adapterManager->InitPaContext();
94 AudioProcessConfig processConfig = GetInnerCapConfig();
95 uint32_t sessionId = 123456;
96 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
97 std::shared_ptr<ICapturerStream> capturerStream = adapterManager->CreateCapturerStream(processConfig, stream);
98 std::shared_ptr<PaCapturerStreamImpl> capturerStreamImpl =
99 std::static_pointer_cast<PaCapturerStreamImpl>(capturerStream);
100 return capturerStreamImpl;
101 }
102
103 /**
104 * @tc.name : Test PaCapturerStreamImpl API
105 * @tc.type : FUNC
106 * @tc.number: PaCapturerStream_001
107 * @tc.desc : Test PaCapturerStreamImpl interface.
108 */
109 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_001, TestSize.Level1)
110 {
111 #ifdef HAS_FEATURE_INNERCAPTURER
112 LoadPaPort();
113 #endif
114 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
115 uint64_t framesReadRet = 0;
116 capturerStreamImplRet->byteSizePerFrame_ = 0;
117 auto ret = capturerStreamImplRet->GetStreamFramesRead(framesReadRet);
118 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
119
120 capturerStreamImplRet->byteSizePerFrame_ = 1;
121 ret = capturerStreamImplRet->GetStreamFramesRead(framesReadRet);
122 EXPECT_EQ(ret, SUCCESS);
123 }
124
125 /**
126 * @tc.name : Test PaCapturerStreamImpl API
127 * @tc.type : FUNC
128 * @tc.number: PaCapturerStream_002
129 * @tc.desc : Test PaCapturerStreamImpl interface.
130 */
131 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_002, TestSize.Level1)
132 {
133 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
134 uint64_t timestampRet = 0;
135 capturerStreamImplRet->paStream_ = nullptr;
136
137 auto ret = capturerStreamImplRet->GetCurrentTimeStamp(timestampRet);
138 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
139 }
140
141 /**
142 * @tc.name : Test PaCapturerStreamImpl API
143 * @tc.type : FUNC
144 * @tc.number: PaCapturerStream_003
145 * @tc.desc : Test PaCapturerStreamImpl interface.
146 */
147 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_003, TestSize.Level1)
148 {
149 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
150 uint64_t timestampRet = 0;
151
152 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
153 adapterManager->InitPaContext();
154 uint32_t sessionId = 123456;
155 AudioProcessConfig processConfig = GetInnerCapConfig();
156 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
157 capturerStreamImplRet->paStream_ = stream;
158 EXPECT_EQ(pa_stream_get_state(capturerStreamImplRet->paStream_), PA_STREAM_READY);
159 pa_stream_terminate(capturerStreamImplRet->paStream_);
160 auto ret = capturerStreamImplRet->GetCurrentTimeStamp(timestampRet);
161 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
162 }
163
164 /**
165 * @tc.name : Test PaCapturerStreamImpl API
166 * @tc.type : FUNC
167 * @tc.number: PaCapturerStream_004
168 * @tc.desc : Test PaCapturerStreamImpl interface.
169 */
170 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_004, TestSize.Level1)
171 {
172 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
173 uint64_t latencyRet;
174 bool isStandbyRet = false;
175 capturerStreamImplRet->paStream_ = nullptr;
176
177 auto ret = capturerStreamImplRet->GetLatency(latencyRet);
178 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
179
180 ret = capturerStreamImplRet->Flush();
181 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
182
183 ret = capturerStreamImplRet->Stop();
184 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
185
186 ret = capturerStreamImplRet->Start();
187 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
188
189 ret = capturerStreamImplRet->Pause(isStandbyRet);
190 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
191 }
192
193 /**
194 * @tc.name : Test PaCapturerStreamImpl API
195 * @tc.type : FUNC
196 * @tc.number: PaCapturerStream_005
197 * @tc.desc : Test PaCapturerStreamImpl interface.
198 */
199 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_005, TestSize.Level1)
200 {
201 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
202 bool isStandbyRet = false;
203 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
204 adapterManager->InitPaContext();
205 uint32_t sessionId = 123456;
206 AudioProcessConfig processConfig = GetInnerCapConfig();
207 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
208 capturerStreamImplRet->paStream_ = stream;
209 EXPECT_EQ(pa_stream_get_state(capturerStreamImplRet->paStream_), PA_STREAM_READY);
210
211 auto ret = capturerStreamImplRet->Start();
212 EXPECT_EQ(ret, SUCCESS);
213
214 ret = capturerStreamImplRet->Pause(isStandbyRet);
215 EXPECT_EQ(ret, SUCCESS);
216
217 ret = capturerStreamImplRet->Flush();
218 EXPECT_EQ(ret, SUCCESS);
219
220 ret = capturerStreamImplRet->Stop();
221 EXPECT_EQ(ret, SUCCESS);
222 }
223
224 /**
225 * @tc.name : Test PaCapturerStreamImpl API
226 * @tc.type : FUNC
227 * @tc.number: PaCapturerStream_006
228 * @tc.desc : Test PaCapturerStreamImpl interface.
229 */
230 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_006, TestSize.Level1)
231 {
232 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
233 capturerStreamImplRet->paStream_ = nullptr;
234 capturerStreamImplRet->state_ = RUNNING;
235
236 auto ret = capturerStreamImplRet->Release();
237 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
238 }
239
240 /**
241 * @tc.name : Test PaCapturerStreamImpl API
242 * @tc.type : FUNC
243 * @tc.number: PaCapturerStream_007
244 * @tc.desc : Test PaCapturerStreamImpl interface.
245 */
246 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_007, TestSize.Level1)
247 {
248 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
249 capturerStreamImplRet->statusCallback_ = std::weak_ptr<IStatusCallback>();
250 capturerStreamImplRet->state_ = STOPPED;
251
252 auto ret = capturerStreamImplRet->Release();
253 EXPECT_EQ(ret, SUCCESS);
254 }
255
256 /**
257 * @tc.name : Test PaCapturerStreamImpl API
258 * @tc.type : FUNC
259 * @tc.number: PaCapturerStream_008
260 * @tc.desc : Test PaCapturerStreamImpl interface.
261 */
262 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_008, TestSize.Level1)
263 {
264 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
265 ASSERT_NE(nullptr, capturerStreamImplRet);
266
267 size_t lengthRet = 10;
268 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
269 adapterManager->InitPaContext();
270 uint32_t sessionId = 123456;
271 AudioProcessConfig processConfig = GetInnerCapConfig();
272 pa_stream *streamRet = adapterManager->InitPaStream(processConfig, sessionId, false);
273 ASSERT_NE(nullptr, streamRet);
274
275 void *userdataRet = nullptr;
276 capturerStreamImplRet->PAStreamReadCb(streamRet, lengthRet, userdataRet);
277 EXPECT_NE(capturerStreamImplRet->paStream_, nullptr);
278 }
279
280 /**
281 * @tc.name : Test PaCapturerStreamImpl API
282 * @tc.type : FUNC
283 * @tc.number: PaCapturerStream_009
284 * @tc.desc : Test PaCapturerStreamImpl interface.
285 */
286 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_009, TestSize.Level1)
287 {
288 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
289 ASSERT_NE(nullptr, capturerStreamImplRet);
290
291 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
292 adapterManager->InitPaContext();
293 uint32_t sessionId = 123456;
294 AudioProcessConfig processConfig = GetInnerCapConfig();
295 pa_stream *streamRet = adapterManager->InitPaStream(processConfig, sessionId, false);
296 ASSERT_NE(nullptr, streamRet);
297
298 void *userdataRet = nullptr;
299 capturerStreamImplRet->PAStreamMovedCb(streamRet, userdataRet);
300 capturerStreamImplRet->PAStreamMovedCb(streamRet, (void *)1);
301 EXPECT_NE(capturerStreamImplRet->paStream_, nullptr);
302 }
303
304 /**
305 * @tc.name : Test PaCapturerStreamImpl API
306 * @tc.type : FUNC
307 * @tc.number: PaCapturerStream_010
308 * @tc.desc : Test PaCapturerStreamImpl interface.
309 */
310 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_010, TestSize.Level1)
311 {
312 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
313 ASSERT_NE(nullptr, capturerStreamImplRet);
314
315 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
316 adapterManager->InitPaContext();
317 uint32_t sessionId = 123456;
318 AudioProcessConfig processConfig = GetInnerCapConfig();
319 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
320 ASSERT_NE(nullptr, stream);
321
322 capturerStreamImplRet->paStream_ = stream;
323 auto ret = capturerStreamImplRet->InitParams();
324 EXPECT_EQ(ret, SUCCESS);
325 }
326
327 /**
328 * @tc.name : Test PaCapturerStreamImpl API
329 * @tc.type : FUNC
330 * @tc.number: PaCapturerStream_011
331 * @tc.desc : Test PaCapturerStreamImpl interface.
332 */
333 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_011, TestSize.Level1)
334 {
335 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
336 ASSERT_NE(nullptr, capturerStreamImplRet);
337
338 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
339 adapterManager->InitPaContext();
340 uint32_t sessionId = 123456;
341 AudioProcessConfig processConfig = GetInnerCapConfig();
342 pa_stream *streamRet = adapterManager->InitPaStream(processConfig, sessionId, false);
343 ASSERT_NE(nullptr, streamRet);
344
345 void *userdataRet = nullptr;
346 capturerStreamImplRet->PAStreamUnderFlowCb(streamRet, userdataRet);
347 EXPECT_NE(capturerStreamImplRet->paStream_, nullptr);
348 }
349
350 /**
351 * @tc.name : Test PaCapturerStreamImpl API
352 * @tc.type : FUNC
353 * @tc.number: PaCapturerStream_012
354 * @tc.desc : Test PaCapturerStreamImpl interface.
355 */
356 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_012, TestSize.Level1)
357 {
358 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
359 ASSERT_NE(nullptr, capturerStreamImplRet);
360
361 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
362 adapterManager->InitPaContext();
363 uint32_t sessionId = 123456;
364 AudioProcessConfig processConfig = GetInnerCapConfig();
365 pa_stream *streamRet = adapterManager->InitPaStream(processConfig, sessionId, false);
366 ASSERT_NE(nullptr, streamRet);
367
368 void *userdataRet = nullptr;
369 capturerStreamImplRet->PAStreamSetStartedCb(streamRet, userdataRet);
370 capturerStreamImplRet->PAStreamSetStartedCb(streamRet, (void *)1);
371 EXPECT_NE(capturerStreamImplRet->paStream_, nullptr);
372 }
373
374 /**
375 * @tc.name : Test PaCapturerStreamImpl API
376 * @tc.type : FUNC
377 * @tc.number: PaCapturerStream_013
378 * @tc.desc : Test PaCapturerStreamImpl interface.
379 */
380 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_013, TestSize.Level1)
381 {
382 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
383 ASSERT_NE(nullptr, capturerStreamImplRet);
384
385 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
386 adapterManager->InitPaContext();
387 uint32_t sessionId = 123456;
388 AudioProcessConfig processConfig = GetInnerCapConfig();
389 pa_stream *streamRet = adapterManager->InitPaStream(processConfig, sessionId, false);
390 ASSERT_NE(nullptr, streamRet);
391 void *userdataRet = nullptr;
392 int32_t successRet = 0;
393
394 capturerStreamImplRet->PAStreamStartSuccessCb(streamRet, successRet, userdataRet);
395 capturerStreamImplRet->PAStreamPauseSuccessCb(streamRet, successRet, userdataRet);
396 capturerStreamImplRet->PAStreamFlushSuccessCb(streamRet, successRet, userdataRet);
397 capturerStreamImplRet->PAStreamStopSuccessCb(streamRet, successRet, userdataRet);
398 }
399
400 /**
401 * @tc.name : Test PaCapturerStreamImpl API
402 * @tc.type : FUNC
403 * @tc.number: PaCapturerStream_014
404 * @tc.desc : Test PaCapturerStreamImpl interface.
405 */
406 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_014, TestSize.Level1)
407 {
408 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
409 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
410 adapterManager->InitPaContext();
411 uint32_t sessionId = 123456;
412 AudioProcessConfig processConfig = GetInnerCapConfig();
413 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
414 capturerStreamImplRet->paStream_ = stream;
415 EXPECT_EQ(pa_stream_get_state(capturerStreamImplRet->paStream_), PA_STREAM_READY);
416 pa_stream_terminate(capturerStreamImplRet->paStream_);
417 int32_t ret = capturerStreamImplRet->Start();
418 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
419 }
420
421 /**
422 * @tc.name : Test PaCapturerStreamImpl API
423 * @tc.type : FUNC
424 * @tc.number: PaCapturerStream_015
425 * @tc.desc : Test PaCapturerStreamImpl interface.
426 */
427 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_015, TestSize.Level1)
428 {
429 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
430 bool isStandbyRet = false;
431 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
432 adapterManager->InitPaContext();
433 uint32_t sessionId = 123456;
434 AudioProcessConfig processConfig = GetInnerCapConfig();
435 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
436 capturerStreamImplRet->paStream_ = stream;
437 EXPECT_EQ(pa_stream_get_state(capturerStreamImplRet->paStream_), PA_STREAM_READY);
438
439 auto ret = capturerStreamImplRet->Start();
440 EXPECT_EQ(ret, SUCCESS);
441 pa_stream_terminate(capturerStreamImplRet->paStream_);
442 ret = capturerStreamImplRet->Pause(isStandbyRet);
443 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
444 }
445
446 /**
447 * @tc.name : Test PaCapturerStreamImpl API
448 * @tc.type : FUNC
449 * @tc.number: PaCapturerStream_016
450 * @tc.desc : Test PaCapturerStreamImpl interface.
451 */
452 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_016, TestSize.Level1)
453 {
454 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
455 bool isStandbyRet = false;
456 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
457 adapterManager->InitPaContext();
458 uint32_t sessionId = 123456;
459 AudioProcessConfig processConfig = GetInnerCapConfig();
460 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
461 capturerStreamImplRet->paStream_ = stream;
462 EXPECT_EQ(pa_stream_get_state(capturerStreamImplRet->paStream_), PA_STREAM_READY);
463
464 auto ret = capturerStreamImplRet->Start();
465 EXPECT_EQ(ret, SUCCESS);
466
467 ret = capturerStreamImplRet->Pause(isStandbyRet);
468 EXPECT_EQ(ret, SUCCESS);
469
470 pa_stream_terminate(capturerStreamImplRet->paStream_);
471 ret = capturerStreamImplRet->Flush();
472 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
473 }
474
475 /**
476 * @tc.name : Test PaCapturerStreamImpl API
477 * @tc.type : FUNC
478 * @tc.number: PaCapturerStream_017
479 * @tc.desc : Test PaCapturerStreamImpl interface.
480 */
481 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_017, TestSize.Level1)
482 {
483 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
484 bool isStandbyRet = false;
485 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
486 adapterManager->InitPaContext();
487 uint32_t sessionId = 123456;
488 AudioProcessConfig processConfig = GetInnerCapConfig();
489 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
490 capturerStreamImplRet->paStream_ = stream;
491 EXPECT_EQ(pa_stream_get_state(capturerStreamImplRet->paStream_), PA_STREAM_READY);
492
493 auto ret = capturerStreamImplRet->Start();
494 EXPECT_EQ(ret, SUCCESS);
495
496 ret = capturerStreamImplRet->Pause(isStandbyRet);
497 EXPECT_EQ(ret, SUCCESS);
498
499 ret = capturerStreamImplRet->Flush();
500 EXPECT_EQ(ret, SUCCESS);
501
502 pa_stream_terminate(capturerStreamImplRet->paStream_);
503 ret = capturerStreamImplRet->Stop();
504 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
505 }
506
507 /**
508 * @tc.name : Test PaCapturerStreamImpl API
509 * @tc.type : FUNC
510 * @tc.number: PaCapturerStream_018
511 * @tc.desc : Test PaCapturerStreamImpl interface.
512 */
513 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_018, TestSize.Level1)
514 {
515 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
516 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
517 adapterManager->InitPaContext();
518 uint32_t sessionId = 123456;
519 AudioProcessConfig processConfig = GetInnerCapConfig();
520 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
521 capturerStreamImplRet->paStream_ = stream;
522 capturerStreamImplRet->state_ = RUNNING;
523 auto ret = capturerStreamImplRet->Release();
524 EXPECT_EQ(ret, SUCCESS);
525 }
526
527 /**
528 * @tc.name : Test PaCapturerStreamImpl API
529 * @tc.type : FUNC
530 * @tc.number: PaCapturerStream_019
531 * @tc.desc : Test PaCapturerStreamImpl interface.
532 */
533 HWTEST_F(PaCapturerStreamUnitTest, PaCapturerStream_019, TestSize.Level1)
534 {
535 auto capturerStreamImplRet = CreatePaCapturerStreamImpl();
536 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
537 adapterManager->InitPaContext();
538 uint32_t sessionId = 123456;
539 AudioProcessConfig processConfig = GetInnerCapConfig();
540 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
541 capturerStreamImplRet->paStream_ = stream;
542 capturerStreamImplRet->capturerServerDumpFile_ = fopen("/data/data/.pulse_dir/capturer_impl.pcm", "wb+");
543 size_t length = 1;
544 capturerStreamImplRet->DequeueBuffer(length);
545 EXPECT_EQ(capturerStreamImplRet != nullptr, true);
546 #ifdef HAS_FEATURE_INNERCAPTURER
547 ReleasePaPort();
548 #endif
549 }
550 }
551 }