glebtv-httpclient 3.1.1 → 3.2.0

data/stress-test/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+ruby '2.0.0'
+
+gem 'unicorn'

data/stress-test/Gemfile.lock

@@ -0,0 +1,16 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    kgio (2.8.1)
+    rack (1.5.2)
+    raindrops (0.12.0)
+    unicorn (4.7.0)
+      kgio (~> 2.6)
+      rack
+      raindrops (~> 0.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  unicorn

data/stress-test/client.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'httpclient'
+
+require 'thread'
+
+threads = []
+# clnt = HTTPClient.new()
+
+# 20.times do 
+#   threads << Thread.new do
+#     loop do
+#       clnt.get("http://localhost:7000/#{rand(1000..10000).to_s}.html") do |str|
+#         puts str.length if str.length != 1300000
+#       end
+#     end
+#   end
+# end
+# 
+# clnt = HTTPClient.new()
+# 10.times do
+#   threads << Thread.new do
+#     loop do
+#       begin
+#       clnt.get("http://#{rand(10000...200000)}.test.local/test.htm") do |str|
+#         puts str.length if str.length != 1300000
+#       end
+#       rescue
+#       end
+#     end
+#   end
+# end
+
+20.times do 
+  threads << Thread.new do
+    loop do
+      clnt = HTTPClient.new()
+      clnt.get("http://localhost:7000/#{rand(1000..10000).to_s}.html") do |str|
+        puts str.length if str.length != 1300000
+      end
+    end
+  end
+end
+
+def ostats(last_stat = nil)
+ stats = Hash.new(0)
+ ObjectSpace.each_object {|o| stats[o.class] += 1}
+
+ stats.sort {|(k1,v1),(k2,v2)| v2 <=> v1}.each do |k,v|
+   next if v < 25
+   printf "%-30s  %10d", k, v
+   printf " | delta %10d", (v - last_stat[k]) if last_stat
+   puts
+ end
+
+ stats
+end
+
+mstat = nil
+
+threads << Thread.new do
+  loop do
+    mstat = ostats(mstat)
+    puts '-' * 80
+    sleep 1
+  end
+end
+
+threads.each do |t|
+  t.join
+end

data/stress-test/config.ru

@@ -0,0 +1,4 @@
+body = ['abcdfghklmnop' * 100_000]
+run Proc.new { |env|
+  [200, {'Content-Type' => 'text/html'}, body]
+}

data/stress-test/unicorn.conf

@@ -0,0 +1,2 @@
+listen 7000
+worker_processes 10

data/test.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join('.', 'lib'))
+require 'httpclient'
+
+clnt = HTTPClient.new()
+site = ARGV.shift
+threads = []
+15.times do
+  threads << Thread.new do
+    loop do
+      puts "GET #{site}"
+      cnt = clnt.get_content site
+      sleep 1
+    end
+  end
+end
+
+threads.map(&:join)

data/test/helper.rb

@@ -1,9 +1,10 @@
 # -*- encoding: utf-8 -*-
-require 'test/unit'
+require "test/unit"
+
 begin
   require 'simplecov'
-  require 'simplecov-rcov'
-  SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+  # require 'simplecov-rcov'
+  # SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
   SimpleCov.start
 rescue LoadError
 end

data/test/test_httpclient.rb

@@ -64,56 +64,6 @@ class TestHTTPClient < Test::Unit::TestCase
     assert(!str.empty?)
   end
 
-  def test_protocol_version_http09
-    @client.protocol_version = 'HTTP/0.9'
-    @client.debug_dev = str = ''
-    @client.test_loopback_http_response << "hello\nworld\n"
-    res = @client.get(serverurl + 'hello')
-    assert_equal('0.9', res.http_version)
-    assert_equal(nil, res.status)
-    assert_equal(nil, res.reason)
-    assert_equal("hello\nworld\n", res.content)
-    lines = str.split(/(?:\r?\n)+/)
-    assert_equal("= Request", lines[0])
-    assert_equal("! CONNECTION ESTABLISHED", lines[2])
-    assert_equal("GET /hello HTTP/0.9", lines[3])
-    assert_equal("Connection: close", lines[7])
-    assert_equal("= Response", lines[8])
-    assert_match(/^hello$/, lines[9])
-    assert_match(/^world$/, lines[10])
-  end
-
-  def test_protocol_version_http10
-    assert_equal(nil, @client.protocol_version)
-    @client.protocol_version = 'HTTP/1.0'
-    assert_equal('HTTP/1.0', @client.protocol_version)
-    str = ""
-    @client.debug_dev = str
-    @client.get(serverurl + 'hello')
-    lines = str.split(/(?:\r?\n)+/)
-    assert_equal("= Request", lines[0])
-    assert_equal("! CONNECTION ESTABLISHED", lines[2])
-    assert_equal("GET /hello HTTP/1.0", lines[3])
-    assert_equal("Connection: close", lines[7])
-    assert_equal("= Response", lines[8])
-  end
-
-  def test_header_accept_by_default
-    str = ""
-    @client.debug_dev = str
-    @client.get(serverurl)
-    lines = str.split(/(?:\r?\n)+/)
-    assert_equal("Accept: */*", lines[5])
-  end
-
-  def test_header_accept
-    str = ""
-    @client.debug_dev = str
-    @client.get(serverurl, :header => {:Accept => 'text/html'})
-    lines = str.split(/(?:\r?\n)+/)
-    assert_equal("Accept: text/html", lines[4])
-  end
-
   def test_host_given
     str = ""
     @client.debug_dev = str
@@ -143,35 +93,6 @@ class TestHTTPClient < Test::Unit::TestCase
     end
   end
 
-  def test_protocol_version_http11
-    assert_equal(nil, @client.protocol_version)
-    str = ""
-    @client.debug_dev = str
-    @client.get(serverurl)
-    lines = str.split(/(?:\r?\n)+/)
-    assert_equal("= Request", lines[0])
-    assert_equal("! CONNECTION ESTABLISHED", lines[2])
-    assert_equal("GET / HTTP/1.1", lines[3])
-    assert_equal("Host: localhost:#{serverport}", lines[7])
-    @client.protocol_version = 'HTTP/1.1'
-    assert_equal('HTTP/1.1', @client.protocol_version)
-    str = ""
-    @client.debug_dev = str
-    @client.get(serverurl)
-    lines = str.split(/(?:\r?\n)+/)
-    assert_equal("= Request", lines[0])
-    assert_equal("! CONNECTION ESTABLISHED", lines[2])
-    assert_equal("GET / HTTP/1.1", lines[3])
-    @client.protocol_version = 'HTTP/1.0'
-    str = ""
-    @client.debug_dev = str
-    @client.get(serverurl)
-    lines = str.split(/(?:\r?\n)+/)
-    assert_equal("= Request", lines[0])
-    assert_equal("! CONNECTION ESTABLISHED", lines[2])
-    assert_equal("GET / HTTP/1.0", lines[3])
-  end
-
   def test_proxy
     setup_proxyserver
     escape_noproxy do
@@ -526,104 +447,6 @@ EOS
     end
   end
 
-  def test_get_content
-    assert_equal('hello', @client.get_content(serverurl + 'hello'))
-    assert_equal('hello', @client.get_content(serverurl + 'redirect1'))
-    assert_equal('hello', @client.get_content(serverurl + 'redirect2'))
-    url = serverurl.sub(/localhost/, '127.0.0.1')
-    assert_equal('hello', @client.get_content(url + 'hello'))
-    assert_equal('hello', @client.get_content(url + 'redirect1'))
-    assert_equal('hello', @client.get_content(url + 'redirect2'))
-    @client.reset(serverurl)
-    @client.reset(url)
-    @client.reset(serverurl)
-    @client.reset(url)
-    assert_raises(HTTPClient::BadResponseError) do
-      @client.get_content(serverurl + 'notfound')
-    end
-    assert_raises(HTTPClient::BadResponseError) do
-      @client.get_content(serverurl + 'redirect_self')
-    end
-    called = false
-    @client.redirect_uri_callback = lambda { |uri, res|
-      newuri = res.header['location'][0]
-      called = true
-      newuri
-    }
-    assert_equal('hello', @client.get_content(serverurl + 'relative_redirect'))
-    assert(called)
-  end
-
-  GZIP_CONTENT = "\x1f\x8b\x08\x00\x1a\x96\xe0\x4c\x00\x03\xcb\x48\xcd\xc9\xc9\x07\x00\x86\xa6\x10\x36\x05\x00\x00\x00"
-  DEFLATE_CONTENT = "\x78\x9c\xcb\x48\xcd\xc9\xc9\x07\x00\x06\x2c\x02\x15"
-  GZIP_CONTENT.force_encoding('BINARY') if GZIP_CONTENT.respond_to?(:force_encoding)
-  DEFLATE_CONTENT.force_encoding('BINARY') if DEFLATE_CONTENT.respond_to?(:force_encoding)
-  def test_get_gzipped_content
-    @client.transparent_gzip_decompression = false
-    content = @client.get_content(serverurl + 'compressed?enc=gzip')
-    assert_not_equal('hello', content)
-    assert_equal(GZIP_CONTENT, content)
-    @client.transparent_gzip_decompression = true
-    assert_equal('hello', @client.get_content(serverurl + 'compressed?enc=gzip'))
-    assert_equal('hello', @client.get_content(serverurl + 'compressed?enc=deflate'))
-    @client.transparent_gzip_decompression = false
-  end
-
-  def test_get_content_with_block
-    @client.get_content(serverurl + 'hello') do |str|
-      assert_equal('hello', str)
-    end
-    @client.get_content(serverurl + 'redirect1') do |str|
-      assert_equal('hello', str)
-    end
-    @client.get_content(serverurl + 'redirect2') do |str|
-      assert_equal('hello', str)
-    end
-  end
-
-  def test_post_content
-    assert_equal('hello', @client.post_content(serverurl + 'hello'))
-    assert_equal('hello', @client.post_content(serverurl + 'redirect1'))
-    assert_equal('hello', @client.post_content(serverurl + 'redirect2'))
-    assert_raises(HTTPClient::BadResponseError) do
-      @client.post_content(serverurl + 'notfound')
-    end
-    assert_raises(HTTPClient::BadResponseError) do
-      @client.post_content(serverurl + 'redirect_self')
-    end
-    called = false
-    @client.redirect_uri_callback = lambda { |uri, res|
-      newuri = res.header['location'][0]
-      called = true
-      newuri
-    }
-    assert_equal('hello', @client.post_content(serverurl + 'relative_redirect'))
-    assert(called)
-  end
-
-  def test_post_content_io
-    post_body = StringIO.new("1234567890")
-    assert_equal('post,1234567890', @client.post_content(serverurl + 'servlet', post_body))
-
-    # all browsers use GET for 302
-    post_body = StringIO.new("1234567890")
-    assert_equal('1234567890', @client.post_content(serverurl + 'servlet_413', post_body))
-
-    assert_equal('', @client.get_content(serverurl + 'servlet_redirect_413'))
-    post_body = StringIO.new("1234567890")
-    assert_equal('', @client.post_content(serverurl + 'servlet_redirect_413', post_body))
-
-
-    post_body = StringIO.new("1234567890")
-    assert_equal('post,1234567890', @client.post_content(serverurl + 'servlet_temporary_redirect', post_body))
-    post_body = StringIO.new("1234567890")
-    assert_equal('get', @client.post_content(serverurl + 'servlet_see_other', post_body))
-    #
-    post_body = StringIO.new("1234567890")
-    post_body.read(5)
-    assert_equal('post,67890', @client.post_content(serverurl + 'servlet_temporary_redirect', post_body))
-  end
-
   def test_head
     assert_equal("head", @client.head(serverurl + 'servlet').header["x-head"][0])
     param = {'1'=>'2', '3'=>'4'}
@@ -888,7 +711,24 @@ EOS
     assert_equal(param, params(res.header["x-query"][0]))
   end
 
-  def test_delete
+  def test_patch
+    assert_equal("patch", @client.patch(serverurl + 'servlet').content)
+    param = {'1'=>'2', '3'=>'4'}
+    @client.debug_dev = str = ''
+    res = @client.patch(serverurl + 'servlet', param)
+    assert_equal(param, params(res.header["x-query"][0]))
+    assert_equal('Content-Type: application/x-www-form-urlencoded', str.split(/\r?\n/)[5])
+  end
+
+  def test_patch_async
+    param = {'1'=>'2', '3'=>'4'}
+    conn = @client.patch_async(serverurl + 'servlet', param)
+    Thread.pass while !conn.finished?
+    res = conn.pop
+    assert_equal(param, params(res.header["x-query"][0]))
+  end
+
+ def test_delete
     assert_equal("delete", @client.delete(serverurl + 'servlet').content)
   end
 
@@ -963,6 +803,7 @@ EOS
 
   def test_chunked
     assert_equal('chunked', @client.get_content(serverurl + 'chunked', { 'msg' => 'chunked' }))
+    assert_equal('あいうえお', @client.get_content(serverurl + 'chunked', { 'msg' => 'あいうえお' }))
   end
 
   def test_chunked_empty
@@ -1086,14 +927,6 @@ EOS
     assert_equal('hello', @client.post(serverurl + 'sleep', :sec => 2).content)
   end
 
-  # disable for now -- does not work
-  #def test_async_error
-  #  assert_raise( SocketError ) do
-  #    conn = @client.get_async("http://non-existing-host/")
-  #    conn.pop
-  #  end
-  #end
-
   def test_reset
     url = serverurl + 'servlet'
     assert_nothing_raised do
@@ -1188,14 +1021,6 @@ EOS
     end
   end
 
-  def test_urify
-    extend HTTPClient::Util
-    assert_nil(urify(nil))
-    uri = 'http://foo'
-    assert_equal(urify(uri), urify(uri))
-    assert_equal(urify(uri), urify(urify(uri)))
-  end
-
   def test_connection
     c = HTTPClient::Connection.new
     assert(c.finished?)
@@ -1249,156 +1074,6 @@ EOS
     assert_equal([['foo', 'bar'], ['foo', 'bar2']], res.header.get('foo'))
   end
 
-  def test_mime_type
-    assert_equal('text/plain', HTTP::Message.mime_type('foo.txt'))
-    assert_equal('text/html', HTTP::Message.mime_type('foo.html'))
-    assert_equal('text/html', HTTP::Message.mime_type('foo.htm'))
-    assert_equal('application/msword', HTTP::Message.mime_type('foo.doc'))
-    assert_equal('image/png', HTTP::Message.mime_type('foo.png'))
-    assert_equal('image/gif', HTTP::Message.mime_type('foo.gif'))
-    assert_equal('image/jpeg', HTTP::Message.mime_type('foo.jpg'))
-    assert_equal('image/jpeg', HTTP::Message.mime_type('foo.jpeg'))
-    assert_equal('application/octet-stream', HTTP::Message.mime_type('foo.unknown'))
-    #
-    handler = lambda { |path| 'hello/world' }
-    assert_nil(HTTP::Message.mime_type_handler)
-    assert_nil(HTTP::Message.get_mime_type_func)
-    HTTP::Message.mime_type_handler = handler
-    assert_not_nil(HTTP::Message.mime_type_handler)
-    assert_not_nil(HTTP::Message.get_mime_type_func)
-    assert_equal('hello/world', HTTP::Message.mime_type('foo.txt'))
-    HTTP::Message.mime_type_handler = nil
-    assert_equal('text/plain', HTTP::Message.mime_type('foo.txt'))
-    HTTP::Message.set_mime_type_func(nil)
-    assert_equal('text/plain', HTTP::Message.mime_type('foo.txt'))
-    #
-    handler = lambda { |path| nil }
-    HTTP::Message.mime_type_handler = handler
-    assert_equal('application/octet-stream', HTTP::Message.mime_type('foo.txt'))
-  end
-
-  def test_connect_request
-    req = HTTP::Message.new_connect_request(urify('https://foo/bar'))
-    assert_equal("CONNECT foo:443 HTTP/1.0\r\n\r\n", req.dump)
-    req = HTTP::Message.new_connect_request(urify('https://example.com/'))
-    assert_equal("CONNECT example.com:443 HTTP/1.0\r\n\r\n", req.dump)
-  end
-
-  def test_response
-    res = HTTP::Message.new_response('response')
-    res.contenttype = 'text/plain'
-    res.header.body_date = Time.at(946652400)
-    assert_equal(
-      [
-        "",
-        "Content-Length: 8",
-        "Content-Type: text/plain",
-        "Last-Modified: Fri, 31 Dec 1999 15:00:00 GMT",
-        "Status: 200 OK",
-        "response"
-      ],
-      res.dump.split(/\r\n/).sort
-    )
-    assert_equal(['8'], res.header['Content-Length'])
-    assert_equal('8', res.headers['Content-Length'])
-    res.header.set('foo', 'bar')
-    assert_equal(
-      [
-        "",
-        "Content-Length: 8",
-        "Content-Type: text/plain",
-        "Last-Modified: Fri, 31 Dec 1999 15:00:00 GMT",
-        "Status: 200 OK",
-        "foo: bar",
-        "response"
-      ],
-      res.dump.split(/\r\n/).sort
-    )
-    # nil body
-    res = HTTP::Message.new_response(nil)
-    assert_equal(
-      [
-        "Content-Length: 0",
-        "Content-Type: text/html; charset=us-ascii",
-        "Status: 200 OK"
-      ],
-      res.dump.split(/\r\n/).sort
-    )
-    # for mod_ruby env
-    Object.const_set('Apache', nil)
-    begin
-      res = HTTP::Message.new_response('response')
-      assert(res.dump.split(/\r\n/).any? { |line| /^Date/ =~ line })
-      #
-      res = HTTP::Message.new_response('response')
-      res.contenttype = 'text/plain'
-      res.header.body_date = Time.at(946652400)
-      res.header['Date'] = Time.at(946652400).httpdate
-      assert_equal(
-        [
-          "",
-          "Content-Length: 8",
-          "Content-Type: text/plain",
-          "Date: Fri, 31 Dec 1999 15:00:00 GMT",
-          "HTTP/1.1 200 OK",
-          "Last-Modified: Fri, 31 Dec 1999 15:00:00 GMT",
-          "response"
-        ],
-        res.dump.split(/\r\n/).sort
-      )
-    ensure
-      Object.instance_eval { remove_const('Apache') }
-    end
-  end
-
-  def test_response_cookies
-    res = HTTP::Message.new_response('response')
-    res.contenttype = 'text/plain'
-    res.header.body_date = Time.at(946652400)
-    assert_nil(res.cookies)
-    #
-    res.header['Set-Cookie'] = [
-      'CUSTOMER=WILE_E_COYOTE; path=/; expires=Wednesday, 09-Nov-99 23:12:40 GMT',
-      'PART_NUMBER=ROCKET_LAUNCHER_0001; path=/'
-    ]
-    assert_equal(
-      [
-        "",
-        "Content-Length: 8",
-        "Content-Type: text/plain",
-        "Last-Modified: Fri, 31 Dec 1999 15:00:00 GMT",
-        "Set-Cookie: CUSTOMER=WILE_E_COYOTE; path=/; expires=Wednesday, 09-Nov-99 23:12:40 GMT",
-        "Set-Cookie: PART_NUMBER=ROCKET_LAUNCHER_0001; path=/",
-        "Status: 200 OK",
-        "response"
-      ],
-      res.dump.split(/\r\n/).sort
-    )
-    assert_equal(2, res.cookies.size)
-    assert_equal('CUSTOMER', res.cookies[0].name)
-    assert_equal('PART_NUMBER', res.cookies[1].name)
-  end
-
-  def test_ok_response_success
-    res = HTTP::Message.new_response('response')
-    assert_equal(true, res.ok?)
-    res.status = 404
-    assert_equal(false, res.ok?)
-    res.status = 500
-    assert_equal(false, res.ok?)
-    res.status = 302
-    assert_equal(false, res.ok?)
-  end
-
-  if !defined?(JRUBY_VERSION) and RUBY_VERSION < '1.9'
-    def test_timeout_scheduler
-      assert_equal('hello', @client.get_content(serverurl + 'hello'))
-      status =  HTTPClient.timeout_scheduler.instance_eval { @thread.kill; @thread.join; @thread.status }
-      assert(!status) # dead
-      assert_equal('hello', @client.get_content(serverurl + 'hello'))
-    end
-  end
-
   def test_session_manager
     mgr = HTTPClient::SessionManager.new(@client)
     assert_nil(mgr.instance_eval { @proxy })
@@ -1410,131 +1085,6 @@ EOS
     assert_equal(@client.debug_dev, mgr.debug_dev)
   end
 
-  def create_keepalive_disconnected_thread(idx, sock)
-    Thread.new {
-      # return "12345" for the first connection
-      sock.gets
-      sock.gets
-      sock.write("HTTP/1.1 200 OK\r\n")
-      sock.write("Content-Length: 5\r\n")
-      sock.write("\r\n")
-      sock.write("12345")
-      # for the next connection, close while reading the request for emulating
-      # KeepAliveDisconnected
-      sock.gets
-      sock.close
-    }
-  end
-
-  def test_keepalive_disconnected
-    client = HTTPClient.new
-    server = TCPServer.open('127.0.0.1', 0)
-    server.listen(30) # set enough backlogs
-    endpoint = "http://127.0.0.1:#{server.addr[1]}/"
-    Thread.new {
-      Thread.abort_on_exception = true
-      # emulate 10 keep-alive connections
-      10.times do |idx|
-        sock = server.accept
-        create_keepalive_disconnected_thread(idx, sock)
-      end
-      # return "23456" for the request which gets KeepAliveDisconnected
-      5.times do
-        sock = server.accept
-        sock.gets
-        sock.gets
-        sock.write("HTTP/1.1 200 OK\r\n")
-        sock.write("\r\n")
-        sock.write("23456")
-        sock.close
-      end
-      # return "34567" for the rest requests
-      while true
-        sock = server.accept
-        sock.gets
-        sock.gets
-        sock.write("HTTP/1.1 200 OK\r\n")
-        sock.write("Connection: close\r\n")
-        sock.write("Content-Length: 5\r\n")
-        sock.write("\r\n")
-        sock.write("34567")
-        sock.close
-      end
-    }
-    # allocate 10 keep-alive connections
-    (0...10).to_a.map {
-      Thread.new {
-        assert_equal("12345", client.get(endpoint).content)
-      }
-    }.each { |th| th.join }
-    # send 5 requests, which should get KeepAliveDesconnected.
-    # doing these requests, rest keep-alive connections are invalidated.
-    (0...5).to_a.map {
-      Thread.new {
-        assert_equal("23456", client.get(endpoint).content)
-      }
-    }.each { |th| th.join }
-    # rest requests won't get KeepAliveDisconnected; how can I check this?
-    (0...10).to_a.map {
-      Thread.new {
-        assert_equal("34567", client.get(endpoint).content)
-      }
-    }.each { |th| th.join }
-  end
-
-  def create_keepalive_thread(count, sock)
-    Thread.new {
-      Thread.abort_on_exception = true
-      count.times do
-        req = sock.gets
-        while line = sock.gets
-          break if line.chomp.empty?
-        end
-        case req
-        when /chunked/
-          sock.write("HTTP/1.1 200 OK\r\n")
-          sock.write("Transfer-Encoding: chunked\r\n")
-          sock.write("\r\n")
-          sock.write("1a\r\n")
-          sock.write("abcdefghijklmnopqrstuvwxyz\r\n")
-          sock.write("10\r\n")
-          sock.write("1234567890abcdef\r\n")
-          sock.write("0\r\n")
-          sock.write("\r\n")
-        else
-          sock.write("HTTP/1.1 200 OK\r\n")
-          sock.write("Content-Length: 5\r\n")
-          sock.write("\r\n")
-          sock.write("12345")
-        end
-      end
-      sock.close
-    }
-  end
-
-  def test_keepalive
-    server = TCPServer.open('localhost', 0)
-    server_thread = Thread.new {
-      Thread.abort_on_exception = true
-      sock = server.accept
-      create_keepalive_thread(10, sock)
-    }
-    url = "http://localhost:#{server.addr[1]}/"
-    begin
-      # content-length
-      5.times do
-        assert_equal('12345', @client.get(url).body)
-      end
-      # chunked
-      5.times do
-        assert_equal('abcdefghijklmnopqrstuvwxyz1234567890abcdef', @client.get(url + 'chunked').body)
-      end
-    ensure
-      server.close
-      server_thread.join
-    end
-  end
-
   def test_socket_local
     @client.socket_local.host = '127.0.0.1'
     assert_equal('hello', @client.get_content(serverurl + 'hello'))
@@ -1608,212 +1158,4 @@ private
     )
   end
 
-  def setup_server
-    @server = WEBrick::HTTPServer.new(
-      :BindAddress => "localhost",
-      :Logger => @logger,
-      :Port => 0,
-      :AccessLog => [],
-      :DocumentRoot => File.dirname(File.expand_path(__FILE__))
-    )
-    @serverport = @server.config[:Port]
-    [
-      :hello, :sleep, :servlet_redirect, :servlet_temporary_redirect, :servlet_see_other,
-      :redirect1, :redirect2, :redirect3,
-      :redirect_self, :relative_redirect, :redirect_see_other, :chunked,
-      :largebody, :status, :compressed, :charset, :continue,
-      :servlet_redirect_413, :servlet_413
-    ].each do |sym|
-      @server.mount(
-        "/#{sym}",
-        WEBrick::HTTPServlet::ProcHandler.new(method("do_#{sym}").to_proc)
-      )
-    end
-    @server.mount('/servlet', TestServlet.new(@server))
-    @server_thread = start_server_thread(@server)
-  end
-
-  def escape_noproxy
-    backup = HTTPClient::NO_PROXY_HOSTS.dup
-    HTTPClient::NO_PROXY_HOSTS.clear
-    yield
-  ensure
-    HTTPClient::NO_PROXY_HOSTS.replace(backup)
-  end
-
-  def do_hello(req, res)
-    res['content-type'] = 'text/html'
-    res.body = "hello"
-  end
-
-  def do_sleep(req, res)
-    sec = req.query['sec'].to_i
-    sleep sec
-    res['content-type'] = 'text/html'
-    res.body = "hello"
-  end
-
-  def do_servlet_redirect(req, res)
-    res.set_redirect(WEBrick::HTTPStatus::Found, serverurl + "servlet")
-  end
-
-  def do_servlet_redirect_413(req, res)
-    res.set_redirect(WEBrick::HTTPStatus::Found, serverurl + "servlet_413")
-  end
-
-  def do_servlet_413(req, res)
-    res.body = req.body.to_s
-  end
-
-  def do_servlet_temporary_redirect(req, res)
-    res.set_redirect(WEBrick::HTTPStatus::TemporaryRedirect, serverurl + "servlet")
-  end
-
-  def do_servlet_see_other(req, res)
-    res.set_redirect(WEBrick::HTTPStatus::SeeOther, serverurl + "servlet")
-  end
-
-  def do_redirect1(req, res)
-    res.set_redirect(WEBrick::HTTPStatus::MovedPermanently, serverurl + "hello")
-  end
-
-  def do_redirect2(req, res)
-    res.set_redirect(WEBrick::HTTPStatus::TemporaryRedirect, serverurl + "redirect3")
-  end
-
-  def do_redirect3(req, res)
-    res.set_redirect(WEBrick::HTTPStatus::Found, serverurl + "hello")
-  end
-
-  def do_redirect_self(req, res)
-    res.set_redirect(WEBrick::HTTPStatus::Found, serverurl + "redirect_self")
-  end
-
-  def do_relative_redirect(req, res)
-    res.set_redirect(WEBrick::HTTPStatus::Found, "hello")
-  end
-
-  def do_redirect_see_other(req, res)
-    if req.request_method == 'POST'
-      res.set_redirect(WEBrick::HTTPStatus::SeeOther, serverurl + "redirect_see_other") # self
-    else
-      res.body = 'hello'
-    end
-  end
-
-  def do_chunked(req, res)
-    res.chunked = true
-    piper, pipew = IO.pipe
-    res.body = piper
-    pipew << req.query['msg']
-    pipew.close
-  end
-
-  def do_largebody(req, res)
-    res['content-type'] = 'text/html'
-    res.body = "a" * 1000 * 1000
-  end
-
-  def do_compressed(req, res)
-    res['content-type'] = 'application/octet-stream'
-    if req.query['enc'] == 'gzip'
-      res['content-encoding'] = 'gzip'
-      res.body = GZIP_CONTENT
-    elsif req.query['enc'] == 'deflate'
-      res['content-encoding'] = 'deflate'
-      res.body = DEFLATE_CONTENT
-    end
-  end
-
-  def do_charset(req, res)
-    if RUBY_VERSION > "1.9"
-      res.body = 'あいうえお'.encode("euc-jp")
-      res['Content-Type'] = 'text/plain; charset=euc-jp'
-    else
-      res.body = 'this endpoint is for 1.9 or later'
-    end
-  end
-
-  def do_status(req, res)
-    res.status = req.query['status'].to_i
-  end
-
-  def do_continue(req, res)
-    req.continue
-    res.body = 'done!'
-  end
-
-  class TestServlet < WEBrick::HTTPServlet::AbstractServlet
-    def get_instance(*arg)
-      self
-    end
-
-    def do_HEAD(req, res)
-      res["x-head"] = 'head'    # use this for test purpose only.
-      res["x-query"] = query_response(req)
-    end
-
-    def do_GET(req, res)
-      res.body = 'get'
-      res["x-query"] = query_response(req)
-    end
-
-    def do_POST(req, res)
-      res["content-type"] = "text/plain" # iso-8859-1, not US-ASCII
-      res.body = 'post,' + req.body.to_s
-      res["x-query"] = body_response(req)
-    end
-
-    def do_PUT(req, res)
-      res["x-query"] = body_response(req)
-      param = WEBrick::HTTPUtils.parse_query(req.body) || {}
-      res["x-size"] = (param['txt'] || '').size
-      res.body = param['txt'] || 'put'
-    end
-
-    def do_DELETE(req, res)
-      res.body = 'delete'
-    end
-
-    def do_OPTIONS(req, res)
-      # check RFC for legal response.
-      res.body = 'options'
-    end
-
-    def do_PROPFIND(req, res)
-      res.body = 'propfind'
-    end
-
-    def do_PROPPATCH(req, res)
-      res.body = 'proppatch'
-      res["x-query"] = body_response(req)
-    end
-
-    def do_TRACE(req, res)
-      # client SHOULD reflect the message received back to the client as the
-      # entity-body of a 200 (OK) response. [RFC2616]
-      res.body = 'trace'
-      res["x-query"] = query_response(req)
-    end
-
-  private
-
-    def query_response(req)
-      query_escape(WEBrick::HTTPUtils.parse_query(req.query_string))
-    end
-
-    def body_response(req)
-      query_escape(WEBrick::HTTPUtils.parse_query(req.body))
-    end
-
-    def query_escape(query)
-      escaped = []
-      query.sort_by { |k, v| k }.collect do |k, v|
-        v.to_ary.each do |ve|
-          escaped << CGI.escape(k) + '=' + CGI.escape(ve)
-        end
-      end
-      escaped.join('&')
-    end
-  end
 end