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/quic/core/quic_versions.h"
6
7 #include <cstddef>
8 #include <sstream>
9
10 #include "absl/algorithm/container.h"
11 #include "absl/base/macros.h"
12 #include "quiche/quic/platform/api/quic_expect_bug.h"
13 #include "quiche/quic/platform/api/quic_flags.h"
14 #include "quiche/quic/platform/api/quic_test.h"
15
16 namespace quic {
17 namespace test {
18 namespace {
19
20 using ::testing::ElementsAre;
21 using ::testing::IsEmpty;
22
TEST(QuicVersionsTest,CreateQuicVersionLabelUnsupported)23 TEST(QuicVersionsTest, CreateQuicVersionLabelUnsupported) {
24 EXPECT_QUIC_BUG(
25 CreateQuicVersionLabel(UnsupportedQuicVersion()),
26 "Unsupported version QUIC_VERSION_UNSUPPORTED PROTOCOL_UNSUPPORTED");
27 }
28
TEST(QuicVersionsTest,KnownAndValid)29 TEST(QuicVersionsTest, KnownAndValid) {
30 for (const ParsedQuicVersion& version : AllSupportedVersions()) {
31 EXPECT_TRUE(version.IsKnown());
32 EXPECT_TRUE(ParsedQuicVersionIsValid(version.handshake_protocol,
33 version.transport_version));
34 }
35 ParsedQuicVersion unsupported = UnsupportedQuicVersion();
36 EXPECT_FALSE(unsupported.IsKnown());
37 EXPECT_TRUE(ParsedQuicVersionIsValid(unsupported.handshake_protocol,
38 unsupported.transport_version));
39 ParsedQuicVersion reserved = QuicVersionReservedForNegotiation();
40 EXPECT_TRUE(reserved.IsKnown());
41 EXPECT_TRUE(ParsedQuicVersionIsValid(reserved.handshake_protocol,
42 reserved.transport_version));
43 // Check that invalid combinations are not valid.
44 EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_TLS1_3, QUIC_VERSION_46));
45 EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_QUIC_CRYPTO,
46 QUIC_VERSION_IETF_DRAFT_29));
47 // Check that deprecated versions are not valid.
48 EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_QUIC_CRYPTO,
49 static_cast<QuicTransportVersion>(33)));
50 EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_QUIC_CRYPTO,
51 static_cast<QuicTransportVersion>(99)));
52 EXPECT_FALSE(ParsedQuicVersionIsValid(PROTOCOL_TLS1_3,
53 static_cast<QuicTransportVersion>(99)));
54 }
55
TEST(QuicVersionsTest,Features)56 TEST(QuicVersionsTest, Features) {
57 ParsedQuicVersion parsed_version_q046 = ParsedQuicVersion::Q046();
58 ParsedQuicVersion parsed_version_draft_29 = ParsedQuicVersion::Draft29();
59
60 EXPECT_TRUE(parsed_version_q046.IsKnown());
61 EXPECT_FALSE(parsed_version_q046.KnowsWhichDecrypterToUse());
62 EXPECT_FALSE(parsed_version_q046.UsesInitialObfuscators());
63 EXPECT_FALSE(parsed_version_q046.AllowsLowFlowControlLimits());
64 EXPECT_FALSE(parsed_version_q046.HasHeaderProtection());
65 EXPECT_FALSE(parsed_version_q046.SupportsRetry());
66 EXPECT_FALSE(
67 parsed_version_q046.SendsVariableLengthPacketNumberInLongHeader());
68 EXPECT_FALSE(parsed_version_q046.AllowsVariableLengthConnectionIds());
69 EXPECT_FALSE(parsed_version_q046.SupportsClientConnectionIds());
70 EXPECT_FALSE(parsed_version_q046.HasLengthPrefixedConnectionIds());
71 EXPECT_FALSE(parsed_version_q046.SupportsAntiAmplificationLimit());
72 EXPECT_FALSE(parsed_version_q046.CanSendCoalescedPackets());
73 EXPECT_TRUE(parsed_version_q046.SupportsGoogleAltSvcFormat());
74 EXPECT_FALSE(parsed_version_q046.UsesHttp3());
75 EXPECT_FALSE(parsed_version_q046.HasLongHeaderLengths());
76 EXPECT_FALSE(parsed_version_q046.UsesCryptoFrames());
77 EXPECT_FALSE(parsed_version_q046.HasIetfQuicFrames());
78 EXPECT_FALSE(parsed_version_q046.UsesTls());
79 EXPECT_TRUE(parsed_version_q046.UsesQuicCrypto());
80
81 EXPECT_TRUE(parsed_version_draft_29.IsKnown());
82 EXPECT_TRUE(parsed_version_draft_29.KnowsWhichDecrypterToUse());
83 EXPECT_TRUE(parsed_version_draft_29.UsesInitialObfuscators());
84 EXPECT_TRUE(parsed_version_draft_29.AllowsLowFlowControlLimits());
85 EXPECT_TRUE(parsed_version_draft_29.HasHeaderProtection());
86 EXPECT_TRUE(parsed_version_draft_29.SupportsRetry());
87 EXPECT_TRUE(
88 parsed_version_draft_29.SendsVariableLengthPacketNumberInLongHeader());
89 EXPECT_TRUE(parsed_version_draft_29.AllowsVariableLengthConnectionIds());
90 EXPECT_TRUE(parsed_version_draft_29.SupportsClientConnectionIds());
91 EXPECT_TRUE(parsed_version_draft_29.HasLengthPrefixedConnectionIds());
92 EXPECT_TRUE(parsed_version_draft_29.SupportsAntiAmplificationLimit());
93 EXPECT_TRUE(parsed_version_draft_29.CanSendCoalescedPackets());
94 EXPECT_FALSE(parsed_version_draft_29.SupportsGoogleAltSvcFormat());
95 EXPECT_TRUE(parsed_version_draft_29.UsesHttp3());
96 EXPECT_TRUE(parsed_version_draft_29.HasLongHeaderLengths());
97 EXPECT_TRUE(parsed_version_draft_29.UsesCryptoFrames());
98 EXPECT_TRUE(parsed_version_draft_29.HasIetfQuicFrames());
99 EXPECT_TRUE(parsed_version_draft_29.UsesTls());
100 EXPECT_FALSE(parsed_version_draft_29.UsesQuicCrypto());
101 }
102
TEST(QuicVersionsTest,ParseQuicVersionLabel)103 TEST(QuicVersionsTest, ParseQuicVersionLabel) {
104 static_assert(SupportedVersions().size() == 4u,
105 "Supported versions out of sync");
106 EXPECT_EQ(ParsedQuicVersion::Q046(),
107 ParseQuicVersionLabel(MakeVersionLabel('Q', '0', '4', '6')));
108 EXPECT_EQ(ParsedQuicVersion::Draft29(),
109 ParseQuicVersionLabel(MakeVersionLabel(0xff, 0x00, 0x00, 0x1d)));
110 EXPECT_EQ(ParsedQuicVersion::RFCv1(),
111 ParseQuicVersionLabel(MakeVersionLabel(0x00, 0x00, 0x00, 0x01)));
112 EXPECT_EQ(ParsedQuicVersion::RFCv2(),
113 ParseQuicVersionLabel(MakeVersionLabel(0x6b, 0x33, 0x43, 0xcf)));
114 EXPECT_EQ((ParsedQuicVersionVector{ParsedQuicVersion::RFCv2(),
115 ParsedQuicVersion::RFCv1(),
116 ParsedQuicVersion::Draft29()}),
117 ParseQuicVersionLabelVector(QuicVersionLabelVector{
118 MakeVersionLabel(0x6b, 0x33, 0x43, 0xcf),
119 MakeVersionLabel(0x00, 0x00, 0x00, 0x01),
120 MakeVersionLabel(0xaa, 0xaa, 0xaa, 0xaa),
121 MakeVersionLabel(0xff, 0x00, 0x00, 0x1d)}));
122
123 for (const ParsedQuicVersion& version : AllSupportedVersions()) {
124 EXPECT_EQ(version, ParseQuicVersionLabel(CreateQuicVersionLabel(version)));
125 }
126 }
127
TEST(QuicVersionsTest,ParseQuicVersionString)128 TEST(QuicVersionsTest, ParseQuicVersionString) {
129 static_assert(SupportedVersions().size() == 4u,
130 "Supported versions out of sync");
131 EXPECT_EQ(ParsedQuicVersion::Q046(),
132 ParseQuicVersionString("QUIC_VERSION_46"));
133 EXPECT_EQ(ParsedQuicVersion::Q046(), ParseQuicVersionString("46"));
134 EXPECT_EQ(ParsedQuicVersion::Q046(), ParseQuicVersionString("Q046"));
135
136 EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionString(""));
137 EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionString("Q 46"));
138 EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionString("Q046 "));
139 EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionString("99"));
140 EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionString("70"));
141
142 EXPECT_EQ(ParsedQuicVersion::Draft29(), ParseQuicVersionString("ff00001d"));
143 EXPECT_EQ(ParsedQuicVersion::Draft29(), ParseQuicVersionString("draft29"));
144 EXPECT_EQ(ParsedQuicVersion::Draft29(), ParseQuicVersionString("h3-29"));
145
146 EXPECT_EQ(ParsedQuicVersion::RFCv1(), ParseQuicVersionString("00000001"));
147 EXPECT_EQ(ParsedQuicVersion::RFCv1(), ParseQuicVersionString("h3"));
148
149 // QUICv2 will never be the result for "h3".
150
151 for (const ParsedQuicVersion& version : AllSupportedVersions()) {
152 EXPECT_EQ(version,
153 ParseQuicVersionString(ParsedQuicVersionToString(version)));
154 EXPECT_EQ(version, ParseQuicVersionString(QuicVersionLabelToString(
155 CreateQuicVersionLabel(version))));
156 if (!version.AlpnDeferToRFCv1()) {
157 EXPECT_EQ(version, ParseQuicVersionString(AlpnForVersion(version)));
158 }
159 }
160 }
161
TEST(QuicVersionsTest,ParseQuicVersionVectorString)162 TEST(QuicVersionsTest, ParseQuicVersionVectorString) {
163 ParsedQuicVersion version_q046 = ParsedQuicVersion::Q046();
164 ParsedQuicVersion version_draft_29 = ParsedQuicVersion::Draft29();
165
166 EXPECT_THAT(ParseQuicVersionVectorString(""), IsEmpty());
167
168 EXPECT_THAT(ParseQuicVersionVectorString("QUIC_VERSION_46"),
169 ElementsAre(version_q046));
170 EXPECT_THAT(ParseQuicVersionVectorString("h3-Q046"),
171 ElementsAre(version_q046));
172 EXPECT_THAT(ParseQuicVersionVectorString("h3-Q046, h3-29"),
173 ElementsAre(version_q046, version_draft_29));
174 EXPECT_THAT(ParseQuicVersionVectorString("h3-29,h3-Q046,h3-29"),
175 ElementsAre(version_draft_29, version_q046));
176 EXPECT_THAT(ParseQuicVersionVectorString("h3-29, h3-Q046"),
177 ElementsAre(version_draft_29, version_q046));
178 EXPECT_THAT(ParseQuicVersionVectorString("QUIC_VERSION_46,h3-29"),
179 ElementsAre(version_q046, version_draft_29));
180 EXPECT_THAT(ParseQuicVersionVectorString("h3-29,QUIC_VERSION_46"),
181 ElementsAre(version_draft_29, version_q046));
182 EXPECT_THAT(ParseQuicVersionVectorString("QUIC_VERSION_46, h3-29"),
183 ElementsAre(version_q046, version_draft_29));
184 EXPECT_THAT(ParseQuicVersionVectorString("h3-29, QUIC_VERSION_46"),
185 ElementsAre(version_draft_29, version_q046));
186 EXPECT_THAT(ParseQuicVersionVectorString("h3-29,QUIC_VERSION_46"),
187 ElementsAre(version_draft_29, version_q046));
188 EXPECT_THAT(ParseQuicVersionVectorString("QUIC_VERSION_46,h3-29"),
189 ElementsAre(version_q046, version_draft_29));
190
191 // Regression test for https://crbug.com/1044952.
192 EXPECT_THAT(ParseQuicVersionVectorString("QUIC_VERSION_46, QUIC_VERSION_46"),
193 ElementsAre(version_q046));
194 EXPECT_THAT(ParseQuicVersionVectorString("h3-Q046, h3-Q046"),
195 ElementsAre(version_q046));
196 EXPECT_THAT(ParseQuicVersionVectorString("h3-Q046, QUIC_VERSION_46"),
197 ElementsAre(version_q046));
198 EXPECT_THAT(ParseQuicVersionVectorString(
199 "QUIC_VERSION_46, h3-Q046, QUIC_VERSION_46, h3-Q046"),
200 ElementsAre(version_q046));
201 EXPECT_THAT(ParseQuicVersionVectorString("QUIC_VERSION_46, h3-29, h3-Q046"),
202 ElementsAre(version_q046, version_draft_29));
203
204 EXPECT_THAT(ParseQuicVersionVectorString("99"), IsEmpty());
205 EXPECT_THAT(ParseQuicVersionVectorString("70"), IsEmpty());
206 EXPECT_THAT(ParseQuicVersionVectorString("h3-01"), IsEmpty());
207 EXPECT_THAT(ParseQuicVersionVectorString("h3-01,h3-29"),
208 ElementsAre(version_draft_29));
209 }
210
211 // Do not use MakeVersionLabel() to generate expectations, because
212 // CreateQuicVersionLabel() uses MakeVersionLabel() internally,
213 // in case it has a bug.
TEST(QuicVersionsTest,CreateQuicVersionLabel)214 TEST(QuicVersionsTest, CreateQuicVersionLabel) {
215 static_assert(SupportedVersions().size() == 4u,
216 "Supported versions out of sync");
217 EXPECT_EQ(0x51303436u, CreateQuicVersionLabel(ParsedQuicVersion::Q046()));
218 EXPECT_EQ(0xff00001du, CreateQuicVersionLabel(ParsedQuicVersion::Draft29()));
219 EXPECT_EQ(0x00000001u, CreateQuicVersionLabel(ParsedQuicVersion::RFCv1()));
220 EXPECT_EQ(0x6b3343cfu, CreateQuicVersionLabel(ParsedQuicVersion::RFCv2()));
221
222 // Make sure the negotiation reserved version is in the IETF reserved space.
223 EXPECT_EQ(
224 0xda5a3a3au & 0x0f0f0f0f,
225 CreateQuicVersionLabel(ParsedQuicVersion::ReservedForNegotiation()) &
226 0x0f0f0f0f);
227
228 // Make sure that disabling randomness works.
229 SetQuicFlag(quic_disable_version_negotiation_grease_randomness, true);
230 EXPECT_EQ(0xda5a3a3au, CreateQuicVersionLabel(
231 ParsedQuicVersion::ReservedForNegotiation()));
232 }
233
TEST(QuicVersionsTest,QuicVersionLabelToString)234 TEST(QuicVersionsTest, QuicVersionLabelToString) {
235 static_assert(SupportedVersions().size() == 4u,
236 "Supported versions out of sync");
237 EXPECT_EQ("Q046", QuicVersionLabelToString(
238 CreateQuicVersionLabel(ParsedQuicVersion::Q046())));
239 EXPECT_EQ("ff00001d", QuicVersionLabelToString(CreateQuicVersionLabel(
240 ParsedQuicVersion::Draft29())));
241 EXPECT_EQ("00000001", QuicVersionLabelToString(CreateQuicVersionLabel(
242 ParsedQuicVersion::RFCv1())));
243 EXPECT_EQ("6b3343cf", QuicVersionLabelToString(CreateQuicVersionLabel(
244 ParsedQuicVersion::RFCv2())));
245
246 QuicVersionLabelVector version_labels = {
247 MakeVersionLabel('Q', '0', '3', '5'),
248 MakeVersionLabel('T', '0', '3', '8'),
249 MakeVersionLabel(0xff, 0, 0, 7),
250 };
251
252 EXPECT_EQ("Q035", QuicVersionLabelToString(version_labels[0]));
253 EXPECT_EQ("T038", QuicVersionLabelToString(version_labels[1]));
254 EXPECT_EQ("ff000007", QuicVersionLabelToString(version_labels[2]));
255
256 EXPECT_EQ("Q035,T038,ff000007",
257 QuicVersionLabelVectorToString(version_labels));
258 EXPECT_EQ("Q035:T038:ff000007",
259 QuicVersionLabelVectorToString(version_labels, ":", 2));
260 EXPECT_EQ("Q035|T038|...",
261 QuicVersionLabelVectorToString(version_labels, "|", 1));
262
263 std::ostringstream os;
264 os << version_labels;
265 EXPECT_EQ("Q035,T038,ff000007", os.str());
266 }
267
TEST(QuicVersionsTest,ParseQuicVersionLabelString)268 TEST(QuicVersionsTest, ParseQuicVersionLabelString) {
269 static_assert(SupportedVersions().size() == 4u,
270 "Supported versions out of sync");
271 // Explicitly test known QUIC version label strings.
272 EXPECT_EQ(ParsedQuicVersion::Q046(), ParseQuicVersionLabelString("Q046"));
273 EXPECT_EQ(ParsedQuicVersion::Draft29(),
274 ParseQuicVersionLabelString("ff00001d"));
275 EXPECT_EQ(ParsedQuicVersion::RFCv1(),
276 ParseQuicVersionLabelString("00000001"));
277 EXPECT_EQ(ParsedQuicVersion::RFCv2(),
278 ParseQuicVersionLabelString("6b3343cf"));
279
280 // Sanity check that a variety of other serialization formats are ignored.
281 EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionLabelString("1"));
282 EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionLabelString("46"));
283 EXPECT_EQ(UnsupportedQuicVersion(),
284 ParseQuicVersionLabelString("QUIC_VERSION_46"));
285 EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionLabelString("h3"));
286 EXPECT_EQ(UnsupportedQuicVersion(), ParseQuicVersionLabelString("h3-29"));
287
288 // Test round-trips between QuicVersionLabelToString and
289 // ParseQuicVersionLabelString.
290 for (const ParsedQuicVersion& version : AllSupportedVersions()) {
291 EXPECT_EQ(version, ParseQuicVersionLabelString(QuicVersionLabelToString(
292 CreateQuicVersionLabel(version))));
293 }
294 }
295
TEST(QuicVersionsTest,QuicVersionToString)296 TEST(QuicVersionsTest, QuicVersionToString) {
297 EXPECT_EQ("QUIC_VERSION_UNSUPPORTED",
298 QuicVersionToString(QUIC_VERSION_UNSUPPORTED));
299
300 QuicTransportVersion single_version[] = {QUIC_VERSION_46};
301 QuicTransportVersionVector versions_vector;
302 for (size_t i = 0; i < ABSL_ARRAYSIZE(single_version); ++i) {
303 versions_vector.push_back(single_version[i]);
304 }
305 EXPECT_EQ("QUIC_VERSION_46",
306 QuicTransportVersionVectorToString(versions_vector));
307
308 QuicTransportVersion multiple_versions[] = {QUIC_VERSION_UNSUPPORTED,
309 QUIC_VERSION_46};
310 versions_vector.clear();
311 for (size_t i = 0; i < ABSL_ARRAYSIZE(multiple_versions); ++i) {
312 versions_vector.push_back(multiple_versions[i]);
313 }
314 EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_46",
315 QuicTransportVersionVectorToString(versions_vector));
316
317 // Make sure that all supported versions are present in QuicVersionToString.
318 for (const ParsedQuicVersion& version : AllSupportedVersions()) {
319 EXPECT_NE("QUIC_VERSION_UNSUPPORTED",
320 QuicVersionToString(version.transport_version));
321 }
322
323 std::ostringstream os;
324 os << versions_vector;
325 EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_46", os.str());
326 }
327
TEST(QuicVersionsTest,ParsedQuicVersionToString)328 TEST(QuicVersionsTest, ParsedQuicVersionToString) {
329 EXPECT_EQ("0", ParsedQuicVersionToString(ParsedQuicVersion::Unsupported()));
330 EXPECT_EQ("Q046", ParsedQuicVersionToString(ParsedQuicVersion::Q046()));
331 EXPECT_EQ("draft29", ParsedQuicVersionToString(ParsedQuicVersion::Draft29()));
332 EXPECT_EQ("RFCv1", ParsedQuicVersionToString(ParsedQuicVersion::RFCv1()));
333 EXPECT_EQ("RFCv2", ParsedQuicVersionToString(ParsedQuicVersion::RFCv2()));
334
335 ParsedQuicVersionVector versions_vector = {ParsedQuicVersion::Q046()};
336 EXPECT_EQ("Q046", ParsedQuicVersionVectorToString(versions_vector));
337
338 versions_vector = {ParsedQuicVersion::Unsupported(),
339 ParsedQuicVersion::Q046()};
340 EXPECT_EQ("0,Q046", ParsedQuicVersionVectorToString(versions_vector));
341 EXPECT_EQ("0:Q046", ParsedQuicVersionVectorToString(versions_vector, ":",
342 versions_vector.size()));
343 EXPECT_EQ("0|...", ParsedQuicVersionVectorToString(versions_vector, "|", 0));
344
345 // Make sure that all supported versions are present in
346 // ParsedQuicVersionToString.
347 for (const ParsedQuicVersion& version : AllSupportedVersions()) {
348 EXPECT_NE("0", ParsedQuicVersionToString(version));
349 }
350
351 std::ostringstream os;
352 os << versions_vector;
353 EXPECT_EQ("0,Q046", os.str());
354 }
355
TEST(QuicVersionsTest,FilterSupportedVersionsAllVersions)356 TEST(QuicVersionsTest, FilterSupportedVersionsAllVersions) {
357 for (const ParsedQuicVersion& version : AllSupportedVersions()) {
358 QuicEnableVersion(version);
359 }
360 ParsedQuicVersionVector expected_parsed_versions;
361 for (const ParsedQuicVersion& version : SupportedVersions()) {
362 expected_parsed_versions.push_back(version);
363 }
364 EXPECT_EQ(expected_parsed_versions,
365 FilterSupportedVersions(AllSupportedVersions()));
366 EXPECT_EQ(expected_parsed_versions, AllSupportedVersions());
367 }
368
TEST(QuicVersionsTest,FilterSupportedVersionsWithoutFirstVersion)369 TEST(QuicVersionsTest, FilterSupportedVersionsWithoutFirstVersion) {
370 for (const ParsedQuicVersion& version : AllSupportedVersions()) {
371 QuicEnableVersion(version);
372 }
373 QuicDisableVersion(AllSupportedVersions().front());
374 ParsedQuicVersionVector expected_parsed_versions;
375 for (const ParsedQuicVersion& version : SupportedVersions()) {
376 expected_parsed_versions.push_back(version);
377 }
378 expected_parsed_versions.erase(expected_parsed_versions.begin());
379 EXPECT_EQ(expected_parsed_versions,
380 FilterSupportedVersions(AllSupportedVersions()));
381 }
382
TEST(QuicVersionsTest,LookUpParsedVersionByIndex)383 TEST(QuicVersionsTest, LookUpParsedVersionByIndex) {
384 ParsedQuicVersionVector all_versions = AllSupportedVersions();
385 int version_count = all_versions.size();
386 for (int i = -5; i <= version_count + 1; ++i) {
387 ParsedQuicVersionVector index = ParsedVersionOfIndex(all_versions, i);
388 if (i >= 0 && i < version_count) {
389 EXPECT_EQ(all_versions[i], index[0]);
390 } else {
391 EXPECT_EQ(UnsupportedQuicVersion(), index[0]);
392 }
393 }
394 }
395
396 // This test may appear to be so simplistic as to be unnecessary,
397 // yet a typo was made in doing the #defines and it was caught
398 // only in some test far removed from here... Better safe than sorry.
TEST(QuicVersionsTest,CheckTransportVersionNumbersForTypos)399 TEST(QuicVersionsTest, CheckTransportVersionNumbersForTypos) {
400 static_assert(SupportedVersions().size() == 4u,
401 "Supported versions out of sync");
402 EXPECT_EQ(QUIC_VERSION_46, 46);
403 EXPECT_EQ(QUIC_VERSION_IETF_DRAFT_29, 73);
404 EXPECT_EQ(QUIC_VERSION_IETF_RFC_V1, 80);
405 EXPECT_EQ(QUIC_VERSION_IETF_RFC_V2, 82);
406 }
407
TEST(QuicVersionsTest,AlpnForVersion)408 TEST(QuicVersionsTest, AlpnForVersion) {
409 static_assert(SupportedVersions().size() == 4u,
410 "Supported versions out of sync");
411 EXPECT_EQ("h3-Q046", AlpnForVersion(ParsedQuicVersion::Q046()));
412 EXPECT_EQ("h3-29", AlpnForVersion(ParsedQuicVersion::Draft29()));
413 EXPECT_EQ("h3", AlpnForVersion(ParsedQuicVersion::RFCv1()));
414 EXPECT_EQ("h3", AlpnForVersion(ParsedQuicVersion::RFCv2()));
415 }
416
TEST(QuicVersionsTest,QuicVersionEnabling)417 TEST(QuicVersionsTest, QuicVersionEnabling) {
418 for (const ParsedQuicVersion& version : AllSupportedVersions()) {
419 QuicFlagSaver flag_saver;
420 QuicDisableVersion(version);
421 EXPECT_FALSE(QuicVersionIsEnabled(version));
422 QuicEnableVersion(version);
423 EXPECT_TRUE(QuicVersionIsEnabled(version));
424 }
425 }
426
TEST(QuicVersionsTest,ReservedForNegotiation)427 TEST(QuicVersionsTest, ReservedForNegotiation) {
428 EXPECT_EQ(QUIC_VERSION_RESERVED_FOR_NEGOTIATION,
429 QuicVersionReservedForNegotiation().transport_version);
430 // QUIC_VERSION_RESERVED_FOR_NEGOTIATION MUST NOT be supported.
431 for (const ParsedQuicVersion& version : AllSupportedVersions()) {
432 EXPECT_NE(QUIC_VERSION_RESERVED_FOR_NEGOTIATION, version.transport_version);
433 }
434 }
435
TEST(QuicVersionsTest,SupportedVersionsHasCorrectList)436 TEST(QuicVersionsTest, SupportedVersionsHasCorrectList) {
437 size_t index = 0;
438 for (HandshakeProtocol handshake_protocol : SupportedHandshakeProtocols()) {
439 for (int trans_vers = 255; trans_vers > 0; trans_vers--) {
440 QuicTransportVersion transport_version =
441 static_cast<QuicTransportVersion>(trans_vers);
442 SCOPED_TRACE(index);
443 if (ParsedQuicVersionIsValid(handshake_protocol, transport_version)) {
444 ParsedQuicVersion version = SupportedVersions()[index];
445 EXPECT_EQ(version,
446 ParsedQuicVersion(handshake_protocol, transport_version));
447 index++;
448 }
449 }
450 }
451 EXPECT_EQ(SupportedVersions().size(), index);
452 }
453
TEST(QuicVersionsTest,SupportedVersionsAllDistinct)454 TEST(QuicVersionsTest, SupportedVersionsAllDistinct) {
455 for (size_t index1 = 0; index1 < SupportedVersions().size(); ++index1) {
456 ParsedQuicVersion version1 = SupportedVersions()[index1];
457 for (size_t index2 = index1 + 1; index2 < SupportedVersions().size();
458 ++index2) {
459 ParsedQuicVersion version2 = SupportedVersions()[index2];
460 EXPECT_NE(version1, version2) << version1 << " " << version2;
461 EXPECT_NE(CreateQuicVersionLabel(version1),
462 CreateQuicVersionLabel(version2))
463 << version1 << " " << version2;
464 // The one pair where ALPNs are the same.
465 if ((version1 != ParsedQuicVersion::RFCv2()) &&
466 (version2 != ParsedQuicVersion::RFCv1())) {
467 EXPECT_NE(AlpnForVersion(version1), AlpnForVersion(version2))
468 << version1 << " " << version2;
469 }
470 }
471 }
472 }
473
TEST(QuicVersionsTest,CurrentSupportedHttp3Versions)474 TEST(QuicVersionsTest, CurrentSupportedHttp3Versions) {
475 ParsedQuicVersionVector h3_versions = CurrentSupportedHttp3Versions();
476 ParsedQuicVersionVector all_current_supported_versions =
477 CurrentSupportedVersions();
478 for (auto& version : all_current_supported_versions) {
479 bool version_is_h3 = false;
480 for (auto& h3_version : h3_versions) {
481 if (version == h3_version) {
482 EXPECT_TRUE(version.UsesHttp3());
483 version_is_h3 = true;
484 break;
485 }
486 }
487 if (!version_is_h3) {
488 EXPECT_FALSE(version.UsesHttp3());
489 }
490 }
491 }
492
TEST(QuicVersionsTest,ObsoleteSupportedVersions)493 TEST(QuicVersionsTest, ObsoleteSupportedVersions) {
494 ParsedQuicVersionVector obsolete_versions = ObsoleteSupportedVersions();
495 EXPECT_EQ(quic::ParsedQuicVersion::Q046(), obsolete_versions[0]);
496 EXPECT_EQ(quic::ParsedQuicVersion::Draft29(), obsolete_versions[1]);
497 }
498
TEST(QuicVersionsTest,IsObsoleteSupportedVersion)499 TEST(QuicVersionsTest, IsObsoleteSupportedVersion) {
500 for (const ParsedQuicVersion& version : AllSupportedVersions()) {
501 bool is_obsolete = version.handshake_protocol != PROTOCOL_TLS1_3 ||
502 version.transport_version < QUIC_VERSION_IETF_RFC_V1;
503 EXPECT_EQ(is_obsolete, IsObsoleteSupportedVersion(version));
504 }
505 }
506
TEST(QuicVersionsTest,CurrentSupportedVersionsForClients)507 TEST(QuicVersionsTest, CurrentSupportedVersionsForClients) {
508 ParsedQuicVersionVector supported_versions = CurrentSupportedVersions();
509 ParsedQuicVersionVector client_versions =
510 CurrentSupportedVersionsForClients();
511 for (auto& version : supported_versions) {
512 const bool is_obsolete = IsObsoleteSupportedVersion(version);
513 const bool is_supported =
514 absl::c_find(client_versions, version) != client_versions.end();
515 // Every supported version which is not obsolete should be a supported
516 // client version.
517 EXPECT_EQ(!is_obsolete, is_supported);
518 }
519 // Every client version should be a supported version, of course.
520 for (auto& version : client_versions) {
521 EXPECT_TRUE(absl::c_find(supported_versions, version) !=
522 supported_versions.end());
523 }
524 }
525
526 } // namespace
527 } // namespace test
528 } // namespace quic
529