// Copyright 2013 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "net/base/url_util.h" #include #include #include "base/format_macros.h" #include "base/strings/utf_string_conversions.h" #include "base/test/scoped_feature_list.h" #include "testing/gtest/include/gtest/gtest.h" #include "url/gurl.h" #include "url/scheme_host_port.h" #include "url/url_features.h" #include "url/url_util.h" using base::ASCIIToUTF16; using base::WideToUTF16; namespace net { namespace { TEST(UrlUtilTest, AppendQueryParameter) { // Appending a name-value pair to a URL without a query component. EXPECT_EQ("http://example.com/path?name=value", AppendQueryParameter(GURL("http://example.com/path"), "name", "value").spec()); // Appending a name-value pair to a URL with a query component. // The original component should be preserved, and the new pair should be // appended with '&'. EXPECT_EQ("http://example.com/path?existing=one&name=value", AppendQueryParameter(GURL("http://example.com/path?existing=one"), "name", "value").spec()); // Appending a name-value pair with unsafe characters included. The // unsafe characters should be escaped. EXPECT_EQ("http://example.com/path?existing=one&na+me=v.alue%3D", AppendQueryParameter(GURL("http://example.com/path?existing=one"), "na me", "v.alue=") .spec()); } TEST(UrlUtilTest, AppendOrReplaceQueryParameter) { // Appending a name-value pair to a URL without a query component. EXPECT_EQ("http://example.com/path?name=value", AppendOrReplaceQueryParameter(GURL("http://example.com/path"), "name", "value").spec()); // Appending a name-value pair to a URL with a query component. // The original component should be preserved, and the new pair should be // appended with '&'. EXPECT_EQ("http://example.com/path?existing=one&name=value", AppendOrReplaceQueryParameter( GURL("http://example.com/path?existing=one"), "name", "value").spec()); // Appending a name-value pair with unsafe characters included. The // unsafe characters should be escaped. EXPECT_EQ("http://example.com/path?existing=one&na+me=v.alue%3D", AppendOrReplaceQueryParameter( GURL("http://example.com/path?existing=one"), "na me", "v.alue=").spec()); // Replace value of an existing paramater. EXPECT_EQ("http://example.com/path?existing=one&name=new", AppendOrReplaceQueryParameter( GURL("http://example.com/path?existing=one&name=old"), "name", "new").spec()); // Replace a name-value pair with unsafe characters included. The // unsafe characters should be escaped. EXPECT_EQ("http://example.com/path?na+me=n.ew%3D&existing=one", AppendOrReplaceQueryParameter( GURL("http://example.com/path?na+me=old&existing=one"), "na me", "n.ew=").spec()); // Replace the value of first parameter with this name only. EXPECT_EQ("http://example.com/path?name=new&existing=one&name=old", AppendOrReplaceQueryParameter( GURL("http://example.com/path?name=old&existing=one&name=old"), "name", "new").spec()); // Preserve the content of the original params regardless of our failure to // interpret them correctly. EXPECT_EQ("http://example.com/path?bar&name=new&left=&" "=right&=&&name=again", AppendOrReplaceQueryParameter( GURL("http://example.com/path?bar&name=old&left=&" "=right&=&&name=again"), "name", "new").spec()); // ----- Removing the key using nullopt value ----- // Removes the name-value pair from the URL preserving other query parameters. EXPECT_EQ("http://example.com/path?abc=xyz", AppendOrReplaceQueryParameter( GURL("http://example.com/path?name=value&abc=xyz"), "name", std::nullopt) .spec()); // Removes the name-value pair from the URL. EXPECT_EQ("http://example.com/path?", AppendOrReplaceQueryParameter( GURL("http://example.com/path?existing=one"), "existing", std::nullopt) .spec()); // Removes the first name-value pair. EXPECT_EQ("http://example.com/path?c=d&e=f", AppendOrReplaceQueryParameter( GURL("http://example.com/path?a=b&c=d&e=f"), "a", std::nullopt) .spec()); // Removes a name-value pair in between two query params. EXPECT_EQ( "http://example.com/path?existing=one&hello=world", AppendOrReplaceQueryParameter( GURL("http://example.com/path?existing=one&replace=sure&hello=world"), "replace", std::nullopt) .spec()); // Removes the last name-value pair. EXPECT_EQ("http://example.com/path?existing=one", AppendOrReplaceQueryParameter( GURL("http://example.com/path?existing=one&replace=sure"), "replace", std::nullopt) .spec()); // Removing a name-value pair with unsafe characters included. The // unsafe characters should be escaped. EXPECT_EQ("http://example.com/path?existing=one&hello=world", AppendOrReplaceQueryParameter( GURL("http://example.com/" "path?existing=one&na+me=v.alue%3D&hello=world"), "na me", std::nullopt) .spec()); // Does nothing if the provided query param key does not exist. EXPECT_EQ("http://example.com/path?existing=one&name=old", AppendOrReplaceQueryParameter( GURL("http://example.com/path?existing=one&name=old"), "old", std::nullopt) .spec()); // Remove the value of first parameter with this name only. EXPECT_EQ( "http://example.com/path?existing=one&name=old", AppendOrReplaceQueryParameter( GURL("http://example.com/path?name=something&existing=one&name=old"), "name", std::nullopt) .spec()); // Preserve the content of the original params regardless of our failure to // interpret them correctly. EXPECT_EQ( "http://example.com/path?bar&left=&" "=right&=&&name=again", AppendOrReplaceQueryParameter( GURL("http://example.com/path?bar&name=old&left=&" "=right&=&&name=again"), "name", std::nullopt) .spec()); } TEST(UrlUtilTest, AppendOrReplaceRef) { // Setting a new ref should append it. EXPECT_EQ("http://example.com/path#ref", AppendOrReplaceRef(GURL("http://example.com/path"), "ref").spec()); // Setting a ref over an existing one should replace it. EXPECT_EQ("http://example.com/path#ref", AppendOrReplaceRef(GURL("http://example.com/path#old_ref"), "ref") .spec()); // Setting a ref on a url with existing query parameters should simply append // it at the end EXPECT_EQ( "http://example.com/path?query=value#ref", AppendOrReplaceRef(GURL("http://example.com/path?query=value#ref"), "ref") .spec()); // Setting a ref on a url with existing query parameters and with special // encoded characters: `special-chars?query=value#ref chars%\";'` EXPECT_EQ( "http://example.com/special-chars?query=value#ref%20chars%%22;'", AppendOrReplaceRef(GURL("http://example.com/special-chars?query=value"), "ref chars%\";'") .spec()); // Testing adding a ref to a URL with specially encoded characters. // `special chars%\";'?query=value#ref` EXPECT_EQ( "http://example.com/special%20chars%%22;'?query=value#ref", AppendOrReplaceRef( GURL("http://example.com/special chars%\";'?query=value"), "ref") .spec()); } TEST(UrlUtilTest, GetValueForKeyInQuery) { GURL url("http://example.com/path?name=value&boolParam&" "url=http://test.com/q?n1%3Dv1%26n2"); std::string value; // False when getting a non-existent query param. EXPECT_FALSE(GetValueForKeyInQuery(url, "non-exist", &value)); // True when query param exist. EXPECT_TRUE(GetValueForKeyInQuery(url, "name", &value)); EXPECT_EQ("value", value); EXPECT_TRUE(GetValueForKeyInQuery(url, "boolParam", &value)); EXPECT_EQ("", value); EXPECT_TRUE(GetValueForKeyInQuery(url, "url", &value)); EXPECT_EQ("http://test.com/q?n1=v1&n2", value); } TEST(UrlUtilTest, GetValueForKeyInQueryInvalidURL) { GURL url("http://%01/?test"); std::string value; // Always false when parsing an invalid URL. EXPECT_FALSE(GetValueForKeyInQuery(url, "test", &value)); } TEST(UrlUtilTest, ParseQuery) { const GURL url("http://example.com/path?name=value&boolParam&" "url=http://test.com/q?n1%3Dv1%26n2&" "multikey=value1&multikey=value2&multikey"); QueryIterator it(url); ASSERT_FALSE(it.IsAtEnd()); EXPECT_EQ("name", it.GetKey()); EXPECT_EQ("value", it.GetValue()); EXPECT_EQ("value", it.GetUnescapedValue()); it.Advance(); ASSERT_FALSE(it.IsAtEnd()); EXPECT_EQ("boolParam", it.GetKey()); EXPECT_EQ("", it.GetValue()); EXPECT_EQ("", it.GetUnescapedValue()); it.Advance(); ASSERT_FALSE(it.IsAtEnd()); EXPECT_EQ("url", it.GetKey()); EXPECT_EQ("http://test.com/q?n1%3Dv1%26n2", it.GetValue()); EXPECT_EQ("http://test.com/q?n1=v1&n2", it.GetUnescapedValue()); it.Advance(); ASSERT_FALSE(it.IsAtEnd()); EXPECT_EQ("multikey", it.GetKey()); EXPECT_EQ("value1", it.GetValue()); EXPECT_EQ("value1", it.GetUnescapedValue()); it.Advance(); ASSERT_FALSE(it.IsAtEnd()); EXPECT_EQ("multikey", it.GetKey()); EXPECT_EQ("value2", it.GetValue()); EXPECT_EQ("value2", it.GetUnescapedValue()); it.Advance(); ASSERT_FALSE(it.IsAtEnd()); EXPECT_EQ("multikey", it.GetKey()); EXPECT_EQ("", it.GetValue()); EXPECT_EQ("", it.GetUnescapedValue()); it.Advance(); EXPECT_TRUE(it.IsAtEnd()); } TEST(UrlUtilTest, ParseQueryInvalidURL) { const GURL url("http://%01/?test"); QueryIterator it(url); EXPECT_TRUE(it.IsAtEnd()); } TEST(UrlUtilTest, ParseHostAndPort) { const struct { const char* const input; bool success; const char* const expected_host; int expected_port; } tests[] = { // Valid inputs: {"foo:10", true, "foo", 10}, {"foo", true, "foo", -1}, { "[1080:0:0:0:8:800:200C:4171]:11", true, "1080:0:0:0:8:800:200C:4171", 11 }, { "[1080:0:0:0:8:800:200C:4171]", true, "1080:0:0:0:8:800:200C:4171", -1 }, // Because no validation is done on the host, the following are accepted, // even though they are invalid names. {"]", true, "]", -1}, {"::1", true, ":", 1}, // Invalid inputs: {"foo:bar", false, "", -1}, {"foo:", false, "", -1}, {":", false, "", -1}, {":80", false, "", -1}, {"", false, "", -1}, {"porttoolong:300000", false, "", -1}, {"usrname@host", false, "", -1}, {"usrname:password@host", false, "", -1}, {":password@host", false, "", -1}, {":password@host:80", false, "", -1}, {":password@host", false, "", -1}, {"@host", false, "", -1}, {"[", false, "", -1}, {"[]", false, "", -1}, }; for (const auto& test : tests) { std::string host; int port; bool ok = ParseHostAndPort(test.input, &host, &port); EXPECT_EQ(test.success, ok); if (test.success) { EXPECT_EQ(test.expected_host, host); EXPECT_EQ(test.expected_port, port); } } } TEST(UrlUtilTest, GetHostAndPort) { const struct { GURL url; const char* const expected_host_and_port; } tests[] = { { GURL("http://www.foo.com/x"), "www.foo.com:80"}, { GURL("http://www.foo.com:21/x"), "www.foo.com:21"}, // For IPv6 literals should always include the brackets. { GURL("http://[1::2]/x"), "[1::2]:80"}, { GURL("http://[::a]:33/x"), "[::a]:33"}, }; for (const auto& test : tests) { std::string host_and_port = GetHostAndPort(test.url); EXPECT_EQ(std::string(test.expected_host_and_port), host_and_port); } } TEST(UrlUtilTest, GetHostAndOptionalPort) { const struct { GURL url; const char* const expected_host_and_port; } tests[] = { {GURL("http://www.foo.com/x"), "www.foo.com"}, {GURL("http://www.foo.com:21/x"), "www.foo.com:21"}, {GURL("http://www.foo.com:443/x"), "www.foo.com:443"}, {GURL("https://www.foo.com/x"), "www.foo.com"}, {GURL("https://www.foo.com:80/x"), "www.foo.com:80"}, // For IPv6 literals should always include the brackets. {GURL("http://[1::2]/x"), "[1::2]"}, {GURL("http://[::a]:33/x"), "[::a]:33"}, }; for (const auto& test : tests) { EXPECT_EQ(test.expected_host_and_port, GetHostAndOptionalPort(test.url)); // Also test the SchemeHostPort variant. EXPECT_EQ(test.expected_host_and_port, GetHostAndOptionalPort(url::SchemeHostPort(test.url))); } } TEST(UrlUtilTest, GetHostOrSpecFromURL) { EXPECT_EQ("example.com", GetHostOrSpecFromURL(GURL("http://example.com/test"))); EXPECT_EQ("example.com", GetHostOrSpecFromURL(GURL("http://example.com./test"))); EXPECT_EQ("file:///tmp/test.html", GetHostOrSpecFromURL(GURL("file:///tmp/test.html"))); } TEST(UrlUtilTest, GetSuperdomain) { struct { const char* const domain; const char* const expected_superdomain; } tests[] = { // Basic cases {"foo.bar.example", "bar.example"}, {"bar.example", "example"}, {"example", ""}, // Returned value may be an eTLD. {"google.com", "com"}, {"google.co.uk", "co.uk"}, // Weird cases. {"", ""}, {"has.trailing.dot.", "trailing.dot."}, {"dot.", ""}, {".has.leading.dot", "has.leading.dot"}, {".", ""}, {"..", "."}, {"127.0.0.1", "0.0.1"}, }; for (const auto& test : tests) { EXPECT_EQ(test.expected_superdomain, GetSuperdomain(test.domain)); } } TEST(UrlUtilTest, IsSubdomainOf) { struct { const char* subdomain; const char* superdomain; bool is_subdomain; } tests[] = { {"bar.foo.com", "foo.com", true}, {"barfoo.com", "foo.com", false}, {"bar.foo.com", "com", true}, {"bar.foo.com", "other.com", false}, {"bar.foo.com", "bar.foo.com", true}, {"bar.foo.com", "baz.foo.com", false}, {"bar.foo.com", "baz.bar.foo.com", false}, {"bar.foo.com", "ar.foo.com", false}, {"foo.com", "foo.com.", false}, {"bar.foo.com", "foo.com.", false}, {"", "", true}, {"a", "", false}, {"", "a", false}, {"127.0.0.1", "0.0.1", true}, // Don't do this... }; for (const auto& test : tests) { EXPECT_EQ(test.is_subdomain, IsSubdomainOf(test.subdomain, test.superdomain)); } } TEST(UrlUtilTest, CompliantHost) { struct { const char* const host; bool expected_output; } compliant_host_cases[] = { {"", false}, {"a", true}, {"-", false}, {"_", false}, {".", false}, {"9", true}, {"9a", true}, {"9_", true}, {"a.", true}, {".a", false}, {"a.a", true}, {"9.a", true}, {"a.9", true}, {"_9a", false}, {"-9a", false}, {"a.a9", true}, {"_.9a", true}, {"a.-a9", false}, {"a+9a", false}, {"-a.a9", true}, {"a_.a9", true}, {"1-.a-b", true}, {"1_.a-b", true}, {"1-2.a_b", true}, {"a.b.c.d.e", true}, {"1.2.3.4.5", true}, {"1.2.3..4.5", false}, {"1.2.3.4.5.", true}, {"1.2.3.4.5..", false}, {"%20%20noodles.blorg", false}, {"noo dles.blorg ", false}, {"noo dles.blorg. ", false}, {"^noodles.blorg", false}, {"noodles^.blorg", false}, {"noo&dles.blorg", false}, {"noodles.blorg`", false}, {"www.noodles.blorg", true}, {"1www.noodles.blorg", true}, {"www.2noodles.blorg", true}, {"www.n--oodles.blorg", true}, {"www.noodl_es.blorg", true}, {"www.no-_odles.blorg", true}, {"www_.noodles.blorg", true}, {"www.noodles.blorg.", true}, {"_privet._tcp.local", true}, // 63-char label (before or without dot) allowed {"z23456789a123456789a123456789a123456789a123456789a123456789a123", true}, {"z23456789a123456789a123456789a123456789a123456789a123456789a123.", true}, // 64-char label (before or without dot) disallowed {"123456789a123456789a123456789a123456789a123456789a123456789a1234", false}, {"123456789a123456789a123456789a123456789a123456789a123456789a1234.", false}, // 253-char host allowed {"abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi." "abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi." "abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi." "abcdefghi.abcdefghi.abcdefghi.abcdefghi.abc", true}, // 253-char+dot host allowed {"abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi." "abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi." "abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi.abcdefghi." "abcdefghi.abcdefghi.abcdefghi.abcdefghi.abc.", true}, // 254-char host disallowed {"123456789.123456789.123456789.123456789.123456789.123456789.123456789." "123456789.123456789.123456789.123456789.123456789.123456789.123456789." "123456789.123456789.123456789.123456789.123456789.123456789.123456789." "123456789.123456789.123456789.123456789.1234", false}, // 254-char+dot host disallowed {"123456789.123456789.123456789.123456789.123456789.123456789.123456789." "123456789.123456789.123456789.123456789.123456789.123456789.123456789." "123456789.123456789.123456789.123456789.123456789.123456789.123456789." "123456789.123456789.123456789.123456789.1234.", false}, }; for (const auto& compliant_host : compliant_host_cases) { EXPECT_EQ(compliant_host.expected_output, IsCanonicalizedHostCompliant(compliant_host.host)) << compliant_host.host; } } struct NonUniqueNameTestData { bool is_unique; const char* const hostname; }; // Google Test pretty-printer. void PrintTo(const NonUniqueNameTestData& data, std::ostream* os) { ASSERT_TRUE(data.hostname); *os << " hostname: " << testing::PrintToString(data.hostname) << "; is_unique: " << testing::PrintToString(data.is_unique); } const NonUniqueNameTestData kNonUniqueNameTestData[] = { // Domains under ICANN-assigned domains. { true, "google.com" }, { true, "google.co.uk" }, // Domains under private registries. { true, "appspot.com" }, { true, "test.appspot.com" }, // Unreserved IPv4 addresses (in various forms). { true, "8.8.8.8" }, { true, "99.64.0.0" }, { true, "212.15.0.0" }, { true, "212.15" }, { true, "212.15.0" }, { true, "3557752832" }, // Reserved IPv4 addresses (in various forms). { false, "192.168.0.0" }, { false, "192.168.0.6" }, { false, "10.0.0.5" }, { false, "10.0" }, { false, "10.0.0" }, { false, "3232235526" }, // Unreserved IPv6 addresses. { true, "FFC0:ba98:7654:3210:FEDC:BA98:7654:3210" }, { true, "2000:ba98:7654:2301:EFCD:BA98:7654:3210" }, // Reserved IPv6 addresses. { false, "::192.9.5.5" }, { false, "FEED::BEEF" }, { false, "FEC0:ba98:7654:3210:FEDC:BA98:7654:3210" }, // 'internal'/non-IANA assigned domains. { false, "intranet" }, { false, "intranet." }, { false, "intranet.example" }, { false, "host.intranet.example" }, // gTLDs under discussion, but not yet assigned. { false, "intranet.corp" }, { false, "intranet.internal" }, // Invalid host names are treated as unique - but expected to be // filtered out before then. { true, "junk)(£)$*!@~#" }, { true, "w$w.example.com" }, { true, "nocolonsallowed:example" }, { true, "[::4.5.6.9]" }, }; class UrlUtilNonUniqueNameTest : public testing::TestWithParam { public: ~UrlUtilNonUniqueNameTest() override = default; protected: bool IsUnique(const std::string& hostname) { return !IsHostnameNonUnique(hostname); } }; // Test that internal/non-unique names are properly identified as such, but // that IP addresses and hosts beneath registry-controlled domains are flagged // as unique names. TEST_P(UrlUtilNonUniqueNameTest, IsHostnameNonUnique) { const NonUniqueNameTestData& test_data = GetParam(); EXPECT_EQ(test_data.is_unique, IsUnique(test_data.hostname)); } INSTANTIATE_TEST_SUITE_P(All, UrlUtilNonUniqueNameTest, testing::ValuesIn(kNonUniqueNameTestData)); TEST(UrlUtilTest, IsLocalhost) { EXPECT_TRUE(HostStringIsLocalhost("localhost")); EXPECT_TRUE(HostStringIsLocalhost("localHosT")); EXPECT_TRUE(HostStringIsLocalhost("localhost.")); EXPECT_TRUE(HostStringIsLocalhost("localHost.")); EXPECT_TRUE(HostStringIsLocalhost("127.0.0.1")); EXPECT_TRUE(HostStringIsLocalhost("127.0.1.0")); EXPECT_TRUE(HostStringIsLocalhost("127.1.0.0")); EXPECT_TRUE(HostStringIsLocalhost("127.0.0.255")); EXPECT_TRUE(HostStringIsLocalhost("127.0.255.0")); EXPECT_TRUE(HostStringIsLocalhost("127.255.0.0")); EXPECT_TRUE(HostStringIsLocalhost("::1")); EXPECT_TRUE(HostStringIsLocalhost("0:0:0:0:0:0:0:1")); EXPECT_TRUE(HostStringIsLocalhost("foo.localhost")); EXPECT_TRUE(HostStringIsLocalhost("foo.localhost.")); EXPECT_TRUE(HostStringIsLocalhost("foo.localhoST")); EXPECT_TRUE(HostStringIsLocalhost("foo.localhoST.")); EXPECT_FALSE(HostStringIsLocalhost("localhost.localdomain")); EXPECT_FALSE(HostStringIsLocalhost("localhost.localDOMain")); EXPECT_FALSE(HostStringIsLocalhost("localhost.localdomain.")); EXPECT_FALSE(HostStringIsLocalhost("localhost6")); EXPECT_FALSE(HostStringIsLocalhost("localhost6.")); EXPECT_FALSE(HostStringIsLocalhost("localhost6.localdomain6")); EXPECT_FALSE(HostStringIsLocalhost("localhost6.localdomain6.")); EXPECT_FALSE(HostStringIsLocalhost("localhostx")); EXPECT_FALSE(HostStringIsLocalhost("localhost.x")); EXPECT_FALSE(HostStringIsLocalhost("foo.localdomain")); EXPECT_FALSE(HostStringIsLocalhost("foo.localdomain.x")); EXPECT_FALSE(HostStringIsLocalhost("localhost6x")); EXPECT_FALSE(HostStringIsLocalhost("localhost.localdomain6")); EXPECT_FALSE(HostStringIsLocalhost("localhost6.localdomain")); EXPECT_FALSE(HostStringIsLocalhost("127.0.0.1.1")); EXPECT_FALSE(HostStringIsLocalhost(".127.0.0.255")); EXPECT_FALSE(HostStringIsLocalhost("::2")); EXPECT_FALSE(HostStringIsLocalhost("::1:1")); EXPECT_FALSE(HostStringIsLocalhost("0:0:0:0:1:0:0:1")); EXPECT_FALSE(HostStringIsLocalhost("::1:1")); EXPECT_FALSE(HostStringIsLocalhost("0:0:0:0:0:0:0:0:1")); EXPECT_FALSE(HostStringIsLocalhost("foo.localhost.com")); EXPECT_FALSE(HostStringIsLocalhost("foo.localhoste")); EXPECT_FALSE(HostStringIsLocalhost("foo.localhos")); EXPECT_FALSE(HostStringIsLocalhost("[::1]")); GURL localhost6("http://[::1]/"); EXPECT_TRUE(IsLocalhost(localhost6)); } class UrlUtilTypedTest : public ::testing::TestWithParam { public: UrlUtilTypedTest() : use_standard_compliant_non_special_scheme_url_parsing_(GetParam()) { if (use_standard_compliant_non_special_scheme_url_parsing_) { scoped_feature_list_.InitAndEnableFeature( url::kStandardCompliantNonSpecialSchemeURLParsing); } else { scoped_feature_list_.InitAndDisableFeature( url::kStandardCompliantNonSpecialSchemeURLParsing); } } protected: bool use_standard_compliant_non_special_scheme_url_parsing_; private: base::test::ScopedFeatureList scoped_feature_list_; }; INSTANTIATE_TEST_SUITE_P(All, UrlUtilTypedTest, ::testing::Bool()); TEST(UrlUtilTest, SimplifyUrlForRequest) { struct { const char* const input_url; const char* const expected_simplified_url; } tests[] = { { // Reference section should be stripped. "http://www.google.com:78/foobar?query=1#hash", "http://www.google.com:78/foobar?query=1", }, { // Reference section can itself contain #. "http://192.168.0.1?query=1#hash#10#11#13#14", "http://192.168.0.1?query=1", }, { // Strip username/password. "http://user:pass@google.com", "http://google.com/", }, { // Strip both the reference and the username/password. "http://user:pass@google.com:80/sup?yo#X#X", "http://google.com/sup?yo", }, { // Try an HTTPS URL -- strip both the reference and the username/password. "https://user:pass@google.com:80/sup?yo#X#X", "https://google.com:80/sup?yo", }, { // Try an FTP URL -- strip both the reference and the username/password. "ftp://user:pass@google.com:80/sup?yo#X#X", "ftp://google.com:80/sup?yo", }, }; for (const auto& test : tests) { SCOPED_TRACE(test.input_url); GURL input_url(GURL(test.input_url)); GURL expected_url(GURL(test.expected_simplified_url)); EXPECT_EQ(expected_url, SimplifyUrlForRequest(input_url)); } } TEST_P(UrlUtilTypedTest, SimplifyUrlForRequest) { static constexpr struct { const char* const input_url; const char* const expected_when_compliant; const char* const expected_when_non_compliant; } tests[] = { { // Try a non-special URL "foobar://user:pass@google.com:80/sup?yo#X#X", "foobar://google.com:80/sup?yo", "foobar://user:pass@google.com:80/sup?yo", }, }; for (const auto& test : tests) { SCOPED_TRACE(test.input_url); GURL simplified = SimplifyUrlForRequest(GURL(test.input_url)); if (use_standard_compliant_non_special_scheme_url_parsing_) { EXPECT_EQ(simplified, GURL(test.expected_when_compliant)); } else { EXPECT_EQ(simplified, GURL(test.expected_when_non_compliant)); } } } TEST(UrlUtilTest, ChangeWebSocketSchemeToHttpScheme) { struct { const char* const input_url; const char* const expected_output_url; } tests[] = { {"ws://google.com:78/path?query=1", "http://google.com:78/path?query=1"}, {"wss://google.com:441/path?q=1", "https://google.com:441/path?q=1"}}; for (const auto& test : tests) { GURL input_url(test.input_url); GURL expected_output_url(test.expected_output_url); EXPECT_EQ(expected_output_url, ChangeWebSocketSchemeToHttpScheme(input_url)); } } TEST(UrlUtilTest, SchemeHasNetworkHost) { const char kCustomSchemeWithHostPortAndUserInformation[] = "foo"; const char kCustomSchemeWithHostAndPort[] = "bar"; const char kCustomSchemeWithHost[] = "baz"; const char kCustomSchemeWithoutAuthority[] = "qux"; const char kNonStandardScheme[] = "not-registered"; url::ScopedSchemeRegistryForTests scheme_registry; AddStandardScheme(kCustomSchemeWithHostPortAndUserInformation, url::SCHEME_WITH_HOST_PORT_AND_USER_INFORMATION); AddStandardScheme(kCustomSchemeWithHostAndPort, url::SCHEME_WITH_HOST_AND_PORT); AddStandardScheme(kCustomSchemeWithHost, url::SCHEME_WITH_HOST); AddStandardScheme(kCustomSchemeWithoutAuthority, url::SCHEME_WITHOUT_AUTHORITY); EXPECT_TRUE(IsStandardSchemeWithNetworkHost(url::kHttpScheme)); EXPECT_TRUE(IsStandardSchemeWithNetworkHost(url::kHttpsScheme)); EXPECT_TRUE(IsStandardSchemeWithNetworkHost(url::kWsScheme)); EXPECT_TRUE(IsStandardSchemeWithNetworkHost(url::kWssScheme)); EXPECT_TRUE(IsStandardSchemeWithNetworkHost(url::kFtpScheme)); EXPECT_TRUE(IsStandardSchemeWithNetworkHost(url::kFileScheme)); EXPECT_TRUE(IsStandardSchemeWithNetworkHost( kCustomSchemeWithHostPortAndUserInformation)); EXPECT_TRUE(IsStandardSchemeWithNetworkHost(kCustomSchemeWithHostAndPort)); EXPECT_FALSE(IsStandardSchemeWithNetworkHost(url::kFileSystemScheme)); EXPECT_FALSE(IsStandardSchemeWithNetworkHost(kCustomSchemeWithHost)); EXPECT_FALSE(IsStandardSchemeWithNetworkHost(kCustomSchemeWithoutAuthority)); EXPECT_FALSE(IsStandardSchemeWithNetworkHost(kNonStandardScheme)); } TEST(UrlUtilTest, GetIdentityFromURL) { struct { const char* const input_url; const char* const expected_username; const char* const expected_password; } tests[] = { { "http://username:password@google.com", "username", "password", }, { // Test for http://crbug.com/19200 "http://username:p@ssword@google.com", "username", "p@ssword", }, { // Special URL characters should be unescaped. "http://username:p%3fa%26s%2fs%23@google.com", "username", "p?a&s/s#", }, { // Username contains %20, password %25. "http://use rname:password%25@google.com", "use rname", "password%", }, { // Username and password contain forward / backward slashes. "http://username%2F:password%5C@google.com", "username/", "password\\", }, { // Keep %00 and %01 as-is, and ignore other escaped characters when // present. "http://use%00rname%20:pass%01word%25@google.com", "use%00rname%20", "pass%01word%25", }, { // Keep CR and LF as-is. "http://use%0Arname:pass%0Dword@google.com", "use%0Arname", "pass%0Dword", }, { // Use a '+' in the username. "http://use+rname:password@google.com", "use+rname", "password", }, { // Use a '&' in the password. "http://username:p&ssword@google.com", "username", "p&ssword", }, { // These UTF-8 characters are considered unsafe to unescape by // UnescapeURLComponent, but raise no special concerns as part of the // identity portion of a URL. "http://%F0%9F%94%92:%E2%80%82@google.com", "\xF0\x9F\x94\x92", "\xE2\x80\x82", }, { // Leave invalid UTF-8 alone, and leave valid UTF-8 characters alone // if there's also an invalid character in the string - strings should // not be partially unescaped. "http://%81:%E2%80%82%E2%80@google.com", "%81", "%E2%80%82%E2%80", }, }; for (const auto& test : tests) { SCOPED_TRACE(test.input_url); GURL url(test.input_url); std::u16string username, password; GetIdentityFromURL(url, &username, &password); EXPECT_EQ(base::UTF8ToUTF16(test.expected_username), username); EXPECT_EQ(base::UTF8ToUTF16(test.expected_password), password); } } // Try extracting a username which was encoded with UTF8. TEST(UrlUtilTest, GetIdentityFromURL_UTF8) { GURL url(u"http://foo:\x4f60\x597d@blah.com"); EXPECT_EQ("foo", url.username()); EXPECT_EQ("%E4%BD%A0%E5%A5%BD", url.password()); // Extract the unescaped identity. std::u16string username, password; GetIdentityFromURL(url, &username, &password); // Verify that it was decoded as UTF8. EXPECT_EQ(u"foo", username); EXPECT_EQ(u"\x4f60\x597d", password); } TEST(UrlUtilTest, GoogleHost) { struct { GURL url; bool expected_output; } google_host_cases[] = { {GURL("http://.google.com"), true}, {GURL("http://.youtube.com"), true}, {GURL("http://.gmail.com"), true}, {GURL("http://.doubleclick.net"), true}, {GURL("http://.gstatic.com"), true}, {GURL("http://.googlevideo.com"), true}, {GURL("http://.googleusercontent.com"), true}, {GURL("http://.googlesyndication.com"), true}, {GURL("http://.google-analytics.com"), true}, {GURL("http://.googleadservices.com"), true}, {GURL("http://.googleapis.com"), true}, {GURL("http://a.google.com"), true}, {GURL("http://b.youtube.com"), true}, {GURL("http://c.gmail.com"), true}, {GURL("http://google.com"), false}, {GURL("http://youtube.com"), false}, {GURL("http://gmail.com"), false}, {GURL("http://google.coma"), false}, {GURL("http://agoogle.com"), false}, {GURL("http://oogle.com"), false}, {GURL("http://google.co"), false}, {GURL("http://oggole.com"), false}, }; for (const auto& host : google_host_cases) { EXPECT_EQ(host.expected_output, HasGoogleHost(host.url)); } } TEST(UrlUtilTest, IsLocalHostname) { EXPECT_TRUE(IsLocalHostname("localhost")); EXPECT_TRUE(IsLocalHostname("localhost.")); EXPECT_TRUE(IsLocalHostname("LOCALhost")); EXPECT_TRUE(IsLocalHostname("LOCALhost.")); EXPECT_TRUE(IsLocalHostname("abc.localhost")); EXPECT_TRUE(IsLocalHostname("abc.localhost.")); EXPECT_TRUE(IsLocalHostname("abc.LOCALhost")); EXPECT_TRUE(IsLocalHostname("abc.LOCALhost.")); EXPECT_TRUE(IsLocalHostname("abc.def.localhost")); EXPECT_FALSE(IsLocalHostname("localhost.actuallynot")); EXPECT_FALSE(IsLocalHostname("notlocalhost")); EXPECT_FALSE(IsLocalHostname("notlocalhost.")); EXPECT_FALSE(IsLocalHostname("still.notlocalhost")); EXPECT_FALSE(IsLocalHostname("localhostjustkidding")); } TEST(UrlUtilTest, GoogleHostWithAlpnH3) { struct { std::string_view host; bool expected_output; } test_cases[] = { {"google.com", true}, {"www.google.com", true}, {"google.CoM", true}, {"www.Google.cOm", true}, {"www.google.cat", false}, {"www.google.co.in", false}, {"www.google.co.jp", false}, }; for (const auto& host : test_cases) { EXPECT_EQ(host.expected_output, IsGoogleHostWithAlpnH3(host.host)); } } } // namespace } // namespace net