http_parser.rb 0.5.1-x86-mswin32-60 → 0.5.2-x86-mswin32-60

data/ext/ruby_http_parser/vendor/http-parser-java/src/test/http_parser/lolevel/TestNoOverflowLongBody.java

@@ -0,0 +1,61 @@
+package http_parser.lolevel;
+
+import java.nio.*;
+
+import static http_parser.lolevel.Util.*;
+
+public class TestNoOverflowLongBody {
+
+  public static void test (http_parser.ParserType type, int len) {
+    HTTPParser parser = new HTTPParser(type);
+    ByteBuffer buf    = getBytes(type, len);
+    
+    int buflen = buf.limit();
+
+    parser.execute(Util.SETTINGS_NULL, buf);
+
+    check(buflen == buf.position());
+
+    buf  = buffer("a");
+    buflen  = buf.limit();
+    
+    for (int i = 0; i!= len; ++i) {
+      parser.execute(Util.SETTINGS_NULL, buf);
+      check(buflen == buf.position());
+      buf.rewind();
+    }
+    
+    buf = getBytes(type, len);
+    buflen = buf.limit();
+
+    parser.execute(Util.SETTINGS_NULL, buf);
+
+    check(buflen == buf.position());
+
+  }
+
+  static ByteBuffer getBytes (http_parser.ParserType type, int length) {
+    if (http_parser.ParserType.HTTP_BOTH == type) {
+      throw new RuntimeException("only HTTP_REQUEST and HTTP_RESPONSE");
+    }
+    
+    String template = "%s\r\nConnection: Keep-Alive\r\nContent-Length: %d\r\n\r\n";
+    String str = null;
+    if (http_parser.ParserType.HTTP_REQUEST == type) {
+      str = String.format(template, "GET / HTTP/1.1", length); 
+    } else {
+      str = String.format(template, "HTTP/1.0 200 OK", length);
+    }
+    return buffer(str);
+  }
+
+  public static void test () {
+    test(http_parser.ParserType.HTTP_REQUEST, 1000);
+    test(http_parser.ParserType.HTTP_REQUEST, 100000);
+    test(http_parser.ParserType.HTTP_RESPONSE, 1000);
+    test(http_parser.ParserType.HTTP_RESPONSE, 100000);
+  }
+
+
+
+}

data/ext/ruby_http_parser/vendor/http-parser-java/src/test/http_parser/lolevel/UnitTest.java

@@ -2,6 +2,7 @@ package http_parser.lolevel;
 
 import java.nio.ByteBuffer;
 import http_parser.HTTPException;
+import http_parser.Util;
 
 public class UnitTest {
 
@@ -108,7 +109,7 @@ public class UnitTest {
   }
 
 
-  public static void main (String [] args) {
+  public static void test () {
     testErrorFormat();
     testErrorCallback();
   }  

data/ext/ruby_http_parser/vendor/http-parser-java/src/test/http_parser/lolevel/Upgrade.java

@@ -0,0 +1,26 @@
+package http_parser.lolevel;
+
+import java.nio.*;
+import java.util.*;
+
+import http_parser.ParserType;
+
+import static http_parser.lolevel.Util.*;
+
+public class Upgrade {
+  static final String upgrade = "GET /demo HTTP/1.1\r\n" +
+                                "Connection: Upgrade\r\n" +
+                                "Upgrade: WebSocket\r\n\r\n" +
+                                "third key data";
+  static void test () {
+    HTTPParser parser = new HTTPParser(ParserType.HTTP_REQUEST);
+    ByteBuffer buf    = buffer(upgrade);
+    
+    int read = parser.execute(Util.SETTINGS_NULL, buf);
+    check (63 == read);
+    String s = str(buf);
+    check ("third key data".equals(str(buf)));
+  
+  }
+
+}

data/ext/ruby_http_parser/vendor/http-parser-java/src/test/http_parser/lolevel/Util.java

@@ -0,0 +1,165 @@
+package http_parser.lolevel;
+
+import java.nio.*;
+import java.util.*;
+
+import primitive.collection.ByteList;
+
+import http_parser.*;
+
+public class Util {
+
+  static final ParserSettings SETTINGS_NULL = new ParserSettings();
+
+  static String str (ByteBuffer b, int pos, int len) {
+    byte [] by = new byte[len];
+    int saved = b.position();
+    b.position(pos);
+    b.get(by);
+    b.position(saved);
+    return new String(by);
+  }
+  static String str (ByteBuffer b) {
+    int len = b.limit() - b.position(); 
+    byte [] by = new byte[len];
+    int saved = b.position();
+    b.get(by);
+    b.position(saved);
+    return new String(by);
+  }
+
+  static ByteBuffer buffer(String str) {
+    return ByteBuffer.wrap(str.getBytes());
+  }
+
+  static ByteBuffer empty() {
+    return ByteBuffer.wrap(new byte[0]);
+  }
+
+  static void check(boolean betterBtrue) {
+    if (!betterBtrue) {
+      throw new RuntimeException("!");
+    }
+  }
+
+  static void test_message(Message mes) {
+    int raw_len = mes.raw.length;
+    for (int msg1len = 0; msg1len != raw_len; ++msg1len) {
+      mes.reset();
+      ByteBuffer msg1 = ByteBuffer.wrap(mes.raw, 0, msg1len);
+      ByteBuffer msg2 = ByteBuffer.wrap(mes.raw, msg1len, mes.raw.length - msg1len);
+
+      HTTPParser parser = new HTTPParser(mes.type);
+      ParserSettings settings = mes.settings();
+      
+      int read = 0;
+      if (msg1len !=0) {
+        read = parser.execute(settings, msg1);
+        if (mes.upgrade && parser.upgrade) {
+          // Messages have a settings() that checks itself...
+          check(1 == mes.num_called);
+          continue; 
+        }
+        check(read == msg1len);
+      }
+
+      read = parser.execute(settings, msg2);
+      if (mes.upgrade && parser.upgrade) {
+        check(1 == mes.num_called);
+        continue; 
+      }
+
+      check(read == mes.raw.length - msg1len);
+      
+      ByteBuffer empty = Util.empty();
+      read = parser.execute(settings, empty);
+      
+      if (mes.upgrade && parser.upgrade) {
+        check(1 == mes.num_called);
+        continue;
+      }
+      check(empty.position() == empty.limit());
+      check(0 == read);
+      check(1 == mes.num_called);
+
+    }
+  }
+
+  static void test_multiple3(Message r1, Message r2, Message r3) {
+    int message_count = 1;
+    if (!r1.upgrade) {
+      message_count++;
+      if (!r2.upgrade) {
+        message_count++;
+      }
+    }
+    boolean has_upgrade = (message_count < 3 || r3.upgrade);
+
+    ByteList blist = new ByteList();
+    blist.addAll(r1.raw);
+    blist.addAll(r2.raw);
+    blist.addAll(r3.raw);
+
+    byte [] raw = blist.toArray();
+    ByteBuffer buf   = ByteBuffer.wrap(raw);
+
+    Util.Settings settings = Util.settings(); 
+    HTTPParser parser = new HTTPParser(r1.type);
+    
+    int read = parser.execute(settings, buf);
+    if (has_upgrade && parser.upgrade) {
+      check(settings.numCalled == message_count); 
+      return;
+    }
+
+    check(read == raw.length);
+
+    buf = Util.empty();    
+    read = parser.execute(settings, buf);
+    if (has_upgrade && parser.upgrade) {
+      check(settings.numCalled == message_count); 
+      return;
+    }
+
+    check(0 == read);
+    check(settings.numCalled == message_count); 
+  }  
+  static void p (Object o) {
+    System.out.println(o);
+  }
+
+  static Settings settings() {
+    return new Settings();
+  }
+  static Message find(List<Message> list, String name) {
+    for (Message m : list) {
+      if (name.equals(m.name)) {
+        return m;
+      }
+    }
+    return null;
+  }
+
+  static class Settings extends ParserSettings {
+    public int numCalled;
+    public int bodyCount;
+    Settings() {
+      this.on_message_complete = new HTTPCallback() {
+        public int cb (HTTPParser parser) {
+          numCalled++;
+          return 0;
+        }
+      };
+      this.on_body = new HTTPDataCallback() {
+        public int cb (HTTPParser p, ByteBuffer b, int pos, int len) {
+          bodyCount += len;
+          return 0;
+        }
+      }; 
+    }
+    
+    int numCalled () {
+      return this.numCalled;
+    }
+  }
+}

data/ext/ruby_http_parser/vendor/http-parser-java/src/test/http_parser/lolevel/WrongContentLength.java

@@ -0,0 +1,58 @@
+package http_parser.lolevel;
+
+import java.nio.*;
+import java.util.*;
+
+import http_parser.ParserType;
+
+import static http_parser.lolevel.Util.*;
+
+public class WrongContentLength {
+  static final String contentLength = "GET / HTTP/1.0\r\n" +
+                                      "Content-Length: 5\r\n" +
+                                      "\r\n" +
+                                      "hello" +
+                                      "hello_again";
+  static void test () {
+    HTTPParser parser = new HTTPParser(ParserType.HTTP_REQUEST);
+    ByteBuffer buf    = buffer(contentLength);
+    
+    Settings settings = new Settings();
+
+    int read = parser.execute(settings, buf);
+    check (settings.msg_cmplt_called);
+    check ("invalid method".equals(settings.err));
+  
+  }
+  public static void main(String [] args) {
+    test();
+  }
+
+  static class Settings extends ParserSettings {
+    public int bodyCount;
+    public boolean msg_cmplt_called;
+    public String err;
+    Settings () {
+      this.on_message_complete = new HTTPCallback () {
+        public int cb (HTTPParser p) {
+          check (5 == bodyCount);
+          msg_cmplt_called = true;
+          return 0;
+        }
+      };
+      this.on_body = new HTTPDataCallback() {
+        public int cb (HTTPParser p, ByteBuffer b, int pos, int len) {
+          bodyCount += len;
+          p(str(b, pos, len));
+          return 0;
+        }
+      }; 
+      this.on_error = new HTTPErrorCallback() {
+        public void cb (HTTPParser p, String mes, ByteBuffer b, int i) {
+          err = mes;
+        }
+      };
+    }
+  }
+
+}

data/ext/ruby_http_parser/vendor/http-parser-java/test.c

@@ -1,4 +1,4 @@
-/* Copyright 2009,2010 Ryan Dahl <ry@tinyclouds.org>
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to
@@ -31,7 +31,7 @@
 #undef FALSE
 #define FALSE 0
 
-#define MAX_HEADERS 10
+#define MAX_HEADERS 13
 #define MAX_ELEMENT_SIZE 500
 
 #define MIN(a,b) ((a) < (b) ? (a) : (b))
@@ -498,7 +498,7 @@ const struct message requests[] =
 #define CONNECT_REQUEST 17
 , {.name = "connect request"
   ,.type= HTTP_REQUEST
-  ,.raw= "CONNECT home.netscape.com:443 HTTP/1.0\r\n"
+  ,.raw= "CONNECT home0.netscape.com:443 HTTP/1.0\r\n"
          "User-agent: Mozilla/1.1N\r\n"
          "Proxy-authorization: basic aGVsbG86d29ybGQ=\r\n"
          "\r\n"
@@ -510,7 +510,7 @@ const struct message requests[] =
   ,.query_string= ""
   ,.fragment= ""
   ,.request_path= ""
-  ,.request_url= "home.netscape.com:443"
+  ,.request_url= "home0.netscape.com:443"
   ,.num_headers= 2
   ,.upgrade=1
   ,.headers= { { "User-agent", "Mozilla/1.1N" }
@@ -538,6 +538,128 @@ const struct message requests[] =
   ,.body= ""
   }
 
+#define NO_HTTP_VERSION 19
+, {.name= "request with no http version"
+  ,.type= HTTP_REQUEST
+  ,.raw= "GET /\r\n"
+         "\r\n"
+  ,.should_keep_alive= FALSE
+  ,.message_complete_on_eof= FALSE
+  ,.http_major= 0
+  ,.http_minor= 9
+  ,.method= HTTP_GET
+  ,.query_string= ""
+  ,.fragment= ""
+  ,.request_path= "/"
+  ,.request_url= "/"
+  ,.num_headers= 0
+  ,.headers= {}
+  ,.body= ""
+  }
+
+#define MSEARCH_REQ 20
+, {.name= "m-search request"
+  ,.type= HTTP_REQUEST
+  ,.raw= "M-SEARCH * HTTP/1.1\r\n"
+         "HOST: 239.255.255.250:1900\r\n"
+         "MAN: \"ssdp:discover\"\r\n"
+         "ST: \"ssdp:all\"\r\n"
+         "\r\n"
+  ,.should_keep_alive= TRUE
+  ,.message_complete_on_eof= FALSE
+  ,.http_major= 1
+  ,.http_minor= 1
+  ,.method= HTTP_MSEARCH
+  ,.query_string= ""
+  ,.fragment= ""
+  ,.request_path= "*"
+  ,.request_url= "*"
+  ,.num_headers= 3
+  ,.headers= { { "HOST", "239.255.255.250:1900" }
+             , { "MAN", "\"ssdp:discover\"" }
+             , { "ST", "\"ssdp:all\"" }
+             }
+  ,.body= ""
+  }
+
+#define UTF8_PATH_REQ 21
+, {.name= "utf-8 path request"
+  ,.type= HTTP_REQUEST
+  ,.raw= "GET /δ¶/δt/pope?q=1#narf HTTP/1.1\r\n"
+         "Host: github.com\r\n"
+         "\r\n"
+  ,.should_keep_alive= TRUE
+  ,.message_complete_on_eof= FALSE
+  ,.http_major= 1
+  ,.http_minor= 1
+  ,.method= HTTP_GET
+  ,.query_string= "q=1"
+  ,.fragment= "narf"
+  ,.request_path= "/δ¶/δt/pope"
+  ,.request_url= "/δ¶/δt/pope?q=1#narf"
+  ,.num_headers= 1
+  ,.headers= { {"Host", "github.com" }
+             }
+  ,.body= ""
+  }
+
+#define QUERY_TERMINATED_HOST 22
+, {.name= "host terminated by a query string"
+  ,.type= HTTP_REQUEST
+  ,.raw= "GET http://hypnotoad.org?hail=all HTTP/1.1\r\n"
+         "\r\n"
+  ,.should_keep_alive= TRUE
+  ,.message_complete_on_eof= FALSE
+  ,.http_major= 1
+  ,.http_minor= 1
+  ,.method= HTTP_GET
+  ,.query_string= "hail=all"
+  ,.fragment= ""
+  ,.request_path= ""
+  ,.request_url= "http://hypnotoad.org?hail=all"
+  ,.num_headers= 0
+  ,.headers= { }
+  ,.body= ""
+  }
+
+#define QUERY_TERMINATED_HOSTPORT 23
+, {.name= "host:port terminated by a query string"
+  ,.type= HTTP_REQUEST
+  ,.raw= "GET http://hypnotoad.org:1234?hail=all HTTP/1.1\r\n"
+         "\r\n"
+  ,.should_keep_alive= TRUE
+  ,.message_complete_on_eof= FALSE
+  ,.http_major= 1
+  ,.http_minor= 1
+  ,.method= HTTP_GET
+  ,.query_string= "hail=all"
+  ,.fragment= ""
+  ,.request_path= ""
+  ,.request_url= "http://hypnotoad.org:1234?hail=all"
+  ,.num_headers= 0
+  ,.headers= { }
+  ,.body= ""
+  }
+
+#define SPACE_TERMINATED_HOSTPORT 24
+, {.name= "host:port terminated by a space"
+  ,.type= HTTP_REQUEST
+  ,.raw= "GET http://hypnotoad.org:1234 HTTP/1.1\r\n"
+         "\r\n"
+  ,.should_keep_alive= TRUE
+  ,.message_complete_on_eof= FALSE
+  ,.http_major= 1
+  ,.http_minor= 1
+  ,.method= HTTP_GET
+  ,.query_string= ""
+  ,.fragment= ""
+  ,.request_path= ""
+  ,.request_url= "http://hypnotoad.org:1234"
+  ,.num_headers= 0
+  ,.headers= { }
+  ,.body= ""
+  }
+
 , {.name= NULL } /* sentinel */
 };
 
@@ -551,9 +673,10 @@ const struct message responses[] =
          "Content-Type: text/html; charset=UTF-8\r\n"
          "Date: Sun, 26 Apr 2009 11:11:49 GMT\r\n"
          "Expires: Tue, 26 May 2009 11:11:49 GMT\r\n"
+         "X-$PrototypeBI-Version: 1.6.0.3\r\n" /* $ char in header field */
          "Cache-Control: public, max-age=2592000\r\n"
          "Server: gws\r\n"
-         "Content-Length: 219\r\n"
+         "Content-Length:  219  \r\n"
          "\r\n"
          "<HTML><HEAD><meta http-equiv=\"content-type\" content=\"text/html;charset=utf-8\">\n"
          "<TITLE>301 Moved</TITLE></HEAD><BODY>\n"
@@ -566,15 +689,16 @@ const struct message responses[] =
   ,.http_major= 1
   ,.http_minor= 1
   ,.status_code= 301
-  ,.num_headers= 7
+  ,.num_headers= 8
   ,.headers=
     { { "Location", "http://www.google.com/" }
     , { "Content-Type", "text/html; charset=UTF-8" }
     , { "Date", "Sun, 26 Apr 2009 11:11:49 GMT" }
     , { "Expires", "Tue, 26 May 2009 11:11:49 GMT" }
+    , { "X-$PrototypeBI-Version", "1.6.0.3" }
     , { "Cache-Control", "public, max-age=2592000" }
     , { "Server", "gws" }
-    , { "Content-Length", "219" }
+    , { "Content-Length", "219  " }
     }
   ,.body= "<HTML><HEAD><meta http-equiv=\"content-type\" content=\"text/html;charset=utf-8\">\n"
           "<TITLE>301 Moved</TITLE></HEAD><BODY>\n"
@@ -833,6 +957,71 @@ const struct message responses[] =
   ,.body= "<xml>hello</xml>"
   }
 
+
+#define RES_FIELD_UNDERSCORE 10
+/* Should handle spaces in header fields */
+, {.name= "field underscore"
+  ,.type= HTTP_RESPONSE
+  ,.raw= "HTTP/1.1 200 OK\r\n"
+         "Date: Tue, 28 Sep 2010 01:14:13 GMT\r\n"
+         "Server: Apache\r\n"
+         "Cache-Control: no-cache, must-revalidate\r\n"
+         "Expires: Mon, 26 Jul 1997 05:00:00 GMT\r\n"
+         ".et-Cookie: PlaxoCS=1274804622353690521; path=/; domain=.plaxo.com\r\n"
+         "Vary: Accept-Encoding\r\n"
+         "_eep-Alive: timeout=45\r\n" /* semantic value ignored */
+         "_onnection: Keep-Alive\r\n" /* semantic value ignored */
+         "Transfer-Encoding: chunked\r\n"
+         "Content-Type: text/html\r\n"
+         "Connection: close\r\n"
+         "\r\n"
+         "0\r\n\r\n"
+  ,.should_keep_alive= FALSE
+  ,.message_complete_on_eof= FALSE
+  ,.http_major= 1
+  ,.http_minor= 1
+  ,.status_code= 200
+  ,.num_headers= 11
+  ,.headers=
+    { { "Date", "Tue, 28 Sep 2010 01:14:13 GMT" }
+    , { "Server", "Apache" }
+    , { "Cache-Control", "no-cache, must-revalidate" }
+    , { "Expires", "Mon, 26 Jul 1997 05:00:00 GMT" }
+    , { ".et-Cookie", "PlaxoCS=1274804622353690521; path=/; domain=.plaxo.com" }
+    , { "Vary", "Accept-Encoding" }
+    , { "_eep-Alive", "timeout=45" }
+    , { "_onnection", "Keep-Alive" }
+    , { "Transfer-Encoding", "chunked" }
+    , { "Content-Type", "text/html" }
+    , { "Connection", "close" }
+    }
+  ,.body= ""
+  }
+
+#define NON_ASCII_IN_STATUS_LINE 11
+/* Should handle non-ASCII in status line */
+, {.name= "non-ASCII in status line"
+  ,.type= HTTP_RESPONSE
+  ,.raw= "HTTP/1.1 500 Oriëntatieprobleem\r\n"
+         "Date: Fri, 5 Nov 2010 23:07:12 GMT+2\r\n"
+         "Content-Length: 0\r\n"
+         "Connection: close\r\n"
+         "\r\n"
+  ,.should_keep_alive= FALSE
+  ,.message_complete_on_eof= FALSE
+  ,.http_major= 1
+  ,.http_minor= 1
+  ,.status_code= 500
+  ,.num_headers= 3
+  ,.headers=
+    { { "Date", "Fri, 5 Nov 2010 23:07:12 GMT+2" }
+    , { "Content-Length", "0" }
+    , { "Connection", "close" }
+    }
+  ,.body= ""
+  }
+
+
 , {.name= NULL } /* sentinel */
 };
 
@@ -1538,8 +1727,8 @@ create_large_chunked_message (int body_size_in_kb, const char* headers)
 char * 
 quote(const char * orig) {
 	size_t j, i, len = strlen(orig);
-	char * quoted = malloc(len*2); // hm..
-	bzero(quoted, len*2);
+	char * quoted = malloc(len == 0 ? 1 : len*2); // hm..
+	bzero(quoted, len == 0 ? 1 : len*2);
 	for (i=0, j=0; i!=len; ++i) {
 		switch (orig[i]){
 			case '\n':
@@ -1578,27 +1767,33 @@ dump_message(const struct message * m)
 			printf("type  :HTTP_BOTH\n");
 	}
 	switch (m->method) {
-    case HTTP_DELETE:     printf("method: HTTP_DELETE\n");break;
-    case HTTP_GET:        printf("method: HTTP_GET\n");break;
-    case HTTP_HEAD:       printf("method: HTTP_HEAD\n");break;
-    case HTTP_POST:       printf("method: HTTP_POST\n");break;
-    case HTTP_PUT:        printf("method: HTTP_PUT\n");break;
-    case HTTP_CONNECT:    printf("method: HTTP_CONNECT\n");break;
-    case HTTP_OPTIONS:    printf("method: HTTP_OPTIONS\n");break;
-    case HTTP_TRACE:      printf("method: HTTP_TRACE\n");break;
-    case HTTP_COPY:       printf("method: HTTP_COPY\n");break;
-    case HTTP_LOCK:       printf("method: HTTP_LOCK\n");break;
-    case HTTP_MKCOL:      printf("method: HTTP_MKCOL\n");break;
-    case HTTP_MOVE:       printf("method: HTTP_MOVE\n");break;
-    case HTTP_PROPFIND:   printf("method: HTTP_PROPFIND\n");break;
-    case HTTP_PROPPATCH:  printf("method: HTTP_PROPPATCH\n");break;
-    case HTTP_UNLOCK:     printf("method: HTTP_UNLOCK\n");break;
+    case HTTP_DELETE:      printf("method: HTTP_DELETE\n");break;
+    case HTTP_GET:         printf("method: HTTP_GET\n");break;
+    case HTTP_HEAD:        printf("method: HTTP_HEAD\n");break;
+    case HTTP_POST:        printf("method: HTTP_POST\n");break;
+    case HTTP_PUT:         printf("method: HTTP_PUT\n");break;
+    case HTTP_CONNECT:     printf("method: HTTP_CONNECT\n");break;
+    case HTTP_OPTIONS:     printf("method: HTTP_OPTIONS\n");break;
+    case HTTP_TRACE:       printf("method: HTTP_TRACE\n");break;
+    case HTTP_COPY:        printf("method: HTTP_COPY\n");break;
+    case HTTP_LOCK:        printf("method: HTTP_LOCK\n");break;
+    case HTTP_MKCOL:       printf("method: HTTP_MKCOL\n");break;
+    case HTTP_MOVE:        printf("method: HTTP_MOVE\n");break;
+    case HTTP_PROPFIND:    printf("method: HTTP_PROPFIND\n");break;
+    case HTTP_PROPPATCH:   printf("method: HTTP_PROPPATCH\n");break;
+    case HTTP_UNLOCK:      printf("method: HTTP_UNLOCK\n");break;
     /* subversion */
-    case HTTP_REPORT:     printf("method: REPORT\n"); break;
-    case HTTP_MKACTIVITY: printf("method: MKACTIVITY\n"); break;
-    case HTTP_CHECKOUT:   printf("method: CHECKOUT\n"); break;
-    case HTTP_MERGE:      printf("method: MERGE\n"); break;
+    case HTTP_REPORT:      printf("method: HTTP_REPORT\n"); break;
+    case HTTP_MKACTIVITY:  printf("method: HTTP_MKACTIVITY\n"); break;
+    case HTTP_CHECKOUT:    printf("method: HTTP_CHECKOUT\n"); break;
+    case HTTP_MERGE:       printf("method: HTTP_MERGE\n"); break;
+
+    case HTTP_MSEARCH:     printf("method: HTTP_MSEARCH\n"); break;
+    case HTTP_NOTIFY:      printf("method: HTTP_NOTIFY\n"); break;
+    case HTTP_SUBSCRIBE:   printf("method: HTTP_SUBSCRIBE\n"); break;
+    case HTTP_UNSUBSCRIBE: printf("method: HTTP_UNSUBSCRIBE\n"); break;
 		default:
+      printf("method: UNKNOWN\n"); break;
 			break;
 	}
 	printf("status_code :%d\n", m->status_code);
@@ -1734,14 +1929,22 @@ main (int argc, char * argv[])
 
   /// REQUESTS
 
-
   test_simple("hello world", 0);
   test_simple("GET / HTP/1.1\r\n\r\n", 0);
 
+
   test_simple("ASDF / HTTP/1.1\r\n\r\n", 0);
   test_simple("PROPPATCHA / HTTP/1.1\r\n\r\n", 0);
   test_simple("GETA / HTTP/1.1\r\n\r\n", 0);
 
+  // Well-formed but incomplete
+  test_simple("GET / HTTP/1.1\r\n"
+              "Content-Type: text/plain\r\n"
+              "Content-Length: 6\r\n"
+              "\r\n"
+              "fooba",
+              0);
+
   static const char *all_methods[] = {
     "DELETE",
     "GET",