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