1 // Copyright (c) 2012 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 "quiche/spdy/core/spdy_protocol.h"
6
7 #include <iostream>
8 #include <string>
9 #include <utility>
10
11 #include "absl/strings/string_view.h"
12 #include "quiche/common/platform/api/quiche_expect_bug.h"
13 #include "quiche/common/platform/api/quiche_test.h"
14
15 namespace spdy {
16
operator <<(std::ostream & os,const SpdyStreamPrecedence precedence)17 std::ostream& operator<<(std::ostream& os,
18 const SpdyStreamPrecedence precedence) {
19 if (precedence.is_spdy3_priority()) {
20 os << "SpdyStreamPrecedence[spdy3_priority=" << precedence.spdy3_priority()
21 << "]";
22 } else {
23 os << "SpdyStreamPrecedence[parent_id=" << precedence.parent_id()
24 << ", weight=" << precedence.weight()
25 << ", is_exclusive=" << precedence.is_exclusive() << "]";
26 }
27 return os;
28 }
29
30 namespace test {
31
TEST(SpdyProtocolTest,ClampSpdy3Priority)32 TEST(SpdyProtocolTest, ClampSpdy3Priority) {
33 EXPECT_QUICHE_BUG(EXPECT_EQ(7, ClampSpdy3Priority(8)), "Invalid priority: 8");
34 EXPECT_EQ(kV3LowestPriority, ClampSpdy3Priority(kV3LowestPriority));
35 EXPECT_EQ(kV3HighestPriority, ClampSpdy3Priority(kV3HighestPriority));
36 }
37
TEST(SpdyProtocolTest,ClampHttp2Weight)38 TEST(SpdyProtocolTest, ClampHttp2Weight) {
39 EXPECT_QUICHE_BUG(EXPECT_EQ(kHttp2MinStreamWeight, ClampHttp2Weight(0)),
40 "Invalid weight: 0");
41 EXPECT_QUICHE_BUG(EXPECT_EQ(kHttp2MaxStreamWeight, ClampHttp2Weight(300)),
42 "Invalid weight: 300");
43 EXPECT_EQ(kHttp2MinStreamWeight, ClampHttp2Weight(kHttp2MinStreamWeight));
44 EXPECT_EQ(kHttp2MaxStreamWeight, ClampHttp2Weight(kHttp2MaxStreamWeight));
45 }
46
TEST(SpdyProtocolTest,Spdy3PriorityToHttp2Weight)47 TEST(SpdyProtocolTest, Spdy3PriorityToHttp2Weight) {
48 EXPECT_EQ(256, Spdy3PriorityToHttp2Weight(0));
49 EXPECT_EQ(220, Spdy3PriorityToHttp2Weight(1));
50 EXPECT_EQ(183, Spdy3PriorityToHttp2Weight(2));
51 EXPECT_EQ(147, Spdy3PriorityToHttp2Weight(3));
52 EXPECT_EQ(110, Spdy3PriorityToHttp2Weight(4));
53 EXPECT_EQ(74, Spdy3PriorityToHttp2Weight(5));
54 EXPECT_EQ(37, Spdy3PriorityToHttp2Weight(6));
55 EXPECT_EQ(1, Spdy3PriorityToHttp2Weight(7));
56 }
57
TEST(SpdyProtocolTest,Http2WeightToSpdy3Priority)58 TEST(SpdyProtocolTest, Http2WeightToSpdy3Priority) {
59 EXPECT_EQ(0u, Http2WeightToSpdy3Priority(256));
60 EXPECT_EQ(0u, Http2WeightToSpdy3Priority(221));
61 EXPECT_EQ(1u, Http2WeightToSpdy3Priority(220));
62 EXPECT_EQ(1u, Http2WeightToSpdy3Priority(184));
63 EXPECT_EQ(2u, Http2WeightToSpdy3Priority(183));
64 EXPECT_EQ(2u, Http2WeightToSpdy3Priority(148));
65 EXPECT_EQ(3u, Http2WeightToSpdy3Priority(147));
66 EXPECT_EQ(3u, Http2WeightToSpdy3Priority(111));
67 EXPECT_EQ(4u, Http2WeightToSpdy3Priority(110));
68 EXPECT_EQ(4u, Http2WeightToSpdy3Priority(75));
69 EXPECT_EQ(5u, Http2WeightToSpdy3Priority(74));
70 EXPECT_EQ(5u, Http2WeightToSpdy3Priority(38));
71 EXPECT_EQ(6u, Http2WeightToSpdy3Priority(37));
72 EXPECT_EQ(6u, Http2WeightToSpdy3Priority(2));
73 EXPECT_EQ(7u, Http2WeightToSpdy3Priority(1));
74 }
75
TEST(SpdyProtocolTest,IsValidHTTP2FrameStreamId)76 TEST(SpdyProtocolTest, IsValidHTTP2FrameStreamId) {
77 // Stream-specific frames must have non-zero stream ids
78 EXPECT_TRUE(IsValidHTTP2FrameStreamId(1, SpdyFrameType::DATA));
79 EXPECT_FALSE(IsValidHTTP2FrameStreamId(0, SpdyFrameType::DATA));
80 EXPECT_TRUE(IsValidHTTP2FrameStreamId(1, SpdyFrameType::HEADERS));
81 EXPECT_FALSE(IsValidHTTP2FrameStreamId(0, SpdyFrameType::HEADERS));
82 EXPECT_TRUE(IsValidHTTP2FrameStreamId(1, SpdyFrameType::PRIORITY));
83 EXPECT_FALSE(IsValidHTTP2FrameStreamId(0, SpdyFrameType::PRIORITY));
84 EXPECT_TRUE(IsValidHTTP2FrameStreamId(1, SpdyFrameType::RST_STREAM));
85 EXPECT_FALSE(IsValidHTTP2FrameStreamId(0, SpdyFrameType::RST_STREAM));
86 EXPECT_TRUE(IsValidHTTP2FrameStreamId(1, SpdyFrameType::CONTINUATION));
87 EXPECT_FALSE(IsValidHTTP2FrameStreamId(0, SpdyFrameType::CONTINUATION));
88 EXPECT_TRUE(IsValidHTTP2FrameStreamId(1, SpdyFrameType::PUSH_PROMISE));
89 EXPECT_FALSE(IsValidHTTP2FrameStreamId(0, SpdyFrameType::PUSH_PROMISE));
90
91 // Connection-level frames must have zero stream ids
92 EXPECT_FALSE(IsValidHTTP2FrameStreamId(1, SpdyFrameType::GOAWAY));
93 EXPECT_TRUE(IsValidHTTP2FrameStreamId(0, SpdyFrameType::GOAWAY));
94 EXPECT_FALSE(IsValidHTTP2FrameStreamId(1, SpdyFrameType::SETTINGS));
95 EXPECT_TRUE(IsValidHTTP2FrameStreamId(0, SpdyFrameType::SETTINGS));
96 EXPECT_FALSE(IsValidHTTP2FrameStreamId(1, SpdyFrameType::PING));
97 EXPECT_TRUE(IsValidHTTP2FrameStreamId(0, SpdyFrameType::PING));
98
99 // Frames that are neither stream-specific nor connection-level
100 // should not have their stream id declared invalid
101 EXPECT_TRUE(IsValidHTTP2FrameStreamId(1, SpdyFrameType::WINDOW_UPDATE));
102 EXPECT_TRUE(IsValidHTTP2FrameStreamId(0, SpdyFrameType::WINDOW_UPDATE));
103 }
104
TEST(SpdyProtocolTest,ParseSettingsId)105 TEST(SpdyProtocolTest, ParseSettingsId) {
106 SpdyKnownSettingsId setting_id;
107 EXPECT_FALSE(ParseSettingsId(0, &setting_id));
108 EXPECT_TRUE(ParseSettingsId(1, &setting_id));
109 EXPECT_EQ(SETTINGS_HEADER_TABLE_SIZE, setting_id);
110 EXPECT_TRUE(ParseSettingsId(2, &setting_id));
111 EXPECT_EQ(SETTINGS_ENABLE_PUSH, setting_id);
112 EXPECT_TRUE(ParseSettingsId(3, &setting_id));
113 EXPECT_EQ(SETTINGS_MAX_CONCURRENT_STREAMS, setting_id);
114 EXPECT_TRUE(ParseSettingsId(4, &setting_id));
115 EXPECT_EQ(SETTINGS_INITIAL_WINDOW_SIZE, setting_id);
116 EXPECT_TRUE(ParseSettingsId(5, &setting_id));
117 EXPECT_EQ(SETTINGS_MAX_FRAME_SIZE, setting_id);
118 EXPECT_TRUE(ParseSettingsId(6, &setting_id));
119 EXPECT_EQ(SETTINGS_MAX_HEADER_LIST_SIZE, setting_id);
120 EXPECT_FALSE(ParseSettingsId(7, &setting_id));
121 EXPECT_TRUE(ParseSettingsId(8, &setting_id));
122 EXPECT_EQ(SETTINGS_ENABLE_CONNECT_PROTOCOL, setting_id);
123 EXPECT_TRUE(ParseSettingsId(9, &setting_id));
124 EXPECT_EQ(SETTINGS_DEPRECATE_HTTP2_PRIORITIES, setting_id);
125 EXPECT_FALSE(ParseSettingsId(10, &setting_id));
126 EXPECT_FALSE(ParseSettingsId(0xFF44, &setting_id));
127 EXPECT_TRUE(ParseSettingsId(0xFF45, &setting_id));
128 EXPECT_EQ(SETTINGS_EXPERIMENT_SCHEDULER, setting_id);
129 EXPECT_FALSE(ParseSettingsId(0xFF46, &setting_id));
130 }
131
TEST(SpdyProtocolTest,SettingsIdToString)132 TEST(SpdyProtocolTest, SettingsIdToString) {
133 struct {
134 SpdySettingsId setting_id;
135 const std::string expected_string;
136 } test_cases[] = {
137 {0, "SETTINGS_UNKNOWN_0"},
138 {SETTINGS_HEADER_TABLE_SIZE, "SETTINGS_HEADER_TABLE_SIZE"},
139 {SETTINGS_ENABLE_PUSH, "SETTINGS_ENABLE_PUSH"},
140 {SETTINGS_MAX_CONCURRENT_STREAMS, "SETTINGS_MAX_CONCURRENT_STREAMS"},
141 {SETTINGS_INITIAL_WINDOW_SIZE, "SETTINGS_INITIAL_WINDOW_SIZE"},
142 {SETTINGS_MAX_FRAME_SIZE, "SETTINGS_MAX_FRAME_SIZE"},
143 {SETTINGS_MAX_HEADER_LIST_SIZE, "SETTINGS_MAX_HEADER_LIST_SIZE"},
144 {7, "SETTINGS_UNKNOWN_7"},
145 {SETTINGS_ENABLE_CONNECT_PROTOCOL, "SETTINGS_ENABLE_CONNECT_PROTOCOL"},
146 {SETTINGS_DEPRECATE_HTTP2_PRIORITIES,
147 "SETTINGS_DEPRECATE_HTTP2_PRIORITIES"},
148 {0xa, "SETTINGS_UNKNOWN_a"},
149 {0xFF44, "SETTINGS_UNKNOWN_ff44"},
150 {0xFF45, "SETTINGS_EXPERIMENT_SCHEDULER"},
151 {0xFF46, "SETTINGS_UNKNOWN_ff46"}};
152 for (auto test_case : test_cases) {
153 EXPECT_EQ(test_case.expected_string,
154 SettingsIdToString(test_case.setting_id));
155 }
156 }
157
TEST(SpdyStreamPrecedenceTest,Basic)158 TEST(SpdyStreamPrecedenceTest, Basic) {
159 SpdyStreamPrecedence spdy3_prec(2);
160 EXPECT_TRUE(spdy3_prec.is_spdy3_priority());
161 EXPECT_EQ(2, spdy3_prec.spdy3_priority());
162 EXPECT_EQ(kHttp2RootStreamId, spdy3_prec.parent_id());
163 EXPECT_EQ(Spdy3PriorityToHttp2Weight(2), spdy3_prec.weight());
164 EXPECT_FALSE(spdy3_prec.is_exclusive());
165
166 for (bool is_exclusive : {true, false}) {
167 SpdyStreamPrecedence h2_prec(7, 123, is_exclusive);
168 EXPECT_FALSE(h2_prec.is_spdy3_priority());
169 EXPECT_EQ(Http2WeightToSpdy3Priority(123), h2_prec.spdy3_priority());
170 EXPECT_EQ(7u, h2_prec.parent_id());
171 EXPECT_EQ(123, h2_prec.weight());
172 EXPECT_EQ(is_exclusive, h2_prec.is_exclusive());
173 }
174 }
175
TEST(SpdyStreamPrecedenceTest,Clamping)176 TEST(SpdyStreamPrecedenceTest, Clamping) {
177 EXPECT_QUICHE_BUG(EXPECT_EQ(7, SpdyStreamPrecedence(8).spdy3_priority()),
178 "Invalid priority: 8");
179 EXPECT_QUICHE_BUG(EXPECT_EQ(kHttp2MinStreamWeight,
180 SpdyStreamPrecedence(3, 0, false).weight()),
181 "Invalid weight: 0");
182 EXPECT_QUICHE_BUG(EXPECT_EQ(kHttp2MaxStreamWeight,
183 SpdyStreamPrecedence(3, 300, false).weight()),
184 "Invalid weight: 300");
185 }
186
TEST(SpdyStreamPrecedenceTest,Copying)187 TEST(SpdyStreamPrecedenceTest, Copying) {
188 SpdyStreamPrecedence prec1(3);
189 SpdyStreamPrecedence copy1(prec1);
190 EXPECT_TRUE(copy1.is_spdy3_priority());
191 EXPECT_EQ(3, copy1.spdy3_priority());
192
193 SpdyStreamPrecedence prec2(4, 5, true);
194 SpdyStreamPrecedence copy2(prec2);
195 EXPECT_FALSE(copy2.is_spdy3_priority());
196 EXPECT_EQ(4u, copy2.parent_id());
197 EXPECT_EQ(5, copy2.weight());
198 EXPECT_TRUE(copy2.is_exclusive());
199
200 copy1 = prec2;
201 EXPECT_FALSE(copy1.is_spdy3_priority());
202 EXPECT_EQ(4u, copy1.parent_id());
203 EXPECT_EQ(5, copy1.weight());
204 EXPECT_TRUE(copy1.is_exclusive());
205
206 copy2 = prec1;
207 EXPECT_TRUE(copy2.is_spdy3_priority());
208 EXPECT_EQ(3, copy2.spdy3_priority());
209 }
210
TEST(SpdyStreamPrecedenceTest,Equals)211 TEST(SpdyStreamPrecedenceTest, Equals) {
212 EXPECT_EQ(SpdyStreamPrecedence(3), SpdyStreamPrecedence(3));
213 EXPECT_NE(SpdyStreamPrecedence(3), SpdyStreamPrecedence(4));
214
215 EXPECT_EQ(SpdyStreamPrecedence(1, 2, false),
216 SpdyStreamPrecedence(1, 2, false));
217 EXPECT_NE(SpdyStreamPrecedence(1, 2, false),
218 SpdyStreamPrecedence(2, 2, false));
219 EXPECT_NE(SpdyStreamPrecedence(1, 2, false),
220 SpdyStreamPrecedence(1, 3, false));
221 EXPECT_NE(SpdyStreamPrecedence(1, 2, false),
222 SpdyStreamPrecedence(1, 2, true));
223
224 SpdyStreamPrecedence spdy3_prec(3);
225 SpdyStreamPrecedence h2_prec(spdy3_prec.parent_id(), spdy3_prec.weight(),
226 spdy3_prec.is_exclusive());
227 EXPECT_NE(spdy3_prec, h2_prec);
228 }
229
TEST(SpdyDataIRTest,Construct)230 TEST(SpdyDataIRTest, Construct) {
231 // Confirm that it makes a string of zero length from a
232 // absl::string_view(nullptr).
233 absl::string_view s1;
234 SpdyDataIR d1(/* stream_id = */ 1, s1);
235 EXPECT_EQ(0u, d1.data_len());
236 EXPECT_NE(nullptr, d1.data());
237
238 // Confirms makes a copy of char array.
239 const char s2[] = "something";
240 SpdyDataIR d2(/* stream_id = */ 2, s2);
241 EXPECT_EQ(absl::string_view(d2.data(), d2.data_len()), s2);
242 EXPECT_NE(absl::string_view(d1.data(), d1.data_len()), s2);
243 EXPECT_EQ((int)d1.data_len(), d1.flow_control_window_consumed());
244
245 // Confirm copies a const string.
246 const std::string foo = "foo";
247 SpdyDataIR d3(/* stream_id = */ 3, foo);
248 EXPECT_EQ(foo, d3.data());
249 EXPECT_EQ((int)d3.data_len(), d3.flow_control_window_consumed());
250
251 // Confirm copies a non-const string.
252 std::string bar = "bar";
253 SpdyDataIR d4(/* stream_id = */ 4, bar);
254 EXPECT_EQ("bar", bar);
255 EXPECT_EQ("bar", absl::string_view(d4.data(), d4.data_len()));
256
257 // Confirm moves an rvalue reference. Note that the test string "baz" is too
258 // short to trigger the move optimization, and instead a copy occurs.
259 std::string baz = "the quick brown fox";
260 SpdyDataIR d5(/* stream_id = */ 5, std::move(baz));
261 EXPECT_EQ("", baz);
262 EXPECT_EQ(absl::string_view(d5.data(), d5.data_len()), "the quick brown fox");
263
264 // Confirms makes a copy of string literal.
265 SpdyDataIR d7(/* stream_id = */ 7, "something else");
266 EXPECT_EQ(absl::string_view(d7.data(), d7.data_len()), "something else");
267
268 SpdyDataIR d8(/* stream_id = */ 8, "shawarma");
269 d8.set_padding_len(20);
270 EXPECT_EQ(28, d8.flow_control_window_consumed());
271 }
272
273 } // namespace test
274 } // namespace spdy
275