proxygen
Functions
RFC2616Test.cpp File Reference
#include <folly/portability/GTest.h>
#include <proxygen/lib/http/RFC2616.h>

Go to the source code of this file.

Functions

 TEST (QvalueTest, Basic)
 
 TEST (QvalueTest, Extras)
 
 TEST (QvalueTest, Invalids)
 
 TEST (ByteRangeSpecTest, Valids)
 
 TEST (ByteRangeSpecTest, Invalids)
 

Function Documentation

TEST ( QvalueTest  ,
Basic   
)

Definition at line 18 of file RFC2616Test.cpp.

References EXPECT_DOUBLE_EQ, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::gen::first, gmock_output_test::output, and proxygen::RFC2616::parseQvalues().

18  {
19 
20  std::vector<RFC2616::TokenQPair> output;
21 
22  string test1("iso-8859-5, unicode-1-1;q=0.8");
23  EXPECT_TRUE(RFC2616::parseQvalues(test1, output));
24  EXPECT_EQ(output.size(), 2);
25  EXPECT_EQ(output[0].first.compare(folly::StringPiece("iso-8859-5")), 0);
26  EXPECT_DOUBLE_EQ(output[0].second, 1);
27  EXPECT_EQ(output[1].first.compare(folly::StringPiece("unicode-1-1")), 0);
28  EXPECT_DOUBLE_EQ(output[1].second, 0.8);
29  output.clear();
30 
31  string test2("compress, gzip");
32  EXPECT_TRUE(RFC2616::parseQvalues(test2, output));
33  EXPECT_EQ(output.size(), 2);
34  EXPECT_EQ(output[0].first.compare(folly::StringPiece("compress")), 0);
35  EXPECT_DOUBLE_EQ(output[0].second, 1);
36  EXPECT_EQ(output[1].first.compare(folly::StringPiece("gzip")), 0);
37  EXPECT_DOUBLE_EQ(output[1].second, 1);
38  output.clear();
39 
40  string test3("");
41  // The spec says a blank one is ok but empty headers are disallowed in SPDY?
42  EXPECT_FALSE(RFC2616::parseQvalues(test3, output));
43  EXPECT_EQ(output.size(), 0);
44 
45  string test4("compress;q=0.5, gzip;q=1.0");
46  EXPECT_TRUE(RFC2616::parseQvalues(test4, output));
47  EXPECT_EQ(output.size(), 2);
48  EXPECT_EQ(output[0].first.compare(folly::StringPiece("compress")), 0);
49  EXPECT_DOUBLE_EQ(output[0].second, 0.5);
50  EXPECT_EQ(output[1].first.compare(folly::StringPiece("gzip")), 0);
51  EXPECT_DOUBLE_EQ(output[1].second, 1.0);
52  output.clear();
53 
54  string test5("gzip;q=1.0, identity; q=0.5, *;q=0");
55  EXPECT_TRUE(RFC2616::parseQvalues(test5, output));
56  EXPECT_EQ(output.size(), 3);
57  EXPECT_EQ(output[0].first.compare(folly::StringPiece("gzip")), 0);
58  EXPECT_DOUBLE_EQ(output[0].second, 1);
59  EXPECT_EQ(output[1].first.compare(folly::StringPiece("identity")), 0);
60  EXPECT_DOUBLE_EQ(output[1].second, 0.5);
61  EXPECT_EQ(output[2].first.compare(folly::StringPiece("*")), 0);
62  EXPECT_DOUBLE_EQ(output[2].second, 0);
63  output.clear();
64 
65  string test6("da, en-gb;q=0.8, en;q=0.7");
66  EXPECT_TRUE(RFC2616::parseQvalues(test6, output));
67  EXPECT_EQ(output.size(), 3);
68  EXPECT_EQ(output[0].first.compare(folly::StringPiece("da")), 0);
69  EXPECT_DOUBLE_EQ(output[0].second, 1);
70  EXPECT_EQ(output[1].first.compare(folly::StringPiece("en-gb")), 0);
71  EXPECT_DOUBLE_EQ(output[1].second, 0.8);
72  EXPECT_EQ(output[2].first.compare(folly::StringPiece("en")), 0);
73  EXPECT_DOUBLE_EQ(output[2].second, 0.7);
74  output.clear();
75 }
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
EXPECT_TRUE
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
gmock_output_test.output
output
Definition: gmock_output_test.py:175
EXPECT_DOUBLE_EQ
#define EXPECT_DOUBLE_EQ(val1, val2)
Definition: gtest.h:2031
EXPECT_FALSE
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
proxygen::RFC2616::parseQvalues
bool parseQvalues(folly::StringPiece value, std::vector< TokenQPair > &output)
Definition: RFC2616.cpp:64
folly::gen::first
constexpr detail::First first
Definition: Base-inl.h:2553
TEST ( QvalueTest  ,
Extras   
)

Definition at line 77 of file RFC2616Test.cpp.

References EXPECT_DOUBLE_EQ, EXPECT_EQ, EXPECT_TRUE, folly::gen::first, gmock_output_test::output, and proxygen::RFC2616::parseQvalues().

77  {
78 
79  std::vector<RFC2616::TokenQPair> output;
80 
81  string test1(" iso-8859-5, unicode-1-1; q=0.8 hi mom!");
82  EXPECT_TRUE(RFC2616::parseQvalues(test1, output));
83  EXPECT_EQ(output.size(), 2);
84  EXPECT_EQ(output[0].first.compare(folly::StringPiece("iso-8859-5")), 0);
85  EXPECT_DOUBLE_EQ(output[0].second, 1);
86  EXPECT_EQ(output[1].first.compare(folly::StringPiece("unicode-1-1")), 0);
87  EXPECT_DOUBLE_EQ(output[1].second, 0.8);
88  output.clear();
89 
90  string test2("gzip");
91  EXPECT_TRUE(RFC2616::parseQvalues(test2, output));
92  EXPECT_EQ(output.size(), 1);
93  EXPECT_EQ(output[0].first.compare(folly::StringPiece("gzip")), 0);
94  EXPECT_DOUBLE_EQ(output[0].second, 1);
95  output.clear();
96 }
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
EXPECT_TRUE
#define EXPECT_TRUE(condition)
Definition: gtest.h:1859
gmock_output_test.output
output
Definition: gmock_output_test.py:175
EXPECT_DOUBLE_EQ
#define EXPECT_DOUBLE_EQ(val1, val2)
Definition: gtest.h:2031
proxygen::RFC2616::parseQvalues
bool parseQvalues(folly::StringPiece value, std::vector< TokenQPair > &output)
Definition: RFC2616.cpp:64
folly::gen::first
constexpr detail::First first
Definition: Base-inl.h:2553
TEST ( QvalueTest  ,
Invalids   
)

Definition at line 98 of file RFC2616Test.cpp.

References EXPECT_DOUBLE_EQ, EXPECT_EQ, EXPECT_FALSE, folly::gen::first, gmock_output_test::output, and proxygen::RFC2616::parseQvalues().

98  {
99 
100  std::vector<RFC2616::TokenQPair> output;
101 
102  string test1(",,,");
103  EXPECT_FALSE(RFC2616::parseQvalues(test1, output));
104  EXPECT_EQ(output.size(), 0);
105  output.clear();
106 
107  string test2(" ; q=0.1");
108  EXPECT_FALSE(RFC2616::parseQvalues(test2, output));
109  EXPECT_EQ(output.size(), 0);
110  output.clear();
111 
112  string test3("gzip; q=uietplease");
113  EXPECT_FALSE(RFC2616::parseQvalues(test3, output));
114  EXPECT_EQ(output.size(), 1);
115  EXPECT_EQ(output[0].first.compare(folly::StringPiece("gzip")), 0);
116  EXPECT_DOUBLE_EQ(output[0].second, 1);
117  output.clear();
118 
119  string test4("gzip; whoohoo, defalte");
120  EXPECT_FALSE(RFC2616::parseQvalues(test4, output));
121  EXPECT_EQ(output.size(), 2);
122  EXPECT_EQ(output[0].first.compare(folly::StringPiece("gzip")), 0);
123  EXPECT_DOUBLE_EQ(output[0].second, 1);
124  EXPECT_EQ(output[1].first.compare(folly::StringPiece("defalte")), 0);
125  EXPECT_DOUBLE_EQ(output[1].second, 1);
126  output.clear();
127 
128 }
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
gmock_output_test.output
output
Definition: gmock_output_test.py:175
EXPECT_DOUBLE_EQ
#define EXPECT_DOUBLE_EQ(val1, val2)
Definition: gtest.h:2031
EXPECT_FALSE
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862
proxygen::RFC2616::parseQvalues
bool parseQvalues(folly::StringPiece value, std::vector< TokenQPair > &output)
Definition: RFC2616.cpp:64
folly::gen::first
constexpr detail::First first
Definition: Base-inl.h:2553
TEST ( ByteRangeSpecTest  ,
Valids   
)

Definition at line 130 of file RFC2616Test.cpp.

References ASSERT_TRUE, EXPECT_EQ, and proxygen::RFC2616::parseByteRangeSpec().

130  {
131  unsigned long firstByte = ULONG_MAX;
132  unsigned long lastByte = ULONG_MAX;
133  unsigned long instanceLength = ULONG_MAX;
134 
135  ASSERT_TRUE(
136  parseByteRangeSpec(
137  "bytes 0-10/100",
138  firstByte, lastByte, instanceLength));
139  EXPECT_EQ(0, firstByte);
140  EXPECT_EQ(10, lastByte);
141  EXPECT_EQ(100, instanceLength);
142 
143  ASSERT_TRUE(
144  parseByteRangeSpec(
145  "bytes */100",
146  firstByte, lastByte, instanceLength));
147  EXPECT_EQ(0, firstByte);
148  EXPECT_EQ(ULONG_MAX, lastByte);
149  EXPECT_EQ(100, instanceLength);
150 
151  ASSERT_TRUE(
152  parseByteRangeSpec(
153  "bytes 0-10/*",
154  firstByte, lastByte, instanceLength));
155  EXPECT_EQ(0, firstByte);
156  EXPECT_EQ(10, lastByte);
157  EXPECT_EQ(ULONG_MAX, instanceLength);
158 }
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
proxygen::RFC2616::parseByteRangeSpec
bool parseByteRangeSpec(folly::StringPiece value, unsigned long &outFirstByte, unsigned long &outLastByte, unsigned long &outInstanceLength)
Definition: RFC2616.cpp:105
ASSERT_TRUE
#define ASSERT_TRUE(condition)
Definition: gtest.h:1865
TEST ( ByteRangeSpecTest  ,
Invalids   
)

Definition at line 160 of file RFC2616Test.cpp.

References dummy(), EXPECT_FALSE, proxygen::RFC2616::parseByteRangeSpec(), and folly::Range< Iter >::subtract().

160  {
161  unsigned long dummy;
162 
163  EXPECT_FALSE(parseByteRangeSpec("0-10/100", dummy, dummy, dummy)) <<
164  "Spec must start with 'bytes '";
165  EXPECT_FALSE(parseByteRangeSpec("bytes 10/100", dummy, dummy, dummy)) <<
166  "Spec missing initial range";
167  EXPECT_FALSE(parseByteRangeSpec("bytes 10-/100", dummy, dummy, dummy)) <<
168  "Spec missing last byte in initial range";
169  EXPECT_FALSE(parseByteRangeSpec("bytes 0-10 100", dummy, dummy, dummy)) <<
170  "Spec missing '/' separator";
171  EXPECT_FALSE(parseByteRangeSpec("bytes 0-10/100Q", dummy, dummy, dummy)) <<
172  "Spec has trailing garbage";
173  EXPECT_FALSE(parseByteRangeSpec("bytes 10-1/100", dummy, dummy, dummy)) <<
174  "Spec initial range is invalid";
175  EXPECT_FALSE(parseByteRangeSpec("bytes 10-90/50", dummy, dummy, dummy)) <<
176  "Spec initial range is invalid too large";
177  EXPECT_FALSE(parseByteRangeSpec("bytes x/100", dummy, dummy, dummy)) <<
178  "Spec initial range has invalid first byte";
179  EXPECT_FALSE(parseByteRangeSpec("bytes 0-x/100", dummy, dummy, dummy)) <<
180  "Spec initial range has invalid last bytek";
181  EXPECT_FALSE(parseByteRangeSpec("bytes *-10/100", dummy, dummy, dummy)) <<
182  "Spec cannot contain wildcard in initial range";
183  EXPECT_FALSE(parseByteRangeSpec("bytes 0-*/100", dummy, dummy, dummy)) <<
184  "Spec cannot contain wildcard in initial range";
185 
186  folly::StringPiece sp("bytes 0-10/100");
187  sp.subtract(3);
188  EXPECT_FALSE(parseByteRangeSpec(sp, dummy, dummy, dummy)) <<
189  "Spec StringPiece ends before instance length";
190  sp.subtract(1);
191  EXPECT_FALSE(parseByteRangeSpec(sp, dummy, dummy, dummy)) <<
192  "Spec StringPiece ends before '/' character";
193  sp.subtract(2);
194  EXPECT_FALSE(parseByteRangeSpec(sp, dummy, dummy, dummy)) <<
195  "Spec StringPiece ends before last byte in initial byte range";
196  sp.subtract(1);
197  EXPECT_FALSE(parseByteRangeSpec(sp, dummy, dummy, dummy)) <<
198  "Spec StringPiece ends before '-' in initial byte range";
199  sp.subtract(2);
200  EXPECT_FALSE(parseByteRangeSpec(sp, dummy, dummy, dummy)) <<
201  "Spec StringPiece ends before first byte in initial byte range";
202 }
dummy
void dummy()
Definition: DwarfBenchmark.cpp:21
proxygen::RFC2616::parseByteRangeSpec
bool parseByteRangeSpec(folly::StringPiece value, unsigned long &outFirstByte, unsigned long &outLastByte, unsigned long &outInstanceLength)
Definition: RFC2616.cpp:105
EXPECT_FALSE
#define EXPECT_FALSE(condition)
Definition: gtest.h:1862