diff --git a/test/http_head_test.dart b/test/http_head_test.dart
index 0388461..0833eac 100644
--- a/test/http_head_test.dart
+++ b/test/http_head_test.dart
@@ -7,9 +7,9 @@
 import 'package:http_io/http_io.dart';
 import 'package:test/test.dart';
 
-Future<Null> testHEAD(int totalConnections) {
+Future<Null> testHEAD(int totalConnections) async {
   final completer = new Completer<Null>();
-  HttpServer.bind("127.0.0.1", 0).then((server) {
+  HttpServer.bind("127.0.0.1", 0).then((server) async {
     server.listen((request) {
       var response = request.response;
       if (request.uri.path == "/test100") {
@@ -48,7 +48,7 @@
 
     for (int i = 0; i < totalConnections; i++) {
       int len = (i % 2 == 0) ? 100 : 200;
-      client
+      await client
           .open("HEAD", "127.0.0.1", server.port, "/test$len")
           .then((request) => request.close())
           .then((HttpClientResponse response) {
@@ -57,7 +57,7 @@
             onDone: requestDone);
       });
 
-      client
+      await client
           .open("HEAD", "127.0.0.1", server.port, "/testChunked$len")
           .then((request) => request.close())
           .then((HttpClientResponse response) {
diff --git a/test/http_keep_alive_test.dart b/test/http_keep_alive_test.dart
index e26f35c..266be96 100644
--- a/test/http_keep_alive_test.dart
+++ b/test/http_keep_alive_test.dart
@@ -7,7 +7,7 @@
 import 'package:http_io/http_io.dart';
 import 'package:test/test.dart';
 
-Future getData(HttpClient client, int port, bool chunked, int length) {
+Future<int> getData(HttpClient client, int port, bool chunked, int length) {
   return client
       .get("127.0.0.1", port, "/?chunked=$chunked&length=$length")
       .then((request) => request.close())
diff --git a/test/http_parser_test.dart b/test/http_parser_test.dart
new file mode 100644
index 0000000..a567838
--- /dev/null
+++ b/test/http_parser_test.dart
@@ -0,0 +1,811 @@
+// 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.
+
+library dart.http;
+
+import "dart:async";
+import "dart:isolate";
+import "dart:math";
+import "dart:typed_data";
+
+import 'package:http_io/http_io.dart';
+import 'package:http_io/src/http_parser.dart';
+import 'package:test/test.dart';
+
+class HttpParserTest {
+  static void runAllTests() {
+    test('parseRequest', testParseRequest);
+    test('parseResponse', testParseResponse);
+    test('parseInvalidRequest', testParseInvalidRequest);
+    test('parseInvalidResponse', testParseInvalidResponse);
+  }
+
+  static void _testParseRequest(
+      String request, String expectedMethod, String expectedUri,
+      {int expectedTransferLength: 0,
+      int expectedBytesReceived: 0,
+      Map<String, String> expectedHeaders: null,
+      bool chunked: false,
+      bool upgrade: false,
+      int unparsedLength: 0,
+      bool connectionClose: false,
+      String expectedVersion: "1.1"}) {
+    StreamController<List<int>> controller;
+    void reset() {
+      HttpParser httpParser = new HttpParser.requestParser();
+      controller = new StreamController(sync: true);
+      var port1 = new ReceivePort();
+      var port2 = new ReceivePort();
+
+      String method;
+      Uri uri;
+      HttpHeaders headers;
+      int bytesReceived;
+      int unparsedBytesReceived;
+      bool upgraded;
+
+      httpParser.listenToStream(controller.stream);
+      httpParser.listen((incoming) {
+        method = incoming.method;
+        uri = incoming.uri;
+        headers = incoming.headers;
+        upgraded = incoming.upgraded;
+        expect(upgrade, equals(upgraded));
+
+        if (!chunked) {
+          expect(expectedTransferLength, equals(incoming.transferLength));
+        } else {
+          expect(-1, equals(incoming.transferLength));
+        }
+        if (expectedHeaders != null) {
+          expectedHeaders.forEach((String name, String value) =>
+              expect(value, equals(headers[name][0])));
+        }
+        incoming.listen((List<int> data) {
+          expect(upgraded, isFalse);
+          bytesReceived += data.length;
+        }, onDone: () {
+          port2.close();
+          expect(expectedMethod, equals(method));
+          expect(expectedUri, equals(uri.toString()));
+          expect(expectedVersion, equals(headers.protocolVersion));
+          if (upgrade) {
+            expect(0, equals(bytesReceived));
+            // port1 is closed by the listener on the detached data.
+          } else {
+            expect(expectedBytesReceived, equals(bytesReceived));
+          }
+        });
+
+        if (upgraded) {
+          port1.close();
+          httpParser.detachIncoming().listen((List<int> data) {
+            unparsedBytesReceived += data.length;
+          }, onDone: () {
+            expect(unparsedLength, equals(unparsedBytesReceived));
+            port2.close();
+          });
+        }
+
+        incoming.dataDone.then((_) {
+          port1.close();
+        });
+      });
+
+      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();
+      for (int pos = 0; pos < requestData.length; pos += chunkSize) {
+        int end = min(requestData.length, pos + chunkSize);
+        controller.add(requestData.sublist(pos, end));
+      }
+      controller.close();
+    }
+
+    // Test parsing the request three times delivering the data in
+    // different chunks.
+    List<int> requestData = new Uint8List.fromList(request.codeUnits);
+    testWrite(requestData);
+    testWrite(requestData, 10);
+    testWrite(requestData, 1);
+  }
+
+  static void _testParseRequestLean(
+      String request, String expectedMethod, String expectedUri,
+      {int expectedTransferLength: 0,
+      int expectedBytesReceived: 0,
+      Map<String, String> expectedHeaders: null,
+      bool chunked: false,
+      bool upgrade: false,
+      int unparsedLength: 0,
+      bool connectionClose: false,
+      String expectedVersion: "1.1"}) {
+    _testParseRequest(request, expectedMethod, expectedUri,
+        expectedTransferLength: expectedTransferLength,
+        expectedBytesReceived: expectedBytesReceived,
+        expectedHeaders: expectedHeaders,
+        chunked: chunked,
+        upgrade: upgrade,
+        unparsedLength: unparsedLength,
+        connectionClose: connectionClose,
+        expectedVersion: expectedVersion);
+    // Same test but with only \n instead of \r\n terminating each header line.
+    _testParseRequest(request.replaceAll('\r', ''), expectedMethod, expectedUri,
+        expectedTransferLength: expectedTransferLength,
+        expectedBytesReceived: expectedBytesReceived,
+        expectedHeaders: expectedHeaders,
+        chunked: chunked,
+        upgrade: upgrade,
+        unparsedLength: unparsedLength,
+        connectionClose: connectionClose,
+        expectedVersion: expectedVersion);
+  }
+
+  static void _testParseInvalidRequest(String request) {
+    HttpParser httpParser;
+    bool errorCalled;
+    StreamController<List<int>> controller;
+
+    void reset() {
+      httpParser = new HttpParser.requestParser();
+      controller = new StreamController(sync: true);
+      var port = new ReceivePort();
+      httpParser.listenToStream(controller.stream);
+      var subscription = httpParser.listen((incoming) {
+        fail("Expected request");
+      });
+      subscription.onError((e) {
+        errorCalled = true;
+      });
+      subscription.onDone(() {
+        port.close();
+        expect(errorCalled, isTrue);
+      });
+      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 end = min(requestData.length, pos + chunkSize);
+        controller.add(requestData.sublist(pos, end));
+      }
+      controller.close();
+    }
+
+    // Test parsing the request three times delivering the data in
+    // different chunks.
+    List<int> requestData = new Uint8List.fromList(request.codeUnits);
+    testWrite(requestData);
+    testWrite(requestData, 10);
+    testWrite(requestData, 1);
+  }
+
+  static void _testParseResponse(
+      String response, int expectedStatusCode, String expectedReasonPhrase,
+      {int expectedTransferLength: 0,
+      int expectedBytesReceived: 0,
+      Map<String, String> expectedHeaders: null,
+      bool chunked: false,
+      bool close: false,
+      String responseToMethod: null,
+      bool connectionClose: false,
+      bool upgrade: false,
+      int unparsedLength: 0,
+      String expectedVersion: "1.1"}) {
+    StreamController<List<int>> controller;
+
+    void reset() {
+      HttpParser httpParser;
+      bool headersCompleteCalled;
+      bool dataEndCalled;
+      bool dataEndClose;
+      int statusCode;
+      String reasonPhrase;
+      HttpHeaders headers;
+      int bytesReceived;
+      httpParser = new HttpParser.responseParser();
+      controller = new StreamController(sync: true);
+      var port = new ReceivePort();
+      httpParser.listenToStream(controller.stream);
+      int doneCallCount = 0;
+      // Called when done parsing entire message and done parsing body.
+      // Only executed when both are done.
+      void whenDone() {
+        doneCallCount++;
+        if (doneCallCount < 2) return;
+        expect(expectedVersion, equals(headers.protocolVersion));
+        expect(expectedStatusCode, equals(statusCode));
+        expect(expectedReasonPhrase, equals(reasonPhrase));
+        expect(headersCompleteCalled, isTrue);
+        expect(expectedBytesReceived, equals(bytesReceived));
+        if (!upgrade) {
+          expect(dataEndCalled, isTrue);
+          if (close) expect(dataEndClose, isTrue);
+          expect(dataEndClose, equals(connectionClose));
+        }
+      }
+
+      ;
+
+      httpParser.listen((incoming) {
+        port.close();
+        statusCode = incoming.statusCode;
+        reasonPhrase = incoming.reasonPhrase;
+        headers = incoming.headers;
+        expect(headersCompleteCalled, isFalse);
+        if (!chunked && !close) {
+          expect(expectedTransferLength, equals(incoming.transferLength));
+        } else {
+          expect(-1, equals(incoming.transferLength));
+        }
+        if (expectedHeaders != null) {
+          expectedHeaders.forEach((String name, String value) {
+            expect(value, equals(headers[name][0]));
+          });
+        }
+        expect(upgrade, equals(httpParser.upgrade));
+        headersCompleteCalled = true;
+        incoming.listen((List<int> data) {
+          expect(headersCompleteCalled, isTrue);
+          bytesReceived += data.length;
+        }, onDone: () {
+          dataEndCalled = true;
+          dataEndClose = close;
+          whenDone();
+        });
+      }, onDone: whenDone);
+
+      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();
+      for (int pos = 0; pos < requestData.length; pos += chunkSize) {
+        int end = min(requestData.length, pos + chunkSize);
+        controller.add(requestData.sublist(pos, end));
+      }
+      if (close) controller.close();
+    }
+
+    // Test parsing the request three times delivering the data in
+    // different chunks.
+    List<int> responseData = new Uint8List.fromList(response.codeUnits);
+    testWrite(responseData);
+    testWrite(responseData, 10);
+    testWrite(responseData, 1);
+  }
+
+  static void _testParseInvalidResponse(String response, [bool close = false]) {
+    void testWrite(List<int> requestData, [int chunkSize = -1]) {
+      HttpParser httpParser = new HttpParser.responseParser();
+      StreamController<List<int>> controller = new StreamController(sync: true);
+      bool errorCalled = false;
+      ;
+
+      if (chunkSize == -1) chunkSize = requestData.length;
+
+      var port = new ReceivePort();
+      httpParser.listenToStream(controller.stream);
+      var subscription = httpParser.listen((incoming) {
+        incoming.listen((data) {}, onError: (e) {
+          expect(errorCalled, isFalse);
+          errorCalled = true;
+        });
+      });
+      subscription.onError((e) {
+        expect(errorCalled, isFalse);
+        errorCalled = true;
+      });
+      subscription.onDone(() {
+        port.close();
+        expect(errorCalled, isTrue);
+      });
+
+      errorCalled = false;
+      for (int pos = 0;
+          pos < requestData.length && !errorCalled;
+          pos += chunkSize) {
+        int end = min(requestData.length, pos + chunkSize);
+        controller.add(requestData.sublist(pos, end));
+      }
+      controller.close();
+    }
+
+    // Test parsing the request three times delivering the data in
+    // different chunks.
+    List<int> responseData = new Uint8List.fromList(response.codeUnits);
+    testWrite(responseData);
+    testWrite(responseData, 10);
+    testWrite(responseData, 1);
+  }
+
+  static void testParseRequest() {
+    String request;
+    Map<String, String> 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 = ['GET'];
+    methods.forEach((method) {
+      request = "$method / HTTP/1.1\r\n\r\n";
+      _testParseRequestLean(request, method, "/");
+      request = "$method /index.html HTTP/1.1\r\n\r\n";
+      _testParseRequestLean(request, method, "/index.html");
+    });
+    request = "GET / HTTP/1.0\r\n\r\n";
+    _testParseRequestLean(request, "GET", "/",
+        expectedVersion: "1.0", connectionClose: true);
+
+    request = "GET / HTTP/1.0\r\nConnection: keep-alive\r\n\r\n";
+    _testParseRequestLean(request, "GET", "/", expectedVersion: "1.0");
+
+    request = """
+POST /test HTTP/1.1\r
+AAA: AAA\r
+\r
+""";
+    _testParseRequestLean(request, "POST", "/test");
+
+    request = """
+POST /test HTTP/1.1\r
+\r
+""";
+    _testParseRequestLean(request, "POST", "/test");
+
+    request = """
+POST /test HTTP/1.1\r
+Header-A: AAA\r
+X-Header-B: bbb\r
+\r
+""";
+    headers = new Map();
+    headers["header-a"] = "AAA";
+    headers["x-header-b"] = "bbb";
+    _testParseRequestLean(request, "POST", "/test", expectedHeaders: headers);
+
+    request = """
+POST /test HTTP/1.1\r
+Empty-Header-1:\r
+Empty-Header-2:\r
+        \r
+\r
+""";
+    headers = new Map();
+    headers["empty-header-1"] = "";
+    headers["empty-header-2"] = "";
+    _testParseRequestLean(request, "POST", "/test", expectedHeaders: headers);
+
+    request = """
+POST /test HTTP/1.1\r
+Header-A:   AAA\r
+X-Header-B:\t \t bbb\r
+\r
+""";
+    headers = new Map();
+    headers["header-a"] = "AAA";
+    headers["x-header-b"] = "bbb";
+    _testParseRequestLean(request, "POST", "/test", expectedHeaders: headers);
+
+    request = """
+POST /test HTTP/1.1\r
+Header-A:   AA\r
+ A\r
+X-Header-B:           b\r
+  b\r
+\t    b\r
+\r
+""";
+
+    headers = new Map();
+    headers["header-a"] = "AAA";
+    headers["x-header-b"] = "bbb";
+    _testParseRequestLean(request, "POST", "/test", expectedHeaders: headers);
+
+    request = """
+POST /test HTTP/1.1\r
+Content-Length: 10\r
+\r
+0123456789""";
+    _testParseRequestLean(request, "POST", "/test",
+        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",
+        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",
+        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",
+        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",
+        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",
+        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();
+    headers["upgrade"] = "irc/1.2";
+    _testParseRequest(request, "GET", "/irc",
+        expectedHeaders: headers, upgrade: true, unparsedLength: 10);
+
+    // Test HTTP upgrade with protocol data.
+    request = """
+GET /irc HTTP/1.1\r
+Upgrade: irc/1.2\r
+Connection: Upgrade\r
+\r\n""";
+    headers = new Map();
+    headers["upgrade"] = "irc/1.2";
+    _testParseRequest(request, "GET", "/irc",
+        expectedHeaders: headers, upgrade: true);
+
+    // Test websocket upgrade.
+    request = """
+GET /chat HTTP/1.1\r
+Host: server.example.com\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r
+Origin: http://example.com\r
+Sec-WebSocket-Version: 13\r
+\r\n""";
+    headers = new Map();
+    headers["host"] = "server.example.com";
+    headers["upgrade"] = "websocket";
+    headers["sec-websocket-key"] = "dGhlIHNhbXBsZSBub25jZQ==";
+    headers["origin"] = "http://example.com";
+    headers["sec-websocket-version"] = "13";
+    _testParseRequest(request, "GET", "/chat",
+        expectedHeaders: headers, upgrade: true);
+
+    // Test websocket upgrade with protocol data. NOTE: When using the
+    // WebSocket protocol this should never happen as the client
+    // should not send protocol data before processing the request
+    // part of the opening handshake. However the HTTP parser should
+    // still handle this.
+    request = """
+GET /chat HTTP/1.1\r
+Host: server.example.com\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r
+Origin: http://example.com\r
+Sec-WebSocket-Version: 13\r
+\r\n0123456""";
+    headers = new Map();
+    headers["host"] = "server.example.com";
+    headers["upgrade"] = "websocket";
+    headers["sec-websocket-key"] = "dGhlIHNhbXBsZSBub25jZQ==";
+    headers["origin"] = "http://example.com";
+    headers["sec-websocket-version"] = "13";
+    _testParseRequest(request, "GET", "/chat",
+        expectedHeaders: headers, upgrade: true, unparsedLength: 7);
+  }
+
+  static void testParseResponse() {
+    String response;
+    Map<String, String> headers;
+    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: 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",
+        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", connectionClose: true);
+
+    response = "HTTP/1.0 200 OK\r\nContent-Length: 0\r\n\r\n";
+    _testParseResponse(response, 200, "OK",
+        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", expectedVersion: "1.0");
+
+    response = "HTTP/1.1 204 No Content\r\nContent-Length: 11\r\n\r\n";
+    _testParseResponse(response, 204, "No Content",
+        expectedTransferLength: 11, expectedBytesReceived: 0);
+
+    response = "HTTP/1.1 304 Not Modified\r\nContent-Length: 12\r\n\r\n";
+    _testParseResponse(response, 304, "Not Modified",
+        expectedTransferLength: 12, expectedBytesReceived: 0);
+
+    response = "HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n";
+    _testParseResponse(response, 200, "OK");
+
+    response = "HTTP/1.1 404 Not found\r\nContent-Length: 0\r\n\r\n";
+    _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");
+
+    // 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",
+        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",
+        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",
+        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", 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",
+        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""";
+    headers = new Map();
+    headers["upgrade"] = "irc/1.2";
+    _testParseResponse(response, 101, "Switching Protocols",
+        expectedHeaders: headers, upgrade: true);
+
+    // Test HTTP upgrade with protocol data.
+    response = """
+HTTP/1.1 101 Switching Protocols\r
+Upgrade: irc/1.2\r
+Connection: Upgrade\r
+\r\n\x00\x10\x20\x30\x40\x50\x60\x70\x80\x90\xA0\xB0\xC0\xD0\xE0\xF0""";
+    headers = new Map();
+    headers["upgrade"] = "irc/1.2";
+    _testParseResponse(response, 101, "Switching Protocols",
+        expectedHeaders: headers, upgrade: true, unparsedLength: 16);
+
+    // Test websocket upgrade.
+    response = """
+HTTP/1.1 101 Switching Protocols\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r
+\r\n""";
+    headers = new Map();
+    headers["upgrade"] = "websocket";
+    headers["sec-websocket-accept"] = "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=";
+    _testParseResponse(response, 101, "Switching Protocols",
+        expectedHeaders: headers, upgrade: true);
+
+    // Test websocket upgrade with protocol data.
+    response = """
+HTTP/1.1 101 Switching Protocols\r
+Upgrade: websocket\r
+Connection: Upgrade\r
+Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r
+\r\nABCD""";
+    headers = new Map();
+    headers["upgrade"] = "websocket";
+    headers["sec-websocket-accept"] = "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=";
+    _testParseResponse(response, 101, "Switching Protocols",
+        expectedHeaders: headers, upgrade: true, unparsedLength: 4);
+  }
+
+  static void testParseInvalidRequest() {
+    String request;
+    request = "GET /\r\n\r\n";
+    _testParseInvalidRequest(request);
+
+    request = "GET / \r\n\r\n";
+    _testParseInvalidRequest(request);
+
+    request = "/ HTTP/1.1\r\n\r\n";
+    _testParseInvalidRequest(request);
+
+    request = "GET HTTP/1.1\r\n\r\n";
+    _testParseInvalidRequest(request);
+
+    request = " / HTTP/1.1\r\n\r\n";
+    _testParseInvalidRequest(request);
+
+    request = "@ / HTTP/1.1\r\n\r\n";
+    _testParseInvalidRequest(request);
+
+    request = "GET / TTP/1.1\r\n\r\n";
+    _testParseInvalidRequest(request);
+
+    request = "GET / HTTP/1.\r\n\r\n";
+    _testParseInvalidRequest(request);
+
+    request = "GET / HTTP/1.1\r\nKeep-Alive: False\r\nbadheader\r\n\r\n";
+    _testParseInvalidRequest(request);
+  }
+
+  static void testParseInvalidResponse() {
+    String response;
+
+    response = "HTTP/1.1\r\nContent-Length: 0\r\n\r\n";
+    _testParseInvalidResponse(response);
+
+    response = "HTTP/1.1 \r\nContent-Length: 0\r\n\r\n";
+    _testParseInvalidResponse(response);
+
+    response = "HTTP/1.1 200\r\nContent-Length: 0\r\n\r\n";
+    _testParseInvalidResponse(response);
+
+    response = "HTTP/1.1 200 \r\nContent-Length: 0\r\n\r\n";
+    _testParseInvalidResponse(response);
+
+    response = "HTTP/1.1 OK\r\nContent-Length: 0\r\n\r\n";
+    _testParseInvalidResponse(response);
+
+    response = "200 OK\r\nContent-Length: 0\r\n\r\n";
+    _testParseInvalidResponse(response);
+
+    response = "HTTP/1. 200 OK\r\nContent-Length: 0\r\n\r\n";
+    _testParseInvalidResponse(response);
+
+    response = "HTTP/1.1 200 O\rK\r\nContent-Length: 0\r\n\r\n";
+    _testParseInvalidResponse(response);
+
+    response = "HTTP/1.1 000 OK\r\nContent-Length: 0\r\n\r\n";
+    _testParseInvalidResponse(response);
+
+    response = "HTTP/1.1 999 Server Error\r\nContent-Length: 0\r\n\r\n";
+    _testParseInvalidResponse(response);
+
+    response = "HTTP/1.1 200 OK\r\nContent-Length: x\r\n\r\n";
+    _testParseInvalidResponse(response);
+
+    response = "HTTP/1.1 200 OK\r\nbadheader\r\n\r\n";
+    _testParseInvalidResponse(response);
+
+    response = """
+HTTP/1.1 200 OK\r
+Transfer-Encoding: chunked\r
+\r
+1A\r
+01234567890123456789012345\r
+1g\r
+0123456789012345678901234567890\r
+0\r\n\r\n""";
+    _testParseInvalidResponse(response);
+  }
+}
+
+void main() {
+  HttpParserTest.runAllTests();
+}