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 class ICapturerStreamTest1 : public ICapturerStream {
65 public:
GetStreamFramesRead(uint64_t & framesRead)66 int32_t GetStreamFramesRead(uint64_t &framesRead) override { return 0; }
GetCurrentTimeStamp(uint64_t & timestamp)67 int32_t GetCurrentTimeStamp(uint64_t ×tamp) override { return 0; }
GetLatency(uint64_t & latency)68 int32_t GetLatency(uint64_t &latency) override { return 0; }
RegisterReadCallback(const std::weak_ptr<IReadCallback> & callback)69 void RegisterReadCallback(const std::weak_ptr<IReadCallback> &callback) override { return; }
GetMinimumBufferSize(size_t & minBufferSize) const70 int32_t GetMinimumBufferSize(size_t &minBufferSize) const override { return 0; }
GetByteSizePerFrame(size_t & byteSizePerFrame) const71 void GetByteSizePerFrame(size_t &byteSizePerFrame) const override { return; }
GetSpanSizePerFrame(size_t & spanSizeInFrame) const72 void GetSpanSizePerFrame(size_t &spanSizeInFrame) const override { spanSizeInFrame = 0; }
DropBuffer()73 int32_t DropBuffer() override { return 0; }
SetStreamIndex(uint32_t index)74 void SetStreamIndex(uint32_t index) override { return; }
GetStreamIndex()75 uint32_t GetStreamIndex() override { return 0; }
Start()76 int32_t Start() override { return 0; }
Pause(bool isStandby=false)77 int32_t Pause(bool isStandby = false) override { return 0; }
Flush()78 int32_t Flush() override { return 0; }
Drain(bool stopFlag=false)79 int32_t Drain(bool stopFlag = false) override { return 0; }
Stop()80 int32_t Stop() override { return 0; }
Release()81 int32_t Release() override { return 0; }
RegisterStatusCallback(const std::weak_ptr<IStatusCallback> & callback)82 void RegisterStatusCallback(const std::weak_ptr<IStatusCallback> &callback) override { return; }
DequeueBuffer(size_t length)83 BufferDesc DequeueBuffer(size_t length) override
84 {
85 BufferDesc bufferDesc;
86 return bufferDesc;
87 }
EnqueueBuffer(const BufferDesc & bufferDesc)88 int32_t EnqueueBuffer(const BufferDesc &bufferDesc) override { return 0; }
89 };
90
91 class ICapturerStreamTest2 : public ICapturerStream {
92 public:
GetStreamFramesRead(uint64_t & framesRead)93 int32_t GetStreamFramesRead(uint64_t &framesRead) override { return 0; }
GetCurrentTimeStamp(uint64_t & timestamp)94 int32_t GetCurrentTimeStamp(uint64_t ×tamp) override { return 0; }
GetLatency(uint64_t & latency)95 int32_t GetLatency(uint64_t &latency) override { return 0; }
RegisterReadCallback(const std::weak_ptr<IReadCallback> & callback)96 void RegisterReadCallback(const std::weak_ptr<IReadCallback> &callback) override { return; }
GetMinimumBufferSize(size_t & minBufferSize) const97 int32_t GetMinimumBufferSize(size_t &minBufferSize) const override { return 0; }
GetByteSizePerFrame(size_t & byteSizePerFrame) const98 void GetByteSizePerFrame(size_t &byteSizePerFrame) const override { return; }
GetSpanSizePerFrame(size_t & spanSizeInFrame) const99 void GetSpanSizePerFrame(size_t &spanSizeInFrame) const override { spanSizeInFrame = 1; }
DropBuffer()100 int32_t DropBuffer() override { return 0; }
SetStreamIndex(uint32_t index)101 void SetStreamIndex(uint32_t index) override { return; }
GetStreamIndex()102 uint32_t GetStreamIndex() override { return 0; }
Start()103 int32_t Start() override { return 0; }
Pause(bool isStandby=false)104 int32_t Pause(bool isStandby = false) override { return 0; }
Flush()105 int32_t Flush() override { return 0; }
Drain(bool stopFlag=false)106 int32_t Drain(bool stopFlag = false) override { return 0; }
Stop()107 int32_t Stop() override { return 0; }
Release()108 int32_t Release() override { return 0; }
RegisterStatusCallback(const std::weak_ptr<IStatusCallback> & callback)109 void RegisterStatusCallback(const std::weak_ptr<IStatusCallback> &callback) override { return; }
DequeueBuffer(size_t length)110 BufferDesc DequeueBuffer(size_t length) override
111 {
112 BufferDesc bufferDesc;
113 return bufferDesc;
114 }
EnqueueBuffer(const BufferDesc & bufferDesc)115 int32_t EnqueueBuffer(const BufferDesc &bufferDesc) override { return 0; }
116 };
117
118 /**
119 * @tc.name : Test CapturerInServer.
120 * @tc.type : FUNC
121 * @tc.number: CapturerInServerUnitTest_001.
122 * @tc.desc : Test ConfigServerBuffer interface.
123 */
124 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_001, TestSize.Level1)
125 {
126 uint32_t totalSizeInFrame = 10;
127 uint32_t spanSizeInFrame = 10;
128 uint32_t byteSizePerFrame = 10;
129 AudioProcessConfig processConfig;
130 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
131 pa_stream *paStream = nullptr;
132 processConfig.capturerInfo.sourceType = SOURCE_TYPE_WAKEUP;
133 std::weak_ptr<IStreamListener> streamListener;
134 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
135 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(AudioBufferHolder::AUDIO_CLIENT,
136 totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
137 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(paStream,
138 processConfig, mainloop);
139 int32_t result = capturerInServer_->ConfigServerBuffer();
140 EXPECT_EQ(result, SUCCESS);
141
142 capturerInServer_->audioServerBuffer_ = nullptr;
143 capturerInServer_->ConfigServerBuffer();
144 EXPECT_NE(capturerInServer_, nullptr);
145
146 capturerInServer_->totalSizeInFrame_ = 0;
147 capturerInServer_->ConfigServerBuffer();
148 EXPECT_NE(capturerInServer_, nullptr);
149
150 capturerInServer_->totalSizeInFrame_ = 10;
151 capturerInServer_->spanSizeInFrame_ = 0;
152 capturerInServer_->ConfigServerBuffer();
153 EXPECT_NE(capturerInServer_, nullptr);
154
155 capturerInServer_->totalSizeInFrame_ = 10;
156 capturerInServer_->spanSizeInFrame_ = 5;
157 capturerInServer_->ConfigServerBuffer();
158 EXPECT_NE(capturerInServer_, nullptr);
159
160 capturerInServer_->totalSizeInFrame_ = 10;
161 capturerInServer_->spanSizeInFrame_ = 3;
162 capturerInServer_->ConfigServerBuffer();
163 EXPECT_NE(capturerInServer_, nullptr);
164 }
165
166 /**
167 * @tc.name : Test CapturerInServer.
168 * @tc.type : FUNC
169 * @tc.number: CapturerInServerUnitTest_002.
170 * @tc.desc : Test ConfigServerBuffer interface.
171 */
172 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_002, TestSize.Level1)
173 {
174 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
175 pa_stream *paStream = nullptr;
176 AudioProcessConfig processConfig;
177 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
178 std::weak_ptr<IStreamListener> streamListener;
179 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
180 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(paStream,
181 processConfig, mainloop);
182 capturerInServer_->ConfigServerBuffer();
183 EXPECT_NE(capturerInServer_, nullptr);
184
185 capturerInServer_->spanSizeInFrame_ = 10;
186 capturerInServer_->ConfigServerBuffer();
187 EXPECT_NE(capturerInServer_, nullptr);
188 }
189
190 /**
191 * @tc.name : Test CapturerInServer.
192 * @tc.type : FUNC
193 * @tc.number: CapturerInServerUnitTest_003.
194 * @tc.desc : Test InitBufferStatus interface.
195 */
196 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_003, TestSize.Level1)
197 {
198 AudioBufferHolder bufferHolder;
199 uint32_t totalSizeInFrame = 10;
200 uint32_t spanSizeInFrame = 10;
201 uint32_t byteSizePerFrame = 10;
202 AudioProcessConfig processConfig;
203 std::weak_ptr<IStreamListener> streamListener;
204 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
205 int32_t result = capturerInServer_->InitBufferStatus();
206 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
207
208 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(bufferHolder, totalSizeInFrame,
209 spanSizeInFrame, byteSizePerFrame);
210 capturerInServer_->audioServerBuffer_->spanBasicInfo_.spanConut_ = 5;
211 capturerInServer_->InitBufferStatus();
212 EXPECT_NE(capturerInServer_, nullptr);
213 }
214
215 /**
216 * @tc.name : Test CapturerInServer.
217 * @tc.type : FUNC
218 * @tc.number: CapturerInServerUnitTest_004.
219 * @tc.desc : Test OnStatusUpdate interface.
220 */
221 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_004, TestSize.Level1)
222 {
223 AudioProcessConfig processConfig;
224 std::shared_ptr<IStreamListener> iStreamListener_ = std::make_shared<ConcreteIStreamListener>();
225 std::weak_ptr<IStreamListener> streamListener = iStreamListener_;
226 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
227 capturerInServer_->status_ = I_STATUS_RELEASED;
228 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_DRAINED);
229 EXPECT_NE(capturerInServer_, nullptr);
230
231 capturerInServer_->status_ = I_STATUS_IDLE;
232 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_UNDERFLOW);
233 EXPECT_NE(capturerInServer_, nullptr);
234
235 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_STARTED);
236 EXPECT_NE(capturerInServer_, nullptr);
237
238 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_PAUSED);
239 EXPECT_NE(capturerInServer_, nullptr);
240
241 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_STOPPED);
242 EXPECT_NE(capturerInServer_, nullptr);
243 }
244
245 /**
246 * @tc.name : Test CapturerInServer.
247 * @tc.type : FUNC
248 * @tc.number: CapturerInServerUnitTest_005.
249 * @tc.desc : Test OnStatusUpdate interface.
250 */
251 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_005, TestSize.Level1)
252 {
253 AudioProcessConfig processConfig;
254 std::shared_ptr<IStreamListener> iStreamListener_ = std::make_shared<ConcreteIStreamListener>();
255 std::weak_ptr<IStreamListener> streamListener = iStreamListener_;
256 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
257 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_FLUSHED);
258 EXPECT_NE(capturerInServer_, nullptr);
259
260 capturerInServer_->status_ = I_STATUS_FLUSHING_WHEN_STARTED;
261 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_FLUSHED);
262 EXPECT_NE(capturerInServer_, nullptr);
263 }
264
265 /**
266 * @tc.name : Test CapturerInServer.
267 * @tc.type : FUNC
268 * @tc.number: CapturerInServerUnitTest_006.
269 * @tc.desc : Test OnStatusUpdate interface.
270 */
271 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_006, TestSize.Level1)
272 {
273 AudioProcessConfig processConfig;
274 std::shared_ptr<IStreamListener> iStreamListener_ = std::make_shared<ConcreteIStreamListener>();
275 std::weak_ptr<IStreamListener> streamListener = iStreamListener_;
276 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
277 capturerInServer_->status_ = I_STATUS_FLUSHING_WHEN_PAUSED;
278 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_FLUSHED);
279 EXPECT_NE(capturerInServer_, nullptr);
280 }
281
282 /**
283 * @tc.name : Test CapturerInServer.
284 * @tc.type : FUNC
285 * @tc.number: CapturerInServerUnitTest_007.
286 * @tc.desc : Test OnStatusUpdate interface.
287 */
288 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_007, TestSize.Level1)
289 {
290 AudioProcessConfig processConfig;
291 std::shared_ptr<IStreamListener> iStreamListener_ = std::make_shared<ConcreteIStreamListener>();
292 std::weak_ptr<IStreamListener> streamListener = iStreamListener_;
293 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
294 capturerInServer_->status_ = I_STATUS_FLUSHING_WHEN_STOPPED;
295 capturerInServer_->OnStatusUpdate(IOperation::OPERATION_FLUSHED);
296 EXPECT_NE(capturerInServer_, nullptr);
297 }
298
299 /**
300 * @tc.name : Test CapturerInServer.
301 * @tc.type : FUNC
302 * @tc.number: CapturerInServerUnitTest_008.
303 * @tc.desc : Test OnStatusUpdate interface.
304 */
305 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_008, TestSize.Level1)
306 {
307 size_t length = 10;
308 uint64_t currentWriteFrame = 10;
309 uint32_t totalSizeInFrame = 10;
310 uint32_t spanSizeInFrame = 10;
311 uint32_t byteSizePerFrame = 10;
312
313 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
314 adapterManager->InitPaContext();
315 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
316 AudioProcessConfig processConfig = GetInnerCapConfig();
317 uint32_t sessionId = 123456;
318 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
319
320 std::shared_ptr<IStreamListener> stateListener = std::make_shared<ConcreteIStreamListener>();
321 std::weak_ptr<IStreamListener> streamListener;
322 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
323 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
324 processConfig, mainloop);
325 ASSERT_NE(nullptr, capturerInServer_);
326
327 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(AudioBufferHolder::AUDIO_CLIENT,
328 totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
329 auto bufferInfo = std::make_shared<BasicBufferInfo>();
330 capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_ = bufferInfo.get();
331
332 capturerInServer_->spanSizeInFrame_ = 5;
333 auto ret = capturerInServer_->IsReadDataOverFlow(length, currentWriteFrame, stateListener);
334 EXPECT_EQ(false, ret);
335 }
336
337 /**
338 * @tc.name : Test CapturerInServer.
339 * @tc.type : FUNC
340 * @tc.number: CapturerInServerUnitTest_009.
341 * @tc.desc : Test ReadData interface.
342 */
343 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_009, TestSize.Level1)
344 {
345 size_t length = 10;
346 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
347 adapterManager->InitPaContext();
348 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
349 AudioProcessConfig processConfig = GetInnerCapConfig();
350 uint32_t sessionId = 123456;
351 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
352 std::weak_ptr<IStreamListener> streamListener = std::make_shared<ConcreteIStreamListener>();
353 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
354 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream, processConfig, mainloop);
355 ASSERT_NE(nullptr, capturerInServer_);
356
357 capturerInServer_->spanSizeInFrame_ = -100;
358 capturerInServer_->muteFlag_.store(true);
359 AudioDump::GetInstance().GetVersionType() = DumpFileUtil::BETA_VERSION;
360 capturerInServer_->ReadData(length);
361 EXPECT_NE(capturerInServer_, nullptr);
362 }
363
364 /**
365 * @tc.name : Test CapturerInServer.
366 * @tc.type : FUNC
367 * @tc.number: CapturerInServerUnitTest_010.
368 * @tc.desc : Test Start/Stop interface.
369 */
370 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_010, TestSize.Level1)
371 {
372 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
373 adapterManager->InitPaContext();
374 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
375 AudioProcessConfig processConfig = GetInnerCapConfig();
376 uint32_t sessionId = 123456;
377 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
378
379 std::weak_ptr<IStreamListener> streamListener;
380 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
381 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
382 processConfig, mainloop);
383 capturerInServer_->status_ = I_STATUS_FLUSHING_WHEN_STARTED;
384 int32_t result = capturerInServer_->Start();
385 EXPECT_NE(result, SUCCESS);
386
387 capturerInServer_->status_ = I_STATUS_IDLE;
388 capturerInServer_->Start();
389 capturerInServer_->Stop();
390 EXPECT_NE(capturerInServer_, nullptr);
391
392 capturerInServer_->status_ = I_STATUS_PAUSED;
393 capturerInServer_->Start();
394 capturerInServer_->Stop();
395 EXPECT_NE(capturerInServer_, nullptr);
396
397 capturerInServer_->status_ = I_STATUS_STOPPED;
398 capturerInServer_->Start();
399 capturerInServer_->Stop();
400 EXPECT_NE(capturerInServer_, nullptr);
401 }
402
403 /**
404 * @tc.name : Test CapturerInServer.
405 * @tc.type : FUNC
406 * @tc.number: CapturerInServerUnitTest_011.
407 * @tc.desc : Test Start/Stop interface.
408 */
409 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_011, TestSize.Level1)
410 {
411 AudioProcessConfig processConfig = GetInnerCapConfig();
412 int32_t UID_MSDP_SA = 6699;
413 processConfig.callerUid = UID_MSDP_SA;
414 std::weak_ptr<IStreamListener> streamListener;
415
416 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
417 adapterManager->InitPaContext();
418 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
419 uint32_t sessionId = 123456;
420 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
421
422 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
423 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
424 processConfig, mainloop);
425 capturerInServer_->status_ = I_STATUS_IDLE;
426 capturerInServer_->Start();
427 capturerInServer_->Stop();
428 EXPECT_NE(capturerInServer_, nullptr);
429 }
430
431 /**
432 * @tc.name : Test CapturerInServer.
433 * @tc.type : FUNC
434 * @tc.number: CapturerInServerUnitTest_012.
435 * @tc.desc : Test Start/Stop interface.
436 */
437 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_012, TestSize.Level1)
438 {
439 AudioProcessConfig processConfig = GetInnerCapConfig();
440 int32_t TIME_OUT_SECONDS = 10;
441 processConfig.callerUid = TIME_OUT_SECONDS;
442 processConfig.capturerInfo.sourceType = SOURCE_TYPE_EC;
443 std::weak_ptr<IStreamListener> streamListener;
444
445 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
446 adapterManager->InitPaContext();
447 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
448 uint32_t sessionId = 123456;
449 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
450
451 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
452 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
453 processConfig, mainloop);
454 capturerInServer_->status_ = I_STATUS_IDLE;
455 capturerInServer_->Start();
456 capturerInServer_->Stop();
457 EXPECT_NE(capturerInServer_, nullptr);
458 }
459
460 /**
461 * @tc.name : Test CapturerInServer.
462 * @tc.type : FUNC
463 * @tc.number: CapturerInServerUnitTest_013.
464 * @tc.desc : Test Start/Stop interface.
465 */
466 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_013, TestSize.Level1)
467 {
468 AudioProcessConfig processConfig = GetInnerCapConfig();
469 int32_t UID_MSDP_SA = 6699;
470 processConfig.callerUid = UID_MSDP_SA;
471 std::weak_ptr<IStreamListener> streamListener;
472
473 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
474 adapterManager->InitPaContext();
475 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
476 uint32_t sessionId = 123456;
477 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
478
479 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
480 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
481 processConfig, mainloop);
482 capturerInServer_->needCheckBackground_ = true;
483 capturerInServer_->status_ = I_STATUS_IDLE;
484 capturerInServer_->Start();
485 capturerInServer_->Stop();
486 EXPECT_NE(capturerInServer_, nullptr);
487 }
488
489 /**
490 * @tc.name : Test CapturerInServer.
491 * @tc.type : FUNC
492 * @tc.number: CapturerInServerUnitTest_014.
493 * @tc.desc : Test Start/Stop interface.
494 */
495 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_014, TestSize.Level1)
496 {
497 AudioProcessConfig processConfig = GetInnerCapConfig();
498 int32_t TIME_OUT_SECONDS = 10;
499 processConfig.callerUid = TIME_OUT_SECONDS;
500 processConfig.capturerInfo.sourceType = SOURCE_TYPE_EC;
501 std::weak_ptr<IStreamListener> streamListener;
502
503 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
504 adapterManager->InitPaContext();
505 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
506 uint32_t sessionId = 123456;
507 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
508
509 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
510 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
511 processConfig, mainloop);
512 capturerInServer_->needCheckBackground_ = true;
513 capturerInServer_->status_ = I_STATUS_IDLE;
514 capturerInServer_->recorderDfx_ = std::make_unique<RecorderDfxWriter>(processConfig.appInfo, 0);
515 capturerInServer_->Start();
516 capturerInServer_->Stop();
517 EXPECT_NE(capturerInServer_, nullptr);
518 }
519
520 /**
521 * @tc.name : Test CapturerInServer.
522 * @tc.type : FUNC
523 * @tc.number: CapturerInServerUnitTest_015.
524 * @tc.desc : Test Pause interface.
525 */
526 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_015, TestSize.Level1)
527 {
528 AudioProcessConfig processConfig = GetInnerCapConfig();
529 std::weak_ptr<IStreamListener> streamListener;
530
531 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
532 adapterManager->InitPaContext();
533 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
534 uint32_t sessionId = 123456;
535 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
536
537 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
538 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
539 processConfig, mainloop);
540 capturerInServer_->status_ = I_STATUS_STARTING;
541 int32_t result = capturerInServer_->Pause();
542 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
543
544 capturerInServer_->status_ = I_STATUS_STARTED;
545 result = capturerInServer_->Pause();
546 EXPECT_NE(capturerInServer_, nullptr);
547
548 capturerInServer_->status_ = I_STATUS_STARTED;
549 capturerInServer_->needCheckBackground_ = true;
550 result = capturerInServer_->Pause();
551 EXPECT_NE(capturerInServer_, nullptr);
552 }
553
554 /**
555 * @tc.name : Test CapturerInServer.
556 * @tc.type : FUNC
557 * @tc.number: CapturerInServerUnitTest_016.
558 * @tc.desc : Test Flush interface.
559 */
560 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_016, TestSize.Level1)
561 {
562 uint32_t totalSizeInFrame = 10;
563 uint32_t spanSizeInFrame = 10;
564 uint32_t byteSizePerFrame = 10;
565 std::weak_ptr<IStreamListener> streamListener;
566
567 AudioProcessConfig processConfig = GetInnerCapConfig();
568 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
569 adapterManager->InitPaContext();
570 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
571 uint32_t sessionId = 123456;
572 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
573
574 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
575 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
576 processConfig, mainloop);
577 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(AudioBufferHolder::AUDIO_CLIENT,
578 totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
579 int32_t result = capturerInServer_->Flush();
580 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
581
582 capturerInServer_->status_ = I_STATUS_STARTED;
583 capturerInServer_->Flush();
584 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
585 }
586
587 /**
588 * @tc.name : Test CapturerInServer.
589 * @tc.type : FUNC
590 * @tc.number: CapturerInServerUnitTest_017.
591 * @tc.desc : Test Flush interface.
592 */
593 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_017, TestSize.Level1)
594 {
595 uint32_t totalSizeInFrame = 10;
596 uint32_t spanSizeInFrame = 10;
597 uint32_t byteSizePerFrame = 10;
598 std::weak_ptr<IStreamListener> streamListener;
599
600 AudioProcessConfig processConfig = GetInnerCapConfig();
601 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
602 adapterManager->InitPaContext();
603 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
604 uint32_t sessionId = 123456;
605 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
606
607 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
608 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
609 processConfig, mainloop);
610 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(AudioBufferHolder::AUDIO_CLIENT,
611 totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
612 capturerInServer_->status_ = I_STATUS_PAUSED;
613 capturerInServer_->Flush();
614 EXPECT_NE(capturerInServer_, nullptr);
615
616 capturerInServer_->status_ = I_STATUS_STOPPED;
617 capturerInServer_->Flush();
618 EXPECT_NE(capturerInServer_, nullptr);
619 }
620
621 /**
622 * @tc.name : Test CapturerInServer.
623 * @tc.type : FUNC
624 * @tc.number: CapturerInServerUnitTest_018.
625 * @tc.desc : Test Stop interface.
626 */
627 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_018, TestSize.Level1)
628 {
629 AudioProcessConfig processConfig = GetInnerCapConfig();
630 std::weak_ptr<IStreamListener> streamListener;
631
632 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
633 adapterManager->InitPaContext();
634 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
635 uint32_t sessionId = 123456;
636 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
637
638 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
639 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
640 processConfig, mainloop);
641 capturerInServer_->status_ = I_STATUS_FLUSHING_WHEN_STARTED;
642 int32_t result = capturerInServer_->Stop();
643 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
644
645 capturerInServer_->status_ = I_STATUS_PAUSED;
646 result = capturerInServer_->Stop();
647 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
648
649 capturerInServer_->status_ = I_STATUS_PAUSED;
650 capturerInServer_->needCheckBackground_ = true;
651 result = capturerInServer_->Stop();
652 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
653 }
654
655 /**
656 * @tc.name : Test CapturerInServer.
657 * @tc.type : FUNC
658 * @tc.number: CapturerInServerUnitTest_019.
659 * @tc.desc : Test Release interface.
660 */
661 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_019, TestSize.Level1)
662 {
663 AudioProcessConfig processConfig;
664 std::weak_ptr<IStreamListener> streamListener;
665 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
666 capturerInServer_->status_ = I_STATUS_RELEASED;
667 int result = capturerInServer_->Release();
668 EXPECT_EQ(result, SUCCESS);
669 }
670
671 /**
672 * @tc.name : Test CapturerInServer.
673 * @tc.type : FUNC
674 * @tc.number: CapturerInServerUnitTest_020.
675 * @tc.desc : Test Release interface.
676 */
677 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_020, TestSize.Level1)
678 {
679 AudioProcessConfig processConfig;
680 std::weak_ptr<IStreamListener> streamListener;
681 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
682 processConfig.innerCapMode = INVALID_CAP_MODE;
683 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
684 capturerInServer_->status_ = I_STATUS_RELEASING;
685 int result = capturerInServer_->Release();
686 EXPECT_EQ(result, SUCCESS);
687
688 capturerInServer_->needCheckBackground_ = true;
689 result = capturerInServer_->Release();
690 EXPECT_EQ(result, SUCCESS);
691 }
692
693 #ifdef HAS_FEATURE_INNERCAPTURER
694 /**
695 * @tc.name : Test CapturerInServer.
696 * @tc.type : FUNC
697 * @tc.number: pdatePlaybackCaptureConfigInLegacy_021.
698 * @tc.desc : Test pdatePlaybackCaptureConfigInLegacy interface.
699 */
700 HWTEST_F(CapturerInServerUnitTest, UpdatePlaybackCaptureConfigInLegacy_001, TestSize.Level3)
701 {
702 AudioProcessConfig processConfig;
703 std::weak_ptr<IStreamListener> streamListener;
704 AudioPlaybackCaptureConfig config;
705 processConfig.innerCapMode = MODERN_INNER_CAP;
706 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
707 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
708 int32_t result = capturerInServer_->UpdatePlaybackCaptureConfigInLegacy(config);
709 EXPECT_EQ(result, SUCCESS);
710 }
711
712 /**
713 * @tc.name : Test CapturerInServer.
714 * @tc.type : FUNC
715 * @tc.number: CapturerInServerUnitTest_021.
716 * @tc.desc : Test UpdatePlaybackCaptureConfig interface.
717 */
718 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_021, TestSize.Level1)
719 {
720 AudioProcessConfig processConfig;
721 std::weak_ptr<IStreamListener> streamListener;
722 AudioPlaybackCaptureConfig config;
723 processConfig.innerCapMode = MODERN_INNER_CAP;
724 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
725 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
726 int32_t result = capturerInServer_->UpdatePlaybackCaptureConfig(config);
727 EXPECT_EQ(result, SUCCESS);
728 }
729
730 /**
731 * @tc.name : Test CapturerInServer.
732 * @tc.type : FUNC
733 * @tc.number: CapturerInServerUnitTest_022.
734 * @tc.desc : Test UpdatePlaybackCaptureConfig interface.
735 */
736 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_022, TestSize.Level1)
737 {
738 AudioProcessConfig processConfig;
739 std::weak_ptr<IStreamListener> streamListener;
740 AudioPlaybackCaptureConfig config;
741 processConfig.innerCapMode = LEGACY_INNER_CAP;
742 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
743 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
744 int32_t result = capturerInServer_->UpdatePlaybackCaptureConfig(config);
745 EXPECT_EQ(result, SUCCESS);
746 }
747
748 /**
749 * @tc.name : Test CapturerInServer.
750 * @tc.type : FUNC
751 * @tc.number: CapturerInServerUnitTest_023.
752 * @tc.desc : Test UpdatePlaybackCaptureConfig interface.
753 */
754 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_023, TestSize.Level1)
755 {
756 AudioProcessConfig processConfig;
757 std::weak_ptr<IStreamListener> streamListener;
758 AudioPlaybackCaptureConfig config;
759 processConfig.innerCapMode = MODERN_INNER_CAP;
760 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
761 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_UNKNOWN);
762 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
763 int32_t result = capturerInServer_->UpdatePlaybackCaptureConfig(config);
764 EXPECT_EQ(result, SUCCESS);
765 }
766
767 /**
768 * @tc.name : Test CapturerInServer.
769 * @tc.type : FUNC
770 * @tc.number: CapturerInServerUnitTest_024.
771 * @tc.desc : Test UpdatePlaybackCaptureConfig interface.
772 */
773 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_024, TestSize.Level1)
774 {
775 AudioProcessConfig processConfig;
776 std::weak_ptr<IStreamListener> streamListener;
777 AudioPlaybackCaptureConfig config;
778 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
779 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION);
780 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
781 int32_t result = capturerInServer_->UpdatePlaybackCaptureConfig(config);
782 EXPECT_EQ(result, ERR_PERMISSION_DENIED);
783 }
784 #endif
785
786 /**
787 * @tc.name : Test CapturerInServer.
788 * @tc.type : FUNC
789 * @tc.number: CapturerInServerUnitTest_025.
790 * @tc.desc : Test GetAudioTime interface.
791 */
792 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_025, TestSize.Level1)
793 {
794 uint64_t framePos;
795 uint64_t timestamp;
796 AudioProcessConfig processConfig;
797 std::weak_ptr<IStreamListener> streamListener;
798 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
799 capturerInServer_->status_ = I_STATUS_STOPPED;
800 int32_t result = capturerInServer_->GetAudioTime(framePos, timestamp);
801 EXPECT_EQ(result, ERR_ILLEGAL_STATE);
802 }
803
804 /**
805 * @tc.name : Test CapturerInServer.
806 * @tc.type : FUNC
807 * @tc.number: CapturerInServerUnitTest_026.
808 * @tc.desc : Test InitCacheBuffer interface.
809 */
810 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_026, TestSize.Level1)
811 {
812 size_t targetSize = 0;
813 AudioProcessConfig processConfig;
814 std::weak_ptr<IStreamListener> streamListener;
815 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
816 processConfig.innerCapMode =LEGACY_MUTE_CAP;
817 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
818 capturerInServer_->spanSizeInBytes_ = 1;
819 int32_t result = capturerInServer_->InitCacheBuffer(targetSize);
820 EXPECT_EQ(result, SUCCESS);
821 }
822
823 /**
824 * @tc.name : Test CapturerInServer.
825 * @tc.type : FUNC
826 * @tc.number: CapturerInServerUnitTest_027.
827 * @tc.desc : Test InitCacheBuffer interface.
828 */
829 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_027, TestSize.Level1)
830 {
831 size_t targetSize = 0;
832 AudioProcessConfig processConfig;
833 std::weak_ptr<IStreamListener> streamListener;
834 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
835 processConfig.innerCapMode =LEGACY_INNER_CAP;
836 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
837 capturerInServer_->spanSizeInBytes_ = 1;
838 int32_t result = capturerInServer_->InitCacheBuffer(targetSize);
839 EXPECT_EQ(result, SUCCESS);
840 }
841
842 /**
843 * @tc.name : Test CapturerInServer.
844 * @tc.type : FUNC
845 * @tc.number: CapturerInServerUnitTest_028.
846 * @tc.desc : Test InitCacheBuffer interface.
847 */
848 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_028, TestSize.Level1)
849 {
850 size_t targetSize = 0;
851 AudioProcessConfig processConfig;
852 std::weak_ptr<IStreamListener> streamListener;
853 processConfig.capturerInfo.sourceType = SOURCE_TYPE_VOICE_RECOGNITION;
854 processConfig.innerCapMode =LEGACY_MUTE_CAP;
855 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
856 capturerInServer_->spanSizeInBytes_ = 1;
857 int32_t result = capturerInServer_->InitCacheBuffer(targetSize);
858 EXPECT_EQ(result, SUCCESS);
859 }
860
861 /**
862 * @tc.name : Test CapturerInServer.
863 * @tc.type : FUNC
864 * @tc.number: CapturerInServerUnitTest_029.
865 * @tc.desc : Test InitCacheBuffer interface.
866 */
867 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_029, TestSize.Level1)
868 {
869 size_t targetSize = 0;
870 AudioProcessConfig processConfig;
871 std::weak_ptr<IStreamListener> streamListener;
872 processConfig.capturerInfo.sourceType = SOURCE_TYPE_VOICE_RECOGNITION;
873 processConfig.innerCapMode =LEGACY_INNER_CAP;
874 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
875 capturerInServer_->spanSizeInBytes_ = 1;
876 int32_t result = capturerInServer_->InitCacheBuffer(targetSize);
877 EXPECT_EQ(result, SUCCESS);
878 }
879
880 /**
881 * @tc.name : Test CapturerInServer.
882 * @tc.type : FUNC
883 * @tc.number: CapturerInServerUnitTest_030.
884 * @tc.desc : Test InitCacheBuffer interface.
885 */
886 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_030, TestSize.Level1)
887 {
888 size_t cacheSize = 960;
889 size_t targetSize = 0;
890 AudioProcessConfig processConfig;
891 std::weak_ptr<IStreamListener> streamListener;
892 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
893 capturerInServer_->ringCache_ = std::make_unique<AudioRingCache>(cacheSize);
894 capturerInServer_->spanSizeInBytes_ = 1;
895 int32_t result = capturerInServer_->InitCacheBuffer(targetSize);
896 EXPECT_EQ(result, SUCCESS);
897 }
898
899 /**
900 * @tc.name : Test CapturerInServer.
901 * @tc.type : FUNC
902 * @tc.number: DrainAudioBuffer_001.
903 * @tc.desc : Test DrainAudioBuffer interface.
904 */
905 HWTEST_F(CapturerInServerUnitTest, DrainAudioBuffer_001, TestSize.Level1)
906 {
907 AudioProcessConfig processConfig;
908 std::weak_ptr<IStreamListener> streamListener;
909 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
910 int32_t result = capturerInServer_->DrainAudioBuffer();
911 EXPECT_EQ(result, SUCCESS);
912 }
913
914 /**
915 * @tc.name : Test CapturerInServer.
916 * @tc.type : FUNC
917 * @tc.number: ResolveBuffer_001.
918 * @tc.desc : Test ResolveBuffer interface.
919 */
920 HWTEST_F(CapturerInServerUnitTest, ResolveBuffer_001, TestSize.Level1)
921 {
922 AudioProcessConfig processConfig;
923 std::weak_ptr<IStreamListener> streamListener;
924 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
925 std::shared_ptr<OHAudioBuffer> buffer;
926 int32_t result = capturerInServer_->ResolveBuffer(buffer);
927 EXPECT_EQ(result, SUCCESS);
928 }
929
930 /**
931 * @tc.name : Test CapturerInServer.
932 * @tc.type : FUNC
933 * @tc.number: OnReadData_001.
934 * @tc.desc : Test OnReadData interface.
935 */
936 HWTEST_F(CapturerInServerUnitTest, OnReadData_001, TestSize.Level1)
937 {
938 AudioProcessConfig processConfig;
939 std::weak_ptr<IStreamListener> streamListener;
940 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
941 size_t length = 0;
942 int32_t result = capturerInServer_->OnReadData(length);
943 EXPECT_EQ(result, SUCCESS);
944 }
945
946 /**
947 * @tc.name : Test CapturerInServer.
948 * @tc.type : FUNC
949 * @tc.number: HandleOperationFlushed_001.
950 * @tc.desc : Test HandleOperationFlushed interface.
951 */
952 HWTEST_F(CapturerInServerUnitTest, HandleOperationFlushed_001, TestSize.Level1)
953 {
954 AudioProcessConfig processConfig;
955 std::weak_ptr<IStreamListener> streamListener;
956 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
957
958 capturerInServer_->status_ = I_STATUS_FLUSHING_WHEN_STARTED;
959 capturerInServer_->HandleOperationFlushed();
960 EXPECT_EQ(capturerInServer_->status_, I_STATUS_STARTED);
961
962 capturerInServer_->status_ = I_STATUS_FLUSHING_WHEN_PAUSED;
963 capturerInServer_->HandleOperationFlushed();
964 EXPECT_EQ(capturerInServer_->status_, I_STATUS_PAUSED);
965
966 capturerInServer_->status_ = I_STATUS_FLUSHING_WHEN_STOPPED;
967 capturerInServer_->HandleOperationFlushed();
968 EXPECT_EQ(capturerInServer_->status_, I_STATUS_STOPPED);
969
970 capturerInServer_->status_ = I_STATUS_IDLE;
971 capturerInServer_->HandleOperationFlushed();
972 }
973
974 /**
975 * @tc.name : Test CapturerInServer.
976 * @tc.type : FUNC
977 * @tc.number: GetLastAudioDuration_001.
978 * @tc.desc : Test GetLastAudioDuration interface.
979 */
980 HWTEST_F(CapturerInServerUnitTest, GetLastAudioDuration_001, TestSize.Level1)
981 {
982 AudioProcessConfig processConfig;
983 std::weak_ptr<IStreamListener> streamListener;
984 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
985
986 capturerInServer_->lastStopTime_ = 1;
987 capturerInServer_->lastStartTime_ = 2;
988 int64_t result = capturerInServer_->GetLastAudioDuration();
989 EXPECT_EQ(result, -1);
990
991 capturerInServer_->lastStopTime_ = 3;
992 result = capturerInServer_->GetLastAudioDuration();
993 EXPECT_EQ(result, 1);
994 }
995
996 /**
997 * @tc.name : Test CapturerInServer.
998 * @tc.type : FUNC
999 * @tc.number: CapturerInServerUnitTest_031.
1000 * @tc.desc : Test Flush interface.
1001 */
1002 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_031, TestSize.Level1)
1003 {
1004 uint32_t totalSizeInFrame = 10;
1005 uint32_t spanSizeInFrame = 10;
1006 uint32_t byteSizePerFrame = 10;
1007 std::weak_ptr<IStreamListener> streamListener;
1008
1009 AudioProcessConfig processConfig = GetInnerCapConfig();
1010 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
1011 adapterManager->InitPaContext();
1012 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
1013 uint32_t sessionId = 123456;
1014 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
1015
1016 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
1017 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream,
1018 processConfig, mainloop);
1019 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(AudioBufferHolder::AUDIO_CLIENT,
1020 totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
1021 capturerInServer_->status_ = I_STATUS_PAUSED;
1022 auto bufferInfo = std::make_shared<BasicBufferInfo>();
1023 capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_ = bufferInfo.get();
1024 capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_->curWriteFrame.store(10);
1025 capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_->curReadFrame.store(20);
1026 auto ret = capturerInServer_->Flush();
1027 EXPECT_NE(SUCCESS, ret);
1028 }
1029
1030 /**
1031 * @tc.name : Test CapturerInServer.
1032 * @tc.type : FUNC
1033 * @tc.number: CapturerInServerUnitTest_032.
1034 * @tc.desc : Test GetAudioTime interface.
1035 */
1036 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_032, TestSize.Level1)
1037 {
1038 uint64_t framePos;
1039 uint64_t timestamp;
1040 AudioProcessConfig processConfig;
1041 std::weak_ptr<IStreamListener> streamListener;
1042 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
1043 capturerInServer_->status_ = I_STATUS_STARTING;
1044
1045 pa_stream *paStream = nullptr;
1046 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
1047 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(paStream,
1048 processConfig, mainloop);
1049
1050 capturerInServer_->resetTime_ = false;
1051 int32_t result = capturerInServer_->GetAudioTime(framePos, timestamp);
1052 EXPECT_EQ(result, SUCCESS);
1053
1054 capturerInServer_->resetTime_ = true;
1055 result = capturerInServer_->GetAudioTime(framePos, timestamp);
1056 EXPECT_EQ(result, SUCCESS);
1057 }
1058
1059 /**
1060 * @tc.name : Test CapturerInServer.
1061 * @tc.type : FUNC
1062 * @tc.number: CapturerInServerUnitTest_033.
1063 * @tc.desc : Test GetAudioTime interface.
1064 */
1065 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_033, TestSize.Level1)
1066 {
1067 uint32_t totalSizeInFrame = 10;
1068 uint32_t spanSizeInFrame = 10;
1069 uint32_t byteSizePerFrame = 10;
1070 AudioProcessConfig processConfig;
1071 std::weak_ptr<IStreamListener> streamListener;
1072 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
1073 ASSERT_TRUE(capturerInServer_ != nullptr);
1074
1075 RestoreInfo restoreInfo;
1076 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(AudioBufferHolder::AUDIO_CLIENT,
1077 totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
1078 capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_ = nullptr;
1079 capturerInServer_->RestoreSession(restoreInfo);
1080 auto bufferInfo = std::make_shared<BasicBufferInfo>();
1081 capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_ = bufferInfo.get();
1082 capturerInServer_->RestoreSession(restoreInfo);
1083 capturerInServer_->status_.store(I_STATUS_INVALID);
1084 capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_->restoreStatus.store(NEED_RESTORE);
1085 auto ret = capturerInServer_->RestoreSession(restoreInfo);
1086 EXPECT_EQ(NEED_RESTORE, ret);
1087 capturerInServer_->status_.store(I_STATUS_FLUSHING_WHEN_STARTED);
1088 capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_->restoreStatus.store(NEED_RESTORE);
1089 ret = capturerInServer_->RestoreSession(restoreInfo);
1090 EXPECT_EQ(NEED_RESTORE, ret);
1091 capturerInServer_->status_.store(I_STATUS_FLUSHING_WHEN_PAUSED);
1092 capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_->restoreStatus.store(NEED_RESTORE);
1093 ret = capturerInServer_->RestoreSession(restoreInfo);
1094 EXPECT_EQ(NEED_RESTORE, ret);
1095 capturerInServer_->status_.store(I_STATUS_FLUSHING_WHEN_STOPPED);
1096 capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_->restoreStatus.store(NEED_RESTORE);
1097 ret = capturerInServer_->RestoreSession(restoreInfo);
1098 EXPECT_EQ(NEED_RESTORE, ret);
1099 capturerInServer_->status_.store(I_STATUS_RELEASED);
1100 capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_->restoreStatus.store(NEED_RESTORE);
1101 ret = capturerInServer_->RestoreSession(restoreInfo);
1102 EXPECT_EQ(NEED_RESTORE, ret);
1103 capturerInServer_->status_.store(I_STATUS_IDLE);
1104 capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_->restoreStatus.store(NEED_RESTORE);
1105 ret = capturerInServer_->RestoreSession(restoreInfo);
1106 EXPECT_EQ(NEED_RESTORE, ret);
1107 }
1108
1109 /**
1110 * @tc.name : Test CapturerInServer.
1111 * @tc.type : FUNC
1112 * @tc.number: CapturerInServerUnitTest_034
1113 * @tc.desc : Test ConfigServerBuffer interface.
1114 */
1115 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_034, TestSize.Level1)
1116 {
1117 AudioProcessConfig processConfig;
1118 processConfig.capturerInfo.sourceType = SOURCE_TYPE_WAKEUP;
1119
1120 std::weak_ptr<IStreamListener> streamListener;
1121 auto capturerInServer = std::make_shared<CapturerInServer>(processConfig, streamListener);
1122 capturerInServer->audioServerBuffer_ = nullptr;
1123 capturerInServer->stream_ = std::make_shared<ICapturerStreamTest1>();
1124 ASSERT_NE(capturerInServer->stream_, nullptr);
1125
1126 auto ret = capturerInServer->ConfigServerBuffer();
1127 EXPECT_EQ(ret, ERR_INVALID_PARAM);
1128 }
1129
1130 /**
1131 * @tc.name : Test CapturerInServer.
1132 * @tc.type : FUNC
1133 * @tc.number: CapturerInServerUnitTest_035
1134 * @tc.desc : Test ConfigServerBuffer interface.
1135 */
1136 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_035, TestSize.Level1)
1137 {
1138 AudioProcessConfig processConfig;
1139 processConfig.capturerInfo.sourceType = SOURCE_TYPE_WAKEUP;
1140
1141 std::weak_ptr<IStreamListener> streamListener;
1142 auto capturerInServer = std::make_shared<CapturerInServer>(processConfig, streamListener);
1143 capturerInServer->audioServerBuffer_ = nullptr;
1144 capturerInServer->stream_ = std::make_shared<ICapturerStreamTest2>();
1145 ASSERT_NE(capturerInServer->stream_, nullptr);
1146
1147 auto ret = capturerInServer->ConfigServerBuffer();
1148 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1149 }
1150
1151 /**
1152 * @tc.name : Test CapturerInServer.
1153 * @tc.type : FUNC
1154 * @tc.number: CapturerInServerUnitTest_036.
1155 * @tc.desc : Test Init interface.
1156 */
1157 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_036, TestSize.Level1)
1158 {
1159 uint32_t totalSizeInFrame = 10;
1160 uint32_t spanSizeInFrame = 10;
1161 uint32_t byteSizePerFrame = 10;
1162 AudioProcessConfig processConfig;
1163 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
1164 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
1165 adapterManager->InitPaContext();
1166 uint32_t sessionId = 123456;
1167 pa_stream *paStream = adapterManager->InitPaStream(processConfig, sessionId, false);
1168 processConfig.capturerInfo.sourceType = SOURCE_TYPE_WAKEUP;
1169 std::shared_ptr<IStreamListener> iStreamListener_ = std::make_shared<ConcreteIStreamListener>();
1170 std::weak_ptr<IStreamListener> streamListener = iStreamListener_;
1171 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
1172 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(AudioBufferHolder::AUDIO_CLIENT,
1173 totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
1174 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(paStream,
1175 processConfig, mainloop);
1176 EXPECT_NE(capturerInServer_, nullptr);
1177
1178 auto ret = capturerInServer_->Init();
1179 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1180 }
1181
1182 /**
1183 * @tc.name : Test CapturerInServer.
1184 * @tc.type : FUNC
1185 * @tc.number: CapturerInServerUnitTest_037.
1186 * @tc.desc : Test TurnOnMicIndicator interface.
1187 */
1188 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_037, TestSize.Level1)
1189 {
1190 AudioProcessConfig processConfig = GetInnerCapConfig();
1191 std::weak_ptr<IStreamListener> streamListener;
1192 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
1193 ASSERT_TRUE(capturerInServer_ != nullptr);
1194
1195 CapturerState capturerState = CAPTURER_NEW;
1196 capturerInServer_->processConfig_.appInfo.appFullTokenId = (static_cast<uint64_t>(1) << 32);
1197 auto ret = capturerInServer_->TurnOnMicIndicator(capturerState);
1198 EXPECT_EQ(ret, false);
1199
1200 capturerInServer_->isMicIndicatorOn_ = true;
1201 ret = capturerInServer_->TurnOnMicIndicator(capturerState);
1202 EXPECT_EQ(true, ret);
1203 }
1204
1205 /**
1206 * @tc.name : Test CapturerInServer.
1207 * @tc.type : FUNC
1208 * @tc.number: CapturerInServerUnitTest_038.
1209 * @tc.desc : Test TurnOffMicIndicator interface.
1210 */
1211 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_038, TestSize.Level1)
1212 {
1213 AudioProcessConfig processConfig = GetInnerCapConfig();
1214 std::weak_ptr<IStreamListener> streamListener;
1215 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
1216 ASSERT_TRUE(capturerInServer_ != nullptr);
1217
1218 CapturerState capturerState = CAPTURER_NEW;
1219 auto ret = capturerInServer_->TurnOffMicIndicator(capturerState);
1220 EXPECT_EQ(ret, true);
1221
1222 capturerInServer_->isMicIndicatorOn_ = true;
1223 ret = capturerInServer_->TurnOffMicIndicator(capturerState);
1224 EXPECT_EQ(true, ret);
1225 }
1226
1227 /**
1228 * @tc.name : Test CapturerInServer.
1229 * @tc.type : FUNC
1230 * @tc.number: CapturerInServerUnitTest_039.
1231 * @tc.desc : Test OnReadData interface.
1232 */
1233 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_039, TestSize.Level1)
1234 {
1235 PaAdapterManager *adapterManager = new PaAdapterManager(DUP_PLAYBACK);
1236 adapterManager->InitPaContext();
1237 pa_threaded_mainloop *mainloop = pa_threaded_mainloop_new();
1238 AudioProcessConfig processConfig = GetInnerCapConfig();
1239 uint32_t sessionId = 123456;
1240 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
1241 auto streamListener = std::make_shared<ConcreteIStreamListener>();
1242 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
1243 capturerInServer_->stream_ = std::make_shared<PaCapturerStreamImpl>(stream, processConfig, mainloop);
1244 ASSERT_NE(nullptr, capturerInServer_);
1245
1246 uint32_t totalSizeInFrame = 10;
1247 uint32_t spanSizeInFrame = 10;
1248 uint32_t byteSizePerFrame = 10;
1249 size_t cacheSize = 1024;
1250 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(AudioBufferHolder::AUDIO_CLIENT,
1251 totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
1252 auto bufferInfo = std::make_shared<BasicBufferInfo>();
1253 capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_ = bufferInfo.get();
1254 capturerInServer_->status_.store(I_STATUS_STARTED);
1255 capturerInServer_->ringCache_ = std::make_unique<AudioRingCache>(cacheSize);
1256 int8_t outputData[10] = {1, 2, 3, 4};
1257 auto ret = capturerInServer_->OnReadData(outputData, 10);
1258 EXPECT_EQ(SUCCESS, ret);
1259
1260 capturerInServer_->spanSizeInBytes_ = 10;
1261 ret = capturerInServer_->OnReadData(outputData, 10);
1262 EXPECT_EQ(SUCCESS, ret);
1263 }
1264
1265 /**
1266 * @tc.name : Test CapturerInServer.
1267 * @tc.type : FUNC
1268 * @tc.number: CapturerInServerUnitTest_040.
1269 * @tc.desc : Test Release interface.
1270 */
1271 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_040, TestSize.Level1)
1272 {
1273 AudioProcessConfig processConfig;
1274 std::weak_ptr<IStreamListener> streamListener;
1275 processConfig.capturerInfo.sourceType = SOURCE_TYPE_PLAYBACK_CAPTURE;
1276 processConfig.innerCapMode = INVALID_CAP_MODE;
1277 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
1278 capturerInServer_->status_ = I_STATUS_RELEASING;
1279 capturerInServer_->needCheckBackground_ = true;
1280 auto result = capturerInServer_->Release();
1281 EXPECT_EQ(result, SUCCESS);
1282 }
1283
1284 /**
1285 * @tc.name : Test CapturerInServer.
1286 * @tc.type : FUNC
1287 * @tc.number: CapturerInServerUnitTest_041.
1288 * @tc.desc : Test InitCacheBuffer interface.
1289 */
1290 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_041, TestSize.Level1)
1291 {
1292 size_t targetSize = 17 * 1024 * 1024;
1293 size_t cacheSize = 960;
1294 AudioProcessConfig processConfig;
1295 std::weak_ptr<IStreamListener> streamListener;
1296 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
1297 capturerInServer_->ringCache_ = std::make_unique<AudioRingCache>(cacheSize);
1298 capturerInServer_->spanSizeInBytes_ = 1;
1299 int32_t result = capturerInServer_->InitCacheBuffer(targetSize);
1300 EXPECT_EQ(ERR_OPERATION_FAILED, result);
1301 }
1302
1303 /**
1304 * @tc.name : Test CapturerInServer.
1305 * @tc.type : FUNC
1306 * @tc.number: CapturerInServerUnitTest_042.
1307 * @tc.desc : Test GetAudioTime interface.
1308 */
1309 HWTEST_F(CapturerInServerUnitTest, CapturerInServerUnitTest_042, TestSize.Level1)
1310 {
1311 uint32_t totalSizeInFrame = 10;
1312 uint32_t spanSizeInFrame = 10;
1313 uint32_t byteSizePerFrame = 10;
1314 AudioProcessConfig processConfig;
1315 std::weak_ptr<IStreamListener> streamListener;
1316 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
1317 ASSERT_TRUE(capturerInServer_ != nullptr);
1318
1319 RestoreInfo restoreInfo;
1320 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(AudioBufferHolder::AUDIO_CLIENT,
1321 totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
1322 auto bufferInfo = std::make_shared<BasicBufferInfo>();
1323 capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_ = bufferInfo.get();
1324 capturerInServer_->audioServerBuffer_->ohAudioBufferBase_.basicBufferInfo_->restoreStatus.store(NEED_RESTORE);
1325 auto ret = capturerInServer_->RestoreSession(restoreInfo);
1326 EXPECT_EQ(NEED_RESTORE, ret);
1327 }
1328
1329 /**
1330 * @tc.name : Test ConfigServerBuffer.
1331 * @tc.type : FUNC
1332 * @tc.number: ConfigServerBuffer_001.
1333 * @tc.desc : Test ConfigServerBuffer interface.
1334 */
1335 HWTEST_F(CapturerInServerUnitTest, ConfigServerBuffer_001, TestSize.Level1)
1336 {
1337 AudioProcessConfig processConfig;
1338 std::weak_ptr<IStreamListener> streamListener;
1339 uint32_t totalSizeInFrame = 10;
1340 uint32_t spanSizeInFrame = 10;
1341 uint32_t byteSizePerFrame = 10;
1342 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
1343 ASSERT_TRUE(capturerInServer_ != nullptr);
1344 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(AudioBufferHolder::AUDIO_CLIENT,
1345 totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
1346
1347 int32_t result = capturerInServer_->ConfigServerBuffer();
1348 EXPECT_EQ(result, SUCCESS);
1349 }
1350
1351 /**
1352 * @tc.name : Test OnStatusUpdate.
1353 * @tc.type : FUNC
1354 * @tc.number: OnStatusUpdate_001.
1355 * @tc.desc : Test OnStatusUpdate interface.
1356 */
1357 HWTEST_F(CapturerInServerUnitTest, OnStatusUpdate_001, TestSize.Level1)
1358 {
1359 AudioProcessConfig processConfig;
1360 std::weak_ptr<IStreamListener> streamListener;
1361 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
1362 capturerInServer_->status_ = I_STATUS_RELEASED;
1363
1364 capturerInServer_->OnStatusUpdate(OPERATION_STARTED);
1365
1366 EXPECT_EQ(capturerInServer_->status_, I_STATUS_RELEASED);
1367 }
1368
1369 /**
1370 * @tc.name : Test OnStatusUpdate.
1371 * @tc.type : FUNC
1372 * @tc.number: OnStatusUpdate_002
1373 * @tc.desc : Test OnStatusUpdate interface.
1374 */
1375 HWTEST_F(CapturerInServerUnitTest, OnStatusUpdate_002, TestSize.Level1)
1376 {
1377 AudioProcessConfig processConfig;
1378 std::weak_ptr<IStreamListener> streamListener;
1379 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
1380 capturerInServer_->status_ = I_STATUS_STARTED;
1381
1382 capturerInServer_->OnStatusUpdate(static_cast<IOperation>(999));
1383
1384 EXPECT_NE(capturerInServer_->status_, I_STATUS_INVALID);
1385 }
1386
1387 /**
1388 * @tc.name : Test OnStatusUpdate.
1389 * @tc.type : FUNC
1390 * @tc.number: StopSession_001
1391 * @tc.desc : Test StopSession interface.
1392 */
1393 HWTEST_F(CapturerInServerUnitTest, StopSession_001, TestSize.Level3)
1394 {
1395 AudioProcessConfig processConfig;
1396 std::weak_ptr<IStreamListener> streamListener;
1397 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
1398 uint32_t totalSizeInFrame = 10;
1399 uint32_t spanSizeInFrame = 10;
1400 uint32_t byteSizePerFrame = 10;
1401
1402 capturerInServer_->audioServerBuffer_ = std::make_shared<OHAudioBuffer>(AudioBufferHolder::AUDIO_CLIENT,
1403 totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
1404 auto result = capturerInServer_->StopSession();
1405
1406 EXPECT_EQ(result, SUCCESS);
1407 }
1408
1409 /**
1410 * @tc.name : Test OnStatusUpdate.
1411 * @tc.type : FUNC
1412 * @tc.number: ResolveBufferBaseAndGetServerSpanSize_001
1413 * @tc.desc : Test ResolveBufferBaseAndGetServerSpanSize interface.
1414 */
1415 HWTEST_F(CapturerInServerUnitTest, ResolveBufferBaseAndGetServerSpanSize_001, TestSize.Level3)
1416 {
1417 AudioProcessConfig processConfig;
1418 std::weak_ptr<IStreamListener> streamListener;
1419 auto capturerInServer_ = std::make_shared<CapturerInServer>(processConfig, streamListener);
1420 std::shared_ptr<OHAudioBufferBase> buffer;
1421 uint32_t spanSizeInFrame = 1;
1422 uint64_t engineTotalSizeInFrame = 1;
1423
1424 auto result = capturerInServer_->ResolveBufferBaseAndGetServerSpanSize(
1425 buffer, spanSizeInFrame, engineTotalSizeInFrame);
1426
1427 EXPECT_EQ(result, ERR_NOT_SUPPORTED);
1428 }
1429 } // namespace AudioStandard
1430 } // namespace OHOS
1431