webrick 1.3.1 → 1.6.1

data/test/webrick/test_httpauth.rb

@@ -1,167 +0,0 @@
-require "test/unit"
-require "net/http"
-require "tempfile"
-require "webrick"
-require "webrick/httpauth/basicauth"
-require_relative "utils"
-
-class TestWEBrickHTTPAuth < Test::Unit::TestCase
-  def test_basic_auth
-    TestWEBrick.start_httpserver{|server, addr, port, log|
-      realm = "WEBrick's realm"
-      path = "/basic_auth"
-
-      server.mount_proc(path){|req, res|
-        WEBrick::HTTPAuth.basic_auth(req, res, realm){|user, pass|
-          user == "webrick" && pass == "supersecretpassword"
-        }
-        res.body = "hoge"
-      }
-      http = Net::HTTP.new(addr, port)
-      g = Net::HTTP::Get.new(path)
-      g.basic_auth("webrick", "supersecretpassword")
-      http.request(g){|res| assert_equal("hoge", res.body, log.call)}
-      g.basic_auth("webrick", "not super")
-      http.request(g){|res| assert_not_equal("hoge", res.body, log.call)}
-    }
-  end
-
-  def test_basic_auth2
-    TestWEBrick.start_httpserver{|server, addr, port, log|
-      realm = "WEBrick's realm"
-      path = "/basic_auth2"
-
-      tmpfile = Tempfile.new("test_webrick_auth")
-      tmpfile.close
-      tmp_pass = WEBrick::HTTPAuth::Htpasswd.new(tmpfile.path)
-      tmp_pass.set_passwd(realm, "webrick", "supersecretpassword")
-      tmp_pass.set_passwd(realm, "foo", "supersecretpassword")
-      tmp_pass.flush
-
-      htpasswd = WEBrick::HTTPAuth::Htpasswd.new(tmpfile.path)
-      users = []
-      htpasswd.each{|user, pass| users << user }
-      assert_equal(2, users.size, log.call)
-      assert(users.member?("webrick"), log.call)
-      assert(users.member?("foo"), log.call)
-
-      server.mount_proc(path){|req, res|
-        auth = WEBrick::HTTPAuth::BasicAuth.new(
-          :Realm => realm, :UserDB => htpasswd,
-          :Logger => server.logger
-        )
-        auth.authenticate(req, res)
-        res.body = "hoge"
-      }
-      http = Net::HTTP.new(addr, port)
-      g = Net::HTTP::Get.new(path)
-      g.basic_auth("webrick", "supersecretpassword")
-      http.request(g){|res| assert_equal("hoge", res.body, log.call)}
-      g.basic_auth("webrick", "not super")
-      http.request(g){|res| assert_not_equal("hoge", res.body, log.call)}
-    }
-  end
-
-  def test_basic_auth3
-    tmpfile = Tempfile.new("test_webrick_auth")
-    tmpfile.puts("webrick:{SHA}GJYFRpBbdchp595jlh3Bhfmgp8k=")
-    tmpfile.flush
-    assert_raise(NotImplementedError){
-      WEBrick::HTTPAuth::Htpasswd.new(tmpfile.path)
-    }
-    tmpfile.close(true)
-
-    tmpfile = Tempfile.new("test_webrick_auth")
-    tmpfile.puts("webrick:$apr1$IOVMD/..$rmnOSPXr0.wwrLPZHBQZy0")
-    tmpfile.flush
-    assert_raise(NotImplementedError){
-      WEBrick::HTTPAuth::Htpasswd.new(tmpfile.path)
-    }
-    tmpfile.close(true)
-  end
-
-  DIGESTRES_ = /
-    ([a-zA-z\-]+)
-      [\s\t]*(?:\r\n[\s\t]*)*
-      =
-      [\s\t]*(?:\r\n[\s\t]*)*
-      (?:
-       "((?:[^"]+|\\[\x00-\x7F])*)" |
-       ([!\#$%&'*+\-.0-9A-Z^_`a-z|~]+)
-      )/x
-
-  def test_digest_auth
-    TestWEBrick.start_httpserver{|server, addr, port, log|
-      realm = "WEBrick's realm"
-      path = "/digest_auth"
-
-      tmpfile = Tempfile.new("test_webrick_auth")
-      tmpfile.close
-      tmp_pass = WEBrick::HTTPAuth::Htdigest.new(tmpfile.path)
-      tmp_pass.set_passwd(realm, "webrick", "supersecretpassword")
-      tmp_pass.set_passwd(realm, "foo", "supersecretpassword")
-      tmp_pass.flush
-
-      htdigest = WEBrick::HTTPAuth::Htdigest.new(tmpfile.path)
-      users = []
-      htdigest.each{|user, pass| users << user }
-      assert_equal(2, users.size, log.call)
-      assert(users.member?("webrick"), log.call)
-      assert(users.member?("foo"), log.call)
-
-      auth = WEBrick::HTTPAuth::DigestAuth.new(
-        :Realm => realm, :UserDB => htdigest,
-        :Algorithm => 'MD5',
-        :Logger => server.logger
-      )
-      server.mount_proc(path){|req, res|
-        auth.authenticate(req, res)
-        res.body = "hoge"
-      }
-
-      Net::HTTP.start(addr, port) do |http|
-        g = Net::HTTP::Get.new(path)
-        params = {}
-        http.request(g) do |res|
-          assert_equal('401', res.code, log.call)
-          res["www-authenticate"].scan(DIGESTRES_) do |key, quoted, token|
-            params[key.downcase] = token || quoted.delete('\\')
-          end
-           params['uri'] = "http://#{addr}:#{port}#{path}"
-        end
-
-        g['Authorization'] = credentials_for_request('webrick', "supersecretpassword", params)
-        http.request(g){|res| assert_equal("hoge", res.body, log.call)}
-
-        params['algorithm'].downcase! #4936
-        g['Authorization'] = credentials_for_request('webrick', "supersecretpassword", params)
-        http.request(g){|res| assert_equal("hoge", res.body, log.call)}
-
-        g['Authorization'] = credentials_for_request('webrick', "not super", params)
-        http.request(g){|res| assert_not_equal("hoge", res.body, log.call)}
-      end
-    }
-  end
-
-  private
-  def credentials_for_request(user, password, params)
-    cnonce = "hoge"
-    nonce_count = 1
-    ha1 = "#{user}:#{params['realm']}:#{password}"
-    ha2 = "GET:#{params['uri']}"
-    request_digest =
-      "#{Digest::MD5.hexdigest(ha1)}:" \
-      "#{params['nonce']}:#{'%08x' % nonce_count}:#{cnonce}:#{params['qop']}:" \
-      "#{Digest::MD5.hexdigest(ha2)}"
-    "Digest username=\"#{user}\"" \
-      ", realm=\"#{params['realm']}\"" \
-      ", nonce=\"#{params['nonce']}\"" \
-      ", uri=\"#{params['uri']}\"" \
-      ", qop=#{params['qop']}" \
-      ", nc=#{'%08x' % nonce_count}" \
-      ", cnonce=\"#{cnonce}\"" \
-      ", response=\"#{Digest::MD5.hexdigest(request_digest)}\"" \
-      ", opaque=\"#{params['opaque']}\"" \
-      ", algorithm=#{params['algorithm']}"
-  end
-end

data/test/webrick/test_httpproxy.rb

@@ -1,282 +0,0 @@
-require "test/unit"
-require "net/http"
-require "webrick"
-require "webrick/httpproxy"
-begin
-  require "webrick/ssl"
-  require "net/https"
-  require File.expand_path("../openssl/utils.rb", File.dirname(__FILE__))
-rescue LoadError
-  # test_connect will be skipped
-end
-require File.expand_path("utils.rb", File.dirname(__FILE__))
-
-class TestWEBrickHTTPProxy < Test::Unit::TestCase
-  def test_fake_proxy
-    assert_nil(WEBrick::FakeProxyURI.scheme)
-    assert_nil(WEBrick::FakeProxyURI.host)
-    assert_nil(WEBrick::FakeProxyURI.port)
-    assert_nil(WEBrick::FakeProxyURI.path)
-    assert_nil(WEBrick::FakeProxyURI.userinfo)
-    assert_raise(NoMethodError){ WEBrick::FakeProxyURI.foo }
-  end
-
-  def test_proxy
-    # Testing GET or POST to the proxy server
-    # Note that the proxy server works as the origin server.
-    #                    +------+
-    #                    V      |
-    #  client -------> proxy ---+
-    #        GET / POST     GET / POST
-    #
-    proxy_handler_called = request_handler_called = 0
-    config = {
-      :ServerName => "localhost.localdomain",
-      :ProxyContentHandler => Proc.new{|req, res| proxy_handler_called += 1 },
-      :RequestCallback => Proc.new{|req, res| request_handler_called += 1 }
-    }
-    TestWEBrick.start_httpproxy(config){|server, addr, port, log|
-      server.mount_proc("/"){|req, res|
-        res.body = "#{req.request_method} #{req.path} #{req.body}"
-      }
-      http = Net::HTTP.new(addr, port, addr, port)
-
-      req = Net::HTTP::Get.new("/")
-      http.request(req){|res|
-        assert_equal("1.1 localhost.localdomain:#{port}", res["via"], log.call)
-        assert_equal("GET / ", res.body, log.call)
-      }
-      assert_equal(1, proxy_handler_called, log.call)
-      assert_equal(2, request_handler_called, log.call)
-
-      req = Net::HTTP::Head.new("/")
-      http.request(req){|res|
-        assert_equal("1.1 localhost.localdomain:#{port}", res["via"], log.call)
-        assert_nil(res.body, log.call)
-      }
-      assert_equal(2, proxy_handler_called, log.call)
-      assert_equal(4, request_handler_called, log.call)
-
-      req = Net::HTTP::Post.new("/")
-      req.body = "post-data"
-      http.request(req){|res|
-        assert_equal("1.1 localhost.localdomain:#{port}", res["via"], log.call)
-        assert_equal("POST / post-data", res.body, log.call)
-      }
-      assert_equal(3, proxy_handler_called, log.call)
-      assert_equal(6, request_handler_called, log.call)
-    }
-  end
-
-  def test_no_proxy
-    # Testing GET or POST to the proxy server without proxy request.
-    #
-    #  client -------> proxy
-    #        GET / POST
-    #
-    proxy_handler_called = request_handler_called = 0
-    config = {
-      :ServerName => "localhost.localdomain",
-      :ProxyContentHandler => Proc.new{|req, res| proxy_handler_called += 1 },
-      :RequestCallback => Proc.new{|req, res| request_handler_called += 1 }
-    }
-    TestWEBrick.start_httpproxy(config){|server, addr, port, log|
-      server.mount_proc("/"){|req, res|
-        res.body = "#{req.request_method} #{req.path} #{req.body}"
-      }
-      http = Net::HTTP.new(addr, port)
-
-      req = Net::HTTP::Get.new("/")
-      http.request(req){|res|
-        assert_nil(res["via"], log.call)
-        assert_equal("GET / ", res.body, log.call)
-      }
-      assert_equal(0, proxy_handler_called, log.call)
-      assert_equal(1, request_handler_called, log.call)
-
-      req = Net::HTTP::Head.new("/")
-      http.request(req){|res|
-        assert_nil(res["via"], log.call)
-        assert_nil(res.body, log.call)
-      }
-      assert_equal(0, proxy_handler_called, log.call)
-      assert_equal(2, request_handler_called, log.call)
-
-      req = Net::HTTP::Post.new("/")
-      req.body = "post-data"
-      http.request(req){|res|
-        assert_nil(res["via"], log.call)
-        assert_equal("POST / post-data", res.body, log.call)
-      }
-      assert_equal(0, proxy_handler_called, log.call)
-      assert_equal(3, request_handler_called, log.call)
-    }
-  end
-
-  def make_certificate(key, cn)
-    subject = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=#{cn}")
-    exts = [
-      ["keyUsage", "keyEncipherment,digitalSignature", true],
-    ]
-    cert = OpenSSL::TestUtils.issue_cert(
-      subject, key, 1, Time.now, Time.now + 3600, exts,
-      nil, nil, OpenSSL::Digest::SHA1.new
-    )
-    return cert
-  end
-
-  def test_connect
-    # Testing CONNECT to proxy server
-    #
-    #  client -----------> proxy -----------> https
-    #    1.     CONNECT          establish TCP
-    #    2.   ---- establish SSL session --->
-    #    3.   ------- GET or POST ---------->
-    #
-    key = OpenSSL::TestUtils::TEST_KEY_RSA1024
-    cert = make_certificate(key, "127.0.0.1")
-    s_config = {
-      :SSLEnable =>true,
-      :ServerName => "localhost",
-      :SSLCertificate => cert,
-      :SSLPrivateKey => key,
-    }
-    config = {
-      :ServerName => "localhost.localdomain",
-      :RequestCallback => Proc.new{|req, res|
-        assert_equal("CONNECT", req.request_method)
-      },
-    }
-    TestWEBrick.start_httpserver(s_config){|s_server, s_addr, s_port, s_log|
-      s_server.mount_proc("/"){|req, res|
-        res.body = "SSL #{req.request_method} #{req.path} #{req.body}"
-      }
-      TestWEBrick.start_httpproxy(config){|server, addr, port, log|
-        http = Net::HTTP.new("127.0.0.1", s_port, addr, port)
-        http.use_ssl = true
-        http.verify_callback = Proc.new do |preverify_ok, store_ctx|
-          store_ctx.current_cert.to_der == cert.to_der
-        end
-
-        req = Net::HTTP::Get.new("/")
-        http.request(req){|res|
-          assert_equal("SSL GET / ", res.body, s_log.call + log.call)
-        }
-
-        req = Net::HTTP::Post.new("/")
-        req.body = "post-data"
-        http.request(req){|res|
-          assert_equal("SSL POST / post-data", res.body, s_log.call + log.call)
-        }
-      }
-    }
-  end if defined?(OpenSSL)
-
-  def test_upstream_proxy
-    # Testing GET or POST through the upstream proxy server
-    # Note that the upstream proxy server works as the origin server.
-    #                                   +------+
-    #                                   V      |
-    #  client -------> proxy -------> proxy ---+
-    #        GET / POST     GET / POST     GET / POST
-    #
-    up_proxy_handler_called = up_request_handler_called = 0
-    proxy_handler_called = request_handler_called = 0
-    up_config = {
-      :ServerName => "localhost.localdomain",
-      :ProxyContentHandler => Proc.new{|req, res| up_proxy_handler_called += 1},
-      :RequestCallback => Proc.new{|req, res| up_request_handler_called += 1}
-    }
-    TestWEBrick.start_httpproxy(up_config){|up_server, up_addr, up_port, up_log|
-      up_server.mount_proc("/"){|req, res|
-        res.body = "#{req.request_method} #{req.path} #{req.body}"
-      }
-      config = {
-        :ServerName => "localhost.localdomain",
-        :ProxyURI => URI.parse("http://localhost:#{up_port}"),
-        :ProxyContentHandler => Proc.new{|req, res| proxy_handler_called += 1},
-        :RequestCallback => Proc.new{|req, res| request_handler_called += 1},
-      }
-      TestWEBrick.start_httpproxy(config){|server, addr, port, log|
-        http = Net::HTTP.new(up_addr, up_port, addr, port)
-
-        req = Net::HTTP::Get.new("/")
-        http.request(req){|res|
-          skip res.message unless res.code == '200'
-          via = res["via"].split(/,\s+/)
-          assert(via.include?("1.1 localhost.localdomain:#{up_port}"), up_log.call + log.call)
-          assert(via.include?("1.1 localhost.localdomain:#{port}"), up_log.call + log.call)
-          assert_equal("GET / ", res.body)
-        }
-        assert_equal(1, up_proxy_handler_called, up_log.call + log.call)
-        assert_equal(2, up_request_handler_called, up_log.call + log.call)
-        assert_equal(1, proxy_handler_called, up_log.call + log.call)
-        assert_equal(1, request_handler_called, up_log.call + log.call)
-
-        req = Net::HTTP::Head.new("/")
-        http.request(req){|res|
-          via = res["via"].split(/,\s+/)
-          assert(via.include?("1.1 localhost.localdomain:#{up_port}"), up_log.call + log.call)
-          assert(via.include?("1.1 localhost.localdomain:#{port}"), up_log.call + log.call)
-          assert_nil(res.body, up_log.call + log.call)
-        }
-        assert_equal(2, up_proxy_handler_called, up_log.call + log.call)
-        assert_equal(4, up_request_handler_called, up_log.call + log.call)
-        assert_equal(2, proxy_handler_called, up_log.call + log.call)
-        assert_equal(2, request_handler_called, up_log.call + log.call)
-
-        req = Net::HTTP::Post.new("/")
-        req.body = "post-data"
-        http.request(req){|res|
-          via = res["via"].split(/,\s+/)
-          assert(via.include?("1.1 localhost.localdomain:#{up_port}"), up_log.call + log.call)
-          assert(via.include?("1.1 localhost.localdomain:#{port}"), up_log.call + log.call)
-          assert_equal("POST / post-data", res.body, up_log.call + log.call)
-        }
-        assert_equal(3, up_proxy_handler_called, up_log.call + log.call)
-        assert_equal(6, up_request_handler_called, up_log.call + log.call)
-        assert_equal(3, proxy_handler_called, up_log.call + log.call)
-        assert_equal(3, request_handler_called, up_log.call + log.call)
-
-        if defined?(OpenSSL)
-          # Testing CONNECT to the upstream proxy server
-          #
-          #  client -------> proxy -------> proxy -------> https
-          #    1.   CONNECT        CONNECT      establish TCP
-          #    2.   -------- establish SSL session ------>
-          #    3.   ---------- GET or POST -------------->
-          #
-          key = OpenSSL::TestUtils::TEST_KEY_RSA1024
-          cert = make_certificate(key, "127.0.0.1")
-          s_config = {
-            :SSLEnable =>true,
-            :ServerName => "localhost",
-            :SSLCertificate => cert,
-            :SSLPrivateKey => key,
-          }
-          TestWEBrick.start_httpserver(s_config){|s_server, s_addr, s_port, s_log|
-            s_server.mount_proc("/"){|req2, res|
-              res.body = "SSL #{req2.request_method} #{req2.path} #{req2.body}"
-            }
-            http = Net::HTTP.new("127.0.0.1", s_port, addr, port, up_log.call + log.call + s_log.call)
-            http.use_ssl = true
-            http.verify_callback = Proc.new do |preverify_ok, store_ctx|
-              store_ctx.current_cert.to_der == cert.to_der
-            end
-
-            req2 = Net::HTTP::Get.new("/")
-            http.request(req2){|res|
-              assert_equal("SSL GET / ", res.body, up_log.call + log.call + s_log.call)
-            }
-
-            req2 = Net::HTTP::Post.new("/")
-            req2.body = "post-data"
-            http.request(req2){|res|
-              assert_equal("SSL POST / post-data", res.body, up_log.call + log.call + s_log.call)
-            }
-          }
-        end
-      }
-    }
-  end
-end

data/test/webrick/test_httprequest.rb

@@ -1,411 +0,0 @@
-require "webrick"
-require "stringio"
-require "test/unit"
-
-class TestWEBrickHTTPRequest < Test::Unit::TestCase
-  def test_simple_request
-    msg = <<-_end_of_message_
-GET /
-    _end_of_message_
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg))
-    assert(req.meta_vars) # fails if @header was not initialized and iteration is attempted on the nil reference
-  end
-
-  def test_parse_09
-    msg = <<-_end_of_message_
-      GET /
-      foobar    # HTTP/0.9 request don't have header nor entity body.
-    _end_of_message_
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-    assert_equal("GET", req.request_method)
-    assert_equal("/", req.unparsed_uri)
-    assert_equal(WEBrick::HTTPVersion.new("0.9"), req.http_version)
-    assert_equal(WEBrick::Config::HTTP[:ServerName], req.host)
-    assert_equal(80, req.port)
-    assert_equal(false, req.keep_alive?)
-    assert_equal(nil, req.body)
-    assert(req.query.empty?)
-  end
-
-  def test_parse_10
-    msg = <<-_end_of_message_
-      GET / HTTP/1.0
-
-    _end_of_message_
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-    assert_equal("GET", req.request_method)
-    assert_equal("/", req.unparsed_uri)
-    assert_equal(WEBrick::HTTPVersion.new("1.0"), req.http_version)
-    assert_equal(WEBrick::Config::HTTP[:ServerName], req.host)
-    assert_equal(80, req.port)
-    assert_equal(false, req.keep_alive?)
-    assert_equal(nil, req.body)
-    assert(req.query.empty?)
-  end
-
-  def test_parse_11
-    msg = <<-_end_of_message_
-      GET /path HTTP/1.1
-
-    _end_of_message_
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-    assert_equal("GET", req.request_method)
-    assert_equal("/path", req.unparsed_uri)
-    assert_equal("", req.script_name)
-    assert_equal("/path", req.path_info)
-    assert_equal(WEBrick::HTTPVersion.new("1.1"), req.http_version)
-    assert_equal(WEBrick::Config::HTTP[:ServerName], req.host)
-    assert_equal(80, req.port)
-    assert_equal(true, req.keep_alive?)
-    assert_equal(nil, req.body)
-    assert(req.query.empty?)
-  end
-
-  def test_request_uri_too_large
-    msg = <<-_end_of_message_
-      GET /#{"a"*2084} HTTP/1.1
-    _end_of_message_
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    assert_raise(WEBrick::HTTPStatus::RequestURITooLarge){
-      req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-    }
-  end
-
-  def test_parse_headers
-    msg = <<-_end_of_message_
-      GET /path HTTP/1.1
-      Host: test.ruby-lang.org:8080
-      Connection: close
-      Accept: text/*;q=0.3, text/html;q=0.7, text/html;level=1,
-              text/html;level=2;q=0.4, */*;q=0.5
-      Accept-Encoding: compress;q=0.5
-      Accept-Encoding: gzip;q=1.0, identity; q=0.4, *;q=0
-      Accept-Language: en;q=0.5, *; q=0
-      Accept-Language: ja
-      Content-Type: text/plain
-      Content-Length: 7
-      X-Empty-Header:
-
-      foobar
-    _end_of_message_
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-    assert_equal(
-      URI.parse("http://test.ruby-lang.org:8080/path"), req.request_uri)
-    assert_equal("test.ruby-lang.org", req.host)
-    assert_equal(8080, req.port)
-    assert_equal(false, req.keep_alive?)
-    assert_equal(
-      %w(text/html;level=1 text/html */* text/html;level=2 text/*),
-      req.accept)
-    assert_equal(%w(gzip compress identity *), req.accept_encoding)
-    assert_equal(%w(ja en *), req.accept_language)
-    assert_equal(7, req.content_length)
-    assert_equal("text/plain", req.content_type)
-    assert_equal("foobar\n", req.body)
-    assert_equal("", req["x-empty-header"])
-    assert_equal(nil, req["x-no-header"])
-    assert(req.query.empty?)
-  end
-
-  def test_parse_header2()
-    msg = <<-_end_of_message_
-      POST /foo/bar/../baz?q=a HTTP/1.0
-      Content-Length: 9
-      User-Agent:
-        FOO   BAR
-        BAZ
-
-      hogehoge
-    _end_of_message_
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-    assert_equal("POST", req.request_method)
-    assert_equal("/foo/baz", req.path)
-    assert_equal("", req.script_name)
-    assert_equal("/foo/baz", req.path_info)
-    assert_equal("9", req['content-length'])
-    assert_equal("FOO BAR BAZ", req['user-agent'])
-    assert_equal("hogehoge\n", req.body)
-  end
-
-  def test_parse_headers3
-    msg = <<-_end_of_message_
-      GET /path HTTP/1.1
-      Host: test.ruby-lang.org
-
-    _end_of_message_
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-    assert_equal(URI.parse("http://test.ruby-lang.org/path"), req.request_uri)
-    assert_equal("test.ruby-lang.org", req.host)
-    assert_equal(80, req.port)
-
-    msg = <<-_end_of_message_
-      GET /path HTTP/1.1
-      Host: 192.168.1.1
-
-    _end_of_message_
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-    assert_equal(URI.parse("http://192.168.1.1/path"), req.request_uri)
-    assert_equal("192.168.1.1", req.host)
-    assert_equal(80, req.port)
-
-    msg = <<-_end_of_message_
-      GET /path HTTP/1.1
-      Host: [fe80::208:dff:feef:98c7]
-
-    _end_of_message_
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-    assert_equal(URI.parse("http://[fe80::208:dff:feef:98c7]/path"),
-                 req.request_uri)
-    assert_equal("[fe80::208:dff:feef:98c7]", req.host)
-    assert_equal(80, req.port)
-
-    msg = <<-_end_of_message_
-      GET /path HTTP/1.1
-      Host: 192.168.1.1:8080
-
-    _end_of_message_
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-    assert_equal(URI.parse("http://192.168.1.1:8080/path"), req.request_uri)
-    assert_equal("192.168.1.1", req.host)
-    assert_equal(8080, req.port)
-
-    msg = <<-_end_of_message_
-      GET /path HTTP/1.1
-      Host: [fe80::208:dff:feef:98c7]:8080
-
-    _end_of_message_
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-    assert_equal(URI.parse("http://[fe80::208:dff:feef:98c7]:8080/path"),
-                 req.request_uri)
-    assert_equal("[fe80::208:dff:feef:98c7]", req.host)
-    assert_equal(8080, req.port)
-  end
-
-  def test_parse_get_params
-    param = "foo=1;foo=2;foo=3;bar=x"
-    msg = <<-_end_of_message_
-      GET /path?#{param} HTTP/1.1
-      Host: test.ruby-lang.org:8080
-
-    _end_of_message_
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-    query = req.query
-    assert_equal("1", query["foo"])
-    assert_equal(["1", "2", "3"], query["foo"].to_ary)
-    assert_equal(["1", "2", "3"], query["foo"].list)
-    assert_equal("x", query["bar"])
-    assert_equal(["x"], query["bar"].list)
-  end
-
-  def test_parse_post_params
-    param = "foo=1;foo=2;foo=3;bar=x"
-    msg = <<-_end_of_message_
-      POST /path?foo=x;foo=y;foo=z;bar=1 HTTP/1.1
-      Host: test.ruby-lang.org:8080
-      Content-Length: #{param.size}
-      Content-Type: application/x-www-form-urlencoded
-
-      #{param}
-    _end_of_message_
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-    query = req.query
-    assert_equal("1", query["foo"])
-    assert_equal(["1", "2", "3"], query["foo"].to_ary)
-    assert_equal(["1", "2", "3"], query["foo"].list)
-    assert_equal("x", query["bar"])
-    assert_equal(["x"], query["bar"].list)
-  end
-
-  def test_chunked
-    crlf = "\x0d\x0a"
-    msg = <<-_end_of_message_
-      POST /path HTTP/1.1
-      Host: test.ruby-lang.org:8080
-      Transfer-Encoding: chunked
-
-    _end_of_message_
-    msg.gsub!(/^ {6}/, "")
-    open(__FILE__){|io|
-      while chunk = io.read(100)
-        msg << chunk.size.to_s(16) << crlf
-        msg << chunk << crlf
-      end
-    }
-    msg << "0" << crlf
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg))
-    assert_equal(File.read(__FILE__), req.body)
-  end
-
-  def test_forwarded
-    msg = <<-_end_of_message_
-      GET /foo HTTP/1.1
-      Host: localhost:10080
-      User-Agent: w3m/0.5.2
-      X-Forwarded-For: 123.123.123.123
-      X-Forwarded-Host: forward.example.com
-      X-Forwarded-Server: server.example.com
-      Connection: Keep-Alive
-
-    _end_of_message_
-    msg.gsub!(/^ {6}/, "")
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg))
-    assert_equal("server.example.com", req.server_name)
-    assert_equal("http://forward.example.com/foo", req.request_uri.to_s)
-    assert_equal("forward.example.com", req.host)
-    assert_equal(80, req.port)
-    assert_equal("123.123.123.123", req.remote_ip)
-    assert(!req.ssl?)
-
-    msg = <<-_end_of_message_
-      GET /foo HTTP/1.1
-      Host: localhost:10080
-      User-Agent: w3m/0.5.2
-      X-Forwarded-For: 192.168.1.10, 172.16.1.1, 123.123.123.123
-      X-Forwarded-Host: forward.example.com:8080
-      X-Forwarded-Server: server.example.com
-      Connection: Keep-Alive
-
-    _end_of_message_
-    msg.gsub!(/^ {6}/, "")
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg))
-    assert_equal("server.example.com", req.server_name)
-    assert_equal("http://forward.example.com:8080/foo", req.request_uri.to_s)
-    assert_equal("forward.example.com", req.host)
-    assert_equal(8080, req.port)
-    assert_equal("123.123.123.123", req.remote_ip)
-    assert(!req.ssl?)
-
-    msg = <<-_end_of_message_
-      GET /foo HTTP/1.1
-      Host: localhost:10080
-      Client-IP: 234.234.234.234
-      X-Forwarded-Proto: https
-      X-Forwarded-For: 192.168.1.10, 10.0.0.1, 123.123.123.123
-      X-Forwarded-Host: forward.example.com
-      X-Forwarded-Server: server.example.com
-      X-Requested-With: XMLHttpRequest
-      Connection: Keep-Alive
-
-    _end_of_message_
-    msg.gsub!(/^ {6}/, "")
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg))
-    assert_equal("server.example.com", req.server_name)
-    assert_equal("https://forward.example.com/foo", req.request_uri.to_s)
-    assert_equal("forward.example.com", req.host)
-    assert_equal(443, req.port)
-    assert_equal("234.234.234.234", req.remote_ip)
-    assert(req.ssl?)
-
-    msg = <<-_end_of_message_
-      GET /foo HTTP/1.1
-      Host: localhost:10080
-      Client-IP: 234.234.234.234
-      X-Forwarded-Proto: https
-      X-Forwarded-For: 192.168.1.10
-      X-Forwarded-Host: forward1.example.com:1234, forward2.example.com:5678
-      X-Forwarded-Server: server1.example.com, server2.example.com
-      X-Requested-With: XMLHttpRequest
-      Connection: Keep-Alive
-
-    _end_of_message_
-    msg.gsub!(/^ {6}/, "")
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg))
-    assert_equal("server1.example.com", req.server_name)
-    assert_equal("https://forward1.example.com:1234/foo", req.request_uri.to_s)
-    assert_equal("forward1.example.com", req.host)
-    assert_equal(1234, req.port)
-    assert_equal("234.234.234.234", req.remote_ip)
-    assert(req.ssl?)
-  end
-
-  def test_continue_sent
-    msg = <<-_end_of_message_
-      POST /path HTTP/1.1
-      Expect: 100-continue
-
-    _end_of_message_
-    msg.gsub!(/^ {6}/, "")
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg))
-    assert req['expect']
-    l = msg.size
-    req.continue
-    assert_not_equal l, msg.size
-    assert_match /HTTP\/1.1 100 continue\r\n\r\n\z/, msg
-    assert !req['expect']
-  end
-
-  def test_continue_not_sent
-    msg = <<-_end_of_message_
-      POST /path HTTP/1.1
-
-    _end_of_message_
-    msg.gsub!(/^ {6}/, "")
-    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-    req.parse(StringIO.new(msg))
-    assert !req['expect']
-    l = msg.size
-    req.continue
-    assert_equal l, msg.size
-  end
-
-  def test_bad_messages
-    param = "foo=1;foo=2;foo=3;bar=x"
-    msg = <<-_end_of_message_
-      POST /path?foo=x;foo=y;foo=z;bar=1 HTTP/1.1
-      Host: test.ruby-lang.org:8080
-      Content-Type: application/x-www-form-urlencoded
-
-      #{param}
-    _end_of_message_
-    assert_raise(WEBrick::HTTPStatus::LengthRequired){
-      req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-      req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-      req.body
-    }
-
-    msg = <<-_end_of_message_
-      POST /path?foo=x;foo=y;foo=z;bar=1 HTTP/1.1
-      Host: test.ruby-lang.org:8080
-      Content-Length: 100000
-
-      body is too short.
-    _end_of_message_
-    assert_raise(WEBrick::HTTPStatus::BadRequest){
-      req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-      req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-      req.body
-    }
-
-    msg = <<-_end_of_message_
-      POST /path?foo=x;foo=y;foo=z;bar=1 HTTP/1.1
-      Host: test.ruby-lang.org:8080
-      Transfer-Encoding: foobar
-
-      body is too short.
-    _end_of_message_
-    assert_raise(WEBrick::HTTPStatus::NotImplemented){
-      req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
-      req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
-      req.body
-    }
-  end
-end