1 /*
2 * Copyright (c) 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 "cache_buffer_unittest.h"
17 #include "media_errors.h"
18 #include "media_log.h"
19
20 using namespace OHOS;
21 using namespace OHOS::Media;
22 using namespace testing;
23 using namespace testing::ext;
24
25 const static int32_t DEFAULT_GLOBAL_ID = 1;
26 const static int32_t ERROR_GLOBAL_ID = -1;
27 const static int32_t TEST_SOUND_ID = 1;
28 const static int32_t TEST_STREAM_ID = 1;
29 const static int32_t TEST_FULL_CACHE_DATA = 1000;
30 const static size_t TEST_CURRENT_LENGTH = 10;
31 const static float TEST_LEFT_VOLUMN = 1.0f;
32 const static float TEST_RIGHT_VOLUMN = 1.0f;
33 const static int32_t TEST_LOOP = 1;
34 const static int32_t TEST_PRIORITY = 1;
35
36 const static int32_t TIMES_ONE = 1;
37 const static int32_t TIMES_THREE = 3;
38
39 namespace OHOS {
40 namespace Media {
41
SetUpTestCase(void)42 void CacheBufferUnitTest::SetUpTestCase(void) {}
43
TearDownTestCase(void)44 void CacheBufferUnitTest::TearDownTestCase(void) {}
45
SetUp(void)46 void CacheBufferUnitTest::SetUp(void)
47 {
48 cacheBuffer_ = std::make_shared<CacheBuffer>(trackFormat, soundID, streamID, cacheBufferStopThreadPool);
49 streamIDManager_ = std::make_shared<StreamIDManager>(TEST_FULL_CACHE_DATA, AudioStandard::AudioRendererInfo());
50 mockAudioRenderer_ = std::make_unique<MockAudioRenderer>();
51 }
52
TearDown(void)53 void CacheBufferUnitTest::TearDown(void)
54 {
55 cacheBuffer_ = nullptr;
56 streamIDManager_ = nullptr;
57 mockAudioRenderer_ = nullptr;
58 }
59
60 /**
61 * @tc.name : Test GetGlobalId
62 * @tc.number: GetGlobalId_001
63 * @tc.desc : Test GetGlobalId (auto sharedManager = manager_.lock()) == false
64 */
65 HWTEST_F(CacheBufferUnitTest, GetGlobalId_001, TestSize.Level1)
66 {
67 int32_t soundId = TEST_SOUND_ID;
68 int32_t ret = cacheBuffer_->GetGlobalId(soundId);
69 EXPECT_EQ(ret, ERROR_GLOBAL_ID);
70 }
71
72 /**
73 * @tc.name : Test DelGlobalId
74 * @tc.number: DelGlobalId_001
75 * @tc.desc : Test DelGlobalId (auto sharedManager = manager_.lock()) == true
76 * Test DelGlobalId (auto sharedManager = manager_.lock()) == false
77 */
78 HWTEST_F(CacheBufferUnitTest, DelGlobalId_001, TestSize.Level1)
79 {
80 // Test DelGlobalId (auto sharedManager = manager_.lock()) == false
81 int32_t soundId = TEST_SOUND_ID;
82 cacheBuffer_->DelGlobalId(soundId);
83 EXPECT_TRUE(!cacheBuffer_->manager_.lock());
84
85 // Test DelGlobalId (auto sharedManager = manager_.lock()) == true
86 cacheBuffer_->manager_ = streamIDManager_;
87 cacheBuffer_->DelGlobalId(soundId);
88 EXPECT_TRUE(cacheBuffer_->manager_.lock());
89 }
90
91 /**
92 * @tc.name : Test DealAudioRendererParams
93 * @tc.number: DealAudioRendererParams_001
94 * @tc.desc : Test DealAudioRendererParams IsAudioRendererCanMix(audioRendererInfo) == false
95 */
96 HWTEST_F(CacheBufferUnitTest, DealAudioRendererParams_001, TestSize.Level1)
97 {
98 AudioStandard::AudioRendererOptions rendererOptions;
99 rendererOptions.strategy.concurrencyMode = AudioStandard::AudioConcurrencyMode::DEFAULT;
100 AudioStandard::AudioRendererInfo audioRendererInfo;
101 audioRendererInfo.contentType = AudioStandard::ContentType::CONTENT_TYPE_UNKNOWN;
102 audioRendererInfo.streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_VOICE_RINGTONE;
103 cacheBuffer_->DealAudioRendererParams(rendererOptions, audioRendererInfo);
104 EXPECT_EQ(rendererOptions.strategy.concurrencyMode, AudioStandard::AudioConcurrencyMode::DEFAULT);
105 }
106
107 /**
108 * @tc.name : Test GetAvailableAudioRenderer
109 * @tc.number: GetAvailableAudioRenderer_001
110 * @tc.desc : Test GetAvailableAudioRenderer AudioRendererManager::GetInstance()
111 * .GetAudioRendererInstance(globalId) == nullptr
112 */
113 HWTEST_F(CacheBufferUnitTest, GetAvailableAudioRenderer_001, TestSize.Level1)
114 {
115 streamIDManager_->globalIdVector_.push_back(std::make_pair(TEST_SOUND_ID, DEFAULT_GLOBAL_ID));
116 cacheBuffer_->soundID_ = TEST_SOUND_ID;
117 cacheBuffer_->manager_ = streamIDManager_;
118 cacheBuffer_->audioRenderer_ = std::move(mockAudioRenderer_);
119 AudioStandard::AudioRendererInfo audioRendererInfo;
120 PlayParams playParams;
121 cacheBuffer_->GetAvailableAudioRenderer(audioRendererInfo, playParams);
122 EXPECT_EQ(cacheBuffer_->GetGlobalId(TEST_SOUND_ID), ERROR_GLOBAL_ID);
123 }
124
125 /**
126 * @tc.name : Test GetAvailableAudioRenderer
127 * @tc.number: GetAvailableAudioRenderer_002
128 * @tc.desc : Test GetAvailableAudioRenderer CreateAudioRenderer(audioRendererInfo, playParams) == nullptr
129 */
130 HWTEST_F(CacheBufferUnitTest, GetAvailableAudioRenderer_002, TestSize.Level1)
131 {
132 cacheBuffer_->manager_ = streamIDManager_;
133 AudioStandard::AudioRendererInfo audioRendererInfo;
134 audioRendererInfo.contentType = AudioStandard::ContentType::CONTENT_TYPE_ULTRASONIC;
135 audioRendererInfo.streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_SYSTEM;
136 PlayParams playParams;
137 cacheBuffer_->GetAvailableAudioRenderer(audioRendererInfo, playParams);
138 EXPECT_EQ(cacheBuffer_->audioRenderer_, nullptr);
139 }
140
141 /**
142 * @tc.name : Test HandleRendererNotStart
143 * @tc.number: HandleRendererNotStart_001
144 * @tc.desc : Test HandleRendererNotStart audioRenderer_->GetStatus() !=
145 * OHOS::AudioStandard::RendererState::RENDERER_RUNNING
146 * Test HandleRendererNotStart callback_ == nullptr
147 * Test HandleRendererNotStart cacheBufferCallback_ == nullptr
148 */
149 HWTEST_F(CacheBufferUnitTest, HandleRendererNotStart_001, TestSize.Level1)
150 {
151 EXPECT_CALL(*mockAudioRenderer_, GetStatus())
152 .WillOnce(Return(OHOS::AudioStandard::RendererState::RENDERER_INVALID));
153 EXPECT_CALL(*mockAudioRenderer_, Stop()).WillOnce(Return(true));
154 EXPECT_CALL(*mockAudioRenderer_, Release()).WillOnce(Return(true));
155 cacheBuffer_->audioRenderer_ = std::move(mockAudioRenderer_);
156 int32_t streamId = TEST_STREAM_ID;
157 int32_t ret = cacheBuffer_->HandleRendererNotStart(streamId);
158 EXPECT_EQ(ret, MSERR_INVALID_VAL);
159 }
160
161 /**
162 * @tc.name : Test HandleRendererNotStart
163 * @tc.number: HandleRendererNotStart_002
164 * @tc.desc : Test HandleRendererNotStart callback_ != nullptr
165 * Test HandleRendererNotStart cacheBufferCallback_ != nullptr
166 */
167 HWTEST_F(CacheBufferUnitTest, HandleRendererNotStart_002, TestSize.Level1)
168 {
169 EXPECT_CALL(*mockAudioRenderer_, GetStatus())
170 .WillOnce(Return(OHOS::AudioStandard::RendererState::RENDERER_INVALID));
171 EXPECT_CALL(*mockAudioRenderer_, Stop()).WillOnce(Return(true));
172 EXPECT_CALL(*mockAudioRenderer_, Release()).WillOnce(Return(true));
173 cacheBuffer_->audioRenderer_ = std::move(mockAudioRenderer_);
174
175 auto callback = std::make_shared<MockSoundPoolCallback>();
176 EXPECT_CALL(*callback, OnError(_)).Times(TIMES_ONE);
177 EXPECT_CALL(*callback, OnErrorOccurred(_)).Times(TIMES_ONE);
178 cacheBuffer_->callback_ = callback;
179
180 auto cacheBufferCallback = std::make_shared<MockSoundPoolCallback>();
181 EXPECT_CALL(*cacheBufferCallback, OnError(_)).Times(TIMES_ONE);
182 cacheBuffer_->cacheBufferCallback_ = cacheBufferCallback;
183
184 int32_t streamId = TEST_STREAM_ID;
185 cacheBuffer_->HandleRendererNotStart(streamId);
186 }
187
188 /**
189 * @tc.name : Test HandleRendererNotStart
190 * @tc.number: HandleRendererNotStart_003
191 * @tc.desc : Test HandleRendererNotStart callback_ == nullptr
192 */
193 HWTEST_F(CacheBufferUnitTest, HandleRendererNotStart_003, TestSize.Level1)
194 {
195 EXPECT_CALL(*mockAudioRenderer_, GetStatus())
196 .WillOnce(Return(OHOS::AudioStandard::RendererState::RENDERER_RUNNING));
197 EXPECT_CALL(*mockAudioRenderer_, Stop()).WillOnce(Return(true));
198 EXPECT_CALL(*mockAudioRenderer_, Release()).WillOnce(Return(true));
199 cacheBuffer_->audioRenderer_ = std::move(mockAudioRenderer_);
200 int32_t streamId = TEST_STREAM_ID;
201 int32_t ret = cacheBuffer_->HandleRendererNotStart(streamId);
202 EXPECT_EQ(ret, MSERR_OK);
203 }
204
205 /**
206 * @tc.name : Test OnWriteData
207 * @tc.number: OnWriteData_001
208 * @tc.desc : Test OnWriteData (auto ptr = cacheBufferStopThreadPool_.lock()) == nullptr
209 */
210 HWTEST_F(CacheBufferUnitTest, OnWriteData_001, TestSize.Level1)
211 {
212 EXPECT_CALL(*mockAudioRenderer_, Stop()).WillOnce(Return(true));
213 EXPECT_CALL(*mockAudioRenderer_, Release()).WillOnce(Return(true));
214 EXPECT_CALL(*mockAudioRenderer_, GetBufferDesc(_)).WillRepeatedly(Return(AudioStandard::SUCCESS));
215 cacheBuffer_->audioRenderer_ = std::move(mockAudioRenderer_);
216 cacheBuffer_->isRunning_.store(true);
217 cacheBuffer_->isReadyToStopAudioRenderer_.store(false);
218 uint8_t* data = new uint8_t[1024];
219 cacheBuffer_->fullCacheData_ = std::make_shared<AudioBufferEntry>(data, TEST_FULL_CACHE_DATA);
220 cacheBuffer_->cacheDataFrameIndex_ = TEST_FULL_CACHE_DATA;
221 size_t length = TEST_CURRENT_LENGTH;
222 cacheBuffer_->OnWriteData(length);
223 EXPECT_TRUE(!cacheBuffer_->cacheBufferStopThreadPool_.lock());
224 }
225
226 /**
227 * @tc.name : Test OnInterrupt
228 * @tc.number: OnInterrupt_001
229 * @tc.desc : Test OnInterrupt (auto ptr = cacheBufferStopThreadPool_.lock()) == nullptr
230 */
231 HWTEST_F(CacheBufferUnitTest, OnInterrupt_001, TestSize.Level1)
232 {
233 AudioStandard::InterruptEvent interruptEvent;
234 interruptEvent.hintType = AudioStandard::InterruptHint::INTERRUPT_HINT_PAUSE;
235 cacheBuffer_->OnInterrupt(interruptEvent);
236 EXPECT_EQ(cacheBuffer_->cacheBufferStopThreadPool_.lock(), nullptr);
237 }
238
239 /**
240 * @tc.name : Test Stop
241 * @tc.number: Stop_001
242 * @tc.desc : Test Stop audioRenderer_->IsFastRenderer() == true
243 * Test Stop callback_ == nullptr
244 * Test Stop cacheBufferCallback_ == nullptr
245 */
246 HWTEST_F(CacheBufferUnitTest, Stop_001, TestSize.Level1)
247 {
248 // Test Stop audioRenderer_->IsFastRenderer() == true
249 EXPECT_CALL(*mockAudioRenderer_, IsFastRenderer()).WillOnce(Return(true));
250 EXPECT_CALL(*mockAudioRenderer_, Pause(_)).Times(TIMES_ONE);
251 EXPECT_CALL(*mockAudioRenderer_, Flush()).Times(TIMES_ONE);
252 cacheBuffer_->audioRenderer_ = std::move(mockAudioRenderer_);
253 cacheBuffer_->isRunning_.store(true);
254
255 // Test Stop callback_ == nullptr
256 cacheBuffer_->callback_ = nullptr;
257
258 // Test Stop cacheBufferCallback_ == nullptr
259 cacheBuffer_->cacheBufferCallback_ = nullptr;
260
261 int32_t streamId = TEST_STREAM_ID;
262 cacheBuffer_->streamID_ = TEST_STREAM_ID;
263 cacheBuffer_->Stop(streamId);
264 }
265
266 /**
267 * @tc.name : Test SetVolume
268 * @tc.number: SetVolume_001
269 * @tc.desc : Test SetVolume streamID != streamID_
270 */
271 HWTEST_F(CacheBufferUnitTest, SetVolume_001, TestSize.Level1)
272 {
273 int32_t streamId = TEST_STREAM_ID;
274 float leftVolume = TEST_LEFT_VOLUMN;
275 float rightVolume = TEST_RIGHT_VOLUMN;
276 int32_t ret = cacheBuffer_->SetVolume(streamId, leftVolume, rightVolume);
277 EXPECT_EQ(ret, MSERR_OK);
278 }
279
280 /**
281 * @tc.name : Test SetVolume
282 * @tc.number: SetVolume_002
283 * @tc.desc : Test SetVolume audioRenderer_ == nullptr
284 */
285 HWTEST_F(CacheBufferUnitTest, SetVolume_002, TestSize.Level1)
286 {
287 int32_t streamId = TEST_STREAM_ID;
288 float leftVolume = TEST_LEFT_VOLUMN;
289 float rightVolume = TEST_RIGHT_VOLUMN;
290 cacheBuffer_->streamID_ = TEST_STREAM_ID;
291 cacheBuffer_->audioRenderer_ = nullptr;
292 int32_t ret = cacheBuffer_->SetVolume(streamId, leftVolume, rightVolume);
293 EXPECT_EQ(ret, MSERR_OK);
294 }
295
296 /**
297 * @tc.name : Test SetRate
298 * @tc.number: SetRate_001
299 * @tc.desc : Test SetRate streamID != streamID_
300 */
301 HWTEST_F(CacheBufferUnitTest, SetRate_001, TestSize.Level1)
302 {
303 int32_t streamId = TEST_STREAM_ID;
304 AudioStandard::AudioRendererRate renderRate = AudioStandard::AudioRendererRate::RENDER_RATE_NORMAL;
305 int32_t ret = cacheBuffer_->SetRate(streamId, renderRate);
306 EXPECT_EQ(ret, MSERR_OK);
307 }
308
309 /**
310 * @tc.name : Test SetRate
311 * @tc.number: SetRate_002
312 * @tc.desc : Test SetRate_002 audioRenderer_ == nullptr
313 */
314 HWTEST_F(CacheBufferUnitTest, SetRate_002, TestSize.Level1)
315 {
316 int32_t streamId = TEST_STREAM_ID;
317 cacheBuffer_->streamID_ = TEST_STREAM_ID;
318 AudioStandard::AudioRendererRate renderRate = AudioStandard::AudioRendererRate::RENDER_RATE_NORMAL;
319 cacheBuffer_->audioRenderer_ = nullptr;
320 int32_t ret = cacheBuffer_->SetRate(streamId, renderRate);
321 EXPECT_EQ(ret, MSERR_OK);
322 }
323
324 /**
325 * @tc.name : Test SetPriority
326 * @tc.number: SetPriority_001
327 * @tc.desc : Test SetPriority streamID != streamID_
328 */
329 HWTEST_F(CacheBufferUnitTest, SetPriority_001, TestSize.Level1)
330 {
331 int32_t streamId = TEST_STREAM_ID;
332 int32_t priority = TEST_PRIORITY;
333 cacheBuffer_->SetPriority(streamId, priority);
334 EXPECT_EQ(cacheBuffer_->priority_, 0);
335 }
336
337 /**
338 * @tc.name : Test SetLoop
339 * @tc.number: SetLoop_001
340 * @tc.desc : Test SetLoop streamID != streamID_
341 */
342 HWTEST_F(CacheBufferUnitTest, SetLoop_001, TestSize.Level1)
343 {
344 int32_t streamId = TEST_STREAM_ID;
345 int32_t loop = TEST_LOOP;
346 cacheBuffer_->SetLoop(streamId, loop);
347 EXPECT_EQ(cacheBuffer_->loop_, 0);
348 }
349
350 /**
351 * @tc.name : Test SetParallelPlayFlag
352 * @tc.number: SetParallelPlayFlag_001
353 * @tc.desc : Test SetParallelPlayFlag streamID != streamID_
354 */
355 HWTEST_F(CacheBufferUnitTest, SetParallelPlayFlag_001, TestSize.Level1)
356 {
357 int32_t streamId = TEST_STREAM_ID;
358 bool parallelPlayFlag = false;
359 int32_t ret = cacheBuffer_->SetParallelPlayFlag(streamId, parallelPlayFlag);
360 EXPECT_EQ(ret, MSERR_OK);
361 }
362
363 /**
364 * @tc.name : Test SetParallelPlayFlag
365 * @tc.number: SetParallelPlayFlag_002
366 * @tc.desc : Test SetParallelPlayFlag audioRenderer_ != nullptr
367 */
368 HWTEST_F(CacheBufferUnitTest, SetParallelPlayFlag_002, TestSize.Level1)
369 {
370 EXPECT_CALL(*mockAudioRenderer_, SetParallelPlayFlag(_))
371 .WillOnce(Return(MSERR_OK));
372 EXPECT_CALL(*mockAudioRenderer_, Stop()).WillOnce(Return(true));
373 EXPECT_CALL(*mockAudioRenderer_, Release()).WillOnce(Return(true));
374 cacheBuffer_->audioRenderer_ = std::move(mockAudioRenderer_);
375
376 int32_t streamId = TEST_STREAM_ID;
377 bool parallelPlayFlag = false;
378 cacheBuffer_->streamID_ = TEST_STREAM_ID;
379 cacheBuffer_->SetParallelPlayFlag(streamId, parallelPlayFlag);
380 }
381
382 /**
383 * @tc.name : Test Release
384 * @tc.number: Release_001
385 * @tc.desc : Test FadeInAudioBuffer ret != AudioStandard::SUCCESS
386 * Test Release cacheData_.empty() == true
387 * Test Release frameWriteCallback_ == nullptr
388 */
389 HWTEST_F(CacheBufferUnitTest, Release_001, TestSize.Level1)
390 {
391 // Test FadeInAudioBuffer ret != AudioStandard::SUCCESS
392 cacheBuffer_->isNeedFadeIn_ = true;
393 AudioStandard::BufferDesc bufDesc;
394 bufDesc.bufLength = 0;
395 cacheBuffer_->FadeInAudioBuffer(bufDesc);
396
397 // Test Release cacheData_.empty() == true
398 cacheBuffer_->cacheData_.clear();
399
400 // Test Release frameWriteCallback_ == nullptr
401 cacheBuffer_->frameWriteCallback_ == nullptr;
402
403 int32_t ret = cacheBuffer_->Release();
404 EXPECT_EQ(ret, MSERR_OK);
405 }
406 } // namespace Media
407 } // namespace OHOS