This commit was manufactured by cvs2svn to create branch 'ruby_1_8'.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_8@7783 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

sample/webrick/httpproxy.rb

@@ -0,0 +1,26 @@
+require "webrick"
+require "webrick/httpproxy"
+
+# :ProxyContentHandler will be invoked before sending
+# response to User-Agenge. You can inspect the pair of
+# request and response messages (or can edit the response
+# message if necessary).
+
+pch = Proc.new{|req, res|
+  p [ req.request_line, res.status_line ]
+}
+
+def upstream_proxy
+  if prx = ENV["http_proxy"]
+    return URI.parse(prx)
+  end
+  return nil
+end
+
+httpd = WEBrick::HTTPProxyServer.new(
+  :Port     => 10080,
+  :ProxyContentHandler => pch,
+  :ProxyURI => upstream_proxy
+)
+Signal.trap(:INT){ httpd.shutdown }
+httpd.start

test/webrick/test_cgi.rb

@@ -0,0 +1,46 @@
+require "webrick"
+require File.join(File.dirname(__FILE__), "utils.rb")
+require "test/unit"
+begin
+  loadpath = $:.dup
+  $:.replace($: | [File.expand_path("../ruby", File.dirname(__FILE__))])
+  require 'envutil'
+ensure
+  $:.replace(loadpath)
+end
+
+class TestWEBrickCGI < Test::Unit::TestCase
+  def test_cgi
+    accepted = started = stopped = 0
+    requested0 = requested1 = 0
+    config = {
+      :CGIInterpreter => EnvUtil.rubybin,
+      :DocumentRoot => File.dirname(__FILE__),
+    }
+    TestWEBrick.start_httpserver(config){|server, addr, port|
+      http = Net::HTTP.new(addr, port)
+      req = Net::HTTP::Get.new("/webrick.cgi")
+      http.request(req){|res| assert_equal("/webrick.cgi", res.body)}
+      req = Net::HTTP::Get.new("/webrick.cgi/path/info")
+      http.request(req){|res| assert_equal("/path/info", res.body)}
+      req = Net::HTTP::Get.new("/webrick.cgi/%3F%3F%3F?foo=bar")
+      http.request(req){|res| assert_equal("/???", res.body)}
+      req = Net::HTTP::Get.new("/webrick.cgi/%A4%DB%A4%B2/%A4%DB%A4%B2")
+      http.request(req){|res|
+        assert_equal("/\xA4\xDB\xA4\xB2/\xA4\xDB\xA4\xB2", res.body)}
+      req = Net::HTTP::Get.new("/webrick.cgi?a=1;a=2;b=x")
+      http.request(req){|res| assert_equal("a=1, a=2, b=x", res.body)}
+      req = Net::HTTP::Get.new("/webrick.cgi?a=1&a=2&b=x")
+      http.request(req){|res| assert_equal("a=1, a=2, b=x", res.body)}
+
+      req = Net::HTTP::Post.new("/webrick.cgi?a=x;a=y;b=1")
+      req["Content-Type"] = "application/x-www-form-urlencoded"
+      http.request(req, "a=1;a=2;b=x"){|res|
+        assert_equal("a=1, a=2, b=x", res.body)}
+      req = Net::HTTP::Post.new("/webrick.cgi?a=x&a=y&b=1")
+      req["Content-Type"] = "application/x-www-form-urlencoded"
+      http.request(req, "a=1&a=2&b=x"){|res|
+        assert_equal("a=1, a=2, b=x", res.body)}
+    }
+  end
+end

test/webrick/test_cookie.rb

@@ -0,0 +1,56 @@
+require "test/unit"
+require "webrick/cookie"
+
+class TestWEBrickCookie < Test::Unit::TestCase
+  def test_new
+    cookie = WEBrick::Cookie.new("foo","bar")
+    assert_equal("foo", cookie.name)
+    assert_equal("bar", cookie.value)
+    assert_equal("foo=bar", cookie.to_s)
+  end
+
+  def test_time
+    cookie = WEBrick::Cookie.new("foo","bar")
+    t = 1000000000
+    cookie.max_age = t
+    assert_match(t.to_s, cookie.to_s)
+
+    cookie = WEBrick::Cookie.new("foo","bar")
+    t = Time.at(1000000000)
+    cookie.expires = t
+    assert_equal(Time, cookie.expires.class)
+    assert_equal(t, cookie.expires)
+    ts = t.httpdate
+    cookie.expires = ts
+    assert_equal(Time, cookie.expires.class)
+    assert_equal(t, cookie.expires)
+    assert_match(ts, cookie.to_s)
+  end
+
+  def test_parse
+    data = ""
+    data << '$Version="1"; '
+    data << 'Customer="WILE_E_COYOTE"; $Path="/acme"; '
+    data << 'Part_Number="Rocket_Launcher_0001"; $Path="/acme"; '
+    data << 'Shipping="FedEx"; $Path="/acme"'
+    cookies = WEBrick::Cookie.parse(data)
+    assert_equal(1, cookies[0].version)
+    assert_equal("Customer", cookies[0].name)
+    assert_equal("WILE_E_COYOTE", cookies[0].value)
+    assert_equal("/acme", cookies[0].path)
+    assert_equal(1, cookies[1].version)
+    assert_equal("Part_Number", cookies[1].name)
+    assert_equal("Rocket_Launcher_0001", cookies[1].value)
+    assert_equal(1, cookies[2].version)
+    assert_equal("Shipping", cookies[2].name)
+    assert_equal("FedEx", cookies[2].value)
+
+    data = "hoge=moge; __div__session=9865ecfd514be7f7"
+    cookies = WEBrick::Cookie.parse(data)
+    assert_equal(0, cookies[0].version)
+    assert_equal("hoge", cookies[0].name)
+    assert_equal("moge", cookies[0].value)
+    assert_equal("__div__session", cookies[1].name)
+    assert_equal("9865ecfd514be7f7", cookies[1].value)
+  end
+end

test/webrick/test_filehandler.rb

@@ -0,0 +1,65 @@
+require "test/unit"
+require "webrick"
+require "stringio"
+
+class WEBrick::TestFileHandler < Test::Unit::TestCase
+  def default_file_handler(filename)
+    klass = WEBrick::HTTPServlet::DefaultFileHandler
+    klass.new(WEBrick::Config::HTTP, filename)
+  end
+
+  def get_res_body(res)
+    return res.body.read rescue res.body
+  end
+
+  def make_range_request(range_spec)
+    msg = <<-_end_of_request_
+      GET / HTTP/1.0
+      Range: #{range_spec}
+
+    _end_of_request_
+    return StringIO.new(msg.gsub(/^ {6}/, ""))
+  end
+
+  def make_range_response(file, range_spec)
+    req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+    req.parse(make_range_request(range_spec))
+    res = WEBrick::HTTPResponse.new(WEBrick::Config::HTTP)
+    size = File.size(file)
+    handler = default_file_handler(file)
+    handler.make_partial_content(req, res, file, size)
+    return res
+  end
+
+  def test_make_partial_content
+    filename = __FILE__
+    filesize = File.size(filename)
+
+    res = make_range_response(filename, "bytes=#{filesize-100}-")
+    assert_match(%r{^text/plain}, res["content-type"])
+    assert_equal(get_res_body(res).size, 100)
+
+    res = make_range_response(filename, "bytes=-100")
+    assert_match(%r{^text/plain}, res["content-type"])
+    assert_equal(get_res_body(res).size, 100)
+
+    res = make_range_response(filename, "bytes=0-99")
+    assert_match(%r{^text/plain}, res["content-type"])
+    assert_equal(get_res_body(res).size, 100)
+
+    res = make_range_response(filename, "bytes=100-199")
+    assert_match(%r{^text/plain}, res["content-type"])
+    assert_equal(get_res_body(res).size, 100)
+
+    res = make_range_response(filename, "bytes=0-0")
+    assert_match(%r{^text/plain}, res["content-type"])
+    assert_equal(get_res_body(res).size, 1)
+
+    res = make_range_response(filename, "bytes=-1")
+    assert_match(%r{^text/plain}, res["content-type"])
+    assert_equal(get_res_body(res).size, 1)
+
+    res = make_range_response(filename, "bytes=0-0, -2")
+    assert_match(%r{^multipart/byteranges}, res["content-type"])
+  end
+end

test/webrick/test_httprequest.rb

@@ -0,0 +1,214 @@
+require "webrick"
+require "stringio"
+require "test/unit"
+
+class TestWEBrickHTTPRequest < Test::Unit::TestCase
+  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_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
+
+      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(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_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_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_raises(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_raises(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_raises(WEBrick::HTTPStatus::NotImplemented){
+      req = WEBrick::HTTPRequest.new(WEBrick::Config::HTTP)
+      req.parse(StringIO.new(msg.gsub(/^ {6}/, "")))
+      req.body
+    }
+  end
+end

test/webrick/test_httpserver.rb

@@ -0,0 +1,260 @@
+require "test/unit"
+require "net/http"
+require "webrick"
+require File.join(File.dirname(__FILE__), "utils.rb")
+
+class TestWEBrickHTTPServer < Test::Unit::TestCase
+  def test_mount
+    httpd = WEBrick::HTTPServer.new(
+      :Logger => WEBrick::Log.new(TestWEBrick::NullWriter),
+      :DoNotListen=>true
+    )
+    httpd.mount("/", :Root)
+    httpd.mount("/foo", :Foo)
+    httpd.mount("/foo/bar", :Bar, :bar1)
+    httpd.mount("/foo/bar/baz", :Baz, :baz1, :baz2)
+
+    serv, opts, script_name, path_info = httpd.search_servlet("/")
+    assert_equal(:Root, serv)
+    assert_equal([], opts)
+    assert_equal(script_name, "")
+    assert_equal(path_info, "/")
+
+    serv, opts, script_name, path_info = httpd.search_servlet("/sub")
+    assert_equal(:Root, serv)
+    assert_equal([], opts)
+    assert_equal(script_name, "")
+    assert_equal(path_info, "/sub")
+
+    serv, opts, script_name, path_info = httpd.search_servlet("/sub/")
+    assert_equal(:Root, serv)
+    assert_equal([], opts)
+    assert_equal(script_name, "")
+    assert_equal(path_info, "/sub/")
+
+    serv, opts, script_name, path_info = httpd.search_servlet("/foo")
+    assert_equal(:Foo, serv)
+    assert_equal([], opts)
+    assert_equal(script_name, "/foo")
+    assert_equal(path_info, "")
+
+    serv, opts, script_name, path_info = httpd.search_servlet("/foo/")
+    assert_equal(:Foo, serv)
+    assert_equal([], opts)
+    assert_equal(script_name, "/foo")
+    assert_equal(path_info, "/")
+
+    serv, opts, script_name, path_info = httpd.search_servlet("/foo/sub")
+    assert_equal(:Foo, serv)
+    assert_equal([], opts)
+    assert_equal(script_name, "/foo")
+    assert_equal(path_info, "/sub")
+
+    serv, opts, script_name, path_info = httpd.search_servlet("/foo/bar")
+    assert_equal(:Bar, serv)
+    assert_equal([:bar1], opts)
+    assert_equal(script_name, "/foo/bar")
+    assert_equal(path_info, "")
+
+    serv, opts, script_name, path_info = httpd.search_servlet("/foo/bar/baz")
+    assert_equal(:Baz, serv)
+    assert_equal([:baz1, :baz2], opts)
+    assert_equal(script_name, "/foo/bar/baz")
+    assert_equal(path_info, "")
+  end
+
+  class Req
+    attr_reader :port, :host
+    def initialize(addr, port, host)
+      @addr, @port, @host = addr, port, host
+    end
+    def addr
+      [0,0,0,@addr]
+    end
+  end
+
+  def httpd(addr, port, host, ali)
+    config ={
+      :Logger      => WEBrick::Log.new(TestWEBrick::NullWriter),
+      :DoNotListen => true,
+      :BindAddress => addr,
+      :Port        => port,
+      :ServerName  => host,
+      :ServerAlias => ali,
+    }
+    return WEBrick::HTTPServer.new(config)
+  end
+
+  def assert_eql?(v1, v2)
+    assert_equal(v1.object_id, v2.object_id)
+  end
+
+  def test_lookup_server
+    addr1  = "192.168.100.1"
+    addr2  = "192.168.100.2"
+    addrz  = "192.168.100.254"
+    local  = "127.0.0.1"
+    port1  = 80
+    port2  = 8080
+    port3  = 10080
+    portz  = 32767
+    name1  = "www.example.com"
+    name2  = "www2.example.com"
+    name3  = "www3.example.com"
+    namea  = "www.example.co.jp"
+    nameb  = "www.example.jp"
+    namec  = "www2.example.co.jp"
+    named  = "www2.example.jp"
+    namez  = "foobar.example.com"
+    alias1 = [namea, nameb]
+    alias2 = [namec, named]
+
+    host1 = httpd(nil, port1, name1, nil)
+    hosts = [
+      host2  = httpd(addr1, port1, name1, nil),
+      host3  = httpd(addr1, port1, name2, alias1),
+      host4  = httpd(addr1, port2, name1, nil),
+      host5  = httpd(addr1, port2, name2, alias1),
+      host6  = httpd(addr1, port2, name3, alias2),
+      host7  = httpd(addr2, nil,   name1, nil),
+      host8  = httpd(addr2, nil,   name2, alias1),
+      host9  = httpd(addr2, nil,   name3, alias2),
+      host10 = httpd(local, nil,   nil,   nil),
+      host11 = httpd(nil,   port3, nil,   nil),
+    ].sort_by{ rand }
+    hosts.each{|h| host1.virtual_host(h) }
+
+    # connect to addr1
+    assert_eql?(host2,   host1.lookup_server(Req.new(addr1, port1, name1)))
+    assert_eql?(host3,   host1.lookup_server(Req.new(addr1, port1, name2)))
+    assert_eql?(host3,   host1.lookup_server(Req.new(addr1, port1, namea)))
+    assert_eql?(host3,   host1.lookup_server(Req.new(addr1, port1, nameb)))
+    assert_eql?(nil,     host1.lookup_server(Req.new(addr1, port1, namez)))
+    assert_eql?(host4,   host1.lookup_server(Req.new(addr1, port2, name1)))
+    assert_eql?(host5,   host1.lookup_server(Req.new(addr1, port2, name2)))
+    assert_eql?(host5,   host1.lookup_server(Req.new(addr1, port2, namea)))
+    assert_eql?(host5,   host1.lookup_server(Req.new(addr1, port2, nameb)))
+    assert_eql?(nil,     host1.lookup_server(Req.new(addr1, port2, namez)))
+    assert_eql?(host11,  host1.lookup_server(Req.new(addr1, port3, name1)))
+    assert_eql?(host11,  host1.lookup_server(Req.new(addr1, port3, name2)))
+    assert_eql?(host11,  host1.lookup_server(Req.new(addr1, port3, namea)))
+    assert_eql?(host11,  host1.lookup_server(Req.new(addr1, port3, nameb)))
+    assert_eql?(host11,  host1.lookup_server(Req.new(addr1, port3, namez)))
+    assert_eql?(nil,     host1.lookup_server(Req.new(addr1, portz, name1)))
+    assert_eql?(nil,     host1.lookup_server(Req.new(addr1, portz, name2)))
+    assert_eql?(nil,     host1.lookup_server(Req.new(addr1, portz, namea)))
+    assert_eql?(nil,     host1.lookup_server(Req.new(addr1, portz, nameb)))
+    assert_eql?(nil,     host1.lookup_server(Req.new(addr1, portz, namez)))
+
+    # connect to addr2
+    assert_eql?(host7,  host1.lookup_server(Req.new(addr2, port1, name1)))
+    assert_eql?(host8,  host1.lookup_server(Req.new(addr2, port1, name2)))
+    assert_eql?(host8,  host1.lookup_server(Req.new(addr2, port1, namea)))
+    assert_eql?(host8,  host1.lookup_server(Req.new(addr2, port1, nameb)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addr2, port1, namez)))
+    assert_eql?(host7,  host1.lookup_server(Req.new(addr2, port2, name1)))
+    assert_eql?(host8,  host1.lookup_server(Req.new(addr2, port2, name2)))
+    assert_eql?(host8,  host1.lookup_server(Req.new(addr2, port2, namea)))
+    assert_eql?(host8,  host1.lookup_server(Req.new(addr2, port2, nameb)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addr2, port2, namez)))
+    assert_eql?(host7,  host1.lookup_server(Req.new(addr2, port3, name1)))
+    assert_eql?(host8,  host1.lookup_server(Req.new(addr2, port3, name2)))
+    assert_eql?(host8,  host1.lookup_server(Req.new(addr2, port3, namea)))
+    assert_eql?(host8,  host1.lookup_server(Req.new(addr2, port3, nameb)))
+    assert_eql?(host11, host1.lookup_server(Req.new(addr2, port3, namez)))
+    assert_eql?(host7,  host1.lookup_server(Req.new(addr2, portz, name1)))
+    assert_eql?(host8,  host1.lookup_server(Req.new(addr2, portz, name2)))
+    assert_eql?(host8,  host1.lookup_server(Req.new(addr2, portz, namea)))
+    assert_eql?(host8,  host1.lookup_server(Req.new(addr2, portz, nameb)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addr2, portz, namez)))
+
+    # connect to addrz
+    assert_eql?(nil,    host1.lookup_server(Req.new(addrz, port1, name1)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addrz, port1, name2)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addrz, port1, namea)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addrz, port1, nameb)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addrz, port1, namez)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addrz, port2, name1)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addrz, port2, name2)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addrz, port2, namea)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addrz, port2, nameb)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addrz, port2, namez)))
+    assert_eql?(host11, host1.lookup_server(Req.new(addrz, port3, name1)))
+    assert_eql?(host11, host1.lookup_server(Req.new(addrz, port3, name2)))
+    assert_eql?(host11, host1.lookup_server(Req.new(addrz, port3, namea)))
+    assert_eql?(host11, host1.lookup_server(Req.new(addrz, port3, nameb)))
+    assert_eql?(host11, host1.lookup_server(Req.new(addrz, port3, namez)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addrz, portz, name1)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addrz, portz, name2)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addrz, portz, namea)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addrz, portz, nameb)))
+    assert_eql?(nil,    host1.lookup_server(Req.new(addrz, portz, namez)))
+
+    # connect to localhost
+    assert_eql?(host10, host1.lookup_server(Req.new(local, port1, name1)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, port1, name2)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, port1, namea)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, port1, nameb)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, port1, namez)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, port2, name1)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, port2, name2)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, port2, namea)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, port2, nameb)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, port2, namez)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, port3, name1)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, port3, name2)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, port3, namea)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, port3, nameb)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, port3, namez)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, portz, name1)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, portz, name2)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, portz, namea)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, portz, nameb)))
+    assert_eql?(host10, host1.lookup_server(Req.new(local, portz, namez)))
+  end
+
+  def test_callbacks
+    accepted = started = stopped = 0
+    requested0 = requested1 = 0
+    config = {
+      :ServerName => "localhost",
+      :AcceptCallback => Proc.new{ accepted += 1 },
+      :StartCallback => Proc.new{ started += 1 },
+      :StopCallback => Proc.new{ stopped += 1 },
+      :RequestCallback => Proc.new{|req, res| requested0 += 1 },
+    }
+    TestWEBrick.start_httpserver(config){|server, addr, port|
+      vhost_config = {
+        :ServerName => "myhostname",
+        :BindAddress => addr,
+        :Port => port,
+        :DoNotListen => true,
+        :Logger => WEBrick::Log.new(TestWEBrick::NullWriter),
+        :AccessLog => [],
+        :RequestCallback => Proc.new{|req, res| requested1 += 1 },
+      }
+      server.virtual_host(WEBrick::HTTPServer.new(vhost_config))
+
+      true while server.status != :Running
+      assert_equal(started, 1)
+      assert_equal(stopped, 0)
+      assert_equal(accepted, 0)
+
+      http = Net::HTTP.new(addr, port)
+      req = Net::HTTP::Get.new("/")
+      req["Host"] = "myhostname:#{port}"
+      http.request(req){|res| assert_equal("404", res.code)}
+      http.request(req){|res| assert_equal("404", res.code)}
+      http.request(req){|res| assert_equal("404", res.code)}
+      req["Host"] = "localhost:#{port}"
+      http.request(req){|res| assert_equal("404", res.code)}
+      http.request(req){|res| assert_equal("404", res.code)}
+      http.request(req){|res| assert_equal("404", res.code)}
+      assert_equal(6, accepted)
+      assert_equal(3, requested0)
+      assert_equal(3, requested1)
+    }
+    assert_equal(started, 1)
+    assert_equal(stopped, 1)
+  end
+end

test/webrick/test_httputils.rb

@@ -0,0 +1,90 @@
+require "test/unit"
+require "webrick/httputils"
+
+class TestWEBrickHTTPUtils < Test::Unit::TestCase
+  include WEBrick::HTTPUtils
+
+  def test_normilize_path
+    assert_equal("/foo",       normalize_path("/foo"))
+    assert_equal("/foo/bar/",  normalize_path("/foo/bar/"))
+
+    assert_equal("/",          normalize_path("/foo/../"))
+    assert_equal("/",          normalize_path("/foo/.."))
+    assert_equal("/",          normalize_path("/foo/bar/../../"))
+    assert_equal("/",          normalize_path("/foo/bar/../.."))
+    assert_equal("/",          normalize_path("/foo/bar/../.."))
+    assert_equal("/baz",       normalize_path("/foo/bar/../../baz"))
+    assert_equal("/baz",       normalize_path("/foo/../bar/../baz"))
+    assert_equal("/baz/",      normalize_path("/foo/../bar/../baz/"))
+    assert_equal("/...",       normalize_path("/bar/../..."))
+    assert_equal("/.../",      normalize_path("/bar/../.../"))
+
+    assert_equal("/foo/",      normalize_path("/foo/./"))
+    assert_equal("/foo/",      normalize_path("/foo/."))
+    assert_equal("/foo/",      normalize_path("/foo/././"))
+    assert_equal("/foo/",      normalize_path("/foo/./."))
+    assert_equal("/foo/bar",   normalize_path("/foo/./bar"))
+    assert_equal("/foo/bar/",  normalize_path("/foo/./bar/."))
+    assert_equal("/foo/bar/",  normalize_path("/./././foo/./bar/."))
+
+    assert_equal("/foo/bar/",  normalize_path("//foo///.//bar/.///.//"))
+    assert_equal("/",          normalize_path("//foo///..///bar/.///..//.//"))
+
+    assert_raises(RuntimeError){ normalize_path("foo/bar") }
+    assert_raises(RuntimeError){ normalize_path("..") }
+    assert_raises(RuntimeError){ normalize_path("/..") }
+    assert_raises(RuntimeError){ normalize_path("/./..") }
+    assert_raises(RuntimeError){ normalize_path("/./../") }
+    assert_raises(RuntimeError){ normalize_path("/./../..") }
+    assert_raises(RuntimeError){ normalize_path("/./../../") }
+    assert_raises(RuntimeError){ normalize_path("/./../") }
+    assert_raises(RuntimeError){ normalize_path("/../..") }
+    assert_raises(RuntimeError){ normalize_path("/../../") }
+    assert_raises(RuntimeError){ normalize_path("/../../..") }
+    assert_raises(RuntimeError){ normalize_path("/../../../") }
+    assert_raises(RuntimeError){ normalize_path("/../foo/../") }
+    assert_raises(RuntimeError){ normalize_path("/../foo/../../") }
+    assert_raises(RuntimeError){ normalize_path("/foo/bar/../../../../") }
+    assert_raises(RuntimeError){ normalize_path("/foo/../bar/../../") }
+    assert_raises(RuntimeError){ normalize_path("/./../bar/") }
+    assert_raises(RuntimeError){ normalize_path("/./../") }
+  end
+
+  def test_split_header_value
+    assert_equal(['foo', 'bar'], split_header_value('foo, bar'))
+    assert_equal(['"foo"', 'bar'], split_header_value('"foo", bar'))
+    assert_equal(['foo', '"bar"'], split_header_value('foo, "bar"'))
+    assert_equal(['*'], split_header_value('*'))
+    assert_equal(['W/"xyzzy"', 'W/"r2d2xxxx"', 'W/"c3piozzzz"'],
+                 split_header_value('W/"xyzzy", W/"r2d2xxxx", W/"c3piozzzz"'))
+  end
+
+  def test_escape
+    assert_equal("/foo/bar", escape("/foo/bar"))
+    assert_equal("/~foo/bar", escape("/~foo/bar"))
+    assert_equal("/~foo%20bar", escape("/~foo bar"))
+    assert_equal("/~foo%20bar", escape("/~foo bar"))
+    assert_equal("/~foo%09bar", escape("/~foo\tbar"))
+    assert_equal("/~foo+bar", escape("/~foo+bar"))
+  end
+
+  def test_escape_form
+    assert_equal("%2Ffoo%2Fbar", escape_form("/foo/bar"))
+    assert_equal("%2F~foo%2Fbar", escape_form("/~foo/bar"))
+    assert_equal("%2F~foo+bar", escape_form("/~foo bar"))
+    assert_equal("%2F~foo+%2B+bar", escape_form("/~foo + bar"))
+  end
+
+  def test_unescape
+    assert_equal("/foo/bar", unescape("%2ffoo%2fbar"))
+    assert_equal("/~foo/bar", unescape("/%7efoo/bar"))
+    assert_equal("/~foo/bar", unescape("%2f%7efoo%2fbar"))
+    assert_equal("/~foo+bar", unescape("/%7efoo+bar"))
+  end
+
+  def test_unescape_form
+    assert_equal("//foo/bar", unescape_form("/%2Ffoo/bar"))
+    assert_equal("//foo/bar baz", unescape_form("/%2Ffoo/bar+baz"))
+    assert_equal("/~foo/bar baz", unescape_form("/%7Efoo/bar+baz"))
+  end
+end

test/webrick/test_httpversion.rb

@@ -0,0 +1,40 @@
+require "test/unit"
+require "webrick/httpversion"
+
+class TestWEBrickHTTPVersion < Test::Unit::TestCase
+  def setup
+    @v09 = WEBrick::HTTPVersion.new("0.9")
+    @v10 = WEBrick::HTTPVersion.new("1.0")
+    @v11 = WEBrick::HTTPVersion.new("1.001")
+  end
+
+  def test_to_s()
+    assert_equal("0.9", @v09.to_s)
+    assert_equal("1.0", @v10.to_s)
+    assert_equal("1.1", @v11.to_s)
+  end
+
+  def test_major()
+    assert_equal(0, @v09.major)
+    assert_equal(1, @v10.major)
+    assert_equal(1, @v11.major)
+  end
+
+  def test_minor()
+    assert_equal(9, @v09.minor)
+    assert_equal(0, @v10.minor)
+    assert_equal(1, @v11.minor)
+  end
+
+  def test_compar()
+    assert_equal(0, @v09 <=> "0.9")
+    assert_equal(0, @v09 <=> "0.09")
+
+    assert_equal(-1, @v09 <=> @v10)
+    assert_equal(-1, @v09 <=> "1.00")
+
+    assert_equal(1, @v11 <=> @v09)
+    assert_equal(1, @v11 <=> "1.0")
+    assert_equal(1, @v11 <=> "0.9")
+  end
+end

test/webrick/test_server.rb

@@ -0,0 +1,64 @@
+require "test/unit"
+require "tempfile"
+require "webrick"
+require File.join(File.dirname(__FILE__), "utils.rb")
+
+class TestWEBrickServer < Test::Unit::TestCase
+  class Echo < WEBrick::GenericServer
+    def run(sock)
+      while line = sock.gets
+        sock << line
+      end
+    end
+  end
+
+  def test_server
+    TestWEBrick.start_server(Echo){|server, addr, port|
+      TCPSocket.open(addr, port){|sock|
+        sock.puts("foo"); assert_equal("foo\n", sock.gets)
+        sock.puts("bar"); assert_equal("bar\n", sock.gets)
+        sock.puts("baz"); assert_equal("baz\n", sock.gets)
+        sock.puts("qux"); assert_equal("qux\n", sock.gets)
+      }
+    }
+  end
+
+  def test_callbacks
+    accepted = started = stopped = 0
+    config = {
+      :AcceptCallback => Proc.new{ accepted += 1 },
+      :StartCallback => Proc.new{ started += 1 },
+      :StopCallback => Proc.new{ stopped += 1 },
+    }
+    TestWEBrick.start_server(Echo, config){|server, addr, port|
+      true while server.status != :Running
+      assert_equal(started, 1)
+      assert_equal(stopped, 0)
+      assert_equal(accepted, 0)
+      TCPSocket.open(addr, port){|sock| (sock << "foo\n").gets }
+      TCPSocket.open(addr, port){|sock| (sock << "foo\n").gets }
+      TCPSocket.open(addr, port){|sock| (sock << "foo\n").gets }
+      assert_equal(accepted, 3)
+    }
+    assert_equal(started, 1)
+    assert_equal(stopped, 1)
+  end
+
+  def test_daemon
+    begin
+      r, w = IO.pipe
+      Process.fork{
+        r.close
+        WEBrick::Daemon.start
+        w.puts(Process.pid)
+        sleep
+      }
+      assert(Process.kill(:KILL, r.gets.to_i))
+    rescue NotImplementedError
+      # snip this test
+    ensure
+      r.close
+      w.close
+    end
+  end
+end

test/webrick/utils.rb

@@ -0,0 +1,40 @@
+require "webrick"
+begin
+  require "webrick/https"
+rescue LoadError
+end
+require "webrick/httpproxy"
+
+module TestWEBrick
+  NullWriter = Object.new
+  def NullWriter.<<(msg)
+    puts msg if $DEBUG
+    return self
+  end
+
+  module_function
+
+  def start_server(klass, config={}, &block)
+    server = klass.new({
+      :BindAddress => "127.0.0.1", :Port => 0,
+      :Logger => WEBrick::Log.new(NullWriter),
+      :AccessLog => [[NullWriter, ""]]
+    }.update(config))
+    begin
+      thread = Thread.start{ server.start }
+      addr = server.listeners[0].addr
+      block.call([server, addr[3], addr[1]])
+    ensure
+      server.stop
+      thread.join
+    end
+  end
+
+  def start_httpserver(config={}, &block)
+    start_server(WEBrick::HTTPServer, config, &block)
+  end
+
+  def start_httpproxy(config={}, &block)
+    start_server(WEBrick::HTTPProxyServer, config, &block)
+  end
+end

test/webrick/webrick.cgi

@@ -0,0 +1,26 @@
+#!ruby -d
+require "webrick/cgi"
+
+class TestApp < WEBrick::CGI
+  def do_GET(req, res)
+    res["content-type"] = "text/plain"
+    if p = req.path_info
+      res.body = p
+    elsif (q = req.query).size > 0
+      res.body = q.keys.sort.collect{|key|
+        q[key].list.sort.collect{|v|
+          "#{key}=#{v}"
+        }.join(", ")
+      }.join(", ")
+    else
+      res.body = req.script_name
+    end
+  end
+
+  def do_POST(req, res)
+    do_GET(req, res)
+  end
+end
+
+cgi = TestApp.new
+cgi.start