midori_http_parser 0.6.1.1-java

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

@@ -0,0 +1,51 @@
+package http_parser.lolevel;
+
+import http_parser.HTTPParserUrl;
+import static http_parser.lolevel.Util.*;
+
+public class ParseUrl {
+  public static void test(int i) {
+    HTTPParserUrl u = new HTTPParserUrl();
+    HTTPParser p = new HTTPParser();
+    Url test = Url.URL_TESTS[i];
+//    System.out.println(":: " + test.name);
+    int rv = p.parse_url(Util.buffer(test.url),test.is_connect,u);
+    UnitTest.check_equals(rv, test.rv);
+    if(test.rv == 0){
+      UnitTest.check_equals(u, test.u);
+    }
+
+  }
+  public static void test() {
+    p(ParseUrl.class);
+
+    for (int i = 0; i < Url.URL_TESTS.length; i++) {
+      test(i);      
+    }
+  }
+  
+  static void usage() {
+    p("usage: [jre] http_parser.lolevel.ParseUrl [i]");
+    p("             i : optional test case id");
+    p("---------------------------------------------");
+    p("Test Cases:");
+    for (int i =0; i!= Url.URL_TESTS.length; ++i) {
+      p(" "+i+": "+Url.URL_TESTS[i].name);
+    }
+  }
+
+  public static void main (String [] args) {
+    if (0 == args.length) {
+      test();
+    } else {
+      try {
+        int i = Integer.parseInt(args[0]);
+        test(i);
+      } catch (Throwable t) {
+        t.printStackTrace();
+        usage();
+      }
+    
+    }
+  }
+}

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

@@ -0,0 +1,69 @@
+package http_parser.lolevel;
+
+import java.nio.*;
+import java.util.*;
+
+import static http_parser.lolevel.Util.*;
+import http_parser.*;
+
+import primitive.collection.ByteList;
+
+public class Requests {
+  
+  static void test_simple(String req, boolean should_pass) {
+    HTTPParser parser = new HTTPParser(ParserType.HTTP_REQUEST);
+    ByteBuffer buf = buffer(req);
+    boolean passed = false;
+    int read = 0;
+    try {
+      parser.execute(Util.SETTINGS_NULL, buf);
+      passed = (read == req.length());
+      read = parser.execute(Util.SETTINGS_NULL, Util.empty());
+      passed &= (0 == read);
+    } catch (Throwable t) {
+      passed = false;
+    }
+    check(passed == should_pass);
+  }
+  static void simple_tests() {
+    test_simple("hello world", false);
+    test_simple("GET / HTP/1.1\r\n\r\n", false);
+
+    test_simple("ASDF / HTTP/1.1\r\n\r\n", false);
+    test_simple("PROPPATCHA / HTTP/1.1\r\n\r\n", false);
+    test_simple("GETA / HTTP/1.1\r\n\r\n", false);
+  }
+
+  public static void test () {
+    p(Requests.class);    
+    simple_tests();
+    
+    List<Message> all = TestLoaderNG.load("tests.dumped");
+    List<Message> requests = new LinkedList<Message>();
+    for (Message m : all) {
+      if (ParserType.HTTP_REQUEST == m.type) {
+        requests.add(m);
+      }
+    }
+    for (Message m : requests) {
+      test_message(m);
+    }
+    
+    for (int i = 0; i!= requests.size(); ++i) {
+      if (!requests.get(i).should_keep_alive) continue;
+      for (int j = 0; j!=requests.size(); ++j) {
+        if (!requests.get(j).should_keep_alive) continue;
+        for (int k = 0; k!= requests.size(); ++k) {
+          test_multiple3(requests.get(i), requests.get(j), requests.get(k));
+        }
+      }
+    }
+    
+    // postpone test_scan
+
+  }
+
+  
+
+
+}

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

@@ -0,0 +1,52 @@
+package http_parser.lolevel;
+
+import java.nio.*;
+import java.util.*;
+
+import static http_parser.lolevel.Util.*;
+import http_parser.*;
+
+import primitive.collection.ByteList;
+
+public class Responses {
+
+  
+
+  public static void test () {
+    p(Responses.class);
+    List<Message> all = TestLoaderNG.load("tests.dumped");
+    List<Message> responses = new LinkedList<Message>();
+    for (Message m : all) {
+      if (ParserType.HTTP_RESPONSE == m.type) {
+        responses.add(m);
+      }
+    }
+    for (Message m : responses) {
+      test_message(m);
+    }
+    
+    for (int i = 0; i!= responses.size(); ++i) {
+      if (!responses.get(i).should_keep_alive) continue;
+      for (int j = 0; j!=responses.size(); ++j) {
+        if (!responses.get(j).should_keep_alive) continue;
+        for (int k = 0; k!= responses.size(); ++k) {
+          test_multiple3(responses.get(i), responses.get(j), responses.get(k));
+        }
+      }
+    }
+
+  // not sure what test_message_count_body does that test_message doesn't...
+  //   Message m = find(responses, "404 no headers no body");
+  //   test_message_count_body(m);
+  //           m = find(responses, "200 trailing space on chunked body");
+  //   test_message_count_body(m);
+
+  // TODO test very large chunked response  
+
+  // test_scan is more or less the same as test_permutations, will implement later...
+  }
+
+  
+
+
+}

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

@@ -0,0 +1,16 @@
+package http_parser.lolevel;
+
+
+public class Test {
+  public static void main (String [] args) {
+    UnitTest.test();
+    TestHeaderOverflowError.test();
+    TestNoOverflowLongBody.test();
+    Responses.test();
+    ParseUrl.test();
+    Requests.test();
+    Upgrade.test();
+    WrongContentLength.test();
+  }
+
+}

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

@@ -0,0 +1,48 @@
+package http_parser.lolevel;
+
+import java.nio.*;
+
+import static http_parser.lolevel.Util.*;
+
+public class TestHeaderOverflowError {
+
+  public static void test (http_parser.ParserType type) {
+    HTTPParser parser = new HTTPParser(type);
+    ByteBuffer buf    = getBytes(type);
+    
+    int numbytes = buf.limit();
+
+    parser.execute(Util.SETTINGS_NULL, buf);
+
+    check(numbytes == buf.position());
+
+    buf      = buffer("header-key: header-value\r\n");
+    numbytes = buf.limit();
+    for (int i = 0; i!= 1000; ++i) {
+      parser.execute(Util.SETTINGS_NULL, buf);
+      check(numbytes == buf.position());
+
+      buf.rewind();
+
+    }
+  }
+
+  static ByteBuffer getBytes (http_parser.ParserType type) {
+    if (http_parser.ParserType.HTTP_BOTH == type) {
+      throw new RuntimeException("only HTTP_REQUEST and HTTP_RESPONSE");
+    }
+
+    if (http_parser.ParserType.HTTP_REQUEST == type) {
+      return buffer("GET / HTTP/1.1\r\n"); 
+    }
+    return buffer("HTTP/1.0 200 OK\r\n");
+  }
+
+  public static void test () {
+    p(TestHeaderOverflowError.class);
+    test(http_parser.ParserType.HTTP_REQUEST);
+    test(http_parser.ParserType.HTTP_RESPONSE);
+  }
+
+
+}

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

@@ -0,0 +1,212 @@
+package http_parser.lolevel;
+// name  : 200 trailing space on chunked body
+// raw   : "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nTransfer-Encoding: chunked\r\n\r\n25  \r\nThis is the data in the first chunk\r\n\r\n1C\r\nand this is the second one\r\n\r\n0  \r\n\r\n"
+// type  : HTTP_RESPONSE
+// method: HTTP_DELETE
+// status code :200
+// request_path:
+// request_url :
+// fragment    :
+// query_string:
+// body        :"This is the data in the first chunk\r\nand this is the second one\r\n"
+// body_size   :65
+// header_0 :{ "Content-Type": "text/plain"}
+// header_1 :{ "Transfer-Encoding": "chunked"}
+// should_keep_alive         :1
+// upgrade                   :0
+// http_major                :1
+// http_minor                :1
+
+
+import java.io.FileReader;
+import java.io.BufferedReader;
+import java.io.StringReader;
+import java.io.Reader;
+import java.io.Reader;
+import java.io.IOException;
+
+import java.util.*;
+import java.util.regex.*;
+
+import java.nio.ByteBuffer;
+
+import http_parser.HTTPMethod;
+import http_parser.ParserType;
+
+public class TestLoaderNG {
+  String fn;
+  public TestLoaderNG(String filename) {
+    this.fn = filename;
+  }
+  static void p(Object o) {
+    System.out.println(o);
+  }
+  public static List<Message> load (String fn) {
+    List<Message> list = null;
+    try {
+      BufferedReader buf = new BufferedReader(new FileReader(fn));
+      list = load(buf);
+    } catch (Throwable t) {
+      throw new RuntimeException(t);
+    }
+      return list;
+
+  }
+  public static Message parse (String message) {
+    List<Message> list = load(new BufferedReader(new StringReader(message)));  
+    if (null == list || 0 == list.size() ) {
+      return null;
+    } 
+    return list.get(0);
+  }
+
+  public static List<Message> load (BufferedReader buf) {
+    List<Message>    list = new LinkedList<Message>();
+    String        line = null;
+    Message          curr = new Message();
+    Pattern    pattern = Pattern.compile("(\\S+)\\s*:(.*)");
+    try {
+      while (null != (line = buf.readLine()) ){
+        if ("".equals(line.trim())) {
+          list.add (curr);
+          curr = new Message();
+          continue;
+        }
+        Matcher m = pattern.matcher(line);
+        if (m.matches()) {
+          // you can not be fucking serious!?
+          // this has got to be the most retarded regex 
+          // interface in the history of the world ...
+          // (though I'm sure there's worse c++ regexp libs...)
+          MatchResult r = m.toMatchResult();
+          String    key = r.group(1).trim();
+          String  value = r.group(2).trim();
+               if ("name".equals(key))         {curr.name = value;}
+          else if ("raw".equals(key))          {curr.raw = toByteArray(value);} //!
+          else if ("type".equals(key))         {curr.type = ParserType.parse(value);}
+          else if ("method".equals(key))       {curr.method = HTTPMethod.parse(value);}
+          else if ("status_code".equals(key))  {curr.status_code = Integer.parseInt(value);}
+          else if ("request_path".equals(key)) {curr.request_path = value;}
+          else if ("request_url".equals(key))  {curr.request_url = value;}
+
+          else if ("fragment".equals(key))     {curr.fragment = value;}
+          else if ("query_string".equals(key)) {curr.query_string = value;}
+          else if ("body".equals(key))         {curr.body = toByteArray(value);} //!
+          else if ("body_size".equals(key))    {curr.body_size = Integer.parseInt(value);}
+          else if (key.startsWith("header"))   {
+            String [] h = getHeader(value); 
+            curr.header.put(h[0], h[1]);
+          } 
+          else if ("should_keep_alive".equals(key)) 
+          {curr.should_keep_alive = (1 == Integer.parseInt(value));}
+          else if ("upgrade".equals(key))      { curr.upgrade = toByteArray(value);}
+          else if ("http_major".equals(key))   {curr.http_major = Integer.parseInt(value);}
+          else if ("http_minor".equals(key))   {curr.http_minor = Integer.parseInt(value);}
+        } else {
+          p("WTF?"+line);
+        }
+
+      }
+    } catch (Throwable t) {
+      throw new RuntimeException(t);
+    }
+    return list;
+  }
+
+  static String [] getHeader(String value) {
+    // { "Host": "0.0.0.0=5000"}
+    Pattern p = Pattern.compile("\\{ ?\"([^\"]*)\": ?\"(.*)\"}");
+    Matcher m = p.matcher(value);
+    if (!m.matches()) {
+      p(value);
+      throw new RuntimeException("something wrong");
+    }
+    String [] result = new String[2];
+    MatchResult r = m.toMatchResult();
+    result[0] = r.group(1).trim();
+    result[1] = r.group(2); //.trim();
+    return result;
+  }
+
+  static final byte BSLASH = 0x5c;
+  static final byte QUOT   = 0x22;
+  static final byte CR     = 0x0d;
+  static final byte LF     = 0x0a;
+  static final byte n      = 0x6e;
+  static final byte r      = 0x72;
+
+  static final Byte[] JAVA_GENERICS_ROCK_HARD = new Byte[0];
+
+
+  static byte [] toByteArray (String quotedString) {
+    ArrayList<Byte> bytes = new ArrayList<Byte>();
+    String s = quotedString.substring(1, quotedString.length()-1);
+    byte [] byts = s.getBytes(java.nio.charset.Charset.forName("UTF8"));
+    boolean escaped = false;
+    for (byte b : byts) {
+      switch (b) {
+        case BSLASH:
+          escaped = true;
+          break;
+        case n:
+          if (escaped) {
+            bytes.add(LF);
+            escaped = false;
+          } else {
+            bytes.add(b);
+          }
+          break;
+        case r:
+          if (escaped) {
+            escaped = false;
+            bytes.add(CR);
+          } else {
+            bytes.add(b);
+          }
+          break;
+        case QUOT:
+          escaped = false;
+          bytes.add(QUOT);
+          break;
+        default:
+          bytes.add(b);
+      }
+
+    }
+
+    byts = new byte[bytes.size()];
+    int i = 0;
+    for (Byte b : bytes) {
+      byts[i++]=b;
+    }
+    return byts;
+  }
+
+  public static void main(String [] args) throws Throwable {
+    //TestLoaderNG  l = new TestLoaderNG(args[0]);
+    List<Message> ts = load(args[0]);
+    for (Message t : ts) {
+//      for (int i =0; i!= t.raw.length; ++i) {
+//        p(i+":"+t.raw[i]);
+//      }
+//      try {
+      t.execute_permutations();
+//      } catch (Throwable th) {
+//        p("failed: "+t.name);
+//      }
+      t.execute();
+      //	System.exit(0);
+    }
+  }
+
+  class Header {
+    String field;
+    String value;
+  }
+  enum LastHeader {
+    NONE
+      ,FIELD
+      ,VALUE
+  }
+
+}