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