9 files changed, 499 insertions, 111 deletions

diff --git a/test/uri/test_common.rb b/test/uri/test_common.rb
index 5e30cda41d..569264005a 100644
--- a/test/uri/test_common.rb
+++ b/test/uri/test_common.rb
@@ -3,16 +3,57 @@ require 'test/unit'
 require 'envutil'
 require 'uri'
 
-module URI
-
-
-class TestCommon < Test::Unit::TestCase
+class URI::TestCommon < Test::Unit::TestCase
   def setup
   end
 
   def teardown
   end
 
+  EnvUtil.suppress_warning do
+    class Foo
+      # Intentionally use `URI::REGEXP`, which is for the compatibility
+      include URI::REGEXP::PATTERN
+    end
+  end
+
+  def test_fallback_constants
+    EnvUtil.suppress_warning do
+      assert_raise(NameError) { URI::FOO }
+
+      assert_equal URI::ABS_URI, URI::RFC2396_PARSER.regexp[:ABS_URI]
+      assert_equal URI::PATTERN, URI::RFC2396_Parser::PATTERN
+      assert_equal URI::REGEXP, URI::RFC2396_REGEXP
+      assert_equal URI::REGEXP::PATTERN, URI::RFC2396_REGEXP::PATTERN
+      assert_equal Foo::IPV4ADDR, URI::RFC2396_REGEXP::PATTERN::IPV4ADDR
+    end
+  end
+
+  def test_parser_switch
+    assert_equal(URI::Parser, URI::RFC3986_Parser)
+    assert_equal(URI::PARSER, URI::RFC3986_PARSER)
+    refute defined?(URI::REGEXP)
+    refute defined?(URI::PATTERN)
+
+    URI.parser = URI::RFC2396_PARSER
+
+    assert_equal(URI::Parser, URI::RFC2396_Parser)
+    assert_equal(URI::PARSER, URI::RFC2396_PARSER)
+    assert defined?(URI::REGEXP)
+    assert defined?(URI::PATTERN)
+    assert defined?(URI::PATTERN::ESCAPED)
+    assert defined?(URI::REGEXP::PATTERN::IPV6ADDR)
+
+    URI.parser = URI::RFC3986_PARSER
+
+    assert_equal(URI::Parser, URI::RFC3986_Parser)
+    assert_equal(URI::PARSER, URI::RFC3986_PARSER)
+    refute defined?(URI::REGEXP)
+    refute defined?(URI::PATTERN)
+  ensure
+    URI.parser = URI::RFC3986_PARSER
+  end
+
   def test_extract
     EnvUtil.suppress_warning do
       assert_equal(['http://example.com'],
@@ -37,22 +78,57 @@ class TestCommon < Test::Unit::TestCase
     return unless defined?(Ractor)
     assert_ractor(<<~RUBY, require: 'uri')
       r = Ractor.new { URI.parse("https://ruby-lang.org/").inspect }
-      assert_equal(URI.parse("https://ruby-lang.org/").inspect, r.take)
+      assert_equal(URI.parse("https://ruby-lang.org/").inspect, r.value)
     RUBY
   end
 
+  DEFAULT_SCHEMES = ["FILE", "FTP", "HTTP", "HTTPS", "LDAP", "LDAPS", "MAILTO", "WS", "WSS"].sort.freeze
+
   def test_register_scheme
-    assert_equal(["FILE", "FTP", "HTTP", "HTTPS", "LDAP", "LDAPS", "MAILTO", "WS"].sort, URI.scheme_list.keys.sort)
+    assert_equal(DEFAULT_SCHEMES, URI.scheme_list.keys.sort)
 
     foobar = Class.new(URI::Generic)
     URI.register_scheme 'FOOBAR', foobar
     begin
-      assert_equal(["FILE", "FTP", "HTTP", "HTTPS", "LDAP", "LDAPS", "MAILTO", "WS", "FOOBAR"].sort, URI.scheme_list.keys.sort)
+      assert_include(URI.scheme_list.keys, "FOOBAR")
+      assert_equal foobar, URI.parse('foobar://localhost').class
     ensure
       URI.const_get(:Schemes).send(:remove_const, :FOOBAR)
     end
 
-    assert_equal(["FILE", "FTP", "HTTP", "HTTPS", "LDAP", "LDAPS", "MAILTO", "WS"].sort, URI.scheme_list.keys.sort)
+    assert_equal(DEFAULT_SCHEMES, URI.scheme_list.keys.sort)
+  end
+
+  def test_register_scheme_lowercase
+    assert_equal(DEFAULT_SCHEMES, URI.scheme_list.keys.sort)
+
+    foobar = Class.new(URI::Generic)
+    URI.register_scheme 'foobarlower', foobar
+    begin
+      assert_include(URI.scheme_list.keys, "FOOBARLOWER")
+      assert_equal foobar, URI.parse('foobarlower://localhost').class
+    ensure
+      URI.const_get(:Schemes).send(:remove_const, :FOOBARLOWER)
+    end
+
+    assert_equal(DEFAULT_SCHEMES, URI.scheme_list.keys.sort)
+  end
+
+  def test_register_scheme_with_symbols
+    # Valid schemes from https://www.iana.org/assignments/uri-schemes/uri-schemes.xhtml
+    list = []
+    %w[ms-search microsoft.windows.camera coaps+ws].each {|name|
+      list << [name, URI.register_scheme(name, Class.new(URI::Generic))]
+    }
+
+    list.each do |scheme, uri_class|
+      assert_equal uri_class, URI.parse("#{scheme}://localhost").class
+    end
+  ensure
+    schemes = URI.const_get(:Schemes)
+    list.each do |scheme, |
+      schemes.send(:remove_const, schemes.escape(scheme))
+    end
   end
 
   def test_regexp
@@ -78,6 +154,17 @@ class TestCommon < Test::Unit::TestCase
     assert_raise(NoMethodError) { Object.new.URI("http://www.ruby-lang.org/") }
   end
 
+  def test_parse_timeout
+    pre = ->(n) {
+      'https://example.com/dir/' + 'a' * (n * 100) + '/##.jpg'
+    }
+    assert_linear_performance((1..3).map {|i| 10**i}, rehearsal: 1000, pre: pre) do |uri|
+      assert_raise(URI::InvalidURIError) do
+        URI.parse(uri)
+      end
+    end
+  end
+
   def test_encode_www_form_component
     assert_equal("%00+%21%22%23%24%25%26%27%28%29*%2B%2C-.%2F09%3A%3B%3C%3D%3E%3F%40" \
                  "AZ%5B%5C%5D%5E_%60az%7B%7C%7D%7E",
@@ -130,6 +217,58 @@ class TestCommon < Test::Unit::TestCase
     assert_nothing_raised(ArgumentError){URI.decode_www_form_component("x"*(1024*1024))}
   end
 
+  def test_encode_uri_component
+    assert_equal("%00%20%21%22%23%24%25%26%27%28%29*%2B%2C-.%2F09%3A%3B%3C%3D%3E%3F%40" \
+                 "AZ%5B%5C%5D%5E_%60az%7B%7C%7D%7E",
+                 URI.encode_uri_component("\x00 !\"\#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~"))
+    assert_equal("%95A", URI.encode_uri_component(
+                   "\x95\x41".force_encoding(Encoding::Shift_JIS)))
+    assert_equal("0B", URI.encode_uri_component(
+                   "\x30\x42".force_encoding(Encoding::UTF_16BE)))
+    assert_equal("%1B%24B%24%22%1B%28B", URI.encode_uri_component(
+                   "\e$B$\"\e(B".force_encoding(Encoding::ISO_2022_JP)))
+
+    assert_equal("%E3%81%82", URI.encode_uri_component(
+                   "\u3042", Encoding::ASCII_8BIT))
+    assert_equal("%82%A0", URI.encode_uri_component(
+                   "\u3042", Encoding::Windows_31J))
+    assert_equal("%E3%81%82", URI.encode_uri_component(
+                   "\u3042", Encoding::UTF_8))
+
+    assert_equal("%82%A0", URI.encode_uri_component(
+                   "\u3042".encode("sjis"), Encoding::ASCII_8BIT))
+    assert_equal("%A4%A2", URI.encode_uri_component(
+                   "\u3042".encode("sjis"), Encoding::EUC_JP))
+    assert_equal("%E3%81%82", URI.encode_uri_component(
+                   "\u3042".encode("sjis"), Encoding::UTF_8))
+    assert_equal("B0", URI.encode_uri_component(
+                   "\u3042".encode("sjis"), Encoding::UTF_16LE))
+    assert_equal("%26%23730%3B", URI.encode_uri_component(
+                   "\u02DA", Encoding::WINDOWS_1252))
+
+    # invalid
+    assert_equal("%EF%BF%BD%EF%BF%BD", URI.encode_uri_component(
+                   "\xE3\x81\xFF", "utf-8"))
+    assert_equal("%E6%9F%8A%EF%BF%BD%EF%BF%BD", URI.encode_uri_component(
+                   "\x95\x41\xff\xff".force_encoding(Encoding::Shift_JIS), "utf-8"))
+  end
+
+  def test_decode_uri_component
+    assert_equal(" +!\"\#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~",
+                 URI.decode_uri_component(
+                   "%20+%21%22%23%24%25%26%27%28%29*%2B%2C-.%2F09%3A%3B%3C%3D%3E%3F%40" \
+                   "AZ%5B%5C%5D%5E_%60az%7B%7C%7D%7E"))
+    assert_equal("\xA1\xA2".force_encoding(Encoding::EUC_JP),
+                 URI.decode_uri_component("%A1%A2", "EUC-JP"))
+    assert_equal("\xE3\x81\x82\xE3\x81\x82".force_encoding("UTF-8"),
+                 URI.decode_uri_component("\xE3\x81\x82%E3%81%82".force_encoding("UTF-8")))
+
+    assert_raise(ArgumentError){URI.decode_uri_component("%")}
+    assert_raise(ArgumentError){URI.decode_uri_component("%a")}
+    assert_raise(ArgumentError){URI.decode_uri_component("x%a_")}
+    assert_nothing_raised(ArgumentError){URI.decode_uri_component("x"*(1024*1024))}
+  end
+
   def test_encode_www_form
     assert_equal("a=1", URI.encode_www_form("a" => "1"))
     assert_equal("a=1", URI.encode_www_form(a: 1))
@@ -195,6 +334,3 @@ class TestCommon < Test::Unit::TestCase
   private
   def s(str) str.force_encoding(Encoding::Windows_31J); end
 end
-
-
-end
diff --git a/test/uri/test_ftp.rb b/test/uri/test_ftp.rb
index 0eec984db8..3ad7864490 100644
--- a/test/uri/test_ftp.rb
+++ b/test/uri/test_ftp.rb
@@ -2,10 +2,7 @@
 require 'test/unit'
 require 'uri/ftp'
 
-module URI
-
-
-class TestFTP < Test::Unit::TestCase
+class URI::TestFTP < Test::Unit::TestCase
   def setup
   end
 
@@ -29,18 +26,18 @@ class TestFTP < Test::Unit::TestCase
   end
 
   def test_parse_invalid
-    assert_raise(InvalidURIError){URI.parse('ftp:example')}
+    assert_raise(URI::InvalidURIError) {URI.parse('ftp:example')}
   end
 
   def test_paths
     # If you think what's below is wrong, please read RubyForge bug 2055,
     # RFC 1738 section 3.2.2, and RFC 2396.
     u = URI.parse('ftp://ftp.example.com/foo/bar/file.ext')
-    assert(u.path == 'foo/bar/file.ext')
+    assert_equal('foo/bar/file.ext', u.path)
     u = URI.parse('ftp://ftp.example.com//foo/bar/file.ext')
-    assert(u.path == '/foo/bar/file.ext')
+    assert_equal('/foo/bar/file.ext', u.path)
     u = URI.parse('ftp://ftp.example.com/%2Ffoo/bar/file.ext')
-    assert(u.path == '/foo/bar/file.ext')
+    assert_equal('/foo/bar/file.ext', u.path)
   end
 
   def test_assemble
@@ -48,8 +45,8 @@ class TestFTP < Test::Unit::TestCase
     # assuming everyone else has implemented RFC 2396.
     uri = URI::FTP.build(['user:password', 'ftp.example.com', nil,
                          '/path/file.zip', 'i'])
-    assert(uri.to_s ==
-           'ftp://user:password@ftp.example.com/%2Fpath/file.zip;type=i')
+    assert_equal('ftp://user:password@ftp.example.com/%2Fpath/file.zip;type=i',
+                 uri.to_s)
   end
 
   def test_select
@@ -62,6 +59,3 @@ class TestFTP < Test::Unit::TestCase
     end
   end
 end
-
-
-end
diff --git a/test/uri/test_generic.rb b/test/uri/test_generic.rb
index fdb405e396..94eea71b51 100644
--- a/test/uri/test_generic.rb
+++ b/test/uri/test_generic.rb
@@ -24,7 +24,19 @@ class URI::TestGeneric < Test::Unit::TestCase
 
     assert_equal "file:///foo", URI("file:///foo").to_s
     assert_equal "postgres:///foo", URI("postgres:///foo").to_s
-    assert_equal "http:/foo", URI("http:///foo").to_s
+    assert_equal "http:///foo", URI("http:///foo").to_s
+    assert_equal "http:/foo", URI("http:/foo").to_s
+
+    uri = URI('rel_path')
+    assert_equal "rel_path", uri.to_s
+    uri.scheme = 'http'
+    assert_equal "http:rel_path", uri.to_s
+    uri.host = 'h'
+    assert_equal "http://h/rel_path", uri.to_s
+    uri.port = 8080
+    assert_equal "http://h:8080/rel_path", uri.to_s
+    uri.host = nil
+    assert_equal "http::8080/rel_path", uri.to_s
   end
 
   def test_parse
@@ -157,6 +169,23 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal(nil, url.user)
     assert_equal(nil, url.password)
     assert_equal(nil, url.userinfo)
+
+    # sec-156615
+    url = URI.parse('http:////example.com')
+    # must be empty string to identify as path-abempty, not path-absolute
+    assert_equal('', url.host)
+    assert_equal('http:////example.com', url.to_s)
+
+    # sec-2957667
+    url = URI.parse('http://user:pass@example.com').merge('//example.net')
+    assert_equal('http://example.net', url.to_s)
+    assert_nil(url.userinfo)
+    url = URI.join('http://user:pass@example.com', '//example.net')
+    assert_equal('http://example.net', url.to_s)
+    assert_nil(url.userinfo)
+    url = URI.parse('http://user:pass@example.com') + '//example.net'
+    assert_equal('http://example.net', url.to_s)
+    assert_nil(url.userinfo)
   end
 
   def test_parse_scheme_with_symbols
@@ -211,9 +240,9 @@ class URI::TestGeneric < Test::Unit::TestCase
     u = URI.parse('http://foo/bar/baz')
     assert_equal(nil, u.merge!(""))
     assert_equal(nil, u.merge!(u))
-    assert(nil != u.merge!("."))
+    refute_nil(u.merge!("."))
     assert_equal('http://foo/bar/', u.to_s)
-    assert(nil != u.merge!("../baz"))
+    refute_nil(u.merge!("../baz"))
     assert_equal('http://foo/baz', u.to_s)
 
     url = URI.parse('http://a/b//c') + 'd//e'
@@ -249,6 +278,16 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal(u0, u1)
   end
 
+  def test_merge_authority
+    u = URI.parse('http://user:pass@example.com:8080')
+    u0 = URI.parse('http://new.example.org/path')
+    u1 = u.merge('//new.example.org/path')
+    assert_equal(u0, u1)
+    u0 = URI.parse('http://other@example.net')
+    u1 = u.merge('//other@example.net')
+    assert_equal(u0, u1)
+  end
+
   def test_route
     url = URI.parse('http://hoge/a.html').route_to('http://hoge/b.html')
     assert_equal('b.html', url.to_s)
@@ -320,7 +359,7 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal('http://a/b/c/g', url.to_s)
     url = @base_url.route_to('http://a/b/c/g')
     assert_kind_of(URI::Generic, url)
-    assert('./g' != url.to_s) # ok
+    refute_equal('./g', url.to_s) # ok
     assert_equal('g', url.to_s)
 
 #  http://a/b/c/d;p?q
@@ -339,7 +378,7 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal('http://a/g', url.to_s)
     url = @base_url.route_to('http://a/g')
     assert_kind_of(URI::Generic, url)
-    assert('/g' != url.to_s) # ok
+    refute_equal('/g', url.to_s) # ok
     assert_equal('../../g', url.to_s)
 
 #  http://a/b/c/d;p?q
@@ -430,7 +469,7 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal('http://a/b/c/', url.to_s)
     url = @base_url.route_to('http://a/b/c/')
     assert_kind_of(URI::Generic, url)
-    assert('.' != url.to_s) # ok
+    refute_equal('.', url.to_s) # ok
     assert_equal('./', url.to_s)
 
 #  http://a/b/c/d;p?q
@@ -449,7 +488,7 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal('http://a/b/', url.to_s)
     url = @base_url.route_to('http://a/b/')
     assert_kind_of(URI::Generic, url)
-    assert('..' != url.to_s) # ok
+    refute_equal('..', url.to_s) # ok
     assert_equal('../', url.to_s)
 
 #  http://a/b/c/d;p?q
@@ -477,7 +516,7 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal('http://a/', url.to_s)
     url = @base_url.route_to('http://a/')
     assert_kind_of(URI::Generic, url)
-    assert('../..' != url.to_s) # ok
+    refute_equal('../..', url.to_s) # ok
     assert_equal('../../', url.to_s)
 
 #  http://a/b/c/d;p?q
@@ -568,7 +607,7 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal('http://a/g', url.to_s)
     url = @base_url.route_to('http://a/g')
     assert_kind_of(URI::Generic, url)
-    assert('../../../g' != url.to_s)  # ok? yes, it confuses you
+    refute_equal('../../../g', url.to_s)  # ok? yes, it confuses you
     assert_equal('../../g', url.to_s) # and it is clearly
 
 #  http://a/b/c/d;p?q
@@ -578,7 +617,7 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal('http://a/g', url.to_s)
     url = @base_url.route_to('http://a/g')
     assert_kind_of(URI::Generic, url)
-    assert('../../../../g' != url.to_s) # ok? yes, it confuses you
+    refute_equal('../../../../g', url.to_s) # ok? yes, it confuses you
     assert_equal('../../g', url.to_s)   # and it is clearly
 
 #  http://a/b/c/d;p?q
@@ -588,7 +627,7 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal('http://a/b/g', url.to_s)
     url = @base_url.route_to('http://a/b/g')
     assert_kind_of(URI::Generic, url)
-    assert('./../g' != url.to_s) # ok
+    refute_equal('./../g', url.to_s) # ok
     assert_equal('../g', url.to_s)
 
 #  http://a/b/c/d;p?q
@@ -598,7 +637,7 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal('http://a/b/c/g/', url.to_s)
     url = @base_url.route_to('http://a/b/c/g/')
     assert_kind_of(URI::Generic, url)
-    assert('./g/.' != url.to_s) # ok
+    refute_equal('./g/.', url.to_s) # ok
     assert_equal('g/', url.to_s)
 
 #  http://a/b/c/d;p?q
@@ -608,7 +647,7 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal('http://a/b/c/g/h', url.to_s)
     url = @base_url.route_to('http://a/b/c/g/h')
     assert_kind_of(URI::Generic, url)
-    assert('g/./h' != url.to_s) # ok
+    refute_equal('g/./h', url.to_s) # ok
     assert_equal('g/h', url.to_s)
 
 #  http://a/b/c/d;p?q
@@ -618,7 +657,7 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal('http://a/b/c/h', url.to_s)
     url = @base_url.route_to('http://a/b/c/h')
     assert_kind_of(URI::Generic, url)
-    assert('g/../h' != url.to_s) # ok
+    refute_equal('g/../h', url.to_s) # ok
     assert_equal('h', url.to_s)
 
 #  http://a/b/c/d;p?q
@@ -628,7 +667,7 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal('http://a/b/c/g;x=1/y', url.to_s)
     url = @base_url.route_to('http://a/b/c/g;x=1/y')
     assert_kind_of(URI::Generic, url)
-    assert('g;x=1/./y' != url.to_s) # ok
+    refute_equal('g;x=1/./y', url.to_s) # ok
     assert_equal('g;x=1/y', url.to_s)
 
 #  http://a/b/c/d;p?q
@@ -638,7 +677,7 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal('http://a/b/c/y', url.to_s)
     url = @base_url.route_to('http://a/b/c/y')
     assert_kind_of(URI::Generic, url)
-    assert('g;x=1/../y' != url.to_s) # ok
+    refute_equal('g;x=1/../y', url.to_s) # ok
     assert_equal('y', url.to_s)
 
 #  http://a/b/c/d;p?q
@@ -712,17 +751,18 @@ class URI::TestGeneric < Test::Unit::TestCase
   def test_set_component
     uri = URI.parse('http://foo:bar@baz')
     assert_equal('oof', uri.user = 'oof')
-    assert_equal('http://oof:bar@baz', uri.to_s)
+    assert_equal('http://oof@baz', uri.to_s)
     assert_equal('rab', uri.password = 'rab')
     assert_equal('http://oof:rab@baz', uri.to_s)
     assert_equal('foo', uri.userinfo = 'foo')
-    assert_equal('http://foo:rab@baz', uri.to_s)
+    assert_equal('http://foo@baz', uri.to_s)
     assert_equal(['foo', 'bar'], uri.userinfo = ['foo', 'bar'])
     assert_equal('http://foo:bar@baz', uri.to_s)
     assert_equal(['foo'], uri.userinfo = ['foo'])
-    assert_equal('http://foo:bar@baz', uri.to_s)
+    assert_equal('http://foo@baz', uri.to_s)
     assert_equal('zab', uri.host = 'zab')
-    assert_equal('http://foo:bar@zab', uri.to_s)
+    assert_equal('http://zab', uri.to_s)
+    uri.userinfo = ['foo', 'bar']
     uri.port = ""
     assert_nil(uri.port)
     uri.port = "80"
@@ -732,7 +772,8 @@ class URI::TestGeneric < Test::Unit::TestCase
     uri.port = " 080 "
     assert_equal(80, uri.port)
     assert_equal(8080, uri.port = 8080)
-    assert_equal('http://foo:bar@zab:8080', uri.to_s)
+    assert_equal('http://zab:8080', uri.to_s)
+    uri = URI.parse('http://foo:bar@zab:8080')
     assert_equal('/', uri.path = '/')
     assert_equal('http://foo:bar@zab:8080/', uri.to_s)
     assert_equal('a=1', uri.query = 'a=1')
@@ -786,18 +827,18 @@ class URI::TestGeneric < Test::Unit::TestCase
     hierarchical = URI.parse('http://a.b.c/example')
     opaque = URI.parse('mailto:mduerst@ifi.unizh.ch')
 
-    assert hierarchical.hierarchical?
-    refute opaque.hierarchical?
+    assert_predicate hierarchical, :hierarchical?
+    refute_predicate opaque, :hierarchical?
   end
 
   def test_absolute
     abs_uri = URI.parse('http://a.b.c/')
     not_abs = URI.parse('a.b.c')
 
-    refute not_abs.absolute?
+    refute_predicate not_abs, :absolute?
 
-    assert abs_uri.absolute
-    assert abs_uri.absolute?
+    assert_predicate abs_uri, :absolute
+    assert_predicate abs_uri, :absolute?
   end
 
   def test_ipv6
@@ -810,8 +851,10 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal("http://[::1]/bar", u.to_s)
     u.hostname = "::1"
     assert_equal("http://[::1]/bar", u.to_s)
-    u.hostname = ""
-    assert_equal("http:///bar", u.to_s)
+
+    u = URI("file://foo/bar")
+    u.hostname = ''
+    assert_equal("file:///bar", u.to_s)
   end
 
   def test_build
@@ -832,6 +875,19 @@ class URI::TestGeneric < Test::Unit::TestCase
     assert_equal("http://[::1]/bar/baz", u.to_s)
     assert_equal("[::1]", u.host)
     assert_equal("::1", u.hostname)
+
+    assert_raise_with_message(ArgumentError, /URI::Generic/) {
+      URI::Generic.build(nil)
+    }
+
+    c = Class.new(URI::Generic) do
+      def self.component; raise; end
+    end
+    expected = /\(#{URI::Generic::COMPONENT.join(', ')}\)/
+    message = "fallback to URI::Generic::COMPONENT if component raised"
+    assert_raise_with_message(ArgumentError, expected, message) {
+      c.build(nil)
+    }
   end
 
   def test_build2
@@ -970,6 +1026,10 @@ class URI::TestGeneric < Test::Unit::TestCase
     end
   end
 
+  def test_split
+    assert_equal [nil, nil, nil, nil, nil, "", nil, nil, nil], URI.split("//")
+  end
+
   class CaseInsensitiveEnv
     def initialize(h={})
       @h = {}
diff --git a/test/uri/test_http.rb b/test/uri/test_http.rb
index cc19046c8f..8816d20175 100644
--- a/test/uri/test_http.rb
+++ b/test/uri/test_http.rb
@@ -1,11 +1,9 @@
 # frozen_string_literal: false
 require 'test/unit'
 require 'uri/http'
+require 'uri/https'
 
-module URI
-
-
-class TestHTTP < Test::Unit::TestCase
+class URI::TestHTTP < Test::Unit::TestCase
   def setup
   end
 
@@ -21,39 +19,45 @@ class TestHTTP < Test::Unit::TestCase
     assert_kind_of(URI::HTTP, u)
   end
 
+  def test_build_empty_host
+    assert_raise(URI::InvalidComponentError) { URI::HTTP.build(host: '') }
+  end
+
   def test_parse
     u = URI.parse('http://a')
     assert_kind_of(URI::HTTP, u)
-    assert_equal(['http',
-		   nil, 'a', URI::HTTP.default_port,
-		   '', nil, nil], uri_to_ary(u))
+    assert_equal([
+      'http',
+      nil, 'a', URI::HTTP.default_port,
+      '', nil, nil
+    ], uri_to_ary(u))
   end
 
   def test_normalize
     host = 'aBcD'
-    u1 = URI.parse('http://' + host          + '/eFg?HiJ')
+    u1 = URI.parse('http://' + host + '/eFg?HiJ')
     u2 = URI.parse('http://' + host.downcase + '/eFg?HiJ')
-    assert(u1.normalize.host == 'abcd')
-    assert(u1.normalize.path == u1.path)
-    assert(u1.normalize == u2.normalize)
-    assert(!u1.normalize.host.equal?(u1.host))
-    assert( u2.normalize.host.equal?(u2.host))
+    assert_equal('abcd', u1.normalize.host)
+    assert_equal(u1.path, u1.normalize.path)
+    assert_equal(u2.normalize, u1.normalize)
+    refute_same(u1.host, u1.normalize.host)
+    assert_same(u2.host, u2.normalize.host)
 
     assert_equal('http://abc/', URI.parse('http://abc').normalize.to_s)
   end
 
   def test_equal
-    assert(URI.parse('http://abc') == URI.parse('http://ABC'))
-    assert(URI.parse('http://abc/def') == URI.parse('http://ABC/def'))
-    assert(URI.parse('http://abc/def') != URI.parse('http://ABC/DEF'))
+    assert_equal(URI.parse('http://ABC'), URI.parse('http://abc'))
+    assert_equal(URI.parse('http://ABC/def'), URI.parse('http://abc/def'))
+    refute_equal(URI.parse('http://ABC/DEF'), URI.parse('http://abc/def'))
   end
 
   def test_request_uri
-    assert_equal('/',         URI.parse('http://a.b.c/').request_uri)
+    assert_equal('/', URI.parse('http://a.b.c/').request_uri)
     assert_equal('/?abc=def', URI.parse('http://a.b.c/?abc=def').request_uri)
-    assert_equal('/',         URI.parse('http://a.b.c').request_uri)
+    assert_equal('/', URI.parse('http://a.b.c').request_uri)
     assert_equal('/?abc=def', URI.parse('http://a.b.c?abc=def').request_uri)
-    assert_equal(nil,         URI.parse('http:foo').request_uri)
+    assert_equal(nil, URI.parse('http:foo').request_uri)
   end
 
   def test_select
@@ -64,7 +68,18 @@ class TestHTTP < Test::Unit::TestCase
       u.select(:scheme, :host, :not_exist, :port)
     end
   end
-end
+
+  def test_authority
+    assert_equal('a.b.c', URI.parse('http://a.b.c/').authority)
+    assert_equal('a.b.c:8081', URI.parse('http://a.b.c:8081/').authority)
+    assert_equal('a.b.c', URI.parse('http://a.b.c:80/').authority)
+  end
 
 
+  def test_origin
+    assert_equal('http://a.b.c', URI.parse('http://a.b.c/').origin)
+    assert_equal('http://a.b.c:8081', URI.parse('http://a.b.c:8081/').origin)
+    assert_equal('http://a.b.c', URI.parse('http://a.b.c:80/').origin)
+    assert_equal('https://a.b.c', URI.parse('https://a.b.c/').origin)
+  end
 end
diff --git a/test/uri/test_ldap.rb b/test/uri/test_ldap.rb
index 64845e487a..9c4506a357 100644
--- a/test/uri/test_ldap.rb
+++ b/test/uri/test_ldap.rb
@@ -2,10 +2,7 @@
 require 'test/unit'
 require 'uri/ldap'
 
-module URI
-
-
-class TestLDAP < Test::Unit::TestCase
+class URI::TestLDAP < Test::Unit::TestCase
   def setup
   end
 
@@ -39,7 +36,7 @@ class TestLDAP < Test::Unit::TestCase
     # from RFC2255, section 6.
     {
       'ldap:///o=University%20of%20Michigan,c=US' =>
-      ['ldap', nil, URI::LDAP::DEFAULT_PORT,
+      ['ldap', '', URI::LDAP::DEFAULT_PORT,
 	'o=University%20of%20Michigan,c=US',
 	nil, nil, nil, nil],
 
@@ -74,12 +71,12 @@ class TestLDAP < Test::Unit::TestCase
 	nil, '(int=%5c00%5c00%5c00%5c04)', nil, nil],
 
       'ldap:///??sub??bindname=cn=Manager%2co=Foo' =>
-      ['ldap', nil, URI::LDAP::DEFAULT_PORT,
+      ['ldap', '', URI::LDAP::DEFAULT_PORT,
 	'',
 	nil, 'sub', nil, 'bindname=cn=Manager%2co=Foo'],
 
       'ldap:///??sub??!bindname=cn=Manager%2co=Foo' =>
-      ['ldap', nil, URI::LDAP::DEFAULT_PORT,
+      ['ldap', '', URI::LDAP::DEFAULT_PORT,
 	'',
 	nil, 'sub', nil, '!bindname=cn=Manager%2co=Foo'],
     }.each do |url2, ary|
@@ -100,6 +97,3 @@ class TestLDAP < Test::Unit::TestCase
     assert_raise(URI::InvalidURIError) {URI.parse("ldap:https://example.com")}
   end
 end
-
-
-end
diff --git a/test/uri/test_mailto.rb b/test/uri/test_mailto.rb
index e7d3142198..6cd3352978 100644
--- a/test/uri/test_mailto.rb
+++ b/test/uri/test_mailto.rb
@@ -141,6 +141,21 @@ class URI::TestMailTo < Test::Unit::TestCase
   def test_check_to
     u = URI::MailTo.build(['joe@example.com', 'subject=Ruby'])
 
+    # Valid emails
+    u.to = 'a@valid.com'
+    assert_equal(u.to, 'a@valid.com')
+
+    # Intentionally allowed violations of RFC 5322
+    u.to = 'a..a@valid.com'
+    assert_equal(u.to, 'a..a@valid.com')
+
+    u.to = 'hello.@valid.com'
+    assert_equal(u.to, 'hello.@valid.com')
+
+    u.to = '.hello@valid.com'
+    assert_equal(u.to, '.hello@valid.com')
+
+    # Invalid emails
     assert_raise(URI::InvalidComponentError) do
       u.to = '#1@mail.com'
     end
@@ -148,6 +163,63 @@ class URI::TestMailTo < Test::Unit::TestCase
     assert_raise(URI::InvalidComponentError) do
       u.to = '@invalid.email'
     end
+
+    # Invalid host emails
+    assert_raise(URI::InvalidComponentError) do
+      u.to = 'a@.invalid.email'
+    end
+
+    assert_raise(URI::InvalidComponentError) do
+      u.to = 'a@invalid.email.'
+    end
+
+    assert_raise(URI::InvalidComponentError) do
+      u.to = 'a@invalid..email'
+    end
+
+    assert_raise(URI::InvalidComponentError) do
+      u.to = 'a@-invalid.email'
+    end
+
+    assert_raise(URI::InvalidComponentError) do
+      u.to = 'a@invalid-.email'
+    end
+
+    assert_raise(URI::InvalidComponentError) do
+      u.to = 'a@invalid.-email'
+    end
+
+    assert_raise(URI::InvalidComponentError) do
+      u.to = 'a@invalid.email-'
+    end
+
+    u.to = 'a@'+'invalid'.ljust(63, 'd')+'.email'
+    assert_raise(URI::InvalidComponentError) do
+      u.to = 'a@'+'invalid'.ljust(64, 'd')+'.email'
+    end
+
+    u.to = 'a@invalid.'+'email'.rjust(63, 'e')
+    assert_raise(URI::InvalidComponentError) do
+      u.to = 'a@invalid.'+'email'.rjust(64, 'e')
+    end
+  end
+
+  def test_email_regexp
+    re = URI::MailTo::EMAIL_REGEXP
+
+    repeat = 10
+    longlabel = '.' + 'invalid'.ljust(63, 'd')
+    endlabel = ''
+    seq = (1..3).map {|i| 10**i}
+    rehearsal = 10
+    pre = ->(n) {'a@invalid' + longlabel*(n) + endlabel}
+    assert_linear_performance(seq, rehearsal: rehearsal, pre: pre) do |to|
+      repeat.times {re =~ to or flunk}
+    end
+    endlabel = '.' + 'email'.rjust(64, 'd')
+    assert_linear_performance(seq, rehearsal: rehearsal, pre: pre) do |to|
+      repeat.times {re =~ to and flunk}
+    end
   end
 
   def test_to_s
diff --git a/test/uri/test_parser.rb b/test/uri/test_parser.rb
index 03de137788..c14824f5e8 100644
--- a/test/uri/test_parser.rb
+++ b/test/uri/test_parser.rb
@@ -8,8 +8,8 @@ class URI::TestParser < Test::Unit::TestCase
   end
 
   def test_inspect
-    assert_match(/URI::RFC2396_Parser/, URI::Parser.new.inspect)
-    assert_match(/URI::RFC3986_Parser/, URI::RFC3986_Parser.new.inspect)
+    assert_match(/URI::RFC2396_Parser/, URI::RFC2396_Parser.new.inspect)
+    assert_match(/URI::RFC3986_Parser/, URI::Parser.new.inspect)
   end
 
   def test_compare
@@ -20,20 +20,22 @@ class URI::TestParser < Test::Unit::TestCase
     u2 = p.parse(url)
     u3 = p.parse(url)
 
-    assert(u0 == u1)
-    assert(u0.eql?(u1))
-    assert(!u0.equal?(u1))
+    assert_equal(u1, u0)
+    assert_send([u0, :eql?, u1])
+    refute_same(u1, u0)
 
-    assert(u1 == u2)
-    assert(!u1.eql?(u2))
-    assert(!u1.equal?(u2))
+    assert_equal(u2, u1)
+    assert_not_send([u1, :eql?, u2])
+    refute_same(u1, u2)
 
-    assert(u2 == u3)
-    assert(u2.eql?(u3))
-    assert(!u2.equal?(u3))
+    assert_equal(u3, u2)
+    assert_send([u2, :eql?, u3])
+    refute_same(u3, u2)
   end
 
-  def test_parse
+  def test_parse_rfc2396_parser
+    URI.parser = URI::RFC2396_PARSER
+
     escaped = URI::REGEXP::PATTERN::ESCAPED
     hex = URI::REGEXP::PATTERN::HEX
     p1 = URI::Parser.new(:ESCAPED => "(?:#{escaped}|%u[#{hex}]{4})")
@@ -43,6 +45,8 @@ class URI::TestParser < Test::Unit::TestCase
     u1.path = '/%uDCBA'
     assert_equal(['http', nil, 'a', URI::HTTP.default_port, '/%uDCBA', nil, nil],
 		 uri_to_ary(u1))
+  ensure
+    URI.parser = URI::DEFAULT_PARSER
   end
 
   def test_parse_query_pct_encoded
@@ -50,17 +54,71 @@ class URI::TestParser < Test::Unit::TestCase
     assert_raise(URI::InvalidURIError) { URI.parse('https://www.example.com/search?q=%XX') }
   end
 
+  def test_parse_auth
+    str = "http://al%40ice:p%40s%25sword@example.com/dir%2Fname/subdir?foo=bar%40example.com"
+    uri = URI.parse(str)
+    assert_equal "al%40ice", uri.user
+    assert_equal "p%40s%25sword", uri.password
+    assert_equal "al@ice", uri.decoded_user
+    assert_equal "p@s%sword", uri.decoded_password
+  end
+
   def test_raise_bad_uri_for_integer
     assert_raise(URI::InvalidURIError) do
       URI.parse(1)
     end
   end
 
-  def test_unescape
-    p1 = URI::Parser.new
+  def test_rfc2822_unescape
+    p1 = URI::RFC2396_Parser.new
     assert_equal("\xe3\x83\x90", p1.unescape("\xe3\x83\x90"))
     assert_equal("\xe3\x83\x90", p1.unescape('%e3%83%90'))
     assert_equal("\u3042", p1.unescape('%e3%81%82'.force_encoding(Encoding::US_ASCII)))
     assert_equal("\xe3\x83\x90\xe3\x83\x90", p1.unescape("\xe3\x83\x90%e3%83%90"))
   end
+
+  def test_split
+    assert_equal(["http", nil, "example.com", nil, nil, "", nil, nil, nil], URI.split("http://example.com"))
+    assert_equal(["http", nil, "[0::0]", nil, nil, "", nil, nil, nil], URI.split("http://[0::0]"))
+    assert_equal([nil, nil, "example.com", nil, nil, "", nil, nil, nil], URI.split("//example.com"))
+    assert_equal([nil, nil, "[0::0]", nil, nil, "", nil, nil, nil], URI.split("//[0::0]"))
+
+    assert_equal(["a", nil, nil, nil, nil, "", nil, nil, nil], URI.split("a:"))
+    assert_raise(URI::InvalidURIError) do
+      URI.parse("::")
+    end
+    assert_raise(URI::InvalidURIError) do
+      URI.parse("foo@example:foo")
+    end
+  end
+
+  def test_rfc2822_parse_relative_uri
+    pre = ->(length) {
+      " " * length + "\0"
+    }
+    parser = URI::RFC2396_Parser.new
+    assert_linear_performance((1..5).map {|i| 10**i}, pre: pre) do |uri|
+      assert_raise(URI::InvalidURIError) do
+        parser.split(uri)
+      end
+    end
+  end
+
+  def test_rfc3986_port_check
+    pre = ->(length) {"\t" * length + "a"}
+    uri = URI.parse("http://my.example.com")
+    assert_linear_performance((1..5).map {|i| 10**i}, pre: pre) do |port|
+      assert_raise(URI::InvalidComponentError) do
+        uri.port = port
+      end
+    end
+  end
+
+  def test_rfc2822_make_regexp
+    parser = URI::RFC2396_Parser.new
+    regexp = parser.make_regexp("HTTP")
+    assert_match(regexp, "HTTP://EXAMPLE.COM/")
+    assert_match(regexp, "http://example.com/")
+    refute_match(regexp, "https://example.com/")
+  end
 end
diff --git a/test/uri/test_ws.rb b/test/uri/test_ws.rb
index 17acb0d9f2..d63ebd4a46 100644
--- a/test/uri/test_ws.rb
+++ b/test/uri/test_ws.rb
@@ -3,10 +3,7 @@ require 'test/unit'
 require 'uri/http'
 require 'uri/ws'
 
-module URI
-
-
-class TestWS < Test::Unit::TestCase
+class URI::TestWS < Test::Unit::TestCase
   def setup
   end
 
@@ -34,19 +31,19 @@ class TestWS < Test::Unit::TestCase
     host = 'aBcD'
     u1 = URI.parse('ws://' + host          + '/eFg?HiJ')
     u2 = URI.parse('ws://' + host.downcase + '/eFg?HiJ')
-    assert(u1.normalize.host == 'abcd')
-    assert(u1.normalize.path == u1.path)
-    assert(u1.normalize == u2.normalize)
-    assert(!u1.normalize.host.equal?(u1.host))
-    assert( u2.normalize.host.equal?(u2.host))
+    assert_equal('abcd', u1.normalize.host)
+    assert_equal(u1.path, u1.normalize.path)
+    assert_equal(u2.normalize, u1.normalize)
+    refute_same(u1.host, u1.normalize.host)
+    assert_same(u2.host, u2.normalize.host)
 
     assert_equal('ws://abc/', URI.parse('ws://abc').normalize.to_s)
   end
 
   def test_equal
-    assert(URI.parse('ws://abc') == URI.parse('ws://ABC'))
-    assert(URI.parse('ws://abc/def') == URI.parse('ws://ABC/def'))
-    assert(URI.parse('ws://abc/def') != URI.parse('ws://ABC/DEF'))
+    assert_equal(URI.parse('ws://ABC'), URI.parse('ws://abc'))
+    assert_equal(URI.parse('ws://ABC/def'), URI.parse('ws://abc/def'))
+    refute_equal(URI.parse('ws://ABC/DEF'), URI.parse('ws://abc/def'))
   end
 
   def test_request_uri
@@ -66,6 +63,3 @@ class TestWS < Test::Unit::TestCase
     end
   end
 end
-
-
-end
diff --git a/test/uri/test_wss.rb b/test/uri/test_wss.rb
new file mode 100644
index 0000000000..cbef327cc6
--- /dev/null
+++ b/test/uri/test_wss.rb
@@ -0,0 +1,65 @@
+# frozen_string_literal: false
+require 'test/unit'
+require 'uri/https'
+require 'uri/wss'
+
+class URI::TestWSS < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  def uri_to_ary(uri)
+    uri.class.component.collect {|c| uri.send(c)}
+  end
+
+  def test_build
+    u = URI::WSS.build(host: 'www.example.com', path: '/foo/bar')
+    assert_kind_of(URI::WSS, u)
+  end
+
+  def test_parse
+    u = URI.parse('wss://a')
+    assert_kind_of(URI::WSS, u)
+    assert_equal(['wss',
+		   nil, 'a', URI::HTTPS.default_port,
+		   '', nil], uri_to_ary(u))
+  end
+
+  def test_normalize
+    host = 'aBcD'
+    u1 = URI.parse('wss://' + host          + '/eFg?HiJ')
+    u2 = URI.parse('wss://' + host.downcase + '/eFg?HiJ')
+    assert_equal('abcd', u1.normalize.host)
+    assert_equal(u1.path, u1.normalize.path)
+    assert_equal(u2.normalize, u1.normalize)
+    refute_same(u1.host, u1.normalize.host)
+    assert_same(u2.host, u2.normalize.host)
+
+    assert_equal('wss://abc/', URI.parse('wss://abc').normalize.to_s)
+  end
+
+  def test_equal
+    assert_equal(URI.parse('wss://ABC'), URI.parse('wss://abc'))
+    assert_equal(URI.parse('wss://ABC/def'), URI.parse('wss://abc/def'))
+    refute_equal(URI.parse('wss://ABC/DEF'), URI.parse('wss://abc/def'))
+  end
+
+  def test_request_uri
+    assert_equal('/',         URI.parse('wss://a.b.c/').request_uri)
+    assert_equal('/?abc=def', URI.parse('wss://a.b.c/?abc=def').request_uri)
+    assert_equal('/',         URI.parse('wss://a.b.c').request_uri)
+    assert_equal('/?abc=def', URI.parse('wss://a.b.c?abc=def').request_uri)
+    assert_equal(nil,         URI.parse('wss:foo').request_uri)
+  end
+
+  def test_select
+    assert_equal(['wss', 'a.b.c', 443], URI.parse('wss://a.b.c/').select(:scheme, :host, :port))
+    u = URI.parse('wss://a.b.c/')
+    assert_equal(uri_to_ary(u), u.select(*u.component))
+    assert_raise(ArgumentError) do
+      u.select(:scheme, :host, :not_exist, :port)
+    end
+  end
+end