husc 0.1.0

data/vendor/bundle/gems/http-cookie-1.0.3/lib/http/cookie_jar/yaml_saver.rb

@@ -0,0 +1,76 @@
+# :markup: markdown
+require 'http/cookie_jar'
+require 'psych' if !defined?(YAML) && RUBY_VERSION == "1.9.2"
+require 'yaml'
+
+# YAMLSaver saves and loads cookies in the YAML format.  It can load a
+# YAML file saved by Mechanize, but the saving format is not
+# compatible with older versions of Mechanize (< 2.7).
+class HTTP::CookieJar::YAMLSaver < HTTP::CookieJar::AbstractSaver
+  # :singleton-method: new
+  # :call-seq:
+  #   new(**options)
+  #
+  # There is no option keyword supported at the moment.
+
+  ##
+
+  def save(io, jar)
+    YAML.dump(@session ? jar.to_a : jar.reject(&:session?), io)
+  end
+
+  def load(io, jar)
+    begin
+      data = YAML.load(io)
+    rescue ArgumentError => e
+      case e.message
+      when %r{\Aundefined class/module Mechanize::}
+        # backward compatibility with Mechanize::Cookie
+        begin
+          io.rewind # hopefully
+          yaml = io.read
+          # a gross hack
+          yaml.gsub!(%r{^(    [^ ].*:) !ruby/object:Mechanize::Cookie$}, "\\1")
+          data = YAML.load(yaml)
+        rescue Errno::ESPIPE
+          @logger.warn "could not rewind the stream for conversion" if @logger
+        rescue ArgumentError
+        end
+      end
+    end
+
+    case data
+    when Array
+      data.each { |cookie|
+        jar.add(cookie)
+      }
+    when Hash
+      # backward compatibility with Mechanize::Cookie
+      data.each { |domain, paths|
+        paths.each { |path, names|
+          names.each { |cookie_name, cookie_hash|
+            if cookie_hash.respond_to?(:ivars)
+              # YAML::Object of Syck
+              cookie_hash = cookie_hash.ivars
+            end
+            cookie = HTTP::Cookie.new({}.tap { |hash|
+                cookie_hash.each_pair { |key, value|
+                  hash[key.to_sym] = value
+                }
+              })
+            jar.add(cookie)
+          }
+        }
+      }
+    else
+      @logger.warn "incompatible YAML cookie data discarded" if @logger
+      return
+    end
+  end
+
+  private
+
+  def default_options
+    {}
+  end
+end

data/vendor/bundle/gems/http-cookie-1.0.3/test/helper.rb

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'test-unit'
+require 'uri'
+require 'http/cookie'
+
+module Test
+  module Unit
+    module Assertions
+      def assert_warn(pattern, message = nil, &block)
+        class << (output = "")
+          alias write <<
+        end
+        stderr, $stderr = $stderr, output
+        yield
+        assert_match(pattern, output, message)
+      ensure
+        $stderr = stderr
+      end
+
+      def assert_warning(pattern, message = nil, &block)
+        verbose, $VERBOSE = $VERBOSE, true
+        assert_warn(pattern, message, &block)
+      ensure
+        $VERBOSE = verbose
+      end
+    end
+  end
+end
+
+module Enumerable
+  def combine
+    masks = inject([[], 1]){|(ar, m), e| [ar << m, m << 1 ] }[0]
+    all = masks.inject(0){ |al, m| al|m }
+
+    result = []
+    for i in 1..all do
+      tmp = []
+      each_with_index do |e, idx|
+        tmp << e unless (masks[idx] & i) == 0
+      end
+      result << tmp
+    end
+    result
+  end
+end
+
+def test_file(filename)
+  File.expand_path(filename, File.dirname(__FILE__))
+end
+
+def sleep_until(time)
+  if (s = time - Time.now) > 0
+    sleep s
+  end
+end

data/vendor/bundle/gems/http-cookie-1.0.3/test/mechanize.yml

@@ -0,0 +1,101 @@
+---
+google.com:
+  /:
+    PREF: !ruby/object:Mechanize::Cookie
+      version: 0
+      port: 
+      discard: 
+      comment_url: 
+      expires: Tue, 24 Mar 2065 08:20:15 GMT
+      max_age: 
+      comment: 
+      secure: false
+      path: /
+      domain: google.com
+      accessed_at: 2013-03-24 17:20:15.822619000 +09:00
+      created_at: 2013-03-24 17:20:15.822619000 +09:00
+      name: PREF
+      value: ID=7571a59c059e09db:FF=0:TM=1364199615:LM=1364199615:S=BxUqnqPrchd2cVmC
+      for_domain: true
+      domain_name: !ruby/object:DomainName
+        ipaddr: 
+        hostname: google.com
+        uri_host: google.com
+        tld: com
+        canonical_tld_p: true
+        domain: google.com
+      session: false
+    NID: !ruby/object:Mechanize::Cookie
+      version: 0
+      port: 
+      discard: 
+      comment_url: 
+      expires: Sun, 23 Sep 2063 08:20:15 GMT
+      max_age: 
+      comment: 
+      secure: false
+      path: /
+      domain: google.com
+      accessed_at: 2013-03-24 17:20:15.828434000 +09:00
+      created_at: 2013-03-24 17:20:15.828434000 +09:00
+      name: NID
+      value: 67=Kn2osS6wOzILpl7sCM1QIDmGg2VESBiwCyt6zx4vOVSWKOYDlwGIpgIGrpD8FpkbS9eqizo3QWFa5YkOygnCF6vRIQpbvlTxWB2Hq1Oo-qXWy0317yCqQ-B25eJLfUcC
+      for_domain: true
+      domain_name: !ruby/object:DomainName
+        ipaddr: 
+        hostname: google.com
+        uri_host: google.com
+        tld: com
+        canonical_tld_p: true
+        domain: google.com
+      session: false
+google.co.jp:
+  /:
+    PREF: !ruby/object:Mechanize::Cookie
+      version: 0
+      port: 
+      discard: 
+      comment_url: 
+      expires: Tue, 24 Mar 2065 08:20:16 GMT
+      max_age: 
+      comment: 
+      secure: false
+      path: /
+      domain: google.co.jp
+      accessed_at: 2013-03-24 17:20:17.136581000 +09:00
+      created_at: 2013-03-24 17:20:17.136581000 +09:00
+      name: PREF
+      value: ID=cb25dd1567d8b5c8:FF=0:TM=1364199616:LM=1364199616:S=c3PbhRq79Wo5T_vV
+      for_domain: true
+      domain_name: !ruby/object:DomainName
+        ipaddr: 
+        hostname: google.co.jp
+        uri_host: google.co.jp
+        tld: jp
+        canonical_tld_p: true
+        domain: google.co.jp
+      session: false
+    NID: !ruby/object:Mechanize::Cookie
+      version: 0
+      port: 
+      discard: 
+      comment_url: 
+      expires: Sun, 23 Sep 2063 08:20:16 GMT
+      max_age: 
+      comment: 
+      secure: false
+      path: /
+      domain: google.co.jp
+      accessed_at: 2013-03-24 17:20:17.139782000 +09:00
+      created_at: 2013-03-24 17:20:17.139782000 +09:00
+      name: NID
+      value: 67=GS7P-68zgm_KRA0e0dpN_XbYpmw9uBDe56qUeoCGiSRTahsM7dtOBCKfCoIFRKlzSuOiwJQdIZNpwv3DSXQNHXDKltucgfv2qkHlGeoj8-5VlowPXLLesz2VIpLOLw-a
+      for_domain: true
+      domain_name: !ruby/object:DomainName
+        ipaddr: 
+        hostname: google.co.jp
+        uri_host: google.co.jp
+        tld: jp
+        canonical_tld_p: true
+        domain: google.co.jp
+      session: false

data/vendor/bundle/gems/http-cookie-1.0.3/test/simplecov_start.rb

@@ -0,0 +1,2 @@
+require 'simplecov'
+SimpleCov.start

data/vendor/bundle/gems/http-cookie-1.0.3/test/test_http_cookie.rb

@@ -0,0 +1,1122 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('helper', File.dirname(__FILE__))
+
+class TestHTTPCookie < Test::Unit::TestCase
+  def setup
+    httpdate = 'Sun, 27-Sep-2037 00:00:00 GMT'
+
+    @cookie_params = {
+      'expires'  => 'expires=%s' % httpdate,
+      'path'     => 'path=/',
+      'domain'   => 'domain=.rubyforge.org',
+      'httponly' => 'HttpOnly',
+    }
+
+    @expires = Time.parse(httpdate)
+  end
+
+  def test_parse_dates
+    url = URI.parse('http://localhost/')
+
+    yesterday = Time.now - 86400
+
+    dates = [ "14 Apr 89 03:20:12",
+              "14 Apr 89 03:20 GMT",
+              "Fri, 17 Mar 89 4:01:33",
+              "Fri, 17 Mar 89 4:01 GMT",
+              "Mon Jan 16 16:12 PDT 1989",
+              #"Mon Jan 16 16:12 +0130 1989",
+              "6 May 1992 16:41-JST (Wednesday)",
+              #"22-AUG-1993 10:59:12.82",
+              "22-AUG-1993 10:59pm",
+              "22-AUG-1993 12:59am",
+              "22-AUG-1993 12:59 PM",
+              #"Friday, August 04, 1995 3:54 PM",
+              #"06/21/95 04:24:34 PM",
+              #"20/06/95 21:07",
+              #"95-06-08 19:32:48 EDT",
+    ]
+
+    dates.each do |date|
+      cookie = "PREF=1; expires=#{date}"
+      assert_equal 1, HTTP::Cookie.parse(cookie, url) { |c|
+        assert c.expires, "Tried parsing: #{date}"
+        assert_send [c.expires, :<, yesterday]
+      }.size
+    end
+
+    [
+      ["PREF=1; expires=Wed, 01 Jan 100 12:34:56 GMT", nil],
+      ["PREF=1; expires=Sat, 01 Jan 1600 12:34:56 GMT", nil],
+      ["PREF=1; expires=Tue, 01 Jan 69 12:34:56 GMT", 2069],
+      ["PREF=1; expires=Thu, 01 Jan 70 12:34:56 GMT", 1970],
+      ["PREF=1; expires=Wed, 01 Jan 20 12:34:56 GMT", 2020],
+      ["PREF=1; expires=Sat, 01 Jan 2020 12:34:60 GMT", nil],
+      ["PREF=1; expires=Sat, 01 Jan 2020 12:60:56 GMT", nil],
+      ["PREF=1; expires=Sat, 01 Jan 2020 24:00:00 GMT", nil],
+      ["PREF=1; expires=Sat, 32 Jan 2020 12:34:56 GMT", nil],
+    ].each { |set_cookie, year|
+      cookie, = HTTP::Cookie.parse(set_cookie, url)
+      if year
+        assert_equal year, cookie.expires.year, "#{set_cookie}: expires in #{year}"
+      else
+        assert_equal nil, cookie.expires, "#{set_cookie}: invalid expiry date"
+      end
+    }
+  end
+
+  def test_parse_empty
+    cookie_str = 'a=b; ; c=d'
+
+    uri = URI.parse 'http://example'
+
+    assert_equal 1, HTTP::Cookie.parse(cookie_str, uri) { |cookie|
+      assert_equal 'a', cookie.name
+      assert_equal 'b', cookie.value
+    }.size
+  end
+
+  def test_parse_no_space
+    cookie_str = "foo=bar;Expires=Sun, 06 Nov 2011 00:28:06 GMT;Path=/"
+
+    uri = URI.parse 'http://example'
+
+    assert_equal 1, HTTP::Cookie.parse(cookie_str, uri) { |cookie|
+      assert_equal 'foo',               cookie.name
+      assert_equal 'bar',               cookie.value
+      assert_equal '/',                 cookie.path
+      assert_equal Time.at(1320539286), cookie.expires
+    }.size
+  end
+
+  def test_parse_too_long_cookie
+    uri = URI.parse 'http://example'
+
+    cookie_str = "foo=#{'Cookie' * 680}; path=/ab/"
+    assert_equal(HTTP::Cookie::MAX_LENGTH - 1, cookie_str.bytesize)
+
+    assert_equal 1, HTTP::Cookie.parse(cookie_str, uri).size
+
+    assert_equal 1, HTTP::Cookie.parse(cookie_str.sub(';', 'x;'), uri).size
+
+    assert_equal 0, HTTP::Cookie.parse(cookie_str.sub(';', 'xx;'), uri).size
+  end
+
+  def test_parse_quoted
+    cookie_str =
+      "quoted=\"value\"; Expires=Sun, 06 Nov 2011 00:11:18 GMT; Path=/; comment=\"comment is \\\"comment\\\"\""
+
+    uri = URI.parse 'http://example'
+
+    assert_equal 1, HTTP::Cookie.parse(cookie_str, uri) { |cookie|
+      assert_equal 'quoted', cookie.name
+      assert_equal 'value', cookie.value
+    }.size
+  end
+
+  def test_parse_no_nothing
+    cookie = '; "", ;'
+    url = URI.parse('http://www.example.com/')
+    assert_equal 0, HTTP::Cookie.parse(cookie, url).size
+  end
+
+  def test_parse_no_name
+    cookie = '=no-name; path=/'
+    url = URI.parse('http://www.example.com/')
+    assert_equal 0, HTTP::Cookie.parse(cookie, url).size
+  end
+
+  def test_parse_bad_name
+    cookie = "a\001b=c"
+    url = URI.parse('http://www.example.com/')
+    assert_nothing_raised {
+      assert_equal 0, HTTP::Cookie.parse(cookie, url).size
+    }
+  end
+
+  def test_parse_bad_value
+    cookie = "a=b\001c"
+    url = URI.parse('http://www.example.com/')
+    assert_nothing_raised {
+      assert_equal 0, HTTP::Cookie.parse(cookie, url).size
+    }
+  end
+
+  def test_parse_weird_cookie
+    cookie = 'n/a, ASPSESSIONIDCSRRQDQR=FBLDGHPBNDJCPCGNCPAENELB; path=/'
+    url = URI.parse('http://www.searchinnovation.com/')
+    assert_equal 1, HTTP::Cookie.parse(cookie, url) { |c|
+      assert_equal('ASPSESSIONIDCSRRQDQR', c.name)
+      assert_equal('FBLDGHPBNDJCPCGNCPAENELB', c.value)
+    }.size
+  end
+
+  def test_double_semicolon
+    double_semi = 'WSIDC=WEST;; domain=.williams-sonoma.com; path=/'
+    url = URI.parse('http://williams-sonoma.com/')
+    assert_equal 1, HTTP::Cookie.parse(double_semi, url) { |cookie|
+      assert_equal('WSIDC', cookie.name)
+      assert_equal('WEST', cookie.value)
+    }.size
+  end
+
+  def test_parse_bad_version
+    bad_cookie = 'PRETANET=TGIAqbFXtt; Name=/PRETANET; Path=/; Version=1.2; Content-type=text/html; Domain=192.168.6.196; expires=Friday, 13-November-2026  23:01:46 GMT;'
+    url = URI.parse('http://192.168.6.196/')
+    # The version attribute is obsolete and simply ignored
+    cookies = HTTP::Cookie.parse(bad_cookie, url)
+    assert_equal 1, cookies.size
+  end
+
+  def test_parse_bad_max_age
+    bad_cookie = 'PRETANET=TGIAqbFXtt; Name=/PRETANET; Path=/; Max-Age=forever; Content-type=text/html; Domain=192.168.6.196; expires=Friday, 13-November-2026  23:01:46 GMT;'
+    url = URI.parse('http://192.168.6.196/')
+    # A bad max-age is simply ignored
+    cookies = HTTP::Cookie.parse(bad_cookie, url)
+    assert_equal 1, cookies.size
+    assert_equal nil, cookies.first.max_age
+  end
+
+  def test_parse_date_fail
+    url = URI.parse('http://localhost/')
+
+    dates = [
+      "20/06/95 21:07",
+    ]
+
+    dates.each { |date|
+      cookie = "PREF=1; expires=#{date}"
+      assert_equal 1, HTTP::Cookie.parse(cookie, url) { |c|
+        assert_equal(true, c.expires.nil?)
+      }.size
+    }
+  end
+
+  def test_parse_domain_dot
+    url = URI.parse('http://host.example.com/')
+
+    cookie_str = 'a=b; domain=.example.com'
+
+    cookie = HTTP::Cookie.parse(cookie_str, url).first
+
+    assert_equal 'example.com', cookie.domain
+    assert cookie.for_domain?
+    assert_equal '.example.com', cookie.dot_domain
+  end
+
+  def test_parse_domain_no_dot
+    url = URI.parse('http://host.example.com/')
+
+    cookie_str = 'a=b; domain=example.com'
+
+    cookie = HTTP::Cookie.parse(cookie_str, url).first
+
+    assert_equal 'example.com', cookie.domain
+    assert cookie.for_domain?
+    assert_equal '.example.com', cookie.dot_domain
+  end
+
+  def test_parse_public_suffix
+    cookie = HTTP::Cookie.new('a', 'b', :domain => 'com')
+    assert_equal('com', cookie.domain)
+    assert_equal(false, cookie.for_domain?)
+
+    cookie.origin = 'http://com/'
+    assert_equal('com', cookie.domain)
+    assert_equal(false, cookie.for_domain?)
+
+    assert_raises(ArgumentError) {
+      cookie.origin = 'http://example.com/'
+    }
+  end
+
+  def test_parse_domain_none
+    url = URI.parse('http://example.com/')
+
+    cookie_str = 'a=b;'
+
+    cookie = HTTP::Cookie.parse(cookie_str, url).first
+
+    assert_equal 'example.com', cookie.domain
+    assert !cookie.for_domain?
+    assert_equal 'example.com', cookie.dot_domain
+  end
+
+  def test_parse_max_age
+    url = URI.parse('http://localhost/')
+
+    epoch, date = 4485353164, 'Fri, 19 Feb 2112 19:26:04 GMT'
+    base = Time.at(1363014000)
+
+    cookie = HTTP::Cookie.parse("name=Akinori; expires=#{date}", url).first
+    assert_equal Time.at(epoch), cookie.expires
+
+    cookie = HTTP::Cookie.parse('name=Akinori; max-age=3600', url).first
+    assert_in_delta Time.now + 3600, cookie.expires, 1
+    cookie = HTTP::Cookie.parse('name=Akinori; max-age=3600', url, :created_at => base).first
+    assert_equal base + 3600, cookie.expires
+
+    # Max-Age has precedence over Expires
+    cookie = HTTP::Cookie.parse("name=Akinori; max-age=3600; expires=#{date}", url).first
+    assert_in_delta Time.now + 3600, cookie.expires, 1
+    cookie = HTTP::Cookie.parse("name=Akinori; max-age=3600; expires=#{date}", url, :created_at => base).first
+    assert_equal base + 3600, cookie.expires
+
+    cookie = HTTP::Cookie.parse("name=Akinori; expires=#{date}; max-age=3600", url).first
+    assert_in_delta Time.now + 3600, cookie.expires, 1
+    cookie = HTTP::Cookie.parse("name=Akinori; expires=#{date}; max-age=3600", url, :created_at => base).first
+    assert_equal base + 3600, cookie.expires
+  end
+
+  def test_parse_expires_session
+    url = URI.parse('http://localhost/')
+
+    [
+      'name=Akinori',
+      'name=Akinori; expires',
+      'name=Akinori; max-age',
+      'name=Akinori; expires=',
+      'name=Akinori; max-age=',
+    ].each { |str|
+      cookie = HTTP::Cookie.parse(str, url).first
+      assert cookie.session?, str
+    }
+
+    [
+      'name=Akinori; expires=Mon, 19 Feb 2012 19:26:04 GMT',
+      'name=Akinori; max-age=3600',
+    ].each { |str|
+      cookie = HTTP::Cookie.parse(str, url).first
+      assert !cookie.session?, str
+    }
+  end
+
+  def test_parse_many
+    url = URI 'http://localhost/'
+    cookie_str =
+      "abc, " \
+      "name=Aaron; Domain=localhost; Expires=Sun, 06 Nov 2011 00:29:51 GMT; Path=/, " \
+      "name=Aaron; Domain=localhost; Expires=Sun, 06 Nov 2011 00:29:51 GMT; Path=/, " \
+      "name=Aaron; Domain=localhost; Expires=Sun, 06 Nov 2011 00:29:51 GMT; Path=/, " \
+      "name=Aaron; Domain=localhost; Expires=Sun, 06 Nov 2011 00:29:51 GMT; Path=/; HttpOnly, " \
+      "expired=doh; Expires=Fri, 04 Nov 2011 00:29:51 GMT; Path=/, " \
+      "a_path=some_path; Expires=Sun, 06 Nov 2011 00:29:51 GMT; Path=/some_path, " \
+      "no_path1=no_path; Expires=Sun, 06 Nov 2011 00:29:52 GMT, no_expires=nope; Path=/, " \
+      "no_path2=no_path; Expires=Sun, 06 Nov 2011 00:29:52 GMT; no_expires=nope; Path, " \
+      "no_path3=no_path; Expires=Sun, 06 Nov 2011 00:29:52 GMT; no_expires=nope; Path=, " \
+      "rel_path1=rel_path; Expires=Sun, 06 Nov 2011 00:29:52 GMT; no_expires=nope; Path=foo/bar, " \
+      "rel_path1=rel_path; Expires=Sun, 06 Nov 2011 00:29:52 GMT; no_expires=nope; Path=foo, " \
+      "no_domain1=no_domain; Expires=Sun, 06 Nov 2011 00:29:53 GMT; no_expires=nope, " \
+      "no_domain2=no_domain; Expires=Sun, 06 Nov 2011 00:29:53 GMT; no_expires=nope; Domain, " \
+      "no_domain3=no_domain; Expires=Sun, 06 Nov 2011 00:29:53 GMT; no_expires=nope; Domain="
+
+    cookies = HTTP::Cookie.parse cookie_str, url
+    assert_equal 15, cookies.length
+
+    name = cookies.find { |c| c.name == 'name' }
+    assert_equal "Aaron",             name.value
+    assert_equal "/",                 name.path
+    assert_equal Time.at(1320539391), name.expires
+
+    a_path = cookies.find { |c| c.name == 'a_path' }
+    assert_equal "some_path",         a_path.value
+    assert_equal "/some_path",        a_path.path
+    assert_equal Time.at(1320539391), a_path.expires
+
+    no_expires = cookies.find { |c| c.name == 'no_expires' }
+    assert_equal "nope", no_expires.value
+    assert_equal "/",    no_expires.path
+    assert_nil           no_expires.expires
+
+    no_path_cookies = cookies.select { |c| c.value == 'no_path' }
+    assert_equal 3, no_path_cookies.size
+    no_path_cookies.each { |c|
+      assert_equal "/",                 c.path,    c.name
+      assert_equal Time.at(1320539392), c.expires, c.name
+    }
+
+    rel_path_cookies = cookies.select { |c| c.value == 'rel_path' }
+    assert_equal 2, rel_path_cookies.size
+    rel_path_cookies.each { |c|
+      assert_equal "/",                 c.path,    c.name
+      assert_equal Time.at(1320539392), c.expires, c.name
+    }
+
+    no_domain_cookies = cookies.select { |c| c.value == 'no_domain' }
+    assert_equal 3, no_domain_cookies.size
+    no_domain_cookies.each { |c|
+      assert !c.for_domain?, c.name
+      assert_equal c.domain, url.host, c.name
+      assert_equal Time.at(1320539393), c.expires, c.name
+    }
+
+    assert cookies.find { |c| c.name == 'expired' }
+  end
+
+  def test_parse_valid_cookie
+    url = URI.parse('http://rubyforge.org/')
+    cookie_params = @cookie_params
+    cookie_value = '12345%7D=ASDFWEE345%3DASda'
+
+    cookie_params.keys.combine.each do |keys|
+      cookie_text = [cookie_value, *keys.map { |key| cookie_params[key] }].join('; ')
+      cookie, = HTTP::Cookie.parse(cookie_text, url)
+
+      assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
+      assert_equal('/', cookie.path)
+
+      assert_equal(keys.include?('expires') ? @expires : nil, cookie.expires)
+      assert_equal(keys.include?('httponly'), cookie.httponly?)
+    end
+  end
+
+  def test_parse_valid_cookie_empty_value
+    url = URI.parse('http://rubyforge.org/')
+    cookie_params = @cookie_params
+    cookie_value = '12345%7D='
+
+    cookie_params.keys.combine.each do |keys|
+      cookie_text = [cookie_value, *keys.map { |key| cookie_params[key] }].join('; ')
+      cookie, = HTTP::Cookie.parse(cookie_text, url)
+
+      assert_equal('12345%7D=', cookie.to_s)
+      assert_equal('', cookie.value)
+      assert_equal('/', cookie.path)
+
+      assert_equal(keys.include?('expires') ? @expires : nil, cookie.expires)
+      assert_equal(keys.include?('httponly'), cookie.httponly?)
+    end
+  end
+
+  # If no path was given, use the one from the URL
+  def test_cookie_using_url_path
+    url = URI.parse('http://rubyforge.org/login.php')
+    cookie_params = @cookie_params
+    cookie_value = '12345%7D=ASDFWEE345%3DASda'
+
+    cookie_params.keys.combine.each do |keys|
+      next if keys.include?('path')
+      cookie_text = [cookie_value, *keys.map { |key| cookie_params[key] }].join('; ')
+      cookie, = HTTP::Cookie.parse(cookie_text, url)
+
+      assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
+      assert_equal('/', cookie.path)
+
+      assert_equal(keys.include?('expires') ? @expires : nil, cookie.expires)
+      assert_equal(keys.include?('httponly'), cookie.httponly?)
+    end
+  end
+
+  # Test using secure cookies
+  def test_cookie_with_secure
+    url = URI.parse('http://rubyforge.org/')
+    cookie_params = @cookie_params.merge('secure' => 'secure')
+    cookie_value = '12345%7D=ASDFWEE345%3DASda'
+
+    cookie_params.keys.combine.each do |keys|
+      next unless keys.include?('secure')
+      cookie_text = [cookie_value, *keys.map { |key| cookie_params[key] }].join('; ')
+      cookie, = HTTP::Cookie.parse(cookie_text, url)
+
+      assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
+      assert_equal('/', cookie.path)
+      assert_equal(true, cookie.secure)
+
+      assert_equal(keys.include?('expires') ? @expires : nil, cookie.expires)
+      assert_equal(keys.include?('httponly'), cookie.httponly?)
+    end
+  end
+
+  def test_cookie_value
+    [
+      ['foo="bar  baz"', 'bar  baz'],
+      ['foo="bar\"; \"baz"', 'bar"; "baz'],
+    ].each { |cookie_value, value|
+      cookie = HTTP::Cookie.new('foo', value)
+      assert_equal(cookie_value, cookie.cookie_value)
+    }
+
+    pairs = [
+      ['Foo', 'value1'],
+      ['Bar', 'value 2'],
+      ['Baz', 'value3'],
+      ['Bar', 'value"4'],
+      ['Quux', 'x, value=5'],
+    ]
+
+    cookie_value = HTTP::Cookie.cookie_value(pairs.map { |name, value|
+        HTTP::Cookie.new(:name => name, :value => value)
+      })
+
+    assert_equal 'Foo=value1; Bar="value 2"; Baz=value3; Bar="value\\"4"; Quux="x, value=5"', cookie_value
+
+    hash = HTTP::Cookie.cookie_value_to_hash(cookie_value)
+
+    assert_equal pairs.map(&:first).uniq.size, hash.size
+
+    hash.each_pair { |name, value|
+      _, pvalue = pairs.assoc(name)
+      assert_equal pvalue, value
+    }
+
+    # Do not treat comma in a Cookie header value as separator; see CVE-2016-7401
+    hash = HTTP::Cookie.cookie_value_to_hash('Quux=x, value=5; Foo=value1; Bar="value 2"; Baz=value3; Bar="value\\"4"')
+
+    assert_equal pairs.map(&:first).uniq.size, hash.size
+
+    hash.each_pair { |name, value|
+      _, pvalue = pairs.assoc(name)
+      assert_equal pvalue, value
+    }
+  end
+
+  def test_set_cookie_value
+    url = URI.parse('http://rubyforge.org/path/')
+
+    [
+      HTTP::Cookie.new('a', 'b', :domain => 'rubyforge.org', :path => '/path/'),
+      HTTP::Cookie.new('a', 'b', :origin => url),
+    ].each { |cookie|
+      cookie.set_cookie_value
+    }
+
+    [
+      HTTP::Cookie.new('a', 'b', :domain => 'rubyforge.org'),
+      HTTP::Cookie.new('a', 'b', :for_domain => true, :path => '/path/'),
+    ].each { |cookie|
+      assert_raises(RuntimeError) {
+        cookie.set_cookie_value
+      }
+    }
+
+    ['foo=bar', 'foo="bar"', 'foo="ba\"r baz"'].each { |cookie_value|
+      cookie_params = @cookie_params.merge('path' => '/path/', 'secure' => 'secure', 'max-age' => 'Max-Age=1000')
+      date = Time.at(Time.now.to_i)
+      cookie_params.keys.combine.each do |keys|
+        cookie_text = [cookie_value, *keys.map { |key| cookie_params[key] }].join('; ')
+        cookie, = HTTP::Cookie.parse(cookie_text, url, :created_at => date)
+        cookie2, = HTTP::Cookie.parse(cookie.set_cookie_value, url, :created_at => date)
+
+        assert_equal(cookie.name, cookie2.name)
+        assert_equal(cookie.value, cookie2.value)
+        assert_equal(cookie.domain, cookie2.domain)
+        assert_equal(cookie.for_domain?, cookie2.for_domain?)
+        assert_equal(cookie.path, cookie2.path)
+        assert_equal(cookie.expires, cookie2.expires)
+        if keys.include?('max-age')
+          assert_equal(date + 1000, cookie2.expires)
+        elsif keys.include?('expires')
+          assert_equal(@expires, cookie2.expires)
+        else
+          assert_equal(nil, cookie2.expires)
+        end
+        assert_equal(cookie.secure?, cookie2.secure?)
+        assert_equal(cookie.httponly?, cookie2.httponly?)
+      end
+    }
+  end
+
+  def test_parse_cookie_no_spaces
+    url = URI.parse('http://rubyforge.org/')
+    cookie_params = @cookie_params
+    cookie_value = '12345%7D=ASDFWEE345%3DASda'
+
+    cookie_params.keys.combine.each do |keys|
+      cookie_text = [cookie_value, *keys.map { |key| cookie_params[key] }].join(';')
+      cookie, = HTTP::Cookie.parse(cookie_text, url)
+
+      assert_equal('12345%7D=ASDFWEE345%3DASda', cookie.to_s)
+      assert_equal('/', cookie.path)
+
+      assert_equal(keys.include?('expires') ? @expires : nil, cookie.expires)
+      assert_equal(keys.include?('httponly'), cookie.httponly?)
+    end
+  end
+
+  def test_new
+    cookie = HTTP::Cookie.new('key', 'value')
+    assert_equal 'key', cookie.name
+    assert_equal 'value', cookie.value
+    assert_equal nil, cookie.expires
+    assert_raises(RuntimeError) {
+      cookie.acceptable?
+    }
+
+    # Minimum unit for the expires attribute is second
+    expires = Time.at((Time.now + 3600).to_i)
+
+    cookie = HTTP::Cookie.new('key', 'value', :expires => expires.dup)
+    assert_equal 'key', cookie.name
+    assert_equal 'value', cookie.value
+    assert_equal expires, cookie.expires
+    assert_raises(RuntimeError) {
+      cookie.acceptable?
+    }
+
+    # various keywords
+    [
+      ["Expires", /use downcased symbol/],
+    ].each { |key, pattern|
+      assert_warning(pattern, "warn of key: #{key.inspect}") {
+        cookie = HTTP::Cookie.new(:value => 'value', :name => 'key', key => expires.dup)
+        assert_equal 'key', cookie.name
+        assert_equal 'value', cookie.value
+        assert_equal expires, cookie.expires, "key: #{key.inspect}"
+      }
+    }
+    [
+      [:Expires,   /unknown attribute name/],
+      [:expires?,  /unknown attribute name/],
+      [[:expires], /invalid keyword/],
+    ].each { |key, pattern|
+      assert_warning(pattern, "warn of key: #{key.inspect}") {
+        cookie = HTTP::Cookie.new(:value => 'value', :name => 'key', key => expires.dup)
+        assert_equal 'key', cookie.name
+        assert_equal 'value', cookie.value
+        assert_equal nil, cookie.expires, "key: #{key.inspect}"
+      }
+    }
+
+    cookie = HTTP::Cookie.new(:value => 'value', :name => 'key', :expires => expires.dup)
+    assert_equal 'key', cookie.name
+    assert_equal 'value', cookie.value
+    assert_equal expires, cookie.expires
+    assert_equal false, cookie.for_domain?
+    assert_raises(RuntimeError) {
+      # domain and path are missing
+      cookie.acceptable?
+    }
+
+    cookie = HTTP::Cookie.new(:value => 'value', :name => 'key', :expires => expires.dup, :domain => '.example.com')
+    assert_equal 'key', cookie.name
+    assert_equal 'value', cookie.value
+    assert_equal expires, cookie.expires
+    assert_equal true, cookie.for_domain?
+    assert_raises(RuntimeError) {
+      # path is missing
+      cookie.acceptable?
+    }
+
+    cookie = HTTP::Cookie.new(:value => 'value', :name => 'key', :expires => expires.dup, :domain => 'example.com', :for_domain => false)
+    assert_equal 'key', cookie.name
+    assert_equal 'value', cookie.value
+    assert_equal expires, cookie.expires
+    assert_equal false, cookie.for_domain?
+    assert_raises(RuntimeError) {
+      # path is missing
+      cookie.acceptable?
+    }
+
+    cookie = HTTP::Cookie.new(:value => 'value', :name => 'key', :expires => expires.dup, :domain => 'example.org', :for_domain? => true)
+    assert_equal 'key', cookie.name
+    assert_equal 'value', cookie.value
+    assert_equal expires, cookie.expires
+    assert_equal 'example.org', cookie.domain
+    assert_equal true, cookie.for_domain?
+    assert_raises(RuntimeError) {
+      # path is missing
+      cookie.acceptable?
+    }
+
+    assert_raises(ArgumentError) { HTTP::Cookie.new() }
+    assert_raises(ArgumentError) { HTTP::Cookie.new(:value => 'value') }
+    assert_raises(ArgumentError) { HTTP::Cookie.new('', 'value') }
+    assert_raises(ArgumentError) { HTTP::Cookie.new('key=key', 'value') }
+    assert_raises(ArgumentError) { HTTP::Cookie.new("key\tkey", 'value') }
+    assert_raises(ArgumentError) { HTTP::Cookie.new('key', 'value', 'something') }
+    assert_raises(ArgumentError) { HTTP::Cookie.new('key', 'value', {}, 'something') }
+
+    [
+      HTTP::Cookie.new(:name => 'name'),
+      HTTP::Cookie.new("key", nil, :for_domain => true),
+      HTTP::Cookie.new("key", nil),
+      HTTP::Cookie.new("key", :secure => true),
+      HTTP::Cookie.new("key"),
+    ].each { |cookie|
+      assert_equal '', cookie.value
+      assert_equal true, cookie.expired?
+    }
+
+    [
+      HTTP::Cookie.new(:name => 'name', :max_age => 3600),
+      HTTP::Cookie.new("key", nil, :expires => Time.now + 3600),
+      HTTP::Cookie.new("key", :expires => Time.now + 3600),
+      HTTP::Cookie.new("key", :expires => Time.now + 3600, :value => nil),
+    ].each { |cookie|
+      assert_equal '', cookie.value
+      assert_equal false, cookie.expired?
+    }
+  end
+
+  def cookie_values(options = {})
+    {
+      :name     => 'Foo',
+      :value    => 'Bar',
+      :path     => '/',
+      :expires  => Time.now + (10 * 86400),
+      :for_domain => true,
+      :domain   => 'rubyforge.org',
+      :origin   => 'http://rubyforge.org/'
+   }.merge(options)
+  end
+
+  def test_bad_name
+    [
+      "a\tb", "a\vb", "a\rb", "a\nb", 'a b',
+      "a\\b", 'a"b', # 'a:b', 'a/b', 'a[b]',
+      'a=b', 'a,b', 'a;b',
+    ].each { |name|
+      assert_raises(ArgumentError) {
+        HTTP::Cookie.new(cookie_values(:name => name))
+      }
+      cookie = HTTP::Cookie.new(cookie_values)
+      assert_raises(ArgumentError) {
+        cookie.name = name
+      }
+    }
+  end
+
+  def test_bad_value
+    [
+      "a\tb", "a\vb", "a\rb", "a\nb",
+      "a\\b", 'a"b', # 'a:b', 'a/b', 'a[b]',
+    ].each { |name|
+      assert_raises(ArgumentError) {
+        HTTP::Cookie.new(cookie_values(:name => name))
+      }
+      cookie = HTTP::Cookie.new(cookie_values)
+      assert_raises(ArgumentError) {
+        cookie.name = name
+      }
+    }
+  end
+
+  def test_compare
+    time = Time.now
+    cookies = [
+      { :created_at => time + 1 },
+      { :created_at => time - 1 },
+      { :created_at => time },
+      { :created_at => time, :path => '/foo/bar/' },
+      { :created_at => time, :path => '/foo/' },
+      { :created_at => time, :path => '/foo' },
+    ].map { |attrs| HTTP::Cookie.new(cookie_values(attrs)) }
+
+    assert_equal([3, 4, 5, 1, 2, 0], cookies.sort.map { |i|
+        cookies.find_index { |j| j.equal?(i) }
+      })
+  end
+
+  def test_expiration
+    cookie = HTTP::Cookie.new(cookie_values)
+
+    assert_equal false, cookie.expired?
+    assert_equal true, cookie.expired?(cookie.expires + 1)
+    assert_equal false, cookie.expired?(cookie.expires - 1)
+    cookie.expire!
+    assert_equal true, cookie.expired?
+  end
+
+  def test_max_age=
+    cookie = HTTP::Cookie.new(cookie_values)
+    expires = cookie.expires
+
+    assert_raises(ArgumentError) {
+      cookie.max_age = "+1"
+    }
+    # make sure #expires is not destroyed
+    assert_equal expires, cookie.expires
+
+    assert_raises(ArgumentError) {
+      cookie.max_age = "1.5"
+    }
+    # make sure #expires is not destroyed
+    assert_equal expires, cookie.expires
+
+    assert_raises(ArgumentError) {
+      cookie.max_age = "1 day"
+    }
+    # make sure #expires is not destroyed
+    assert_equal expires, cookie.expires
+
+    assert_raises(TypeError) {
+      cookie.max_age = [1]
+    }
+    # make sure #expires is not destroyed
+    assert_equal expires, cookie.expires
+
+    cookie.max_age = "12"
+    assert_equal 12, cookie.max_age
+
+    cookie.max_age = -3
+    assert_equal -3, cookie.max_age
+  end
+
+  def test_session
+    cookie = HTTP::Cookie.new(cookie_values)
+
+    assert_equal false, cookie.session?
+    assert_equal nil, cookie.max_age
+
+    cookie.expires = nil
+    assert_equal true, cookie.session?
+    assert_equal nil, cookie.max_age
+
+    cookie.expires = Time.now + 3600
+    assert_equal false, cookie.session?
+    assert_equal nil, cookie.max_age
+
+    cookie.max_age = 3600
+    assert_equal false, cookie.session?
+    assert_equal cookie.created_at + 3600, cookie.expires
+
+    cookie.max_age = nil
+    assert_equal true, cookie.session?
+    assert_equal nil, cookie.expires
+  end
+
+  def test_equal
+    assert_not_equal(HTTP::Cookie.new(cookie_values),
+      HTTP::Cookie.new(cookie_values(:value => 'bar')))
+  end
+
+  def test_new_tld_domain
+    url = URI 'http://rubyforge.org/'
+
+    tld_cookie1 = HTTP::Cookie.new(cookie_values(:domain => 'org', :origin => url))
+    assert_equal false, tld_cookie1.for_domain?
+    assert_equal 'org', tld_cookie1.domain
+    assert_equal false, tld_cookie1.acceptable?
+
+    tld_cookie2 = HTTP::Cookie.new(cookie_values(:domain => '.org', :origin => url))
+    assert_equal false, tld_cookie1.for_domain?
+    assert_equal 'org', tld_cookie2.domain
+    assert_equal false, tld_cookie2.acceptable?
+  end
+
+  def test_new_tld_domain_from_tld
+    url = URI 'http://org/'
+
+    tld_cookie1 = HTTP::Cookie.new(cookie_values(:domain => 'org', :origin => url))
+    assert_equal false, tld_cookie1.for_domain?
+    assert_equal 'org', tld_cookie1.domain
+    assert_equal true, tld_cookie1.acceptable?
+
+    tld_cookie2 = HTTP::Cookie.new(cookie_values(:domain => '.org', :origin => url))
+    assert_equal false, tld_cookie1.for_domain?
+    assert_equal 'org', tld_cookie2.domain
+    assert_equal true, tld_cookie2.acceptable?
+  end
+
+  def test_fall_back_rules_for_local_domains
+    url = URI 'http://www.example.local'
+
+    tld_cookie = HTTP::Cookie.new(cookie_values(:domain => '.local', :origin => url))
+    assert_equal false, tld_cookie.acceptable?
+
+    sld_cookie = HTTP::Cookie.new(cookie_values(:domain => '.example.local', :origin => url))
+    assert_equal true, sld_cookie.acceptable?
+  end
+
+  def test_new_rejects_cookies_with_ipv4_address_subdomain
+    url = URI 'http://192.168.0.1/'
+
+    cookie = HTTP::Cookie.new(cookie_values(:domain => '.0.1', :origin => url))
+    assert_equal false, cookie.acceptable?
+  end
+
+  def test_value
+    cookie = HTTP::Cookie.new('name', 'value')
+    assert_equal 'value', cookie.value
+
+    cookie.value = 'new value'
+    assert_equal 'new value', cookie.value
+
+    assert_raises(ArgumentError) { cookie.value = "a\tb" }
+    assert_raises(ArgumentError) { cookie.value = "a\nb" }
+
+    assert_equal false, cookie.expired?
+    cookie.value = nil
+    assert_equal '', cookie.value
+    assert_equal true, cookie.expired?
+  end
+
+  def test_path
+    uri = URI.parse('http://example.com/foo/bar')
+
+    assert_equal '/foo/bar', uri.path
+
+    cookie_str = 'a=b'
+    cookie = HTTP::Cookie.parse(cookie_str, uri).first
+    assert '/foo/', cookie.path
+
+    cookie_str = 'a=b; path=/foo'
+    cookie = HTTP::Cookie.parse(cookie_str, uri).first
+    assert '/foo', cookie.path
+
+    uri = URI.parse('http://example.com')
+
+    assert_equal '', uri.path
+
+    cookie_str = 'a=b'
+    cookie = HTTP::Cookie.parse(cookie_str, uri).first
+    assert '/', cookie.path
+
+    cookie_str = 'a=b; path=/foo'
+    cookie = HTTP::Cookie.parse(cookie_str, uri).first
+    assert '/foo', cookie.path
+  end
+
+  def test_domain_nil
+    cookie = HTTP::Cookie.new('a', 'b')
+    assert_raises(RuntimeError) {
+      cookie.valid_for_uri?('http://example.com/')
+    }
+  end
+
+  def test_domain=
+    url = URI.parse('http://host.dom.example.com:8080/')
+
+    cookie_str = 'a=b; domain=Example.Com'
+    cookie = HTTP::Cookie.parse(cookie_str, url).first
+    assert 'example.com', cookie.domain
+
+    cookie.domain = DomainName(url.host)
+    assert 'host.dom.example.com', cookie.domain
+
+    cookie.domain = 'Dom.example.com'
+    assert 'dom.example.com', cookie.domain
+
+    cookie.domain = Object.new.tap { |o|
+      def o.to_str
+        'Example.com'
+      end
+    }
+    assert 'example.com', cookie.domain
+
+    url = URI 'http://rubyforge.org/'
+
+    [nil, '', '.'].each { |d|
+      cookie = HTTP::Cookie.new('Foo', 'Bar', :path => '/')
+      cookie.domain = d
+      assert_equal nil, cookie.domain, "domain=#{d.inspect}"
+      assert_equal nil, cookie.domain_name, "domain=#{d.inspect}"
+      assert_raises(RuntimeError) {
+        cookie.acceptable?
+      }
+
+      cookie = HTTP::Cookie.new('Foo', 'Bar', :path => '/')
+      cookie.origin = url
+      cookie.domain = d
+      assert_equal url.host, cookie.domain, "domain=#{d.inspect}"
+      assert_equal true, cookie.acceptable?, "domain=#{d.inspect}"
+    }
+  end
+
+  def test_origin=
+    url = URI.parse('http://example.com/path/')
+
+    cookie = HTTP::Cookie.new('a', 'b')
+    assert_raises(ArgumentError) {
+      cookie.origin = 123
+    }
+    cookie.origin = url
+    assert_equal '/path/', cookie.path
+    assert_equal 'example.com', cookie.domain
+    assert_equal false, cookie.for_domain
+    assert_raises(ArgumentError) {
+      # cannot change the origin once set
+      cookie.origin = URI.parse('http://www.example.com/')
+    }
+
+    cookie = HTTP::Cookie.new('a', 'b', :domain => '.example.com', :path => '/')
+    cookie.origin = url
+    assert_equal '/', cookie.path
+    assert_equal 'example.com', cookie.domain
+    assert_equal true, cookie.for_domain
+    assert_raises(ArgumentError) {
+      # cannot change the origin once set
+      cookie.origin = URI.parse('http://www.example.com/')
+    }
+
+    cookie = HTTP::Cookie.new('a', 'b', :domain => '.example.com')
+    cookie.origin = URI.parse('http://example.org/')
+    assert_equal false, cookie.acceptable?
+
+    cookie = HTTP::Cookie.new('a', 'b', :domain => '.example.com')
+    cookie.origin = 'file:///tmp/test.html'
+    assert_equal nil, cookie.path
+
+    cookie = HTTP::Cookie.new('a', 'b', :domain => '.example.com', :path => '/')
+    cookie.origin = 'file:///tmp/test.html'
+    assert_equal false, cookie.acceptable?
+  end
+
+  def test_acceptable_from_uri?
+    cookie = HTTP::Cookie.new(cookie_values(
+        :domain => 'uk',
+        :for_domain => true,
+        :origin => nil))
+    assert_equal false, cookie.for_domain?
+    assert_equal true, cookie.acceptable_from_uri?('http://uk/')
+    assert_equal false, cookie.acceptable_from_uri?('http://foo.uk/')
+  end
+
+  def test_valid_for_uri?
+    {
+      HTTP::Cookie.parse('a1=b',
+        'http://example.com/dir/file.html').first => {
+        true => [
+          'http://example.com/dir/',
+          'http://example.com/dir/test.html',
+          'https://example.com/dir/',
+          'https://example.com/dir/test.html',
+        ],
+        false => [
+          'file:///dir/test.html',
+          'http://example.com/dir',
+          'http://example.com/dir2/test.html',
+          'http://www.example.com/dir/test.html',
+          'http://www.example.com/dir2/test.html',
+          'https://example.com/dir',
+          'https://example.com/dir2/test.html',
+          'https://www.example.com/dir/test.html',
+          'https://www.example.com/dir2/test.html',
+        ]
+      },
+      HTTP::Cookie.parse('a2=b; path=/dir2/',
+        'http://example.com/dir/file.html').first => {
+        true => [
+          'http://example.com/dir2/',
+          'http://example.com/dir2/test.html',
+          'https://example.com/dir2/',
+          'https://example.com/dir2/test.html',
+        ],
+        false => [
+          'file:///dir/test.html',
+          'http://example.com/dir/test.html',
+          'http://www.example.com/dir/test.html',
+          'http://www.example.com/dir2',
+          'http://www.example.com/dir2/test.html',
+          'https://example.com/dir/test.html',
+          'https://www.example.com/dir/test.html',
+          'https://www.example.com/dir2',
+          'https://www.example.com/dir2/test.html',
+        ]
+      },
+      HTTP::Cookie.parse('a4=b; domain=example.com; path=/dir2/',
+        URI('http://example.com/dir/file.html')).first => {
+        true => [
+          'https://example.com/dir2/test.html',
+          'http://example.com/dir2/test.html',
+          'https://www.example.com/dir2/test.html',
+          'http://www.example.com/dir2/test.html',
+        ],
+        false => [
+          'https://example.com/dir/test.html',
+          'http://example.com/dir/test.html',
+          'https://www.example.com/dir/test.html',
+          'http://www.example.com/dir/test.html',
+          'file:///dir2/test.html',
+        ]
+      },
+      HTTP::Cookie.parse('a4=b; secure',
+        URI('https://example.com/dir/file.html')).first => {
+        true => [
+          'https://example.com/dir/test.html',
+        ],
+        false => [
+          'http://example.com/dir/test.html',
+          'https://example.com/dir2/test.html',
+          'http://example.com/dir2/test.html',
+          'file:///dir2/test.html',
+        ]
+      },
+      HTTP::Cookie.parse('a5=b',
+        URI('https://example.com/')).first => {
+        true => [
+          'https://example.com',
+        ],
+        false => [
+          'file:///',
+        ]
+      },
+      HTTP::Cookie.parse('a6=b; path=/dir',
+        'http://example.com/dir/file.html').first => {
+        true => [
+          'http://example.com/dir',
+          'http://example.com/dir/',
+          'http://example.com/dir/test.html',
+          'https://example.com/dir',
+          'https://example.com/dir/',
+          'https://example.com/dir/test.html',
+        ],
+        false => [
+          'file:///dir/test.html',
+          'http://example.com/dir2',
+          'http://example.com/dir2/test.html',
+          'http://www.example.com/dir/test.html',
+          'http://www.example.com/dir2/test.html',
+          'https://example.com/dir2',
+          'https://example.com/dir2/test.html',
+          'https://www.example.com/dir/test.html',
+          'https://www.example.com/dir2/test.html',
+        ]
+      },
+    }.each { |cookie, hash|
+      hash.each { |expected, urls|
+        urls.each { |url|
+          assert_equal expected, cookie.valid_for_uri?(url), '%s: %s' % [cookie.name, url]
+          assert_equal expected, cookie.valid_for_uri?(URI(url)), "%s: URI(%s)" % [cookie.name, url]
+        }
+      }
+    }
+  end
+
+  def test_yaml_expires
+    require 'yaml'
+    cookie = HTTP::Cookie.new(cookie_values)
+
+    assert_equal false, cookie.session?
+    assert_equal nil, cookie.max_age
+
+    ycookie = YAML.load(cookie.to_yaml)
+    assert_equal false, ycookie.session?
+    assert_equal nil, ycookie.max_age
+    assert_in_delta cookie.expires, ycookie.expires, 1
+
+    cookie.expires = nil
+    ycookie = YAML.load(cookie.to_yaml)
+    assert_equal true, ycookie.session?
+    assert_equal nil, ycookie.max_age
+
+    cookie.expires = Time.now + 3600
+    ycookie = YAML.load(cookie.to_yaml)
+    assert_equal false, ycookie.session?
+    assert_equal nil, ycookie.max_age
+    assert_in_delta cookie.expires, ycookie.expires, 1
+
+    cookie.max_age = 3600
+    ycookie = YAML.load(cookie.to_yaml)
+    assert_equal false, ycookie.session?
+    assert_in_delta cookie.created_at + 3600, ycookie.expires, 1
+
+    cookie.max_age = nil
+    ycookie = YAML.load(cookie.to_yaml)
+    assert_equal true, ycookie.session?
+    assert_equal nil, ycookie.expires
+  end
+
+  def test_s_path_match?
+    assert_equal true,  HTTP::Cookie.path_match?('/admin/', '/admin/index')
+    assert_equal false, HTTP::Cookie.path_match?('/admin/', '/Admin/index')
+    assert_equal true,  HTTP::Cookie.path_match?('/admin/', '/admin/')
+    assert_equal false, HTTP::Cookie.path_match?('/admin/', '/admin')
+
+    assert_equal true,  HTTP::Cookie.path_match?('/admin', '/admin')
+    assert_equal false, HTTP::Cookie.path_match?('/admin', '/Admin')
+    assert_equal false, HTTP::Cookie.path_match?('/admin', '/admins')
+    assert_equal true,  HTTP::Cookie.path_match?('/admin', '/admin/')
+    assert_equal true,  HTTP::Cookie.path_match?('/admin', '/admin/index')
+  end
+end