| // Copyright (c) 2015 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "spdy/core/spdy_alt_svc_wire_format.h" |
| |
| #include "common/platform/api/quiche_test.h" |
| |
| namespace spdy { |
| |
| namespace test { |
| |
| // Expose all private methods of class SpdyAltSvcWireFormat. |
| class SpdyAltSvcWireFormatPeer { |
| public: |
| static void SkipWhiteSpace(absl::string_view::const_iterator* c, |
| absl::string_view::const_iterator end) { |
| SpdyAltSvcWireFormat::SkipWhiteSpace(c, end); |
| } |
| static bool PercentDecode(absl::string_view::const_iterator c, |
| absl::string_view::const_iterator end, |
| std::string* output) { |
| return SpdyAltSvcWireFormat::PercentDecode(c, end, output); |
| } |
| static bool ParseAltAuthority(absl::string_view::const_iterator c, |
| absl::string_view::const_iterator end, |
| std::string* host, |
| uint16_t* port) { |
| return SpdyAltSvcWireFormat::ParseAltAuthority(c, end, host, port); |
| } |
| static bool ParsePositiveInteger16(absl::string_view::const_iterator c, |
| absl::string_view::const_iterator end, |
| uint16_t* max_age_seconds) { |
| return SpdyAltSvcWireFormat::ParsePositiveInteger16(c, end, |
| max_age_seconds); |
| } |
| static bool ParsePositiveInteger32(absl::string_view::const_iterator c, |
| absl::string_view::const_iterator end, |
| uint32_t* max_age_seconds) { |
| return SpdyAltSvcWireFormat::ParsePositiveInteger32(c, end, |
| max_age_seconds); |
| } |
| static char HexDigitToInt(char c) { |
| return SpdyAltSvcWireFormat::HexDigitToInt(c); |
| } |
| static bool HexDecodeToUInt32(absl::string_view data, uint32_t* value) { |
| return SpdyAltSvcWireFormat::HexDecodeToUInt32(data, value); |
| } |
| }; |
| |
| namespace { |
| |
| // Generate header field values, possibly with multiply defined parameters and |
| // random case, and corresponding AlternativeService entries. |
| void FuzzHeaderFieldValue( |
| int i, |
| std::string* header_field_value, |
| SpdyAltSvcWireFormat::AlternativeService* expected_altsvc) { |
| if (!header_field_value->empty()) { |
| header_field_value->push_back(','); |
| } |
| // TODO(b/77515496): use struct of bools instead of int |i| to generate the |
| // header field value. |
| bool is_ietf_format_quic = (i & 1 << 0) != 0; |
| if (i & 1 << 0) { |
| expected_altsvc->protocol_id = "hq"; |
| header_field_value->append("hq=\""); |
| } else { |
| expected_altsvc->protocol_id = "a=b%c"; |
| header_field_value->append("a%3Db%25c=\""); |
| } |
| if (i & 1 << 1) { |
| expected_altsvc->host = "foo\"bar\\baz"; |
| header_field_value->append("foo\\\"bar\\\\baz"); |
| } else { |
| expected_altsvc->host = ""; |
| } |
| expected_altsvc->port = 42; |
| header_field_value->append(":42\""); |
| if (i & 1 << 2) { |
| header_field_value->append(" "); |
| } |
| if (i & 3 << 3) { |
| expected_altsvc->max_age_seconds = 1111; |
| header_field_value->append(";"); |
| if (i & 1 << 3) { |
| header_field_value->append(" "); |
| } |
| header_field_value->append("mA=1111"); |
| if (i & 2 << 3) { |
| header_field_value->append(" "); |
| } |
| } |
| if (i & 1 << 5) { |
| header_field_value->append("; J=s"); |
| } |
| if (i & 1 << 6) { |
| if (is_ietf_format_quic) { |
| if (i & 1 << 7) { |
| expected_altsvc->version.push_back(0x923457e); |
| header_field_value->append("; quic=923457E"); |
| } else { |
| expected_altsvc->version.push_back(1); |
| expected_altsvc->version.push_back(0xFFFFFFFF); |
| header_field_value->append("; quic=1; quic=fFfFffFf"); |
| } |
| } else { |
| if (i & i << 7) { |
| expected_altsvc->version.push_back(24); |
| header_field_value->append("; v=\"24\""); |
| } else { |
| expected_altsvc->version.push_back(1); |
| expected_altsvc->version.push_back(65535); |
| header_field_value->append("; v=\"1,65535\""); |
| } |
| } |
| } |
| if (i & 1 << 8) { |
| expected_altsvc->max_age_seconds = 999999999; |
| header_field_value->append("; Ma=999999999"); |
| } |
| if (i & 1 << 9) { |
| header_field_value->append(";"); |
| } |
| if (i & 1 << 10) { |
| header_field_value->append(" "); |
| } |
| if (i & 1 << 11) { |
| header_field_value->append(","); |
| } |
| if (i & 1 << 12) { |
| header_field_value->append(" "); |
| } |
| } |
| |
| // Generate AlternativeService entries and corresponding header field values in |
| // canonical form, that is, what SerializeHeaderFieldValue() should output. |
| void FuzzAlternativeService(int i, |
| SpdyAltSvcWireFormat::AlternativeService* altsvc, |
| std::string* expected_header_field_value) { |
| if (!expected_header_field_value->empty()) { |
| expected_header_field_value->push_back(','); |
| } |
| altsvc->protocol_id = "a=b%c"; |
| altsvc->port = 42; |
| expected_header_field_value->append("a%3Db%25c=\""); |
| if (i & 1 << 0) { |
| altsvc->host = "foo\"bar\\baz"; |
| expected_header_field_value->append("foo\\\"bar\\\\baz"); |
| } |
| expected_header_field_value->append(":42\""); |
| if (i & 1 << 1) { |
| altsvc->max_age_seconds = 1111; |
| expected_header_field_value->append("; ma=1111"); |
| } |
| if (i & 1 << 2) { |
| altsvc->version.push_back(24); |
| altsvc->version.push_back(25); |
| expected_header_field_value->append("; v=\"24,25\""); |
| } |
| } |
| |
| // Tests of public API. |
| |
| TEST(SpdyAltSvcWireFormatTest, DefaultValues) { |
| SpdyAltSvcWireFormat::AlternativeService altsvc; |
| EXPECT_EQ("", altsvc.protocol_id); |
| EXPECT_EQ("", altsvc.host); |
| EXPECT_EQ(0u, altsvc.port); |
| EXPECT_EQ(86400u, altsvc.max_age_seconds); |
| EXPECT_TRUE(altsvc.version.empty()); |
| } |
| |
| TEST(SpdyAltSvcWireFormatTest, ParseInvalidEmptyHeaderFieldValue) { |
| SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector; |
| ASSERT_FALSE(SpdyAltSvcWireFormat::ParseHeaderFieldValue("", &altsvc_vector)); |
| } |
| |
| TEST(SpdyAltSvcWireFormatTest, ParseHeaderFieldValueClear) { |
| SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector; |
| ASSERT_TRUE( |
| SpdyAltSvcWireFormat::ParseHeaderFieldValue("clear", &altsvc_vector)); |
| EXPECT_EQ(0u, altsvc_vector.size()); |
| } |
| |
| // Fuzz test of ParseHeaderFieldValue() with optional whitespaces, ignored |
| // parameters, duplicate parameters, trailing space, trailing alternate service |
| // separator, etc. Single alternative service at a time. |
| TEST(SpdyAltSvcWireFormatTest, ParseHeaderFieldValue) { |
| for (int i = 0; i < 1 << 13; ++i) { |
| std::string header_field_value; |
| SpdyAltSvcWireFormat::AlternativeService expected_altsvc; |
| FuzzHeaderFieldValue(i, &header_field_value, &expected_altsvc); |
| SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector; |
| ASSERT_TRUE(SpdyAltSvcWireFormat::ParseHeaderFieldValue(header_field_value, |
| &altsvc_vector)); |
| ASSERT_EQ(1u, altsvc_vector.size()); |
| EXPECT_EQ(expected_altsvc.protocol_id, altsvc_vector[0].protocol_id); |
| EXPECT_EQ(expected_altsvc.host, altsvc_vector[0].host); |
| EXPECT_EQ(expected_altsvc.port, altsvc_vector[0].port); |
| EXPECT_EQ(expected_altsvc.max_age_seconds, |
| altsvc_vector[0].max_age_seconds); |
| EXPECT_EQ(expected_altsvc.version, altsvc_vector[0].version); |
| |
| // Roundtrip test starting with |altsvc_vector|. |
| std::string reserialized_header_field_value = |
| SpdyAltSvcWireFormat::SerializeHeaderFieldValue(altsvc_vector); |
| SpdyAltSvcWireFormat::AlternativeServiceVector roundtrip_altsvc_vector; |
| ASSERT_TRUE(SpdyAltSvcWireFormat::ParseHeaderFieldValue( |
| reserialized_header_field_value, &roundtrip_altsvc_vector)); |
| ASSERT_EQ(1u, roundtrip_altsvc_vector.size()); |
| EXPECT_EQ(expected_altsvc.protocol_id, |
| roundtrip_altsvc_vector[0].protocol_id); |
| EXPECT_EQ(expected_altsvc.host, roundtrip_altsvc_vector[0].host); |
| EXPECT_EQ(expected_altsvc.port, roundtrip_altsvc_vector[0].port); |
| EXPECT_EQ(expected_altsvc.max_age_seconds, |
| roundtrip_altsvc_vector[0].max_age_seconds); |
| EXPECT_EQ(expected_altsvc.version, roundtrip_altsvc_vector[0].version); |
| } |
| } |
| |
| // Fuzz test of ParseHeaderFieldValue() with optional whitespaces, ignored |
| // parameters, duplicate parameters, trailing space, trailing alternate service |
| // separator, etc. Possibly multiple alternative service at a time. |
| TEST(SpdyAltSvcWireFormatTest, ParseHeaderFieldValueMultiple) { |
| for (int i = 0; i < 1 << 13;) { |
| std::string header_field_value; |
| SpdyAltSvcWireFormat::AlternativeServiceVector expected_altsvc_vector; |
| // This will generate almost two hundred header field values with two, |
| // three, four, five, six, and seven alternative services each, and |
| // thousands with a single one. |
| do { |
| SpdyAltSvcWireFormat::AlternativeService expected_altsvc; |
| FuzzHeaderFieldValue(i, &header_field_value, &expected_altsvc); |
| expected_altsvc_vector.push_back(expected_altsvc); |
| ++i; |
| } while (i % 6 < i % 7); |
| SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector; |
| ASSERT_TRUE(SpdyAltSvcWireFormat::ParseHeaderFieldValue(header_field_value, |
| &altsvc_vector)); |
| ASSERT_EQ(expected_altsvc_vector.size(), altsvc_vector.size()); |
| for (unsigned int j = 0; j < altsvc_vector.size(); ++j) { |
| EXPECT_EQ(expected_altsvc_vector[j].protocol_id, |
| altsvc_vector[j].protocol_id); |
| EXPECT_EQ(expected_altsvc_vector[j].host, altsvc_vector[j].host); |
| EXPECT_EQ(expected_altsvc_vector[j].port, altsvc_vector[j].port); |
| EXPECT_EQ(expected_altsvc_vector[j].max_age_seconds, |
| altsvc_vector[j].max_age_seconds); |
| EXPECT_EQ(expected_altsvc_vector[j].version, altsvc_vector[j].version); |
| } |
| |
| // Roundtrip test starting with |altsvc_vector|. |
| std::string reserialized_header_field_value = |
| SpdyAltSvcWireFormat::SerializeHeaderFieldValue(altsvc_vector); |
| SpdyAltSvcWireFormat::AlternativeServiceVector roundtrip_altsvc_vector; |
| ASSERT_TRUE(SpdyAltSvcWireFormat::ParseHeaderFieldValue( |
| reserialized_header_field_value, &roundtrip_altsvc_vector)); |
| ASSERT_EQ(expected_altsvc_vector.size(), roundtrip_altsvc_vector.size()); |
| for (unsigned int j = 0; j < roundtrip_altsvc_vector.size(); ++j) { |
| EXPECT_EQ(expected_altsvc_vector[j].protocol_id, |
| roundtrip_altsvc_vector[j].protocol_id); |
| EXPECT_EQ(expected_altsvc_vector[j].host, |
| roundtrip_altsvc_vector[j].host); |
| EXPECT_EQ(expected_altsvc_vector[j].port, |
| roundtrip_altsvc_vector[j].port); |
| EXPECT_EQ(expected_altsvc_vector[j].max_age_seconds, |
| roundtrip_altsvc_vector[j].max_age_seconds); |
| EXPECT_EQ(expected_altsvc_vector[j].version, |
| roundtrip_altsvc_vector[j].version); |
| } |
| } |
| } |
| |
| TEST(SpdyAltSvcWireFormatTest, SerializeEmptyHeaderFieldValue) { |
| SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector; |
| EXPECT_EQ("clear", |
| SpdyAltSvcWireFormat::SerializeHeaderFieldValue(altsvc_vector)); |
| } |
| |
| // Test ParseHeaderFieldValue() and SerializeHeaderFieldValue() on the same pair |
| // of |expected_header_field_value| and |altsvc|, with and without hostname and |
| // each |
| // parameter. Single alternative service at a time. |
| TEST(SpdyAltSvcWireFormatTest, RoundTrip) { |
| for (int i = 0; i < 1 << 3; ++i) { |
| SpdyAltSvcWireFormat::AlternativeService altsvc; |
| std::string expected_header_field_value; |
| FuzzAlternativeService(i, &altsvc, &expected_header_field_value); |
| |
| // Test ParseHeaderFieldValue(). |
| SpdyAltSvcWireFormat::AlternativeServiceVector parsed_altsvc_vector; |
| ASSERT_TRUE(SpdyAltSvcWireFormat::ParseHeaderFieldValue( |
| expected_header_field_value, &parsed_altsvc_vector)); |
| ASSERT_EQ(1u, parsed_altsvc_vector.size()); |
| EXPECT_EQ(altsvc.protocol_id, parsed_altsvc_vector[0].protocol_id); |
| EXPECT_EQ(altsvc.host, parsed_altsvc_vector[0].host); |
| EXPECT_EQ(altsvc.port, parsed_altsvc_vector[0].port); |
| EXPECT_EQ(altsvc.max_age_seconds, parsed_altsvc_vector[0].max_age_seconds); |
| EXPECT_EQ(altsvc.version, parsed_altsvc_vector[0].version); |
| |
| // Test SerializeHeaderFieldValue(). |
| SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector; |
| altsvc_vector.push_back(altsvc); |
| EXPECT_EQ(expected_header_field_value, |
| SpdyAltSvcWireFormat::SerializeHeaderFieldValue(altsvc_vector)); |
| } |
| } |
| |
| // Test ParseHeaderFieldValue() and SerializeHeaderFieldValue() on the same pair |
| // of |expected_header_field_value| and |altsvc|, with and without hostname and |
| // each |
| // parameter. Multiple alternative services at a time. |
| TEST(SpdyAltSvcWireFormatTest, RoundTripMultiple) { |
| SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector; |
| std::string expected_header_field_value; |
| for (int i = 0; i < 1 << 3; ++i) { |
| SpdyAltSvcWireFormat::AlternativeService altsvc; |
| FuzzAlternativeService(i, &altsvc, &expected_header_field_value); |
| altsvc_vector.push_back(altsvc); |
| } |
| |
| // Test ParseHeaderFieldValue(). |
| SpdyAltSvcWireFormat::AlternativeServiceVector parsed_altsvc_vector; |
| ASSERT_TRUE(SpdyAltSvcWireFormat::ParseHeaderFieldValue( |
| expected_header_field_value, &parsed_altsvc_vector)); |
| ASSERT_EQ(altsvc_vector.size(), parsed_altsvc_vector.size()); |
| auto expected_it = altsvc_vector.begin(); |
| auto parsed_it = parsed_altsvc_vector.begin(); |
| for (; expected_it != altsvc_vector.end(); ++expected_it, ++parsed_it) { |
| EXPECT_EQ(expected_it->protocol_id, parsed_it->protocol_id); |
| EXPECT_EQ(expected_it->host, parsed_it->host); |
| EXPECT_EQ(expected_it->port, parsed_it->port); |
| EXPECT_EQ(expected_it->max_age_seconds, parsed_it->max_age_seconds); |
| EXPECT_EQ(expected_it->version, parsed_it->version); |
| } |
| |
| // Test SerializeHeaderFieldValue(). |
| EXPECT_EQ(expected_header_field_value, |
| SpdyAltSvcWireFormat::SerializeHeaderFieldValue(altsvc_vector)); |
| } |
| |
| // ParseHeaderFieldValue() should return false on malformed field values: |
| // invalid percent encoding, unmatched quotation mark, empty port, non-numeric |
| // characters in numeric fields. |
| TEST(SpdyAltSvcWireFormatTest, ParseHeaderFieldValueInvalid) { |
| SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector; |
| const char* invalid_field_value_array[] = {"a%", |
| "a%x", |
| "a%b", |
| "a%9z", |
| "a=", |
| "a=\"", |
| "a=\"b\"", |
| "a=\":\"", |
| "a=\"c:\"", |
| "a=\"c:foo\"", |
| "a=\"c:42foo\"", |
| "a=\"b:42\"bar", |
| "a=\"b:42\" ; m", |
| "a=\"b:42\" ; min-age", |
| "a=\"b:42\" ; ma", |
| "a=\"b:42\" ; ma=", |
| "a=\"b:42\" ; v=\"..\"", |
| "a=\"b:42\" ; ma=ma", |
| "a=\"b:42\" ; ma=123bar", |
| "a=\"b:42\" ; v=24", |
| "a=\"b:42\" ; v=24,25", |
| "a=\"b:42\" ; v=\"-3\"", |
| "a=\"b:42\" ; v=\"1.2\"", |
| "a=\"b:42\" ; v=\"24,\""}; |
| for (const char* invalid_field_value : invalid_field_value_array) { |
| EXPECT_FALSE(SpdyAltSvcWireFormat::ParseHeaderFieldValue( |
| invalid_field_value, &altsvc_vector)) |
| << invalid_field_value; |
| } |
| } |
| |
| // ParseHeaderFieldValue() should return false on a field values truncated |
| // before closing quotation mark, without trying to access memory beyond the end |
| // of the input. |
| TEST(SpdyAltSvcWireFormatTest, ParseTruncatedHeaderFieldValue) { |
| SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector; |
| const char* field_value_array[] = {"a=\":137\"", "a=\"foo:137\"", |
| "a%25=\"foo\\\"bar\\\\baz:137\""}; |
| for (const std::string& field_value : field_value_array) { |
| for (size_t len = 1; len < field_value.size(); ++len) { |
| EXPECT_FALSE(SpdyAltSvcWireFormat::ParseHeaderFieldValue( |
| field_value.substr(0, len), &altsvc_vector)) |
| << len; |
| } |
| } |
| } |
| |
| // Tests of private methods. |
| |
| // Test SkipWhiteSpace(). |
| TEST(SpdyAltSvcWireFormatTest, SkipWhiteSpace) { |
| absl::string_view input("a \tb "); |
| absl::string_view::const_iterator c = input.begin(); |
| SpdyAltSvcWireFormatPeer::SkipWhiteSpace(&c, input.end()); |
| ASSERT_EQ(input.begin(), c); |
| ++c; |
| SpdyAltSvcWireFormatPeer::SkipWhiteSpace(&c, input.end()); |
| ASSERT_EQ(input.begin() + 3, c); |
| ++c; |
| SpdyAltSvcWireFormatPeer::SkipWhiteSpace(&c, input.end()); |
| ASSERT_EQ(input.end(), c); |
| } |
| |
| // Test PercentDecode() on valid input. |
| TEST(SpdyAltSvcWireFormatTest, PercentDecodeValid) { |
| absl::string_view input(""); |
| std::string output; |
| ASSERT_TRUE(SpdyAltSvcWireFormatPeer::PercentDecode(input.begin(), |
| input.end(), &output)); |
| EXPECT_EQ("", output); |
| |
| input = absl::string_view("foo"); |
| output.clear(); |
| ASSERT_TRUE(SpdyAltSvcWireFormatPeer::PercentDecode(input.begin(), |
| input.end(), &output)); |
| EXPECT_EQ("foo", output); |
| |
| input = absl::string_view("%2ca%5Cb"); |
| output.clear(); |
| ASSERT_TRUE(SpdyAltSvcWireFormatPeer::PercentDecode(input.begin(), |
| input.end(), &output)); |
| EXPECT_EQ(",a\\b", output); |
| } |
| |
| // Test PercentDecode() on invalid input. |
| TEST(SpdyAltSvcWireFormatTest, PercentDecodeInvalid) { |
| const char* invalid_input_array[] = {"a%", "a%x", "a%b", "%J22", "%9z"}; |
| for (const char* invalid_input : invalid_input_array) { |
| absl::string_view input(invalid_input); |
| std::string output; |
| EXPECT_FALSE(SpdyAltSvcWireFormatPeer::PercentDecode(input.begin(), |
| input.end(), &output)) |
| << input; |
| } |
| } |
| |
| // Test ParseAltAuthority() on valid input. |
| TEST(SpdyAltSvcWireFormatTest, ParseAltAuthorityValid) { |
| absl::string_view input(":42"); |
| std::string host; |
| uint16_t port; |
| ASSERT_TRUE(SpdyAltSvcWireFormatPeer::ParseAltAuthority( |
| input.begin(), input.end(), &host, &port)); |
| EXPECT_TRUE(host.empty()); |
| EXPECT_EQ(42, port); |
| |
| input = absl::string_view("foo:137"); |
| ASSERT_TRUE(SpdyAltSvcWireFormatPeer::ParseAltAuthority( |
| input.begin(), input.end(), &host, &port)); |
| EXPECT_EQ("foo", host); |
| EXPECT_EQ(137, port); |
| |
| input = absl::string_view("[2003:8:0:16::509d:9615]:443"); |
| ASSERT_TRUE(SpdyAltSvcWireFormatPeer::ParseAltAuthority( |
| input.begin(), input.end(), &host, &port)); |
| EXPECT_EQ("[2003:8:0:16::509d:9615]", host); |
| EXPECT_EQ(443, port); |
| } |
| |
| // Test ParseAltAuthority() on invalid input: empty string, no port, zero port, |
| // non-digit characters following port. |
| TEST(SpdyAltSvcWireFormatTest, ParseAltAuthorityInvalid) { |
| const char* invalid_input_array[] = {"", |
| ":", |
| "foo:", |
| ":bar", |
| ":0", |
| "foo:0", |
| ":12bar", |
| "foo:23bar", |
| " ", |
| ":12 ", |
| "foo:12 ", |
| "[2003:8:0:16::509d:9615]", |
| "[2003:8:0:16::509d:9615]:", |
| "[2003:8:0:16::509d:9615]foo:443", |
| "[2003:8:0:16::509d:9615:443", |
| "2003:8:0:16::509d:9615]:443"}; |
| for (const char* invalid_input : invalid_input_array) { |
| absl::string_view input(invalid_input); |
| std::string host; |
| uint16_t port; |
| EXPECT_FALSE(SpdyAltSvcWireFormatPeer::ParseAltAuthority( |
| input.begin(), input.end(), &host, &port)) |
| << input; |
| } |
| } |
| |
| // Test ParseInteger() on valid input. |
| TEST(SpdyAltSvcWireFormatTest, ParseIntegerValid) { |
| absl::string_view input("3"); |
| uint16_t value; |
| ASSERT_TRUE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( |
| input.begin(), input.end(), &value)); |
| EXPECT_EQ(3, value); |
| |
| input = absl::string_view("1337"); |
| ASSERT_TRUE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( |
| input.begin(), input.end(), &value)); |
| EXPECT_EQ(1337, value); |
| } |
| |
| // Test ParseIntegerValid() on invalid input: empty, zero, non-numeric, trailing |
| // non-numeric characters. |
| TEST(SpdyAltSvcWireFormatTest, ParseIntegerInvalid) { |
| const char* invalid_input_array[] = {"", " ", "a", "0", "00", "1 ", "12b"}; |
| for (const char* invalid_input : invalid_input_array) { |
| absl::string_view input(invalid_input); |
| uint16_t value; |
| EXPECT_FALSE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( |
| input.begin(), input.end(), &value)) |
| << input; |
| } |
| } |
| |
| // Test ParseIntegerValid() around overflow limit. |
| TEST(SpdyAltSvcWireFormatTest, ParseIntegerOverflow) { |
| // Largest possible uint16_t value. |
| absl::string_view input("65535"); |
| uint16_t value16; |
| ASSERT_TRUE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( |
| input.begin(), input.end(), &value16)); |
| EXPECT_EQ(65535, value16); |
| |
| // Overflow uint16_t, ParsePositiveInteger16() should return false. |
| input = absl::string_view("65536"); |
| ASSERT_FALSE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( |
| input.begin(), input.end(), &value16)); |
| |
| // However, even if overflow is not checked for, 65536 overflows to 0, which |
| // returns false anyway. Check for a larger number which overflows to 1. |
| input = absl::string_view("65537"); |
| ASSERT_FALSE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger16( |
| input.begin(), input.end(), &value16)); |
| |
| // Largest possible uint32_t value. |
| input = absl::string_view("4294967295"); |
| uint32_t value32; |
| ASSERT_TRUE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger32( |
| input.begin(), input.end(), &value32)); |
| EXPECT_EQ(4294967295, value32); |
| |
| // Overflow uint32_t, ParsePositiveInteger32() should return false. |
| input = absl::string_view("4294967296"); |
| ASSERT_FALSE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger32( |
| input.begin(), input.end(), &value32)); |
| |
| // However, even if overflow is not checked for, 4294967296 overflows to 0, |
| // which returns false anyway. Check for a larger number which overflows to |
| // 1. |
| input = absl::string_view("4294967297"); |
| ASSERT_FALSE(SpdyAltSvcWireFormatPeer::ParsePositiveInteger32( |
| input.begin(), input.end(), &value32)); |
| } |
| |
| // Test parsing an Alt-Svc entry with IP literal hostname. |
| // Regression test for https://crbug.com/664173. |
| TEST(SpdyAltSvcWireFormatTest, ParseIPLiteral) { |
| const char* input = |
| "quic=\"[2003:8:0:16::509d:9615]:443\"; v=\"36,35\"; ma=60"; |
| SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector; |
| ASSERT_TRUE( |
| SpdyAltSvcWireFormat::ParseHeaderFieldValue(input, &altsvc_vector)); |
| EXPECT_EQ(1u, altsvc_vector.size()); |
| EXPECT_EQ("quic", altsvc_vector[0].protocol_id); |
| EXPECT_EQ("[2003:8:0:16::509d:9615]", altsvc_vector[0].host); |
| EXPECT_EQ(443u, altsvc_vector[0].port); |
| EXPECT_EQ(60u, altsvc_vector[0].max_age_seconds); |
| EXPECT_THAT(altsvc_vector[0].version, ::testing::ElementsAre(36, 35)); |
| } |
| |
| TEST(SpdyAltSvcWireFormatTest, HexDigitToInt) { |
| EXPECT_EQ(0, SpdyAltSvcWireFormatPeer::HexDigitToInt('0')); |
| EXPECT_EQ(1, SpdyAltSvcWireFormatPeer::HexDigitToInt('1')); |
| EXPECT_EQ(2, SpdyAltSvcWireFormatPeer::HexDigitToInt('2')); |
| EXPECT_EQ(3, SpdyAltSvcWireFormatPeer::HexDigitToInt('3')); |
| EXPECT_EQ(4, SpdyAltSvcWireFormatPeer::HexDigitToInt('4')); |
| EXPECT_EQ(5, SpdyAltSvcWireFormatPeer::HexDigitToInt('5')); |
| EXPECT_EQ(6, SpdyAltSvcWireFormatPeer::HexDigitToInt('6')); |
| EXPECT_EQ(7, SpdyAltSvcWireFormatPeer::HexDigitToInt('7')); |
| EXPECT_EQ(8, SpdyAltSvcWireFormatPeer::HexDigitToInt('8')); |
| EXPECT_EQ(9, SpdyAltSvcWireFormatPeer::HexDigitToInt('9')); |
| |
| EXPECT_EQ(10, SpdyAltSvcWireFormatPeer::HexDigitToInt('a')); |
| EXPECT_EQ(11, SpdyAltSvcWireFormatPeer::HexDigitToInt('b')); |
| EXPECT_EQ(12, SpdyAltSvcWireFormatPeer::HexDigitToInt('c')); |
| EXPECT_EQ(13, SpdyAltSvcWireFormatPeer::HexDigitToInt('d')); |
| EXPECT_EQ(14, SpdyAltSvcWireFormatPeer::HexDigitToInt('e')); |
| EXPECT_EQ(15, SpdyAltSvcWireFormatPeer::HexDigitToInt('f')); |
| |
| EXPECT_EQ(10, SpdyAltSvcWireFormatPeer::HexDigitToInt('A')); |
| EXPECT_EQ(11, SpdyAltSvcWireFormatPeer::HexDigitToInt('B')); |
| EXPECT_EQ(12, SpdyAltSvcWireFormatPeer::HexDigitToInt('C')); |
| EXPECT_EQ(13, SpdyAltSvcWireFormatPeer::HexDigitToInt('D')); |
| EXPECT_EQ(14, SpdyAltSvcWireFormatPeer::HexDigitToInt('E')); |
| EXPECT_EQ(15, SpdyAltSvcWireFormatPeer::HexDigitToInt('F')); |
| } |
| |
| TEST(SpdyAltSvcWireFormatTest, HexDecodeToUInt32) { |
| uint32_t out; |
| EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("0", &out)); |
| EXPECT_EQ(0u, out); |
| EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("00", &out)); |
| EXPECT_EQ(0u, out); |
| EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("0000000", &out)); |
| EXPECT_EQ(0u, out); |
| EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("00000000", &out)); |
| EXPECT_EQ(0u, out); |
| EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("1", &out)); |
| EXPECT_EQ(1u, out); |
| EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("ffffFFF", &out)); |
| EXPECT_EQ(0xFFFFFFFu, out); |
| EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("fFfFffFf", &out)); |
| EXPECT_EQ(0xFFFFFFFFu, out); |
| EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("01AEF", &out)); |
| EXPECT_EQ(0x1AEFu, out); |
| EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("abcde", &out)); |
| EXPECT_EQ(0xABCDEu, out); |
| EXPECT_TRUE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("1234abcd", &out)); |
| EXPECT_EQ(0x1234ABCDu, out); |
| |
| EXPECT_FALSE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("", &out)); |
| EXPECT_FALSE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("111111111", &out)); |
| EXPECT_FALSE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("1111111111", &out)); |
| EXPECT_FALSE(SpdyAltSvcWireFormatPeer::HexDecodeToUInt32("0x1111", &out)); |
| } |
| |
| } // namespace |
| |
| } // namespace test |
| |
| } // namespace spdy |
