1 /*
2  * Copyright (c) 2023 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 "hls_media_downloader_unit_test.h"
16 #include "http_server_demo.h"
17 #include "source_callback.h"
18 
19 using namespace OHOS;
20 using namespace OHOS::Media;
21 namespace OHOS::Media::Plugins::HttpPlugin {
22 using namespace std;
23 using namespace testing::ext;
24 
25 
26 const std::map<std::string, std::string> httpHeader = {
27     {"User-Agent", "ABC"},
28     {"Referer", "DEF"},
29 };
30 
31 static const std::string TEST_URI_PATH = "http://127.0.0.1:46666/";
32 static const std::string M3U8_PATH_1 = "test_hls/testHLSEncode.m3u8";
33 constexpr int MIN_WITDH = 480;
34 constexpr int SECOND_WITDH = 720;
35 constexpr int THIRD_WITDH = 1080;
36 constexpr int MAX_RECORD_COUNT = 10;
37 
38 std::unique_ptr<MediaAVCodec::HttpServerDemo> g_server = nullptr;
39 
SetUpTestCase(void)40 void HlsMediaDownloaderUnitTest::SetUpTestCase(void)
41 {
42     g_server = std::make_unique<MediaAVCodec::HttpServerDemo>();
43     g_server->StartServer();
44 }
45 
TearDownTestCase(void)46 void HlsMediaDownloaderUnitTest::TearDownTestCase(void)
47 {
48     g_server->StopServer();
49     g_server = nullptr;
50 }
51 
SetUp(void)52 void HlsMediaDownloaderUnitTest ::SetUp(void)
53 {
54     hlsMediaDownloader = new HlsMediaDownloader();
55 }
56 
TearDown(void)57 void HlsMediaDownloaderUnitTest ::TearDown(void)
58 {
59     delete hlsMediaDownloader;
60     hlsMediaDownloader = nullptr;
61 }
62 
63 HWTEST_F(HlsMediaDownloaderUnitTest, GetDownloadInfo1, TestSize.Level1)
64 {
65     hlsMediaDownloader->recordSpeedCount_ = 0;
66     DownloadInfo downloadInfo;
67     hlsMediaDownloader->GetDownloadInfo(downloadInfo);
68     EXPECT_EQ(downloadInfo.avgDownloadRate, 0);
69 }
70 
71 HWTEST_F(HlsMediaDownloaderUnitTest, GetDownloadInfo2, TestSize.Level1)
72 {
73     hlsMediaDownloader->recordSpeedCount_ = 5;
74     hlsMediaDownloader->avgSpeedSum_ = 25;
75     DownloadInfo downloadInfo;
76     hlsMediaDownloader->GetDownloadInfo(downloadInfo);
77     EXPECT_EQ(downloadInfo.avgDownloadRate, 5);
78 }
79 
80 HWTEST_F(HlsMediaDownloaderUnitTest, GetDownloadInfo3, TestSize.Level1)
81 {
82     hlsMediaDownloader->avgDownloadSpeed_ = 10;
83     DownloadInfo downloadInfo;
84     hlsMediaDownloader->GetDownloadInfo(downloadInfo);
85     EXPECT_EQ(downloadInfo.avgDownloadSpeed, 10);
86 }
87 
88 HWTEST_F(HlsMediaDownloaderUnitTest, GetDownloadInfo4, TestSize.Level1)
89 {
90     hlsMediaDownloader->totalBits_ = 50;
91     DownloadInfo downloadInfo;
92     hlsMediaDownloader->GetDownloadInfo(downloadInfo);
93     EXPECT_EQ(downloadInfo.totalDownLoadBits, 50);
94 }
95 
96 HWTEST_F(HlsMediaDownloaderUnitTest, GetDownloadInfo5, TestSize.Level1)
97 {
98     hlsMediaDownloader->isTimeOut_ = true;
99     DownloadInfo downloadInfo;
100     hlsMediaDownloader->GetDownloadInfo(downloadInfo);
101     EXPECT_EQ(downloadInfo.isTimeOut, true);
102 }
103 
104 HWTEST_F(HlsMediaDownloaderUnitTest, GetBufferSize, TestSize.Level1)
105 {
106     size_t actualSize = hlsMediaDownloader->GetBufferSize();
107     EXPECT_EQ(actualSize, 0);
108 }
109 
110 HWTEST_F(HlsMediaDownloaderUnitTest, GetTotalBufferSize, TestSize.Level1)
111 {
112     hlsMediaDownloader->totalBufferSize_ = 1024;
113     EXPECT_EQ(hlsMediaDownloader->GetTotalBufferSize(), 1024);
114 }
115 
116 HWTEST_F(HlsMediaDownloaderUnitTest, TransferSizeToBitRate1, TestSize.Level1)
117 {
118     int width = MIN_WITDH;
119     uint64_t expectedBitRate = RING_BUFFER_SIZE;
120     uint64_t actualBitRate = hlsMediaDownloader->TransferSizeToBitRate(width);
121     EXPECT_EQ(expectedBitRate, actualBitRate);
122 }
123 
124 HWTEST_F(HlsMediaDownloaderUnitTest, TransferSizeToBitRate2, TestSize.Level1)
125 {
126     int width = SECOND_WITDH - 1;
127     uint64_t expectedBitRate = RING_BUFFER_SIZE + RING_BUFFER_SIZE;
128     uint64_t actualBitRate = hlsMediaDownloader->TransferSizeToBitRate(width);
129     EXPECT_EQ(expectedBitRate, actualBitRate);
130 }
131 
132 HWTEST_F(HlsMediaDownloaderUnitTest, TransferSizeToBitRate3, TestSize.Level1)
133 {
134     int width = THIRD_WITDH - 1;
135     uint64_t expectedBitRate = RING_BUFFER_SIZE + RING_BUFFER_SIZE + RING_BUFFER_SIZE;
136     uint64_t actualBitRate = hlsMediaDownloader->TransferSizeToBitRate(width);
137     EXPECT_EQ(expectedBitRate, actualBitRate);
138 }
139 
140 HWTEST_F(HlsMediaDownloaderUnitTest, TransferSizeToBitRate4, TestSize.Level1)
141 {
142     int width = THIRD_WITDH + 1;
143     uint64_t expectedBitRate = RING_BUFFER_SIZE + RING_BUFFER_SIZE + RING_BUFFER_SIZE + RING_BUFFER_SIZE;
144     uint64_t actualBitRate = hlsMediaDownloader->TransferSizeToBitRate(width);
145     EXPECT_EQ(expectedBitRate, actualBitRate);
146 }
147 
148 HWTEST_F(HlsMediaDownloaderUnitTest, InActiveAutoBufferSize, TestSize.Level1)
149 {
150     hlsMediaDownloader->InActiveAutoBufferSize();
151     EXPECT_FALSE(hlsMediaDownloader->autoBufferSize_);
152 }
153 
154 HWTEST_F(HlsMediaDownloaderUnitTest, ActiveAutoBufferSize1, TestSize.Level1)
155 {
156     hlsMediaDownloader->ActiveAutoBufferSize();
157     EXPECT_TRUE(hlsMediaDownloader->autoBufferSize_);
158 }
159 
160 HWTEST_F(HlsMediaDownloaderUnitTest, ActiveAutoBufferSize2, TestSize.Level1)
161 {
162     hlsMediaDownloader->userDefinedBufferDuration_ = true;
163     bool oldAutoBufferSize = hlsMediaDownloader->autoBufferSize_;
164     hlsMediaDownloader->ActiveAutoBufferSize();
165     EXPECT_EQ(oldAutoBufferSize, hlsMediaDownloader->autoBufferSize_);
166 }
167 
168 HWTEST_F(HlsMediaDownloaderUnitTest, OnReadRingBuffer1, TestSize.Level1)
169 {
170     uint32_t len = 100;
171     hlsMediaDownloader->bufferedDuration_ = 50;
172     hlsMediaDownloader->OnReadBuffer(len);
173     EXPECT_EQ(hlsMediaDownloader->bufferedDuration_, 0);
174 }
175 
176 HWTEST_F(HlsMediaDownloaderUnitTest, OnReadRingBuffer2, TestSize.Level1)
177 {
178     uint32_t len = 50;
179     hlsMediaDownloader->bufferedDuration_ = 100;
180     hlsMediaDownloader->OnReadBuffer(len);
181     EXPECT_LT(hlsMediaDownloader->bufferedDuration_, 100);
182 }
183 
184 HWTEST_F(HlsMediaDownloaderUnitTest, OnReadRingBuffer3, TestSize.Level1)
185 {
186     uint32_t len = 50;
187     hlsMediaDownloader->bufferedDuration_ = 0;
188     hlsMediaDownloader->lastReadTime_ = 0;
189     hlsMediaDownloader->OnReadBuffer(len);
190     EXPECT_NE(hlsMediaDownloader->bufferLeastRecord_, nullptr);
191 }
192 
193 HWTEST_F(HlsMediaDownloaderUnitTest, OnReadRingBuffer4, TestSize.Level1)
194 {
195     uint32_t len = 50;
196     hlsMediaDownloader->bufferedDuration_ = 0;
197     hlsMediaDownloader->lastReadTime_ = 0;
198     for (int i = 0; i < MAX_RECORD_COUNT + 1; i++) {
199         hlsMediaDownloader->OnReadBuffer(len);
200     }
201     EXPECT_NE(hlsMediaDownloader->bufferLeastRecord_->next, nullptr);
202 }
203 
204 HWTEST_F(HlsMediaDownloaderUnitTest, DownBufferSize1, TestSize.Level1)
205 {
206     hlsMediaDownloader->totalBufferSize_ = 10 * 1024 * 1024;
207     hlsMediaDownloader->DownBufferSize();
208     EXPECT_EQ(hlsMediaDownloader->totalBufferSize_, 9 * 1024 * 1024);
209 }
210 
211 HWTEST_F(HlsMediaDownloaderUnitTest, DownBufferSize2, TestSize.Level1)
212 {
213     hlsMediaDownloader->totalBufferSize_ = RING_BUFFER_SIZE;
214     hlsMediaDownloader->DownBufferSize();
215     EXPECT_EQ(hlsMediaDownloader->totalBufferSize_, RING_BUFFER_SIZE);
216 }
217 
218 HWTEST_F(HlsMediaDownloaderUnitTest, RiseBufferSize1, TestSize.Level1)
219 {
220     hlsMediaDownloader->totalBufferSize_ = 0;
221     hlsMediaDownloader->RiseBufferSize();
222     EXPECT_EQ(hlsMediaDownloader->totalBufferSize_, 1 * 1024 * 1024);
223 }
224 
225 HWTEST_F(HlsMediaDownloaderUnitTest, RiseBufferSize2, TestSize.Level1)
226 {
227     hlsMediaDownloader->totalBufferSize_ = MAX_BUFFER_SIZE;
228     hlsMediaDownloader->RiseBufferSize();
229     EXPECT_EQ(hlsMediaDownloader->totalBufferSize_, MAX_BUFFER_SIZE);
230 }
231 
232 HWTEST_F(HlsMediaDownloaderUnitTest, CheckPulldownBufferSize, TestSize.Level1)
233 {
234     hlsMediaDownloader->recordData_ = nullptr;
235     bool result = hlsMediaDownloader->CheckPulldownBufferSize();
236     EXPECT_FALSE(result);
237 }
238 
239 HWTEST_F(HlsMediaDownloaderUnitTest, CheckRiseBufferSize, TestSize.Level1)
240 {
241     hlsMediaDownloader->recordData_ = nullptr;
242     bool result = hlsMediaDownloader->CheckRiseBufferSize();
243     EXPECT_FALSE(result);
244 }
245 
246 HWTEST_F(HlsMediaDownloaderUnitTest, SetDownloadErrorState, TestSize.Level1)
247 {
248     hlsMediaDownloader->SetDownloadErrorState();
249     EXPECT_TRUE(hlsMediaDownloader->downloadErrorState_);
250 }
251 
252 HWTEST_F(HlsMediaDownloaderUnitTest, SetDemuxerState, TestSize.Level1)
253 {
254     hlsMediaDownloader->SetDemuxerState(0);
255     EXPECT_TRUE(hlsMediaDownloader->isReadFrame_);
256     EXPECT_TRUE(hlsMediaDownloader->isFirstFrameArrived_);
257 }
258 
259 HWTEST_F(HlsMediaDownloaderUnitTest, CheckBreakCondition, TestSize.Level1)
260 {
261     hlsMediaDownloader->downloadErrorState_ = true;
262     EXPECT_TRUE(hlsMediaDownloader->CheckBreakCondition());
263 }
264 
265 HWTEST_F(HlsMediaDownloaderUnitTest, HandleBuffering, TestSize.Level1)
266 {
267     hlsMediaDownloader->isBuffering_ = false;
268     EXPECT_FALSE(hlsMediaDownloader->HandleBuffering());
269 }
270 
271 HWTEST_F(HlsMediaDownloaderUnitTest, TestDefaultConstructor, TestSize.Level1)
272 {
273     EXPECT_EQ(hlsMediaDownloader->totalBufferSize_, MAX_CACHE_BUFFER_SIZE);
274 }
275 
276 HWTEST_F(HlsMediaDownloaderUnitTest, SAVE_HEADER_001, TestSize.Level1)
277 {
278     hlsMediaDownloader->SaveHttpHeader(httpHeader);
279     EXPECT_EQ(hlsMediaDownloader->httpHeader_["User-Agent"], "ABC");
280     EXPECT_EQ(hlsMediaDownloader->httpHeader_["Referer"], "DEF");
281 }
282 
283 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_OPEN_001, TestSize.Level1)
284 {
285     HlsMediaDownloader *downloader = new HlsMediaDownloader(1000);
286     EXPECT_EQ(downloader->expectDuration_, static_cast<uint64_t>(1000));
287     delete downloader;
288     downloader = nullptr;
289 }
290 
291 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_OPEN_002, TestSize.Level1)
292 {
293     HlsMediaDownloader *downloader = new HlsMediaDownloader(10);
294     EXPECT_EQ(downloader->expectDuration_, static_cast<uint64_t>(10));
295     delete downloader;
296     downloader = nullptr;
297 }
298 
299 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_PAUSE, TestSize.Level1)
300 {
301     HlsMediaDownloader *downloader = new HlsMediaDownloader(10);
302     std::string testUrl = TEST_URI_PATH + "test_hls/testHLSEncode.m3u8";
303     downloader->Open(testUrl, httpHeader);
304     EXPECT_TRUE(downloader);
305     downloader->isInterrupt_ = false;
306     downloader->Pause();
307     downloader->Resume();
308     downloader->Pause();
309     delete downloader;
310     downloader = nullptr;
311 }
312 
313 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_SEEK_TO_TIME, TestSize.Level1)
314 {
315     std::shared_ptr<HlsMediaDownloader> downloader = std::make_shared<HlsMediaDownloader>();
316     std::string testUrl = TEST_URI_PATH + "test_cbr/720_1M/video_720.m3u8";
317     auto statusCallback = [] (DownloadStatus&& status, std::shared_ptr<Downloader>& downloader,
__anon1c4b8d1a0102(DownloadStatus&& status, std::shared_ptr<Downloader>& downloader, std::shared_ptr<DownloadRequest>& request) 318         std::shared_ptr<DownloadRequest>& request) {
319     };
320     downloader->SetStatusCallback(statusCallback);
321     downloader->Open(testUrl, httpHeader);
322     downloader->GetSeekable();
323     bool result = downloader->SeekToTime(1, SeekMode::SEEK_NEXT_SYNC);
324     downloader->Close(true);
325     downloader = nullptr;
326     EXPECT_TRUE(result);
327 }
328 
329 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_READ_001, TestSize.Level1)
330 {
331     std::shared_ptr<HlsMediaDownloader> downloader = std::make_shared<HlsMediaDownloader>(10);
332     std::string testUrl = TEST_URI_PATH + "test_cbr/720_1M/video_720.m3u8";
333     auto statusCallback = [] (DownloadStatus&& status, std::shared_ptr<Downloader>& downloader,
__anon1c4b8d1a0202(DownloadStatus&& status, std::shared_ptr<Downloader>& downloader, std::shared_ptr<DownloadRequest>& request) 334         std::shared_ptr<DownloadRequest>& request) {
335     };
336     downloader->SetStatusCallback(statusCallback);
337     downloader->Open(testUrl, httpHeader);
338     downloader->GetSeekable();
339     unsigned char buff[10];
340     ReadDataInfo readDataInfo;
341     readDataInfo.streamId_ = 0;
342     readDataInfo.wantReadLength_ = 10;
343     readDataInfo.isEos_ = true;
344     downloader->Read(buff, readDataInfo);
345 
346     OSAL::SleepFor(1 * 1000);
347     downloader->Close(true);
348     downloader = nullptr;
349     EXPECT_GE(readDataInfo.realReadLength_, 0);
350 }
351 
352 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_CALLBACK, TestSize.Level1)
353 {
354     std::shared_ptr<HlsMediaDownloader> downloader = std::make_shared<HlsMediaDownloader>(10);
355     std::string testUrl = TEST_URI_PATH + "test_cbr/720_1M/video_720.m3u8";
356     auto statusCallback = [] (DownloadStatus&& status, std::shared_ptr<Downloader>& downloader,
__anon1c4b8d1a0302(DownloadStatus&& status, std::shared_ptr<Downloader>& downloader, std::shared_ptr<DownloadRequest>& request) 357         std::shared_ptr<DownloadRequest>& request) {
358     };
359     downloader->SetStatusCallback(statusCallback);
360     Plugins::Callback* sourceCallback = new SourceCallback();
361     downloader->SetCallback(sourceCallback);
362     downloader->Open(testUrl, httpHeader);
363     downloader->GetSeekable();
364     unsigned char buff[10];
365     ReadDataInfo readDataInfo;
366     readDataInfo.streamId_ = 0;
367     readDataInfo.wantReadLength_ = 10;
368     readDataInfo.isEos_ = true;
369     downloader->Read(buff, readDataInfo);
370     EXPECT_GE(readDataInfo.realReadLength_, 0);
371     OSAL::SleepFor(1 * 1000);
372 
373     downloader->SetCurrentBitRate(-1, 0);
374     downloader->UpdateWaterLineAbove();
375     downloader->SetCurrentBitRate(10, 0);
376     downloader->UpdateWaterLineAbove();
377     downloader->HandleCachedDuration();
378     downloader->SetInterruptState(true);
379     downloader->SetInterruptState(false);
380     downloader->GetContentLength();
381     downloader->GetDuration();
382     downloader->GetBitRates();
383     downloader->SetReadBlockingFlag(true);
384     downloader->SetReadBlockingFlag(false);
385     downloader->ReportBitrateStart(100);
386     downloader->CalculateBitRate(0, 0);
387     downloader->CalculateBitRate(1, 0);
388     std::multimap<std::string, std::vector<uint8_t>> drmInfos;
389     downloader->OnDrmInfoChanged(drmInfos);
390     downloader->Close(true);
391     downloader = nullptr;
392 }
393 
394 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_CALLBACK1, TestSize.Level1)
395 {
396     std::shared_ptr<HlsMediaDownloader> downloader = std::make_shared<HlsMediaDownloader>(10);
397     std::string testUrl = TEST_URI_PATH + "test_cbr/720_1M/video_720.m3u8";
398     auto statusCallback = [] (DownloadStatus&& status, std::shared_ptr<Downloader>& downloader,
__anon1c4b8d1a0402(DownloadStatus&& status, std::shared_ptr<Downloader>& downloader, std::shared_ptr<DownloadRequest>& request) 399         std::shared_ptr<DownloadRequest>& request) {
400     };
401     downloader->SetStatusCallback(statusCallback);
402     Plugins::Callback* sourceCallback = new SourceCallback();
403     downloader->SetCallback(sourceCallback);
404     downloader->Open(testUrl, httpHeader);
405     downloader->GetSeekable();
406     unsigned char buff[10];
407     ReadDataInfo readDataInfo;
408     readDataInfo.streamId_ = 0;
409     readDataInfo.wantReadLength_ = 10;
410     readDataInfo.isEos_ = true;
411     downloader->Read(buff, readDataInfo);
412     OSAL::SleepFor(1 * 1000);
413     downloader->HandleCache();
414     downloader->Close(true);
415     downloader = nullptr;
416     EXPECT_GE(readDataInfo.realReadLength_, 0);
417 }
418 
419 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_DownloadReport, TestSize.Level1)
420 {
421     std::shared_ptr<HlsMediaDownloader> downloader = std::make_shared<HlsMediaDownloader>(10);
422     std::string testUrl = TEST_URI_PATH + "test_cbr/1080_3M/video_1080.m3u8";
423     auto statusCallback = [] (DownloadStatus&& status, std::shared_ptr<Downloader>& downloader,
__anon1c4b8d1a0502(DownloadStatus&& status, std::shared_ptr<Downloader>& downloader, std::shared_ptr<DownloadRequest>& request) 424         std::shared_ptr<DownloadRequest>& request) {
425     };
426     downloader->SetStatusCallback(statusCallback);
427     Plugins::Callback* sourceCallback = new SourceCallback();
428     downloader->SetCallback(sourceCallback);
429     downloader->Open(testUrl, httpHeader);
430     ReadDataInfo readDataInfo;
431     for (int i = 0; i < 80; i++) {
432         OSAL::SleepFor(100);
433         downloader->DownloadReport();
434 
435         unsigned char buff[100 * 1024];
436         readDataInfo.streamId_ = 0;
437         readDataInfo.wantReadLength_ = 100 * 1024;
438         readDataInfo.isEos_ = false;
439         downloader->Read(buff, readDataInfo);
440     }
441     downloader->CheckBufferingOneSeconds();
442     downloader->Close(true);
443     downloader = nullptr;
444     EXPECT_GE(readDataInfo.realReadLength_, 0);
445 }
446 
447 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_DownloadReport_5M, TestSize.Level1)
448 {
449     std::shared_ptr<HlsMediaDownloader> downloader = std::make_shared<HlsMediaDownloader>(10);
450     std::string testUrl = TEST_URI_PATH + "test_cbr/1080_3M/video_1080.m3u8";
451     auto statusCallback = [] (DownloadStatus&& status, std::shared_ptr<Downloader>& downloader,
__anon1c4b8d1a0602(DownloadStatus&& status, std::shared_ptr<Downloader>& downloader, std::shared_ptr<DownloadRequest>& request) 452         std::shared_ptr<DownloadRequest>& request) {
453     };
454     downloader->SetStatusCallback(statusCallback);
455     Plugins::Callback* sourceCallback = new SourceCallback();
456     downloader->SetCallback(sourceCallback);
457     downloader->Open(testUrl, httpHeader);
458     OSAL::SleepFor(6 * 1000);
459     downloader->DownloadReport();
460     downloader->GetSeekable();
461     unsigned char buff[5 * 1024 * 1024];
462     ReadDataInfo readDataInfo;
463     readDataInfo.streamId_ = 0;
464     readDataInfo.wantReadLength_ = 5 * 1024 * 1024;
465     readDataInfo.isEos_ = true;
466     downloader->Read(buff, readDataInfo);
467     OSAL::SleepFor(1 * 1000);
468     downloader->HandleCache();
469     downloader->CheckBufferingOneSeconds();
470     downloader->Close(true);
471     downloader = nullptr;
472     EXPECT_GE(readDataInfo.realReadLength_, 0);
473 }
474 
475 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_DownloadReport_5M_default, TestSize.Level1)
476 {
477     std::shared_ptr<HlsMediaDownloader> downloader = std::make_shared<HlsMediaDownloader>();
478     std::string testUrl = TEST_URI_PATH + "test_cbr/1080_3M/video_1080.m3u8";
479     auto statusCallback = [] (DownloadStatus&& status, std::shared_ptr<Downloader>& downloader,
__anon1c4b8d1a0702(DownloadStatus&& status, std::shared_ptr<Downloader>& downloader, std::shared_ptr<DownloadRequest>& request) 480         std::shared_ptr<DownloadRequest>& request) {
481     };
482     downloader->SetStatusCallback(statusCallback);
483     Plugins::Callback* sourceCallback = new SourceCallback();
484     downloader->SetCallback(sourceCallback);
485     downloader->Open(testUrl, httpHeader);
486     downloader->GetSeekable();
487     ReadDataInfo readDataInfo;
488     for (int i = 0; i < 800; i++) {
489         OSAL::SleepFor(10);
490         downloader->DownloadReport();
491 
492         unsigned char buff[10 * 1024];
493         readDataInfo.streamId_ = 0;
494         readDataInfo.wantReadLength_ = 10 * 1024;
495         readDataInfo.isEos_ = false;
496         downloader->Read(buff, readDataInfo);
497         if (i == 3) {
498             downloader->SetDemuxerState(0);
499         }
500     }
501     downloader->CheckBufferingOneSeconds();
502     downloader->Close(true);
503     downloader = nullptr;
504     EXPECT_GE(readDataInfo.realReadLength_, 0);
505 }
506 
507 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_read_all, TestSize.Level1)
508 {
509     std::shared_ptr<HlsMediaDownloader> downloader = std::make_shared<HlsMediaDownloader>();
510     std::string testUrl = TEST_URI_PATH + "test_cbr/720_1M/video_720.m3u8";
511     auto statusCallback = [] (DownloadStatus&& status, std::shared_ptr<Downloader>& downloader,
__anon1c4b8d1a0802(DownloadStatus&& status, std::shared_ptr<Downloader>& downloader, std::shared_ptr<DownloadRequest>& request) 512         std::shared_ptr<DownloadRequest>& request) {
513     };
514     downloader->SetStatusCallback(statusCallback);
515     Plugins::Callback* sourceCallback = new SourceCallback();
516     downloader->SetCallback(sourceCallback);
517     downloader->Open(testUrl, httpHeader);
518     downloader->GetSeekable();
519     ReadDataInfo readDataInfo;
520     for (int i = 0; i < 800; i++) {
521         OSAL::SleepFor(10);
522         unsigned char buff[10 * 1024];
523         readDataInfo.streamId_ = 0;
524         readDataInfo.wantReadLength_ = 10 * 1024;
525         readDataInfo.isEos_ = false;
526         downloader->Read(buff, readDataInfo);
527     }
528     downloader->Close(true);
529     downloader = nullptr;
530     EXPECT_GE(readDataInfo.realReadLength_, 0);
531 }
532 
533 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_Read_Live, TestSize.Level1)
534 {
535     std::shared_ptr<HlsMediaDownloader> downloader = std::make_shared<HlsMediaDownloader>(10);
536     std::string testUrl = TEST_URI_PATH + "test_cbr/720_1M/video_720_live.m3u8";
537     auto statusCallback = [] (DownloadStatus&& status, std::shared_ptr<Downloader>& downloader,
__anon1c4b8d1a0902(DownloadStatus&& status, std::shared_ptr<Downloader>& downloader, std::shared_ptr<DownloadRequest>& request) 538         std::shared_ptr<DownloadRequest>& request) {
539     };
540     downloader->SetStatusCallback(statusCallback);
541     Plugins::Callback* sourceCallback = new SourceCallback();
542     downloader->SetCallback(sourceCallback);
543     downloader->Open(testUrl, httpHeader);
544     downloader->GetSeekable();
545     unsigned char buff[5 * 1024 * 1024];
546     ReadDataInfo readDataInfo;
547     readDataInfo.streamId_ = 0;
548     readDataInfo.wantReadLength_ = 5 * 1024 * 1024;
549     readDataInfo.isEos_ = true;
550     downloader->Read(buff, readDataInfo);
551     OSAL::SleepFor(1 * 1000);
552     downloader->HandleCache();
553     downloader->CheckBufferingOneSeconds();
554     downloader->Close(true);
555     downloader = nullptr;
556     EXPECT_GE(readDataInfo.realReadLength_, 0);
557 }
558 
559 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_READ_Encrypted, TestSize.Level1)
560 {
561     std::shared_ptr<HlsMediaDownloader> downloader = std::make_shared<HlsMediaDownloader>(10);
562     std::string testUrl = TEST_URI_PATH + "test_hls/testHLSEncode.m3u8";
563     auto statusCallback = [] (DownloadStatus&& status, std::shared_ptr<Downloader>& downloader,
__anon1c4b8d1a0a02(DownloadStatus&& status, std::shared_ptr<Downloader>& downloader, std::shared_ptr<DownloadRequest>& request) 564         std::shared_ptr<DownloadRequest>& request) {
565     };
566     downloader->SetStatusCallback(statusCallback);
567     downloader->Open(testUrl, httpHeader);
568     downloader->GetSeekable();
569     downloader->GetStartedStatus();
570     unsigned char buff[10];
571     ReadDataInfo readDataInfo;
572     readDataInfo.streamId_ = 0;
573     readDataInfo.wantReadLength_ = 10;
574     readDataInfo.isEos_ = true;
575     downloader->Read(buff, readDataInfo);
576 
577     OSAL::SleepFor(2 * 1000);
578     downloader->Close(true);
579     downloader = nullptr;
580     EXPECT_GE(readDataInfo.realReadLength_, 0);
581 }
582 
583 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_READ_Encrypted_session_key, TestSize.Level1)
584 {
585     std::shared_ptr<HlsMediaDownloader> downloader = std::make_shared<HlsMediaDownloader>(10);
586     std::string testUrl = TEST_URI_PATH + "test_hls/testHLSEncode_session_key.m3u8";
587     auto statusCallback = [] (DownloadStatus&& status, std::shared_ptr<Downloader>& downloader,
__anon1c4b8d1a0b02(DownloadStatus&& status, std::shared_ptr<Downloader>& downloader, std::shared_ptr<DownloadRequest>& request) 588         std::shared_ptr<DownloadRequest>& request) {
589     };
590     downloader->SetStatusCallback(statusCallback);
591     downloader->Open(testUrl, httpHeader);
592     downloader->GetSeekable();
593     downloader->GetStartedStatus();
594     unsigned char buff[10];
595     ReadDataInfo readDataInfo;
596     readDataInfo.streamId_ = 0;
597     readDataInfo.wantReadLength_ = 10;
598     readDataInfo.isEos_ = true;
599     downloader->Read(buff, readDataInfo);
600 
601     OSAL::SleepFor(2 * 1000);
602     downloader->Close(true);
603     downloader = nullptr;
604     EXPECT_GE(readDataInfo.realReadLength_, 0);
605 }
606 
607 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_OPEN_URL, TestSize.Level1)
608 {
609     std::shared_ptr<HlsMediaDownloader> downloader = std::make_shared<HlsMediaDownloader>("application/m3u8");
610     std::string testUrl = "fd://1?offset=0&size=1024";
611     auto statusCallback = [] (DownloadStatus&& status, std::shared_ptr<Downloader>& downloader,
__anon1c4b8d1a0c02(DownloadStatus&& status, std::shared_ptr<Downloader>& downloader, std::shared_ptr<DownloadRequest>& request) 612         std::shared_ptr<DownloadRequest>& request) {
613     };
614     downloader->SetStatusCallback(statusCallback);
615     downloader->Open(testUrl, httpHeader);
616     EXPECT_TRUE(downloader);
617     downloader->Close(true);
618     testUrl = "fd://-1?offset=0&size=1024";
619     downloader->Open(testUrl, httpHeader);
620     downloader->Close(true);
621     testUrl = "fd://1?offset=2048&size=1024";
622     downloader->Open(testUrl, httpHeader);
623     downloader->Close(true);
624     testUrl = "fd://1?offset=512&size=1024";
625     downloader->Open(testUrl, httpHeader);
626     downloader->Close(true);
627     downloader = nullptr;
628 }
629 
GetFileSize(const string & fileName)630 int64_t GetFileSize(const string &fileName)
631 {
632     int64_t fileSize = 0;
633     if (!fileName.empty()) {
634         struct stat fileStatus {};
635         if (stat(fileName.c_str(), &fileStatus) == 0) {
636             fileSize = static_cast<int64_t>(fileStatus.st_size);
637         }
638     }
639     return fileSize;
640 }
641 
642 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_READ_null, TestSize.Level1)
643 {
644     std::shared_ptr<HlsMediaDownloader> downloader = std::make_shared<HlsMediaDownloader>("application/m3u8");
645     std::string path = "/data/test/media/test_cbr/720_1M/video_720_native.m3u8";
646     int32_t fd = open(path.c_str(), O_RDONLY);
647     int64_t size = GetFileSize(path);
648     std::string testUrl = "fd://" + std::to_string(fd) + "?offset=0&size=" + std::to_string(size);
649     auto statusCallback = [] (DownloadStatus&& status, std::shared_ptr<Downloader>& downloader,
__anon1c4b8d1a0d02(DownloadStatus&& status, std::shared_ptr<Downloader>& downloader, std::shared_ptr<DownloadRequest>& request) 650         std::shared_ptr<DownloadRequest>& request) {
651     };
652     downloader->SetStatusCallback(statusCallback);
653     downloader->Open(testUrl, httpHeader);
654     downloader->GetSeekable();
655     downloader->GetStartedStatus();
656     unsigned char buff[10];
657     ReadDataInfo readDataInfo;
658     readDataInfo.streamId_ = 0;
659     readDataInfo.wantReadLength_ = 10;
660     readDataInfo.isEos_ = true;
661     downloader->Read(buff, readDataInfo);
662 
663     OSAL::SleepFor(4 * 1000);
664     downloader->Close(true);
665     downloader = nullptr;
666     EXPECT_GE(readDataInfo.realReadLength_, 0);
667 }
668 
669 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_READ_MAX_M3U8, TestSize.Level1)
670 {
671     std::shared_ptr<HlsMediaDownloader> downloader = std::make_shared<HlsMediaDownloader>(10);
672     std::string testUrl = TEST_URI_PATH + "test_cbr/720_1M/video_720_5K.m3u8";
673     auto statusCallback = [] (DownloadStatus&& status, std::shared_ptr<Downloader>& downloader,
__anon1c4b8d1a0e02(DownloadStatus&& status, std::shared_ptr<Downloader>& downloader, std::shared_ptr<DownloadRequest>& request) 674         std::shared_ptr<DownloadRequest>& request) {
675     };
676     downloader->SetStatusCallback(statusCallback);
677     downloader->Open(testUrl, httpHeader);
678     downloader->GetSeekable();
679     downloader->GetStartedStatus();
680     unsigned char buff[10];
681     ReadDataInfo readDataInfo;
682     readDataInfo.streamId_ = 0;
683     readDataInfo.wantReadLength_ = 10;
684     readDataInfo.isEos_ = true;
685     downloader->Read(buff, readDataInfo);
686 
687     OSAL::SleepFor(4 * 1000);
688     downloader->Close(true);
689     downloader = nullptr;
690     EXPECT_GE(readDataInfo.realReadLength_, 0);
691 }
692 
693 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_READ_SelectBR, TestSize.Level1)
694 {
695     std::shared_ptr<HlsMediaDownloader> downloader = std::make_shared<HlsMediaDownloader>("test");
696     std::string testUrl = TEST_URI_PATH + "test_cbr/test_cbr.m3u8";
697     auto statusCallback = [] (DownloadStatus&& status, std::shared_ptr<Downloader>& downloader,
__anon1c4b8d1a0f02(DownloadStatus&& status, std::shared_ptr<Downloader>& downloader, std::shared_ptr<DownloadRequest>& request) 698         std::shared_ptr<DownloadRequest>& request) {
699     };
700     downloader->SetStatusCallback(statusCallback);
701     downloader->Open(testUrl, httpHeader);
702     downloader->GetSeekable();
703     unsigned char buff[10];
704     ReadDataInfo readDataInfo;
705     readDataInfo.streamId_ = 0;
706     readDataInfo.wantReadLength_ = 10;
707     readDataInfo.isEos_ = true;
708     downloader->Read(buff, readDataInfo);
709     downloader->AutoSelectBitrate(1000000);
710 
711     OSAL::SleepFor(4 * 1000);
712     downloader->Close(true);
713     downloader = nullptr;
714     EXPECT_GE(readDataInfo.realReadLength_, 0);
715 }
716 
717 HWTEST_F(HlsMediaDownloaderUnitTest, TEST_WRITE_RINGBUFFER_001, TestSize.Level1)
718 {
719     HlsMediaDownloader *downloader = new HlsMediaDownloader();
720     downloader->OnWriteCacheBuffer(0);
721     downloader->OnWriteCacheBuffer(0);
722     EXPECT_EQ(downloader->bufferedDuration_, 0);
723     EXPECT_EQ(downloader->totalBits_, 0);
724     EXPECT_EQ(downloader->lastWriteBit_, 0);
725 
726     downloader->OnWriteCacheBuffer(1);
727     downloader->OnWriteCacheBuffer(1);
728     EXPECT_EQ(downloader->bufferedDuration_, 16);
729     EXPECT_EQ(downloader->totalBits_, 16);
730     EXPECT_EQ(downloader->lastWriteBit_, 16);
731 
732     downloader->OnWriteCacheBuffer(1000);
733     downloader->OnWriteCacheBuffer(1000);
734     EXPECT_EQ(downloader->bufferedDuration_, 16016);
735     EXPECT_EQ(downloader->totalBits_, 16016);
736     EXPECT_EQ(downloader->lastWriteBit_, 16016);
737     delete downloader;
738     downloader = nullptr;
739 }
740 
741 HWTEST_F(HlsMediaDownloaderUnitTest, RISE_BUFFER_001, TestSize.Level1)
742 {
743     HlsMediaDownloader *downloader = new HlsMediaDownloader();
744     downloader->totalBufferSize_ = MAX_BUFFER_SIZE;
745     downloader->RiseBufferSize();
746     EXPECT_EQ(downloader->totalBufferSize_, MAX_BUFFER_SIZE);
747     delete downloader;
748     downloader = nullptr;
749 }
750 
751 HWTEST_F(HlsMediaDownloaderUnitTest, RISE_BUFFER_002, TestSize.Level1)
752 {
753     HlsMediaDownloader *downloader = new HlsMediaDownloader();
754     downloader->totalBufferSize_ = RING_BUFFER_SIZE;
755     downloader->RiseBufferSize();
756     EXPECT_EQ(downloader->totalBufferSize_, 6 * 1024 * 1024);
757     delete downloader;
758     downloader = nullptr;
759 }
760 
761 HWTEST_F(HlsMediaDownloaderUnitTest, DOWN_BUFFER_001, TestSize.Level1)
762 {
763     HlsMediaDownloader *downloader = new HlsMediaDownloader();
764     downloader->totalBufferSize_ = 10 * 1024 * 1024;
765     downloader->DownBufferSize();
766     EXPECT_EQ(downloader->totalBufferSize_, 9 * 1024 * 1024);
767     delete downloader;
768     downloader = nullptr;
769 }
770 
771 HWTEST_F(HlsMediaDownloaderUnitTest, DOWN_BUFFER_002, TestSize.Level1)
772 {
773     HlsMediaDownloader *downloader = new HlsMediaDownloader();
774     downloader->totalBufferSize_ = RING_BUFFER_SIZE;
775     downloader->DownBufferSize();
776     EXPECT_EQ(downloader->totalBufferSize_, RING_BUFFER_SIZE);
777     delete downloader;
778     downloader = nullptr;
779 }
780 
781 HWTEST_F(HlsMediaDownloaderUnitTest, GET_PLAYBACK_INFO_001, TestSize.Level1)
782 {
783     HlsMediaDownloader *downloader = new HlsMediaDownloader(10);
784     std::string testUrl = TEST_URI_PATH + "test_hls/testHLSEncode.m3u8";
785     downloader->Open(testUrl, httpHeader);
786     PlaybackInfo playbackInfo;
787     downloader->GetPlaybackInfo(playbackInfo);
788     EXPECT_EQ(playbackInfo.serverIpAddress, "");
789     EXPECT_EQ(playbackInfo.averageDownloadRate, 0);
790     EXPECT_EQ(playbackInfo.isDownloading, true);
791     EXPECT_EQ(playbackInfo.downloadRate, 0);
792     EXPECT_EQ(playbackInfo.bufferDuration, 0);
793     delete downloader;
794     downloader = nullptr;
795 }
796 
797 HWTEST_F(HlsMediaDownloaderUnitTest, GET_PLAYBACK_INFO_002, TestSize.Level1)
798 {
799     HlsMediaDownloader *downloader = new HlsMediaDownloader(10);
800     std::string testUrl = TEST_URI_PATH + "test_hls/testHLSEncode.m3u8";
801     downloader->Open(testUrl, httpHeader);
802     downloader->totalDownloadDuringTime_ = 1000;
803     downloader->totalBits_ = 1000;
804     downloader->isDownloadFinish_ = true;
805     std::shared_ptr<HlsMediaDownloader::RecordData> recordBuff = std::make_shared<HlsMediaDownloader::RecordData>();
806     recordBuff->downloadRate = 1000;
807     recordBuff->bufferDuring = 1;
808     recordBuff->next = downloader->recordData_;
809     downloader->recordData_ = recordBuff;
810 
811     PlaybackInfo playbackInfo;
812     downloader->GetPlaybackInfo(playbackInfo);
813     EXPECT_EQ(playbackInfo.serverIpAddress, "");
814     EXPECT_EQ(playbackInfo.averageDownloadRate, 1000);
815     EXPECT_EQ(playbackInfo.isDownloading, false);
816     EXPECT_EQ(playbackInfo.downloadRate, 1000);
817     EXPECT_EQ(playbackInfo.bufferDuration, 0);
818     delete downloader;
819     downloader = nullptr;
820 }
821 
822 }