Speed up web_socket_test by running subtests in parallel.

tests/standalone/io/web_socket_test.dart

 // Copyright (c) 2012, 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:io";
 import "dart:isolate";
 import "dart:scalarlist";
 import "dart:uri";
 
 const SERVER_ADDRESS = "127.0.0.1";
 const HOST_NAME = "localhost";
 
 // We will run the tests once over HTTP and once over HTTPS.
 bool secure = false;
 
-Future testRequestResponseClientCloses(
+void testRequestResponseClientCloses(
     int totalConnections, int closeStatus, String closeReason) {
-  Completer done = new Completer();
+  ReceivePort keepAlive = new ReceivePort();

[Anders Johnsen, 2013/01/17 14:17:33]

The ReceivePorts are redundant in some of these tests. I would suggest that we
try to avoid redundant code in tests. Your choice.

   HttpServer server = secure ? new HttpsServer() : new HttpServer();

[Anders Johnsen, 2013/01/17 14:17:33]

Move all of this out to a

createServer();

ditto for createClient, HttpClientConnection/HttpClient.

   HttpClient client = new HttpClient();
 
   server.listen(SERVER_ADDRESS,
                 0,
                 backlog: totalConnections,
                 certificate_name: "CN=$HOST_NAME");
 
   // Create a web socket handler and set it as the HTTP server default handler.
   WebSocketHandler wsHandler = new WebSocketHandler();
   wsHandler.onOpen = (WebSocketConnection conn) {
@@ skipping 27 matching lines @@
     };
     wsconn.onClosed = (status, reason) {
       Expect.equals(closeStatus == null
                     ? WebSocketStatus.NO_STATUS_RECEIVED
                     : closeStatus, status);
       Expect.equals("", reason);
       closeCount++;
       if (closeCount == totalConnections) {
         client.shutdown();
         server.close();
-        done.complete(null);
+        keepAlive.close();
       }
     };
   }
-  return done.future;
 }
 
 
-Future testRequestResponseServerCloses(
+void testRequestResponseServerCloses(
     int totalConnections, int closeStatus, String closeReason) {
-  Completer done = new Completer();
+  ReceivePort keepAlive = new ReceivePort();
   HttpServer server = secure ? new HttpsServer() : new HttpServer();
   HttpClient client = new HttpClient();
 
   server.listen(SERVER_ADDRESS,
                 0,
                 backlog: totalConnections,
                 certificate_name: "CN=$HOST_NAME");
 
   // Create a web socket handler and set is as the HTTP server default
   // handler.
@@ skipping 13 matching lines @@
     };
     conn.onClosed = (status, reason) {
       Expect.equals(closeStatus == null
                     ? WebSocketStatus.NO_STATUS_RECEIVED
                     : closeStatus, status);
       Expect.equals("", reason);
       closeCount++;
       if (closeCount == totalConnections) {
         client.shutdown();
         server.close();
-        done.complete(null);
+        keepAlive.close();
       }
     };
     conn.send(messageText);
   };
   server.defaultRequestHandler = wsHandler.onRequest;
 
   for (int i = 0; i < totalConnections; i++) {
     HttpClientConnection conn = client.getUrl(new Uri.fromString(
         '${secure ? "https" : "http"}://$HOST_NAME:${server.port}/'));
     WebSocketClientConnection wsconn = new WebSocketClientConnection(conn);
     wsconn.onMessage = (message) => wsconn.send(message);
     wsconn.onClosed = (status, reason) {
       Expect.equals(closeStatus == null
                     ? WebSocketStatus.NO_STATUS_RECEIVED
                     : closeStatus, status);
       Expect.equals(closeReason == null ? "" : closeReason, reason);
     };
   }
-  return done.future;
 }
 
 
-Future testMessageLength(int messageLength) {
-  Completer done = new Completer();
+void testMessageLength(int messageLength) {
+  ReceivePort keepAlive = new ReceivePort();
   HttpServer server = secure ? new HttpsServer() : new HttpServer();
   HttpClient client = new HttpClient();
   bool serverReceivedMessage = false;
   bool clientReceivedMessage = false;
 
   server.listen(SERVER_ADDRESS,
                 0,
                 backlog: 1,
                 certificate_name: "CN=$HOST_NAME");
 
@@ skipping 18 matching lines @@
   wsconn.onMessage = (message) {
     clientReceivedMessage = true;
     Expect.listEquals(originalMessage, message);
     wsconn.close();
   };
   wsconn.onClosed = (status, reason) {
     Expect.isTrue(serverReceivedMessage);
     Expect.isTrue(clientReceivedMessage);
     client.shutdown();
     server.close();
-    done.complete(null);
+    keepAlive.close();
   };
   wsconn.onOpen = () {
     wsconn.send(originalMessage);
   };
-  return done.future;
 }
 
 
-Future testNoUpgrade() {
-  Completer done = new Completer();
+void testNoUpgrade() {
+  ReceivePort keepAlive = new ReceivePort();
   HttpServer server = secure ? new HttpsServer() : new HttpServer();
   HttpClient client = new HttpClient();
 
   server.listen(SERVER_ADDRESS,
                 0,
                 backlog: 5,
                 certificate_name: "CN=$HOST_NAME");
 
   // Create a server which always responds with a redirect.
   server.defaultRequestHandler = (request, response) {
     response.statusCode = HttpStatus.MOVED_PERMANENTLY;
     response.outputStream.close();
   };
 
   HttpClientConnection conn = client.getUrl(new Uri.fromString(
       '${secure ? "https" : "http"}://$HOST_NAME:${server.port}/'));
   conn.followRedirects = false;
   WebSocketClientConnection wsconn = new WebSocketClientConnection(conn);
   wsconn.onNoUpgrade = (response) {
     Expect.equals(HttpStatus.MOVED_PERMANENTLY, response.statusCode);
     client.shutdown();
     server.close();
-    done.complete(null);
+    keepAlive.close();
   };
-  return done.future;
 }
 
 
-Future testUsePOST() {
-  Completer done = new Completer();
+void testUsePOST() {
+  ReceivePort keepAlive = new ReceivePort();
   HttpServer server = secure ? new HttpsServer() : new HttpServer();
   HttpClient client = new HttpClient();
 
   server.listen(SERVER_ADDRESS,
                 0,
                 backlog: 5,
                 certificate_name: "CN=$HOST_NAME");
 
   // Create a web socket handler and set is as the HTTP server default
   // handler.
   int closeCount = 0;
   WebSocketHandler wsHandler = new WebSocketHandler();
   wsHandler.onOpen = (WebSocketConnection conn) {
     Expect.fail("No connection expected");
   };
   server.defaultRequestHandler = wsHandler.onRequest;
 
   HttpClientConnection conn = client.postUrl(new Uri.fromString(
       '${secure ? "https" : "http"}://$HOST_NAME:${server.port}/'));
   WebSocketClientConnection wsconn = new WebSocketClientConnection(conn);
   wsconn.onNoUpgrade = (response) {
     Expect.equals(HttpStatus.BAD_REQUEST, response.statusCode);
     client.shutdown();
     server.close();
-    done.complete(null);
+    keepAlive.close();
   };
-  return done.future;
 }
 
 
 class WebSocketInfo {
   int messageCount = 0;
 }
 
 
-Future testHashCode(int totalConnections) {
-  Completer done = new Completer();
+void testHashCode(int totalConnections) {
+  ReceivePort keepAlive = new ReceivePort();
   HttpServer server = secure ? new HttpsServer() : new HttpServer();
   HttpClient client = new HttpClient();
   Map connections = new Map();
 
   server.listen(SERVER_ADDRESS,
                 0,
                 backlog: totalConnections,
                 certificate_name: "CN=$HOST_NAME");
 
   void handleMessage(conn, message) {
@@ skipping 17 matching lines @@
     conn.onMessage = (Object message) {
       handleMessage(conn, message);
     };
     conn.onClosed = (status, reason) {
       closeCount++;
       var info = connections[conn];
       Expect.equals(10, info.messageCount);
       if (closeCount == totalConnections) {
         client.shutdown();
         server.close();
-        done.complete();
+        keepAlive.close();
       }
     };
     conn.send(messageText);
   };
   server.defaultRequestHandler = wsHandler.onRequest;
 
   for (int i = 0; i < totalConnections; i++) {
     HttpClientConnection conn = client.getUrl(new Uri.fromString(
         '${secure ? "https" : "http"}://$HOST_NAME:${server.port}/'));
     WebSocketClientConnection wsconn = new WebSocketClientConnection(conn);
     wsconn.onMessage = (message) => wsconn.send(message);
   }
-  return done.future;
 }
 
 
-Future testW3CInterface(
+void testW3CInterface(
     int totalConnections, int closeStatus, String closeReason) {
+  ReceivePort keepAlive = new ReceivePort();
   List<Future> tasks = [];
   HttpServer server = secure ? new HttpsServer() : new HttpServer();
 
   server.listen(SERVER_ADDRESS,
                 0,
                 backlog: totalConnections,
                 certificate_name: "CN=$HOST_NAME");
 
   // Create a web socket handler and set is as the HTTP server default
   // handler.
@@ skipping 59 matching lines @@
       Expect.equals(3002, event.code);
       Expect.equals("Got tired", event.reason);
       Expect.equals(WebSocket.CLOSED, websocket.readyState);
       clientDone.complete(null);
     };
   }
 
   for (int i = 0; i < totalConnections; i++) {
     webSocketConnection();
   }
-  return Future.wait(tasks);
+  Future.wait(tasks).then((_) {
+    keepAlive.close();
+  });
 }
 
 
 void InitializeSSL() {
   var testPkcertDatabase =
       new Path(new Options().script).directoryPath.append("pkcert/");
   SecureSocket.initialize(database: testPkcertDatabase.toNativePath(),
                           password: "dartdart");
 }
 
 
-Future runTests() =>
-  testRequestResponseClientCloses(2, null, null).then((_) =>
-  testRequestResponseClientCloses(2, 3001, null)).then((_) =>
-  testRequestResponseClientCloses(2, 3002, "Got tired")).then((_) =>
-  testRequestResponseServerCloses(2, null, null)).then((_) =>
-  testRequestResponseServerCloses(2, 3001, null)).then((_) =>
-  testRequestResponseServerCloses(2, 3002, "Got tired")).then((_) =>
-  testMessageLength(125)).then((_) =>
-  testMessageLength(126)).then((_) =>
-  testMessageLength(127)).then((_) =>
-  testMessageLength(65535)).then((_) =>
-  testMessageLength(65536)).then((_) =>
-  testNoUpgrade()).then((_) =>
-  testUsePOST()).then((_) =>
-  testHashCode(2)).then((_) =>
-  testW3CInterface(2, 3002, "Got tired"));
+/**
+ * Run all the tests in parallel, complete when the last one finishes.
+ */
+runTests() {
+  testRequestResponseClientCloses(2, null, null);
+  testRequestResponseClientCloses(2, 3001, null);
+  testRequestResponseClientCloses(2, 3002, "Got tired");
+  testRequestResponseServerCloses(2, null, null);
+  testRequestResponseServerCloses(2, 3001, null);
+  testRequestResponseServerCloses(2, 3002, "Got tired");
+  testMessageLength(125);
+  testMessageLength(126);
+  testMessageLength(127);
+  testMessageLength(65535);
+  testMessageLength(65536);
+  testNoUpgrade();
+  testUsePOST();
+  testHashCode(2);
+  testW3CInterface(2, 3002, "Got tired");
+}
 
 
 main() {
-  ReceivePort keepAlive = new ReceivePort();
-  runTests().then((_) {
-    InitializeSSL();
-    secure = true;
-  }).then((_) =>
-    runTests()).then((_) {
-    keepAlive.close();
-  });
+  runTests();
+  InitializeSSL();

[Anders Johnsen, 2013/01/17 14:17:33]

initializeSSL

+  secure = true;
+  runTests();

[Anders Johnsen, 2013/01/17 14:17:33]

Put in secure == null below, so we can check that connections are created when
we expect them.

 }