1// Copyright (c) 2009 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "net/http/http_byte_range.h"
6#include "testing/gtest/include/gtest/gtest.h"
7
8TEST(HttpByteRangeTest, ValidRanges) {
9  const struct {
10    int64 first_byte_position;
11    int64 last_byte_position;
12    int64 suffix_length;
13    bool valid;
14  } tests[] = {
15    {  -1, -1,  0, false },
16    {   0,  0,  0, true  },
17    { -10,  0,  0, false },
18    {  10,  0,  0, false },
19    {  10, -1,  0, true  },
20    {  -1, -1, -1, false },
21    {  -1, 50,  0, false },
22    {  10, 10000, 0, true },
23    {  -1, -1, 100000, true },
24  };
25
26  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
27    net::HttpByteRange range;
28    range.set_first_byte_position(tests[i].first_byte_position);
29    range.set_last_byte_position(tests[i].last_byte_position);
30    range.set_suffix_length(tests[i].suffix_length);
31    EXPECT_EQ(tests[i].valid, range.IsValid());
32  }
33}
34
35TEST(HttpByteRangeTest, SetInstanceSize) {
36  const struct {
37    int64 first_byte_position;
38    int64 last_byte_position;
39    int64 suffix_length;
40    int64 instance_size;
41    bool expected_return_value;
42    int64 expected_lower_bound;
43    int64 expected_upper_bound;
44  } tests[] = {
45    { -10,  0,  -1,   0, false,  -1,  -1 },
46    {  10,  0,  -1,   0, false,  -1,  -1 },
47    // Zero instance size is valid, this is the case that user has to handle.
48    {  -1, -1,  -1,   0,  true,   0,  -1 },
49    {  -1, -1, 500,   0,  true,   0,  -1 },
50    {  -1, 50,  -1,   0, false,  -1,  -1 },
51    {  -1, -1, 500, 300,  true,   0, 299 },
52    {  -1, -1,  -1, 100,  true,   0,  99 },
53    {  10, -1,  -1, 100,  true,  10,  99 },
54    {  -1, -1, 500, 1000, true, 500, 999 },
55    {  10, 10000, -1, 1000000, true, 10, 10000 },
56  };
57
58  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
59    net::HttpByteRange range;
60    range.set_first_byte_position(tests[i].first_byte_position);
61    range.set_last_byte_position(tests[i].last_byte_position);
62    range.set_suffix_length(tests[i].suffix_length);
63
64    bool return_value = range.ComputeBounds(tests[i].instance_size);
65    EXPECT_EQ(tests[i].expected_return_value, return_value);
66    if (return_value) {
67      EXPECT_EQ(tests[i].expected_lower_bound, range.first_byte_position());
68      EXPECT_EQ(tests[i].expected_upper_bound, range.last_byte_position());
69
70      // Try to call SetInstanceSize the second time.
71      EXPECT_FALSE(range.ComputeBounds(tests[i].instance_size));
72      // And expect there's no side effect.
73      EXPECT_EQ(tests[i].expected_lower_bound, range.first_byte_position());
74      EXPECT_EQ(tests[i].expected_upper_bound, range.last_byte_position());
75      EXPECT_EQ(tests[i].suffix_length, range.suffix_length());
76    }
77  }
78}
79
80TEST(HttpByteRangeTest, GetHeaderValue) {
81  static const struct {
82    net::HttpByteRange range;
83    const char* expected;
84  } tests[] = {{net::HttpByteRange::Bounded(0, 0),       "bytes=0-0"},
85               {net::HttpByteRange::Bounded(0, 100),     "bytes=0-100"},
86               {net::HttpByteRange::Bounded(0, -1),      "bytes=0-"},
87               {net::HttpByteRange::RightUnbounded(100), "bytes=100-"},
88               {net::HttpByteRange::Suffix(100),         "bytes=-100"}, };
89  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); ++i) {
90    EXPECT_EQ(tests[i].expected, tests[i].range.GetHeaderValue());
91  }
92}
93