Merge IO v2 branch to bleeding edge

tests/standalone/io/http_parser_test.dart

-// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:async';
 import 'dart:math';
 import 'dart:scalarlist';
+import 'dart:isolate';
+import 'dart:uri';
 
+part '../../../sdk/lib/io/io_stream_consumer.dart';
 part '../../../sdk/lib/io/http.dart';
+part '../../../sdk/lib/io/http_impl.dart';
 part '../../../sdk/lib/io/http_headers.dart';
 part '../../../sdk/lib/io/http_parser.dart';
+part '../../../sdk/lib/io/socket.dart';
 
 class HttpParserTest {
   static void runAllTests() {
     testParseRequest();
     testParseResponse();
     testParseInvalidRequest();
     testParseInvalidResponse();
   }
 
   static void _testParseRequest(String request,
                                 String expectedMethod,
                                 String expectedUri,
-                                {int expectedContentLength: 0,
+                                {int expectedTransferLength: 0,
                                  int expectedBytesReceived: 0,
                                  Map expectedHeaders: null,
                                  bool chunked: false,
                                  bool upgrade: false,
                                  int unparsedLength: 0,
                                  bool connectionClose: false,
                                  String expectedVersion: "1.1"}) {
-    _HttpParser httpParser;
-    bool headersCompleteCalled;
-    bool dataEndCalled;
-    String method;
-    String uri;
-    String version;
-    HttpHeaders headers;
-    int contentLength;
-    int bytesReceived;
+    StreamController controller;
+    void reset() {
+      _HttpParser httpParser = new _HttpParser.requestParser();
+      controller = new StreamController();
+      var port1 = new ReceivePort();
+      var port2 = new ReceivePort();
 
-    void reset() {
-      httpParser = new _HttpParser.requestParser();
-      httpParser.requestStart = (m, u, v, h, b) {
-        method = m;
-        uri = u;
-        version = v;
-        headers = h;
-        headersCompleteCalled = true;
+      String method;
+      Uri uri;
+      HttpHeaders headers;
+      int contentLength;
+      int bytesReceived;
+      int unparsedBytesReceived;
+      bool upgraded;
+
+      controller.stream.pipe(httpParser);
+      var subscription = httpParser.listen((incoming) {
+        method = incoming.method;
+        uri = incoming.uri;
+        headers = incoming.headers;
+        upgraded = incoming.upgraded;
+        Expect.equals(upgrade, upgraded);
+
         if (!chunked) {
-          Expect.equals(expectedContentLength, httpParser.contentLength);
+          Expect.equals(expectedTransferLength, incoming.transferLength);
         } else {
-          Expect.equals(-1, httpParser.contentLength);
+          Expect.equals(-1, incoming.transferLength);
         }
         if (expectedHeaders != null) {
           expectedHeaders.forEach(
               (String name, String value) =>
               Expect.equals(value, headers[name][0]));
         }
-        Expect.equals(upgrade, httpParser.upgrade);
-        Expect.equals(connectionClose, !httpParser.persistentConnection);
-        headersCompleteCalled = true;
-      };
-      httpParser.responseStart = (s, r, v, h, b) {
-        Expect.fail("Expected request");
-      };
-      httpParser.dataReceived = (List<int> data) {
-        Expect.isTrue(headersCompleteCalled);
-        bytesReceived += data.length;
-      };
-      httpParser.dataEnd = (close) {
-        Expect.isFalse(close);
-        dataEndCalled = true;
-      };
-      httpParser.closed = () { };
+        incoming.listen(
+            (List<int> data) {
+              Expect.isFalse(upgraded);
+              bytesReceived += data.length;
+            },
+            onDone: () {
+              Expect.isFalse(upgraded);
+              port2.close();
+            });
 
-      headersCompleteCalled = false;
-      dataEndCalled = false;
+        if (upgraded) {
+          port1.close();
+          httpParser.detachIncoming().listen(
+              (List<int> data) {
+                unparsedBytesReceived += data.length;
+              },
+              onDone: () {
+                Expect.equals(unparsedLength, unparsedBytesReceived);
+                port2.close();
+              });
+        }
+
+        incoming.dataDone.then((_) {
+          port1.close();
+          Expect.isFalse(upgraded);
+          Expect.equals(expectedMethod, method);
+          Expect.stringEquals(expectedUri, uri.toString());
+          Expect.equals(expectedVersion, headers.protocolVersion);
+          if (upgrade) {
+            Expect.equals(0, bytesReceived);
+            // port1 is closed by the listener on the detached data.
+          } else {
+            Expect.equals(expectedBytesReceived, bytesReceived);
+          }
+        });
+      });
+
       method = null;
       uri = null;
       headers = null;
       bytesReceived = 0;
+      unparsedBytesReceived = 0;
+      upgraded = false;
     }
 
     void testWrite(List<int> requestData, [int chunkSize = -1]) {
       if (chunkSize == -1) chunkSize = requestData.length;
       reset();
-      int written = 0;
-      int unparsed;
       for (int pos = 0; pos < requestData.length; pos += chunkSize) {
         int remaining = requestData.length - pos;
         int writeLength = min(chunkSize, remaining);
-        written += writeLength;
-        httpParser.streamData(requestData.getRange(pos, writeLength));
-        unparsed = httpParser.readUnparsedData().length;
-        if (httpParser.upgrade) {
-          unparsed += requestData.length - written;
-          break;
-        } else {
-          Expect.equals(0, unparsed);
-        }
+        controller.add(requestData.getRange(pos, writeLength));
       }
-      Expect.equals(expectedMethod, method);
-      Expect.equals(expectedUri, uri);
-      Expect.equals(expectedVersion, version);
-      Expect.isTrue(headersCompleteCalled);
-      Expect.equals(expectedBytesReceived, bytesReceived);
-      if (!upgrade) Expect.isTrue(dataEndCalled);
-      if (unparsedLength == 0) {
-        Expect.equals(0, unparsed);
-      } else {
-        Expect.equals(unparsedLength, unparsed);
-      }
+      controller.close();
     }
 
     // Test parsing the request three times delivering the data in
     // different chunks.
     List<int> requestData = request.charCodes;
     testWrite(requestData);
     testWrite(requestData, 10);
     testWrite(requestData, 1);
   }
 
   static void _testParseInvalidRequest(String request) {
     _HttpParser httpParser;
     bool errorCalled;
+    StreamController controller;
 
     void reset() {
       httpParser = new _HttpParser.requestParser();
-      httpParser.responseStart = (s, r, v, h, b) {
+      controller = new StreamController();
+      var port = new ReceivePort();
+      controller.stream.pipe(httpParser);
+      var subscription = httpParser.listen((incoming) {
         Expect.fail("Expected request");
-      };
-      httpParser.error = (e) {
+      });
+      subscription.onError((e) {
         errorCalled = true;
-      };
-      httpParser.closed = () { };
-
+      });
+      subscription.onDone(() {
+        port.close();
+        Expect.isTrue(errorCalled);
+      });
       errorCalled = false;
     }
 
     void testWrite(List<int> requestData, [int chunkSize = -1]) {
       if (chunkSize == -1) chunkSize = requestData.length;
       reset();
       for (int pos = 0;
            pos < requestData.length && !errorCalled;
            pos += chunkSize) {
         int remaining = requestData.length - pos;
         int writeLength = min(chunkSize, remaining);
-        httpParser.streamData(requestData.getRange(pos, writeLength));
+        controller.add(requestData.getRange(pos, writeLength));
       }
-      Expect.isTrue(errorCalled);
+      controller.close();
     }
 
     // Test parsing the request three times delivering the data in
     // different chunks.
     List<int> requestData = request.charCodes;
     testWrite(requestData);
     testWrite(requestData, 10);
     testWrite(requestData, 1);
   }
 
   static void _testParseResponse(String response,
                                  int expectedStatusCode,
                                  String expectedReasonPhrase,
-                                 {int expectedContentLength: -1,
+                                 {int expectedTransferLength: 0,
                                   int expectedBytesReceived: 0,
                                   Map expectedHeaders: null,
                                   bool chunked: false,
                                   bool close: false,
                                   String responseToMethod: null,
                                   bool connectionClose: false,
                                   bool upgrade: false,
                                   int unparsedLength: 0,
                                   String expectedVersion: "1.1"}) {
     _HttpParser httpParser;
     bool headersCompleteCalled;
     bool dataEndCalled;
     bool dataEndClose;
     int statusCode;
     String reasonPhrase;
-    String version;
     HttpHeaders headers;
     int contentLength;
     int bytesReceived;
+    StreamController controller;
+    bool upgraded;
 
     void reset() {
       httpParser = new _HttpParser.responseParser();
-      if (responseToMethod != null) {
-        httpParser.responseToMethod = responseToMethod;
-      }
-      httpParser.requestStart = (m, u, v, h, b) {
-        Expect.fail("Expected response");
-      };
-      httpParser.responseStart = (s, r, v, h, b) {
-        statusCode = s;
-        reasonPhrase = r;
-        version = v;
-        headers = h;
+      controller = new StreamController();
+      var port = new ReceivePort();
+      controller.stream.pipe(httpParser);
+      var subscription = httpParser.listen((incoming) {
+        port.close();
+        statusCode = incoming.statusCode;
+        reasonPhrase = incoming.reasonPhrase;
+        headers = incoming.headers;
         Expect.isFalse(headersCompleteCalled);
         if (!chunked && !close) {
-          Expect.equals(expectedContentLength, httpParser.contentLength);
+          Expect.equals(expectedTransferLength, incoming.transferLength);
         } else {
-          Expect.equals(-1, httpParser.contentLength);
+          Expect.equals(-1, incoming.transferLength);
         }
         if (expectedHeaders != null) {
           expectedHeaders.forEach((String name, String value) {
             Expect.equals(value, headers[name][0]);
           });
         }
         Expect.equals(upgrade, httpParser.upgrade);
         headersCompleteCalled = true;
-      };
-      httpParser.dataReceived = (List<int> data) {
+        incoming.listen(
+            (List<int> data) {
+              Expect.isTrue(headersCompleteCalled);
+              bytesReceived += data.length;
+            },
+            onDone: () {
+              dataEndCalled = true;
+              dataEndClose = close;
+            });
+      });
+
+      subscription.onDone(() {
+        Expect.equals(expectedVersion, headers.protocolVersion);
+        Expect.equals(expectedStatusCode, statusCode);
+        Expect.equals(expectedReasonPhrase, reasonPhrase);
         Expect.isTrue(headersCompleteCalled);
-        bytesReceived += data.length;
-      };
-      httpParser.dataEnd = (close) {
-        dataEndCalled = true;
-        dataEndClose = close;
-      };
-      httpParser.closed = () { };
+        Expect.equals(expectedBytesReceived, bytesReceived);
+        if (!upgrade) {
+          Expect.isTrue(dataEndCalled);
+          if (close) Expect.isTrue(dataEndClose);
+          Expect.equals(dataEndClose, connectionClose);
+        }
+      });
 
       headersCompleteCalled = false;
       dataEndCalled = false;
       dataEndClose = null;
       statusCode = -1;
       reasonPhrase = null;
       headers = null;
       bytesReceived = 0;
     }
 
     void testWrite(List<int> requestData, [int chunkSize = -1]) {
       if (chunkSize == -1) chunkSize = requestData.length;
       reset();
-      int written = 0;
-      int unparsed;
       for (int pos = 0; pos < requestData.length; pos += chunkSize) {
         int remaining = requestData.length - pos;
         int writeLength = min(chunkSize, remaining);
-        written += writeLength;
-        httpParser.streamData(requestData.getRange(pos, writeLength));
-        unparsed = httpParser.readUnparsedData().length;
-        if (httpParser.upgrade) {
-          unparsed += requestData.length - written;
-          break;
-        } else {
-          Expect.equals(0, unparsed);
-        }
+        controller.add(requestData.getRange(pos, writeLength));
+
       }
-      if (close) httpParser.streamDone();
-      Expect.equals(expectedVersion, version);
-      Expect.equals(expectedStatusCode, statusCode);
-      Expect.equals(expectedReasonPhrase, reasonPhrase);
-      Expect.isTrue(headersCompleteCalled);
-      Expect.equals(expectedBytesReceived, bytesReceived);
-      if (!upgrade) {
-        Expect.isTrue(dataEndCalled);
-        if (close) Expect.isTrue(dataEndClose);
-        Expect.equals(dataEndClose, connectionClose);
-      }
-      if (unparsedLength == 0) {
-        Expect.equals(0, unparsed);
-      } else {
-        Expect.equals(unparsedLength, unparsed);
-      }
+      if (close) controller.close();
     }
 
     // Test parsing the request three times delivering the data in
     // different chunks.
     List<int> responseData = response.charCodes;
     testWrite(responseData);
     testWrite(responseData, 10);
     testWrite(responseData, 1);
   }
 
   static void _testParseInvalidResponse(String response, [bool close = false]) {
     _HttpParser httpParser;
     bool errorCalled;
+    StreamController controller;
 
     void reset() {
       httpParser = new _HttpParser.responseParser();
-      httpParser.requestStart = (m, u, v, h, b) {
-        Expect.fail("Expected response");
-      };
-      httpParser.error = (e) => errorCalled = true;
-      httpParser.closed = () { };
-
+      controller = new StreamController();
+      var port = new ReceivePort();
+      controller.stream.pipe(httpParser);
+      var subscription = httpParser.listen((incoming) {
+        incoming.listen(
+          (data) {},
+          onError: (e) {
+            Expect.isFalse(errorCalled);
+            errorCalled = true;
+          });
+      });
+      subscription.onError((e) {
+        Expect.isFalse(errorCalled);
+        errorCalled = true;
+      });
+      subscription.onDone(() {
+        port.close();
+        Expect.isTrue(errorCalled);
+      });
       errorCalled = false;
     }
 
     void testWrite(List<int> requestData, [int chunkSize = -1]) {
       if (chunkSize == -1) chunkSize = requestData.length;
       reset();
       for (int pos = 0;
            pos < requestData.length && !errorCalled;
            pos += chunkSize) {
         int remaining = requestData.length - pos;
         int writeLength = min(chunkSize, remaining);
-        httpParser.streamData(requestData.getRange(pos, writeLength));
+        controller.add(requestData.getRange(pos, writeLength));
       }
-      if (close) httpParser.streamDone();
-      Expect.isTrue(errorCalled);
+      controller.close();
     }
 
     // Test parsing the request three times delivering the data in
     // different chunks.
     List<int> responseData = response.charCodes;
     testWrite(responseData);
     testWrite(responseData, 10);
     testWrite(responseData, 1);
   }
 
   static void testParseRequest() {
     String request;
     Map headers;
     var methods = [
         // RFC 2616 methods.
         "OPTIONS", "GET", "HEAD", "POST", "PUT", "DELETE", "TRACE", "CONNECT",
         // WebDAV methods from RFC 4918.
         "PROPFIND", "PROPPATCH", "MKCOL", "COPY", "MOVE", "LOCK", "UNLOCK",
         // WebDAV methods from RFC 5323.
         "SEARCH",
         // Methods with HTTP prefix.
         "H", "HT", "HTT", "HTTP", "HX", "HTX", "HTTX", "HTTPX"];
     methods.forEach((method) {
        request = "$method / HTTP/1.1\r\n\r\n";
       _testParseRequest(request, method, "/");
        request = "$method /index.html HTTP/1.1\r\n\r\n";
       _testParseRequest(request, method, "/index.html");
     });
 
+
     request = "GET / HTTP/1.0\r\n\r\n";
     _testParseRequest(request, "GET", "/",
                       expectedVersion: "1.0",
                       connectionClose: true);
 
     request = "GET / HTTP/1.0\r\nConnection: keep-alive\r\n\r\n";
     _testParseRequest(request, "GET", "/", expectedVersion: "1.0");
 
     request = """
 POST /test HTTP/1.1\r
@@ skipping 57 matching lines @@
     _testParseRequest(request, "POST", "/test", expectedHeaders: headers);
 
     request = """
 POST /test HTTP/1.1\r
 Content-Length: 10\r
 \r
 0123456789""";
     _testParseRequest(request,
                       "POST",
                       "/test",
-                      expectedContentLength: 10,
+                      expectedTransferLength: 10,
                       expectedBytesReceived: 10);
 
     // Test connection close header.
     request = "GET /test HTTP/1.1\r\nConnection: close\r\n\r\n";
     _testParseRequest(request, "GET", "/test", connectionClose: true);
 
     // Test chunked encoding.
     request = """
 POST /test HTTP/1.1\r
 Transfer-Encoding: chunked\r
 \r
 5\r
 01234\r
 5\r
 56789\r
 0\r\n\r\n""";
     _testParseRequest(request,
                       "POST",
                       "/test",
-                      expectedContentLength: -1,
+                      expectedTransferLength: -1,
                       expectedBytesReceived: 10,
                       chunked: true);
 
     // Test mixing chunked encoding and content length (content length
     // is ignored).
     request = """
 POST /test HTTP/1.1\r
 Content-Length: 7\r
 Transfer-Encoding: chunked\r
 \r
 5\r
 01234\r
 5\r
 56789\r
 0\r\n\r\n""";
     _testParseRequest(request,
                       "POST",
                       "/test",
-                      expectedContentLength: -1,
+                      expectedTransferLength: -1,
                       expectedBytesReceived: 10,
                       chunked: true);
 
     // Test mixing chunked encoding and content length (content length
     // is ignored).
     request = """
 POST /test HTTP/1.1\r
 Transfer-Encoding: chunked\r
 Content-Length: 3\r
 \r
 5\r
 01234\r
 5\r
 56789\r
 0\r\n\r\n""";
     _testParseRequest(request,
                       "POST",
                       "/test",
-                      expectedContentLength: -1,
+                      expectedTransferLength: -1,
                       expectedBytesReceived: 10,
                       chunked: true);
 
     // Test upper and lower case hex digits in chunked encoding.
     request = """
 POST /test HTTP/1.1\r
 Transfer-Encoding: chunked\r
 \r
 1E\r
 012345678901234567890123456789\r
 1e\r
 012345678901234567890123456789\r
 0\r\n\r\n""";
     _testParseRequest(request,
                       "POST",
                       "/test",
-                      expectedContentLength: -1,
+                      expectedTransferLength: -1,
                       expectedBytesReceived: 60,
                       chunked: true);
 
     // Test chunk extensions in chunked encoding.
     request = """
 POST /test HTTP/1.1\r
 Transfer-Encoding: chunked\r
 \r
 1E;xxx\r
 012345678901234567890123456789\r
 1E;yyy=zzz\r
 012345678901234567890123456789\r
 0\r\n\r\n""";
     _testParseRequest(request,
                       "POST",
                       "/test",
-                      expectedContentLength: -1,
+                      expectedTransferLength: -1,
                       expectedBytesReceived: 60,
                       chunked: true);
 
     // Test HTTP upgrade.
     request = """
 GET /irc HTTP/1.1\r
 Upgrade: irc/1.2\r
 Connection: Upgrade\r
 \r\n\x01\x01\x01\x01\x01\x02\x02\x02\x02\xFF""";
     headers = new Map();
@@ skipping 67 matching lines @@
                       "/chat",
                       expectedHeaders: headers,
                       upgrade: true,
                       unparsedLength: 7);
   }
 
   static void testParseResponse() {
     String response;
     Map headers;
     response = "HTTP/1.1 100 Continue\r\nContent-Length: 0\r\n\r\n";
-    _testParseResponse(response, 100, "Continue", expectedContentLength: 0);
+    _testParseResponse(response, 100, "Continue");
+
+    response = "HTTP/1.1 100 Continue\r\nContent-Length: 0\r\n\r\n";
+    _testParseResponse(response, 100, "Continue");
 
     response = "HTTP/1.1 100 Continue\r\nContent-Length: 10\r\n\r\n";
     _testParseResponse(response,
                        100,
                        "Continue",
-                       expectedContentLength: 10,
+                       expectedTransferLength: 10,
                        expectedBytesReceived: 0);
 
     response = "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n"
                "Connection: Close\r\n\r\n";
     _testParseResponse(response,
                        200,
                        "OK",
-                       expectedContentLength: 0,
                        connectionClose: true);
 
     response = "HTTP/1.0 200 OK\r\nContent-Length: 0\r\n\r\n";
     _testParseResponse(response,
                        200,
                        "OK",
-                       expectedContentLength: 0,
                        expectedVersion: "1.0",
                        connectionClose: true);
 
     response = "HTTP/1.0 200 OK\r\nContent-Length: 0\r\n"
                "Connection: Keep-Alive\r\n\r\n";
     _testParseResponse(response,
                        200,
                        "OK",
-                       expectedContentLength: 0,
                        expectedVersion: "1.0");
 
     response = "HTTP/1.1 204 No Content\r\nContent-Length: 11\r\n\r\n";
     _testParseResponse(response,
                        204,
                        "No Content",
-                       expectedContentLength: 11,
+                       expectedTransferLength: 11,
                        expectedBytesReceived: 0);
 
     response = "HTTP/1.1 304 Not Modified\r\nContent-Length: 12\r\n\r\n";
     _testParseResponse(response,
                        304,
                        "Not Modified",
-                       expectedContentLength: 12,
+                       expectedTransferLength: 12,
                        expectedBytesReceived: 0);
 
     response = "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n";
-    _testParseResponse(response, 200, "OK", expectedContentLength: 0);
+    _testParseResponse(response, 200, "OK");
 
     response = "HTTP/1.1 404 Not found\r\nContent-Length: 0\r\n\r\n";
-    _testParseResponse(response, 404, "Not found", expectedContentLength: 0);
+    _testParseResponse(response, 404, "Not found");
 
     response = "HTTP/1.1 500 Server error\r\nContent-Length: 0\r\n\r\n";
-    _testParseResponse(response, 500, "Server error", expectedContentLength: 0);
+    _testParseResponse(response, 500, "Server error");
 
     // Test response to HEAD request.
     response = """
 HTTP/1.1 200 OK\r
 Content-Length: 20\r
 Content-Type: text/html\r
 \r\n""";
     headers = new Map();
     headers["content-length"] = "20";
     headers["content-type"] = "text/html";
     _testParseResponse(response,
                        200,
                        "OK",
                        responseToMethod: "HEAD",
-                       expectedContentLength: 20,
+                       expectedTransferLength: 20,
                        expectedBytesReceived: 0,
                        expectedHeaders: headers);
 
     // Test content.
     response = """
 HTTP/1.1 200 OK\r
 Content-Length: 20\r
 \r
 01234567890123456789""";
     _testParseResponse(response,
                        200,
                        "OK",
-                       expectedContentLength: 20,
+                       expectedTransferLength: 20,
                        expectedBytesReceived: 20);
 
     // Test upper and lower case hex digits in chunked encoding.
     response = """
 HTTP/1.1 200 OK\r
 Transfer-Encoding: chunked\r
 \r
 1A\r
 01234567890123456789012345\r
 1f\r
 0123456789012345678901234567890\r
 0\r\n\r\n""";
     _testParseResponse(response,
                        200,
                        "OK",
-                       expectedContentLength: -1,
+                       expectedTransferLength: -1,
                        expectedBytesReceived: 57,
                        chunked: true);
 
     // Test connection close header.
     response = """
 HTTP/1.1 200 OK\r
 Content-Length: 0\r
 Connection: close\r
 \r\n""";
     _testParseResponse(response,
                        200,
                        "OK",
-                       expectedContentLength: 0,
                        connectionClose: true);
 
     // Test HTTP response without any transfer length indications
     // where closing the connections indicates end of body.
     response = """
 HTTP/1.1 200 OK\r
 \r
 01234567890123456789012345
 0123456789012345678901234567890
 """;
     _testParseResponse(response,
                        200,
                        "OK",
-                       expectedContentLength: -1,
+                       expectedTransferLength: -1,
                        expectedBytesReceived: 59,
                        close: true,
                        connectionClose: true);
 
     // Test HTTP upgrade.
     response = """
 HTTP/1.1 101 Switching Protocols\r
 Upgrade: irc/1.2\r
 Connection: Upgrade\r
 \r\n""";
@@ skipping 133 matching lines @@
 0123456789012345678901234567890\r
 0\r\n\r\n""";
     _testParseInvalidResponse(response);
   }
 }
 
 
 void main() {
   HttpParserTest.runAllTests();
 }