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_Reset_0100
314 * @tc.desc: FileFdSource_Reset_0100
315 * @tc.type: FUNC
316 */
317 HWTEST_F(FileFdSourceUnitTest, FileFdSource_Reset_0100, TestSize.Level1)
318 {
319 EXPECT_EQ(Status::OK, fileFdSourcePlugin_->Reset());
320 }
321 /**
322 * @tc.name: FileFdSource_SetBundleName_0100
323 * @tc.desc: FileFdSource_SetBundleName_0100
324 * @tc.type: FUNC
325 */
326 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SetBundleName_0100, TestSize.Level1)
327 {
328 fileFdSourcePlugin_->Stop();
329 fileFdSourcePlugin_->SetBundleName("TestFileFdSource");
330 EXPECT_EQ(Status::OK, fileFdSourcePlugin_->Stop());
331 }
332 /**
333 * @tc.name: FileFdSource_getCacheTime_0100
334 * @tc.desc: FileFdSource_getCacheTime_0100
335 * @tc.type: FUNC
336 */
337 HWTEST_F(FileFdSourceUnitTest, FileFdSource_getCacheTime_0100, TestSize.Level1)
338 {
339 fileFdSourcePlugin_->GetCacheTime(0.0);
340 fileFdSourcePlugin_->GetCacheTime(0.2);
341 fileFdSourcePlugin_->GetCacheTime(0.5);
342 fileFdSourcePlugin_->GetCacheTime(1.0);
343 fileFdSourcePlugin_->GetCacheTime(2.0);
344 fileFdSourcePlugin_->HasCacheData(0, 0);
345 ASSERT_NE(fileFdSourcePlugin_->HasCacheData(0, 0), true);
346 }
347
348 /**
349 * @tc.name: FileFdSource_ReadOnlineFile_0100
350 * @tc.desc: FileFdSource_ReadOnlineFile_0100
351 * @tc.type: FUNC
352 */
353 HWTEST_F(FileFdSourceUnitTest, FileFdSource_ReadOnlineFile_0100, TestSize.Level1)
354 {
355 fileFdSourcePlugin_->GetCacheTime(0.0);
356 fileFdSourcePlugin_->isBuffering_ = true;
357 std::shared_ptr<Buffer> buffer;
358 EXPECT_EQ(Status::ERROR_AGAIN, fileFdSourcePlugin_->ReadOnlineFile(0, buffer, 0, 0));
359 }
360
361 /**
362 * @tc.name: FileFdSource_SeekToOnlineFile_0100
363 * @tc.desc: FileFdSource_SeekToOnlineFile_0100
364 * @tc.type: FUNC
365 */
366 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SeekToOnlineFile_0100, TestSize.Level1)
367 {
368 std::shared_ptr<RingBufferMock> buffer = std::make_shared<RingBufferMock>(0);
369 fileFdSourcePlugin_->ringBuffer_ = buffer;
370 buffer->seekRet_ = true;
371 int64_t offset = 0;
372 EXPECT_EQ(Status::ERROR_UNKNOWN, fileFdSourcePlugin_->SeekToOnlineFile(offset));
373 }
374
375 /**
376 * @tc.name: FileFdSource_SeekToOnlineFile_0200
377 * @tc.desc: FileFdSource_SeekToOnlineFile_0200
378 * @tc.type: FUNC
379 */
380 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SeekToOnlineFile_0200, TestSize.Level1)
381 {
382 std::shared_ptr<RingBufferMock> buffer = std::make_shared<RingBufferMock>(0);
383 fileFdSourcePlugin_->ringBuffer_ = buffer;
384 buffer->seekRet_ = false;
385 int64_t offset = 0;
386 std::shared_ptr<Task> task = std::make_shared<Task>("test");
387 fileFdSourcePlugin_->downloadTask_ = task;
388 EXPECT_EQ(Status::ERROR_UNKNOWN, fileFdSourcePlugin_->SeekToOnlineFile(offset));
389 sleep(1);
390 }
391
392 /**
393 * @tc.name: FileFdSource_SeekToOnlineFile_0300
394 * @tc.desc: FileFdSource_SeekToOnlineFile_0300
395 * @tc.type: FUNC
396 */
397 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SeekToOnlineFile_0300, TestSize.Level1)
398 {
399 std::shared_ptr<RingBufferMock> buffer = std::make_shared<RingBufferMock>(0);
400 fileFdSourcePlugin_->ringBuffer_ = buffer;
401 buffer->seekRet_ = false;
402 int64_t offset = 0;
403 EXPECT_EQ(Status::ERROR_UNKNOWN, fileFdSourcePlugin_->SeekToOnlineFile(offset));
404 sleep(1);
405 }
406
407 /**
408 * @tc.name: FileFdSource_CacheDataLoop_0100
409 * @tc.desc: FileFdSource_CacheDataLoop_0100
410 * @tc.type: FUNC
411 */
412 HWTEST_F(FileFdSourceUnitTest, FileFdSource_CacheDataLoop_0100, TestSize.Level1)
413 {
414 std::shared_ptr<Task> task = std::make_shared<Task>("test");
415 fileFdSourcePlugin_->downloadTask_ = task;
416 fileFdSourcePlugin_->PauseDownloadTask(true);
417 sleep(1);
418 fileFdSourcePlugin_->PauseDownloadTask(false);
419 sleep(1);
420 fileFdSourcePlugin_->isInterrupted_ = true;
421 fileFdSourcePlugin_->CacheDataLoop();
422
423 fileFdSourcePlugin_->isInterrupted_ = false;
424 fileFdSourcePlugin_->CacheDataLoop();
425
426 fileFdSourcePlugin_->size_ = 10;
427 std::shared_ptr<RingBufferMock> buffer = std::make_shared<RingBufferMock>(0);
428 fileFdSourcePlugin_->ringBuffer_ = buffer;
429 buffer->readBufferSize_ = true;
430 fileFdSourcePlugin_->isBuffering_ = true;
431 fileFdSourcePlugin_->waterLineAbove_ = 0;
432 fileFdSourcePlugin_->CacheDataLoop();
433 EXPECT_EQ(0, fileFdSourcePlugin_->ringBuffer_->GetSize());
434
435 buffer->readBufferSize_ = false;
436 fileFdSourcePlugin_->inSeek_ = false;
437 fileFdSourcePlugin_->isInterrupted_ = true;
438 fileFdSourcePlugin_->CacheDataLoop();
439
440 fileFdSourcePlugin_->inSeek_ = true;
441 fileFdSourcePlugin_->cachePosition_ = 1;
442 fileFdSourcePlugin_->CacheDataLoop();
443
444 fileFdSourcePlugin_->CacheDataLoop();
445 EXPECT_EQ(0, fileFdSourcePlugin_->ringBuffer_->GetSize());
446 }
447
448 /**
449 * @tc.name: FileFdSource_HandleBuffering_0100
450 * @tc.desc: FileFdSource_HandleBuffering_0100
451 * @tc.type: FUNC
452 */
453 HWTEST_F(FileFdSourceUnitTest, FileFdSource_HandleBuffering_0100, TestSize.Level1)
454 {
455 EXPECT_EQ(false, fileFdSourcePlugin_->HandleBuffering());
456 fileFdSourcePlugin_->isBuffering_ = true;
457 EXPECT_EQ(true, fileFdSourcePlugin_->HandleBuffering());
458 fileFdSourcePlugin_->isInterrupted_ = true;
459 EXPECT_EQ(true, fileFdSourcePlugin_->HandleBuffering());
460 fileFdSourcePlugin_->isInterrupted_ = false;
461 fileFdSourcePlugin_->isReadBlocking_ = true;
462 fileFdSourcePlugin_->isBuffering_ = false;
463 EXPECT_EQ(false, fileFdSourcePlugin_->HandleBuffering());
464 }
465
466 /**
467 * @tc.name: FileFdSource_NotifyBufferingPercent_0200
468 * @tc.desc: FileFdSource_NotifyBufferingPercent_0200
469 * @tc.type: FUNC
470 */
471 HWTEST_F(FileFdSourceUnitTest, FileFdSource_NotifyBufferingPercent_0200, TestSize.Level1)
472 {
473 std::shared_ptr<RingBufferMock> buffer = std::make_shared<RingBufferMock>(0);
474 fileFdSourcePlugin_->ringBuffer_ = buffer;
475 fileFdSourcePlugin_->NotifyBufferingPercent();
476 fileFdSourcePlugin_->waterLineAbove_ = 1;
477 fileFdSourcePlugin_->isBuffering_ = true;
478 CallbackMock* cb = new CallbackMock();
479 fileFdSourcePlugin_->callback_ = cb;
480 fileFdSourcePlugin_->NotifyBufferingStart();
481 EXPECT_EQ("start", cb->description_);
482 fileFdSourcePlugin_->isInterrupted_ = true;;
483 fileFdSourcePlugin_->NotifyBufferingPercent();
484
485 fileFdSourcePlugin_->callback_ = nullptr;
486 fileFdSourcePlugin_->NotifyBufferingPercent();
487
488 fileFdSourcePlugin_->isBuffering_ = false;
489 fileFdSourcePlugin_->NotifyBufferingPercent();
490
491 fileFdSourcePlugin_->callback_ = cb;
492 fileFdSourcePlugin_->waterLineAbove_ = 1;
493 fileFdSourcePlugin_->isBuffering_ = true;
494 fileFdSourcePlugin_->isInterrupted_ = false;
495 fileFdSourcePlugin_->NotifyBufferingPercent();
496
497 EXPECT_EQ("0", cb->description_);
498 delete cb;
499 cb = nullptr;
500 }
501
502 /**
503 * @tc.name: FileFdSource_NotifyBufferingEnd_0200
504 * @tc.desc: FileFdSource_NotifyBufferingEnd_0200
505 * @tc.type: FUNC
506 */
507 HWTEST_F(FileFdSourceUnitTest, FileFdSource_NotifyBufferingEnd_0200, TestSize.Level1)
508 {
509 std::shared_ptr<RingBufferMock> buffer = std::make_shared<RingBufferMock>(0);
510 fileFdSourcePlugin_->ringBuffer_ = buffer;
511 fileFdSourcePlugin_->isBuffering_ = true;
512 fileFdSourcePlugin_->NotifyBufferingEnd();
513 EXPECT_EQ(false, fileFdSourcePlugin_->isBuffering_);
514
515 fileFdSourcePlugin_->isBuffering_ = true;
516 CallbackMock* cb = new CallbackMock();
517 fileFdSourcePlugin_->NotifyBufferingStart();
518 fileFdSourcePlugin_->callback_ = cb;
519 fileFdSourcePlugin_->isInterrupted_ = true;
520 fileFdSourcePlugin_->NotifyBufferingEnd();
521 EXPECT_EQ(false, fileFdSourcePlugin_->isBuffering_);
522
523 fileFdSourcePlugin_->isInterrupted_ = false;
524 fileFdSourcePlugin_->NotifyBufferingEnd();
525 EXPECT_EQ("end", cb->description_);
526 delete cb;
527 cb = nullptr;
528 }
529
530 /**
531 * @tc.name: FileFdSource_SetReadBlockingFlag_0100
532 * @tc.desc: FileFdSource_SetReadBlockingFlag_0100
533 * @tc.type: FUNC
534 */
535 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SetReadBlockingFlag_0100, TestSize.Level1)
536 {
537 fileFdSourcePlugin_->ringBuffer_ = std::make_shared<RingBufferMock>(0);
538 fileFdSourcePlugin_->SetReadBlockingFlag(true);
539 EXPECT_EQ(true, fileFdSourcePlugin_->isReadBlocking_);
540 fileFdSourcePlugin_->SetReadBlockingFlag(false);
541 EXPECT_EQ(false, fileFdSourcePlugin_->isReadBlocking_);
542 }
543
544 /**
545 * @tc.name: FileFdSource_SetInterruptState_0100
546 * @tc.desc: FileFdSource_SetInterruptState_0100
547 * @tc.type: FUNC
548 */
549 HWTEST_F(FileFdSourceUnitTest, FileFdSource_SetInterruptState_0100, TestSize.Level1)
550 {
551 fileFdSourcePlugin_->ringBuffer_ = std::make_shared<RingBufferMock>(0);
552 fileFdSourcePlugin_->SetInterruptState(true);
553 EXPECT_EQ(true, fileFdSourcePlugin_->isInterrupted_);
554 fileFdSourcePlugin_->SetInterruptState(false);
555 EXPECT_EQ(false, fileFdSourcePlugin_->isInterrupted_);
556 fileFdSourcePlugin_->isInterrupted_ = true;
557 fileFdSourcePlugin_->SetInterruptState(true);
558 EXPECT_EQ(true, fileFdSourcePlugin_->isInterrupted_);
559 fileFdSourcePlugin_->isCloudFile_ = true;
560 fileFdSourcePlugin_->SetInterruptState(true);
561 EXPECT_EQ(true, fileFdSourcePlugin_->isInterrupted_);
562 std::shared_ptr<Task> task = std::make_shared<Task>("test");
563 fileFdSourcePlugin_->downloadTask_ = task;
564 fileFdSourcePlugin_->SetInterruptState(true);
565 EXPECT_EQ(true, fileFdSourcePlugin_->isInterrupted_);
566 sleep(1);
567 }
568
569 /**
570 * @tc.name: FileFdSource_CheckFileType_0100
571 * @tc.desc: FileFdSource_CheckFileType_0100
572 * @tc.type: FUNC
573 */
574 HWTEST_F(FileFdSourceUnitTest, FileFdSource_CheckFileType_0100, TestSize.Level1)
575 {
576 fileFdSourcePlugin_->isEnableFdCache_ = false;
577 fileFdSourcePlugin_->CheckFileType();
578 EXPECT_EQ(false, fileFdSourcePlugin_->isCloudFile_);
579 }
580
581 /**
582 * @tc.name: FileFdSource_CheckFileType_0200
583 * @tc.desc: FileFdSource_CheckFileType_0200
584 * @tc.type: FUNC
585 */
586 HWTEST_F(FileFdSourceUnitTest, FileFdSource_CheckFileType_0200, TestSize.Level1)
587 {
588 fileFdSourcePlugin_->fd_ = -1;
589 fileFdSourcePlugin_->CheckFileType();
590 EXPECT_EQ(false, fileFdSourcePlugin_->isCloudFile_);
591 }
592
593 /**
594 * @tc.name: FileFdSource_GetBufferPtr_0100
595 * @tc.desc: FileFdSource_GetBufferPtr_0100
596 * @tc.type: FUNC
597 */
598 HWTEST_F(FileFdSourceUnitTest, FileFdSource_GetBufferPtr_0100, TestSize.Level1)
599 {
600 std::shared_ptr<Buffer> buffer = std::make_shared<Buffer>();
601 EXPECT_NE(nullptr, fileFdSourcePlugin_->GetBufferPtr(buffer, 10));
602 }
603
604 /**
605 * @tc.name: FileFdSource_GetCurrentSpeed_0100
606 * @tc.desc: FileFdSource_GetCurrentSpeed_0100
607 * @tc.type: FUNC
608 */
609 HWTEST_F(FileFdSourceUnitTest, FileFdSource_GetCurrentSpeed_0100, TestSize.Level1)
610 {
611 fileFdSourcePlugin_->GetCurrentSpeed(0);
612 fileFdSourcePlugin_->downloadSize_ = 10;
613 fileFdSourcePlugin_->GetCurrentSpeed(2 * 1000);
614 EXPECT_EQ(5, fileFdSourcePlugin_->avgDownloadSpeed_);
615 fileFdSourcePlugin_->lastCheckTime_ = 0;
616 fileFdSourcePlugin_->currentBitRate_ = 1;
617 fileFdSourcePlugin_->downloadSize_ = 2;
618 fileFdSourcePlugin_->GetCurrentSpeed(2 * 1000);
619 EXPECT_EQ(1, fileFdSourcePlugin_->avgDownloadSpeed_);
620 }
621
622 /**
623 * @tc.name: FileFdSource_GetCacheTime_0100
624 * @tc.desc: FileFdSource_GetCacheTime_0100
625 * @tc.type: FUNC
626 */
627 HWTEST_F(FileFdSourceUnitTest, FileFdSource_GetCacheTime_0100, TestSize.Level1)
628 {
629 EXPECT_EQ(5, fileFdSourcePlugin_->GetCacheTime(0.25));
630 EXPECT_EQ(5, fileFdSourcePlugin_->GetCacheTime(0.75));
631 EXPECT_TRUE((int)(fileFdSourcePlugin_->GetCacheTime(1) * 1000000) == (int)(0.3 * 1000000));
632 EXPECT_EQ((float)0.3, fileFdSourcePlugin_->GetCacheTime(-1));
633 EXPECT_EQ((float)0.3, fileFdSourcePlugin_->GetCacheTime(1));
634 }
635
636 /**
637 * @tc.name: FileFdSource_DeleteCacheBuffer_0100
638 * @tc.desc: FileFdSource_DeleteCacheBuffer_0100
639 * @tc.type: FUNC
640 */
641 HWTEST_F(FileFdSourceUnitTest, FileFdSource_DeleteCacheBuffer_0100, TestSize.Level1)
642 {
643 fileFdSourcePlugin_->DeleteCacheBuffer(nullptr, 0);
644 int32_t bufferSize = 4;
645 char* cacheBuffer = new char[bufferSize];
646
647 fileFdSourcePlugin_->DeleteCacheBuffer(cacheBuffer, 4);
648 EXPECT_NE(nullptr, cacheBuffer);
649 }
650
651 /**
652 * @tc.name: FileFdSource_CheckReadTime_0100
653 * @tc.desc: FileFdSource_CheckReadTime_0100
654 * @tc.type: FUNC
655 */
656 HWTEST_F(FileFdSourceUnitTest, FileFdSource_CheckReadTime_0100, TestSize.Level1)
657 {
658 fileFdSourcePlugin_->curReadTime_ = 10;
659 fileFdSourcePlugin_->CheckReadTime();
660 EXPECT_EQ(10, fileFdSourcePlugin_->lastReadTime_);
661
662 fileFdSourcePlugin_->lastReadTime_ = 1000;
663 fileFdSourcePlugin_->curReadTime_ = 2000;
664 fileFdSourcePlugin_->CheckReadTime();
665 EXPECT_EQ(1000, fileFdSourcePlugin_->lastReadTime_);
666
667 fileFdSourcePlugin_->curReadTime_ = 1020;
668 fileFdSourcePlugin_->CheckReadTime();
669 EXPECT_EQ(1000, fileFdSourcePlugin_->lastReadTime_);
670
671 fileFdSourcePlugin_->curReadTime_ = 1040;
672 fileFdSourcePlugin_->CheckReadTime();
673 EXPECT_EQ(0, fileFdSourcePlugin_->lastReadTime_);
674 }
675
676 /**
677 * @tc.name: FileFdSource_checkReadTime_0200
678 * @tc.desc: FileFdSource_checkReadTime_0200
679 * @tc.type: FUNC
680 */
681 HWTEST_F(FileFdSourceUnitTest, FileFdSource_checkReadTime_0200, TestSize.Level1)
682 {
683 fileFdSourcePlugin_->callback_ = nullptr;
684 int64_t curTime = 0;
685 int64_t lastTime = 0;
686 auto isValidTime = fileFdSourcePlugin_->IsValidTime(curTime, lastTime);
687 ASSERT_FALSE(isValidTime);
688 fileFdSourcePlugin_->CheckReadTime();
689 }
690 /**
691 * @tc.name: FileFdSource_PauseDownloadTask_0100
692 * @tc.desc: FileFdSource_PauseDownloadTask_0100
693 * @tc.type: FUNC
694 */
695 HWTEST_F(FileFdSourceUnitTest, FileFdSource_PauseDownloadTask_0100, TestSize.Level1)
696 {
697 fileFdSourcePlugin_->downloadTask_ = nullptr;
698 fileFdSourcePlugin_->PauseDownloadTask(true);
699 fileFdSourcePlugin_->downloadTask_ = std::shared_ptr<Task>();
700 fileFdSourcePlugin_->PauseDownloadTask(true);
701 fileFdSourcePlugin_->PauseDownloadTask(false);
702 ASSERT_TRUE(fileFdSourcePlugin_->downloadSize_ == 0);
703 }
704
705 /**
706 * @tc.name: FileFdSource_IsLocalFd_0100
707 * @tc.desc: FileFdSource_IsLocalFd_0100
708 * @tc.type: FUNC
709 */
710 HWTEST_F(FileFdSourceUnitTest, FileFdSource_IsLocalFd_0100, TestSize.Level1)
711 {
712 fileFdSourcePlugin_->isCloudFile_ = false;
713 ASSERT_TRUE(fileFdSourcePlugin_->IsLocalFd());
714 }
715 } // namespace FileSource
716 } // namespace Plugins
717 } // namespace Media
718 } // namespace OHOS