1 /*
2 * Copyright (c) 2024-2025 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 "audio_errors.h"
18 #include "audio_utils.h"
19 #include "pa_capturer_stream_impl.h"
20 #include "pa_adapter_manager.h"
21 #include "capturer_in_server.h"
22
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace AudioStandard {
27 class CapturerInServerUnitTest : public testing::Test {
28 public:
29 // SetUpTestCase: Called before all test cases
30 static void SetUpTestCase(void);
31 // TearDownTestCase: Called after all test case
32 static void TearDownTestCase(void);
33 // SetUp: Called before each test cases
34 void SetUp(void);
35 // TearDown: Called after each test cases
36 void TearDown(void);
37 };
38
SetUpTestCase()39 void CapturerInServerUnitTest::SetUpTestCase() {}
TearDownTestCase()40 void CapturerInServerUnitTest::TearDownTestCase() {}
SetUp()41 void CapturerInServerUnitTest::SetUp() {}
TearDown()42 void CapturerInServerUnitTest::TearDown() {}
43
44 class ConcreteIStreamListener : public IStreamListener {
OnOperationHandled(Operation operation,int64_t result)45 int32_t OnOperationHandled(Operation operation, int64_t result) { return SUCCESS; }
46 };
47
48 const int32_t CAPTURER_FLAG = 10;
GetInnerCapConfig()49 static AudioProcessConfig GetInnerCapConfig()
50 {
51 AudioProcessConfig config;
52 config.appInfo.appUid = CAPTURER_FLAG;
53 config.appInfo.appPid = CAPTURER_FLAG;
54 config.streamInfo.format = SAMPLE_S32LE;
55 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
56 config.streamInfo.channels = STEREO;
57 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
58 config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
59 config.streamType = AudioStreamType::STREAM_MUSIC;
60 config.deviceType = DEVICE_TYPE_USB_HEADSET;
61 return config;
62 }
63
64 /**
65 * @tc.name : Test CapturerInServer.
66 * @tc.type : FUNC
67 * @tc.number: CapturerInServerUnitTest_001.
68 * @tc.desc : Test ConfigServerBuffer interface.
69 */
70 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_001, TestSize.Level1)
71 {
72 uint32_t totalSizeInFrame = 10;
73 uint32_t spanSizeInFrame = 10;
74 uint32_t byteSizePerFrame = 10;
75 AudioProcessConfig processConfig;
76 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
77 pa_stream *paStream = nullptr;
78 processConfig.capturerInfo.sourceType = SOURCE_TYPE_WAKEUP;
79 std::weak_ptr<IStreamListener> streamListener;
80 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
81 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(AudioBufferHolder::AUDIO_CLIENT,
82 totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
83 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(paStream,
84 processConfig, mainloop);
85 int32_t result = capturerInServer_->ConfigServerBuffer();
86 EXPECT_EQ(result, SUCCESS);
87
88 capturerInServer_->audioServerBuffer_ = nullptr;
89 capturerInServer_->ConfigServerBuffer();
90 EXPECT_NE(capturerInServer_, nullptr);
91
92 capturerInServer_->spanSizeInFrame_ = 10;
93 capturerInServer_->ConfigServerBuffer();
94 EXPECT_NE(capturerInServer_, nullptr);
95 }
96
97 /**
98 * @tc.name : Test CapturerInServer.
99 * @tc.type : FUNC
100 * @tc.number: CapturerInServerUnitTest_002.
101 * @tc.desc : Test ConfigServerBuffer interface.
102 */
103 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_002, TestSize.Level1)
104 {
105 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
106 pa_stream *paStream = nullptr;
107 AudioProcessConfig processConfig;
108 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
109 std::weak_ptr<IStreamListener> streamListener;
110 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
111 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(paStream,
112 processConfig, mainloop);
113 capturerInServer_->ConfigServerBuffer();
114 EXPECT_NE(capturerInServer_, nullptr);
115
116 capturerInServer_->spanSizeInFrame_ = 10;
117 capturerInServer_->ConfigServerBuffer();
118 EXPECT_NE(capturerInServer_, nullptr);
119 }
120
121 /**
122 * @tc.name : Test CapturerInServer.
123 * @tc.type : FUNC
124 * @tc.number: CapturerInServerUnitTest_003.
125 * @tc.desc : Test InitBufferStatus interface.
126 */
127 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_003, TestSize.Level1)
128 {
129 AudioBufferHolder bufferHolder;
130 uint32_t totalSizeInFrame = 10;
131 uint32_t spanSizeInFrame = 10;
132 uint32_t byteSizePerFrame = 10;
133 AudioProcessConfig processConfig;
134 std::weak_ptr<IStreamListener> streamListener;
135 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
136 int32_t result = capturerInServer_->InitBufferStatus();
137 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
138
139 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
140 spanSizeInFrame, byteSizePerFrame);
141 capturerInServer_->audioServerBuffer_->spanConut_ = 5;
142 capturerInServer_->InitBufferStatus();
143 EXPECT_NE(capturerInServer_, nullptr);
144 }
145 #ifdef CAPTURER_IN_SERVER_UNIT_TEST_DIFF
146 /**
147 * @tc.name : Test CapturerInServer.
148 * @tc.type : FUNC
149 * @tc.number: CapturerInServerUnitTest_004.
150 * @tc.desc : Test OnStatusUpdate interface.
151 */
152 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_004, TestSize.Level1)
153 {
154 AudioProcessConfig processConfig;
155 std::shared_ptr<IStreamListener> iStreamListener_ = std::make_shared<ConcreteIStreamListener>();
156 std::weak_ptr<IStreamListener> streamListener = iStreamListener_;
157 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
158 capturerInServer_->status_ = I_STATUS_RELEASED;
159 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_DRAINED);
160 EXPECT_NE(capturerInServer_, nullptr);
161
162 capturerInServer_->status_ = I_STATUS_IDLE;
163 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_UNDERFLOW);
164 EXPECT_NE(capturerInServer_, nullptr);
165
166 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_STARTED);
167 EXPECT_NE(capturerInServer_, nullptr);
168
169 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_PAUSED);
170 EXPECT_NE(capturerInServer_, nullptr);
171
172 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_STOPPED);
173 EXPECT_NE(capturerInServer_, nullptr);
174 }
175
176 /**
177 * @tc.name : Test CapturerInServer.
178 * @tc.type : FUNC
179 * @tc.number: CapturerInServerUnitTest_005.
180 * @tc.desc : Test OnStatusUpdate interface.
181 */
182 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_005, TestSize.Level1)
183 {
184 AudioProcessConfig processConfig;
185 std::shared_ptr<IStreamListener> iStreamListener_ = std::make_shared<ConcreteIStreamListener>();
186 std::weak_ptr<IStreamListener> streamListener = iStreamListener_;
187 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
188 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_FLUSHED);
189 EXPECT_NE(capturerInServer_, nullptr);
190
191 capturerInServer_->status_ = I_STATUS_FLUSHING_WHEN_STARTED;
192 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_FLUSHED);
193 EXPECT_NE(capturerInServer_, nullptr);
194 }
195
196 /**
197 * @tc.name : Test CapturerInServer.
198 * @tc.type : FUNC
199 * @tc.number: CapturerInServerUnitTest_006.
200 * @tc.desc : Test OnStatusUpdate interface.
201 */
202 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_006, TestSize.Level1)
203 {
204 AudioProcessConfig processConfig;
205 std::shared_ptr<IStreamListener> iStreamListener_ = std::make_shared<ConcreteIStreamListener>();
206 std::weak_ptr<IStreamListener> streamListener = iStreamListener_;
207 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
208 capturerInServer_->status_ = I_STATUS_FLUSHING_WHEN_PAUSED;
209 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_FLUSHED);
210 EXPECT_NE(capturerInServer_, nullptr);
211 }
212
213 /**
214 * @tc.name : Test CapturerInServer.
215 * @tc.type : FUNC
216 * @tc.number: CapturerInServerUnitTest_007.
217 * @tc.desc : Test OnStatusUpdate interface.
218 */
219 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_007, TestSize.Level1)
220 {
221 AudioProcessConfig processConfig;
222 std::shared_ptr<IStreamListener> iStreamListener_ = std::make_shared<ConcreteIStreamListener>();
223 std::weak_ptr<IStreamListener> streamListener = iStreamListener_;
224 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
225 capturerInServer_->status_ = I_STATUS_FLUSHING_WHEN_STOPPED;
226 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_FLUSHED);
227 EXPECT_NE(capturerInServer_, nullptr);
228 }
229
230 /**
231 * @tc.name : Test CapturerInServer.
232 * @tc.type : FUNC
233 * @tc.number: CapturerInServerUnitTest_008.
234 * @tc.desc : Test OnStatusUpdate interface.
235 */
236 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_008, TestSize.Level1)
237 {
238 size_t length = 10;
239 uint64_t currentWriteFrame = 10;
240 uint32_t totalSizeInFrame = 10;
241 uint32_t spanSizeInFrame = 10;
242 uint32_t byteSizePerFrame = 10;
243
244 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
245 adapterManager->InitPaContext();
246 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
247 AudioProcessConfig processConfig = GetInnerCapConfig();
248 uint32_t sessionId = 123456;
249 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
250
251 std::shared_ptr<IStreamListener> stateListener = std::make_shared<ConcreteIStreamListener>();
252 std::weak_ptr<IStreamListener> streamListener;
253 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
254 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
255 processConfig, mainloop);
256 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(AudioBufferHolder::AUDIO_CLIENT,
257 totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
258 capturerInServer_->audioServerBuffer_->basicBufferInfo_ = new BasicBufferInfo();
259 capturerInServer_->spanSizeInFrame_ = 1000;
260
261 capturerInServer_->IsReadDataOverFlow(length, currentWriteFrame, stateListener);
262 EXPECT_NE(capturerInServer_, nullptr);
263
264 capturerInServer_->overFlowLogFlag_ = 1;
265 capturerInServer_->IsReadDataOverFlow(length, currentWriteFrame, stateListener);
266 EXPECT_NE(capturerInServer_, nullptr);
267 delete capturerInServer_->audioServerBuffer_->basicBufferInfo_;
268 }
269 #endif
270 /**
271 * @tc.name : Test CapturerInServer.
272 * @tc.type : FUNC
273 * @tc.number: CapturerInServerUnitTest_009.
274 * @tc.desc : Test ReadData interface.
275 */
276 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_009, TestSize.Level1)
277 {
278 size_t length = 10;
279 AudioProcessConfig processConfig;
280 std::weak_ptr<IStreamListener> streamListener = std::make_shared<ConcreteIStreamListener>();
281 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
282 capturerInServer_->spanSizeInFrame_ = -100;
283 capturerInServer_->muteFlag_.store(true);
284 AudioDump::GetInstance().GetVersionType() = DumpFileUtil::BETA_VERSION;
285 capturerInServer_->ReadData(length);
286 EXPECT_NE(capturerInServer_, nullptr);
287 }
288
289 /**
290 * @tc.name : Test CapturerInServer.
291 * @tc.type : FUNC
292 * @tc.number: CapturerInServerUnitTest_010.
293 * @tc.desc : Test Start/Stop interface.
294 */
295 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_010, TestSize.Level1)
296 {
297 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
298 adapterManager->InitPaContext();
299 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
300 AudioProcessConfig processConfig = GetInnerCapConfig();
301 uint32_t sessionId = 123456;
302 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
303
304 std::weak_ptr<IStreamListener> streamListener;
305 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
306 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
307 processConfig, mainloop);
308 capturerInServer_->status_ = I_STATUS_FLUSHING_WHEN_STARTED;
309 int32_t result = capturerInServer_->Start();
310 EXPECT_NE(result, SUCCESS);
311
312 capturerInServer_->status_ = I_STATUS_IDLE;
313 capturerInServer_->Start();
314 capturerInServer_->Stop();
315 EXPECT_NE(capturerInServer_, nullptr);
316
317 capturerInServer_->status_ = I_STATUS_PAUSED;
318 capturerInServer_->Start();
319 capturerInServer_->Stop();
320 EXPECT_NE(capturerInServer_, nullptr);
321
322 capturerInServer_->status_ = I_STATUS_STOPPED;
323 capturerInServer_->Start();
324 capturerInServer_->Stop();
325 EXPECT_NE(capturerInServer_, nullptr);
326 }
327
328 /**
329 * @tc.name : Test CapturerInServer.
330 * @tc.type : FUNC
331 * @tc.number: CapturerInServerUnitTest_011.
332 * @tc.desc : Test Start/Stop interface.
333 */
334 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_011, TestSize.Level1)
335 {
336 AudioProcessConfig processConfig = GetInnerCapConfig();
337 int32_t UID_MSDP_SA = 6699;
338 processConfig.callerUid = UID_MSDP_SA;
339 std::weak_ptr<IStreamListener> streamListener;
340
341 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
342 adapterManager->InitPaContext();
343 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
344 uint32_t sessionId = 123456;
345 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
346
347 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
348 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
349 processConfig, mainloop);
350 capturerInServer_->status_ = I_STATUS_IDLE;
351 capturerInServer_->Start();
352 capturerInServer_->Stop();
353 EXPECT_NE(capturerInServer_, nullptr);
354 }
355
356 /**
357 * @tc.name : Test CapturerInServer.
358 * @tc.type : FUNC
359 * @tc.number: CapturerInServerUnitTest_012.
360 * @tc.desc : Test Start/Stop interface.
361 */
362 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_012, TestSize.Level1)
363 {
364 AudioProcessConfig processConfig = GetInnerCapConfig();
365 int32_t TIME_OUT_SECONDS = 10;
366 processConfig.callerUid = TIME_OUT_SECONDS;
367 processConfig.capturerInfo.sourceType = SOURCE_TYPE_EC;
368 std::weak_ptr<IStreamListener> streamListener;
369
370 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
371 adapterManager->InitPaContext();
372 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
373 uint32_t sessionId = 123456;
374 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
375
376 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
377 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
378 processConfig, mainloop);
379 capturerInServer_->status_ = I_STATUS_IDLE;
380 capturerInServer_->Start();
381 capturerInServer_->Stop();
382 EXPECT_NE(capturerInServer_, nullptr);
383 }
384
385 /**
386 * @tc.name : Test CapturerInServer.
387 * @tc.type : FUNC
388 * @tc.number: CapturerInServerUnitTest_013.
389 * @tc.desc : Test Start/Stop interface.
390 */
391 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_013, TestSize.Level1)
392 {
393 AudioProcessConfig processConfig = GetInnerCapConfig();
394 int32_t UID_MSDP_SA = 6699;
395 processConfig.callerUid = UID_MSDP_SA;
396 std::weak_ptr<IStreamListener> streamListener;
397
398 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
399 adapterManager->InitPaContext();
400 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
401 uint32_t sessionId = 123456;
402 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
403
404 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
405 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
406 processConfig, mainloop);
407 capturerInServer_->needCheckBackground_ = true;
408 capturerInServer_->status_ = I_STATUS_IDLE;
409 capturerInServer_->Start();
410 capturerInServer_->Stop();
411 EXPECT_NE(capturerInServer_, nullptr);
412 }
413
414 /**
415 * @tc.name : Test CapturerInServer.
416 * @tc.type : FUNC
417 * @tc.number: CapturerInServerUnitTest_014.
418 * @tc.desc : Test Start/Stop interface.
419 */
420 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_014, TestSize.Level1)
421 {
422 AudioProcessConfig processConfig = GetInnerCapConfig();
423 int32_t TIME_OUT_SECONDS = 10;
424 processConfig.callerUid = TIME_OUT_SECONDS;
425 processConfig.capturerInfo.sourceType = SOURCE_TYPE_EC;
426 std::weak_ptr<IStreamListener> streamListener;
427
428 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
429 adapterManager->InitPaContext();
430 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
431 uint32_t sessionId = 123456;
432 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
433
434 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
435 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
436 processConfig, mainloop);
437 capturerInServer_->needCheckBackground_ = true;
438 capturerInServer_->status_ = I_STATUS_IDLE;
439 capturerInServer_->Start();
440 capturerInServer_->Stop();
441 EXPECT_NE(capturerInServer_, nullptr);
442 }
443
444 /**
445 * @tc.name : Test CapturerInServer.
446 * @tc.type : FUNC
447 * @tc.number: CapturerInServerUnitTest_015.
448 * @tc.desc : Test Pause interface.
449 */
450 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_015, TestSize.Level1)
451 {
452 AudioProcessConfig processConfig = GetInnerCapConfig();
453 std::weak_ptr<IStreamListener> streamListener;
454
455 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
456 adapterManager->InitPaContext();
457 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
458 uint32_t sessionId = 123456;
459 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
460
461 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
462 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
463 processConfig, mainloop);
464 capturerInServer_->status_ = I_STATUS_STARTING;
465 int32_t result = capturerInServer_->Pause();
466 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
467
468 capturerInServer_->status_ = I_STATUS_STARTED;
469 result = capturerInServer_->Pause();
470 EXPECT_NE(capturerInServer_, nullptr);
471
472 capturerInServer_->status_ = I_STATUS_STARTING;
473 capturerInServer_->needCheckBackground_ = true;
474 result = capturerInServer_->Pause();
475 EXPECT_NE(capturerInServer_, nullptr);
476 }
477
478 /**
479 * @tc.name : Test CapturerInServer.
480 * @tc.type : FUNC
481 * @tc.number: CapturerInServerUnitTest_016.
482 * @tc.desc : Test Flush interface.
483 */
484 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_016, TestSize.Level1)
485 {
486 uint32_t totalSizeInFrame = 10;
487 uint32_t spanSizeInFrame = 10;
488 uint32_t byteSizePerFrame = 10;
489 std::weak_ptr<IStreamListener> streamListener;
490
491 AudioProcessConfig processConfig = GetInnerCapConfig();
492 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
493 adapterManager->InitPaContext();
494 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
495 uint32_t sessionId = 123456;
496 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
497
498 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
499 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
500 processConfig, mainloop);
501 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(AudioBufferHolder::AUDIO_CLIENT,
502 totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
503 int32_t result = capturerInServer_->Flush();
504 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
505
506 capturerInServer_->status_ = I_STATUS_STARTED;
507 capturerInServer_->Flush();
508 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
509 }
510
511 /**
512 * @tc.name : Test CapturerInServer.
513 * @tc.type : FUNC
514 * @tc.number: CapturerInServerUnitTest_017.
515 * @tc.desc : Test Flush interface.
516 */
517 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_017, TestSize.Level1)
518 {
519 uint32_t totalSizeInFrame = 10;
520 uint32_t spanSizeInFrame = 10;
521 uint32_t byteSizePerFrame = 10;
522 std::weak_ptr<IStreamListener> streamListener;
523
524 AudioProcessConfig processConfig = GetInnerCapConfig();
525 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
526 adapterManager->InitPaContext();
527 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
528 uint32_t sessionId = 123456;
529 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
530
531 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
532 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
533 processConfig, mainloop);
534 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(AudioBufferHolder::AUDIO_CLIENT,
535 totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
536 capturerInServer_->status_ = I_STATUS_PAUSED;
537 capturerInServer_->Flush();
538 EXPECT_NE(capturerInServer_, nullptr);
539
540 capturerInServer_->status_ = I_STATUS_STOPPED;
541 capturerInServer_->Flush();
542 EXPECT_NE(capturerInServer_, nullptr);
543 }
544
545 /**
546 * @tc.name : Test CapturerInServer.
547 * @tc.type : FUNC
548 * @tc.number: CapturerInServerUnitTest_018.
549 * @tc.desc : Test Stop interface.
550 */
551 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_018, TestSize.Level1)
552 {
553 AudioProcessConfig processConfig = GetInnerCapConfig();
554 std::weak_ptr<IStreamListener> streamListener;
555
556 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
557 adapterManager->InitPaContext();
558 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
559 uint32_t sessionId = 123456;
560 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
561
562 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
563 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
564 processConfig, mainloop);
565 capturerInServer_->status_ = I_STATUS_FLUSHING_WHEN_STARTED;
566 int32_t result = capturerInServer_->Stop();
567 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
568
569 capturerInServer_->status_ = I_STATUS_PAUSED;
570 result = capturerInServer_->Stop();
571 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
572
573 capturerInServer_->status_ = I_STATUS_PAUSED;
574 capturerInServer_->needCheckBackground_ = true;
575 result = capturerInServer_->Stop();
576 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
577 }
578
579 /**
580 * @tc.name : Test CapturerInServer.
581 * @tc.type : FUNC
582 * @tc.number: CapturerInServerUnitTest_019.
583 * @tc.desc : Test Release interface.
584 */
585 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_019, TestSize.Level1)
586 {
587 AudioProcessConfig processConfig;
588 std::weak_ptr<IStreamListener> streamListener;
589 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
590 capturerInServer_->status_ = I_STATUS_RELEASED;
591 int result = capturerInServer_->Release();
592 EXPECT_EQ(result, SUCCESS);
593 }
594
595 /**
596 * @tc.name : Test CapturerInServer.
597 * @tc.type : FUNC
598 * @tc.number: CapturerInServerUnitTest_020.
599 * @tc.desc : Test Release interface.
600 */
601 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_020, TestSize.Level1)
602 {
603 AudioProcessConfig processConfig;
604 std::weak_ptr<IStreamListener> streamListener;
605 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
606 processConfig.innerCapMode = INVALID_CAP_MODE;
607 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
608 capturerInServer_->status_ = I_STATUS_RELEASING;
609 int result = capturerInServer_->Release();
610 EXPECT_EQ(result, SUCCESS);
611
612 capturerInServer_->needCheckBackground_ = true;
613 result = capturerInServer_->Release();
614 EXPECT_EQ(result, SUCCESS);
615 }
616
617 #ifdef HAS_FEATURE_INNERCAPTURER
618 /**
619 * @tc.name : Test CapturerInServer.
620 * @tc.type : FUNC
621 * @tc.number: CapturerInServerUnitTest_021.
622 * @tc.desc : Test UpdatePlaybackCaptureConfig interface.
623 */
624 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_021, TestSize.Level1)
625 {
626 AudioProcessConfig processConfig;
627 std::weak_ptr<IStreamListener> streamListener;
628 AudioPlaybackCaptureConfig config;
629 processConfig.innerCapMode = MODERN_INNER_CAP;
630 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
631 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
632 int32_t result = capturerInServer_->UpdatePlaybackCaptureConfig(config);
633 EXPECT_EQ(result, SUCCESS);
634 }
635
636 /**
637 * @tc.name : Test CapturerInServer.
638 * @tc.type : FUNC
639 * @tc.number: CapturerInServerUnitTest_022.
640 * @tc.desc : Test UpdatePlaybackCaptureConfig interface.
641 */
642 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_022, TestSize.Level1)
643 {
644 AudioProcessConfig processConfig;
645 std::weak_ptr<IStreamListener> streamListener;
646 AudioPlaybackCaptureConfig config;
647 processConfig.innerCapMode = LEGACY_INNER_CAP;
648 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
649 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
650 int32_t result = capturerInServer_->UpdatePlaybackCaptureConfig(config);
651 EXPECT_EQ(result, SUCCESS);
652 }
653
654 /**
655 * @tc.name : Test CapturerInServer.
656 * @tc.type : FUNC
657 * @tc.number: CapturerInServerUnitTest_023.
658 * @tc.desc : Test UpdatePlaybackCaptureConfig interface.
659 */
660 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_023, TestSize.Level1)
661 {
662 AudioProcessConfig processConfig;
663 std::weak_ptr<IStreamListener> streamListener;
664 AudioPlaybackCaptureConfig config;
665 processConfig.innerCapMode = MODERN_INNER_CAP;
666 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
667 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_UNKNOWN);
668 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
669 int32_t result = capturerInServer_->UpdatePlaybackCaptureConfig(config);
670 EXPECT_EQ(result, SUCCESS);
671 }
672
673 /**
674 * @tc.name : Test CapturerInServer.
675 * @tc.type : FUNC
676 * @tc.number: CapturerInServerUnitTest_024.
677 * @tc.desc : Test UpdatePlaybackCaptureConfig interface.
678 */
679 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_024, TestSize.Level1)
680 {
681 AudioProcessConfig processConfig;
682 std::weak_ptr<IStreamListener> streamListener;
683 AudioPlaybackCaptureConfig config;
684 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
685 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION);
686 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
687 int32_t result = capturerInServer_->UpdatePlaybackCaptureConfig(config);
688 EXPECT_EQ(result, ERR_PERMISSION_DENIED);
689 }
690 #endif
691
692 /**
693 * @tc.name : Test CapturerInServer.
694 * @tc.type : FUNC
695 * @tc.number: CapturerInServerUnitTest_025.
696 * @tc.desc : Test GetAudioTime interface.
697 */
698 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_025, TestSize.Level1)
699 {
700 uint64_t framePos;
701 uint64_t timestamp;
702 AudioProcessConfig processConfig;
703 std::weak_ptr<IStreamListener> streamListener;
704 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
705 capturerInServer_->status_ = I_STATUS_STOPPED;
706 int32_t result = capturerInServer_->GetAudioTime(framePos, timestamp);
707 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
708 }
709
710 /**
711 * @tc.name : Test CapturerInServer.
712 * @tc.type : FUNC
713 * @tc.number: CapturerInServerUnitTest_026.
714 * @tc.desc : Test InitCacheBuffer interface.
715 */
716 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_026, TestSize.Level1)
717 {
718 size_t targetSize = 0;
719 AudioProcessConfig processConfig;
720 std::weak_ptr<IStreamListener> streamListener;
721 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
722 processConfig.innerCapMode =LEGACY_MUTE_CAP;
723 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
724 capturerInServer_->spanSizeInBytes_ = 1;
725 int32_t result = capturerInServer_->InitCacheBuffer(targetSize);
726 EXPECT_EQ(result, SUCCESS);
727 }
728
729 /**
730 * @tc.name : Test CapturerInServer.
731 * @tc.type : FUNC
732 * @tc.number: CapturerInServerUnitTest_027.
733 * @tc.desc : Test InitCacheBuffer interface.
734 */
735 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_027, TestSize.Level1)
736 {
737 size_t targetSize = 0;
738 AudioProcessConfig processConfig;
739 std::weak_ptr<IStreamListener> streamListener;
740 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
741 processConfig.innerCapMode =LEGACY_INNER_CAP;
742 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
743 capturerInServer_->spanSizeInBytes_ = 1;
744 int32_t result = capturerInServer_->InitCacheBuffer(targetSize);
745 EXPECT_EQ(result, SUCCESS);
746 }
747
748 /**
749 * @tc.name : Test CapturerInServer.
750 * @tc.type : FUNC
751 * @tc.number: CapturerInServerUnitTest_028.
752 * @tc.desc : Test InitCacheBuffer interface.
753 */
754 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_028, TestSize.Level1)
755 {
756 size_t targetSize = 0;
757 AudioProcessConfig processConfig;
758 std::weak_ptr<IStreamListener> streamListener;
759 processConfig.capturerInfo.sourceType = SOURCE_TYPE_VOICE_RECOGNITION;
760 processConfig.innerCapMode =LEGACY_MUTE_CAP;
761 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
762 capturerInServer_->spanSizeInBytes_ = 1;
763 int32_t result = capturerInServer_->InitCacheBuffer(targetSize);
764 EXPECT_EQ(result, SUCCESS);
765 }
766
767 /**
768 * @tc.name : Test CapturerInServer.
769 * @tc.type : FUNC
770 * @tc.number: CapturerInServerUnitTest_029.
771 * @tc.desc : Test InitCacheBuffer interface.
772 */
773 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_029, TestSize.Level1)
774 {
775 size_t targetSize = 0;
776 AudioProcessConfig processConfig;
777 std::weak_ptr<IStreamListener> streamListener;
778 processConfig.capturerInfo.sourceType = SOURCE_TYPE_VOICE_RECOGNITION;
779 processConfig.innerCapMode =LEGACY_INNER_CAP;
780 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
781 capturerInServer_->spanSizeInBytes_ = 1;
782 int32_t result = capturerInServer_->InitCacheBuffer(targetSize);
783 EXPECT_EQ(result, SUCCESS);
784 }
785
786 /**
787 * @tc.name : Test CapturerInServer.
788 * @tc.type : FUNC
789 * @tc.number: CapturerInServerUnitTest_030.
790 * @tc.desc : Test InitCacheBuffer interface.
791 */
792 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_030, TestSize.Level1)
793 {
794 size_t cacheSize = 960;
795 size_t targetSize = 0;
796 AudioProcessConfig processConfig;
797 std::weak_ptr<IStreamListener> streamListener;
798 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
799 capturerInServer_->ringCache_ = std::make_unique<AudioRingCache>(cacheSize);
800 capturerInServer_->spanSizeInBytes_ = 1;
801 int32_t result = capturerInServer_->InitCacheBuffer(targetSize);
802 EXPECT_EQ(result, SUCCESS);
803 }
804
805 /**
806 * @tc.name : Test CapturerInServer.
807 * @tc.type : FUNC
808 * @tc.number: DrainAudioBuffer_001.
809 * @tc.desc : Test DrainAudioBuffer interface.
810 */
811 HWTEST_F(CapturerInServerUnitTest, DrainAudioBuffer_001, TestSize.Level1)
812 {
813 AudioProcessConfig processConfig;
814 std::weak_ptr<IStreamListener> streamListener;
815 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
816 int32_t result = capturerInServer_->DrainAudioBuffer();
817 EXPECT_EQ(result, SUCCESS);
818 }
819
820 /**
821 * @tc.name : Test CapturerInServer.
822 * @tc.type : FUNC
823 * @tc.number: ResolveBuffer_001.
824 * @tc.desc : Test ResolveBuffer interface.
825 */
826 HWTEST_F(CapturerInServerUnitTest, ResolveBuffer_001, TestSize.Level1)
827 {
828 AudioProcessConfig processConfig;
829 std::weak_ptr<IStreamListener> streamListener;
830 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
831 std::shared_ptr<OHAudioBuffer> buffer;
832 int32_t result = capturerInServer_->ResolveBuffer(buffer);
833 EXPECT_EQ(result, SUCCESS);
834 }
835
836 /**
837 * @tc.name : Test CapturerInServer.
838 * @tc.type : FUNC
839 * @tc.number: OnReadData_001.
840 * @tc.desc : Test OnReadData interface.
841 */
842 HWTEST_F(CapturerInServerUnitTest, OnReadData_001, TestSize.Level1)
843 {
844 AudioProcessConfig processConfig;
845 std::weak_ptr<IStreamListener> streamListener;
846 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
847 size_t length = 0;
848 int32_t result = capturerInServer_->OnReadData(length);
849 EXPECT_EQ(result, SUCCESS);
850 }
851 } // namespace AudioStandard
852 } // namespace OHOS
853