Add 'deadline' to HttpResponse, making it possible to give a max duration for the liveness of the r…

tests/standalone/io/http_response_deadline_test.dart

Index: tests/standalone/io/http_response_deadline_test.dart
diff --git a/tests/standalone/io/http_response_deadline_test.dart b/tests/standalone/io/http_response_deadline_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..833269b6f42d8d76d9055302cf48012185169d5f
--- /dev/null
+++ b/tests/standalone/io/http_response_deadline_test.dart
@@ -0,0 +1,95 @@
+// 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.
+//
+// VMOptions=
+// VMOptions=--short_socket_read
+// VMOptions=--short_socket_write
+// VMOptions=--short_socket_read --short_socket_write
+
+import "package:expect/expect.dart";
+import "dart:async";
+import "dart:io";
+
+void testSimpleDeadline(int connections) {
+  HttpServer.bind('localhost', 0).then((server) {
+    server.listen((request) {
+      request.response.deadline = const Duration(seconds: 1);
+      request.response.write("stuff");
+      request.response.close();
+    });
+
+    var futures = [];
+    var client = new HttpClient();
+    for (int i = 0; i < connections; i++) {
+      futures.add(client.get('localhost', server.port, '/')
+          .then((request) => request.close())
+          .then((response) => response.drain()));
+    }
+    Future.wait(futures).then((_) => server.close());
+  });
+}
+
+void testExceedDeadline(int connections) {
+  HttpServer.bind('localhost', 0).then((server) {
+    server.listen((request) {
+      request.response.deadline = const Duration(milliseconds: 100);
+      request.response.contentLength = 10000;
+      request.response.write("stuff");
+    });
+
+    var futures = [];
+    var client = new HttpClient();
+    for (int i = 0; i < connections; i++) {
+      futures.add(client.get('localhost', server.port, '/')
+          .then((request) => request.close())
+          .then((response) {
+            return new Future.delayed(const Duration(milliseconds: 500), () {

[Søren Gjesse, 2013/07/24 12:29:51]

Even though we are in the same VM timing issues could make the two timers fire
"at the same time". But still the dead line timer will fire first, so it should
not be flaky as socket.destroy is sync.

[Anders Johnsen, 2013/07/24 12:46:23]

Reworked the timers a bit.

+              return response.drain().then((_) {
+                Expect.fail("Expected error");
+              }, onError: (e) {
+                // Expect error.
+              });
+            });
+          }));
+    }
+    Future.wait(futures).then((_) => server.close());
+  });
+}
+
+void testDeadlineAndDetach(int connections) {
+  HttpServer.bind('localhost', 0).then((server) {
+    server.listen((request) {
+      request.response.deadline = const Duration(milliseconds: 100);
+      request.response.contentLength = 5;
+      request.response.detachSocket().then((socket) {
+        new Timer(const Duration(milliseconds: 500), () {
+          socket.write('stuff');
+          socket.close();
+        });
+      });
+    });
+
+    var futures = [];
+    var client = new HttpClient();
+    for (int i = 0; i < connections; i++) {
+      futures.add(client.get('localhost', server.port, '/')
+          .then((request) => request.close())
+          .then((response) {
+            return response.fold(new BytesBuilder(), (b, d) => b..add(d))
+                .then((builder) {
+                  Expect.equals('stuff',
+                                new String.fromCharCodes(builder.takeBytes()));
+                });
+          }));
+    }
+    Future.wait(futures).then((_) => server.close());
+  });
+}
+
+void main() {
+  testSimpleDeadline(10);
+  testExceedDeadline(10);
+  testDeadlineAndDetach(10);
+}
+