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 #include <string>
16 #include <sys/stat.h>
17 #include <fcntl.h>
18 #include <cinttypes>
19 #include "gtest/gtest.h"
20 #include "data_stream_source_plugin_unit_test.h"
21
22 using namespace OHOS;
23 using namespace OHOS::Media;
24 using namespace std;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Media {
29 namespace Plugin {
30 namespace DataStreamSource {
31 constexpr size_t DEFAULT_PREDOWNLOAD_SIZE_BYTE = 10 * 1024 * 1024;
32
SetUpTestCase(void)33 void DataStreamSourceUnitTest::SetUpTestCase(void)
34 {
35 }
36
TearDownTestCase(void)37 void DataStreamSourceUnitTest::TearDownTestCase(void)
38 {
39 }
40
SetUp(void)41 void DataStreamSourceUnitTest::SetUp(void)
42 {
43 plugin_ = std::make_shared<DataStreamSourcePlugin>("testPlugin");
44 mockDataSrc_ = std::make_shared<MockMediaDataSource>();
45 plugin_->dataSrc_ = mockDataSrc_;
46 }
47
TearDown(void)48 void DataStreamSourceUnitTest::TearDown(void)
49 {
50 plugin_ = nullptr;
51 mockDataSrc_ = nullptr;
52 }
53
54
55 /**
56 * @tc.name : Read_001
57 * @tc.number: 1
58 * @tc.desc : test isInterrupted_ true
59 */
60 HWTEST_F(DataStreamSourceUnitTest, Read_001, TestSize.Level1)
61 {
62 plugin_->isInterrupted_ = true;
63 std::shared_ptr<Plugins::Buffer> buffer;
64 uint64_t offset = 0;
65 size_t expectedLen = 1024;
66
67 Status result = plugin_->Read(buffer, offset, expectedLen);
68
69 EXPECT_EQ(result, Status::OK);
70 }
71
72 /**
73 * @tc.name : Read_002
74 * @tc.number: 2
75 * @tc.desc : Test isInterrupted_ false isExitRead_ true
76 */
77 HWTEST_F(DataStreamSourceUnitTest, Read_002, TestSize.Level1)
78 {
79 plugin_->isInterrupted_ = false;
80 plugin_->isExitRead_ = true;
81 uint64_t offset = 0;
82 size_t expectedLen = 1024;
83 std::shared_ptr<Plugins::Buffer> buffer = Plugins::Buffer::CreateDefaultBuffer(expectedLen);
84 Status result = plugin_->Read(buffer, offset, expectedLen);
85
86 EXPECT_EQ(result, Status::OK);
87 }
88
89 /**
90 * @tc.name : Read_003
91 * @tc.number: 3
92 * @tc.desc : Test seekable is true
93 */
94 HWTEST_F(DataStreamSourceUnitTest, Read_003, TestSize.Level1)
95 {
96 plugin_->seekable_ = Plugins::Seekable::SEEKABLE;
97 plugin_->offset_ = 0;
98 plugin_->size_ = 2048;
99 uint64_t offset = 0;
100 size_t expectedLen = 1024;
101 std::shared_ptr<Plugins::Buffer> buffer = Plugins::Buffer::CreateDefaultBuffer(expectedLen);
102 EXPECT_CALL(*mockDataSrc_, ReadAt(0, 1024, testing::_))
103 .Times(1)
104 .WillOnce(testing::Return(1024));
105
106 Status result = plugin_->Read(buffer, offset, expectedLen);
107
108 EXPECT_EQ(result, Status::OK);
109 }
110
111 /**
112 * @tc.name : Read_004
113 * @tc.number: 4
114 * @tc.desc : Test seekable is false
115 */
116 HWTEST_F(DataStreamSourceUnitTest, Read_004, TestSize.Level1)
117 {
118 plugin_->seekable_ = Plugins::Seekable::UNSEEKABLE;
119 plugin_->offset_ = 0;
120 plugin_->size_ = 2048;
121 uint64_t offset = 0;
122 size_t expectedLen = 1024;
123 std::shared_ptr<Plugins::Buffer> buffer = Plugins::Buffer::CreateDefaultBuffer(expectedLen);
124 EXPECT_CALL(*mockDataSrc_, ReadAt(1024, testing::_))
125 .Times(1)
126 .WillOnce(testing::Return(1024));
127
128 Status result = plugin_->Read(buffer, offset, expectedLen);
129
130 EXPECT_EQ(result, Status::OK);
131 }
132
133 /**
134 * @tc.name : Read_005
135 * @tc.number: 5
136 * @tc.desc : Test realLen is zero
137 */
138 HWTEST_F(DataStreamSourceUnitTest, Read_005, TestSize.Level1)
139 {
140 plugin_->seekable_ = Plugins::Seekable::SEEKABLE;
141 plugin_->offset_ = 0;
142 plugin_->size_ = 2048;
143 uint64_t offset = 0;
144 size_t expectedLen = 1024;
145 std::shared_ptr<Plugins::Buffer> buffer = Plugins::Buffer::CreateDefaultBuffer(expectedLen);
146 EXPECT_CALL(*mockDataSrc_, ReadAt(0, 1024, testing::_))
147 .WillOnce(testing::Return(0))
148 .WillOnce(testing::Return(1024));
149
150 Status result = plugin_->Read(buffer, offset, expectedLen);
151
152 EXPECT_EQ(result, Status::OK);
153 }
154
155 /**
156 * @tc.name : Read_006
157 * @tc.number: 6
158 * @tc.desc : Test buffer is nullptr
159 */
160 HWTEST_F(DataStreamSourceUnitTest, Read_006, TestSize.Level1)
161 {
162 plugin_->seekable_ = Plugins::Seekable::UNSEEKABLE;
163 plugin_->offset_ = 0;
164 plugin_->size_ = 2048;
165 uint64_t offset = 0;
166 size_t expectedLen = 1024;
167 std::shared_ptr<Plugins::Buffer> buffer = nullptr;
168 EXPECT_CALL(*mockDataSrc_, ReadAt(1024, testing::_))
169 .Times(1)
170 .WillOnce(testing::Return(1024));
171
172 Status result = plugin_->Read(buffer, offset, expectedLen);
173
174 EXPECT_EQ(result, Status::OK);
175 }
176
177 /**
178 * @tc.name : HandleBufferingStart_001
179 * @tc.number: 1
180 * @tc.desc : isBufferingStart is false, callback_ is nullptr
181 */
182 HWTEST_F(DataStreamSourceUnitTest, HandleBufferingStart_001, TestSize.Level1)
183 {
184 plugin_->isBufferingStart = false;
185 plugin_->callback_ = nullptr;
186
187 plugin_->HandleBufferingStart();
188 EXPECT_TRUE(plugin_->isBufferingStart);
189 }
190
191 /**
192 * @tc.name : HandleBufferingStart_002
193 * @tc.number: 2
194 * @tc.desc : isBufferingStart is false, callback_ is not nullptr
195 */
196 HWTEST_F(DataStreamSourceUnitTest, HandleBufferingStart_002, TestSize.Level1)
197 {
198 plugin_->isBufferingStart = false;
199 plugin_->callback_ = new TestCallback();
200
201 plugin_->HandleBufferingStart();
202 EXPECT_TRUE(plugin_->isBufferingStart);
203 delete plugin_->callback_;
204 }
205
206 /**
207 * @tc.name : HandleBufferingStart_003
208 * @tc.number: 3
209 * @tc.desc : isBufferingStart is true
210 */
211 HWTEST_F(DataStreamSourceUnitTest, HandleBufferingStart_003, TestSize.Level1)
212 {
213 plugin_->isBufferingStart = true;
214 plugin_->HandleBufferingStart();
215 EXPECT_TRUE(plugin_->isBufferingStart);
216 }
217
218
219 /**
220 * @tc.name : HandleBufferingEnd_001
221 * @tc.number: 1
222 * @tc.desc : isBufferingStart is true, callback_ is nullptr
223 */
224 HWTEST_F(DataStreamSourceUnitTest, HandleBufferingEnd_001, TestSize.Level1)
225 {
226 plugin_->isBufferingStart = true;
227 plugin_->callback_ = nullptr;
228
229 plugin_->HandleBufferingEnd();
230 EXPECT_FALSE(plugin_->isBufferingStart);
231 }
232
233 /**
234 * @tc.name : HandleBufferingEnd_002
235 * @tc.number: 2
236 * @tc.desc : isBufferingStart is true, callback_ is not nullptr
237 */
238 HWTEST_F(DataStreamSourceUnitTest, HandleBufferingEnd_002, TestSize.Level1)
239 {
240 plugin_->isBufferingStart = true;
241 plugin_->callback_ = new TestCallback();
242
243 plugin_->HandleBufferingEnd();
244 EXPECT_FALSE(plugin_->isBufferingStart);
245 delete plugin_->callback_;
246 }
247
248 /**
249 * @tc.name : HandleBufferingEnd_003
250 * @tc.number: 3
251 * @tc.desc : isBufferingStart is false
252 */
253 HWTEST_F(DataStreamSourceUnitTest, HandleBufferingEnd_003, TestSize.Level1)
254 {
255 plugin_->isBufferingStart = false;
256 plugin_->HandleBufferingEnd();
257 EXPECT_FALSE(plugin_->isBufferingStart);
258 }
259
260 /**
261 * @tc.name : GetSize_001
262 * @tc.number: 1
263 * @tc.desc : Test GetSize function when seekable_ is SEEKABLE.
264 */
265 HWTEST_F(DataStreamSourceUnitTest, GetSize_001, TestSize.Level1)
266 {
267 plugin_->seekable_ = Plugins::Seekable::SEEKABLE;
268 plugin_->size_ = 100;
269 uint64_t size = 0;
270 EXPECT_EQ(plugin_->GetSize(size), Status::OK);
271 EXPECT_EQ(size, 100);
272 }
273
274 /**
275 * @tc.name : GetSize_002
276 * @tc.number: 2
277 * @tc.desc : Test GetSize function when seekable_ is not SEEKABLE.
278 */
279 HWTEST_F(DataStreamSourceUnitTest, GetSize_002, TestSize.Level1)
280 {
281 plugin_->seekable_ = Plugins::Seekable::UNSEEKABLE;
282 plugin_->offset_ = 50;
283 uint64_t size = 0;
284 EXPECT_EQ(plugin_->GetSize(size), Status::OK);
285 EXPECT_EQ(size, DEFAULT_PREDOWNLOAD_SIZE_BYTE);
286 }
287
288 /**
289 * @tc.name : SeekTo_001
290 * @tc.number: 1
291 * @tc.desc : Test SeekTo function when source is unseekable
292 */
293 HWTEST_F(DataStreamSourceUnitTest, SeekTo_001, TestSize.Level1)
294 {
295 plugin_->seekable_ = Plugins::Seekable::UNSEEKABLE;
296 EXPECT_EQ(plugin_->SeekTo(0), Status::ERROR_INVALID_OPERATION);
297 }
298
299 /**
300 * @tc.name : SeekTo_002
301 * @tc.number: 2
302 * @tc.desc : Test SeekTo function when offset is invalid
303 */
304 HWTEST_F(DataStreamSourceUnitTest, SeekTo_002, TestSize.Level1)
305 {
306 plugin_->seekable_ = Plugins::Seekable::SEEKABLE;
307 plugin_->size_ = 100;
308 EXPECT_EQ(plugin_->SeekTo(101), Status::ERROR_INVALID_PARAMETER);
309 }
310
311 /**
312 * @tc.name : SeekTo_003
313 * @tc.number: 3
314 * @tc.desc : Test SeekTo function when offset is valid
315 */
316 HWTEST_F(DataStreamSourceUnitTest, SeekTo_003, TestSize.Level1)
317 {
318 plugin_->seekable_ = Plugins::Seekable::SEEKABLE;
319 plugin_->size_ = 100;
320 EXPECT_EQ(plugin_->SeekTo(50), Status::OK);
321 EXPECT_EQ(plugin_->offset_, 50);
322 EXPECT_FALSE(plugin_->isExitRead_);
323 }
324 } // namespace DataStreamSource
325 } // namespace Plugins
326 } // namespace Media
327 } // namespace OHOS