url / gurl_unittest.cc [blame]

// 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 "url/gurl.h"

#include <stddef.h>

#include <array>

#include "base/strings/string_number_conversions.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_abstract_tests.h"
#include "url/origin.h"
#include "url/url_canon.h"
#include "url/url_features.h"
#include "url/url_test_utils.h"

namespace url {

namespace {

// Returns the canonicalized string for the given URL string for the
// GURLTest.Types test.
std::string TypesTestCase(const char* src) {
  GURL gurl(src);
  return gurl.possibly_invalid_spec();
}

}  // namespace

// Different types of URLs should be handled differently, and handed off to
// different canonicalizers.
TEST(GURLTest, Types) {
  // URLs with unknown schemes should be treated as path URLs, even when they
  // have things like "://".
  EXPECT_EQ("something:///HOSTNAME.com/",
            TypesTestCase("something:///HOSTNAME.com/"));

  // Conversely, URLs with known schemes should always trigger standard URL
  // handling.
  EXPECT_EQ("http://hostname.com/", TypesTestCase("http:HOSTNAME.com"));
  EXPECT_EQ("http://hostname.com/", TypesTestCase("http:/HOSTNAME.com"));
  EXPECT_EQ("http://hostname.com/", TypesTestCase("http://HOSTNAME.com"));
  EXPECT_EQ("http://hostname.com/", TypesTestCase("http:///HOSTNAME.com"));

#ifdef WIN32
  // URLs that look like Windows absolute path specs.
  EXPECT_EQ("file:///C:/foo.txt", TypesTestCase("c:\\foo.txt"));
  EXPECT_EQ("file:///Z:/foo.txt", TypesTestCase("Z|foo.txt"));
  EXPECT_EQ("file://server/foo.txt", TypesTestCase("\\\\server\\foo.txt"));
  EXPECT_EQ("file://server/foo.txt", TypesTestCase("//server/foo.txt"));
#endif
}

// Test the basic creation and querying of components in a GURL. We assume that
// the parser is already tested and works, so we are mostly interested if the
// object does the right thing with the results.
TEST(GURLTest, Components) {
  GURL empty_url(u"");
  EXPECT_TRUE(empty_url.is_empty());
  EXPECT_FALSE(empty_url.is_valid());

  GURL url(u"http://user:pass@google.com:99/foo;bar?q=a#ref");
  EXPECT_FALSE(url.is_empty());
  EXPECT_TRUE(url.is_valid());
  EXPECT_TRUE(url.SchemeIs("http"));
  EXPECT_FALSE(url.SchemeIsFile());

  // This is the narrow version of the URL, which should match the wide input.
  EXPECT_EQ("http://user:pass@google.com:99/foo;bar?q=a#ref", url.spec());

  EXPECT_EQ("http", url.scheme());
  EXPECT_EQ("user", url.username());
  EXPECT_EQ("pass", url.password());
  EXPECT_EQ("google.com", url.host());
  EXPECT_EQ("99", url.port());
  EXPECT_EQ(99, url.IntPort());
  EXPECT_EQ("/foo;bar", url.path());
  EXPECT_EQ("q=a", url.query());
  EXPECT_EQ("ref", url.ref());

  // Test parsing userinfo with special characters.
  GURL url_special_pass("http://user:%40!$&'()*+,;=:@google.com:12345");
  EXPECT_TRUE(url_special_pass.is_valid());
  // GURL canonicalizes some delimiters.
  EXPECT_EQ("%40!$&%27()*+,%3B%3D%3A", url_special_pass.password());
  EXPECT_EQ("google.com", url_special_pass.host());
  EXPECT_EQ("12345", url_special_pass.port());

  // Test path collapsing.
  GURL url_path_collapse("http://example.com/a/./b/c/d/../../e");
  EXPECT_EQ("/a/b/e", url_path_collapse.path());

  // Test an IDNA (Internationalizing Domain Names in Applications) host.
  GURL url_idna("http://Bücher.exAMple/");
  EXPECT_EQ("xn--bcher-kva.example", url_idna.host());

  // Test non-ASCII characters, outside of the host (IDNA).
  GURL url_non_ascii("http://example.com/foo/aβc%2Etxt?q=r🙂s");
  EXPECT_EQ("/foo/a%CE%B2c.txt", url_non_ascii.path());
  EXPECT_EQ("q=r%F0%9F%99%82s", url_non_ascii.query());

  // Test already percent-escaped strings.
  GURL url_percent_escaped("http://example.com/a/./%2e/i%2E%2F%2fj?q=r%2Es");
  EXPECT_EQ("/a/i.%2F%2fj", url_percent_escaped.path());
  EXPECT_EQ("q=r%2Es", url_percent_escaped.query());
}

TEST(GURLTest, Empty) {
  GURL url;
  EXPECT_FALSE(url.is_valid());
  EXPECT_EQ("", url.spec());

  EXPECT_EQ("", url.scheme());
  EXPECT_EQ("", url.username());
  EXPECT_EQ("", url.password());
  EXPECT_EQ("", url.host());
  EXPECT_EQ("", url.port());
  EXPECT_EQ(PORT_UNSPECIFIED, url.IntPort());
  EXPECT_EQ("", url.path());
  EXPECT_EQ("", url.query());
  EXPECT_EQ("", url.ref());
}

TEST(GURLTest, Copy) {
  GURL url(u"http://user:pass@google.com:99/foo;bar?q=a#ref");

  GURL url2(url);
  EXPECT_TRUE(url2.is_valid());

  EXPECT_EQ("http://user:pass@google.com:99/foo;bar?q=a#ref", url2.spec());
  EXPECT_EQ("http", url2.scheme());
  EXPECT_EQ("user", url2.username());
  EXPECT_EQ("pass", url2.password());
  EXPECT_EQ("google.com", url2.host());
  EXPECT_EQ("99", url2.port());
  EXPECT_EQ(99, url2.IntPort());
  EXPECT_EQ("/foo;bar", url2.path());
  EXPECT_EQ("q=a", url2.query());
  EXPECT_EQ("ref", url2.ref());

  // Copying of invalid URL should be invalid
  GURL invalid;
  GURL invalid2(invalid);
  EXPECT_FALSE(invalid2.is_valid());
  EXPECT_EQ("", invalid2.spec());
  EXPECT_EQ("", invalid2.scheme());
  EXPECT_EQ("", invalid2.username());
  EXPECT_EQ("", invalid2.password());
  EXPECT_EQ("", invalid2.host());
  EXPECT_EQ("", invalid2.port());
  EXPECT_EQ(PORT_UNSPECIFIED, invalid2.IntPort());
  EXPECT_EQ("", invalid2.path());
  EXPECT_EQ("", invalid2.query());
  EXPECT_EQ("", invalid2.ref());
}

TEST(GURLTest, Assign) {
  GURL url(u"http://user:pass@google.com:99/foo;bar?q=a#ref");

  GURL url2;
  url2 = url;
  EXPECT_TRUE(url2.is_valid());

  EXPECT_EQ("http://user:pass@google.com:99/foo;bar?q=a#ref", url2.spec());
  EXPECT_EQ("http", url2.scheme());
  EXPECT_EQ("user", url2.username());
  EXPECT_EQ("pass", url2.password());
  EXPECT_EQ("google.com", url2.host());
  EXPECT_EQ("99", url2.port());
  EXPECT_EQ(99, url2.IntPort());
  EXPECT_EQ("/foo;bar", url2.path());
  EXPECT_EQ("q=a", url2.query());
  EXPECT_EQ("ref", url2.ref());

  // Assignment of invalid URL should be invalid
  GURL invalid;
  GURL invalid2;
  invalid2 = invalid;
  EXPECT_FALSE(invalid2.is_valid());
  EXPECT_EQ("", invalid2.spec());
  EXPECT_EQ("", invalid2.scheme());
  EXPECT_EQ("", invalid2.username());
  EXPECT_EQ("", invalid2.password());
  EXPECT_EQ("", invalid2.host());
  EXPECT_EQ("", invalid2.port());
  EXPECT_EQ(PORT_UNSPECIFIED, invalid2.IntPort());
  EXPECT_EQ("", invalid2.path());
  EXPECT_EQ("", invalid2.query());
  EXPECT_EQ("", invalid2.ref());
}

// This is a regression test for http://crbug.com/309975.
TEST(GURLTest, SelfAssign) {
  GURL a("filesystem:http://example.com/temporary/");
  // This should not crash.
  a = *&a;  // The *& defeats Clang's -Wself-assign warning.
}

TEST(GURLTest, CopyFileSystem) {
  GURL url(u"filesystem:https://user:pass@google.com:99/t/foo;bar?q=a#ref");

  GURL url2(url);
  EXPECT_TRUE(url2.is_valid());

  EXPECT_EQ("filesystem:https://google.com:99/t/foo;bar?q=a#ref", url2.spec());
  EXPECT_EQ("filesystem", url2.scheme());
  EXPECT_EQ("", url2.username());
  EXPECT_EQ("", url2.password());
  EXPECT_EQ("", url2.host());
  EXPECT_EQ("", url2.port());
  EXPECT_EQ(PORT_UNSPECIFIED, url2.IntPort());
  EXPECT_EQ("/foo;bar", url2.path());
  EXPECT_EQ("q=a", url2.query());
  EXPECT_EQ("ref", url2.ref());

  const GURL* inner = url2.inner_url();
  ASSERT_TRUE(inner);
  EXPECT_EQ("https", inner->scheme());
  EXPECT_EQ("", inner->username());
  EXPECT_EQ("", inner->password());
  EXPECT_EQ("google.com", inner->host());
  EXPECT_EQ("99", inner->port());
  EXPECT_EQ(99, inner->IntPort());
  EXPECT_EQ("/t", inner->path());
  EXPECT_EQ("", inner->query());
  EXPECT_EQ("", inner->ref());
}

TEST(GURLTest, IsValid) {
  auto valid_cases = std::to_array<const char*>({
      "http://google.com",
      "unknown://google.com",
      "http://user:pass@google.com",
      "http://google.com:12345",
      "http://google.com:0",  // 0 is a valid port
      "http://google.com/path",
      "http://google.com//path",
      "http://google.com?k=v#fragment",
      "http://user:pass@google.com:12345/path?k=v#fragment",
      "http:/path",
      "http:path",
  });
  for (size_t i = 0; i < std::size(valid_cases); i++) {
    EXPECT_TRUE(GURL(valid_cases[i]).is_valid())
        << "Case: " << valid_cases[i];
  }

  auto invalid_cases = std::to_array<const char*>({
      "http://?k=v",
      "http:://google.com",
      "http//google.com",
      "http://google.com:12three45",
      "file://server:123",  // file: URLs cannot have a port
      "file://server:0",
      "://google.com",
      "path",
  });
  for (size_t i = 0; i < std::size(invalid_cases); i++) {
    EXPECT_FALSE(GURL(invalid_cases[i]).is_valid())
        << "Case: " << invalid_cases[i];
  }
}

TEST(GURLTest, ExtraSlashesBeforeAuthority) {
  // According to RFC3986, the hierarchical part for URI with an authority
  // must use only two slashes; GURL intentionally just ignores extra slashes
  // if there are more than 2, and parses the following part as an authority.
  GURL url("http:///host");
  EXPECT_EQ("host", url.host());
  EXPECT_EQ("/", url.path());
}

// Given invalid URLs, we should still get most of the components.
TEST(GURLTest, ComponentGettersWorkEvenForInvalidURL) {
  constexpr struct InvalidURLTestExpectations {
    const char* url;
    const char* spec;
    const char* scheme;
    const char* host;
    const char* port;
    const char* path;
    // Extend as needed...
  } expectations[] = {
      {
          "http:google.com:foo",
          "http://google.com:foo/",
          "http",
          "google.com",
          "foo",
          "/",
      },
      {
          "https:google.com:foo",
          "https://google.com:foo/",
          "https",
          "google.com",
          "foo",
          "/",
      },
  };

  for (const auto& e : expectations) {
    const GURL url(e.url);
    EXPECT_FALSE(url.is_valid());
    EXPECT_EQ(e.spec, url.possibly_invalid_spec());
    EXPECT_EQ(e.scheme, url.scheme());
    EXPECT_EQ("", url.username());
    EXPECT_EQ("", url.password());
    EXPECT_EQ(e.host, url.host());
    EXPECT_EQ(e.port, url.port());
    EXPECT_EQ(PORT_INVALID, url.IntPort());
    EXPECT_EQ(e.path, url.path());
    EXPECT_EQ("", url.query());
    EXPECT_EQ("", url.ref());
  }
}

TEST(GURLTest, Resolve) {
  // The tricky cases for relative URL resolving are tested in the
  // canonicalizer unit test. Here, we just test that the GURL integration
  // works properly.
  struct ResolveCase {
    const char* base;
    const char* relative;
    bool expected_valid;
    const char* expected;
  };
  auto resolve_cases = std::to_array<ResolveCase>({
      {"http://www.google.com/", "foo.html", true,
       "http://www.google.com/foo.html"},
      {"http://www.google.com/foo/", "bar", true,
       "http://www.google.com/foo/bar"},
      {"http://www.google.com/foo/", "/bar", true, "http://www.google.com/bar"},
      {"http://www.google.com/foo", "bar", true, "http://www.google.com/bar"},
      {"http://www.google.com/", "http://images.google.com/foo.html", true,
       "http://images.google.com/foo.html"},
      {"http://www.google.com/", "http://images.\tgoogle.\ncom/\rfoo.html",
       true, "http://images.google.com/foo.html"},
      {"http://www.google.com/blah/bloo?c#d", "../../../hello/./world.html?a#b",
       true, "http://www.google.com/hello/world.html?a#b"},
      {"http://www.google.com/foo#bar", "#com", true,
       "http://www.google.com/foo#com"},
      {"http://www.google.com/", "Https:images.google.com", true,
       "https://images.google.com/"},
      // An opaque path URL can be replaced with a special absolute URL.
      {"data:blahblah", "http://google.com/", true, "http://google.com/"},
      {"data:blahblah", "http:google.com", true, "http://google.com/"},
      {"data:blahblah", "https:google.com", true, "https://google.com/"},
      // An opaque path URL can not be replaced with a relative URL.
      {"git:opaque", "", false, ""},
      {"git:opaque", "path", false, ""},
      // A non-special URL which doesn't have a host can be replaced with a
      // relative URL.
      {"git:/a", "b", true, "git:/b"},
      // Filesystem URLs have different paths to test.
      {"filesystem:http://www.google.com/type/", "foo.html", true,
       "filesystem:http://www.google.com/type/foo.html"},
      {"filesystem:http://www.google.com/type/", "../foo.html", true,
       "filesystem:http://www.google.com/type/foo.html"},
      // https://crbug.com/530123 - scheme validation (e.g. are "10.0.0.7:"
      // or "x1:" valid schemes) when deciding if |relative| is an absolute url.
      {"file:///some/dir/ip-relative.html", "10.0.0.7:8080/foo.html", true,
       "file:///some/dir/10.0.0.7:8080/foo.html"},
      {"file:///some/dir/", "1://host", true, "file:///some/dir/1://host"},
      {"file:///some/dir/", "x1://host", true, "x1://host"},
      {"file:///some/dir/", "X1://host", true, "x1://host"},
      {"file:///some/dir/", "x.://host", true, "x.://host"},
      {"file:///some/dir/", "x+://host", true, "x+://host"},
      {"file:///some/dir/", "x-://host", true, "x-://host"},
      {"file:///some/dir/", "x!://host", true, "file:///some/dir/x!://host"},
      {"file:///some/dir/", "://host", true, "file:///some/dir/://host"},
  });

  for (size_t i = 0; i < std::size(resolve_cases); i++) {
    // 8-bit code path.
    GURL input(resolve_cases[i].base);
    GURL output = input.Resolve(resolve_cases[i].relative);
    EXPECT_EQ(resolve_cases[i].expected_valid, output.is_valid()) << i;
    EXPECT_EQ(resolve_cases[i].expected, output.spec()) << i;
    EXPECT_EQ(output.SchemeIsFileSystem(), output.inner_url() != NULL);

    // Wide code path.
    GURL inputw(base::UTF8ToUTF16(resolve_cases[i].base));
    GURL outputw =
        input.Resolve(base::UTF8ToUTF16(resolve_cases[i].relative));
    EXPECT_EQ(resolve_cases[i].expected_valid, outputw.is_valid()) << i;
    EXPECT_EQ(resolve_cases[i].expected, outputw.spec()) << i;
    EXPECT_EQ(outputw.SchemeIsFileSystem(), outputw.inner_url() != NULL);
  }
}

class GURLTypedTest : public ::testing::TestWithParam<bool> {
 public:
  GURLTypedTest()
      : use_standard_compliant_non_special_scheme_url_parsing_(GetParam()) {
    if (use_standard_compliant_non_special_scheme_url_parsing_) {
      scoped_feature_list_.InitAndEnableFeature(
          kStandardCompliantNonSpecialSchemeURLParsing);
    } else {
      scoped_feature_list_.InitAndDisableFeature(
          kStandardCompliantNonSpecialSchemeURLParsing);
    }
  }

 protected:
  struct ResolveCase {
    std::string_view base;
    std::string_view relative;
    std::optional<std::string_view> expected;
  };

  using ApplyReplacementsFunc = GURL(const GURL&);

  struct ReplaceCase {
    std::string_view base;
    ApplyReplacementsFunc* apply_replacements;
    std::string_view expected;
  };

  struct ReplaceHostCase {
    std::string_view base;
    std::string_view replacement_host;
    std::string_view expected;
  };

  struct ReplacePathCase {
    std::string_view base;
    std::string_view replacement_path;
    std::string_view expected;
  };

  void TestResolve(const ResolveCase& resolve_case) {
    SCOPED_TRACE(testing::Message() << "base: " << resolve_case.base
                                    << ", relative: " << resolve_case.relative);
    GURL input(resolve_case.base);
    GURL output = input.Resolve(resolve_case.relative);
    if (resolve_case.expected) {
      ASSERT_TRUE(output.is_valid());
      EXPECT_EQ(output.spec(), *resolve_case.expected);
    } else {
      EXPECT_FALSE(output.is_valid());
    }
  }

  void TestReplace(const ReplaceCase& replace) {
    GURL output = replace.apply_replacements(GURL(replace.base));
    EXPECT_EQ(output.spec(), replace.expected);
  }

  void TestReplaceHost(const ReplaceHostCase& replace) {
    GURL url(replace.base);
    GURL::Replacements replacements;
    replacements.SetHostStr(replace.replacement_host);
    GURL output = url.ReplaceComponents(replacements);
    EXPECT_EQ(output.spec(), replace.expected);
  }

  void TestReplacePath(const ReplacePathCase& replace) {
    GURL url(replace.base);
    GURL::Replacements replacements;
    replacements.SetPathStr(replace.replacement_path);
    GURL output = url.ReplaceComponents(replacements);
    EXPECT_EQ(output.spec(), replace.expected);
  }

  bool use_standard_compliant_non_special_scheme_url_parsing_;

 private:
  base::test::ScopedFeatureList scoped_feature_list_;
};

TEST_P(GURLTypedTest, Resolve) {
  // Test flag-dependent behaviors.
  // Existing tests in GURLTest::Resolve cover common cases.
  if (use_standard_compliant_non_special_scheme_url_parsing_) {
    ResolveCase cases[] = {
        // Non-special base URLs whose paths are empty.
        {"git://host", "", "git://host"},
        {"git://host", ".", "git://host/"},
        {"git://host", "..", "git://host/"},
        {"git://host", "a", "git://host/a"},
        {"git://host", "/a", "git://host/a"},

        // Non-special base URLs whose paths are "/".
        {"git://host/", "", "git://host/"},
        {"git://host/", ".", "git://host/"},
        {"git://host/", "..", "git://host/"},
        {"git://host/", "a", "git://host/a"},
        {"git://host/", "/a", "git://host/a"},

        // Non-special base URLs whose hosts and paths are non-empty.
        {"git://host/b", "a", "git://host/a"},
        {"git://host/b/c", "a", "git://host/b/a"},
        {"git://host/b/c", "../a", "git://host/a"},

        // An opaque path can be specified.
        {"git://host", "git:opaque", "git:opaque"},
        {"git://host/path#ref", "git:opaque", "git:opaque"},
        {"git:/path", "git:opaque", "git:opaque"},
        {"https://host/path", "git:opaque", "git:opaque"},

        // Path-only base URLs should remain path-only URLs unless a host is
        // specified.
        {"git:/", "", "git:/"},
        {"git:/", ".", "git:/"},
        {"git:/", "..", "git:/"},
        {"git:/", "a", "git:/a"},
        {"git:/", "/a", "git:/a"},
        {"git:/#ref", "", "git:/"},
        {"git:/#ref", "a", "git:/a"},

        // Non-special base URLs whose hosts and path are both empty. The
        // result's host should remain empty unless a relative URL specify a
        // host.
        {"git://", "", "git://"},
        {"git://", ".", "git:///"},
        {"git://", "..", "git:///"},
        {"git://", "a", "git:///a"},
        {"git://", "/a", "git:///a"},

        // Non-special base URLs whose hosts are empty, but with non-empty path.
        {"git:///", "", "git:///"},
        {"git:///", ".", "git:///"},
        {"git:///", "..", "git:///"},
        {"git:///", "a", "git:///a"},
        {"git:///", "/a", "git:///a"},
        {"git:///#ref", "", "git:///"},
        {"git:///#ref", "a", "git:///a"},

        // Relative URLs can specify empty hosts for non-special base URLs.
        // e.g. "///path"
        {"git://host/", "//", "git://"},
        {"git://host/", "//a", "git://a"},
        {"git://host/", "///", "git:///"},
        {"git://host/", "////", "git:////"},
        {"git://host/", "////..", "git:///"},
        {"git://host/", "////../..", "git:///"},
        {"git://host/", "////../../..", "git:///"},
    };
    for (const auto& i : cases) {
      TestResolve(i);
    }
  } else {
    ResolveCase cases[] = {
        {"git:/", "", "git:/"},
        {"git:/", "a", "git:/a"},
        {"git:/path", "a", "git:/a"},
        // All non-special base URLs which don't start with a *single* slash
        // can not be resolved with a relative URL.
        {"git:", "", std::nullopt},
        {"git://host", "", std::nullopt},
        {"git://host", "a", std::nullopt},
        {"git://", "", std::nullopt},
        {"git:///", "", std::nullopt},
    };
    for (const auto& i : cases) {
      TestResolve(i);
    }
  }
}

INSTANTIATE_TEST_SUITE_P(All, GURLTypedTest, ::testing::Bool());

TEST(GURLTest, GetOrigin) {
  struct TestCase {
    const char* input;
    const char* expected;
  };
  auto cases = std::to_array<TestCase>({
      {"http://www.google.com", "http://www.google.com/"},
      {"javascript:window.alert(\"hello,world\");", ""},
      {"http://user:pass@www.google.com:21/blah#baz",
       "http://www.google.com:21/"},
      {"http://user@www.google.com", "http://www.google.com/"},
      {"http://:pass@www.google.com", "http://www.google.com/"},
      {"http://:@www.google.com", "http://www.google.com/"},
      {"filesystem:http://www.google.com/temp/foo?q#b",
       "http://www.google.com/"},
      {"filesystem:http://user:pass@google.com:21/blah#baz",
       "http://google.com:21/"},
      {"blob:null/guid-goes-here", ""},
      {"blob:http://origin/guid-goes-here", "" /* should be http://origin/ */},
  });
  for (size_t i = 0; i < std::size(cases); i++) {
    GURL url(cases[i].input);
    GURL origin = url.DeprecatedGetOriginAsURL();
    EXPECT_EQ(cases[i].expected, origin.spec());
  }
}

TEST(GURLTest, GetAsReferrer) {
  struct TestCase {
    const char* input;
    const char* expected;
  };
  auto cases = std::to_array<TestCase>({
      {"http://www.google.com", "http://www.google.com/"},
      {"http://user:pass@www.google.com:21/blah#baz",
       "http://www.google.com:21/blah"},
      {"http://user@www.google.com", "http://www.google.com/"},
      {"http://:pass@www.google.com", "http://www.google.com/"},
      {"http://:@www.google.com", "http://www.google.com/"},
      {"http://www.google.com/temp/foo?q#b",
       "http://www.google.com/temp/foo?q"},
      {"not a url", ""},
      {"unknown-scheme://foo.html", ""},
      {"file:///tmp/test.html", ""},
      {"https://www.google.com", "https://www.google.com/"},
  });
  for (size_t i = 0; i < std::size(cases); i++) {
    GURL url(cases[i].input);
    GURL origin = url.GetAsReferrer();
    EXPECT_EQ(cases[i].expected, origin.spec());
  }
}

TEST(GURLTest, GetWithEmptyPath) {
  struct TestCase {
    const char* input;
    const char* expected;
  };
  auto cases = std::to_array<TestCase>({
      {"http://www.google.com", "http://www.google.com/"},
      {"javascript:window.alert(\"hello, world\");", ""},
      {"http://www.google.com/foo/bar.html?baz=22", "http://www.google.com/"},
      {"filesystem:http://www.google.com/temporary/bar.html?baz=22",
       "filesystem:http://www.google.com/temporary/"},
      {"filesystem:file:///temporary/bar.html?baz=22",
       "filesystem:file:///temporary/"},
  });

  for (size_t i = 0; i < std::size(cases); i++) {
    GURL url(cases[i].input);
    GURL empty_path = url.GetWithEmptyPath();
    EXPECT_EQ(cases[i].expected, empty_path.spec());
  }
}

TEST(GURLTest, GetWithoutFilename) {
  struct TestCase {
    const char* input;
    const char* expected;
  };
  auto cases = std::to_array<TestCase>({
      // Common Standard URLs.
      {"https://www.google.com", "https://www.google.com/"},
      {"https://www.google.com/", "https://www.google.com/"},
      {"https://www.google.com/maps.htm", "https://www.google.com/"},
      {"https://www.google.com/maps/", "https://www.google.com/maps/"},
      {"https://www.google.com/index.html", "https://www.google.com/"},
      {"https://www.google.com/index.html?q=maps", "https://www.google.com/"},
      {"https://www.google.com/index.html#maps/", "https://www.google.com/"},
      {"https://foo:bar@www.google.com/maps.htm",
       "https://foo:bar@www.google.com/"},
      {"https://www.google.com/maps/au/index.html",
       "https://www.google.com/maps/au/"},
      {"https://www.google.com/maps/au/north",
       "https://www.google.com/maps/au/"},
      {"https://www.google.com/maps/au/north/",
       "https://www.google.com/maps/au/north/"},
      {"https://www.google.com/maps/au/index.html?q=maps#fragment/",
       "https://www.google.com/maps/au/"},
      {"http://www.google.com:8000/maps/au/index.html?q=maps#fragment/",
       "http://www.google.com:8000/maps/au/"},
      {"https://www.google.com/maps/au/north/?q=maps#fragment",
       "https://www.google.com/maps/au/north/"},
      {"https://www.google.com/maps/au/north?q=maps#fragment",
       "https://www.google.com/maps/au/"},
      // Less common standard URLs.
      {"filesystem:http://www.google.com/temporary/bar.html?baz=22",
       "filesystem:http://www.google.com/temporary/"},
      {"file:///temporary/bar.html?baz=22", "file:///temporary/"},
      {"ftp://foo/test/index.html", "ftp://foo/test/"},
      {"gopher://foo/test/index.html", "gopher://foo/test/"},
      {"ws://foo/test/index.html", "ws://foo/test/"},
      // Non-standard, hierarchical URLs.
      {"chrome://foo/bar.html", "chrome://foo/"},
      {"httpa://foo/test/index.html", "httpa://foo/test/"},
      // Non-standard, non-hierarchical URLs.
      {"blob:https://foo.bar/test/index.html", ""},
      {"about:blank", ""},
      {"data:foobar", ""},
      {"scheme:opaque_data", ""},
      // Invalid URLs.
      {"foobar", ""},
  });

  for (size_t i = 0; i < std::size(cases); i++) {
    GURL url(cases[i].input);
    GURL without_filename = url.GetWithoutFilename();
    EXPECT_EQ(cases[i].expected, without_filename.spec()) << i;
  }
}

TEST(GURLTest, GetWithoutRef) {
  struct TestCase {
    const char* input;
    const char* expected;
  };
  auto cases = std::to_array<TestCase>({
      // Common Standard URLs.
      {"https://www.google.com/index.html",
       "https://www.google.com/index.html"},
      {"https://www.google.com/index.html#maps/",
       "https://www.google.com/index.html"},

      {"https://foo:bar@www.google.com/maps.htm",
       "https://foo:bar@www.google.com/maps.htm"},
      {"https://foo:bar@www.google.com/maps.htm#fragment",
       "https://foo:bar@www.google.com/maps.htm"},

      {"https://www.google.com/maps/au/index.html?q=maps",
       "https://www.google.com/maps/au/index.html?q=maps"},
      {"https://www.google.com/maps/au/index.html?q=maps#fragment/",
       "https://www.google.com/maps/au/index.html?q=maps"},

      {"http://www.google.com:8000/maps/au/index.html?q=maps",
       "http://www.google.com:8000/maps/au/index.html?q=maps"},
      {"http://www.google.com:8000/maps/au/index.html?q=maps#fragment/",
       "http://www.google.com:8000/maps/au/index.html?q=maps"},

      {"https://www.google.com/maps/au/north/?q=maps",
       "https://www.google.com/maps/au/north/?q=maps"},
      {"https://www.google.com/maps/au/north?q=maps#fragment",
       "https://www.google.com/maps/au/north?q=maps"},

      // Less common standard URLs.
      {"filesystem:http://www.google.com/temporary/bar.html?baz=22",
       "filesystem:http://www.google.com/temporary/bar.html?baz=22"},
      {"file:///temporary/bar.html?baz=22#fragment",
       "file:///temporary/bar.html?baz=22"},

      {"ftp://foo/test/index.html", "ftp://foo/test/index.html"},
      {"ftp://foo/test/index.html#fragment", "ftp://foo/test/index.html"},

      {"gopher://foo/test/index.html", "gopher://foo/test/index.html"},
      {"gopher://foo/test/index.html#fragment", "gopher://foo/test/index.html"},

      {"ws://foo/test/index.html", "ws://foo/test/index.html"},
      {"ws://foo/test/index.html#fragment", "ws://foo/test/index.html"},

      // Non-standard, hierarchical URLs.
      {"chrome://foo/bar.html", "chrome://foo/bar.html"},
      {"chrome://foo/bar.html#fragment", "chrome://foo/bar.html"},

      {"httpa://foo/test/index.html", "httpa://foo/test/index.html"},
      {"httpa://foo/test/index.html#fragment", "httpa://foo/test/index.html"},

      // Non-standard, non-hierarchical URLs.
      {"blob:https://foo.bar/test/index.html",
       "blob:https://foo.bar/test/index.html"},
      {"blob:https://foo.bar/test/index.html#fragment",
       "blob:https://foo.bar/test/index.html"},

      {"about:blank", "about:blank"},
      {"about:blank#ref", "about:blank"},

      {"data:foobar", "data:foobar"},
      {"scheme:opaque_data", "scheme:opaque_data"},
      // Invalid URLs.
      {"foobar", ""},
  });

  for (size_t i = 0; i < std::size(cases); i++) {
    GURL url(cases[i].input);
    GURL without_ref = url.GetWithoutRef();
    EXPECT_EQ(cases[i].expected, without_ref.spec());
  }
}

TEST(GURLTest, Replacements) {
  // The URL canonicalizer replacement test will handle most of these case.
  // The most important thing to do here is to check that the proper
  // canonicalizer gets called based on the scheme of the input.
  struct ReplaceCase {
    using ApplyReplacementsFunc = GURL(const GURL&);

    const char* base;
    ApplyReplacementsFunc* apply_replacements;
    const char* expected;
  } replace_cases[] = {
      {.base = "http://www.google.com/foo/bar.html?foo#bar",
       .apply_replacements =
           +[](const GURL& url) {
             GURL::Replacements replacements;
             replacements.SetPathStr("/");
             replacements.ClearQuery();
             replacements.ClearRef();
             return url.ReplaceComponents(replacements);
           },
       .expected = "http://www.google.com/"},
      {.base = "file:///C:/foo/bar.txt",
       .apply_replacements =
           +[](const GURL& url) {
             GURL::Replacements replacements;
             replacements.SetSchemeStr("http");
             replacements.SetHostStr("www.google.com");
             replacements.SetPortStr("99");
             replacements.SetPathStr("/foo");
             replacements.SetQueryStr("search");
             replacements.SetRefStr("ref");
             return url.ReplaceComponents(replacements);
           },
       .expected = "http://www.google.com:99/foo?search#ref"},
#ifdef WIN32
      {.base = "http://www.google.com/foo/bar.html?foo#bar",
       .apply_replacements =
           +[](const GURL& url) {
             GURL::Replacements replacements;
             replacements.SetSchemeStr("file");
             replacements.ClearUsername();
             replacements.ClearPassword();
             replacements.ClearHost();
             replacements.ClearPort();
             replacements.SetPathStr("c:\\");
             replacements.ClearQuery();
             replacements.ClearRef();
             return url.ReplaceComponents(replacements);
           },
       .expected = "file:///C:/"},
#endif
      {.base = "filesystem:http://www.google.com/foo/bar.html?foo#bar",
       .apply_replacements =
           +[](const GURL& url) {
             GURL::Replacements replacements;
             replacements.SetPathStr("/");
             replacements.ClearQuery();
             replacements.ClearRef();
             return url.ReplaceComponents(replacements);
           },
       .expected = "filesystem:http://www.google.com/foo/"},
      // Lengthen the URL instead of shortening it, to test creation of
      // inner_url.
      {.base = "filesystem:http://www.google.com/foo/",
       .apply_replacements =
           +[](const GURL& url) {
             GURL::Replacements replacements;
             replacements.SetPathStr("bar.html");
             replacements.SetQueryStr("foo");
             replacements.SetRefStr("bar");
             return url.ReplaceComponents(replacements);
           },
       .expected = "filesystem:http://www.google.com/foo/bar.html?foo#bar"},
      // Regression test for https://crbug.com/375660989.
      //
      // "steam:" is explicitly registered as an opaque non-special scheme for
      // compatibility reasons. See SchemeRegistry::opaque_non_special_schemes.
      {.base = "steam:a",
       .apply_replacements =
           +[](const GURL& url) {
             GURL::Replacements replacements;
             replacements.SetPathStr("b");
             return url.ReplaceComponents(replacements);
           },
       .expected = "steam:b"},
  };

  for (const ReplaceCase& c : replace_cases) {
    GURL output = c.apply_replacements(GURL(c.base));

    EXPECT_EQ(c.expected, output.spec());

    EXPECT_EQ(output.SchemeIsFileSystem(), output.inner_url() != NULL);
    if (output.SchemeIsFileSystem()) {
      // TODO(mmenke): inner_url()->spec() is currently the same as the spec()
      // for the GURL itself.  This should be fixed.
      // See https://crbug.com/619596
      EXPECT_EQ(c.expected, output.inner_url()->spec());
    }
  }
}

TEST_P(GURLTypedTest, Replacements) {
  // Test flag-dependent behavior.
  // Existing tests in GURLTest::Replacements cover common cases.

  if (use_standard_compliant_non_special_scheme_url_parsing_) {
    ReplaceCase replace_cases[] = {
        {.base = "git://a1/a2?a3=a4#a5",
         .apply_replacements =
             +[](const GURL& url) {
               GURL::Replacements replacements;
               replacements.SetHostStr("b1");
               replacements.SetPortStr("99");
               replacements.SetPathStr("b2");
               replacements.SetQueryStr("b3=b4");
               replacements.SetRefStr("b5");
               return url.ReplaceComponents(replacements);
             },
         .expected = "git://b1:99/b2?b3=b4#b5"},
        // URL Standard: https://url.spec.whatwg.org/#dom-url-username
        // > 1. If this’s URL cannot have a username/password/port, then return.
        {.base = "git:///",
         .apply_replacements =
             +[](const GURL& url) {
               GURL::Replacements replacements;
               replacements.SetUsernameStr("x");
               return url.ReplaceComponents(replacements);
             },
         .expected = "git:///"},
        // URL Standard: https://url.spec.whatwg.org/#dom-url-password
        // > 1. If this’s URL cannot have a username/password/port, then return.
        {.base = "git:///",
         .apply_replacements =
             +[](const GURL& url) {
               GURL::Replacements replacements;
               replacements.SetPasswordStr("x");
               return url.ReplaceComponents(replacements);
             },
         .expected = "git:///"},
        // URL Standard: https://url.spec.whatwg.org/#dom-url-port
        // > 1. If this’s URL cannot have a username/password/port, then return.
        {.base = "git:///",
         .apply_replacements =
             +[](const GURL& url) {
               GURL::Replacements replacements;
               replacements.SetPortStr("80");
               return url.ReplaceComponents(replacements);
             },
         .expected = "git:///"}};

    for (const ReplaceCase& c : replace_cases) {
      TestReplace(c);
    }

    ReplaceHostCase replace_host_cases[] = {
        {"git:/", "host", "git://host/"},
        {"git:/a", "host", "git://host/a"},
        {"git://", "host", "git://host"},
        {"git:///", "host", "git://host/"},
        {"git://h/a", "host", "git://host/a"},
        // The following behavior is different from Web-facing URL APIs
        // because DOMURLUtils::setHostname disallows setting an empty host.
        //
        // Web-facing URL API behavior is:
        // > const url = new URL("git://u:p@h:80/");
        // > url.hostname = "";
        // > assertEquals(url.href, "git://u:p@h:80/");
        {"git://u:p@h:80/", "", "git:///"}};
    for (const ReplaceHostCase& c : replace_host_cases) {
      TestReplaceHost(c);
    }

    ReplacePathCase replace_path_cases[] = {
        {"git:/", "a", "git:/a"},
        {"git:/", "", "git:/"},
        {"git:/", "//a", "git:/.//a"},
        {"git:/", "/.//a", "git:/.//a"},
        {"git://", "a", "git:///a"},
        {"git:///", "a", "git:///a"},
        {"git://host", "a", "git://host/a"},
        {"git://host/b", "a", "git://host/a"}};
    for (const ReplacePathCase& c : replace_path_cases) {
      TestReplacePath(c);
    }
  } else {
    // Non-compliant behaviors.
    ReplaceHostCase replace_host_cases[] = {
        {"git://host", "h2", "git://host"},
    };
    for (const ReplaceHostCase& c : replace_host_cases) {
      TestReplaceHost(c);
    }

    // Non-compliant behaviors.
    ReplacePathCase replace_path_cases[] = {{"git://host", "path", "git:path"}};
    for (const ReplacePathCase& c : replace_path_cases) {
      TestReplacePath(c);
    }
  }
}

TEST(GURLTypedTest, ClearFragmentOnDataUrl) {
  // http://crbug.com/291747 - a data URL may legitimately have trailing
  // whitespace in the spec after the ref is cleared. Test this does not trigger
  // the Parsed importing validation DCHECK in GURL.
  GURL url(" data: one # two ");
  EXPECT_TRUE(url.is_valid());

  // By default the trailing whitespace will have been stripped.
  EXPECT_EQ("data: one #%20two", url.spec());

  // Clear the URL's ref and observe the trailing whitespace.
  GURL::Replacements repl;
  repl.ClearRef();
  GURL url_no_ref = url.ReplaceComponents(repl);
  EXPECT_TRUE(url_no_ref.is_valid());
  EXPECT_EQ("data: one ", url_no_ref.spec());

  // Importing a parsed URL via this constructor overload will retain trailing
  // whitespace.
  GURL import_url(url_no_ref.spec(),
                  url_no_ref.parsed_for_possibly_invalid_spec(),
                  url_no_ref.is_valid());
  EXPECT_TRUE(import_url.is_valid());
  EXPECT_EQ(url_no_ref, import_url);
  EXPECT_EQ("data: one ", import_url.spec());
  EXPECT_EQ(" one ", import_url.path());

  // For completeness, test that re-parsing the same URL rather than importing
  // it trims the trailing whitespace.
  GURL reparsed_url(url_no_ref.spec());
  EXPECT_TRUE(reparsed_url.is_valid());
  EXPECT_EQ("data: one", reparsed_url.spec());
}

TEST(GURLTest, PathForRequest) {
  struct TestCase {
    const char* input;
    const char* expected;
    const char* inner_expected;
  };
  auto cases = std::to_array<TestCase>({
      {"http://www.google.com", "/", nullptr},
      {"http://www.google.com/", "/", nullptr},
      {"http://www.google.com/foo/bar.html?baz=22", "/foo/bar.html?baz=22",
       nullptr},
      {"http://www.google.com/foo/bar.html#ref", "/foo/bar.html", nullptr},
      {"http://www.google.com/foo/bar.html?query#ref", "/foo/bar.html?query",
       nullptr},
      {"filesystem:http://www.google.com/temporary/foo/bar.html?query#ref",
       "/foo/bar.html?query", "/temporary"},
      {"filesystem:http://www.google.com/temporary/foo/bar.html?query",
       "/foo/bar.html?query", "/temporary"},
  });

  for (size_t i = 0; i < std::size(cases); i++) {
    GURL url(cases[i].input);
    EXPECT_EQ(cases[i].expected, url.PathForRequest());
    EXPECT_EQ(cases[i].expected, url.PathForRequestPiece());
    EXPECT_EQ(cases[i].inner_expected == NULL, url.inner_url() == NULL);
    if (url.inner_url() && cases[i].inner_expected) {
      EXPECT_EQ(cases[i].inner_expected, url.inner_url()->PathForRequest());
      EXPECT_EQ(cases[i].inner_expected,
                url.inner_url()->PathForRequestPiece());
    }
  }
}

TEST(GURLTest, EffectiveIntPort) {
  struct PortTest {
    const char* spec;
    int expected_int_port;
  };
  auto port_tests = std::to_array<PortTest>({
      // http
      {"http://www.google.com/", 80},
      {"http://www.google.com:80/", 80},
      {"http://www.google.com:443/", 443},

      // https
      {"https://www.google.com/", 443},
      {"https://www.google.com:443/", 443},
      {"https://www.google.com:80/", 80},

      // ftp
      {"ftp://www.google.com/", 21},
      {"ftp://www.google.com:21/", 21},
      {"ftp://www.google.com:80/", 80},

      // file - no port
      {"file://www.google.com/", PORT_UNSPECIFIED},
      {"file://www.google.com:443/", PORT_UNSPECIFIED},

      // data - no port
      {"data:www.google.com:90", PORT_UNSPECIFIED},
      {"data:www.google.com", PORT_UNSPECIFIED},

      // filesystem - no port
      {"filesystem:http://www.google.com:90/t/foo", PORT_UNSPECIFIED},
      {"filesystem:file:///t/foo", PORT_UNSPECIFIED},
  });

  for (size_t i = 0; i < std::size(port_tests); i++) {
    GURL url(port_tests[i].spec);
    EXPECT_EQ(port_tests[i].expected_int_port, url.EffectiveIntPort());
  }
}

TEST(GURLTest, IPAddress) {
  struct IPTest {
    const char* spec;
    bool expected_ip;
  };
  auto ip_tests = std::to_array<IPTest>({
      {"http://www.google.com/", false},
      {"http://192.168.9.1/", true},
      {"http://192.168.9.1.2/", false},
      {"http://192.168.m.1/", false},
      {"http://2001:db8::1/", false},
      {"http://[2001:db8::1]/", true},
      {"", false},
      {"some random input!", false},
  });

  for (size_t i = 0; i < std::size(ip_tests); i++) {
    GURL url(ip_tests[i].spec);
    EXPECT_EQ(ip_tests[i].expected_ip, url.HostIsIPAddress());
  }
}

TEST(GURLTest, HostNoBrackets) {
  struct TestCase {
    const char* input;
    const char* expected_host;
    const char* expected_plainhost;
  };
  auto cases = std::to_array<TestCase>({
      {"http://www.google.com", "www.google.com", "www.google.com"},
      {"http://[2001:db8::1]/", "[2001:db8::1]", "2001:db8::1"},
      {"http://[::]/", "[::]", "::"},

      // Don't require a valid URL, but don't crash either.
      {"http://[]/", "[]", ""},
      {"http://[x]/", "[x]", "x"},
      {"http://[x/", "[x", "[x"},
      {"http://x]/", "x]", "x]"},
      {"http://[/", "[", "["},
      {"http://]/", "]", "]"},
      {"", "", ""},
  });
  for (size_t i = 0; i < std::size(cases); i++) {
    GURL url(cases[i].input);
    EXPECT_EQ(cases[i].expected_host, url.host());
    EXPECT_EQ(cases[i].expected_plainhost, url.HostNoBrackets());
    EXPECT_EQ(cases[i].expected_plainhost, url.HostNoBracketsPiece());
  }
}

TEST(GURLTest, DomainIs) {
  GURL url_1("http://google.com/foo");
  EXPECT_TRUE(url_1.DomainIs("google.com"));

  // Subdomain and port are ignored.
  GURL url_2("http://www.google.com:99/foo");
  EXPECT_TRUE(url_2.DomainIs("google.com"));

  // Different top-level domain.
  GURL url_3("http://www.google.com.cn/foo");
  EXPECT_FALSE(url_3.DomainIs("google.com"));

  // Different host name.
  GURL url_4("http://www.iamnotgoogle.com/foo");
  EXPECT_FALSE(url_4.DomainIs("google.com"));

  // The input must be lower-cased otherwise DomainIs returns false.
  GURL url_5("http://www.google.com/foo");
  EXPECT_FALSE(url_5.DomainIs("Google.com"));

  // If the URL is invalid, DomainIs returns false.
  GURL invalid_url("google.com");
  EXPECT_FALSE(invalid_url.is_valid());
  EXPECT_FALSE(invalid_url.DomainIs("google.com"));

  GURL url_with_escape_chars("https://www.,.test");
  EXPECT_TRUE(url_with_escape_chars.is_valid());
  EXPECT_EQ(url_with_escape_chars.host(), "www.,.test");
  EXPECT_TRUE(url_with_escape_chars.DomainIs(",.test"));
}

TEST(GURLTest, DomainIsTerminatingDotBehavior) {
  // If the host part ends with a dot, it matches input domains
  // with or without a dot.
  GURL url_with_dot("http://www.google.com./foo");
  EXPECT_TRUE(url_with_dot.DomainIs("google.com"));
  EXPECT_TRUE(url_with_dot.DomainIs("google.com."));
  EXPECT_TRUE(url_with_dot.DomainIs(".com"));
  EXPECT_TRUE(url_with_dot.DomainIs(".com."));

  // But, if the host name doesn't end with a dot and the input
  // domain does, then it's considered to not match.
  GURL url_without_dot("http://google.com/foo");
  EXPECT_FALSE(url_without_dot.DomainIs("google.com."));

  // If the URL ends with two dots, it doesn't match.
  GURL url_with_two_dots("http://www.google.com../foo");
  EXPECT_FALSE(url_with_two_dots.DomainIs("google.com"));
}

TEST(GURLTest, DomainIsWithFilesystemScheme) {
  GURL url_1("filesystem:http://www.google.com:99/foo/");
  EXPECT_TRUE(url_1.DomainIs("google.com"));

  GURL url_2("filesystem:http://www.iamnotgoogle.com/foo/");
  EXPECT_FALSE(url_2.DomainIs("google.com"));
}

// Newlines should be stripped from inputs.
TEST(GURLTest, Newlines) {
  // Constructor.
  GURL url_1(" \t ht\ntp://\twww.goo\rgle.com/as\ndf \n ");
  EXPECT_EQ("http://www.google.com/asdf", url_1.spec());
  EXPECT_FALSE(
      url_1.parsed_for_possibly_invalid_spec().potentially_dangling_markup);

  // Relative path resolver.
  GURL url_2 = url_1.Resolve(" \n /fo\to\r ");
  EXPECT_EQ("http://www.google.com/foo", url_2.spec());
  EXPECT_FALSE(
      url_2.parsed_for_possibly_invalid_spec().potentially_dangling_markup);

  // Constructor.
  GURL url_3(" \t ht\ntp://\twww.goo\rgle.com/as\ndf< \n ");
  EXPECT_EQ("http://www.google.com/asdf%3C", url_3.spec());
  EXPECT_TRUE(
      url_3.parsed_for_possibly_invalid_spec().potentially_dangling_markup);

  // Relative path resolver.
  GURL url_4 = url_1.Resolve(" \n /fo\to<\r ");
  EXPECT_EQ("http://www.google.com/foo%3C", url_4.spec());
  EXPECT_TRUE(
      url_4.parsed_for_possibly_invalid_spec().potentially_dangling_markup);

  // Note that newlines are NOT stripped from ReplaceComponents.
}

TEST(GURLTest, IsStandard) {
  GURL a("http:foo/bar");
  EXPECT_TRUE(a.IsStandard());

  GURL b("foo:bar/baz");
  EXPECT_FALSE(b.IsStandard());

  GURL c("foo://bar/baz");
  EXPECT_FALSE(c.IsStandard());

  GURL d("cid:bar@baz");
  EXPECT_FALSE(d.IsStandard());
}

TEST(GURLTest, SchemeIsHTTPOrHTTPS) {
  EXPECT_TRUE(GURL("http://bar/").SchemeIsHTTPOrHTTPS());
  EXPECT_TRUE(GURL("HTTPS://BAR").SchemeIsHTTPOrHTTPS());
  EXPECT_FALSE(GURL("ftp://bar/").SchemeIsHTTPOrHTTPS());
}

TEST(GURLTest, SchemeIsWSOrWSS) {
  EXPECT_TRUE(GURL("WS://BAR/").SchemeIsWSOrWSS());
  EXPECT_TRUE(GURL("wss://bar/").SchemeIsWSOrWSS());
  EXPECT_FALSE(GURL("http://bar/").SchemeIsWSOrWSS());
}

TEST(GURLTest, SchemeIsCryptographic) {
  EXPECT_TRUE(GURL("https://foo.bar.com/").SchemeIsCryptographic());
  EXPECT_TRUE(GURL("HTTPS://foo.bar.com/").SchemeIsCryptographic());
  EXPECT_TRUE(GURL("HtTpS://foo.bar.com/").SchemeIsCryptographic());

  EXPECT_TRUE(GURL("wss://foo.bar.com/").SchemeIsCryptographic());
  EXPECT_TRUE(GURL("WSS://foo.bar.com/").SchemeIsCryptographic());
  EXPECT_TRUE(GURL("WsS://foo.bar.com/").SchemeIsCryptographic());

  EXPECT_FALSE(GURL("http://foo.bar.com/").SchemeIsCryptographic());
  EXPECT_FALSE(GURL("ws://foo.bar.com/").SchemeIsCryptographic());
}

TEST(GURLTest, SchemeIsCryptographicStatic) {
  EXPECT_TRUE(GURL::SchemeIsCryptographic("https"));
  EXPECT_TRUE(GURL::SchemeIsCryptographic("wss"));
  EXPECT_FALSE(GURL::SchemeIsCryptographic("http"));
  EXPECT_FALSE(GURL::SchemeIsCryptographic("ws"));
  EXPECT_FALSE(GURL::SchemeIsCryptographic("ftp"));
}

TEST(GURLTest, SchemeIsBlob) {
  EXPECT_TRUE(GURL("BLOB://BAR/").SchemeIsBlob());
  EXPECT_TRUE(GURL("blob://bar/").SchemeIsBlob());
  EXPECT_FALSE(GURL("http://bar/").SchemeIsBlob());
}

TEST(GURLTest, SchemeIsLocal) {
  EXPECT_TRUE(GURL("BLOB://BAR/").SchemeIsLocal());
  EXPECT_TRUE(GURL("blob://bar/").SchemeIsLocal());
  EXPECT_TRUE(GURL("DATA:TEXT/HTML,BAR").SchemeIsLocal());
  EXPECT_TRUE(GURL("data:text/html,bar").SchemeIsLocal());
  EXPECT_TRUE(GURL("ABOUT:BAR").SchemeIsLocal());
  EXPECT_TRUE(GURL("about:bar").SchemeIsLocal());
  EXPECT_TRUE(GURL("FILESYSTEM:HTTP://FOO.EXAMPLE/BAR").SchemeIsLocal());
  EXPECT_TRUE(GURL("filesystem:http://foo.example/bar").SchemeIsLocal());

  EXPECT_FALSE(GURL("http://bar/").SchemeIsLocal());
  EXPECT_FALSE(GURL("file:///bar").SchemeIsLocal());
}

// Tests that the 'content' of the URL is properly extracted. This can be
// complex in cases such as multiple schemes (view-source:http:) or for
// javascript URLs. See GURL::GetContent for more details.
TEST(GURLTest, ContentForNonStandardURLs) {
  struct TestCase {
    const char* url;
    const char* expected;
  } cases[] = {
      {"null", ""},
      {"not-a-standard-scheme:this is arbitrary content",
       "this is arbitrary content"},

      // When there are multiple schemes, only the first is excluded from the
      // content. Note also that for e.g. 'http://', the '//' is part of the
      // content not the scheme.
      {"view-source:http://example.com/path", "http://example.com/path"},
      {"blob:http://example.com/GUID", "http://example.com/GUID"},
      {"blob:http://user:password@example.com/GUID",
       "http://user:password@example.com/GUID"},

      // The octothorpe character ('#') marks the end of the URL content, and
      // the start of the fragment. It should not be included in the content.
      {"http://www.example.com/GUID#ref", "www.example.com/GUID"},
      {"http://me:secret@example.com/GUID/#ref", "me:secret@example.com/GUID/"},
      {"data:text/html,Question?<div style=\"color: #bad\">idea</div>",
       "text/html,Question?%3Cdiv%20style=%22color:%20"},

      // TODO(mkwst): This seems like a bug. https://crbug.com/513600
      {"filesystem:http://example.com/path", "/"},

      // Javascript URLs include '#' symbols in their content.
      {"javascript:#", "#"},
      {"javascript:alert('#');", "alert('#');"},
  };

  for (const auto& test : cases) {
    GURL url(test.url);
    EXPECT_EQ(test.expected, url.GetContent()) << test.url;
    EXPECT_EQ(test.expected, url.GetContentPiece()) << test.url;
  }
}

TEST_P(GURLTypedTest, ContentForNonStandardURLs) {
  struct TestCase {
    const std::string_view url;
    const std::string_view expected;
  };

  if (use_standard_compliant_non_special_scheme_url_parsing_) {
    TestCase cases[] = {
        {"blob://http://example.com/GUID", "http//example.com/GUID"},
        {"git://host/path#fragment", "host/path"},
    };
    for (const auto& test : cases) {
      GURL url(test.url);
      EXPECT_EQ(url.GetContent(), test.expected) << test.url;
      EXPECT_EQ(url.GetContentPiece(), test.expected) << test.url;
    }
  } else {
    TestCase cases[] = {
        {"blob://http://example.com/GUID", "//http://example.com/GUID"},
        {"git://host/path#fragment", "//host/path"},
    };
    for (const auto& test : cases) {
      GURL url(test.url);
      EXPECT_EQ(url.GetContent(), test.expected) << test.url;
      EXPECT_EQ(url.GetContentPiece(), test.expected) << test.url;
    }
  }
}

// Tests that the URL path is properly extracted for unusual URLs. This can be
// complex in cases such as multiple schemes (view-source:http:) or when
// octothorpes ('#') are involved.
TEST(GURLTest, PathForNonStandardURLs) {
  struct TestCase {
    const char* url;
    const char* expected;
  } cases[] = {
      {"null", ""},
      {"not-a-standard-scheme:this is arbitrary content",
       "this is arbitrary content"},
      {"view-source:http://example.com/path", "http://example.com/path"},
      {"blob:http://example.com/GUID", "http://example.com/GUID"},
      {"blob:http://user:password@example.com/GUID",
       "http://user:password@example.com/GUID"},

      {"http://www.example.com/GUID#ref", "/GUID"},
      {"http://me:secret@example.com/GUID/#ref", "/GUID/"},
      {"data:text/html,Question?<div style=\"color: #bad\">idea</div>",
       "text/html,Question"},

      // TODO(mkwst): This seems like a bug. https://crbug.com/513600
      {"filesystem:http://example.com/path", "/"},
  };

  for (const auto& test : cases) {
    GURL url(test.url);
    EXPECT_EQ(test.expected, url.path()) << test.url;
  }
}

TEST_P(GURLTypedTest, PathForNonStandardURLs) {
  struct TestCase {
    const std::string_view url;
    const std::string_view expected;
  };

  if (use_standard_compliant_non_special_scheme_url_parsing_) {
    TestCase cases[] = {
        {"blob://http://example.com/GUID", "//example.com/GUID"},
        {"git://host/path#fragment", "/path"},
    };
    for (const auto& test : cases) {
      GURL url(test.url);
      EXPECT_EQ(url.path(), test.expected) << test.url;
    }
  } else {
    TestCase cases[] = {
        {"blob://http://example.com/GUID", "//http://example.com/GUID"},
        {"git://host/path#fragment", "//host/path"},
    };
    for (const auto& test : cases) {
      GURL url(test.url);
      EXPECT_EQ(url.path(), test.expected) << test.url;
    }
  }
}

TEST(GURLTest, EqualsIgnoringRef) {
  const struct {
    const char* url_a;
    const char* url_b;
    bool are_equals;
  } kTestCases[] = {
      // No ref.
      {"http://a.com", "http://a.com", true},
      {"http://a.com", "http://b.com", false},

      // Same Ref.
      {"http://a.com#foo", "http://a.com#foo", true},
      {"http://a.com#foo", "http://b.com#foo", false},

      // Different Refs.
      {"http://a.com#foo", "http://a.com#bar", true},
      {"http://a.com#foo", "http://b.com#bar", false},

      // One has a ref, the other doesn't.
      {"http://a.com#foo", "http://a.com", true},
      {"http://a.com#foo", "http://b.com", false},

      // Empty refs.
      {"http://a.com#", "http://a.com#", true},
      {"http://a.com#", "http://a.com", true},

      // URLs that differ only by their last character.
      {"http://aaa", "http://aab", false},
      {"http://aaa#foo", "http://aab#foo", false},

      // Different size of the part before the ref.
      {"http://123#a", "http://123456#a", false},

      // Blob URLs
      {"blob:http://a.com#foo", "blob:http://a.com#foo", true},
      {"blob:http://a.com#foo", "blob:http://a.com#bar", true},
      {"blob:http://a.com#foo", "blob:http://b.com#bar", false},

      // Filesystem URLs
      {"filesystem:http://a.com#foo", "filesystem:http://a.com#foo", true},
      {"filesystem:http://a.com#foo", "filesystem:http://a.com#bar", true},
      {"filesystem:http://a.com#foo", "filesystem:http://b.com#bar", false},

      // Data URLs
      {"data:text/html,a#foo", "data:text/html,a#bar", true},
      {"data:text/html,a#foo", "data:text/html,a#foo", true},
      {"data:text/html,a#foo", "data:text/html,b#foo", false},
  };

  for (const auto& test_case : kTestCases) {
    SCOPED_TRACE(testing::Message()
                 << std::endl
                 << "url_a = " << test_case.url_a << std::endl
                 << "url_b = " << test_case.url_b << std::endl);
    // A versus B.
    EXPECT_EQ(test_case.are_equals,
              GURL(test_case.url_a).EqualsIgnoringRef(GURL(test_case.url_b)));
    // B versus A.
    EXPECT_EQ(test_case.are_equals,
              GURL(test_case.url_b).EqualsIgnoringRef(GURL(test_case.url_a)));
  }
}

TEST(GURLTest, DebugAlias) {
  GURL url("https://foo.com/bar");
  DEBUG_ALIAS_FOR_GURL(url_debug_alias, url);
  EXPECT_STREQ("https://foo.com/bar", url_debug_alias);
}

TEST(GURLTest, InvalidHost) {
  // This contains an invalid percent escape (%T%) and also a valid
  // percent escape that's not 7-bit ascii (%ae), so that the unescaped
  // host contains both an invalid percent escape and invalid UTF-8.
  GURL url("http://%T%Ae");

  EXPECT_FALSE(url.is_valid());
  EXPECT_TRUE(url.SchemeIs(url::kHttpScheme));

  // The invalid percent escape becomes an escaped percent sign (%25), and the
  // invalid UTF-8 character becomes REPLACEMENT CHARACTER' (U+FFFD) encoded as
  // UTF-8.
  EXPECT_EQ(url.host_piece(), "%25t%EF%BF%BD");
}

TEST(GURLTest, PortZero) {
  GURL port_zero_url("http://127.0.0.1:0/blah");

  // https://url.spec.whatwg.org/#port-state says that the port 1) consists of
  // ASCII digits (this excludes negative numbers) and 2) cannot be greater than
  // 2^16-1.  This means that port=0 should be valid.
  EXPECT_TRUE(port_zero_url.is_valid());
  EXPECT_EQ("0", port_zero_url.port());
  EXPECT_EQ("127.0.0.1", port_zero_url.host());
  EXPECT_EQ("http", port_zero_url.scheme());

  // https://crbug.com/1065532: SchemeHostPort would previously incorrectly
  // consider port=0 to be invalid.
  SchemeHostPort scheme_host_port(port_zero_url);
  EXPECT_TRUE(scheme_host_port.IsValid());
  EXPECT_EQ(port_zero_url.scheme(), scheme_host_port.scheme());
  EXPECT_EQ(port_zero_url.host(), scheme_host_port.host());
  EXPECT_EQ(port_zero_url.port(),
            base::NumberToString(scheme_host_port.port()));

  // https://crbug.com/1065532: The SchemeHostPort problem above would lead to
  // bizarre results below - resolved origin would incorrectly be returned as an
  // opaque origin derived from |another_origin|.
  url::Origin another_origin = url::Origin::Create(GURL("http://other.com"));
  url::Origin resolved_origin =
      url::Origin::Resolve(port_zero_url, another_origin);
  EXPECT_FALSE(resolved_origin.opaque());
  EXPECT_EQ(port_zero_url.scheme(), resolved_origin.scheme());
  EXPECT_EQ(port_zero_url.host(), resolved_origin.host());
  EXPECT_EQ(port_zero_url.port(), base::NumberToString(resolved_origin.port()));

  // port=0 and default HTTP port are different.
  GURL default_port("http://127.0.0.1/foo");
  EXPECT_EQ(0, SchemeHostPort(port_zero_url).port());
  EXPECT_EQ(80, SchemeHostPort(default_port).port());
  url::Origin default_port_origin = url::Origin::Create(default_port);
  EXPECT_FALSE(default_port_origin.IsSameOriginWith(resolved_origin));
}

class GURLTestTraits {
 public:
  using UrlType = GURL;

  static UrlType CreateUrlFromString(std::string_view s) { return GURL(s); }
  static bool IsAboutBlank(const UrlType& url) { return url.IsAboutBlank(); }
  static bool IsAboutSrcdoc(const UrlType& url) { return url.IsAboutSrcdoc(); }

  // Only static members.
  GURLTestTraits() = delete;
};

INSTANTIATE_TYPED_TEST_SUITE_P(GURL, AbstractUrlTest, GURLTestTraits);

}  // namespace url