kcar 0.1.0

data/test/test_parser.rb

@@ -0,0 +1,257 @@
+# -*- encoding: binary -*-
+require 'test/unit'
+require 'pp'
+require 'kcar'
+require 'rack'
+
+class TestParser < Test::Unit::TestCase
+
+  def setup
+    @hp = Kcar::Parser.new
+  end
+
+  def test_reset
+    assert_nothing_raised { @hp.reset }
+  end
+
+  def test_parser_status_eof
+    buf = "HTTP/1.0 200 OK\r\n\r\n"
+    hdr = []
+    hdr_object_id = hdr.object_id
+    response = @hp.headers(hdr, buf)
+    assert_equal(["200 OK", hdr], response)
+    assert hdr.empty?
+    assert ! @hp.keepalive?
+    assert_equal hdr_object_id, hdr.object_id
+    assert_equal "", buf
+  end
+
+  def test_parser_status_eof_one_one
+    buf = "HTTP/1.1 200 OK\r\n\r\n"
+    hdr = []
+    response = @hp.headers(hdr, buf)
+    assert_equal(["200 OK", hdr], response)
+    assert hdr.empty?
+    assert ! @hp.keepalive? # no content-length
+  end
+
+  def test_parser_status_with_content_length
+    buf = "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n"
+    hdr = []
+    response = @hp.headers(hdr, buf)
+    assert_equal(["200 OK", hdr], response)
+    assert_equal([%w(Content-Length 0)], hdr)
+    assert @hp.keepalive?
+  end
+
+  def test_parser_content_length
+    buf = "HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"
+    rv = @hp.headers([], buf)
+    assert_equal "200 OK", rv[0]
+    assert_equal([ %w(Content-Length 5) ], rv[1])
+    assert_equal 2, rv.size
+    assert_equal "", buf
+    assert_equal 5, @hp.body_bytes_left
+  end
+
+  def test_parser_content_length_with_body
+    buf = "HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nabcde"
+    rv = @hp.headers([], buf)
+    assert_equal "200 OK", rv[0]
+    assert_equal([ %w(Content-Length 5) ], rv[1])
+    assert_equal "abcde", buf
+    assert_equal 5, @hp.body_bytes_left
+  end
+
+  def test_bad_crlf
+    buf = "HTTP/1.1 200 OK\nContent-Length: 5\n\r\nabcde"
+    rv = @hp.headers([], buf)
+    assert_equal "200 OK", rv[0]
+    assert_equal([ %w(Content-Length 5) ], rv[1])
+    assert_equal "abcde", buf
+    assert_equal 5, @hp.body_bytes_left
+    assert ! @hp.chunked?
+  end
+
+  def test_chunky_bad_crlf
+    buf = "HTTP/1.1 200 OK\n" \
+          "Transfer-Encoding: chunked\n\n" \
+          "6\nabcdef\n0\n\n"
+    rv = @hp.headers([], buf)
+    assert_equal "200 OK", rv[0]
+    assert_equal([ %w(Transfer-Encoding chunked) ], rv[1])
+    assert_equal "6\nabcdef\n0\n\n", buf
+    assert_nil @hp.body_bytes_left
+    assert @hp.chunked?
+    assert_nil @hp.filter_body(tmp = "", buf)
+    assert_equal "abcdef", tmp
+    assert @hp.keepalive?
+  end
+
+  def test_chunky
+    buf = "HTTP/1.1 200 OK\r\n" \
+          "Transfer-Encoding: chunked\r\n\r\n" \
+          "6\r\nabcdef\r\n0\r\n\r\n"
+    rv = @hp.headers([], buf)
+    assert_equal "200 OK", rv[0]
+    assert_equal([ %w(Transfer-Encoding chunked) ], rv[1])
+    assert_equal "6\r\nabcdef\r\n0\r\n\r\n", buf
+    assert_nil @hp.body_bytes_left
+    assert @hp.chunked?
+    assert_nil @hp.filter_body(tmp = "", buf)
+    assert_equal "abcdef", tmp
+    assert @hp.body_eof?
+    assert @hp.keepalive?
+  end
+
+  def test_chunky_two_step
+    buf = "HTTP/1.1 200 OK\r\n" \
+          "Transfer-Encoding: chunked\r\n\r\n" \
+          "6\r\nabcd"
+    buf2 = "ef\r\n0\r\n\r\n"
+    rv = @hp.headers([], buf)
+    assert_equal "200 OK", rv[0]
+    assert_equal([ %w(Transfer-Encoding chunked) ], rv[1])
+    assert_equal "6\r\nabcd", buf
+    assert_nil @hp.body_bytes_left
+    assert @hp.chunked?
+    assert_nil @hp.filter_body(tmp = "", buf)
+    assert_equal "abcd", tmp
+    assert_equal "", buf
+    assert ! @hp.body_eof?
+    assert_nil @hp.filter_body(tmp = "", buf2)
+    assert_equal "ef", tmp
+    assert @hp.body_eof?
+    assert_equal({}, @hp.trailers(tmp = {}, buf2))
+    assert @hp.keepalive?
+    assert_nothing_raised { @hp.reset }
+  end
+
+  def test_trailers_ary
+    buf = "HTTP/1.1 200 OK\r\n" \
+          "Trailer: Foo\r\n" \
+          "Transfer-Encoding: chunked\r\n\r\n" \
+          "6\r\nabcdef\r\n0\r\nFoo: bar\r\n\r\n"
+    rv = @hp.headers([], buf)
+    assert_equal "200 OK", rv[0]
+    assert_equal([ %w(Trailer Foo), %w(Transfer-Encoding chunked) ], rv[1])
+    assert_equal "6\r\nabcdef\r\n0\r\nFoo: bar\r\n\r\n", buf
+    assert_nil @hp.body_bytes_left
+    assert @hp.chunked?
+    assert_nil @hp.filter_body(tmp = "", buf)
+    assert_equal "abcdef", tmp
+    assert @hp.body_eof?
+    expect = [ %w(Trailer Foo),
+               %w(Transfer-Encoding chunked),
+               %w(Foo bar) ]
+    assert_equal(expect, @hp.trailers(rv[1], buf))
+    assert @hp.keepalive?
+    assert_nothing_raised { @hp.reset }
+  end
+
+  def test_extract_trailers_ary
+    tmp = [ %w(Trailer Foo), %w(Transfer-Encoding chunked), %w(Foo bar) ]
+    assert_equal [ %w(Foo bar) ], @hp.extract_trailers(tmp)
+  end
+
+  def test_extract_trailers_hash
+    tmp = {
+      'Trailer' => 'Foo',
+      'Transfer-Encoding' => 'chunked',
+      'Foo' => 'bar'
+    }
+    assert_equal [ %w(Foo bar) ], @hp.extract_trailers(tmp)
+  end
+
+  def test_extract_trailers_header_hash
+    tmp = Rack::Utils::HeaderHash.new(
+      'Trailer' => 'foo',
+      'Transfer-Encoding' => 'chunked',
+      'Foo' => 'bar'
+    )
+    assert_equal [ %w(foo bar) ], @hp.extract_trailers(tmp)
+  end
+
+  def test_repeated_headers_rack_hash
+    hdr = Rack::Utils::HeaderHash.new
+    buf = "HTTP/1.1 200 OK\r\nSet-Cookie: a=b\r\n"
+    assert_nil  @hp.headers(hdr, buf)
+    assert_equal({ 'Set-Cookie' => 'a=b' }, hdr.to_hash)
+    assert_nil @hp.headers(hdr, buf << "set-cookie: c=d\r\n")
+    assert_equal([ "200 OK", hdr ], @hp.headers(hdr, buf << "\r\n"))
+    assert_equal "", buf
+    assert_equal({ 'Set-Cookie' => "a=b\nc=d" }, hdr.to_hash)
+  end
+
+  def test_repeated_headers_plain_hash
+    hdr = {}
+    buf = "HTTP/1.1 200 OK\r\nSet-Cookie: a=b\r\n"
+    assert_nil  @hp.headers(hdr, buf)
+    assert_equal({ 'Set-Cookie' => 'a=b' }, hdr)
+    assert_nil @hp.headers(hdr, buf << "set-cookie: c=d\r\n")
+    assert_equal([ "200 OK", hdr ], @hp.headers(hdr, buf << "\r\n"))
+    assert_equal "", buf
+    assert_equal({ 'Set-Cookie' => 'a=b', 'set-cookie' => 'c=d' }, hdr)
+  end
+
+  def test_repeated_headers_array
+    hdr = []
+    buf = "HTTP/1.1 200 OK\r\nSet-Cookie: a=b\r\n"
+    assert_nil  @hp.headers(hdr, buf)
+    assert_equal([ %w(Set-Cookie a=b) ] , hdr)
+    assert_nil @hp.headers(hdr, buf << "set-cookie: c=d\r\n")
+    assert_equal([ "200 OK", hdr ], @hp.headers(hdr, buf << "\r\n"))
+    assert_equal "", buf
+    assert_equal([ %w(Set-Cookie a=b), %w(set-cookie c=d) ], hdr)
+  end
+
+  def test_long_line_headers_array
+    hdr = []
+    buf = "HTTP/1.1 200 OK\r\na: b\r\n"
+    assert_nil  @hp.headers(hdr, buf)
+    assert_equal([ %w(a b) ] , hdr)
+    assert_nil @hp.headers(hdr, buf << " c\r\n")
+    assert_equal([ [ 'a', 'b c'] ], hdr)
+    assert_nil @hp.headers(hdr, buf << " d\n")
+    assert_equal([ [ 'a', 'b c d'] ], hdr)
+    assert_equal([ "200 OK", hdr ], @hp.headers(hdr, buf << "\r\n"))
+    assert_equal([ [ 'a', 'b c d'] ], hdr)
+  end
+
+  def test_long_line_headers_plain_hash
+    hdr = {}
+    buf = "HTTP/1.1 200 OK\r\na: b\r\n"
+    assert_nil  @hp.headers(hdr, buf)
+    assert_equal({ 'a' => 'b' }, hdr)
+    assert_nil @hp.headers(hdr, buf << " c\r\n")
+    assert_equal({ 'a' => 'b c' }, hdr)
+    assert_nil @hp.headers(hdr, buf << " d\r\n")
+    assert_equal({ 'a' => 'b c d' }, hdr)
+    assert_equal([ "200 OK", hdr ], @hp.headers(hdr, buf << "\r\n"))
+    assert_equal({ 'a' => 'b c d' }, hdr)
+  end
+
+  def test_long_line_headers_rack_hash
+    hdr = Rack::Utils::HeaderHash.new
+    buf = "HTTP/1.1 200 OK\r\na: b\r\n"
+    assert_nil  @hp.headers(hdr, buf)
+    assert_equal({ 'a' => 'b' }, hdr.to_hash)
+    assert_nil @hp.headers(hdr, buf << " c\r\n")
+    assert_equal({ 'a' => 'b c' }, hdr)
+    assert_nil @hp.headers(hdr, buf << " d\r\n")
+    assert_equal({ 'a' => 'b c d' }, hdr)
+    assert_nil @hp.headers(hdr, buf << "A: e\r\n")
+    assert_equal([ "200 OK", hdr ], @hp.headers(hdr, buf << "\r\n"))
+    assert_equal({ 'a' => "b c d\ne"}, hdr.to_hash)
+  end
+
+  def test_content_length_invalid
+    assert_raises(Kcar::ParserError) do
+      @hp.headers([], "HTTP/1.1 200 OK\r\nContent-Length: 5a\r\n\r\n")
+    end
+    assert_raises(Kcar::ParserError) do
+      @hp.headers([], "HTTP/1.1 200 OK\r\nContent-Length: -1\r\n\r\n")
+    end
+  end
+
+end

data/test/test_response.rb

@@ -0,0 +1,415 @@
+# -*- encoding: binary -*-
+require 'test/unit'
+require 'pp'
+require 'socket'
+require 'kcar'
+
+class TestSession < Test::Unit::TestCase
+  def setup
+    @s, @c = UNIXSocket.pair
+  end
+
+  def test_http_one_zero
+    pid = fork do
+      @s << "HTTP/1.0 200 OK\r\n\r\nHI"
+      @s.close
+    end
+    @s.close
+    @response = Kcar::Response.new(@c)
+    status, headers, body = @response.read
+    assert_equal status, "200 OK"
+    assert headers.empty?
+    tmp = []
+    assert ! body.parser.keepalive?
+    assert_nothing_raised { body.each { |chunk| tmp << chunk.dup } }
+    assert_equal [ "HI" ], tmp
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    body.close
+    assert @c.closed?
+  end
+
+  def test_http_keepalive
+    pid = fork do
+      @s << "HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nHI"
+    end
+    @response = Kcar::Response.new(@c)
+    status, headers, body = @response.read
+    assert_equal status, "200 OK"
+    assert_equal({"Content-Length" => "2" }, headers)
+    tmp = []
+    assert body.parser.keepalive?
+    assert_nothing_raised { body.each { |chunk| tmp << chunk.dup } }
+    assert_equal [ "HI" ], tmp
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    body.close
+    assert ! @c.closed?
+
+    pid = fork do
+      @s << "HTTP/1.1 200 OK\r\nContent-Length: 3\r\n"
+      @s << "Connection: close\r\n\r\nBYE"
+    end
+    status, headers, body = @response.read
+    assert_equal status, "200 OK"
+    assert_equal({ "Content-Length" => "3", "Connection" => "close" }, headers)
+    tmp = []
+    assert ! body.parser.keepalive?
+    assert_nothing_raised { body.each { |chunk| tmp << chunk.dup } }
+    assert_equal [ "BYE" ], tmp
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    body.close
+    assert @c.closed?
+  end
+
+  def test_http_keepalive_chunky
+    @response = Kcar::Response.new(@c)
+    pid = fork do
+      @s << "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n"
+      @s << "5\r\nabcde\r\n"
+      @s << "0\r\n\r\nHTTP/1.1 " # partial response
+    end
+    status, headers, body = @response.read
+    assert_equal status, "200 OK"
+    assert_equal({"Transfer-Encoding" => "chunked" }, headers)
+    tmp = []
+    assert body.parser.keepalive?
+    assert_nothing_raised { body.each { |chunk| tmp << chunk.dup } }
+    assert_equal [ "abcde" ], tmp
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    body.close
+    assert ! @c.closed?
+    assert_equal "HTTP/1.1 ", @response.buf
+
+    pid = fork do
+      @s << "200 OK\r\nContent-Length: 3\r\n"
+      @s << "Connection: close\r\n\r\nBYE"
+    end
+    status, headers, body = @response.read
+    assert_equal status, "200 OK"
+    assert_equal({ "Content-Length" => "3", "Connection" => "close" }, headers)
+    tmp = []
+    assert ! body.parser.keepalive?
+    assert_nothing_raised { body.each { |chunk| tmp << chunk.dup } }
+    assert_equal [ "BYE" ], tmp
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    body.close
+    assert @c.closed?
+  end
+
+  def test_http_no_body_keepalive
+    pid = fork { @s << "HTTP/1.1 100 Continue\r\n\r\n" }
+    @response = Kcar::Response.new(@c)
+    status, headers, body = @response.read
+    assert_equal status, "100 Continue"
+    assert_equal({}, headers)
+    tmp = []
+    assert body.parser.keepalive?
+    assert_nothing_raised { body.each { |chunk| tmp << chunk.dup } }
+    assert tmp.empty?
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    body.close
+    assert ! @c.closed?
+
+    pid = fork { @s << "HTTP/1.1 200 OK\r\nConnection: close\r\n\r\nhello" }
+    @s.close
+    status, headers, body = @response.read
+    assert_equal status, "200 OK"
+    assert_equal({'Connection' => 'close'}, headers)
+    tmp = []
+    assert ! body.parser.keepalive?
+    assert_nothing_raised { body.each { |chunk| tmp << chunk.dup } }
+    assert_equal(%w(hello), tmp)
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    body.close
+    assert @c.closed?
+  end
+
+  def test_trailers
+    pid = fork do
+      @s << "HTTP/1.1 200 OK\r\nTrailer: Foo\r\n"
+      @s << "Transfer-Encoding: chunked\r\n\r\n"
+    end
+    @response = Kcar::Response.new(@c)
+    status, headers, body = @response.read
+    assert_equal status, "200 OK"
+    expect = {
+      "Trailer" => "Foo",
+      "Transfer-Encoding" => "chunked",
+    }
+    assert_equal(expect, headers)
+    assert body.parser.keepalive?
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    tmp = []
+    pid = fork { @s << "5\r\nhello\r\n0\r\nFoo: bar\r\n\r\n" }
+    assert_nothing_raised { body.each { |chunk| tmp << chunk.dup } }
+    assert_equal %w(hello), tmp
+    expect['Foo'] = 'bar'
+    assert_equal(expect, headers)
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    body.close
+    assert ! @c.closed?
+  end
+
+  def test_trailers_pass_through
+    pid = fork do
+      @s << "HTTP/1.1 200 OK\r\nTrailer: Foo\r\n"
+      @s << "Transfer-Encoding: chunked\r\n\r\n"
+    end
+    @response = Kcar::Response.new(@c, {}, false)
+    status, headers, body = @response.read
+    assert_equal status, "200 OK"
+    expect = {
+      "Trailer" => "Foo",
+      "Transfer-Encoding" => "chunked",
+    }
+    assert_equal(expect, headers)
+    assert body.parser.keepalive?
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    tmp = []
+    pid = fork { @s << "5\r\nhello\r\n0\r\nFoo: bar\r\n\r\n" }
+    assert_nothing_raised { body.each { |chunk| tmp << chunk.dup } }
+    assert_equal ["5\r\n", "hello\r\n", "0\r\n", "Foo: bar\r\n\r\n"], tmp
+    expect['Foo'] = 'bar'
+    assert_equal(expect, headers)
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    body.close
+    assert ! @c.closed?
+  end
+
+  def test_pass_through_one_oh
+    pid = fork do
+      @s << "HTTP/1.0 200 OK\r\n"
+      @s << "Content-Type: text/plain\r\n\r\n"
+    end
+    @response = Kcar::Response.new(@c, {}, false)
+    status, headers, body = @response.read
+    assert_equal status, "200 OK"
+    expect = { "Content-Type" => "text/plain", }
+    assert_equal(expect, headers)
+    assert ! body.parser.keepalive?
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    tmp = []
+    pid = fork { @s << "hello" }
+    @s.close
+    assert_nothing_raised { body.each { |chunk| tmp << chunk.dup } }
+    assert_equal %w(hello), tmp
+    assert_equal(expect, headers)
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    body.close
+    assert @c.closed?
+  end
+
+  def test_trailers_burpy
+    pid = fork do
+      @s << "HTTP/1.1 200 OK\r\nTrailer: Foo\r\n"
+      @s << "Transfer-Encoding: chunked\r\n\r\n"
+    end
+    @response = Kcar::Response.new(@c)
+    status, headers, body = @response.read
+    assert_equal status, "200 OK"
+    expect = {
+      "Trailer" => "Foo",
+      "Transfer-Encoding" => "chunked",
+    }
+    assert_equal(expect, headers)
+    assert body.parser.keepalive?
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    tmp = []
+    pid = fork { @s << "5\r\nhello\r\n0\r\nFoo: bar" }
+    rd, wr = IO.pipe
+    crlf_pid = fork do
+      wr.close
+      @s << rd.sysread(4)
+    end
+    rd.close
+    assert_nothing_raised do
+      first = true
+      body.each do |chunk|
+        tmp << chunk.dup
+        if first
+          first = false
+          wr.syswrite "\r\n\r\n"
+        end
+      end
+    end
+    assert_equal %w(hello), tmp
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    _, status = Process.waitpid2(crlf_pid)
+    assert status.success?
+    expect['Foo'] = 'bar'
+    assert_equal(expect, headers)
+    body.close
+    assert ! @c.closed?
+  end
+
+  def test_pass_through_trailers_burpy
+    pid = fork do
+      @s << "HTTP/1.1 200 OK\r\nTrailer: Foo\r\n"
+      @s << "Transfer-Encoding: chunked\r\n\r\n"
+    end
+    @response = Kcar::Response.new(@c, {}, false)
+    status, headers, body = @response.read
+    assert_equal status, "200 OK"
+    expect = {
+      "Trailer" => "Foo",
+      "Transfer-Encoding" => "chunked",
+    }
+    assert_equal(expect, headers)
+    assert body.parser.keepalive?
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    tmp = []
+    pid = fork { @s << "5\r\nhello\r\n0\r\nFoo: bar" }
+    rd, wr = IO.pipe
+    crlf_pid = fork do
+      wr.close
+      @s << rd.sysread(4)
+    end
+    rd.close
+    assert_nothing_raised do
+      first = true
+      body.each do |chunk|
+        tmp << chunk.dup
+        if first
+          first = false
+          wr.syswrite "\r\n\r\n"
+        end
+      end
+    end
+    assert_equal ["5\r\n", "hello\r\n", "0\r\n", "Foo: bar\r\n\r\n"], tmp
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    _, status = Process.waitpid2(crlf_pid)
+    assert status.success?
+    expect['Foo'] = 'bar'
+    assert_equal(expect, headers)
+    body.close
+    assert ! @c.closed?
+  end
+
+  def test_identity_burpy
+    pid = fork { @s << "HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n" }
+    @response = Kcar::Response.new(@c)
+    status, headers, body = @response.read
+    assert_equal status, "200 OK"
+    expect = { "Content-Length" => '5' }
+    assert_equal(expect, headers)
+    assert body.parser.keepalive?
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    tmp = []
+    pid = fork { @s << "h" }
+    rd, wr = IO.pipe
+    crlf_pid = fork do
+      wr.close
+      @s << rd.sysread(4)
+    end
+    rd.close
+    assert_nothing_raised do
+      first = true
+      body.each do |chunk|
+        tmp << chunk.dup
+        if first
+          first = false
+          wr.syswrite "ello"
+        end
+      end
+    end
+    assert_equal %w(h ello), tmp
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    _, status = Process.waitpid2(crlf_pid)
+    assert status.success?
+    assert_equal(expect, headers)
+    body.close
+    assert ! @c.closed?
+  end
+
+  def test_rack_preserve_chunk_hash
+    pid = fork do
+      @s << "HTTP/1.1 200 OK\r\n"
+      @s << "Trailer: Foo\r\n"
+      @s << "Transfer-Encoding: chunked\r\n\r\n"
+      @s << "5\r\nhello\r\n0\r\nFoo: bar\r\n\r\n"
+    end
+    @response = Kcar::Response.new(@c)
+    status, headers, body = @response.rack
+    assert_equal status, "200 OK"
+    expect = {
+      "Trailer" => "Foo",
+      "Transfer-Encoding" => "chunked",
+    }
+    assert_equal expect, headers
+    tmp = []
+    assert body.parser.keepalive?
+    assert_nothing_raised { body.each { |chunk| tmp << chunk.dup } }
+    assert_equal ["5\r\n", "hello\r\n", "0\r\n", "Foo: bar\r\n\r\n"], tmp
+    expect["Foo"] = "bar"
+    assert_equal expect, headers
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    body.close
+    assert ! @c.closed?
+  end
+
+  def test_rack_preserve_chunk_ary
+    pid = fork do
+      @s << "HTTP/1.1 200 OK\r\n"
+      @s << "Trailer: Foo\r\n"
+      @s << "Transfer-Encoding: chunked\r\n\r\n"
+      @s << "5\r\nhello\r\n0\r\nFoo: bar\r\n\r\n"
+    end
+    @response = Kcar::Response.new(@c, [])
+    status, headers, body = @response.rack
+    assert_equal status, "200 OK"
+    expect = [ %w(Trailer Foo), %w(Transfer-Encoding chunked) ]
+    assert_equal expect, headers
+    tmp = []
+    assert body.parser.keepalive?
+    assert_nothing_raised { body.each { |chunk| tmp << chunk.dup } }
+    assert_equal ["5\r\n", "hello\r\n", "0\r\n", "Foo: bar\r\n\r\n"], tmp
+    expect << %w(Foo bar)
+    assert_equal expect, headers
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    body.close
+    assert ! @c.closed?
+  end
+
+  def test_rack_preserve_chunk_ary_no_keepalive
+    pid = fork do
+      @s << "HTTP/1.1 200 OK\r\n"
+      @s << "Connection: close\r\n"
+      @s << "Trailer: Foo\r\n"
+      @s << "Transfer-Encoding: chunked\r\n\r\n"
+      @s << "5\r\nhello\r\n0\r\nFoo: bar\r\n\r\n"
+    end
+    @s.close
+    @response = Kcar::Response.new(@c, [])
+    status, headers, body = @response.rack
+    assert_equal status, "200 OK"
+    tmp = []
+    assert ! body.parser.keepalive?
+    assert_nothing_raised { body.each { |chunk| tmp << chunk.dup } }
+    assert_equal ["5\r\nhello\r\n0\r\nFoo: bar\r\n\r\n"], tmp
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    body.close
+    assert @c.closed?
+  end
+
+end