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 "media_errors.h"
17 #include "stream_unittest.h"
18
19 namespace OHOS {
20 namespace Media {
21 using namespace std;
22 using namespace testing;
23 using namespace testing::ext;
24 static const int32_t DEFAULT_NUM = 10;
25 static const int32_t MSERR_INVALID = -1;
26
SetUpTestCase(void)27 void SoundPoolStreamUnitTest::SetUpTestCase(void)
28 {
29 }
30
TearDownTestCase(void)31 void SoundPoolStreamUnitTest::TearDownTestCase(void)
32 {
33 }
34
SetUp(void)35 void SoundPoolStreamUnitTest::SetUp(void)
36 {
37 Format trackFormat;
38 int32_t soundID = 1;
39 int32_t streamID = DEFAULT_NUM;
40 std::shared_ptr<ThreadPool> streamStopThreadPool;
41 stream_ = std::make_shared<Stream>(trackFormat, soundID, streamID, streamStopThreadPool);
42 }
43
TearDown(void)44 void SoundPoolStreamUnitTest::TearDown(void)
45 {
46 stream_ = nullptr;
47 }
48
49 // @tc.name Test GetGlobalId API
50 // @tc.number StreamGetGlobalIdUnittest_001
51 // @tc.desc Test return ERROE_GLOBAL_ID
52 HWTEST_F(SoundPoolStreamUnitTest, StreamGetGlobalIdUnittest_001, TestSize.Level0)
53 {
54 ASSERT_NE(stream_, nullptr);
55 int32_t soundID = DEFAULT_NUM;
56 int32_t ret = stream_->GetGlobalId(soundID);
57 EXPECT_EQ(ret, MSERR_INVALID);
58 }
59
60 // @tc.name Test IsAudioRendererCanMix API
61 // @tc.number StreamIsAudioRendererCanMixUnittest_001
62 // @tc.desc Test return true
63 // Test return false
64 HWTEST_F(SoundPoolStreamUnitTest, StreamIsAudioRendererCanMixUnittest_001, TestSize.Level0)
65 {
66 ASSERT_NE(stream_, nullptr);
67 AudioStandard::AudioRendererInfo audioRendererInfo;
68 audioRendererInfo.contentType = AudioStandard::ContentType::CONTENT_TYPE_PROMPT;
69 bool ret = false;
70 ret = stream_->IsAudioRendererCanMix(audioRendererInfo);
71 EXPECT_EQ(ret, true);
72 audioRendererInfo.streamUsage = AudioStandard::StreamUsage::STREAM_USAGE_SYSTEM;
73 ret = stream_->IsAudioRendererCanMix(audioRendererInfo);
74 EXPECT_EQ(ret, false);
75 }
76
77 // @tc.name Test OnInterrupt API
78 // @tc.number StreamOnInterruptUnittest_001
79 // @tc.desc Test all
80 HWTEST_F(SoundPoolStreamUnitTest, StreamOnInterruptUnittest_001, TestSize.Level0)
81 {
82 ASSERT_NE(stream_, nullptr);
83 AudioStandard::InterruptEvent interruptEvent;
84 interruptEvent.hintType = AudioStandard::InterruptHint::INTERRUPT_HINT_PAUSE;
85 stream_->OnInterrupt(interruptEvent);
86 EXPECT_EQ(stream_->startStopFlag_.load(), true);
87 }
88
89 // @tc.name Test CheckAndAlignRendererRate API
90 // @tc.number StreamCheckAndAlignRendererRateUnittest_001
91 // @tc.desc Test default
92 HWTEST_F(SoundPoolStreamUnitTest, StreamCheckAndAlignRendererRateUnittest_001, TestSize.Level0)
93 {
94 ASSERT_NE(stream_, nullptr);
95 int32_t rate = DEFAULT_NUM;
96 AudioStandard::AudioRendererRate ret = stream_->CheckAndAlignRendererRate(rate);
97 EXPECT_EQ(ret, AudioStandard::AudioRendererRate::RENDER_RATE_NORMAL);
98 }
99
100 // @tc.name Test CreateAudioRenderer API
101 // @tc.number StreamCreateAudioRendererUnittest_001
102 // @tc.desc Test playParams.cacheDir != ""
103 HWTEST_F(SoundPoolStreamUnitTest, StreamCreateAudioRendererUnittest_001, TestSize.Level0)
104 {
105 ASSERT_NE(stream_, nullptr);
106 AudioStandard::AudioRendererInfo audioRendererInfo;
107 PlayParams playParams;
108 playParams.cacheDir = "/data/test/cache/dir";
109 auto ret = stream_->CreateAudioRenderer(audioRendererInfo, playParams);
110 EXPECT_EQ(ret, nullptr);
111 }
112
113 // @tc.name Test DoPlay API
114 // @tc.number StreamDoPlayUnittest_001
115 // @tc.desc Test fullCacheData_ == nullptr
116 // Test callback_ != nullptr, streamCallback_ != nullptr
117 HWTEST_F(SoundPoolStreamUnitTest, StreamDoPlayUnittest_001, TestSize.Level0)
118 {
119 ASSERT_NE(stream_, nullptr);
120 auto audioRenderer = std::make_unique<MockAudioRender>();
121 EXPECT_CALL(*(audioRenderer), GetBufferSize(_)).WillRepeatedly(testing::Return(0));
122 EXPECT_CALL(*(audioRenderer), SetRenderMode(_)).WillRepeatedly(testing::Return(0));
123 EXPECT_CALL(*(audioRenderer), SetRenderRate(_)).WillRepeatedly(testing::Return(0));
124 EXPECT_CALL(*(audioRenderer), SetVolume(_)).WillRepeatedly(testing::Return(0));
125 EXPECT_CALL(*(audioRenderer), SetOffloadAllowed(_)).WillRepeatedly(testing::Return(0));
126 EXPECT_CALL(*(audioRenderer), SetRendererCallback(_)).WillRepeatedly(testing::Return(0));
127 EXPECT_CALL(*(audioRenderer), SetRendererWriteCallback(_)).WillRepeatedly(testing::Return(0));
128 EXPECT_CALL(*(audioRenderer), SetRendererFirstFrameWritingCallback(_)).WillRepeatedly(testing::Return(0));
129 EXPECT_CALL(*(audioRenderer), SetParallelPlayFlag(_)).WillRepeatedly(testing::Return(0));
130 stream_->audioRenderer_ = std::move(audioRenderer);
131 auto callback = std::make_shared<MockISoundPoolCallback>();
132 EXPECT_CALL(*callback, OnError(_)).WillRepeatedly(testing::Return());
133 stream_->callback_ = callback;
134 auto streamCallback = std::make_shared<MockISoundPoolCallback>();
135 EXPECT_CALL(*streamCallback, OnError(_)).WillRepeatedly(testing::Return());
136 stream_->streamCallback_ = streamCallback;
137 auto ret = stream_->DoPlay();
138 stream_->audioRenderer_ = nullptr;
139 EXPECT_EQ(ret, MSERR_INVALID_VAL);
140 }
141
142 // @tc.name Test DoPlay API
143 // @tc.number StreamDoPlayUnittest_002
144 // @tc.desc Test audioRenderer_->Start() == false
145 // Test callback_ != nullptr, streamCallback_ != nullptr
146 HWTEST_F(SoundPoolStreamUnitTest, StreamDoPlayUnittest_002, TestSize.Level0)
147 {
148 ASSERT_NE(stream_, nullptr);
149 auto audioRenderer = std::make_unique<MockAudioRender>();
150 EXPECT_CALL(*(audioRenderer), GetBufferSize(_)).WillRepeatedly(testing::Return(0));
151 EXPECT_CALL(*(audioRenderer), SetRenderMode(_)).WillRepeatedly(testing::Return(0));
152 EXPECT_CALL(*(audioRenderer), SetRenderRate(_)).WillRepeatedly(testing::Return(0));
153 EXPECT_CALL(*(audioRenderer), SetVolume(_)).WillRepeatedly(testing::Return(0));
154 EXPECT_CALL(*(audioRenderer), SetOffloadAllowed(_)).WillRepeatedly(testing::Return(0));
155 EXPECT_CALL(*(audioRenderer), SetRendererCallback(_)).WillRepeatedly(testing::Return(0));
156 EXPECT_CALL(*(audioRenderer), SetRendererWriteCallback(_)).WillRepeatedly(testing::Return(0));
157 EXPECT_CALL(*(audioRenderer), SetRendererFirstFrameWritingCallback(_)).WillRepeatedly(testing::Return(0));
158 EXPECT_CALL(*(audioRenderer), SetParallelPlayFlag(_)).WillRepeatedly(testing::Return(0));
159 stream_->audioRenderer_ = std::move(audioRenderer);
160 auto callback = std::make_shared<MockISoundPoolCallback>();
161 EXPECT_CALL(*callback, OnError(_)).WillRepeatedly(testing::Return());
162 stream_->callback_ = callback;
163 auto streamCallback = std::make_shared<MockISoundPoolCallback>();
164 EXPECT_CALL(*streamCallback, OnError(_)).WillRepeatedly(testing::Return());
165 EXPECT_CALL(*streamCallback, OnPlayFinished(_)).WillRepeatedly(testing::Return());
166 stream_->streamCallback_ = streamCallback;
167 auto ret = stream_->DoPlay();
168 stream_->audioRenderer_ = nullptr;
169 EXPECT_EQ(ret, MSERR_INVALID_VAL);
170 }
171
172 // @tc.name Test Stop API
173 // @tc.number StreamStopUnittest_001
174 // @tc.desc Test (audioRenderer_->IsFastRenderer()) == true
175 HWTEST_F(SoundPoolStreamUnitTest, StreamStopUnittest_001, TestSize.Level0)
176 {
177 ASSERT_NE(stream_, nullptr);
178 stream_->isRunning_.store(true);
179 stream_->audioRenderer_ = std::make_unique<MockAudioRender>();
180 auto callBack = std::make_shared<MockISoundPoolCallback>();
181 EXPECT_CALL(*callBack, OnPlayFinished(_)).WillRepeatedly(testing::Return());
182 stream_->callback_ = callBack;
183 auto audioRenderer = std::make_unique<MockAudioRender>();
184 EXPECT_CALL(*audioRenderer, IsFastRenderer()).WillRepeatedly(testing::Return(true));
185 EXPECT_CALL(*audioRenderer, Pause(_)).WillRepeatedly(testing::Return(false));
186 EXPECT_CALL(*audioRenderer, Flush()).WillRepeatedly(testing::Return(false));
187 stream_->audioRenderer_ = std::move(audioRenderer);
188 auto ret = stream_->Stop();
189 EXPECT_EQ(ret, MSERR_OK);
190 }
191
192 // @tc.name Test AddStopTask API
193 // @tc.number StreamAddStopTaskUnittest_001
194 // @tc.desc Test streamStopThreadPool_ = nullptr
195 HWTEST_F(SoundPoolStreamUnitTest, StreamAddStopTaskUnittest_001, TestSize.Level0)
196 {
197 ASSERT_NE(stream_, nullptr);
198 stream_->streamCallback_ = nullptr;
199 auto audioRenderer = std::make_unique<MockAudioRender>();
200 EXPECT_CALL(*audioRenderer, IsFastRenderer()).WillRepeatedly(testing::Return(true));
201 stream_->audioRenderer_ = std::move(audioRenderer);
202 stream_->AddStopTask();
203 EXPECT_EQ(stream_->startStopFlag_.load(), true);
204 }
205
206 // @tc.name Test DealPlayParamsBeforePlay API
207 // @tc.number StreamDealPlayParamsBeforePlayUnittest_001
208 HWTEST_F(SoundPoolStreamUnitTest, StreamDealPlayParamsBeforePlayUnittest_001, TestSize.Level2)
209 {
210 ASSERT_NE(stream_, nullptr);
211 auto audioRenderer = std::make_unique<MockAudioRender>();
212 EXPECT_CALL(*(audioRenderer), SetRenderRate(_)).Times(1).WillRepeatedly(testing::Return(0));
213 EXPECT_CALL(*(audioRenderer), SetVolume(_)).Times(1).WillRepeatedly(testing::Return(0));
214 EXPECT_CALL(*(audioRenderer), SetOffloadAllowed(_)).Times(1).WillRepeatedly(testing::Return(0));
215 EXPECT_CALL(*(audioRenderer), SetParallelPlayFlag(_)).Times(1).WillRepeatedly(testing::Return(0));
216 EXPECT_CALL(*(audioRenderer), SetAudioHapticsSyncId(_)).Times(1).WillRepeatedly(testing::Return());
217 stream_->audioRenderer_ = std::move(audioRenderer);
218 int32_t audioHapticsSyncId = 1;
219 struct PlayParams playParameters;
220 playParameters.loop = -1;
221 playParameters.rate = 0;
222 playParameters.leftVolume = 0.5;
223 playParameters.rightVolume = 0.3;
224 playParameters.priority = 1;
225 playParameters.parallelPlayFlag = true;
226 playParameters.audioHapticsSyncId = audioHapticsSyncId;
227 stream_->DealPlayParamsBeforePlay(playParameters);
228 ASSERT_EQ(stream_->loop_, playParameters.loop);
229 ASSERT_EQ(stream_->priority_, playParameters.priority);
230 }
231
232 // @tc.name Test DoPlay API
233 // @tc.number StreamDoPlayUnittest_003
234 // @tc.desc Test audioRenderer_->Start() == false
235 // Test callback_ != nullptr, streamCallback_ != nullptr
236 HWTEST_F(SoundPoolStreamUnitTest, StreamDoPlayUnittest_003, TestSize.Level0)
237 {
238 ASSERT_NE(stream_, nullptr);
239 ASSERT_EQ(true, stream_->manager_.expired());
240 stream_->fullCacheData_ = std::make_shared<AudioBufferEntry>(nullptr, 0);
241 ASSERT_NE(nullptr, stream_->fullCacheData_);
242 auto audioRenderer = std::make_unique<MockAudioRender>();
243 EXPECT_CALL(*(audioRenderer), GetBufferSize(_)).Times(2).WillRepeatedly(testing::Return(0));
244 EXPECT_CALL(*(audioRenderer), SetRenderMode(_)).WillOnce(testing::Return(0));
245 EXPECT_CALL(*(audioRenderer), SetRenderRate(_)).WillOnce(testing::Return(0));
246 EXPECT_CALL(*(audioRenderer), SetVolume(_)).WillOnce(testing::Return(0));
247 EXPECT_CALL(*(audioRenderer), SetOffloadAllowed(_)).WillOnce(testing::Return(0));
248 EXPECT_CALL(*(audioRenderer), SetRendererCallback(_)).WillOnce(testing::Return(0));
249 EXPECT_CALL(*(audioRenderer), SetRendererWriteCallback(_)).WillOnce(testing::Return(0));
250 EXPECT_CALL(*(audioRenderer), SetRendererFirstFrameWritingCallback(_)).WillOnce(testing::Return(0));
251 EXPECT_CALL(*(audioRenderer), SetAudioHapticsSyncId(_)).WillOnce(testing::Return());
252 EXPECT_CALL(*(audioRenderer), SetParallelPlayFlag(_)).WillOnce(testing::Return(0));
253 EXPECT_CALL(*(audioRenderer), Start(_)).WillOnce(testing::Return(false));
254 stream_->audioRenderer_ = std::move(audioRenderer);
255 auto callback = std::make_shared<MockISoundPoolCallback>();
256 EXPECT_CALL(*callback, OnError(_)).WillOnce(testing::Return());
257 stream_->callback_ = callback;
258 auto streamCallback = std::make_shared<MockISoundPoolCallback>();
259 EXPECT_CALL(*streamCallback, OnError(_)).WillOnce(testing::Return());
260 stream_->streamCallback_ = streamCallback;
261 auto ret = stream_->DoPlay();
262 stream_->audioRenderer_ = nullptr;
263 EXPECT_EQ(ret, MSERR_INVALID_VAL);
264 }
265
266 // @tc.name Test DoPlay API
267 // @tc.number StreamDoPlayUnittest_004
268 // @tc.desc Test audioRenderer_->Start() == false
269 // Test callback_ == nullptr, streamCallback_ == nullptr
270 HWTEST_F(SoundPoolStreamUnitTest, StreamDoPlayUnittest_004, TestSize.Level0)
271 {
272 ASSERT_NE(stream_, nullptr);
273 ASSERT_EQ(true, stream_->manager_.expired());
274 stream_->fullCacheData_ = std::make_shared<AudioBufferEntry>(nullptr, 0);
275 ASSERT_NE(nullptr, stream_->fullCacheData_);
276 auto audioRenderer = std::make_unique<MockAudioRender>();
277 EXPECT_CALL(*(audioRenderer), GetBufferSize(_)).Times(2).WillRepeatedly(testing::Return(0));
278 EXPECT_CALL(*(audioRenderer), SetRenderMode(_)).WillOnce(testing::Return(0));
279 EXPECT_CALL(*(audioRenderer), SetRenderRate(_)).WillOnce(testing::Return(0));
280 EXPECT_CALL(*(audioRenderer), SetVolume(_)).WillOnce(testing::Return(0));
281 EXPECT_CALL(*(audioRenderer), SetOffloadAllowed(_)).WillOnce(testing::Return(0));
282 EXPECT_CALL(*(audioRenderer), SetRendererCallback(_)).WillOnce(testing::Return(0));
283 EXPECT_CALL(*(audioRenderer), SetRendererWriteCallback(_)).WillOnce(testing::Return(0));
284 EXPECT_CALL(*(audioRenderer), SetRendererFirstFrameWritingCallback(_)).WillOnce(testing::Return(0));
285 EXPECT_CALL(*(audioRenderer), SetAudioHapticsSyncId(_)).WillOnce(testing::Return());
286 EXPECT_CALL(*(audioRenderer), SetParallelPlayFlag(_)).WillOnce(testing::Return(0));
287 EXPECT_CALL(*(audioRenderer), Start(_)).WillOnce(testing::Return(false));
288 stream_->audioRenderer_ = std::move(audioRenderer);
289 ASSERT_EQ(nullptr, stream_->callback_);
290 ASSERT_EQ(nullptr, stream_->streamCallback_);
291 auto ret = stream_->DoPlay();
292 stream_->audioRenderer_ = nullptr;
293 EXPECT_EQ(ret, MSERR_INVALID_VAL);
294 }
295
296 // @tc.name Test OnInterrupt API
297 // @tc.number StreamOnInterruptUnittest_002
298 // @tc.desc Test hintType == AudioStandard::InterruptHint::INTERRUPT_HINT_STOP
299 HWTEST_F(SoundPoolStreamUnitTest, StreamOnInterruptUnittest_002, TestSize.Level0)
300 {
301 ASSERT_NE(stream_, nullptr);
302 AudioStandard::InterruptEvent interruptEvent;
303 interruptEvent.hintType = AudioStandard::InterruptHint::INTERRUPT_HINT_STOP;
304 stream_->OnInterrupt(interruptEvent);
305 EXPECT_EQ(stream_->startStopFlag_.load(), true);
306 }
307
308 // @tc.name Test OnInterrupt API
309 // @tc.number StreamOnInterruptUnittest_003
310 // @tc.desc Test hintType is not acceptable
311 HWTEST_F(SoundPoolStreamUnitTest, StreamOnInterruptUnittest_003, TestSize.Level0)
312 {
313 ASSERT_NE(stream_, nullptr);
314 AudioStandard::InterruptEvent interruptEvent;
315 interruptEvent.hintType = AudioStandard::InterruptHint::INTERRUPT_HINT_RESUME;
316 stream_->OnInterrupt(interruptEvent);
317 EXPECT_EQ(stream_->startStopFlag_.load(), false);
318 }
319 } // namespace Media
320 } // namespace OHOS
321