about summary refs log tree commit homepage
diff options
context:
space:
mode:
-rw-r--r--test/unit/test_http_parser.rb324
-rw-r--r--test/unit/test_http_parser_ng.rb273
-rw-r--r--test/unit/test_tee_input.rb46
3 files changed, 340 insertions, 303 deletions
diff --git a/test/unit/test_http_parser.rb b/test/unit/test_http_parser.rb
index e6d48e3..7e2b024 100644
--- a/test/unit/test_http_parser.rb
+++ b/test/unit/test_http_parser.rb
@@ -14,9 +14,10 @@ class HttpParserTest < Test::Unit::TestCase
 
   def test_parse_simple
     parser = HttpParser.new
-    req = {}
-    http = "GET / HTTP/1.1\r\n\r\n"
-    assert_equal req, parser.headers(req, http)
+    req = parser.env
+    http = parser.buf
+    http << "GET / HTTP/1.1\r\n\r\n"
+    assert_equal req, parser.parse
     assert_equal '', http
 
     assert_equal 'HTTP/1.1', req['SERVER_PROTOCOL']
@@ -31,14 +32,14 @@ class HttpParserTest < Test::Unit::TestCase
     parser.clear
     req.clear
 
-    http = "G"
-    assert_nil parser.headers(req, http)
+    http << "G"
+    assert_nil parser.parse
     assert_equal "G", http
     assert req.empty?
 
     # try parsing again to ensure we were reset correctly
-    http = "GET /hello-world HTTP/1.1\r\n\r\n"
-    assert parser.headers(req, http)
+    http << "ET /hello-world HTTP/1.1\r\n\r\n"
+    assert parser.parse
 
     assert_equal 'HTTP/1.1', req['SERVER_PROTOCOL']
     assert_equal '/hello-world', req['REQUEST_PATH']
@@ -53,161 +54,161 @@ class HttpParserTest < Test::Unit::TestCase
 
   def test_tab_lws
     parser = HttpParser.new
-    req = {}
-    tmp = "GET / HTTP/1.1\r\nHost:\tfoo.bar\r\n\r\n"
-    assert_equal req.object_id, parser.headers(req, tmp).object_id
+    req = parser.env
+    parser.buf << "GET / HTTP/1.1\r\nHost:\tfoo.bar\r\n\r\n"
+    assert_equal req.object_id, parser.parse.object_id
     assert_equal "foo.bar", req['HTTP_HOST']
   end
 
   def test_connection_close_no_ka
     parser = HttpParser.new
-    req = {}
-    tmp = "GET / HTTP/1.1\r\nConnection: close\r\n\r\n"
-    assert_equal req.object_id, parser.headers(req, tmp).object_id
+    req = parser.env
+    parser.buf << "GET / HTTP/1.1\r\nConnection: close\r\n\r\n"
+    assert_equal req.object_id, parser.parse.object_id
     assert_equal "GET", req['REQUEST_METHOD']
     assert ! parser.keepalive?
   end
 
   def test_connection_keep_alive_ka
     parser = HttpParser.new
-    req = {}
-    tmp = "HEAD / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n"
-    assert_equal req.object_id, parser.headers(req, tmp).object_id
+    req = parser.env
+    parser.buf << "HEAD / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n"
+    assert_equal req.object_id, parser.parse.object_id
     assert parser.keepalive?
   end
 
   def test_connection_keep_alive_no_body
     parser = HttpParser.new
-    req = {}
-    tmp = "POST / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n"
-    assert_equal req.object_id, parser.headers(req, tmp).object_id
+    req = parser.env
+    parser.buf << "POST / HTTP/1.1\r\nConnection: keep-alive\r\n\r\n"
+    assert_equal req.object_id, parser.parse.object_id
     assert parser.keepalive?
   end
 
   def test_connection_keep_alive_no_body_empty
     parser = HttpParser.new
-    req = {}
-    tmp = "POST / HTTP/1.1\r\n" \
-          "Content-Length: 0\r\n" \
-          "Connection: keep-alive\r\n\r\n"
-    assert_equal req.object_id, parser.headers(req, tmp).object_id
+    req = parser.env
+    parser.buf << "POST / HTTP/1.1\r\n" \
+                  "Content-Length: 0\r\n" \
+                  "Connection: keep-alive\r\n\r\n"
+    assert_equal req.object_id, parser.parse.object_id
     assert parser.keepalive?
   end
 
   def test_connection_keep_alive_ka_bad_version
     parser = HttpParser.new
-    req = {}
-    tmp = "GET / HTTP/1.0\r\nConnection: keep-alive\r\n\r\n"
-    assert_equal req.object_id, parser.headers(req, tmp).object_id
+    req = parser.env
+    parser.buf << "GET / HTTP/1.0\r\nConnection: keep-alive\r\n\r\n"
+    assert_equal req.object_id, parser.parse.object_id
     assert parser.keepalive?
   end
 
   def test_parse_server_host_default_port
     parser = HttpParser.new
-    req = {}
-    tmp = "GET / HTTP/1.1\r\nHost: foo\r\n\r\n"
-    assert_equal req, parser.headers(req, tmp)
+    req = parser.env
+    parser.buf << "GET / HTTP/1.1\r\nHost: foo\r\n\r\n"
+    assert_equal req, parser.parse
     assert_equal 'foo', req['SERVER_NAME']
     assert_equal '80', req['SERVER_PORT']
-    assert_equal '', tmp
+    assert_equal '', parser.buf
     assert parser.keepalive?
   end
 
   def test_parse_server_host_alt_port
     parser = HttpParser.new
-    req = {}
-    tmp = "GET / HTTP/1.1\r\nHost: foo:999\r\n\r\n"
-    assert_equal req, parser.headers(req, tmp)
+    req = parser.env
+    parser.buf << "GET / HTTP/1.1\r\nHost: foo:999\r\n\r\n"
+    assert_equal req, parser.parse
     assert_equal 'foo', req['SERVER_NAME']
     assert_equal '999', req['SERVER_PORT']
-    assert_equal '', tmp
+    assert_equal '', parser.buf
     assert parser.keepalive?
   end
 
   def test_parse_server_host_empty_port
     parser = HttpParser.new
-    req = {}
-    tmp = "GET / HTTP/1.1\r\nHost: foo:\r\n\r\n"
-    assert_equal req, parser.headers(req, tmp)
+    req = parser.env
+    parser.buf << "GET / HTTP/1.1\r\nHost: foo:\r\n\r\n"
+    assert_equal req, parser.parse
     assert_equal 'foo', req['SERVER_NAME']
     assert_equal '80', req['SERVER_PORT']
-    assert_equal '', tmp
+    assert_equal '', parser.buf
     assert parser.keepalive?
   end
 
   def test_parse_server_host_xfp_https
     parser = HttpParser.new
-    req = {}
-    tmp = "GET / HTTP/1.1\r\nHost: foo:\r\n" \
-          "X-Forwarded-Proto: https\r\n\r\n"
-    assert_equal req, parser.headers(req, tmp)
+    req = parser.env
+    parser.buf << "GET / HTTP/1.1\r\nHost: foo:\r\n" \
+                  "X-Forwarded-Proto: https\r\n\r\n"
+    assert_equal req, parser.parse
     assert_equal 'foo', req['SERVER_NAME']
     assert_equal '443', req['SERVER_PORT']
-    assert_equal '', tmp
+    assert_equal '', parser.buf
     assert parser.keepalive?
   end
 
   def test_parse_xfp_https_chained
     parser = HttpParser.new
-    req = {}
-    tmp = "GET / HTTP/1.0\r\n" \
-          "X-Forwarded-Proto: https,http\r\n\r\n"
-    assert_equal req, parser.headers(req, tmp)
+    req = parser.env
+    parser.buf << "GET / HTTP/1.0\r\n" \
+                  "X-Forwarded-Proto: https,http\r\n\r\n"
+    assert_equal req, parser.parse
     assert_equal '443', req['SERVER_PORT'], req.inspect
     assert_equal 'https', req['rack.url_scheme'], req.inspect
-    assert_equal '', tmp
+    assert_equal '', parser.buf
   end
 
   def test_parse_xfp_https_chained_backwards
     parser = HttpParser.new
-    req = {}
-    tmp = "GET / HTTP/1.0\r\n" \
+    req = parser.env
+    parser.buf << "GET / HTTP/1.0\r\n" \
           "X-Forwarded-Proto: http,https\r\n\r\n"
-    assert_equal req, parser.headers(req, tmp)
+    assert_equal req, parser.parse
     assert_equal '80', req['SERVER_PORT'], req.inspect
     assert_equal 'http', req['rack.url_scheme'], req.inspect
-    assert_equal '', tmp
+    assert_equal '', parser.buf
   end
 
   def test_parse_xfp_gopher_is_ignored
     parser = HttpParser.new
-    req = {}
-    tmp = "GET / HTTP/1.0\r\n" \
-          "X-Forwarded-Proto: gopher\r\n\r\n"
-    assert_equal req, parser.headers(req, tmp)
+    req = parser.env
+    parser.buf << "GET / HTTP/1.0\r\n" \
+                  "X-Forwarded-Proto: gopher\r\n\r\n"
+    assert_equal req, parser.parse
     assert_equal '80', req['SERVER_PORT'], req.inspect
     assert_equal 'http', req['rack.url_scheme'], req.inspect
-    assert_equal '', tmp
+    assert_equal '', parser.buf
   end
 
   def test_parse_x_forwarded_ssl_on
     parser = HttpParser.new
-    req = {}
-    tmp = "GET / HTTP/1.0\r\n" \
-          "X-Forwarded-Ssl: on\r\n\r\n"
-    assert_equal req, parser.headers(req, tmp)
+    req = parser.env
+    parser.buf << "GET / HTTP/1.0\r\n" \
+                  "X-Forwarded-Ssl: on\r\n\r\n"
+    assert_equal req, parser.parse
     assert_equal '443', req['SERVER_PORT'], req.inspect
     assert_equal 'https', req['rack.url_scheme'], req.inspect
-    assert_equal '', tmp
+    assert_equal '', parser.buf
   end
 
   def test_parse_x_forwarded_ssl_off
     parser = HttpParser.new
-    req = {}
-    tmp = "GET / HTTP/1.0\r\n" \
-          "X-Forwarded-Ssl: off\r\n\r\n"
-    assert_equal req, parser.headers(req, tmp)
+    req = parser.env
+    parser.buf << "GET / HTTP/1.0\r\nX-Forwarded-Ssl: off\r\n\r\n"
+    assert_equal req, parser.parse
     assert_equal '80', req['SERVER_PORT'], req.inspect
     assert_equal 'http', req['rack.url_scheme'], req.inspect
-    assert_equal '', tmp
+    assert_equal '', parser.buf
   end
 
   def test_parse_strange_headers
     parser = HttpParser.new
-    req = {}
+    req = parser.env
     should_be_good = "GET / HTTP/1.1\r\naaaaaaaaaaaaa:++++++++++\r\n\r\n"
-    assert_equal req, parser.headers(req, should_be_good)
-    assert_equal '', should_be_good
+    parser.buf << should_be_good
+    assert_equal req, parser.parse
+    assert_equal '', parser.buf
     assert parser.keepalive?
   end
 
@@ -217,14 +218,14 @@ class HttpParserTest < Test::Unit::TestCase
   def test_nasty_pound_header
     parser = HttpParser.new
     nasty_pound_header = "GET / HTTP/1.1\r\nX-SSL-Bullshit:   -----BEGIN CERTIFICATE-----\r\n\tMIIFbTCCBFWgAwIBAgICH4cwDQYJKoZIhvcNAQEFBQAwcDELMAkGA1UEBhMCVUsx\r\n\tETAPBgNVBAoTCGVTY2llbmNlMRIwEAYDVQQLEwlBdXRob3JpdHkxCzAJBgNVBAMT\r\n\tAkNBMS0wKwYJKoZIhvcNAQkBFh5jYS1vcGVyYXRvckBncmlkLXN1cHBvcnQuYWMu\r\n\tdWswHhcNMDYwNzI3MTQxMzI4WhcNMDcwNzI3MTQxMzI4WjBbMQswCQYDVQQGEwJV\r\n\tSzERMA8GA1UEChMIZVNjaWVuY2UxEzARBgNVBAsTCk1hbmNoZXN0ZXIxCzAJBgNV\r\n\tBAcTmrsogriqMWLAk1DMRcwFQYDVQQDEw5taWNoYWVsIHBhcmQYJKoZIhvcNAQEB\r\n\tBQADggEPADCCAQoCggEBANPEQBgl1IaKdSS1TbhF3hEXSl72G9J+WC/1R64fAcEF\r\n\tW51rEyFYiIeZGx/BVzwXbeBoNUK41OK65sxGuflMo5gLflbwJtHBRIEKAfVVp3YR\r\n\tgW7cMA/s/XKgL1GEC7rQw8lIZT8RApukCGqOVHSi/F1SiFlPDxuDfmdiNzL31+sL\r\n\t0iwHDdNkGjy5pyBSB8Y79dsSJtCW/iaLB0/n8Sj7HgvvZJ7x0fr+RQjYOUUfrePP\r\n\tu2MSpFyf+9BbC/aXgaZuiCvSR+8Snv3xApQY+fULK/xY8h8Ua51iXoQ5jrgu2SqR\r\n\twgA7BUi3G8LFzMBl8FRCDYGUDy7M6QaHXx1ZWIPWNKsCAwEAAaOCAiQwggIgMAwG\r\n\tA1UdEwEB/wQCMAAwEQYJYIZIAYb4QgEBBAQDAgWgMA4GA1UdDwEB/wQEAwID6DAs\r\n\tBglghkgBhvhCAQ0EHxYdVUsgZS1TY2llbmNlIFVzZXIgQ2VydGlmaWNhdGUwHQYD\r\n\tVR0OBBYEFDTt/sf9PeMaZDHkUIldrDYMNTBZMIGaBgNVHSMEgZIwgY+AFAI4qxGj\r\n\tloCLDdMVKwiljjDastqooXSkcjBwMQswCQYDVQQGEwJVSzERMA8GA1UEChMIZVNj\r\n\taWVuY2UxEjAQBgNVBAsTCUF1dGhvcml0eTELMAkGA1UEAxMCQ0ExLTArBgkqhkiG\r\n\t9w0BCQEWHmNhLW9wZXJhdG9yQGdyaWQtc3VwcG9ydC5hYy51a4IBADApBgNVHRIE\r\n\tIjAggR5jYS1vcGVyYXRvckBncmlkLXN1cHBvcnQuYWMudWswGQYDVR0gBBIwEDAO\r\n\tBgwrBgEEAdkvAQEBAQYwPQYJYIZIAYb4QgEEBDAWLmh0dHA6Ly9jYS5ncmlkLXN1\r\n\tcHBvcnQuYWMudmT4sopwqlBWsvcHViL2NybC9jYWNybC5jcmwwPQYJYIZIAYb4QgEDBDAWLmh0\r\n\tdHA6Ly9jYS5ncmlkLXN1cHBvcnQuYWMudWsvcHViL2NybC9jYWNybC5jcmwwPwYD\r\n\tVR0fBDgwNjA0oDKgMIYuaHR0cDovL2NhLmdyaWQt5hYy51ay9wdWIv\r\n\tY3JsL2NhY3JsLmNybDANBgkqhkiG9w0BAQUFAAOCAQEAS/U4iiooBENGW/Hwmmd3\r\n\tXCy6Zrt08YjKCzGNjorT98g8uGsqYjSxv/hmi0qlnlHs+k/3Iobc3LjS5AMYr5L8\r\n\tUO7OSkgFFlLHQyC9JzPfmLCAugvzEbyv4Olnsr8hbxF1MbKZoQxUZtMVu29wjfXk\r\n\thTeApBv7eaKCWpSp7MCbvgzm74izKhu3vlDk9w6qVrxePfGgpKPqfHiOoGhFnbTK\r\n\twTC6o2xq5y0qZ03JonF7OJspEd3I5zKY3E+ov7/ZhW6DqT8UFvsAdjvQbXyhV8Eu\r\n\tYhixw1aKEPzNjNowuIseVogKOLXxWI5vAi5HgXdS0/ES5gDGsABo4fqovUKlgop3\r\n\tRA==\r\n\t-----END CERTIFICATE-----\r\n\r\n"
-    req = {}
-    buf = nasty_pound_header.dup
+    req = parser.env
+    parser.buf << nasty_pound_header.dup
 
     assert nasty_pound_header =~ /(-----BEGIN .*--END CERTIFICATE-----)/m
     expect = $1.dup
     expect.gsub!(/\r\n\t/, ' ')
-    assert_equal req, parser.headers(req, buf)
-    assert_equal '', buf
+    assert_equal req, parser.parse
+    assert_equal '', parser.buf
     assert_equal expect, req['HTTP_X_SSL_BULLSHIT']
   end
 
@@ -235,9 +236,10 @@ class HttpParserTest < Test::Unit::TestCase
              "\t\r\n" \
              "    \r\n" \
              "  ASDF\r\n\r\n"
-    req = {}
-    assert_equal req, parser.headers(req, header)
-    assert_equal '', header
+    parser.buf << header
+    req = parser.env
+    assert_equal req, parser.parse
+    assert_equal '', parser.buf
     assert_equal 'ASDF', req['HTTP_X_ASDF']
   end
 
@@ -249,9 +251,10 @@ class HttpParserTest < Test::Unit::TestCase
              "\t\r\n" \
              "       x\r\n" \
              "  ASDF\r\n\r\n"
-    req = {}
-    assert_equal req, parser.headers(req, header)
-    assert_equal '', header
+    req = parser.env
+    parser.buf << header
+    assert_equal req, parser.parse
+    assert_equal '', parser.buf
     assert_equal 'hi y x ASDF', req['HTTP_X_ASDF']
   end
 
@@ -261,8 +264,9 @@ class HttpParserTest < Test::Unit::TestCase
              "Host: \r\n" \
              "    YHBT.net\r\n" \
              "\r\n"
-    req = {}
-    assert_equal req, parser.headers(req, header)
+    parser.buf << header
+    req = parser.env
+    assert_equal req, parser.parse
     assert_equal 'example.com', req['HTTP_HOST']
   end
 
@@ -271,21 +275,22 @@ class HttpParserTest < Test::Unit::TestCase
   # in case we ever go multithreaded/evented...
   def test_resumable_continuations
     nr = 1000
-    req = {}
     header = "GET / HTTP/1.1\r\n" \
              "X-ASDF:      \r\n" \
              "  hello\r\n"
     tmp = []
     nr.times { |i|
       parser = HttpParser.new
-      assert parser.headers(req, "#{header} #{i}\r\n").nil?
+      req = parser.env
+      parser.buf << "#{header} #{i}\r\n"
+      assert parser.parse.nil?
       asdf = req['HTTP_X_ASDF']
       assert_equal "hello #{i}", asdf
       tmp << [ parser, asdf ]
-      req.clear
     }
     tmp.each_with_index { |(parser, asdf), i|
-      assert_equal req, parser.headers(req, "#{header} #{i}\r\n .\r\n\r\n")
+      parser.buf << " .\r\n\r\n"
+      assert parser.parse
       assert_equal "hello #{i} .", asdf
     }
   end
@@ -296,8 +301,9 @@ class HttpParserTest < Test::Unit::TestCase
              "    y\r\n" \
              "Host: hello\r\n" \
              "\r\n"
-    req = {}
-    assert_raises(HttpParserError) { parser.headers(req, header) }
+    parser.buf << header
+    req = parser.env
+    assert_raises(HttpParserError) { parser.parse }
   end
 
   def test_parse_ie6_urls
@@ -309,7 +315,7 @@ class HttpParserTest < Test::Unit::TestCase
        /mal"formed"?
     ).each do |path|
       parser = HttpParser.new
-      req = {}
+      req = parser.env
       sorta_safe = %(GET #{path} HTTP/1.1\r\n\r\n)
       assert_equal req, parser.headers(req, sorta_safe)
       assert_equal path, req['REQUEST_URI']
@@ -320,7 +326,7 @@ class HttpParserTest < Test::Unit::TestCase
   
   def test_parse_error
     parser = HttpParser.new
-    req = {}
+    req = parser.env
     bad_http = "GET / SsUTF/1.1"
 
     assert_raises(HttpParserError) { parser.headers(req, bad_http) }
@@ -334,7 +340,7 @@ class HttpParserTest < Test::Unit::TestCase
 
   def test_piecemeal
     parser = HttpParser.new
-    req = {}
+    req = parser.env
     http = "GET"
     assert_nil parser.headers(req, http)
     assert_nil parser.headers(req, http)
@@ -356,9 +362,10 @@ class HttpParserTest < Test::Unit::TestCase
   # not common, but underscores do appear in practice
   def test_absolute_uri_underscores
     parser = HttpParser.new
-    req = {}
+    req = parser.env
     http = "GET http://under_score.example.com/foo?q=bar HTTP/1.0\r\n\r\n"
-    assert_equal req, parser.headers(req, http)
+    parser.buf << http
+    assert_equal req, parser.parse
     assert_equal 'http', req['rack.url_scheme']
     assert_equal '/foo?q=bar', req['REQUEST_URI']
     assert_equal '/foo', req['REQUEST_PATH']
@@ -367,16 +374,17 @@ class HttpParserTest < Test::Unit::TestCase
     assert_equal 'under_score.example.com', req['HTTP_HOST']
     assert_equal 'under_score.example.com', req['SERVER_NAME']
     assert_equal '80', req['SERVER_PORT']
-    assert_equal "", http
+    assert_equal "", parser.buf
     assert ! parser.keepalive?
   end
 
   # some dumb clients add users because they're stupid
   def test_absolute_uri_w_user
     parser = HttpParser.new
-    req = {}
+    req = parser.env
     http = "GET http://user%20space@example.com/foo?q=bar HTTP/1.0\r\n\r\n"
-    assert_equal req, parser.headers(req, http)
+    parser.buf << http
+    assert_equal req, parser.parse
     assert_equal 'http', req['rack.url_scheme']
     assert_equal '/foo?q=bar', req['REQUEST_URI']
     assert_equal '/foo', req['REQUEST_PATH']
@@ -385,7 +393,7 @@ class HttpParserTest < Test::Unit::TestCase
     assert_equal 'example.com', req['HTTP_HOST']
     assert_equal 'example.com', req['SERVER_NAME']
     assert_equal '80', req['SERVER_PORT']
-    assert_equal "", http
+    assert_equal "", parser.buf
     assert ! parser.keepalive?
   end
 
@@ -394,7 +402,7 @@ class HttpParserTest < Test::Unit::TestCase
   def test_absolute_uri_uri_parse
     "#{URI::REGEXP::PATTERN::UNRESERVED};:&=+$,".split(//).each do |char|
       parser = HttpParser.new
-      req = {}
+      req = parser.env
       http = "GET http://#{char}@example.com/ HTTP/1.0\r\n\r\n"
       assert_equal req, parser.headers(req, http)
       assert_equal 'http', req['rack.url_scheme']
@@ -412,9 +420,9 @@ class HttpParserTest < Test::Unit::TestCase
 
   def test_absolute_uri
     parser = HttpParser.new
-    req = {}
-    http = "GET http://example.com/foo?q=bar HTTP/1.0\r\n\r\n"
-    assert_equal req, parser.headers(req, http)
+    req = parser.env
+    parser.buf << "GET http://example.com/foo?q=bar HTTP/1.0\r\n\r\n"
+    assert_equal req, parser.parse
     assert_equal 'http', req['rack.url_scheme']
     assert_equal '/foo?q=bar', req['REQUEST_URI']
     assert_equal '/foo', req['REQUEST_PATH']
@@ -423,17 +431,18 @@ class HttpParserTest < Test::Unit::TestCase
     assert_equal 'example.com', req['HTTP_HOST']
     assert_equal 'example.com', req['SERVER_NAME']
     assert_equal '80', req['SERVER_PORT']
-    assert_equal "", http
+    assert_equal "", parser.buf
     assert ! parser.keepalive?
   end
 
   # X-Forwarded-Proto is not in rfc2616, absolute URIs are, however...
   def test_absolute_uri_https
     parser = HttpParser.new
-    req = {}
+    req = parser.env
     http = "GET https://example.com/foo?q=bar HTTP/1.1\r\n" \
            "X-Forwarded-Proto: http\r\n\r\n"
-    assert_equal req, parser.headers(req, http)
+    parser.buf << http
+    assert_equal req, parser.parse
     assert_equal 'https', req['rack.url_scheme']
     assert_equal '/foo?q=bar', req['REQUEST_URI']
     assert_equal '/foo', req['REQUEST_PATH']
@@ -442,17 +451,17 @@ class HttpParserTest < Test::Unit::TestCase
     assert_equal 'example.com', req['HTTP_HOST']
     assert_equal 'example.com', req['SERVER_NAME']
     assert_equal '443', req['SERVER_PORT']
-    assert_equal "", http
+    assert_equal "", parser.buf
     assert parser.keepalive?
   end
 
   # Host: header should be ignored for absolute URIs
   def test_absolute_uri_with_port
     parser = HttpParser.new
-    req = {}
-    http = "GET http://example.com:8080/foo?q=bar HTTP/1.2\r\n" \
+    req = parser.env
+    parser.buf << "GET http://example.com:8080/foo?q=bar HTTP/1.2\r\n" \
            "Host: bad.example.com\r\n\r\n"
-    assert_equal req, parser.headers(req, http)
+    assert_equal req, parser.parse
     assert_equal 'http', req['rack.url_scheme']
     assert_equal '/foo?q=bar', req['REQUEST_URI']
     assert_equal '/foo', req['REQUEST_PATH']
@@ -461,16 +470,16 @@ class HttpParserTest < Test::Unit::TestCase
     assert_equal 'example.com:8080', req['HTTP_HOST']
     assert_equal 'example.com', req['SERVER_NAME']
     assert_equal '8080', req['SERVER_PORT']
-    assert_equal "", http
+    assert_equal "", parser.buf
     assert ! parser.keepalive? # TODO: read HTTP/1.2 when it's final
   end
 
   def test_absolute_uri_with_empty_port
     parser = HttpParser.new
-    req = {}
-    http = "GET https://example.com:/foo?q=bar HTTP/1.1\r\n" \
+    req = parser.env
+    parser.buf << "GET https://example.com:/foo?q=bar HTTP/1.1\r\n" \
            "Host: bad.example.com\r\n\r\n"
-    assert_equal req, parser.headers(req, http)
+    assert_equal req, parser.parse
     assert_equal 'https', req['rack.url_scheme']
     assert_equal '/foo?q=bar', req['REQUEST_URI']
     assert_equal '/foo', req['REQUEST_PATH']
@@ -479,13 +488,13 @@ class HttpParserTest < Test::Unit::TestCase
     assert_equal 'example.com:', req['HTTP_HOST']
     assert_equal 'example.com', req['SERVER_NAME']
     assert_equal '443', req['SERVER_PORT']
-    assert_equal "", http
+    assert_equal "", parser.buf
     assert parser.keepalive? # TODO: read HTTP/1.2 when it's final
   end
 
   def test_absolute_ipv6_uri
     parser = HttpParser.new
-    req = {}
+    req = parser.env
     url = "http://[::1]/foo?q=bar"
     http = "GET #{url} HTTP/1.1\r\n" \
            "Host: bad.example.com\r\n\r\n"
@@ -507,7 +516,7 @@ class HttpParserTest < Test::Unit::TestCase
 
   def test_absolute_ipv6_uri_alpha
     parser = HttpParser.new
-    req = {}
+    req = parser.env
     url = "http://[::a]/"
     http = "GET #{url} HTTP/1.1\r\n" \
            "Host: bad.example.com\r\n\r\n"
@@ -524,7 +533,7 @@ class HttpParserTest < Test::Unit::TestCase
 
   def test_absolute_ipv6_uri_alpha_2
     parser = HttpParser.new
-    req = {}
+    req = parser.env
     url = "http://[::B]/"
     http = "GET #{url} HTTP/1.1\r\n" \
            "Host: bad.example.com\r\n\r\n"
@@ -541,7 +550,7 @@ class HttpParserTest < Test::Unit::TestCase
 
   def test_absolute_ipv6_uri_with_empty_port
     parser = HttpParser.new
-    req = {}
+    req = parser.env
     url = "https://[::1]:/foo?q=bar"
     http = "GET #{url} HTTP/1.1\r\n" \
            "Host: bad.example.com\r\n\r\n"
@@ -563,7 +572,7 @@ class HttpParserTest < Test::Unit::TestCase
 
   def test_absolute_ipv6_uri_with_port
     parser = HttpParser.new
-    req = {}
+    req = parser.env
     url = "https://[::1]:666/foo?q=bar"
     http = "GET #{url} HTTP/1.1\r\n" \
            "Host: bad.example.com\r\n\r\n"
@@ -585,88 +594,86 @@ class HttpParserTest < Test::Unit::TestCase
 
   def test_ipv6_host_header
     parser = HttpParser.new
-    req = {}
-    http = "GET / HTTP/1.1\r\n" \
-           "Host: [::1]\r\n\r\n"
-    assert_equal req, parser.headers(req, http)
+    req = parser.env
+    parser.buf << "GET / HTTP/1.1\r\n" \
+                  "Host: [::1]\r\n\r\n"
+    assert_equal req, parser.parse
     assert_equal "[::1]", req['HTTP_HOST']
     assert_equal "[::1]", req['SERVER_NAME']
     assert_equal '80', req['SERVER_PORT']
-    assert_equal "", http
+    assert_equal "", parser.buf
     assert parser.keepalive? # TODO: read HTTP/1.2 when it's final
   end
 
   def test_ipv6_host_header_with_port
     parser = HttpParser.new
-    req = {}
-    http = "GET / HTTP/1.1\r\n" \
-           "Host: [::1]:666\r\n\r\n"
-    assert_equal req, parser.headers(req, http)
+    req = parser.env
+    parser.buf << "GET / HTTP/1.1\r\n" \
+                  "Host: [::1]:666\r\n\r\n"
+    assert_equal req, parser.parse
     assert_equal "[::1]", req['SERVER_NAME']
     assert_equal '666', req['SERVER_PORT']
     assert_equal "[::1]:666", req['HTTP_HOST']
-    assert_equal "", http
+    assert_equal "", parser.buf
     assert parser.keepalive? # TODO: read HTTP/1.2 when it's final
   end
 
   def test_ipv6_host_header_with_empty_port
     parser = HttpParser.new
-    req = {}
-    http = "GET / HTTP/1.1\r\n" \
-           "Host: [::1]:\r\n\r\n"
-    assert_equal req, parser.headers(req, http)
+    req = parser.env
+    parser.buf << "GET / HTTP/1.1\r\nHost: [::1]:\r\n\r\n"
+    assert_equal req, parser.parse
     assert_equal "[::1]", req['SERVER_NAME']
     assert_equal '80', req['SERVER_PORT']
     assert_equal "[::1]:", req['HTTP_HOST']
-    assert_equal "", http
+    assert_equal "", parser.buf
     assert parser.keepalive? # TODO: read HTTP/1.2 when it's final
   end
 
   # XXX Highly unlikely..., just make sure we don't segfault or assert on it
   def test_broken_ipv6_host_header
     parser = HttpParser.new
-    req = {}
-    http = "GET / HTTP/1.1\r\n" \
-           "Host: [::1:\r\n\r\n"
-    assert_equal req, parser.headers(req, http)
+    req = parser.env
+    parser.buf << "GET / HTTP/1.1\r\nHost: [::1:\r\n\r\n"
+    assert_equal req, parser.parse
     assert_equal "[", req['SERVER_NAME']
     assert_equal ':1:', req['SERVER_PORT']
     assert_equal "[::1:", req['HTTP_HOST']
-    assert_equal "", http
+    assert_equal "", parser.buf
   end
 
   def test_put_body_oneshot
     parser = HttpParser.new
-    req = {}
-    http = "PUT / HTTP/1.0\r\nContent-Length: 5\r\n\r\nabcde"
-    assert_equal req, parser.headers(req, http)
+    req = parser.env
+    parser.buf << "PUT / HTTP/1.0\r\nContent-Length: 5\r\n\r\nabcde"
+    assert_equal req, parser.parse
     assert_equal '/', req['REQUEST_PATH']
     assert_equal '/', req['REQUEST_URI']
     assert_equal 'PUT', req['REQUEST_METHOD']
     assert_equal 'HTTP/1.0', req['HTTP_VERSION']
     assert_equal 'HTTP/1.0', req['SERVER_PROTOCOL']
-    assert_equal "abcde", http
+    assert_equal "abcde", parser.buf
     assert ! parser.keepalive? # TODO: read HTTP/1.2 when it's final
   end
 
   def test_put_body_later
     parser = HttpParser.new
-    req = {}
-    http = "PUT /l HTTP/1.0\r\nContent-Length: 5\r\n\r\n"
-    assert_equal req, parser.headers(req, http)
+    req = parser.env
+    parser.buf << "PUT /l HTTP/1.0\r\nContent-Length: 5\r\n\r\n"
+    assert_equal req, parser.parse
     assert_equal '/l', req['REQUEST_PATH']
     assert_equal '/l', req['REQUEST_URI']
     assert_equal 'PUT', req['REQUEST_METHOD']
     assert_equal 'HTTP/1.0', req['HTTP_VERSION']
     assert_equal 'HTTP/1.0', req['SERVER_PROTOCOL']
-    assert_equal "", http
+    assert_equal "", parser.buf
     assert ! parser.keepalive? # TODO: read HTTP/1.2 when it's final
   end
 
   def test_unknown_methods
     %w(GETT HEADR XGET XHEAD).each { |m|
       parser = HttpParser.new
-      req = {}
+      req = parser.env
       s = "#{m} /forums/1/topics/2375?page=1#posts-17408 HTTP/1.1\r\n\r\n"
       ok = false
       assert_nothing_raised do
@@ -684,17 +691,18 @@ class HttpParserTest < Test::Unit::TestCase
 
   def test_fragment_in_uri
     parser = HttpParser.new
-    req = {}
+    req = parser.env
     get = "GET /forums/1/topics/2375?page=1#posts-17408 HTTP/1.1\r\n\r\n"
+    parser.buf << get
     ok = false
     assert_nothing_raised do
-      ok = parser.headers(req, get)
+      ok = parser.parse
     end
     assert ok
     assert_equal '/forums/1/topics/2375?page=1', req['REQUEST_URI']
     assert_equal 'posts-17408', req['FRAGMENT']
     assert_equal 'page=1', req['QUERY_STRING']
-    assert_equal '', get
+    assert_equal '', parser.buf
     assert parser.keepalive?
   end
 
@@ -720,7 +728,8 @@ class HttpParserTest < Test::Unit::TestCase
     10.times do |c|
       get = "GET /#{rand_data(10,120)} HTTP/1.1\r\nX-#{rand_data(1024, 1024+(c*1024))}: Test\r\n\r\n"
       assert_raises Unicorn::HttpParserError do
-        parser.headers({}, get)
+        parser.buf << get
+        parser.parse
         parser.clear
       end
     end
@@ -729,7 +738,8 @@ class HttpParserTest < Test::Unit::TestCase
     10.times do |c|
       get = "GET /#{rand_data(10,120)} HTTP/1.1\r\nX-Test: #{rand_data(1024, 1024+(c*1024), false)}\r\n\r\n"
       assert_raises Unicorn::HttpParserError do
-        parser.headers({}, get)
+        parser.buf << get
+        parser.parse
         parser.clear
       end
     end
@@ -737,16 +747,18 @@ class HttpParserTest < Test::Unit::TestCase
     # then large headers are rejected too
     get = "GET /#{rand_data(10,120)} HTTP/1.1\r\n"
     get << "X-Test: test\r\n" * (80 * 1024)
+    parser.buf << get
     assert_raises Unicorn::HttpParserError do
-      parser.headers({}, get)
-      parser.clear
+      parser.parse
     end
+    parser.clear
 
     # finally just that random garbage gets blocked all the time
     10.times do |c|
       get = "GET #{rand_data(1024, 1024+(c*1024), false)} #{rand_data(1024, 1024+(c*1024), false)}\r\n\r\n"
       assert_raises Unicorn::HttpParserError do
-        parser.headers({}, get)
+        parser.buf << get
+        parser.parse
         parser.clear
       end
     end
diff --git a/test/unit/test_http_parser_ng.rb b/test/unit/test_http_parser_ng.rb
index b60afdf..e57428c 100644
--- a/test/unit/test_http_parser_ng.rb
+++ b/test/unit/test_http_parser_ng.rb
@@ -97,16 +97,17 @@ class HttpParserNgTest < Test::Unit::TestCase
   end
 
   def test_identity_byte_headers
-    req = {}
+    req = @parser.env
     str = "PUT / HTTP/1.1\r\n"
     str << "Content-Length: 123\r\n"
     str << "\r"
-    hdr = ""
+    hdr = @parser.buf
     str.each_byte { |byte|
-      assert_nil @parser.headers(req, hdr << byte.chr)
+      hdr << byte.chr
+      assert_nil @parser.parse
     }
     hdr << "\n"
-    assert_equal req.object_id, @parser.headers(req, hdr).object_id
+    assert_equal req.object_id, @parser.parse.object_id
     assert_equal '123', req['CONTENT_LENGTH']
     assert_equal 0, hdr.size
     assert ! @parser.keepalive?
@@ -121,13 +122,14 @@ class HttpParserNgTest < Test::Unit::TestCase
   end
 
   def test_identity_step_headers
-    req = {}
-    str = "PUT / HTTP/1.1\r\n"
-    assert ! @parser.headers(req, str)
+    req = @parser.env
+    str = @parser.buf
+    str << "PUT / HTTP/1.1\r\n"
+    assert ! @parser.parse
     str << "Content-Length: 123\r\n"
-    assert ! @parser.headers(req, str)
+    assert ! @parser.parse
     str << "\r\n"
-    assert_equal req.object_id, @parser.headers(req, str).object_id
+    assert_equal req.object_id, @parser.parse.object_id
     assert_equal '123', req['CONTENT_LENGTH']
     assert_equal 0, str.size
     assert ! @parser.keepalive?
@@ -141,9 +143,10 @@ class HttpParserNgTest < Test::Unit::TestCase
   end
 
   def test_identity_oneshot_header
-    req = {}
-    str = "PUT / HTTP/1.1\r\nContent-Length: 123\r\n\r\n"
-    assert_equal req.object_id, @parser.headers(req, str).object_id
+    req = @parser.env
+    str = @parser.buf
+    str << "PUT / HTTP/1.1\r\nContent-Length: 123\r\n\r\n"
+    assert_equal req.object_id, @parser.parse.object_id
     assert_equal '123', req['CONTENT_LENGTH']
     assert_equal 0, str.size
     assert ! @parser.keepalive?
@@ -157,11 +160,12 @@ class HttpParserNgTest < Test::Unit::TestCase
 
   def test_identity_oneshot_header_with_body
     body = ('a' * 123).freeze
-    req = {}
-    str = "PUT / HTTP/1.1\r\n" \
-          "Content-Length: #{body.length}\r\n" \
-          "\r\n#{body}"
-    assert_equal req.object_id, @parser.headers(req, str).object_id
+    req = @parser.env
+    str = @parser.buf
+    str << "PUT / HTTP/1.1\r\n" \
+           "Content-Length: #{body.length}\r\n" \
+           "\r\n#{body}"
+    assert_equal req.object_id, @parser.parse.object_id
     assert_equal '123', req['CONTENT_LENGTH']
     assert_equal 123, str.size
     assert_equal body, str
@@ -174,8 +178,9 @@ class HttpParserNgTest < Test::Unit::TestCase
   end
 
   def test_identity_oneshot_header_with_body_partial
-    str = "PUT / HTTP/1.1\r\nContent-Length: 123\r\n\r\na"
-    assert_equal Hash, @parser.headers({}, str).class
+    str = @parser.buf
+    str << "PUT / HTTP/1.1\r\nContent-Length: 123\r\n\r\na"
+    assert_equal Hash, @parser.parse.class
     assert_equal 1, str.size
     assert_equal 'a', str
     tmp = ''
@@ -192,8 +197,9 @@ class HttpParserNgTest < Test::Unit::TestCase
   end
 
   def test_identity_oneshot_header_with_body_slop
-    str = "PUT / HTTP/1.1\r\nContent-Length: 1\r\n\r\naG"
-    assert_equal Hash, @parser.headers({}, str).class
+    str = @parser.buf
+    str << "PUT / HTTP/1.1\r\nContent-Length: 1\r\n\r\naG"
+    assert_equal Hash, @parser.parse.class
     assert_equal 2, str.size
     assert_equal 'aG', str
     tmp = ''
@@ -206,92 +212,96 @@ class HttpParserNgTest < Test::Unit::TestCase
   end
 
   def test_chunked
-    str = "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n"
-    req = {}
-    assert_equal req, @parser.headers(req, str)
+    str = @parser.buf
+    req = @parser.env
+    str << "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n"
+    assert_equal req, @parser.parse, "msg=#{str}"
     assert_equal 0, str.size
     tmp = ""
-    assert_nil @parser.filter_body(tmp, "6")
+    assert_nil @parser.filter_body(tmp, str << "6")
     assert_equal 0, tmp.size
-    assert_nil @parser.filter_body(tmp, rv = "\r\n")
-    assert_equal 0, rv.size
+    assert_nil @parser.filter_body(tmp, str << "\r\n")
+    assert_equal 0, str.size
     assert_equal 0, tmp.size
     tmp = ""
-    assert_nil @parser.filter_body(tmp, "..")
+    assert_nil @parser.filter_body(tmp, str << "..")
     assert_equal "..", tmp
-    assert_nil @parser.filter_body(tmp, "abcd\r\n0\r\n")
+    assert_nil @parser.filter_body(tmp, str << "abcd\r\n0\r\n")
     assert_equal "abcd", tmp
-    rv = "PUT"
-    assert_equal rv.object_id, @parser.filter_body(tmp, rv).object_id
-    assert_equal "PUT", rv
+    assert_equal str.object_id, @parser.filter_body(tmp, str << "PUT").object_id
+    assert_equal "PUT", str
     assert ! @parser.keepalive?
-    rv << "TY: FOO\r\n\r\n"
-    assert_equal req, @parser.trailers(req, rv)
+    str << "TY: FOO\r\n\r\n"
+    assert_equal req, @parser.parse
     assert_equal "FOO", req["HTTP_PUTTY"]
     assert @parser.keepalive?
   end
 
   def test_two_chunks
-    str = "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n"
-    req = {}
-    assert_equal req, @parser.headers(req, str)
+    str = @parser.buf
+    str << "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n"
+    req = @parser.env
+    assert_equal req, @parser.parse
     assert_equal 0, str.size
     tmp = ""
-    assert_nil @parser.filter_body(tmp, "6")
+    assert_nil @parser.filter_body(tmp, str << "6")
     assert_equal 0, tmp.size
-    assert_nil @parser.filter_body(tmp, rv = "\r\n")
-    assert_equal "", rv
+    assert_nil @parser.filter_body(tmp, str << "\r\n")
+    assert_equal "", str
     assert_equal 0, tmp.size
     tmp = ""
-    assert_nil @parser.filter_body(tmp, "..")
+    assert_nil @parser.filter_body(tmp, str << "..")
     assert_equal 2, tmp.size
     assert_equal "..", tmp
-    assert_nil @parser.filter_body(tmp, "abcd\r\n1")
+    assert_nil @parser.filter_body(tmp, str << "abcd\r\n1")
     assert_equal "abcd", tmp
-    assert_nil @parser.filter_body(tmp, "\r")
+    assert_nil @parser.filter_body(tmp, str << "\r")
     assert_equal "", tmp
-    assert_nil @parser.filter_body(tmp, "\n")
+    assert_nil @parser.filter_body(tmp, str << "\n")
     assert_equal "", tmp
-    assert_nil @parser.filter_body(tmp, "z")
+    assert_nil @parser.filter_body(tmp, str << "z")
     assert_equal "z", tmp
-    assert_nil @parser.filter_body(tmp, "\r\n")
-    assert_nil @parser.filter_body(tmp, "0")
-    assert_nil @parser.filter_body(tmp, "\r")
-    rv = @parser.filter_body(tmp, buf = "\nGET")
+    assert_nil @parser.filter_body(tmp, str << "\r\n")
+    assert_nil @parser.filter_body(tmp, str << "0")
+    assert_nil @parser.filter_body(tmp, str << "\r")
+    rv = @parser.filter_body(tmp, str << "\nGET")
     assert_equal "GET", rv
-    assert_equal buf.object_id, rv.object_id
+    assert_equal str.object_id, rv.object_id
     assert ! @parser.keepalive?
   end
 
   def test_big_chunk
-    str = "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n" \
-          "4000\r\nabcd"
-    req = {}
-    assert_equal req, @parser.headers(req, str)
+    str = @parser.buf
+    str << "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n" \
+           "4000\r\nabcd"
+    req = @parser.env
+    assert_equal req, @parser.parse
     tmp = ''
     assert_nil @parser.filter_body(tmp, str)
     assert_equal '', str
-    str = ' ' * 16300
+    str << ' ' * 16300
     assert_nil @parser.filter_body(tmp, str)
     assert_equal '', str
-    str = ' ' * 80
+    str << ' ' * 80
     assert_nil @parser.filter_body(tmp, str)
     assert_equal '', str
     assert ! @parser.body_eof?
-    assert_equal "", @parser.filter_body(tmp, "\r\n0\r\n")
+    assert_equal "", @parser.filter_body(tmp, str << "\r\n0\r\n")
     assert_equal "", tmp
     assert @parser.body_eof?
-    assert_equal req, @parser.trailers(req, moo = "\r\n")
-    assert_equal "", moo
+    str << "\r\n"
+    assert_equal req, @parser.parse
+    assert_equal "", str
     assert @parser.body_eof?
     assert @parser.keepalive?
   end
 
   def test_two_chunks_oneshot
-    str = "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n" \
-          "1\r\na\r\n2\r\n..\r\n0\r\n"
-    req = {}
-    assert_equal req, @parser.headers(req, str)
+    str = @parser.buf
+    req = @parser.env
+    str << "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n" \
+           "1\r\na\r\n2\r\n..\r\n0\r\n"
+    assert_equal req, @parser.parse
     tmp = ''
     assert_nil @parser.filter_body(tmp, str)
     assert_equal 'a..', tmp
@@ -302,31 +312,33 @@ class HttpParserNgTest < Test::Unit::TestCase
 
   def test_chunks_bytewise
     chunked = "10\r\nabcdefghijklmnop\r\n11\r\n0123456789abcdefg\r\n0\r\n"
-    str = "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n#{chunked}"
-    req = {}
-    assert_equal req, @parser.headers(req, str)
-    assert_equal chunked, str
+    str = "PUT / HTTP/1.1\r\ntransfer-Encoding: chunked\r\n\r\n"
+    buf = @parser.buf
+    buf << str
+    req = @parser.env
+    assert_equal req, @parser.parse
+    assert_equal "", buf
     tmp = ''
-    buf = ''
     body = ''
-    str = str[0..-2]
+    str = chunked[0..-2]
     str.each_byte { |byte|
       assert_nil @parser.filter_body(tmp, buf << byte.chr)
       body << tmp
     }
     assert_equal 'abcdefghijklmnop0123456789abcdefg', body
-    rv = @parser.filter_body(tmp, buf << "\n")
+    rv = @parser.filter_body(tmp, buf<< "\n")
     assert_equal rv.object_id, buf.object_id
     assert ! @parser.keepalive?
   end
 
   def test_trailers
-    str = "PUT / HTTP/1.1\r\n" \
-          "Trailer: Content-MD5\r\n" \
-          "transfer-Encoding: chunked\r\n\r\n" \
-          "1\r\na\r\n2\r\n..\r\n0\r\n"
-    req = {}
-    assert_equal req, @parser.headers(req, str)
+    req = @parser.env
+    str = @parser.buf
+    str << "PUT / HTTP/1.1\r\n" \
+           "Trailer: Content-MD5\r\n" \
+           "transfer-Encoding: chunked\r\n\r\n" \
+           "1\r\na\r\n2\r\n..\r\n0\r\n"
+    assert_equal req, @parser.parse
     assert_equal 'Content-MD5', req['HTTP_TRAILER']
     assert_nil req['HTTP_CONTENT_MD5']
     tmp = ''
@@ -341,19 +353,22 @@ class HttpParserNgTest < Test::Unit::TestCase
     assert_nil @parser.trailers(req, str)
     assert_equal md5_b64, req['HTTP_CONTENT_MD5']
     assert_equal "CONTENT_MD5: #{md5_b64}\r\n", str
-    assert_nil @parser.trailers(req, str << "\r")
-    assert_equal req, @parser.trailers(req, str << "\nGET / ")
+    str << "\r"
+    assert_nil @parser.parse
+    str << "\nGET / "
+    assert_equal req, @parser.parse
     assert_equal "GET / ", str
     assert @parser.keepalive?
   end
 
   def test_trailers_slowly
-    str = "PUT / HTTP/1.1\r\n" \
-          "Trailer: Content-MD5\r\n" \
-          "transfer-Encoding: chunked\r\n\r\n" \
-          "1\r\na\r\n2\r\n..\r\n0\r\n"
-    req = {}
-    assert_equal req, @parser.headers(req, str)
+    str = @parser.buf
+    str << "PUT / HTTP/1.1\r\n" \
+           "Trailer: Content-MD5\r\n" \
+           "transfer-Encoding: chunked\r\n\r\n" \
+           "1\r\na\r\n2\r\n..\r\n0\r\n"
+    req = @parser.env
+    assert_equal req, @parser.parse
     assert_equal 'Content-MD5', req['HTTP_TRAILER']
     assert_nil req['HTTP_CONTENT_MD5']
     tmp = ''
@@ -371,16 +386,19 @@ class HttpParserNgTest < Test::Unit::TestCase
     }
     assert_equal md5_b64, req['HTTP_CONTENT_MD5']
     assert_equal "CONTENT_MD5: #{md5_b64}\r\n", str
-    assert_nil @parser.trailers(req, str << "\r")
-    assert_equal req, @parser.trailers(req, str << "\n")
+    str << "\r"
+    assert_nil @parser.parse
+    str << "\n"
+    assert_equal req, @parser.parse
   end
 
   def test_max_chunk
-    str = "PUT / HTTP/1.1\r\n" \
-          "transfer-Encoding: chunked\r\n\r\n" \
-          "#{HttpParser::CHUNK_MAX.to_s(16)}\r\na\r\n2\r\n..\r\n0\r\n"
-    req = {}
-    assert_equal req, @parser.headers(req, str)
+    str = @parser.buf
+    str << "PUT / HTTP/1.1\r\n" \
+           "transfer-Encoding: chunked\r\n\r\n" \
+           "#{HttpParser::CHUNK_MAX.to_s(16)}\r\na\r\n2\r\n..\r\n0\r\n"
+    req = @parser.env
+    assert_equal req, @parser.parse
     assert_nil @parser.content_length
     assert_nothing_raised { @parser.filter_body('', str) }
     assert ! @parser.keepalive?
@@ -388,59 +406,61 @@ class HttpParserNgTest < Test::Unit::TestCase
 
   def test_max_body
     n = HttpParser::LENGTH_MAX
-    str = "PUT / HTTP/1.1\r\nContent-Length: #{n}\r\n\r\n"
-    req = {}
-    assert_nothing_raised { @parser.headers(req, str) }
+    @parser.buf << "PUT / HTTP/1.1\r\nContent-Length: #{n}\r\n\r\n"
+    req = @parser.env
+    assert_nothing_raised { @parser.headers(req, @parser.buf) }
     assert_equal n, req['CONTENT_LENGTH'].to_i
     assert ! @parser.keepalive?
   end
 
   def test_overflow_chunk
     n = HttpParser::CHUNK_MAX + 1
-    str = "PUT / HTTP/1.1\r\n" \
-          "transfer-Encoding: chunked\r\n\r\n" \
-          "#{n.to_s(16)}\r\na\r\n2\r\n..\r\n0\r\n"
-    req = {}
-    assert_equal req, @parser.headers(req, str)
+    str = @parser.buf
+    req = @parser.env
+    str << "PUT / HTTP/1.1\r\n" \
+           "transfer-Encoding: chunked\r\n\r\n" \
+           "#{n.to_s(16)}\r\na\r\n2\r\n..\r\n0\r\n"
+    assert_equal req, @parser.parse
     assert_nil @parser.content_length
     assert_raise(HttpParserError) { @parser.filter_body('', str) }
   end
 
   def test_overflow_content_length
     n = HttpParser::LENGTH_MAX + 1
-    str = "PUT / HTTP/1.1\r\nContent-Length: #{n}\r\n\r\n"
-    assert_raise(HttpParserError) { @parser.headers({}, str) }
+    @parser.buf << "PUT / HTTP/1.1\r\nContent-Length: #{n}\r\n\r\n"
+    assert_raise(HttpParserError) { @parser.parse }
   end
 
   def test_bad_chunk
-    str = "PUT / HTTP/1.1\r\n" \
-          "transfer-Encoding: chunked\r\n\r\n" \
-          "#zzz\r\na\r\n2\r\n..\r\n0\r\n"
-    req = {}
-    assert_equal req, @parser.headers(req, str)
+    @parser.buf << "PUT / HTTP/1.1\r\n" \
+                   "transfer-Encoding: chunked\r\n\r\n" \
+                   "#zzz\r\na\r\n2\r\n..\r\n0\r\n"
+    req = @parser.env
+    assert_equal req, @parser.parse
     assert_nil @parser.content_length
-    assert_raise(HttpParserError) { @parser.filter_body('', str) }
+    assert_raise(HttpParserError) { @parser.filter_body("", @parser.buf) }
   end
 
   def test_bad_content_length
-    str = "PUT / HTTP/1.1\r\nContent-Length: 7ff\r\n\r\n"
-    assert_raise(HttpParserError) { @parser.headers({}, str) }
+    @parser.buf << "PUT / HTTP/1.1\r\nContent-Length: 7ff\r\n\r\n"
+    assert_raise(HttpParserError) { @parser.parse }
   end
 
   def test_bad_trailers
-    str = "PUT / HTTP/1.1\r\n" \
-          "Trailer: Transfer-Encoding\r\n" \
-          "transfer-Encoding: chunked\r\n\r\n" \
-          "1\r\na\r\n2\r\n..\r\n0\r\n"
-    req = {}
-    assert_equal req, @parser.headers(req, str)
+    str = @parser.buf
+    req = @parser.env
+    str << "PUT / HTTP/1.1\r\n" \
+           "Trailer: Transfer-Encoding\r\n" \
+           "transfer-Encoding: chunked\r\n\r\n" \
+           "1\r\na\r\n2\r\n..\r\n0\r\n"
+    assert_equal req, @parser.parse
     assert_equal 'Transfer-Encoding', req['HTTP_TRAILER']
     tmp = ''
     assert_nil @parser.filter_body(tmp, str)
     assert_equal 'a..', tmp
     assert_equal '', str
     str << "Transfer-Encoding: identity\r\n\r\n"
-    assert_raise(HttpParserError) { @parser.trailers(req, str) }
+    assert_raise(HttpParserError) { @parser.parse }
   end
 
   def test_repeat_headers
@@ -449,18 +469,19 @@ class HttpParserNgTest < Test::Unit::TestCase
           "Trailer: Content-SHA1\r\n" \
           "transfer-Encoding: chunked\r\n\r\n" \
           "1\r\na\r\n2\r\n..\r\n0\r\n"
-    req = {}
-    assert_equal req, @parser.headers(req, str)
+    req = @parser.env
+    @parser.buf << str
+    assert_equal req, @parser.parse
     assert_equal 'Content-MD5,Content-SHA1', req['HTTP_TRAILER']
     assert ! @parser.keepalive?
   end
 
   def test_parse_simple_request
     parser = HttpParser.new
-    req = {}
-    http = "GET /read-rfc1945-if-you-dont-believe-me\r\n"
-    assert_equal req, parser.headers(req, http)
-    assert_equal '', http
+    req = parser.env
+    parser.buf << "GET /read-rfc1945-if-you-dont-believe-me\r\n"
+    assert_equal req, parser.parse
+    assert_equal '', parser.buf
     expect = {
       "SERVER_NAME"=>"localhost",
       "rack.url_scheme"=>"http",
@@ -556,10 +577,10 @@ class HttpParserNgTest < Test::Unit::TestCase
   end
 
   def test_ignore_version_header
-    http = "GET / HTTP/1.1\r\nVersion: hello\r\n\r\n"
-    req = {}
-    assert_equal req, @parser.headers(req, http)
-    assert_equal '', http
+    @parser.buf << "GET / HTTP/1.1\r\nVersion: hello\r\n\r\n"
+    req = @parser.env
+    assert_equal req, @parser.parse
+    assert_equal '', @parser.buf
     expect = {
       "SERVER_NAME" => "localhost",
       "rack.url_scheme" => "http",
diff --git a/test/unit/test_tee_input.rb b/test/unit/test_tee_input.rb
index 3766e1f..96eb268 100644
--- a/test/unit/test_tee_input.rb
+++ b/test/unit/test_tee_input.rb
@@ -12,7 +12,6 @@ class TestTeeInput < Test::Unit::TestCase
 
   def setup
     @rs = $/
-    @env = {}
     @rd, @wr = Kgio::UNIXSocket.pair
     @rd.sync = @wr.sync = true
     @start_pid = $$
@@ -154,12 +153,12 @@ class TestTeeInput < Test::Unit::TestCase
 
   def test_chunked
     @parser = Unicorn::HttpParser.new
-    @buf = "POST / HTTP/1.1\r\n" \
-           "Host: localhost\r\n" \
-           "Transfer-Encoding: chunked\r\n" \
-           "\r\n"
-    assert_equal @env, @parser.headers(@env, @buf)
-    assert_equal "", @buf
+    @parser.buf << "POST / HTTP/1.1\r\n" \
+                   "Host: localhost\r\n" \
+                   "Transfer-Encoding: chunked\r\n" \
+                   "\r\n"
+    assert @parser.parse
+    assert_equal "", @parser.buf
 
     pid = fork {
       @rd.close
@@ -189,12 +188,13 @@ class TestTeeInput < Test::Unit::TestCase
 
   def test_chunked_ping_pong
     @parser = Unicorn::HttpParser.new
-    @buf = "POST / HTTP/1.1\r\n" \
+    buf = @parser.buf
+    buf << "POST / HTTP/1.1\r\n" \
            "Host: localhost\r\n" \
            "Transfer-Encoding: chunked\r\n" \
            "\r\n"
-    assert_equal @env, @parser.headers(@env, @buf)
-    assert_equal "", @buf
+    assert @parser.parse
+    assert_equal "", buf
     chunks = %w(aa bbb cccc dddd eeee)
     rd, wr = IO.pipe
 
@@ -219,13 +219,14 @@ class TestTeeInput < Test::Unit::TestCase
 
   def test_chunked_with_trailer
     @parser = Unicorn::HttpParser.new
-    @buf = "POST / HTTP/1.1\r\n" \
+    buf = @parser.buf
+    buf << "POST / HTTP/1.1\r\n" \
            "Host: localhost\r\n" \
            "Trailer: Hello\r\n" \
            "Transfer-Encoding: chunked\r\n" \
            "\r\n"
-    assert_equal @env, @parser.headers(@env, @buf)
-    assert_equal "", @buf
+    assert @parser.parse
+    assert_equal "", buf
 
     pid = fork {
       @rd.close
@@ -239,7 +240,7 @@ class TestTeeInput < Test::Unit::TestCase
     assert_nil ti.len
     assert ! @parser.body_eof?
     assert_equal 25, ti.size
-    assert_equal "World", @env['HTTP_HELLO']
+    assert_equal "World", @parser.env['HTTP_HELLO']
     status = nil
     assert_nothing_raised { pid, status = Process.waitpid2(pid) }
     assert status.success?
@@ -247,13 +248,14 @@ class TestTeeInput < Test::Unit::TestCase
 
   def test_chunked_and_size_slow
     @parser = Unicorn::HttpParser.new
-    @buf = "POST / HTTP/1.1\r\n" \
+    buf = @parser.buf
+    buf << "POST / HTTP/1.1\r\n" \
            "Host: localhost\r\n" \
            "Trailer: Hello\r\n" \
            "Transfer-Encoding: chunked\r\n" \
            "\r\n"
-    assert_equal @env, @parser.headers(@env, @buf)
-    assert_equal "", @buf
+    assert @parser.parse
+    assert_equal "", buf
 
     @wr.write("9\r\nabcde")
     ti = TeeInput.new(@rd, @parser)
@@ -264,7 +266,7 @@ class TestTeeInput < Test::Unit::TestCase
     assert_equal 9, ti.size
     assert_equal "fghi", ti.read(9)
     assert_equal nil, ti.read(9)
-    assert_equal "World", @env['HTTP_HELLO']
+    assert_equal "World", @parser.env['HTTP_HELLO']
   end
 
   def test_gets_read_mix
@@ -280,12 +282,14 @@ private
   def init_request(body, size = nil)
     @parser = Unicorn::HttpParser.new
     body = body.to_s.freeze
-    @buf = "POST / HTTP/1.1\r\n" \
+    buf = @parser.buf
+    buf << "POST / HTTP/1.1\r\n" \
            "Host: localhost\r\n" \
            "Content-Length: #{size || body.size}\r\n" \
            "\r\n#{body}"
-    assert_equal @env, @parser.headers(@env, @buf)
-    assert_equal body, @buf
+    assert @parser.parse
+    assert_equal body, buf
+    @buf = buf
     @parser
   end