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 #include <string>
16 #include <sys/stat.h>
17 #include <fcntl.h>
18 #include <cinttypes>
19 #include "gtest/gtest.h"
20 #include "avcodec_errors.h"
21 #include "avcodec_info.h"
22 #include "media_description.h"
23 #include "file_fd_source_plugin_unit_test.h"
24
25 using namespace OHOS;
26 using namespace OHOS::Media;
27 using namespace std;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Media {
32 namespace Plugins {
33 namespace FileFdSource {
34 const std::string MEDIA_ROOT = "file:///data/test/media/";
35 const std::string VIDEO_FILE1 = MEDIA_ROOT + "camera_info_parser.mp4";
SetUpTestCase(void)36 void OHOS::Media::Plugins::FileFdSource::FileFdSourceUnitTest::SetUpTestCase(void)
37 {
38 }
39
TearDownTestCase(void)40 void FileFdSourceUnitTest::TearDownTestCase(void)
41 {
42 }
43
SetUp(void)44 void FileFdSourceUnitTest::SetUp(void)
45 {
46 fileFdSourcePlugin_ = std::make_shared<FileFdSourcePlugin>("testPlugin");
47 size_t bufferSize = 1024;
48 std::shared_ptr<RingBuffer> ringBuffer = std::make_shared<RingBuffer>(bufferSize);
49 fileFdSourcePlugin_->ringBuffer_ = ringBuffer;
50 }
51
TearDown(void)52 void FileFdSourceUnitTest::TearDown(void)
53 {
54 fileFdSourcePlugin_->ringBuffer_ = nullptr;
55 fileFdSourcePlugin_ = nullptr;
56 }
57
58 class RingBufferMock : public RingBuffer {
59 public:
RingBufferMock(size_t bufferSize)60 explicit RingBufferMock(size_t bufferSize) : RingBuffer(std::move(bufferSize)) {}
61
ReadBuffer(void * ptr,size_t readSize,int waitTimes=0)62 size_t ReadBuffer(void* ptr, size_t readSize, int waitTimes = 0)
63 {
64 return readBufferSize_;
65 }
66
Seek(uint64_t offset)67 bool Seek(uint64_t offset)
68 {
69 (void)offset;
70 return seekRet_;
71 }
72
SetActive(bool active,bool cleanData=true)73 void SetActive(bool active, bool cleanData = true)
74 {
75 (void)active;
76 (void)cleanData;
77 }
78
79 size_t readBufferSize_ = 0;
80 bool seekRet_ = false;
81 };
82
83 class CallbackMock : public Plugins::Callback {
84 public:
OnEvent(const PluginEvent & event)85 void OnEvent(const PluginEvent &event)
86 {
87 description_ = event.description;
88 }
89
90 std::string description_;
91 };
92
93 class SourceCallback : public Plugins::Callback {
94 public:
OnEvent(const Plugins::PluginEvent & event)95 void OnEvent(const Plugins::PluginEvent &event) override
96 {
97 (void)event;
98 }
99
SetSelectBitRateFlag(bool flag,uint32_t desBitRate)100 void SetSelectBitRateFlag(bool flag, uint32_t desBitRate) override
101 {
102 (void)flag;
103 (void)desBitRate;
104 }
105
CanAutoSelectBitRate()106 bool CanAutoSelectBitRate() override
107 {
108 return true;
109 }
110 };
111
112 /**
113 * @tc.name: FileFdSource_SetSource_0100
114 * @tc.desc: SetSource
115 * @tc.type: FUNC
116 */
117 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SetSource_0100, TestSize.Level1)
118 {
119 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
120 EXPECT_NE(Status::OK, fileFdSourcePlugin_->SetSource(mediaSource));
121 }
122
123 /**
124 * @tc.name: FileFdSource_SetSource_0200
125 * @tc.desc: SetSource
126 * @tc.type: FUNC
127 */
128 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SetSource_0200, TestSize.Level1)
129 {
130 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
131 fileFdSourcePlugin_->isCloudFile_ = true;
132 fileFdSourcePlugin_->isEnableFdCache_ = false;
133 EXPECT_NE(Status::OK, fileFdSourcePlugin_->SetSource(mediaSource));
134 }
135
136 /**
137 * @tc.name: FileFdSource_SetSource_0300
138 * @tc.desc: SetSource
139 * @tc.type: FUNC
140 */
141 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SetSource_0300, TestSize.Level1)
142 {
143 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
144 fileFdSourcePlugin_->isCloudFile_ = false;
145 fileFdSourcePlugin_->isEnableFdCache_ = true;
146 EXPECT_NE(Status::OK, fileFdSourcePlugin_->SetSource(mediaSource));
147 }
148
149 /**
150 * @tc.name: FileFdSource_SetSource_0400
151 * @tc.desc: SetSource
152 * @tc.type: FUNC
153 */
154 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SetSource_0400, TestSize.Level1)
155 {
156 std::shared_ptr<MediaSource> mediaSource = std::make_shared<MediaSource>(VIDEO_FILE1);
157 fileFdSourcePlugin_->isCloudFile_ = false;
158 fileFdSourcePlugin_->isEnableFdCache_ = false;
159 EXPECT_NE(Status::OK, fileFdSourcePlugin_->SetSource(mediaSource));
160 }
161
162 /**
163 * @tc.name: FileFdSource_NotifyBufferingStart_0100
164 * @tc.desc: FileFdSource_NotifyBufferingStart_0100
165 * @tc.type: FUNC
166 */
167 HWTEST_F(FileFdSourceUnitTest, FileFdSource_NotifyBufferingStart_0100, TestSize.Level1)
168 {
169 Plugins::Callback* sourceCallback = new SourceCallback();
170 fileFdSourcePlugin_->isInterrupted_ = false;
171 fileFdSourcePlugin_->NotifyBufferingStart();
172 EXPECT_EQ(Status::OK, fileFdSourcePlugin_->SetCallback(sourceCallback));
173 fileFdSourcePlugin_->isInterrupted_ = true;
174 fileFdSourcePlugin_->NotifyBufferingStart();
175
176 fileFdSourcePlugin_->SetBundleName("TestFileFdSource");
177 fileFdSourcePlugin_->NotifyBufferingStart();
178 EXPECT_EQ(Status::OK, fileFdSourcePlugin_->Stop());
179 delete sourceCallback;
180 sourceCallback = nullptr;
181 }
182 /**
183 * @tc.name: FileFdSource_NotifyBufferingPercent_0100
184 * @tc.desc: FileFdSource_NotifyBufferingPercent_0100
185 * @tc.type: FUNC
186 */
187 HWTEST_F(FileFdSourceUnitTest, FileFdSource_NotifyBufferingPercent_0100, TestSize.Level1)
188 {
189 Plugins::Callback* sourceCallback = new SourceCallback();
190 std::shared_ptr<RingBufferMock> buffer = std::make_shared<RingBufferMock>(0);
191 fileFdSourcePlugin_->ringBuffer_ = buffer;
192 fileFdSourcePlugin_->waterLineAbove_ = 1;
193 fileFdSourcePlugin_->NotifyBufferingPercent();
194 EXPECT_EQ(Status::OK, fileFdSourcePlugin_->SetCallback(sourceCallback));
195 fileFdSourcePlugin_->NotifyBufferingPercent();
196
197 fileFdSourcePlugin_->SetBundleName("TestFileFdSource");
198 fileFdSourcePlugin_->NotifyBufferingPercent();
199 fileFdSourcePlugin_->isBuffering_ = true;
200 fileFdSourcePlugin_->isInterrupted_ = false;
201 fileFdSourcePlugin_->NotifyBufferingPercent();
202 EXPECT_EQ(Status::OK, fileFdSourcePlugin_->Stop());
203 delete sourceCallback;
204 sourceCallback = nullptr;
205 }
206 /**
207 * @tc.name: FileFdSource_NotifyBufferingEnd_0100
208 * @tc.desc: FileFdSource_NotifyBufferingEnd_0100
209 * @tc.type: FUNC
210 */
211 HWTEST_F(FileFdSourceUnitTest, FileFdSource_NotifyBufferingEnd_0100, TestSize.Level1)
212 {
213 Plugins::Callback* sourceCallback = new SourceCallback();
214 std::shared_ptr<RingBufferMock> buffer = std::make_shared<RingBufferMock>(0);
215 fileFdSourcePlugin_->ringBuffer_ = buffer;
216 fileFdSourcePlugin_->NotifyBufferingEnd();
217 EXPECT_EQ(Status::OK, fileFdSourcePlugin_->SetCallback(sourceCallback));
218 fileFdSourcePlugin_->NotifyBufferingEnd();
219
220 fileFdSourcePlugin_->SetBundleName("TestFileFdSource");
221 fileFdSourcePlugin_->NotifyBufferingEnd();
222 EXPECT_EQ(Status::OK, fileFdSourcePlugin_->Stop());
223 delete sourceCallback;
224 sourceCallback = nullptr;
225 }
226 /**
227 * @tc.name: FileFdSource_NotifyReadFail_0100
228 * @tc.desc: FileFdSource_NotifyReadFail_0100
229 * @tc.type: FUNC
230 */
231 HWTEST_F(FileFdSourceUnitTest, FileFdSource_NotifyReadFail_0100, TestSize.Level1)
232 {
233 fileFdSourcePlugin_->NotifyReadFail();
234 Plugins::Callback* sourceCallback = new SourceCallback();
235 EXPECT_EQ(Status::OK, fileFdSourcePlugin_->SetCallback(sourceCallback));
236 fileFdSourcePlugin_->NotifyReadFail();
237 EXPECT_EQ(Status::OK, fileFdSourcePlugin_->Stop());
238 fileFdSourcePlugin_->NotifyReadFail();
239 delete sourceCallback;
240 sourceCallback = nullptr;
241 }
242 /**
243 * @tc.name: FileFdSource_read_0100
244 * @tc.desc: FileFdSource_read_0100
245 * @tc.type: FUNC
246 */
247 HWTEST_F(FileFdSourceUnitTest, FileFdSource_read_0100, TestSize.Level1)
248 {
249 fileFdSourcePlugin_->NotifyBufferingStart();
250 std::shared_ptr<Buffer> buffer = std::make_shared<Buffer>();
251 EXPECT_NE(Status::OK, fileFdSourcePlugin_->Read(buffer, 0, 1024));
252 }
253 /**
254 * @tc.name: FileFdSource_read_0200
255 * @tc.desc: FileFdSource_read_0200
256 * @tc.type: FUNC
257 */
258 HWTEST_F(FileFdSourceUnitTest, FileFdSource_read_0200, TestSize.Level1)
259 {
260 std::shared_ptr<Buffer> buffer = nullptr;
261 EXPECT_NE(Status::OK, fileFdSourcePlugin_->Read(buffer, 0, 1024));
262 }
263 /**
264 * @tc.name: FileFdSource_read_0300
265 * @tc.desc: FileFdSource_read_0300
266 * @tc.type: FUNC
267 */
268 HWTEST_F(FileFdSourceUnitTest, FileFdSource_read_0300, TestSize.Level1)
269 {
270 fileFdSourcePlugin_->NotifyBufferingStart();
271 std::shared_ptr<Buffer> buffer = std::make_shared<Buffer>();
272 fileFdSourcePlugin_->isCloudFile_ = true;
273 EXPECT_NE(Status::OK, fileFdSourcePlugin_->Read(buffer, 0, 1024));
274 }
275 /**
276 * @tc.name: FileFdSource_read_0400
277 * @tc.desc: FileFdSource_read_0400
278 * @tc.type: FUNC
279 */
280 HWTEST_F(FileFdSourceUnitTest, FileFdSource_read_0400, TestSize.Level1)
281 {
282 std::shared_ptr<Buffer> buffer = nullptr;
283 fileFdSourcePlugin_->isCloudFile_ = true;
284 EXPECT_NE(Status::OK, fileFdSourcePlugin_->Read(buffer, 0, 1024));
285 }
286 /**
287 * @tc.name: FileFdSource_ParseUriInfo_0100
288 * @tc.desc: FileFdSource_ParseUriInfo_0100
289 * @tc.type: FUNC
290 */
291 HWTEST_F(FileFdSourceUnitTest, FileFdSource_ParseUriInfo_0100, TestSize.Level1)
292 {
293 std::string uri = "";
294 std::shared_ptr<MediaSource> source = std::make_shared<MediaSource>(uri);
295 fileFdSourcePlugin_->SetSource(source);
296 EXPECT_EQ(Status::OK, fileFdSourcePlugin_->Reset());
297 }
298 /**
299 * @tc.name: FileFdSource_ParseUriInfo_0200
300 * @tc.desc: FileFdSource_ParseUriInfo_0200
301 * @tc.type: FUNC
302 */
303 HWTEST_F(FileFdSourceUnitTest, FileFdSource_ParseUriInfo_0200, TestSize.Level1)
304 {
305 std::string uri = "";
306 std::shared_ptr<MediaSource> source = std::make_shared<MediaSource>(uri);
307 fileFdSourcePlugin_->isCloudFile_ = true;
308 fileFdSourcePlugin_->SetSource(source);
309 EXPECT_EQ(Status::OK, fileFdSourcePlugin_->Reset());
310 }
311
312 /**
313 * @tc.name: FileFdSource_ParseUriInfo_0300
314 * @tc.desc: FileFdSource_ParseUriInfo_0300
315 * @tc.type: FUNC
316 */
317 HWTEST_F(FileFdSourceUnitTest, FileFdSource_ParseUriInfo_0300, TestSize.Level1)
318 {
319 std::string uri = "fd://123123?offset=92233720368547758077&size=125126";
320 EXPECT_NE(Status::OK, fileFdSourcePlugin_->ParseUriInfo(uri));
321 }
322
323 /**
324 * @tc.name: FileFdSource_ParseUriInfo_0400
325 * @tc.desc: FileFdSource_ParseUriInfo_0400
326 * @tc.type: FUNC
327 */
328 HWTEST_F(FileFdSourceUnitTest, FileFdSource_ParseUriInfo_0400, TestSize.Level1)
329 {
330 std::string uri = "fd://123123?offset=9223372036854775ac&size=125126";
331 EXPECT_NE(Status::OK, fileFdSourcePlugin_->ParseUriInfo(uri));
332 }
333
334 /**
335 * @tc.name: FileFdSource_Reset_0100
336 * @tc.desc: FileFdSource_Reset_0100
337 * @tc.type: FUNC
338 */
339 HWTEST_F(FileFdSourceUnitTest, FileFdSource_Reset_0100, TestSize.Level1)
340 {
341 EXPECT_EQ(Status::OK, fileFdSourcePlugin_->Reset());
342 }
343 /**
344 * @tc.name: FileFdSource_SetBundleName_0100
345 * @tc.desc: FileFdSource_SetBundleName_0100
346 * @tc.type: FUNC
347 */
348 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SetBundleName_0100, TestSize.Level1)
349 {
350 fileFdSourcePlugin_->Stop();
351 fileFdSourcePlugin_->SetBundleName("TestFileFdSource");
352 EXPECT_EQ(Status::OK, fileFdSourcePlugin_->Stop());
353 }
354 /**
355 * @tc.name: FileFdSource_getCacheTime_0100
356 * @tc.desc: FileFdSource_getCacheTime_0100
357 * @tc.type: FUNC
358 */
359 HWTEST_F(FileFdSourceUnitTest, FileFdSource_getCacheTime_0100, TestSize.Level1)
360 {
361 fileFdSourcePlugin_->GetCacheTime(0.0);
362 fileFdSourcePlugin_->GetCacheTime(0.2);
363 fileFdSourcePlugin_->GetCacheTime(0.5);
364 fileFdSourcePlugin_->GetCacheTime(1.0);
365 fileFdSourcePlugin_->GetCacheTime(2.0);
366 fileFdSourcePlugin_->HasCacheData(0, 0);
367 ASSERT_NE(fileFdSourcePlugin_->HasCacheData(0, 0), true);
368 }
369
370 /**
371 * @tc.name: FileFdSource_ReadOnlineFile_0100
372 * @tc.desc: FileFdSource_ReadOnlineFile_0100
373 * @tc.type: FUNC
374 */
375 HWTEST_F(FileFdSourceUnitTest, FileFdSource_ReadOnlineFile_0100, TestSize.Level1)
376 {
377 fileFdSourcePlugin_->GetCacheTime(0.0);
378 fileFdSourcePlugin_->isBuffering_ = true;
379 std::shared_ptr<Buffer> buffer;
380 EXPECT_EQ(Status::ERROR_AGAIN, fileFdSourcePlugin_->ReadOnlineFile(0, buffer, 0, 0));
381 }
382
383 /**
384 * @tc.name: FileFdSource_SeekToOnlineFile_0100
385 * @tc.desc: FileFdSource_SeekToOnlineFile_0100
386 * @tc.type: FUNC
387 */
388 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SeekToOnlineFile_0100, TestSize.Level1)
389 {
390 std::shared_ptr<RingBufferMock> buffer = std::make_shared<RingBufferMock>(0);
391 fileFdSourcePlugin_->ringBuffer_ = buffer;
392 buffer->seekRet_ = true;
393 int64_t offset = 0;
394 EXPECT_EQ(Status::ERROR_UNKNOWN, fileFdSourcePlugin_->SeekToOnlineFile(offset));
395 }
396
397 /**
398 * @tc.name: FileFdSource_SeekToOnlineFile_0200
399 * @tc.desc: FileFdSource_SeekToOnlineFile_0200
400 * @tc.type: FUNC
401 */
402 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SeekToOnlineFile_0200, TestSize.Level1)
403 {
404 std::shared_ptr<RingBufferMock> buffer = std::make_shared<RingBufferMock>(0);
405 fileFdSourcePlugin_->ringBuffer_ = buffer;
406 buffer->seekRet_ = false;
407 int64_t offset = 0;
408 std::shared_ptr<Task> task = std::make_shared<Task>("test");
409 fileFdSourcePlugin_->downloadTask_ = task;
410 EXPECT_EQ(Status::ERROR_UNKNOWN, fileFdSourcePlugin_->SeekToOnlineFile(offset));
411 sleep(1);
412 }
413
414 /**
415 * @tc.name: FileFdSource_SeekToOnlineFile_0300
416 * @tc.desc: FileFdSource_SeekToOnlineFile_0300
417 * @tc.type: FUNC
418 */
419 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SeekToOnlineFile_0300, TestSize.Level1)
420 {
421 std::shared_ptr<RingBufferMock> buffer = std::make_shared<RingBufferMock>(0);
422 fileFdSourcePlugin_->ringBuffer_ = buffer;
423 buffer->seekRet_ = false;
424 int64_t offset = 0;
425 EXPECT_EQ(Status::ERROR_UNKNOWN, fileFdSourcePlugin_->SeekToOnlineFile(offset));
426 sleep(1);
427 }
428
429 /**
430 * @tc.name: FileFdSource_CacheDataLoop_0100
431 * @tc.desc: FileFdSource_CacheDataLoop_0100
432 * @tc.type: FUNC
433 */
434 HWTEST_F(FileFdSourceUnitTest, FileFdSource_CacheDataLoop_0100, TestSize.Level1)
435 {
436 std::shared_ptr<Task> task = std::make_shared<Task>("test");
437 fileFdSourcePlugin_->downloadTask_ = task;
438 fileFdSourcePlugin_->PauseDownloadTask(true);
439 sleep(1);
440 fileFdSourcePlugin_->PauseDownloadTask(false);
441 sleep(1);
442 fileFdSourcePlugin_->isInterrupted_ = true;
443 fileFdSourcePlugin_->CacheDataLoop();
444
445 fileFdSourcePlugin_->isInterrupted_ = false;
446 fileFdSourcePlugin_->CacheDataLoop();
447
448 fileFdSourcePlugin_->size_ = 10;
449 std::shared_ptr<RingBufferMock> buffer = std::make_shared<RingBufferMock>(0);
450 fileFdSourcePlugin_->ringBuffer_ = buffer;
451 buffer->readBufferSize_ = true;
452 fileFdSourcePlugin_->isBuffering_ = true;
453 fileFdSourcePlugin_->waterLineAbove_ = 0;
454 fileFdSourcePlugin_->CacheDataLoop();
455 EXPECT_EQ(0, fileFdSourcePlugin_->ringBuffer_->GetSize());
456
457 buffer->readBufferSize_ = false;
458 fileFdSourcePlugin_->inSeek_ = false;
459 fileFdSourcePlugin_->isInterrupted_ = true;
460 fileFdSourcePlugin_->CacheDataLoop();
461
462 fileFdSourcePlugin_->inSeek_ = true;
463 fileFdSourcePlugin_->cachePosition_ = 1;
464 fileFdSourcePlugin_->CacheDataLoop();
465
466 fileFdSourcePlugin_->CacheDataLoop();
467 EXPECT_EQ(0, fileFdSourcePlugin_->ringBuffer_->GetSize());
468 }
469
470 /**
471 * @tc.name: FileFdSource_HandleBuffering_0100
472 * @tc.desc: FileFdSource_HandleBuffering_0100
473 * @tc.type: FUNC
474 */
475 HWTEST_F(FileFdSourceUnitTest, FileFdSource_HandleBuffering_0100, TestSize.Level1)
476 {
477 EXPECT_EQ(false, fileFdSourcePlugin_->HandleBuffering());
478 fileFdSourcePlugin_->isBuffering_ = true;
479 EXPECT_EQ(true, fileFdSourcePlugin_->HandleBuffering());
480 fileFdSourcePlugin_->isInterrupted_ = true;
481 EXPECT_EQ(true, fileFdSourcePlugin_->HandleBuffering());
482 fileFdSourcePlugin_->isInterrupted_ = false;
483 fileFdSourcePlugin_->isReadBlocking_ = true;
484 fileFdSourcePlugin_->isBuffering_ = false;
485 EXPECT_EQ(false, fileFdSourcePlugin_->HandleBuffering());
486 }
487
488 /**
489 * @tc.name: FileFdSource_NotifyBufferingPercent_0200
490 * @tc.desc: FileFdSource_NotifyBufferingPercent_0200
491 * @tc.type: FUNC
492 */
493 HWTEST_F(FileFdSourceUnitTest, FileFdSource_NotifyBufferingPercent_0200, TestSize.Level1)
494 {
495 std::shared_ptr<RingBufferMock> buffer = std::make_shared<RingBufferMock>(0);
496 fileFdSourcePlugin_->ringBuffer_ = buffer;
497 fileFdSourcePlugin_->NotifyBufferingPercent();
498 fileFdSourcePlugin_->waterLineAbove_ = 1;
499 fileFdSourcePlugin_->isBuffering_ = true;
500 CallbackMock* cb = new CallbackMock();
501 fileFdSourcePlugin_->callback_ = cb;
502 fileFdSourcePlugin_->NotifyBufferingStart();
503 EXPECT_EQ("start", cb->description_);
504 fileFdSourcePlugin_->isInterrupted_ = true;;
505 fileFdSourcePlugin_->NotifyBufferingPercent();
506
507 fileFdSourcePlugin_->callback_ = nullptr;
508 fileFdSourcePlugin_->NotifyBufferingPercent();
509
510 fileFdSourcePlugin_->isBuffering_ = false;
511 fileFdSourcePlugin_->NotifyBufferingPercent();
512
513 fileFdSourcePlugin_->callback_ = cb;
514 fileFdSourcePlugin_->waterLineAbove_ = 1;
515 fileFdSourcePlugin_->isBuffering_ = true;
516 fileFdSourcePlugin_->isInterrupted_ = false;
517 fileFdSourcePlugin_->NotifyBufferingPercent();
518
519 EXPECT_EQ("0", cb->description_);
520 delete cb;
521 cb = nullptr;
522 }
523
524 /**
525 * @tc.name: FileFdSource_NotifyBufferingEnd_0200
526 * @tc.desc: FileFdSource_NotifyBufferingEnd_0200
527 * @tc.type: FUNC
528 */
529 HWTEST_F(FileFdSourceUnitTest, FileFdSource_NotifyBufferingEnd_0200, TestSize.Level1)
530 {
531 std::shared_ptr<RingBufferMock> buffer = std::make_shared<RingBufferMock>(0);
532 fileFdSourcePlugin_->ringBuffer_ = buffer;
533 fileFdSourcePlugin_->isBuffering_ = true;
534 fileFdSourcePlugin_->NotifyBufferingEnd();
535 EXPECT_EQ(false, fileFdSourcePlugin_->isBuffering_);
536
537 fileFdSourcePlugin_->isBuffering_ = true;
538 CallbackMock* cb = new CallbackMock();
539 fileFdSourcePlugin_->NotifyBufferingStart();
540 fileFdSourcePlugin_->callback_ = cb;
541 fileFdSourcePlugin_->isInterrupted_ = true;
542 fileFdSourcePlugin_->NotifyBufferingEnd();
543 EXPECT_EQ(false, fileFdSourcePlugin_->isBuffering_);
544
545 fileFdSourcePlugin_->isInterrupted_ = false;
546 fileFdSourcePlugin_->NotifyBufferingEnd();
547 EXPECT_EQ("end", cb->description_);
548 delete cb;
549 cb = nullptr;
550 }
551
552 /**
553 * @tc.name: FileFdSource_SetReadBlockingFlag_0100
554 * @tc.desc: FileFdSource_SetReadBlockingFlag_0100
555 * @tc.type: FUNC
556 */
557 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SetReadBlockingFlag_0100, TestSize.Level1)
558 {
559 fileFdSourcePlugin_->ringBuffer_ = std::make_shared<RingBufferMock>(0);
560 fileFdSourcePlugin_->SetReadBlockingFlag(true);
561 EXPECT_EQ(true, fileFdSourcePlugin_->isReadBlocking_);
562 fileFdSourcePlugin_->SetReadBlockingFlag(false);
563 EXPECT_EQ(false, fileFdSourcePlugin_->isReadBlocking_);
564 }
565
566 /**
567 * @tc.name: FileFdSource_SetInterruptState_0100
568 * @tc.desc: FileFdSource_SetInterruptState_0100
569 * @tc.type: FUNC
570 */
571 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SetInterruptState_0100, TestSize.Level1)
572 {
573 fileFdSourcePlugin_->ringBuffer_ = std::make_shared<RingBufferMock>(0);
574 fileFdSourcePlugin_->SetInterruptState(true);
575 EXPECT_EQ(true, fileFdSourcePlugin_->isInterrupted_);
576 fileFdSourcePlugin_->SetInterruptState(false);
577 EXPECT_EQ(false, fileFdSourcePlugin_->isInterrupted_);
578 fileFdSourcePlugin_->isInterrupted_ = true;
579 fileFdSourcePlugin_->SetInterruptState(true);
580 EXPECT_EQ(true, fileFdSourcePlugin_->isInterrupted_);
581 fileFdSourcePlugin_->isCloudFile_ = true;
582 fileFdSourcePlugin_->SetInterruptState(true);
583 EXPECT_EQ(true, fileFdSourcePlugin_->isInterrupted_);
584 std::shared_ptr<Task> task = std::make_shared<Task>("test");
585 fileFdSourcePlugin_->downloadTask_ = task;
586 fileFdSourcePlugin_->SetInterruptState(true);
587 EXPECT_EQ(true, fileFdSourcePlugin_->isInterrupted_);
588 sleep(1);
589 }
590
591 /**
592 * @tc.name: FileFdSource_CheckFileType_0100
593 * @tc.desc: FileFdSource_CheckFileType_0100
594 * @tc.type: FUNC
595 */
596 HWTEST_F(FileFdSourceUnitTest, FileFdSource_CheckFileType_0100, TestSize.Level1)
597 {
598 fileFdSourcePlugin_->isEnableFdCache_ = false;
599 fileFdSourcePlugin_->CheckFileType();
600 EXPECT_EQ(false, fileFdSourcePlugin_->isCloudFile_);
601 }
602
603 /**
604 * @tc.name: FileFdSource_CheckFileType_0200
605 * @tc.desc: FileFdSource_CheckFileType_0200
606 * @tc.type: FUNC
607 */
608 HWTEST_F(FileFdSourceUnitTest, FileFdSource_CheckFileType_0200, TestSize.Level1)
609 {
610 fileFdSourcePlugin_->fd_ = -1;
611 fileFdSourcePlugin_->CheckFileType();
612 EXPECT_EQ(false, fileFdSourcePlugin_->isCloudFile_);
613 }
614
615 /**
616 * @tc.name: FileFdSource_GetBufferPtr_0100
617 * @tc.desc: FileFdSource_GetBufferPtr_0100
618 * @tc.type: FUNC
619 */
620 HWTEST_F(FileFdSourceUnitTest, FileFdSource_GetBufferPtr_0100, TestSize.Level1)
621 {
622 std::shared_ptr<Buffer> buffer = std::make_shared<Buffer>();
623 EXPECT_NE(nullptr, fileFdSourcePlugin_->GetBufferPtr(buffer, 10));
624 }
625
626 /**
627 * @tc.name: FileFdSource_GetCurrentSpeed_0100
628 * @tc.desc: FileFdSource_GetCurrentSpeed_0100
629 * @tc.type: FUNC
630 */
631 HWTEST_F(FileFdSourceUnitTest, FileFdSource_GetCurrentSpeed_0100, TestSize.Level1)
632 {
633 fileFdSourcePlugin_->GetCurrentSpeed(0);
634 fileFdSourcePlugin_->downloadSize_ = 10;
635 fileFdSourcePlugin_->GetCurrentSpeed(2 * 1000);
636 EXPECT_EQ(5, fileFdSourcePlugin_->avgDownloadSpeed_);
637 fileFdSourcePlugin_->lastCheckTime_ = 0;
638 fileFdSourcePlugin_->currentBitRate_ = 1;
639 fileFdSourcePlugin_->downloadSize_ = 2;
640 fileFdSourcePlugin_->GetCurrentSpeed(2 * 1000);
641 EXPECT_EQ(1, fileFdSourcePlugin_->avgDownloadSpeed_);
642 }
643
644 /**
645 * @tc.name: FileFdSource_GetCacheTime_0100
646 * @tc.desc: FileFdSource_GetCacheTime_0100
647 * @tc.type: FUNC
648 */
649 HWTEST_F(FileFdSourceUnitTest, FileFdSource_GetCacheTime_0100, TestSize.Level1)
650 {
651 EXPECT_EQ(5, fileFdSourcePlugin_->GetCacheTime(0.25));
652 EXPECT_EQ(5, fileFdSourcePlugin_->GetCacheTime(0.75));
653 EXPECT_TRUE((int)(fileFdSourcePlugin_->GetCacheTime(1) * 1000000) == (int)(0.3 * 1000000));
654 EXPECT_EQ((float)0.3, fileFdSourcePlugin_->GetCacheTime(-1));
655 EXPECT_EQ((float)0.3, fileFdSourcePlugin_->GetCacheTime(1));
656 }
657
658 /**
659 * @tc.name: FileFdSource_DeleteCacheBuffer_0100
660 * @tc.desc: FileFdSource_DeleteCacheBuffer_0100
661 * @tc.type: FUNC
662 */
663 HWTEST_F(FileFdSourceUnitTest, FileFdSource_DeleteCacheBuffer_0100, TestSize.Level1)
664 {
665 fileFdSourcePlugin_->DeleteCacheBuffer(nullptr, 0);
666 int32_t bufferSize = 4;
667 char* cacheBuffer = new char[bufferSize];
668
669 fileFdSourcePlugin_->DeleteCacheBuffer(cacheBuffer, 0);
670 EXPECT_NE(nullptr, cacheBuffer);
671 fileFdSourcePlugin_->DeleteCacheBuffer(cacheBuffer, 4);
672 EXPECT_NE(nullptr, cacheBuffer);
673 }
674
675 /**
676 * @tc.name: FileFdSource_CheckReadTime_0100
677 * @tc.desc: FileFdSource_CheckReadTime_0100
678 * @tc.type: FUNC
679 */
680 HWTEST_F(FileFdSourceUnitTest, FileFdSource_CheckReadTime_0100, TestSize.Level1)
681 {
682 fileFdSourcePlugin_->curReadTime_ = 10;
683 fileFdSourcePlugin_->CheckReadTime();
684 EXPECT_EQ(10, fileFdSourcePlugin_->lastReadTime_);
685
686 fileFdSourcePlugin_->lastReadTime_ = 1000;
687 fileFdSourcePlugin_->curReadTime_ = 2000;
688 fileFdSourcePlugin_->CheckReadTime();
689 EXPECT_EQ(1000, fileFdSourcePlugin_->lastReadTime_);
690
691 fileFdSourcePlugin_->curReadTime_ = 1020;
692 fileFdSourcePlugin_->CheckReadTime();
693 EXPECT_EQ(1000, fileFdSourcePlugin_->lastReadTime_);
694
695 fileFdSourcePlugin_->curReadTime_ = 1040;
696 fileFdSourcePlugin_->CheckReadTime();
697 EXPECT_EQ(0, fileFdSourcePlugin_->lastReadTime_);
698 }
699
700 /**
701 * @tc.name: FileFdSource_checkReadTime_0200
702 * @tc.desc: FileFdSource_checkReadTime_0200
703 * @tc.type: FUNC
704 */
705 HWTEST_F(FileFdSourceUnitTest, FileFdSource_checkReadTime_0200, TestSize.Level1)
706 {
707 fileFdSourcePlugin_->callback_ = nullptr;
708 int64_t curTime = 0;
709 int64_t lastTime = 0;
710 auto isValidTime = fileFdSourcePlugin_->IsValidTime(curTime, lastTime);
711 ASSERT_FALSE(isValidTime);
712 fileFdSourcePlugin_->CheckReadTime();
713 }
714 /**
715 * @tc.name: FileFdSource_PauseDownloadTask_0100
716 * @tc.desc: FileFdSource_PauseDownloadTask_0100
717 * @tc.type: FUNC
718 */
719 HWTEST_F(FileFdSourceUnitTest, FileFdSource_PauseDownloadTask_0100, TestSize.Level1)
720 {
721 fileFdSourcePlugin_->downloadTask_ = nullptr;
722 fileFdSourcePlugin_->PauseDownloadTask(true);
723 fileFdSourcePlugin_->downloadTask_ = std::shared_ptr<Task>();
724 fileFdSourcePlugin_->PauseDownloadTask(true);
725 fileFdSourcePlugin_->PauseDownloadTask(false);
726 ASSERT_TRUE(fileFdSourcePlugin_->downloadSize_ == 0);
727 }
728
729 /**
730 * @tc.name: FileFdSource_IsLocalFd_0100
731 * @tc.desc: FileFdSource_IsLocalFd_0100
732 * @tc.type: FUNC
733 */
734 HWTEST_F(FileFdSourceUnitTest, FileFdSource_IsLocalFd_0100, TestSize.Level1)
735 {
736 fileFdSourcePlugin_->isCloudFile_ = false;
737 ASSERT_TRUE(fileFdSourcePlugin_->IsLocalFd());
738 }
739 } // namespace FileSource
740 } // namespace Plugins
741 } // namespace Media
742 } // namespace OHOS