http_tools 0.1.0 → 0.2.0

data/test/parser/response_test.rb

@@ -8,18 +8,31 @@ class ResponseTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     version = nil
     
-    parser.add_listener(:version) {|v| version = v}
+    parser.add_listener(:header) {version = parser.version}
     
-    parser << "HTTP/1.1 "
+    parser << "HTTP/1.1 200 OK\r\n\r\n"
     
     assert_equal("1.1", version)
   end
   
+  def test_one_dot_x_version
+    parser = HTTPTools::Parser.new
+    version = nil
+    
+    parser.add_listener(:header) {version = parser.version}
+    
+    parser << "HTTP/1.x 200 OK\r\n\r\n"
+    
+    assert_equal("1.x", version)
+  end
+  
   def test_ok
     parser = HTTPTools::Parser.new
     code, message = nil
     
-    parser.add_listener(:status) {|c, m| code, message = c, m}
+    parser.add_listener(:header) do
+      code, message = parser.status_code, parser.message
+    end
     
     parser << "HTTP/1.1 200 OK\r\n\r\n"
     
@@ -32,7 +45,9 @@ class ResponseTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     code, message = nil
     
-    parser.add_listener(:status) {|c, m| code, message = c, m}
+    parser.add_listener(:header) do
+      code, message = parser.status_code, parser.message
+    end
     
     parser << "HTTP/1.1 404 Not Found\r\n\r\n"
     
@@ -41,11 +56,61 @@ class ResponseTest < Test::Unit::TestCase
     assert(!parser.finished?, "parser should not be finished")
   end
   
+  def test_missing_message
+    parser = HTTPTools::Parser.new
+    code, message = nil
+    
+    parser.add_listener(:header) do
+      code, message = parser.status_code, parser.message
+    end
+    
+    parser << "HTTP/1.1 302\r\n\r\n"
+    
+    assert_equal(302, code)
+    assert_equal("", message)
+    assert(!parser.finished?, "parser should not be finished")
+  end
+  
+  def test_non_standard_message
+    parser = HTTPTools::Parser.new
+    version, code, message = nil
+    
+    parser.add_listener(:header) do
+      version = parser.version
+      code = parser.status_code
+      message = parser.message
+    end
+    
+    parser << "HTTP/1.0 200 (OK)\r\n\r\n"
+    
+    assert_equal("1.0", version)
+    assert_equal(200, code)
+    assert_equal("(OK)", message)
+    assert(!parser.finished?, "parser should not be finished")
+  end
+  
+  def test_status_message_with_accent
+    parser = HTTPTools::Parser.new
+    code, message = nil
+    
+    parser.add_listener(:header) do
+      code, message = parser.status_code, parser.message
+    end
+    
+    parser << "HTTP/1.1 403 Accès interdit\r\n\r\n"
+    
+    assert_equal(403, code)
+    assert_equal("Accès interdit", message)
+    assert(!parser.finished?, "parser should not be finished")
+  end
+  
   def test_no_content
     parser = HTTPTools::Parser.new
     code, message = nil
     
-    parser.add_listener(:status) {|c, m| code, message = c, m}
+    parser.add_listener(:header) do
+      code, message = parser.status_code, parser.message
+    end
     
     parser << "HTTP/1.1 204 No Content\r\n\r\n"
     
@@ -58,7 +123,9 @@ class ResponseTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     code, message = nil
     
-    parser.add_listener(:status) {|c, m| code, message = c, m}
+    parser.add_listener(:header) do
+      code, message = parser.status_code, parser.message
+    end
     
     parser << "HTTP/1.1 304 Not Modified\r\n\r\n"
     
@@ -72,7 +139,7 @@ class ResponseTest < Test::Unit::TestCase
     parser.force_no_body = true
     headers = nil
     
-    parser.add_listener(:headers) {|h| headers = h}
+    parser.add_listener(:header) {headers = parser.header}
     
     parser << "HTTP/1.1 200 OK\r\n"
     parser << "Content-Length: 20\r\n"
@@ -82,12 +149,178 @@ class ResponseTest < Test::Unit::TestCase
     assert(parser.finished?, "parser should be finished")
   end
   
+  def test_messed_up_iis_headers
+    parser = HTTPTools::Parser.new
+    headers = nil
+    
+    parser.add_listener(:header) {headers = parser.header}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "Server:: Harris Associates L.P.\r\n"
+    parser << "X-DIP:202\r\n"
+    parser << "\r\n"
+    
+    assert_equal({
+      "Server" => ": Harris Associates L.P.",
+      "X-DIP" => "202"}, headers)
+  end
+  
+  def test_space_in_header_key
+    parser = HTTPTools::Parser.new
+    headers = nil
+    
+    parser.add_listener(:header) {headers = parser.header}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "X-Powered-By: PHP/5.3.5\r\n"
+    parser << "HTTP Status Code: HTTP/1.1 404 Not Found\r\n"
+    parser << "\r\n"
+    
+    assert_equal({
+      "X-Powered-By" => "PHP/5.3.5",
+      "HTTP Status Code" => "HTTP/1.1 404 Not Found"}, headers)
+  end
+  
+  def test_header_empty_value
+    parser = HTTPTools::Parser.new
+    headers = nil
+    
+    parser.add_listener(:header) {headers = parser.header}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "X-Empty: \r\n"
+    parser << "Content-Type: text/html\r\n\r\n"
+    
+    assert_equal({
+      "X-Empty" => "",
+      "Content-Type" => "text/html"}, headers)
+  end
+  
+  def test_weird_iis_content_header
+    parser = HTTPTools::Parser.new
+    code, message, headers = nil
+    body = ""
+    
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "Content-Length: 20\r\n"
+    parser << "Content:\r\n"
+    parser << "\r\n"
+    parser << "<h1>Hello world</h1>"
+    
+    assert_equal(200, code)
+    assert_equal("OK", message)
+    assert_equal({"Content-Length" => "20", "Content" => ""}, headers)
+    assert_equal("<h1>Hello world</h1>", body)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
+  def test_multiple_set_cookie_headers
+    parser = HTTPTools::Parser.new
+    headers = nil
+    
+    parser.add_listener(:header) {headers = parser.header}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "Set-Cookie: foo=bar\r\n"
+    parser << "Set-Cookie: baz=qux\r\n\r\n"
+    
+    assert_equal({"Set-Cookie" => ["foo=bar", "baz=qux"]}, headers)
+  end
+  
+  def test_skip_junk_headers_at_end
+    parser = HTTPTools::Parser.new
+    code, message, headers = nil
+    body = ""
+    
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
+    
+    parser << "HTTP/1.1 301 Redirect\r\n"
+    parser << "Location: /index.html\r\n"
+    parser << "Content-Length: 74\r\n"
+    parser << "301 Moved Permanently\r\n\r\n"
+    parser << "You should have been redirected to\n"
+    parser << "<a href=\"/index.html\">/index.html</a>.\n"
+    
+    assert_equal(301, code)
+    assert_equal("Redirect", message)
+    assert_equal({"Location" => "/index.html", "Content-Length" => "74"}, headers)
+    assert_equal("You should have been redirected to\n<a href=\"/index.html\">/index.html</a>.\n", body)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
+  def test_skip_junk_headers_at_start
+    parser = HTTPTools::Parser.new
+    code, message, headers = nil
+    body = ""
+    
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
+    
+    parser << "HTTP/1.0 200 OK\r\n"
+    parser << "QWEBS/1.0 (HP 3000)\r\n"
+    parser << "Content-Type: text/html\r\n\r\n"
+    parser << "<h1>Hello world</h1>"
+    parser.finish
+    
+    assert_equal(200, code)
+    assert_equal("OK", message)
+    assert_equal({"Content-Type" => "text/html"}, headers)
+    assert_equal("<h1>Hello world</h1>", body)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
+  def test_skip_junk_headers_in_the_middle
+    parser = HTTPTools::Parser.new
+    code, message, headers = nil
+    body = ""
+    
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "Content-Length: 20\r\n"
+    parser << "random\t"
+    parser << "garbage\n"
+    parser << "Content-Type: text/html\r\n"
+    parser << "\r\n"
+    parser << "<h1>Hello world</h1>"
+    
+    assert_equal(200, code)
+    assert_equal("OK", message)
+    assert_equal({"Content-Length" => "20", "Content-Type" => "text/html"}, headers)
+    assert_equal("<h1>Hello world</h1>", body)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
   def test_apple_dot_com
     parser = HTTPTools::Parser.new
     code, message, headers = nil
     
-    parser.add_listener(:status) {|c, m| code, message = c, m}
-    parser.add_listener(:headers) {|h| headers = h}
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
     
     parser << "HTTP/1.1 200 OK\r\n"
     parser << "Server: Apache/2.2.11 (Unix)\r\n"
@@ -114,9 +347,12 @@ class ResponseTest < Test::Unit::TestCase
     code, message, headers = nil
     body = []
     
-    parser.add_listener(:status) {|c, m| code, message = c, m}
-    parser.add_listener(:headers) {|h| headers = h}
-    parser.add_listener(:stream) {|b| body << b}
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
     
     parser << "HTTP/1.1 200 OK\r\n"
     parser << "Content-Length: 20\r\n"
@@ -133,11 +369,15 @@ class ResponseTest < Test::Unit::TestCase
   
   def test_body
     parser = HTTPTools::Parser.new
-    code, message, headers, body = nil
+    code, message, headers = nil
+    body = ""
     
-    parser.add_listener(:status) {|c, m| code, message = c, m}
-    parser.add_listener(:headers) {|h| headers = h}
-    parser.add_listener(:body) {|b| body = b}
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
     
     parser << "HTTP/1.1 200 OK\r\n"
     parser << "Content-Length: 20\r\n"
@@ -152,13 +392,67 @@ class ResponseTest < Test::Unit::TestCase
     assert(parser.finished?, "parser should be finished")
   end
   
-  def test_sub_line_chunks
+  def test_zero_length_body
+    parser = HTTPTools::Parser.new
+    code, message, headers, body = nil
+    stream = []
+    body = ""
+    
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk; stream.push(chunk)}
+    
+    parser << "HTTP/1.1 302 Moved Temporarily\r\n"
+    parser << "Location: http://www.example.com/\r\n"
+    parser << "Content-Length: 0\r\n\r\n"
+    
+    assert_equal(302, code)
+    assert_equal("Moved Temporarily", message)
+    assert_equal({"Location" => "http://www.example.com/", "Content-Length" => "0"}, headers)
+    assert_equal([""], stream)
+    assert_equal("", body)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
+  def test_zero_length_body_terminated_by_close
     parser = HTTPTools::Parser.new
     code, message, headers, body = nil
+    stream = []
+    body = ""
+    
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk; stream.push(chunk)}
+    
+    parser << "HTTP/1.1 302 Moved Temporarily\r\n"
+    parser << "Location: http://www.example.com/\r\n\r\n"
+    parser.finish # notify parser the connection has closed
+    
+    assert_equal(302, code)
+    assert_equal("Moved Temporarily", message)
+    assert_equal({"Location" => "http://www.example.com/"}, headers)
+    assert_equal([""], stream)
+    assert_equal("", body)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
+  def test_sub_line_chunks
+    parser = HTTPTools::Parser.new
+    code, message, headers = nil
+    body = ""
     
-    parser.add_listener(:status) {|c, m| code, message = c, m}
-    parser.add_listener(:headers) {|h| headers = h}
-    parser.add_listener(:body) {|b| body = b}
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
     
     parser << "HTTP/"
     parser << "1."
@@ -177,13 +471,60 @@ class ResponseTest < Test::Unit::TestCase
     assert(parser.finished?, "parser should be finished")
   end
   
+  def test_break_between_crlf
+    parser = HTTPTools::Parser.new
+    code, message, headers = nil
+    body = ""
+    
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
+    
+    parser << "HTTP/1.1 200 OK\r"
+    parser << "\nContent-Length: 20\r"
+    parser << "\n\r"
+    parser << "\n<h1>Hello world</h1>"
+    
+    assert_equal(200, code)
+    assert_equal("OK", message)
+    assert_equal({"Content-Length" => "20"}, headers)
+    assert_equal("<h1>Hello world</h1>", body)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
+  def test_double_cr
+    parser = HTTPTools::Parser.new
+    headers = nil
+    body = ""
+    
+    parser.add_listener(:header) {headers = parser.header}
+    parser.add_listener(:stream) {|chunk| body << chunk}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "Page-Completion-Status: Normal\r\r\n"
+    parser << "Content-Length: 20\r\n"
+    parser << "\r\n"
+    parser << "<h1>Hello world</h1>"
+    
+    assert_equal({"Page-Completion-Status" => "Normal\r", "Content-Length" => "20"}, headers)
+    assert_equal("<h1>Hello world</h1>", body)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
   def test_body_with_key_terminator_like_value
     parser = HTTPTools::Parser.new
-    code, message, headers, body = nil
+    code, message, headers = nil
+    body = ""
     
-    parser.add_listener(:status) {|c, m| code, message = c, m}
-    parser.add_listener(:headers) {|h| headers = h}
-    parser.add_listener(:body) {|b| body = b}
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
     
     parser << "HTTP/1.1 200 OK\r\n"
     parser << "Content-Length: 21\r\n"
@@ -198,11 +539,15 @@ class ResponseTest < Test::Unit::TestCase
   
   def test_lazy_server
     parser = HTTPTools::Parser.new
-    code, message, headers, body = nil
+    code, message, headers = nil
+    body = ""
     
-    parser.add_listener(:status) {|c, m| code, message = c, m}
-    parser.add_listener(:headers) {|h| headers = h}
-    parser.add_listener(:body) {|b| body = b}
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
     
     parser << "HTTP/1.1 200 OK\n"
     parser << "Content-Type: text/html; charset=utf-8\n"
@@ -219,11 +564,15 @@ class ResponseTest < Test::Unit::TestCase
   
   def test_chunked
     parser = HTTPTools::Parser.new
-    code, message, headers, body = nil
+    code, message, headers = nil
+    body = ""
     
-    parser.add_listener(:status) {|c, m| code, message = c, m}
-    parser.add_listener(:headers) {|h| headers = h}
-    parser.add_listener(:body) {|b| body = b}
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
     
     parser << "HTTP/1.1 200 OK\r\n"
     parser << "Transfer-Encoding: chunked\r\n"
@@ -244,9 +593,12 @@ class ResponseTest < Test::Unit::TestCase
     code, message, headers = nil
     body = []
     
-    parser.add_listener(:status) {|c, m| code, message = c, m}
-    parser.add_listener(:headers) {|h| headers = h}
-    parser.add_listener(:stream) {|b| body << b}
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
     
     parser << "HTTP/1.1 200 OK\r\n"
     parser << "Transfer-Encoding: chunked\r\n"
@@ -267,9 +619,12 @@ class ResponseTest < Test::Unit::TestCase
     code, message, headers = nil
     body = []
     
-    parser.add_listener(:status) {|c, m| code, message = c, m}
-    parser.add_listener(:headers) {|h| headers = h}
-    parser.add_listener(:stream) {|b| body << b}
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
     
     parser << "HTTP/1.1 200 OK\r\n"
     parser << "Transfer-Encoding: chunked\r\n"
@@ -285,13 +640,82 @@ class ResponseTest < Test::Unit::TestCase
     assert(parser.finished?, "parser should be finished")
   end
   
+  # shouldn't really be allowed, but IIS can't do chunked encoding properly
+  def test_chunked_terminated_by_close
+    parser = HTTPTools::Parser.new
+    code, message, headers = nil
+    body = []
+    
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "Connection: close\r\n"
+    parser << "Transfer-Encoding: chunked\r\n"
+    parser << "\r\n"
+    parser << "9\r\n<h1>Hello\r\n"
+    parser << "b\r\n world</h1>\r\n"
+    parser.finish # notify parser the connection has closed
+    
+    assert_equal(200, code)
+    assert_equal("OK", message)
+    assert_equal({
+      "Transfer-Encoding" => "chunked",
+      "Connection" => "close"}, headers)
+    assert_equal(["<h1>Hello", " world</h1>"], body)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
+  def test_html_body_only_not_allowed
+    parser = HTTPTools::Parser.new
+    
+    assert_raise(HTTPTools::ParseError) do
+      parser << "<html><p>HTTP is hard</p></html>"
+    end
+  end
+  
+  def test_html_body_only_allowed
+    parser = HTTPTools::Parser.new
+    version, code, message, headers = nil
+    body = ""
+    
+    parser.allow_html_without_header = true
+    
+    parser.add_listener(:header) do
+      version = parser.version
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
+    
+    parser << "<html><p>HTTP is hard</p></html>"
+    parser.finish
+    
+    assert_equal("0.0", version)
+    assert_equal(200, code)
+    assert_equal("", message)
+    assert_equal({}, headers)
+    assert_equal("<html><p>HTTP is hard</p></html>", body)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
   def test_finished
     parser = HTTPTools::Parser.new
-    code, message, body, remainder = nil
+    code, message, remainder = nil
+    body = ""
     
-    parser.add_listener(:status) {|c, m| code, message = c, m}
-    parser.add_listener(:body) {|b| body = b}
-    parser.add_listener(:finished) {|r| remainder = r}
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
+    parser.add_listener(:finish) {|r| remainder = r}
     
     parser << "HTTP/1.1 200 OK\r\nContent-Length: 20\r\n\r\n"
     parser << "<h1>Hello world</h1>HTTP/1.1 404 Not Found\r\n"
@@ -305,11 +729,16 @@ class ResponseTest < Test::Unit::TestCase
   
   def test_finished_chunked
     parser = HTTPTools::Parser.new
-    code, message, body, remainder = nil
+    code, message, remainder = nil
+    body = ""
     
-    parser.add_listener(:status) {|c, m| code, message = c, m}
-    parser.add_listener(:body) {|b| body = b}
-    parser.add_listener(:finished) {|r| remainder = r}
+    parser.add_listener(:header) do
+      code = parser.status_code
+      message = parser.message
+      headers = parser.header
+    end
+    parser.add_listener(:stream) {|chunk| body << chunk}
+    parser.add_listener(:finish) {|r| remainder = r}
     
     parser << "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n"
     parser << "14\r\n<h1>Hello world</h1>\r\n0\r\nHTTP/1.1 404 Not Found\r\n"
@@ -325,7 +754,7 @@ class ResponseTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     trailer = nil
     
-    parser.add_listener(:trailer) {|t| trailer = t}
+    parser.add_listener(:trailer) {trailer = parser.trailer}
     
     parser << "HTTP/1.1 200 OK\r\n"
     parser << "Transfer-Encoding: chunked\r\nTrailer: X-Checksum\r\n\r\n"
@@ -340,7 +769,7 @@ class ResponseTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     trailer = nil
     
-    parser.add_listener(:trailer) {|t| trailer = t}
+    parser.add_listener(:trailer) {trailer = parser.trailer}
     
     parser << "HTTP/1.1 200 OK\r\n"
     parser << "Transfer-Encoding: chunked\r\nTrailer: X-Checksum\r\n\r\n"
@@ -356,7 +785,7 @@ class ResponseTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     trailer = nil
     
-    parser.add_listener(:trailer) {|t| trailer = t}
+    parser.add_listener(:trailer) {trailer = parser.trailer}
     
     parser.force_trailer = true
     
@@ -369,6 +798,39 @@ class ResponseTest < Test::Unit::TestCase
     assert(parser.finished?, "parser should be finished")
   end
   
+  def test_messed_up_iis_header_style_trailer_1
+    parser = HTTPTools::Parser.new
+    trailer = nil
+    
+    parser.add_listener(:trailer) {trailer = parser.trailer}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "Server: Microsoft-IIS/6.0\r\n"
+    parser << "Transfer-Encoding: chunked\r\nTrailer: Server::\r\n\r\n"
+    parser << "14\r\n<h1>Hello world</h1>\r\n0\r\n"
+    parser << "Server:: Harris Associates L.P.\r\n"
+    parser << "\r\n"
+    
+    assert_equal({"Server" => ": Harris Associates L.P."}, trailer)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
+  def test_messed_up_iis_header_style_trailer_2
+    parser = HTTPTools::Parser.new
+    trailer = nil
+    
+    parser.add_listener(:trailer) {trailer = parser.trailer}
+    
+    parser << "HTTP/1.1 200 OK\r\n"
+    parser << "Transfer-Encoding: chunked\r\nTrailer: Server::\r\n\r\n"
+    parser << "14\r\n<h1>Hello world</h1>\r\n0\r\n"
+    parser << "X-DIP:202\r\n"
+    parser << "\r\n"
+    
+    assert_equal({"X-DIP" => "202"}, trailer)
+    assert(parser.finished?, "parser should be finished")
+  end
+  
   def test_error_on_unallowed_trailer
     parser = HTTPTools::Parser.new
     
@@ -397,14 +859,14 @@ class ResponseTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     trailer = nil
     
-    parser.add_listener(:trailer) {|t| trailer = t}
+    parser.add_listener(:trailer) {trailer = parser.trailer}
     
     parser << "HTTP/1.1 200 OK\r\n"
     parser << "Transfer-Encoding: chunked\r\nTrailer: X-Checksum\r\n\r\n"
     parser << "14\r\n<h1>Hello world</h1>\r\n0\r\n"
     
     assert_raise(HTTPTools::ParseError) do
-      parser << "x-invalid key: value\r\n\r\n"
+      parser << "x-invalid\0key: value\r\n\r\n"
     end
   end
   
@@ -412,7 +874,7 @@ class ResponseTest < Test::Unit::TestCase
     parser = HTTPTools::Parser.new
     trailer = nil
     
-    parser.add_listener(:trailer) {|t| trailer = t}
+    parser.add_listener(:trailer) {trailer = parser.trailer}
     
     parser << "HTTP/1.1 200 OK\r\n"
     parser << "Transfer-Encoding: chunked\r\nTrailer: X-Checksum\r\n\r\n"
@@ -443,4 +905,10 @@ class ResponseTest < Test::Unit::TestCase
     assert_raise(HTTPTools::MessageIncompleteError) {parser.finish}
   end
   
+  def test_empty
+    parser = HTTPTools::Parser.new
+    
+    assert_raise(HTTPTools::EmptyMessageError) {parser.finish}
+  end
+  
 end