summaryrefslogtreecommitdiffstats
path: root/xbmc/utils/test/TestHttpRangeUtils.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'xbmc/utils/test/TestHttpRangeUtils.cpp')
-rw-r--r--xbmc/utils/test/TestHttpRangeUtils.cpp887
1 files changed, 887 insertions, 0 deletions
diff --git a/xbmc/utils/test/TestHttpRangeUtils.cpp b/xbmc/utils/test/TestHttpRangeUtils.cpp
new file mode 100644
index 0000000..f988f10
--- /dev/null
+++ b/xbmc/utils/test/TestHttpRangeUtils.cpp
@@ -0,0 +1,887 @@
1/*
2 * Copyright (C) 2015-2018 Team Kodi
3 * This file is part of Kodi - https://kodi.tv
4 *
5 * SPDX-License-Identifier: GPL-2.0-or-later
6 * See LICENSES/README.md for more information.
7 */
8
9#include "utils/HttpRangeUtils.h"
10
11#include <gtest/gtest.h>
12
13#define RANGES_START "bytes="
14
15static const uint64_t DefaultFirstPosition = 1;
16static const uint64_t DefaultLastPosition = 0;
17static const uint64_t DefaultLength = 0;
18static const void* DefaultData = NULL;
19
20TEST(TestHttpRange, FirstPosition)
21{
22 const uint64_t expectedFirstPosition = 25;
23
24 CHttpRange range;
25 EXPECT_EQ(DefaultFirstPosition, range.GetFirstPosition());
26
27 range.SetFirstPosition(expectedFirstPosition);
28 EXPECT_EQ(expectedFirstPosition, range.GetFirstPosition());
29}
30
31TEST(TestHttpRange, LastPosition)
32{
33 const uint64_t expectedLastPosition = 25;
34
35 CHttpRange range;
36 EXPECT_EQ(DefaultLastPosition, range.GetLastPosition());
37
38 range.SetLastPosition(expectedLastPosition);
39 EXPECT_EQ(expectedLastPosition, range.GetLastPosition());
40}
41
42TEST(TestHttpRange, Length)
43{
44 const uint64_t expectedFirstPosition = 10;
45 const uint64_t expectedLastPosition = 25;
46 const uint64_t expectedLength = expectedLastPosition - expectedFirstPosition + 1;
47
48 CHttpRange range;
49 EXPECT_EQ(DefaultLength, range.GetLength());
50
51 range.SetFirstPosition(expectedFirstPosition);
52 range.SetLastPosition(expectedLastPosition);
53 EXPECT_EQ(expectedLength, range.GetLength());
54
55 CHttpRange range_length;
56 range.SetFirstPosition(expectedFirstPosition);
57 range.SetLength(expectedLength);
58 EXPECT_EQ(expectedLastPosition, range.GetLastPosition());
59 EXPECT_EQ(expectedLength, range.GetLength());
60}
61
62TEST(TestHttpRange, IsValid)
63{
64 const uint64_t validFirstPosition = 10;
65 const uint64_t validLastPosition = 25;
66 const uint64_t invalidLastPosition = 5;
67
68 CHttpRange range;
69 EXPECT_FALSE(range.IsValid());
70
71 range.SetFirstPosition(validFirstPosition);
72 EXPECT_FALSE(range.IsValid());
73
74 range.SetLastPosition(invalidLastPosition);
75 EXPECT_FALSE(range.IsValid());
76
77 range.SetLastPosition(validLastPosition);
78 EXPECT_TRUE(range.IsValid());
79}
80
81TEST(TestHttpRange, Ctor)
82{
83 const uint64_t validFirstPosition = 10;
84 const uint64_t validLastPosition = 25;
85 const uint64_t invalidLastPosition = 5;
86 const uint64_t validLength = validLastPosition - validFirstPosition + 1;
87
88 CHttpRange range_invalid(validFirstPosition, invalidLastPosition);
89 EXPECT_EQ(validFirstPosition, range_invalid.GetFirstPosition());
90 EXPECT_EQ(invalidLastPosition, range_invalid.GetLastPosition());
91 EXPECT_EQ(DefaultLength, range_invalid.GetLength());
92 EXPECT_FALSE(range_invalid.IsValid());
93
94 CHttpRange range_valid(validFirstPosition, validLastPosition);
95 EXPECT_EQ(validFirstPosition, range_valid.GetFirstPosition());
96 EXPECT_EQ(validLastPosition, range_valid.GetLastPosition());
97 EXPECT_EQ(validLength, range_valid.GetLength());
98 EXPECT_TRUE(range_valid.IsValid());
99}
100
101TEST(TestHttpResponseRange, SetData)
102{
103 const uint64_t validFirstPosition = 1;
104 const uint64_t validLastPosition = 2;
105 const uint64_t validLength = validLastPosition - validFirstPosition + 1;
106 const char* validData = "test";
107 const void* invalidData = DefaultData;
108 const size_t validDataLength = strlen(validData);
109 const size_t invalidDataLength = 1;
110
111 CHttpResponseRange range;
112 EXPECT_EQ(DefaultData, range.GetData());
113 EXPECT_FALSE(range.IsValid());
114
115 range.SetData(invalidData);
116 EXPECT_EQ(invalidData, range.GetData());
117 EXPECT_FALSE(range.IsValid());
118
119 range.SetData(validData);
120 EXPECT_EQ(validData, range.GetData());
121 EXPECT_FALSE(range.IsValid());
122
123 range.SetData(invalidData, 0);
124 EXPECT_EQ(validData, range.GetData());
125 EXPECT_FALSE(range.IsValid());
126
127 range.SetData(invalidData, invalidDataLength);
128 EXPECT_EQ(invalidData, range.GetData());
129 EXPECT_FALSE(range.IsValid());
130
131 range.SetData(validData, validDataLength);
132 EXPECT_EQ(validData, range.GetData());
133 EXPECT_EQ(0U, range.GetFirstPosition());
134 EXPECT_EQ(validDataLength - 1, range.GetLastPosition());
135 EXPECT_EQ(validDataLength, range.GetLength());
136 EXPECT_TRUE(range.IsValid());
137
138 range.SetData(invalidData, 0, 0);
139 EXPECT_EQ(invalidData, range.GetData());
140 EXPECT_FALSE(range.IsValid());
141
142 range.SetData(validData, validFirstPosition, validLastPosition);
143 EXPECT_EQ(validData, range.GetData());
144 EXPECT_EQ(validFirstPosition, range.GetFirstPosition());
145 EXPECT_EQ(validLastPosition, range.GetLastPosition());
146 EXPECT_EQ(validLength, range.GetLength());
147 EXPECT_TRUE(range.IsValid());
148}
149
150TEST(TestHttpRanges, Ctor)
151{
152 CHttpRange range;
153 uint64_t position;
154
155 CHttpRanges ranges_empty;
156
157 EXPECT_EQ(0U, ranges_empty.Size());
158 EXPECT_TRUE(ranges_empty.Get().empty());
159
160 EXPECT_FALSE(ranges_empty.Get(0, range));
161 EXPECT_FALSE(ranges_empty.GetFirst(range));
162 EXPECT_FALSE(ranges_empty.GetLast(range));
163
164 EXPECT_FALSE(ranges_empty.GetFirstPosition(position));
165 EXPECT_FALSE(ranges_empty.GetLastPosition(position));
166 EXPECT_EQ(0U, ranges_empty.GetLength());
167 EXPECT_FALSE(ranges_empty.GetTotalRange(range));
168}
169
170TEST(TestHttpRanges, GetAll)
171{
172 CHttpRange range_0(0, 2);
173 CHttpRange range_1(4, 6);
174 CHttpRange range_2(8, 10);
175
176 HttpRanges ranges_raw;
177 ranges_raw.push_back(range_0);
178 ranges_raw.push_back(range_1);
179 ranges_raw.push_back(range_2);
180
181 CHttpRanges ranges(ranges_raw);
182
183 const HttpRanges& ranges_raw_get = ranges.Get();
184 ASSERT_EQ(ranges_raw.size(), ranges_raw_get.size());
185
186 for (size_t i = 0; i < ranges_raw.size(); ++i)
187 EXPECT_EQ(ranges_raw.at(i), ranges_raw_get.at(i));
188}
189
190TEST(TestHttpRanges, GetIndex)
191{
192 CHttpRange range_0(0, 2);
193 CHttpRange range_1(4, 6);
194 CHttpRange range_2(8, 10);
195
196 HttpRanges ranges_raw;
197 ranges_raw.push_back(range_0);
198 ranges_raw.push_back(range_1);
199 ranges_raw.push_back(range_2);
200
201 CHttpRanges ranges(ranges_raw);
202
203 CHttpRange range;
204 EXPECT_TRUE(ranges.Get(0, range));
205 EXPECT_EQ(range_0, range);
206
207 EXPECT_TRUE(ranges.Get(1, range));
208 EXPECT_EQ(range_1, range);
209
210 EXPECT_TRUE(ranges.Get(2, range));
211 EXPECT_EQ(range_2, range);
212
213 EXPECT_FALSE(ranges.Get(3, range));
214}
215
216TEST(TestHttpRanges, GetFirst)
217{
218 CHttpRange range_0(0, 2);
219 CHttpRange range_1(4, 6);
220 CHttpRange range_2(8, 10);
221
222 HttpRanges ranges_raw;
223 ranges_raw.push_back(range_0);
224 ranges_raw.push_back(range_1);
225 ranges_raw.push_back(range_2);
226
227 CHttpRanges ranges(ranges_raw);
228
229 CHttpRange range;
230 EXPECT_TRUE(ranges.GetFirst(range));
231 EXPECT_EQ(range_0, range);
232}
233
234TEST(TestHttpRanges, GetLast)
235{
236 CHttpRange range_0(0, 2);
237 CHttpRange range_1(4, 6);
238 CHttpRange range_2(8, 10);
239
240 HttpRanges ranges_raw;
241 ranges_raw.push_back(range_0);
242 ranges_raw.push_back(range_1);
243 ranges_raw.push_back(range_2);
244
245 CHttpRanges ranges(ranges_raw);
246
247 CHttpRange range;
248 EXPECT_TRUE(ranges.GetLast(range));
249 EXPECT_EQ(range_2, range);
250}
251
252TEST(TestHttpRanges, Size)
253{
254 CHttpRange range_0(0, 2);
255 CHttpRange range_1(4, 6);
256 CHttpRange range_2(8, 10);
257
258 HttpRanges ranges_raw;
259 ranges_raw.push_back(range_0);
260 ranges_raw.push_back(range_1);
261 ranges_raw.push_back(range_2);
262
263 CHttpRanges ranges_empty;
264 EXPECT_EQ(0U, ranges_empty.Size());
265
266 CHttpRanges ranges(ranges_raw);
267 EXPECT_EQ(ranges_raw.size(), ranges.Size());
268}
269
270TEST(TestHttpRanges, GetFirstPosition)
271{
272 CHttpRange range_0(0, 2);
273 CHttpRange range_1(4, 6);
274 CHttpRange range_2(8, 10);
275
276 HttpRanges ranges_raw;
277 ranges_raw.push_back(range_0);
278 ranges_raw.push_back(range_1);
279 ranges_raw.push_back(range_2);
280
281 CHttpRanges ranges(ranges_raw);
282
283 uint64_t position;
284 EXPECT_TRUE(ranges.GetFirstPosition(position));
285 EXPECT_EQ(range_0.GetFirstPosition(), position);
286}
287
288TEST(TestHttpRanges, GetLastPosition)
289{
290 CHttpRange range_0(0, 2);
291 CHttpRange range_1(4, 6);
292 CHttpRange range_2(8, 10);
293
294 HttpRanges ranges_raw;
295 ranges_raw.push_back(range_0);
296 ranges_raw.push_back(range_1);
297 ranges_raw.push_back(range_2);
298
299 CHttpRanges ranges(ranges_raw);
300
301 uint64_t position;
302 EXPECT_TRUE(ranges.GetLastPosition(position));
303 EXPECT_EQ(range_2.GetLastPosition(), position);
304}
305
306TEST(TestHttpRanges, GetLength)
307{
308 CHttpRange range_0(0, 2);
309 CHttpRange range_1(4, 6);
310 CHttpRange range_2(8, 10);
311 const uint64_t expectedLength = range_0.GetLength() + range_1.GetLength() + range_2.GetLength();
312
313 HttpRanges ranges_raw;
314 ranges_raw.push_back(range_0);
315 ranges_raw.push_back(range_1);
316 ranges_raw.push_back(range_2);
317
318 CHttpRanges ranges(ranges_raw);
319
320 EXPECT_EQ(expectedLength, ranges.GetLength());
321}
322
323TEST(TestHttpRanges, GetTotalRange)
324{
325 CHttpRange range_0(0, 2);
326 CHttpRange range_1(4, 6);
327 CHttpRange range_2(8, 10);
328 CHttpRange range_total_expected(range_0.GetFirstPosition(), range_2.GetLastPosition());
329
330 HttpRanges ranges_raw;
331 ranges_raw.push_back(range_0);
332 ranges_raw.push_back(range_1);
333 ranges_raw.push_back(range_2);
334
335 CHttpRanges ranges(ranges_raw);
336
337 CHttpRange range_total;
338 EXPECT_TRUE(ranges.GetTotalRange(range_total));
339 EXPECT_EQ(range_total_expected, range_total);
340}
341
342TEST(TestHttpRanges, Add)
343{
344 CHttpRange range_0(0, 2);
345 CHttpRange range_1(4, 6);
346 CHttpRange range_2(8, 10);
347
348 CHttpRanges ranges;
349 CHttpRange range;
350
351 ranges.Add(range_0);
352 EXPECT_EQ(1U, ranges.Size());
353 EXPECT_TRUE(ranges.GetFirst(range));
354 EXPECT_EQ(range_0, range);
355 EXPECT_TRUE(ranges.GetLast(range));
356 EXPECT_EQ(range_0, range);
357
358 ranges.Add(range_1);
359 EXPECT_EQ(2U, ranges.Size());
360 EXPECT_TRUE(ranges.GetFirst(range));
361 EXPECT_EQ(range_0, range);
362 EXPECT_TRUE(ranges.GetLast(range));
363 EXPECT_EQ(range_1, range);
364
365 ranges.Add(range_2);
366 EXPECT_EQ(3U, ranges.Size());
367 EXPECT_TRUE(ranges.GetFirst(range));
368 EXPECT_EQ(range_0, range);
369 EXPECT_TRUE(ranges.GetLast(range));
370 EXPECT_EQ(range_2, range);
371}
372
373TEST(TestHttpRanges, Remove)
374{
375 CHttpRange range_0(0, 2);
376 CHttpRange range_1(4, 6);
377 CHttpRange range_2(8, 10);
378
379 HttpRanges ranges_raw;
380 ranges_raw.push_back(range_0);
381 ranges_raw.push_back(range_1);
382 ranges_raw.push_back(range_2);
383
384 CHttpRanges ranges(ranges_raw);
385
386 CHttpRange range;
387 EXPECT_EQ(3U, ranges.Size());
388 EXPECT_TRUE(ranges.Get(0, range));
389 EXPECT_EQ(range_0, range);
390 EXPECT_TRUE(ranges.Get(1, range));
391 EXPECT_EQ(range_1, range);
392 EXPECT_TRUE(ranges.Get(2, range));
393 EXPECT_EQ(range_2, range);
394
395 // remove non-existing range
396 ranges.Remove(ranges.Size());
397 EXPECT_EQ(3U, ranges.Size());
398 EXPECT_TRUE(ranges.Get(0, range));
399 EXPECT_EQ(range_0, range);
400 EXPECT_TRUE(ranges.Get(1, range));
401 EXPECT_EQ(range_1, range);
402 EXPECT_TRUE(ranges.Get(2, range));
403 EXPECT_EQ(range_2, range);
404
405 // remove first range
406 ranges.Remove(0);
407 EXPECT_EQ(2U, ranges.Size());
408 EXPECT_TRUE(ranges.Get(0, range));
409 EXPECT_EQ(range_1, range);
410 EXPECT_TRUE(ranges.Get(1, range));
411 EXPECT_EQ(range_2, range);
412
413 // remove last range
414 ranges.Remove(1);
415 EXPECT_EQ(1U, ranges.Size());
416 EXPECT_TRUE(ranges.Get(0, range));
417 EXPECT_EQ(range_1, range);
418
419 // remove remaining range
420 ranges.Remove(0);
421 EXPECT_EQ(0U, ranges.Size());
422}
423
424TEST(TestHttpRanges, Clear)
425{
426 CHttpRange range_0(0, 2);
427 CHttpRange range_1(4, 6);
428 CHttpRange range_2(8, 10);
429
430 HttpRanges ranges_raw;
431 ranges_raw.push_back(range_0);
432 ranges_raw.push_back(range_1);
433 ranges_raw.push_back(range_2);
434
435 CHttpRanges ranges(ranges_raw);
436
437 CHttpRange range;
438 EXPECT_EQ(3U, ranges.Size());
439 EXPECT_TRUE(ranges.Get(0, range));
440 EXPECT_EQ(range_0, range);
441 EXPECT_TRUE(ranges.Get(1, range));
442 EXPECT_EQ(range_1, range);
443 EXPECT_TRUE(ranges.Get(2, range));
444 EXPECT_EQ(range_2, range);
445
446 ranges.Clear();
447 EXPECT_EQ(0U, ranges.Size());
448}
449
450TEST(TestHttpRanges, ParseInvalid)
451{
452 CHttpRanges ranges;
453
454 // combinations of invalid string and invalid total length
455 EXPECT_FALSE(ranges.Parse(""));
456 EXPECT_FALSE(ranges.Parse("", 0));
457 EXPECT_FALSE(ranges.Parse("", 1));
458 EXPECT_FALSE(ranges.Parse("test", 0));
459 EXPECT_FALSE(ranges.Parse(RANGES_START, 0));
460
461 // empty range definition
462 EXPECT_FALSE(ranges.Parse(RANGES_START));
463 EXPECT_FALSE(ranges.Parse(RANGES_START "-"));
464
465 // bad characters in range definition
466 EXPECT_FALSE(ranges.Parse(RANGES_START "a"));
467 EXPECT_FALSE(ranges.Parse(RANGES_START "1a"));
468 EXPECT_FALSE(ranges.Parse(RANGES_START "1-a"));
469 EXPECT_FALSE(ranges.Parse(RANGES_START "a-a"));
470 EXPECT_FALSE(ranges.Parse(RANGES_START "a-1"));
471 EXPECT_FALSE(ranges.Parse(RANGES_START "--"));
472 EXPECT_FALSE(ranges.Parse(RANGES_START "1--"));
473 EXPECT_FALSE(ranges.Parse(RANGES_START "1--2"));
474 EXPECT_FALSE(ranges.Parse(RANGES_START "--2"));
475
476 // combination of valid and empty range definitions
477 EXPECT_FALSE(ranges.Parse(RANGES_START "0-1,"));
478 EXPECT_FALSE(ranges.Parse(RANGES_START ",0-1"));
479
480 // too big start position
481 EXPECT_FALSE(ranges.Parse(RANGES_START "10-11", 5));
482
483 // end position smaller than start position
484 EXPECT_FALSE(ranges.Parse(RANGES_START "1-0"));
485}
486
487TEST(TestHttpRanges, ParseStartOnly)
488{
489 const uint64_t totalLength = 5;
490 const CHttpRange range0_(0, totalLength - 1);
491 const CHttpRange range2_(2, totalLength - 1);
492
493 CHttpRange range;
494
495 CHttpRanges ranges_all;
496 EXPECT_TRUE(ranges_all.Parse(RANGES_START "0-", totalLength));
497 EXPECT_EQ(1U, ranges_all.Size());
498 EXPECT_TRUE(ranges_all.Get(0, range));
499 EXPECT_EQ(range0_, range);
500
501 CHttpRanges ranges_some;
502 EXPECT_TRUE(ranges_some.Parse(RANGES_START "2-", totalLength));
503 EXPECT_EQ(1U, ranges_some.Size());
504 EXPECT_TRUE(ranges_some.Get(0, range));
505 EXPECT_EQ(range2_, range);
506}
507
508TEST(TestHttpRanges, ParseFromEnd)
509{
510 const uint64_t totalLength = 5;
511 const CHttpRange range_1(totalLength - 1, totalLength - 1);
512 const CHttpRange range_3(totalLength - 3, totalLength - 1);
513
514 CHttpRange range;
515
516 CHttpRanges ranges_1;
517 EXPECT_TRUE(ranges_1.Parse(RANGES_START "-1", totalLength));
518 EXPECT_EQ(1U, ranges_1.Size());
519 EXPECT_TRUE(ranges_1.Get(0, range));
520 EXPECT_EQ(range_1, range);
521
522 CHttpRanges ranges_3;
523 EXPECT_TRUE(ranges_3.Parse(RANGES_START "-3", totalLength));
524 EXPECT_EQ(1U, ranges_3.Size());
525 EXPECT_TRUE(ranges_3.Get(0, range));
526 EXPECT_EQ(range_3, range);
527}
528
529TEST(TestHttpRanges, ParseSingle)
530{
531 const uint64_t totalLength = 5;
532 const CHttpRange range0_0(0, 0);
533 const CHttpRange range0_1(0, 1);
534 const CHttpRange range0_5(0, totalLength - 1);
535 const CHttpRange range1_1(1, 1);
536 const CHttpRange range1_3(1, 3);
537 const CHttpRange range3_4(3, 4);
538 const CHttpRange range4_4(4, 4);
539
540 CHttpRange range;
541
542 CHttpRanges ranges;
543 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0", totalLength));
544 EXPECT_EQ(1U, ranges.Size());
545 EXPECT_TRUE(ranges.Get(0, range));
546 EXPECT_EQ(range0_0, range);
547
548 EXPECT_TRUE(ranges.Parse(RANGES_START "0-1", totalLength));
549 EXPECT_EQ(1U, ranges.Size());
550 EXPECT_TRUE(ranges.Get(0, range));
551 EXPECT_EQ(range0_1, range);
552
553 EXPECT_TRUE(ranges.Parse(RANGES_START "0-5", totalLength));
554 EXPECT_EQ(1U, ranges.Size());
555 EXPECT_TRUE(ranges.Get(0, range));
556 EXPECT_EQ(range0_5, range);
557
558 EXPECT_TRUE(ranges.Parse(RANGES_START "1-1", totalLength));
559 EXPECT_EQ(1U, ranges.Size());
560 EXPECT_TRUE(ranges.Get(0, range));
561 EXPECT_EQ(range1_1, range);
562
563 EXPECT_TRUE(ranges.Parse(RANGES_START "1-3", totalLength));
564 EXPECT_EQ(1U, ranges.Size());
565 EXPECT_TRUE(ranges.Get(0, range));
566 EXPECT_EQ(range1_3, range);
567
568 EXPECT_TRUE(ranges.Parse(RANGES_START "3-4", totalLength));
569 EXPECT_EQ(1U, ranges.Size());
570 EXPECT_TRUE(ranges.Get(0, range));
571 EXPECT_EQ(range3_4, range);
572
573 EXPECT_TRUE(ranges.Parse(RANGES_START "4-4", totalLength));
574 EXPECT_EQ(1U, ranges.Size());
575 EXPECT_TRUE(ranges.Get(0, range));
576 EXPECT_EQ(range4_4, range);
577}
578
579TEST(TestHttpRanges, ParseMulti)
580{
581 const uint64_t totalLength = 6;
582 const CHttpRange range0_0(0, 0);
583 const CHttpRange range0_1(0, 1);
584 const CHttpRange range1_3(1, 3);
585 const CHttpRange range2_2(2, 2);
586 const CHttpRange range4_5(4, 5);
587 const CHttpRange range5_5(5, 5);
588
589 CHttpRange range;
590
591 CHttpRanges ranges;
592 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0,2-2", totalLength));
593 EXPECT_EQ(2U, ranges.Size());
594 EXPECT_TRUE(ranges.Get(0, range));
595 EXPECT_EQ(range0_0, range);
596 EXPECT_TRUE(ranges.Get(1, range));
597 EXPECT_EQ(range2_2, range);
598
599 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0,2-2,4-5", totalLength));
600 EXPECT_EQ(3U, ranges.Size());
601 EXPECT_TRUE(ranges.Get(0, range));
602 EXPECT_EQ(range0_0, range);
603 EXPECT_TRUE(ranges.Get(1, range));
604 EXPECT_EQ(range2_2, range);
605 EXPECT_TRUE(ranges.Get(2, range));
606 EXPECT_EQ(range4_5, range);
607
608 EXPECT_TRUE(ranges.Parse(RANGES_START "0-1,5-5", totalLength));
609 EXPECT_EQ(2U, ranges.Size());
610 EXPECT_TRUE(ranges.Get(0, range));
611 EXPECT_EQ(range0_1, range);
612 EXPECT_TRUE(ranges.Get(1, range));
613 EXPECT_EQ(range5_5, range);
614
615 EXPECT_TRUE(ranges.Parse(RANGES_START "1-3,5-5", totalLength));
616 EXPECT_EQ(2U, ranges.Size());
617 EXPECT_TRUE(ranges.Get(0, range));
618 EXPECT_EQ(range1_3, range);
619 EXPECT_TRUE(ranges.Get(1, range));
620 EXPECT_EQ(range5_5, range);
621}
622
623TEST(TestHttpRanges, ParseOrderedNotOverlapping)
624{
625 const uint64_t totalLength = 5;
626 const CHttpRange range0_0(0, 0);
627 const CHttpRange range0_1(0, 1);
628 const CHttpRange range2_2(2, 2);
629 const CHttpRange range2_(2, totalLength - 1);
630 const CHttpRange range_1(totalLength - 1, totalLength - 1);
631
632 CHttpRange range;
633
634 CHttpRanges ranges;
635 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0,-1", totalLength));
636 EXPECT_EQ(2U, ranges.Size());
637 EXPECT_TRUE(ranges.Get(0, range));
638 EXPECT_EQ(range0_0, range);
639 EXPECT_TRUE(ranges.Get(1, range));
640 EXPECT_EQ(range_1, range);
641
642 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0,2-2,-1", totalLength));
643 EXPECT_EQ(3U, ranges.Size());
644 EXPECT_TRUE(ranges.Get(0, range));
645 EXPECT_EQ(range0_0, range);
646 EXPECT_TRUE(ranges.Get(1, range));
647 EXPECT_EQ(range2_2, range);
648 EXPECT_TRUE(ranges.Get(2, range));
649 EXPECT_EQ(range_1, range);
650
651 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0,2-", totalLength));
652 EXPECT_EQ(2U, ranges.Size());
653 EXPECT_TRUE(ranges.Get(0, range));
654 EXPECT_EQ(range0_0, range);
655 EXPECT_TRUE(ranges.Get(1, range));
656 EXPECT_EQ(range2_, range);
657}
658
659TEST(TestHttpRanges, ParseOrderedBackToBack)
660{
661 const uint64_t totalLength = 5;
662 const CHttpRange range0_1(0, 1);
663 const CHttpRange range0_2(0, 2);
664 const CHttpRange range1_2(1, 2);
665 const CHttpRange range0_3(0, 3);
666 const CHttpRange range4_4(4, 4);
667 const CHttpRange range0_4(0, 4);
668 const CHttpRange range3_4(3, 4);
669
670 CHttpRange range;
671
672 CHttpRanges ranges;
673 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0,1-1", totalLength));
674 EXPECT_EQ(1U, ranges.Size());
675 EXPECT_TRUE(ranges.Get(0, range));
676 EXPECT_EQ(range0_1, range);
677
678 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0,1-1,2-2", totalLength));
679 EXPECT_EQ(1U, ranges.Size());
680 EXPECT_TRUE(ranges.Get(0, range));
681 EXPECT_EQ(range0_2, range);
682
683 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0,1-1,2-2,3-3", totalLength));
684 EXPECT_EQ(1U, ranges.Size());
685 EXPECT_TRUE(ranges.Get(0, range));
686 EXPECT_EQ(range0_3, range);
687
688 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0,1-1,2-2,3-3,4-4", totalLength));
689 EXPECT_EQ(1U, ranges.Size());
690 EXPECT_TRUE(ranges.Get(0, range));
691 EXPECT_EQ(range0_4, range);
692
693 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0,1-1,3-3,4-4", totalLength));
694 EXPECT_EQ(2U, ranges.Size());
695 EXPECT_TRUE(ranges.Get(0, range));
696 EXPECT_EQ(range0_1, range);
697 EXPECT_TRUE(ranges.Get(1, range));
698 EXPECT_EQ(range3_4, range);
699
700 EXPECT_TRUE(ranges.Parse(RANGES_START "1-1,2-2,4-4", totalLength));
701 EXPECT_EQ(2U, ranges.Size());
702 EXPECT_TRUE(ranges.Get(0, range));
703 EXPECT_EQ(range1_2, range);
704 EXPECT_TRUE(ranges.Get(1, range));
705 EXPECT_EQ(range4_4, range);
706}
707
708TEST(TestHttpRanges, ParseOrderedOverlapping)
709{
710 const uint64_t totalLength = 5;
711 const CHttpRange range0_0(0, 0);
712 const CHttpRange range0_1(0, 1);
713 const CHttpRange range0_2(0, 2);
714 const CHttpRange range0_3(0, 3);
715 const CHttpRange range0_4(0, 4);
716 const CHttpRange range2_4(2, 4);
717
718 CHttpRange range;
719
720 CHttpRanges ranges;
721 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0,0-1", totalLength));
722 EXPECT_EQ(1U, ranges.Size());
723 EXPECT_TRUE(ranges.Get(0, range));
724 EXPECT_EQ(range0_1, range);
725
726 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0,0-1,0-2", totalLength));
727 EXPECT_EQ(1U, ranges.Size());
728 EXPECT_TRUE(ranges.Get(0, range));
729 EXPECT_EQ(range0_2, range);
730
731 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0,0-1,1-2", totalLength));
732 EXPECT_EQ(1U, ranges.Size());
733 EXPECT_TRUE(ranges.Get(0, range));
734 EXPECT_EQ(range0_2, range);
735
736 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0,0-2,1-3", totalLength));
737 EXPECT_EQ(1U, ranges.Size());
738 EXPECT_TRUE(ranges.Get(0, range));
739 EXPECT_EQ(range0_3, range);
740
741 EXPECT_TRUE(ranges.Parse(RANGES_START "0-1,1-2,2-3,3-4", totalLength));
742 EXPECT_EQ(1U, ranges.Size());
743 EXPECT_TRUE(ranges.Get(0, range));
744 EXPECT_EQ(range0_4, range);
745
746 EXPECT_TRUE(ranges.Parse(RANGES_START "0-0,2-3,2-4,4-4", totalLength));
747 EXPECT_EQ(2U, ranges.Size());
748 EXPECT_TRUE(ranges.Get(0, range));
749 EXPECT_EQ(range0_0, range);
750 EXPECT_TRUE(ranges.Get(1, range));
751 EXPECT_EQ(range2_4, range);
752}
753
754TEST(TestHttpRanges, ParseUnorderedNotOverlapping)
755{
756 const uint64_t totalLength = 5;
757 const CHttpRange range0_0(0, 0);
758 const CHttpRange range0_1(0, 1);
759 const CHttpRange range2_2(2, 2);
760 const CHttpRange range2_(2, totalLength - 1);
761 const CHttpRange range_1(totalLength - 1, totalLength - 1);
762
763 CHttpRange range;
764
765 CHttpRanges ranges;
766 EXPECT_TRUE(ranges.Parse(RANGES_START "-1,0-0", totalLength));
767 EXPECT_EQ(2U, ranges.Size());
768 EXPECT_TRUE(ranges.Get(0, range));
769 EXPECT_EQ(range0_0, range);
770 EXPECT_TRUE(ranges.Get(1, range));
771 EXPECT_EQ(range_1, range);
772
773 EXPECT_TRUE(ranges.Parse(RANGES_START "2-2,-1,0-0", totalLength));
774 EXPECT_EQ(3U, ranges.Size());
775 EXPECT_TRUE(ranges.Get(0, range));
776 EXPECT_EQ(range0_0, range);
777 EXPECT_TRUE(ranges.Get(1, range));
778 EXPECT_EQ(range2_2, range);
779 EXPECT_TRUE(ranges.Get(2, range));
780 EXPECT_EQ(range_1, range);
781
782 EXPECT_TRUE(ranges.Parse(RANGES_START "2-,0-0", totalLength));
783 EXPECT_EQ(2U, ranges.Size());
784 EXPECT_TRUE(ranges.Get(0, range));
785 EXPECT_EQ(range0_0, range);
786 EXPECT_TRUE(ranges.Get(1, range));
787 EXPECT_EQ(range2_, range);
788}
789
790TEST(TestHttpRanges, ParseUnorderedBackToBack)
791{
792 const uint64_t totalLength = 5;
793 const CHttpRange range0_0(0, 0);
794 const CHttpRange range1_1(1, 1);
795 const CHttpRange range0_1(0, 1);
796 const CHttpRange range2_2(2, 2);
797 const CHttpRange range0_2(0, 2);
798 const CHttpRange range1_2(1, 2);
799 const CHttpRange range3_3(3, 3);
800 const CHttpRange range0_3(0, 3);
801 const CHttpRange range4_4(4, 4);
802 const CHttpRange range0_4(0, 4);
803 const CHttpRange range3_4(3, 4);
804
805 CHttpRange range;
806
807 CHttpRanges ranges;
808 EXPECT_TRUE(ranges.Parse(RANGES_START "1-1,0-0", totalLength));
809 EXPECT_EQ(1U, ranges.Size());
810 EXPECT_TRUE(ranges.Get(0, range));
811 EXPECT_EQ(range0_1, range);
812
813 EXPECT_TRUE(ranges.Parse(RANGES_START "1-1,0-0,2-2", totalLength));
814 EXPECT_EQ(1U, ranges.Size());
815 EXPECT_TRUE(ranges.Get(0, range));
816 EXPECT_EQ(range0_2, range);
817
818 EXPECT_TRUE(ranges.Parse(RANGES_START "2-2,1-1,3-3,0-0", totalLength));
819 EXPECT_EQ(1U, ranges.Size());
820 EXPECT_TRUE(ranges.Get(0, range));
821 EXPECT_EQ(range0_3, range);
822
823 EXPECT_TRUE(ranges.Parse(RANGES_START "4-4,1-1,0-0,2-2,3-3", totalLength));
824 EXPECT_EQ(1U, ranges.Size());
825 EXPECT_TRUE(ranges.Get(0, range));
826 EXPECT_EQ(range0_4, range);
827
828 EXPECT_TRUE(ranges.Parse(RANGES_START "3-3,0-0,4-4,1-1", totalLength));
829 EXPECT_EQ(2U, ranges.Size());
830 EXPECT_TRUE(ranges.Get(0, range));
831 EXPECT_EQ(range0_1, range);
832 EXPECT_TRUE(ranges.Get(1, range));
833 EXPECT_EQ(range3_4, range);
834
835 EXPECT_TRUE(ranges.Parse(RANGES_START "4-4,1-1,2-2", totalLength));
836 EXPECT_EQ(2U, ranges.Size());
837 EXPECT_TRUE(ranges.Get(0, range));
838 EXPECT_EQ(range1_2, range);
839 EXPECT_TRUE(ranges.Get(1, range));
840 EXPECT_EQ(range4_4, range);
841}
842
843TEST(TestHttpRanges, ParseUnorderedOverlapping)
844{
845 const uint64_t totalLength = 5;
846 const CHttpRange range0_0(0, 0);
847 const CHttpRange range0_1(0, 1);
848 const CHttpRange range0_2(0, 2);
849 const CHttpRange range0_3(0, 3);
850 const CHttpRange range0_4(0, 4);
851 const CHttpRange range2_4(2, 4);
852
853 CHttpRange range;
854
855 CHttpRanges ranges;
856 EXPECT_TRUE(ranges.Parse(RANGES_START "0-1,0-0", totalLength));
857 EXPECT_EQ(1U, ranges.Size());
858 EXPECT_TRUE(ranges.Get(0, range));
859 EXPECT_EQ(range0_1, range);
860
861 EXPECT_TRUE(ranges.Parse(RANGES_START "0-2,0-0,0-1", totalLength));
862 EXPECT_EQ(1U, ranges.Size());
863 EXPECT_TRUE(ranges.Get(0, range));
864 EXPECT_EQ(range0_2, range);
865
866 EXPECT_TRUE(ranges.Parse(RANGES_START "0-1,1-2,0-0", totalLength));
867 EXPECT_EQ(1U, ranges.Size());
868 EXPECT_TRUE(ranges.Get(0, range));
869 EXPECT_EQ(range0_2, range);
870
871 EXPECT_TRUE(ranges.Parse(RANGES_START "0-2,0-0,1-3", totalLength));
872 EXPECT_EQ(1U, ranges.Size());
873 EXPECT_TRUE(ranges.Get(0, range));
874 EXPECT_EQ(range0_3, range);
875
876 EXPECT_TRUE(ranges.Parse(RANGES_START "2-3,1-2,0-1,3-4", totalLength));
877 EXPECT_EQ(1U, ranges.Size());
878 EXPECT_TRUE(ranges.Get(0, range));
879 EXPECT_EQ(range0_4, range);
880
881 EXPECT_TRUE(ranges.Parse(RANGES_START "4-4,0-0,2-4,2-3", totalLength));
882 EXPECT_EQ(2U, ranges.Size());
883 EXPECT_TRUE(ranges.Get(0, range));
884 EXPECT_EQ(range0_0, range);
885 EXPECT_TRUE(ranges.Get(1, range));
886 EXPECT_EQ(range2_4, range);
887}
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-12 05:50:40 +0000