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 "m3u8_unit_test.h"
16 #include "http_server_demo.h"
17
18 #include <new>
19 #define LOCAL true
20
21 using namespace OHOS;
22 using namespace OHOS::Media;
23 namespace OHOS::Media::Plugins::HttpPlugin {
24 using namespace testing::ext;
25 using namespace std;
26 constexpr uint32_t MAX_LOOP = 16;
27 std::unique_ptr<MediaAVCodec::HttpServerDemo> g_server = nullptr;
SetUpTestCase(void)28 void M3u8UnitTest::SetUpTestCase(void) {}
29
TearDownTestCase(void)30 void M3u8UnitTest::TearDownTestCase(void) {}
31
SetUp(void)32 void M3u8UnitTest::SetUp(void)
33 {
34 g_server = std::make_unique<MediaAVCodec::HttpServerDemo>();
35 g_server->StartServer();
36 }
37
TearDown(void)38 void M3u8UnitTest::TearDown(void)
39 {
40 g_server->StopServer();
41 g_server = nullptr;
42 }
43
44 HWTEST_F(M3u8UnitTest, Init_Tag_Updaters_Map_001, TestSize.Level1)
45 {
46 double duration = testM3u8->GetDuration();
47 bool isLive = testM3u8->IsLive();
48 EXPECT_GE(duration, 0.0);
49 EXPECT_EQ(isLive, false);
50 }
51
52 HWTEST_F(M3u8UnitTest, is_live_001, TestSize.Level1)
53 {
54 EXPECT_EQ(testM3u8->GetDuration(), 0.0);
55 }
56
57 HWTEST_F(M3u8UnitTest, ConstructorTest, TestSize.Level1)
58 {
59 M3U8 m3u8(testUri, testName);
60 // 检查 URI 和名称是否正确设置
61 ASSERT_EQ(m3u8.uri_, testUri);
62 ASSERT_EQ(m3u8.name_, testName);
63 // 这里可以添加更多的断言来检查初始化的状态
64 }
65
66 // 测试 Update 方法
67 HWTEST_F(M3u8UnitTest, UpdateTest, TestSize.Level1)
68 {
69 M3U8 m3u8("http://example.com/test.m3u8", "TestPlaylist");
70 std::string testPlaylist = "#EXTM3U\n#EXT-X-TARGETDURATION:10\n...";
71
72 // 测试有效的播放列表更新
73 EXPECT_TRUE(m3u8.Update(testPlaylist, true));
74
75 // 测试当播放列表不变时的更新
76 EXPECT_TRUE(m3u8.Update(testPlaylist, true));
77
78 // 测试无效的播放列表更新
79 EXPECT_FALSE(m3u8.Update("Invalid Playlist", true));
80 }
81
82 HWTEST_F(M3u8UnitTest, UPDATE_FROM_TAGS_TEST, TestSize.Level1)
83 {
84 M3U8 m3u8("http://example.com/test.m3u8", "TestPlaylist");
85 //
86 std::list<std::shared_ptr<Tag>> tags;
87 m3u8.UpdateFromTags(tags);
88 EXPECT_TRUE(m3u8.bLive_);
89 m3u8.isDecryptAble_ = true;
90 m3u8.UpdateFromTags(tags);
91 //
92 EXPECT_TRUE(m3u8.bLive_);
93 EXPECT_EQ(m3u8.files_.size(), 0);
94 m3u8.isDecryptAble_ = false;
95 m3u8.UpdateFromTags(tags);
96
97 //
98 EXPECT_TRUE(m3u8.bLive_);
99 EXPECT_EQ(m3u8.files_.size(), 0);
100 }
101
102 HWTEST_F(M3u8UnitTest, TEST_CONSTRUCTOR_WITH_NULL_KEY_AND_IV, TestSize.Level1)
103 {
104 M3U8Fragment m3u8("http://example.com", 10.0, 1, false);
105 M3U8Fragment fragment(m3u8, nullptr, nullptr);
106 EXPECT_EQ(fragment.duration_, 10.0);
107 EXPECT_EQ(fragment.sequence_, 1);
108 EXPECT_EQ(fragment.discont_, false);
109 //
110
111 for (int i = 0; i < static_cast<int>(MAX_LOOP); i++) {
112 EXPECT_NE(fragment.iv_[i], -1);
113 EXPECT_NE(fragment.key_[i], -1);
114 }
115 }
116
117 HWTEST_F(M3u8UnitTest, TEST_CONSTRUCTOR_WITH_VALID_KEY_AND_IV, TestSize.Level1)
118 {
119 M3U8Fragment m3u8("http://example.com", 10.0, 1, false);
120 uint8_t key[MAX_LOOP] = {1, 2, 3, 4, 5};
121 uint8_t iv[MAX_LOOP] = {6, 7, 8, 9, 10};
122 M3U8Fragment fragment(m3u8, key, iv);
123 EXPECT_EQ(fragment.uri_, "http://example.com");
124 EXPECT_EQ(fragment.duration_, 10.0);
125 EXPECT_EQ(fragment.sequence_, 1);
126 EXPECT_EQ(fragment.discont_, false);
127 //
128 for (int i = 0; i < 5; i++) {
129 EXPECT_EQ(fragment.iv_[i], iv[i]);
130 }
131 }
132
133 HWTEST_F(M3u8UnitTest, TEST_CONSTRUCTOR, TestSize.Level1)
134 {
135 M3U8 m3u8("http://example.com/test.m3u8", "Test M3U8");
136
137 // check url
138 EXPECT_EQ(m3u8.uri_, "http://example.com/test.m3u8");
139
140 //check name
141 EXPECT_EQ(m3u8.name_, "Test M3U8");
142
143 //check updaters map
144 EXPECT_FALSE(m3u8.tagUpdatersMap_.empty());
145 }
146
147 HWTEST_F(M3u8UnitTest, TEST_EMPTY_URI, TestSize.Level1)
148 {
149 M3U8 m3u8("", "Test M3U8");
150
151 // check url
152 EXPECT_EQ(m3u8.uri_, "");
153
154 //check name
155 EXPECT_EQ(m3u8.name_, "Test M3U8");
156
157 //check updaters map
158 EXPECT_FALSE(m3u8.tagUpdatersMap_.empty());
159 }
160
161 HWTEST_F(M3u8UnitTest, TEST_EMPTY_NAME, TestSize.Level1)
162 {
163 M3U8 m3u8("http://example.com/test.m3u8", "");
164
165 // check url
166 EXPECT_EQ(m3u8.uri_, "http://example.com/test.m3u8");
167
168 //check name
169 EXPECT_EQ(m3u8.name_, "");
170
171 //check updaters map
172 EXPECT_FALSE(m3u8.tagUpdatersMap_.empty());
173 }
174
175 // test get ext
176 HWTEST_F(M3u8UnitTest, GET_EXT_INF_TEST, TestSize.Level1)
177 {
178 M3U8 m3u8("http://example.com/test.m3u8", "");
179 auto tag = std::make_shared<AttributesTag>(HlsTag::EXTXDISCONTINUITY, "123");
180 auto attr1 = std::make_shared<Attribute>("DURATION", "3.5");
181 tag->AddAttribute(attr1);
182 double duration;
183 m3u8.GetExtInf(tag, duration);
184 //check name
185 EXPECT_DOUBLE_EQ(3.5, duration);
186 }
187
188 HWTEST_F(M3u8UnitTest, PARSE_KEY_METHOD_ATTRIBUTE, TestSize.Level1)
189 {
190 M3U8 m3u8("http://example.com/test.m3u8", "");
191 auto tag = std::make_shared<AttributesTag>(HlsTag::EXTXDISCONTINUITY, "123");
192 auto attr1 = std::make_shared<Attribute>("METHOD", "AES-128");
193 tag->AddAttribute(attr1);
194 m3u8.ParseKey(tag);
195 EXPECT_EQ(*m3u8.method_, "AES-128");
196 }
197
198 HWTEST_F(M3u8UnitTest, PARSE_KEY_URI_ATTRIBUTE, TestSize.Level1)
199 {
200 M3U8 m3u8("http://example.com/test.m3u8", "");
201 auto tag = std::make_shared<AttributesTag>(HlsTag::EXTXDISCONTINUITY, "123");
202 auto attr1 = std::make_shared<Attribute>("URI", "http://example.com/key.bin");
203 tag->AddAttribute(attr1);
204 m3u8.ParseKey(tag);
205 EXPECT_EQ(*m3u8.keyUri_, "http://example.com/key.bin");
206 }
207
208 HWTEST_F(M3u8UnitTest, PARSE_KEY_IV_ATTRIBUTE, TestSize.Level1)
209 {
210 M3U8 m3u8("http://example.com/test.m3u8", "");
211 auto tag = std::make_shared<AttributesTag>(HlsTag::EXTXDISCONTINUITY, "123");
212 auto attr1 = std::make_shared<Attribute>("IV", "0x12345678");
213 tag->AddAttribute(attr1);
214 m3u8.ParseKey(tag);
215 uint8_t vec[4] {0x12, 0x34, 0x56, 0x78};
216 EXPECT_NE(m3u8.iv_, vec);
217 }
218
219 HWTEST_F(M3u8UnitTest, PARSE_KEY_NO_ATTRIBUTE, TestSize.Level1)
220 {
221 M3U8 m3u8("http://example.com/test.m3u8", "");
222 auto tag = std::make_shared<AttributesTag>(HlsTag::EXTXDISCONTINUITY, "123");
223 m3u8.ParseKey(tag);
224 EXPECT_EQ(m3u8.method_, nullptr);
225 EXPECT_EQ(m3u8.keyUri_, nullptr);
226 uint8_t vec[4] {0, 0, 0, 0};
227 EXPECT_NE(m3u8.iv_, vec);
228 }
229
230 HWTEST_F(M3u8UnitTest, SAVE_DATA_VALID_DATA, TestSize.Level1)
231 {
232 M3U8 m3u8("http://example.com/test.m3u8", "");
233 uint8_t data[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
234 uint32_t len = 10;
235
236 bool result = m3u8.SaveData(data, len, false);
237
238 EXPECT_TRUE(result);
239 EXPECT_EQ(m3u8.keyLen_, len);
240 EXPECT_TRUE(m3u8.isDecryptKeyReady_);
241 }
242
243 HWTEST_F(M3u8UnitTest, SAVE_DATA_INVALID_DATA, TestSize.Level1)
244 {
245 M3U8 m3u8("http://example.com/test.m3u8", "");
246 uint8_t data[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
247 uint32_t len = 10;
248
249 bool result = m3u8.SaveData(data, len, false);
250
251 EXPECT_TRUE(result);
252 EXPECT_EQ(m3u8.keyLen_, len);
253 EXPECT_TRUE(m3u8.isDecryptKeyReady_);
254 }
255
256 HWTEST_F(M3u8UnitTest, SAVE_DATA_EXVEEDS_MAX_LOOP, TestSize.Level1)
257 {
258 M3U8 m3u8("http://example.com/test.m3u8", "");
259 uint8_t data[MAX_LOOP + 1];
260 uint32_t len = MAX_LOOP + 1;
261
262 bool result = m3u8.SaveData(data, len, false);
263
264 EXPECT_FALSE(result);
265 EXPECT_EQ(m3u8.keyLen_, 0);
266 EXPECT_FALSE(m3u8.isDecryptKeyReady_);
267 }
268
269 HWTEST_F(M3u8UnitTest, SET_DRM_INFO_NULL_KEY_URI, TestSize.Level1)
270 {
271 M3U8 m3u8("http://example.com/test.m3u8", "");
272 std::multimap<std::string, std::vector<uint8_t>> drmInfo;
273 EXPECT_FALSE(m3u8.SetDrmInfo(drmInfo));
274 }
275
276 HWTEST_F(M3u8UnitTest, SET_DRM_INFO_INVALID_KEY_URI, TestSize.Level1)
277 {
278 M3U8 m3u8("http://example.com/test.m3u8", "");
279 m3u8.keyUri_ = std::make_shared<std::string>("invalid");
280 std::multimap<std::string, std::vector<uint8_t>> drmInfo;
281 EXPECT_FALSE(m3u8.SetDrmInfo(drmInfo));
282 }
283
284 HWTEST_F(M3u8UnitTest, SET_DRM_INFO_VALID_KEY_URI, TestSize.Level1)
285 {
286 M3U8 m3u8("http://example.com/test.m3u8", "");
287 m3u8.keyUri_ = std::make_shared<std::string>("base64,valid");
288 std::multimap<std::string, std::vector<uint8_t>> drmInfo;
289 EXPECT_FALSE(m3u8.SetDrmInfo(drmInfo));
290 }
291
292 HWTEST_F(M3u8UnitTest, SET_DRM_INFO_PSSH_SIZE_SMALL, TestSize.Level1)
293 {
294 M3U8 m3u8("http://example.com/test.m3u8", "");
295 m3u8.keyUri_ = std::make_shared<std::string>("base64,valid");
296 std::multimap<std::string, std::vector<uint8_t>> drmInfo;
297 EXPECT_FALSE(m3u8.SetDrmInfo(drmInfo));
298 }
299
300 HWTEST_F(M3u8UnitTest, SET_DRM_INFO_PSSH_SIZE_VALID, TestSize.Level1)
301 {
302 M3U8 m3u8("http://example.com/test.m3u8", "");
303 m3u8.keyUri_ = std::make_shared<std::string>("base64,valid");
304 std::multimap<std::string, std::vector<uint8_t>> drmInfo;
305 EXPECT_FALSE(m3u8.SetDrmInfo(drmInfo));
306 }
307
308 HWTEST_F(M3u8UnitTest, SET_DRM_INFOS, TestSize.Level1)
309 {
310 M3U8 m3u8("http://example.com/test.m3u8", "");
311 std::multimap<std::string, std::vector<uint8_t>> drmInfo;
312
313 // test no DRM info
314 m3u8.StoreDrmInfos(drmInfo);
315 EXPECT_TRUE(m3u8.localDrmInfos_.empty());
316
317 // test new drm info
318 std::vector<uint8_t> pssh = {1, 2, 3, 4, 5};
319 drmInfo.insert(std::make_pair("uuid1", pssh));
320 m3u8.StoreDrmInfos(drmInfo);
321 EXPECT_EQ(1, m3u8.localDrmInfos_.size());
322 EXPECT_EQ(pssh, m3u8.localDrmInfos_.begin()->second);
323
324 // test existed drm info
325 drmInfo.insert(std::make_pair("uuid1", pssh));
326 m3u8.StoreDrmInfos(drmInfo);
327 EXPECT_EQ(1, m3u8.localDrmInfos_.size());
328 EXPECT_EQ(pssh, m3u8.localDrmInfos_.begin()->second);
329
330 // test diff drm info
331 std::vector<uint8_t> pssh2 = {6, 7, 8, 9, 10};
332 drmInfo.insert(std::make_pair("uuid1", pssh2));
333 m3u8.StoreDrmInfos(drmInfo);
334 EXPECT_EQ(2, m3u8.localDrmInfos_.size());
335 EXPECT_EQ(pssh2, (++m3u8.localDrmInfos_.begin())->second);
336 }
337
338 HWTEST_F(M3u8UnitTest, TestPlaylistStartWithEXTM3U, TestSize.Level1)
339 {
340 M3U8MasterPlaylist playlist("#EXTM3U", "uri");
341 playlist.StartParsing();
342 EXPECT_EQ(playlist.playList_, "#EXTM3U");
343 }
344
345 HWTEST_F(M3u8UnitTest, TestPlaylistNotStartWithEXTM3U, TestSize.Level1)
346 {
347 M3U8MasterPlaylist playlist("playlist", "uri");
348 playlist.StartParsing();
349 EXPECT_EQ(playlist.playList_, "playlist");
350 }
351
352 HWTEST_F(M3u8UnitTest, TestPlaylistContainsEXTINF, TestSize.Level1)
353 {
354 M3U8MasterPlaylist playlist("\n#EXTM3U:", "uri");
355 playlist.StartParsing();
356 EXPECT_EQ(playlist.playList_, "\n#EXTM3U:");
357 }
358
359 HWTEST_F(M3u8UnitTest, TestPlaylistNotContainsEXTINF, TestSize.Level1)
360 {
361 M3U8MasterPlaylist playlist("playlist", "uri");
362 playlist.StartParsing();
363 EXPECT_EQ(playlist.playList_, "playlist");
364 }
365
366 HWTEST_F(M3u8UnitTest, UpdateMediaPlaylistTest, TestSize.Level1)
367 {
368 M3U8MasterPlaylist playlist("playlist", "uri");
369 playlist.StartParsing();
370 playlist.UpdateMediaPlaylist();
371
372 // test variants contains new stream
373 EXPECT_EQ(1, playlist.variants_.size());
374
375 // test defaultVariant_ point new stream
376 EXPECT_EQ(playlist.variants_.front(), playlist.defaultVariant_);
377
378 // test duration updated
379 EXPECT_EQ(0, playlist.duration_);
380
381 // test bLive_ updated
382 EXPECT_FALSE(playlist.bLive_);
383
384 // isSimple updated
385 EXPECT_TRUE(playlist.isSimple_);
386 }
387
388 HWTEST_F(M3u8UnitTest, UpdateMasterPlaylist_default, TestSize.Level1)
389 {
390 M3U8MasterPlaylist playlist("test", "http://test.com/test");
391 playlist.StartParsing();
392 playlist.UpdateMediaPlaylist();
393 EXPECT_EQ(playlist.defaultVariant_, playlist.variants_.front());
394 }
395 // 测试 IsLive 方法
396 HWTEST_F(M3u8UnitTest, IS_LIVE_TEST, TestSize.Level1)
397 {
398 M3U8 m3u8(testUri, "LivePlaylist");
399 EXPECT_FALSE(m3u8.IsLive());
400 }
401
402 // 测试 M3U8Fragment 构造函数
403 HWTEST_F(M3u8UnitTest, M3U8FragmentConstructorTest, TestSize.Level1)
404 {
405 double testDuration = 10.0;
406 int testSequence = 1;
407 bool testDiscont = false;
408 M3U8Fragment fragment(testUri, testDuration, testSequence, testDiscont);
409 ASSERT_EQ(fragment.uri_, testUri);
410 ASSERT_DOUBLE_EQ(fragment.duration_, testDuration);
411 ASSERT_EQ(fragment.sequence_, testSequence);
412 ASSERT_EQ(fragment.discont_, testDiscont);
413 }
414
415 HWTEST_F(M3u8UnitTest, ParseKeyTest, TestSize.Level1)
416 {
417 auto attributesTag = std::make_shared<AttributesTag>(HlsTag::EXTINF, "1234");
418 auto uriAttr = std::make_shared<Attribute>("METHOD", "\"SAMPLE-AES\"");
419 attributesTag->AddAttribute(uriAttr);
420 auto uriAttr1 = std::make_shared<Attribute>("URI", "\"https://example.com/key\"");
421 attributesTag->AddAttribute(uriAttr1);
422 auto uriAttr2 = std::make_shared<Attribute>("IV", "\"0123456789ABCDEF\"");
423 attributesTag->AddAttribute(uriAttr2);
424
425 testM3u8->ParseKey(attributesTag);
426
427 // 验证 method_, keyUri_ 和 iv_ 是否正确设置
428 auto testStr = std::make_shared<std::string>("SAMPLE-AES");
429 ASSERT_EQ(*(testM3u8->method_), *testStr);
430 auto testStr1 = std::make_shared<std::string>("https://example.com/key");
431 ASSERT_EQ(*(testM3u8->keyUri_), *testStr1);
432 }
433
434 HWTEST_F(M3u8UnitTest, SaveDataTest, TestSize.Level1)
435 {
436 uint8_t data[] = {0x01, 0x02, 0x03, 0x04};
437 bool result = testM3u8->SaveData(data, sizeof(data), false);
438 ASSERT_TRUE(result);
439
440 // 验证 key_ 成员变量中的数据是否与传入的数据一致
441 for (size_t i = 0; i < sizeof(data); ++i) {
442 ASSERT_EQ(testM3u8->key_[i], data[i]);
443 }
444
445 // 验证 keyLen_ 是否被正确设置
446 ASSERT_EQ(testM3u8->keyLen_, sizeof(data));
447 }
448
449 HWTEST_F(M3u8UnitTest, SetDrmInfoTest, TestSize.Level1)
450 {
451 std::multimap<std::string, std::vector<uint8_t>> drmInfo;
452 // 设置 keyUri_ 为有效的 base64 编码字符串
453 testM3u8->keyUri_ = std::make_shared<std::string>("base64,VALID_BASE64_ENCODED_STRING");
454
455 bool result = testM3u8->SetDrmInfo(drmInfo);
456 ASSERT_FALSE(result);
457 ASSERT_TRUE(drmInfo.empty());
458 // 验证 drmInfo 是否包含预期的 UUID 和解码后的数据
459 }
460
461 HWTEST_F(M3u8UnitTest, StoreDrmInfosTest, TestSize.Level1)
462 {
463 std::multimap<std::string, std::vector<uint8_t>> drmInfo = { { "uuid1", { 1, 2, 3 } }, { "uuid2", { 4, 5, 6 } } };
464 testM3u8->StoreDrmInfos(drmInfo);
465 // 验证 localDrmInfos_ 是否正确包含了 drmInfo 的内容
466 for (const auto &item : drmInfo) {
467 auto range = testM3u8->localDrmInfos_.equal_range(item.first);
468 ASSERT_NE(range.first, testM3u8->localDrmInfos_.end());
469 ASSERT_EQ(range.first->second, item.second);
470 }
471 }
472
473 HWTEST_F(M3u8UnitTest, ProcessDrmInfosTest, TestSize.Level1)
474 {
475 testM3u8->keyUri_ = std::make_shared<std::string>("base64,VALID_BASE64_ENCODED_STRING");
476 testM3u8->ProcessDrmInfos();
477 // 验证 isDecryptAble_ 是否根据 DRM 信息的处理结果正确设置
478 ASSERT_EQ(testM3u8->isDecryptAble_, testM3u8->localDrmInfos_.empty());
479 }
480
481 HWTEST_F(M3u8UnitTest, GetLiveUpdateGap001, TestSize.Level1)
482 {
483 M3U8 m3u8(testUri, "");
484 size_t time = m3u8.GetLiveUpdateGap();
485 EXPECT_EQ(0, time);
486 m3u8.minFragDuration_ = 1;
487 time = m3u8.GetLiveUpdateGap();
488 EXPECT_EQ(0, time);
489 }
490
491 HWTEST_F(M3u8UnitTest, UPDATE_MEDIA_PLAYLIST_001, TestSize.Level1)
492 {
493 std::shared_ptr<M3U8MasterPlaylist> master = std::make_shared<M3U8MasterPlaylist>("", "https://example.com/key");
494 master->StartParsing();
495 master->isDecryptAble_ = true;
496 master->keyLen_ = 1;
497 master->UpdateMediaPlaylist();
498 EXPECT_EQ(master->isSimple_, true);
499 }
500
501 HWTEST_F(M3u8UnitTest, CHOOSE_STREAM_BY_RESOLUTION_001, TestSize.Level1)
502 {
503 std::shared_ptr<M3U8MasterPlaylist> master = std::make_shared<M3U8MasterPlaylist>("", "https://example.com/key");
504 master->StartParsing();
505 auto stream = std::make_shared<M3U8VariantStream>("test", "https://example.com/key",
506 std::make_shared<M3U8>("https://example.com/key", "test"));
507 stream->bandWidth_ = 1000;
508 stream->width_ = 480;
509 stream->height_ = 640;
510 master->variants_.emplace_back(stream);
511 master->variants_.emplace_back(nullptr);
512 auto stream1 = std::make_shared<M3U8VariantStream>("test", "https://example.com/key",
513 std::make_shared<M3U8>("https://example.com/key", "test"));
514 stream1->bandWidth_ = 2000;
515 stream1->width_ = 480;
516 stream1->height_ = 640;
517 master->variants_.emplace_back(stream1);
518 auto stream2 = std::make_shared<M3U8VariantStream>("test", "https://example.com/key",
519 std::make_shared<M3U8>("https://example.com/key", "test"));
520 stream2->bandWidth_ = 2000;
521 stream2->width_ = 720;
522 stream2->height_ = 1080;
523 master->variants_.emplace_back(stream2);
524 auto stream4 = std::make_shared<M3U8VariantStream>("test", "https://example.com/key",
525 std::make_shared<M3U8>("https://example.com/key", "test"));
526 stream4->bandWidth_ = 3000;
527 stream4->width_ = 720;
528 stream4->height_ = 1080;
529 master->variants_.emplace_back(stream4);
530 auto stream5 = std::make_shared<M3U8VariantStream>("test", "https://example.com/key",
531 std::make_shared<M3U8>("https://example.com/key", "test"));
532 stream4->bandWidth_ = 3000;
533 stream4->width_ = 1080;
534 stream4->height_ = 1920;
535 master->variants_.emplace_back(stream4);
536 master->defaultVariant_ = stream;
537 master->ChooseStreamByResolution();
538 uint32_t resolution = 480 * 720;
539 master->initResolution_ = resolution;
540 master->ChooseStreamByResolution();
541 resolution = 720 * 1080;
542 master->initResolution_ = resolution;
543 master->ChooseStreamByResolution();
544 resolution = 1080 * 1920;
545 master->initResolution_ = resolution;
546 master->ChooseStreamByResolution();
547 EXPECT_EQ(master->defaultVariant_->width_, 1080);
548 EXPECT_EQ(master->defaultVariant_->height_, 1920);
549 }
550
551 HWTEST_F(M3u8UnitTest, DOWNLOAD_STATUS_001, TestSize.Level1)
552 {
553 M3U8 m3u8(testUri, "");
554 std::shared_ptr<Downloader> downloader = std::make_shared<Downloader>("hlsPlayList");
555 std::shared_ptr<DownloadRequest> request = std::make_shared<DownloadRequest>("", nullptr, nullptr, false);
556 m3u8.OnDownloadStatus(DownloadStatus::PARTTAL_DOWNLOAD, downloader, request);
557 request->clientError_ = 52;
558 m3u8.OnDownloadStatus(DownloadStatus::PARTTAL_DOWNLOAD, downloader, request);
559 request->serverError_ = 403;
560 m3u8.OnDownloadStatus(DownloadStatus::PARTTAL_DOWNLOAD, downloader, request);
561 request->clientError_ = 0;
562 m3u8.OnDownloadStatus(DownloadStatus::PARTTAL_DOWNLOAD, downloader, request);
563 EXPECT_EQ(request->serverError_, 403);
564 }
565
566 HWTEST_F(M3u8UnitTest, PARSE_MAP_001, TestSize.Level1)
567 {
568 std::shared_ptr<AttributesTag> tag =
569 std::make_shared<AttributesTag>(HlsTag::EXTXMAP, "#EXT-X-MAP:URI=\"main.mp4\",BYTERANGE=\"718@0\"");
570 M3U8 m3u8(testUri, "");
571 m3u8.isInterruptNeeded_ = true;
572 m3u8.isHeaderReady_ = false;
573 m3u8.ParseMap(tag);
574 EXPECT_NE(m3u8.fmp4Header_, nullptr);
575
576 M3U8 m3u81(testUri, "");
577 m3u81.isHeaderReady_ = true;
578 m3u81.ParseMap(tag);
579 EXPECT_EQ(m3u81.fmp4Header_, nullptr);
580
581 std::shared_ptr<AttributesTag> tag2 = std::make_shared<AttributesTag>(HlsTag::EXTXMAP, "#EXT-X-MAP:");
582 M3U8 m3u82(testUri, "");
583 m3u82.ParseMap(tag2);
584 EXPECT_EQ(m3u82.fmp4Header_, nullptr);
585 }
586
587 HWTEST_F(M3u8UnitTest, IS_NEAR_TO_INIT_RESOLUTION_001, TestSize.Level1)
588 {
589 std::shared_ptr<M3U8MasterPlaylist> master = std::make_shared<M3U8MasterPlaylist>("", "https://example.com/key");
590 master->StartParsing();
591 auto m3u8 = std::make_shared<M3U8>(testUri, "");
592 auto choosedStream = std::make_shared<M3U8VariantStream>(testUri, testUri, m3u8);
593 auto currentStream = std::make_shared<M3U8VariantStream>(testUri, testUri, m3u8);
594 EXPECT_EQ(master->IsNearToInitResolution(choosedStream, currentStream), false);
595 EXPECT_EQ(master->IsNearToInitResolution(choosedStream, nullptr), false);
596 EXPECT_EQ(master->IsNearToInitResolution(nullptr, nullptr), false);
597 }
598
599 HWTEST_F(M3u8UnitTest, SetInterruptState_001, TestSize.Level1)
600 {
601 std::string url = "http://example.com/test.m3u8";
602 auto m3u8 = std::make_shared<M3U8>(testUri, "");
603 m3u8->uri_ = url;
604 m3u8->keyUri_ = std::make_shared<std::string>(url);
605 m3u8->DownloadKey();
606 m3u8->DownloadMap(url, 0, 0);
607 EXPECT_NE(m3u8->downloadHeaderRequest_, nullptr);
608 EXPECT_NE(m3u8->downloadRequest_, nullptr);
609 std::shared_ptr<M3U8MasterPlaylist> master = std::make_shared<M3U8MasterPlaylist>("", url);
610 master->StartParsing();
611 auto stream = std::make_shared<M3U8VariantStream>("test", url,
612 std::make_shared<M3U8>(url, "test"));
613 master->defaultVariant_ = stream;
614 master->defaultVariant_->m3u8_ = nullptr;
615 master->SetInterruptState(true);
616 EXPECT_NE(master->defaultVariant_, nullptr);
617 master->defaultVariant_ = nullptr;
618 master->SetInterruptState(true);
619 EXPECT_EQ(master->defaultVariant_, nullptr);
620 }
621 }