Very simple version of Isolates.

samples/chat/test/chat_server_test.dart

 // 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 'dart:io';
 import 'dart:isolate';
 import 'dart:convert';
 import 'package:expect/expect.dart';
 import '../chat_server_lib.dart';
 
 // Message to start chat test client running in an isolate.
 class ChatTestClientStart {
   ChatTestClientStart(int this.totalClients,
                       int this.messagesToSend,
                       int this.messagesToReceive,
                       int this.port);
 
   int totalClients;
   int messagesToSend;
   int messagesToReceive;
   int port;
 }
 
+Future<SendPort> spawnChatTestClient() {
+  var response = new ReceivePort();
+  return Isolate.spawn(startChatTestClient, response.sendPort)
+      .then((remoteIsolate) => response.first)
+      .whenComplete(() { response.close(); });  // Make sure the port is closed.
+}
 
-void startChatTestClient() {
+void startChatTestClient(SendPort replyTo) {
   var client = new ChatTestClient();
-  port.receive(client.dispatch);
+  replyTo.send(client.dispatchSendPort);
 }
 
 
 // Chat server test client for running in a separate isolate. When
 // this test client is started it will join the chat topic, send a
 // number of messages, receive the expected number of messages and
 // leave the topic.
 class ChatTestClient {
+  ReceivePort _dispatchReceivePort;  // Port that is linked to dispatch.
   SendPort statusPort;  // Port to reply to when test has finished.
   HttpClient httpClient;  // HTTP client connection factory.
 
   int totalClients;  // Total number of clients in the test.
   int messagesToSend;  // Number of messages to send.
   int messagesToReceive;  // Numbe rof messages expected to be received.
   int port;  // TCP/IP port for server.
 
   String sessionId;  // Session id when connected.
   int sendMessageNumber;  // Number of messages sent.
   int joinCount;
   int messageCount;
   int receiveMessageNumber;  // Number of messages received.
 
+  ChatTestClient() : _dispatchReceivePort = new ReceivePort() {
+    _dispatchReceivePort.listen(dispatch);
+  }
+
+  SendPort get dispatchSendPort => _dispatchReceivePort.sendPort;
+
+  void close() {
+    _dispatchReceivePort.close();
+  }
+
   void leave() {
     void leaveResponseHandler(response, String data) {
       Expect.equals(HttpStatus.OK, response.statusCode);
       var responseData = JSON.decode(data);
       Expect.equals("leave", responseData["response"]);
 
       // Test done.
-      statusPort.send("Test succeeded", null);
+      statusPort.send("Test succeeded");
+      close();
     }
 
     Map leaveRequest = new Map();
     leaveRequest["request"] = "leave";
     leaveRequest["sessionId"] = sessionId;
     httpClient.post("127.0.0.1", port, "/leave")
       .then((HttpClientRequest request) {
         request.write(JSON.encode(leaveRequest));
         return request.close();
       })
@@ skipping 115 matching lines @@
         return request.close();
       })
       .then((HttpClientResponse response) {
         StringBuffer body = new StringBuffer();
         response.listen(
           (data) => body.write(new String.fromCharCodes(data)),
           onDone: () => joinResponseHandler(response, body.toString()));
       });
   }
 
-  void dispatch(message, replyTo) {
-    totalClients = message.totalClients;
-    messagesToSend = message.messagesToSend;
-    messagesToReceive = message.messagesToReceive;
-    port = message.port;
+  void dispatch(message) {
+    var chatMessage = message[0];
+    var replyTo = message[1];
+    totalClients = chatMessage.totalClients;
+    messagesToSend = chatMessage.messagesToSend;
+    messagesToReceive = chatMessage.messagesToReceive;
+    port = chatMessage.port;
     statusPort = replyTo;
 
     // Create a HTTP client factory.
     httpClient = new HttpClient();
 
     // Start the client by joining the chat topic.
     join();
   }
 }
 
 
 class TestMain {
   TestMain.run(int this.clientCount, int this.messageCount)
       : serverStatusPort = new ReceivePort(),
         serverPort = null,
         finishedClients = 0 {
-    serverPort = spawnFunction(startChatServer);
-    start();
+    spawnChatServer().then((serverPort) {
+      this.serverPort = serverPort;
+      start();
+    });
   }
 
   void start() {
     // Handle status messages from the server.
-    serverStatusPort.receive(
-        (var message, SendPort replyTo) {
+    serverStatusPort.listen((var message) {
           if (message.isStarted) {
             // When the server is started start all test clients.
             for (int i = 0; i < clientCount; i++) {
               ChatTestClientStart command =
                   new ChatTestClientStart(clientCount,
                                           messageCount,
                                           messageCount * this.clientCount,
                                           message.port);
-              clientPorts[i].send(command, clientStatusPorts[i].toSendPort());
+              clientPorts[i].send([command, clientStatusPorts[i].sendPort]);
             }
           } else if (message.isError) {
             print("Could not start server - probably error \"Address already in use\" from bind.");
             serverStatusPort.close();
           }
         });
 
     // Prepare the requested number of clients.
     clientPorts = new List<SendPort>(clientCount);
     int liveClientsCount = 0;
     clientStatusPorts = new List<ReceivePort>(clientCount);
     for (int i = 0; i < clientCount; i++) {
       ReceivePort statusPort = new ReceivePort();
-      statusPort.receive((var message, SendPort replyTo) {
+      statusPort.listen((var message) {
         // First and only message from the client indicates that
         // the test is done.
         Expect.equals("Test succeeded", message);
         statusPort.close();
         finishedClients++;
 
         // If all clients are finished shutdown the server.
         if (finishedClients == clientCount) {
           // Send server stop message to the server.
-          serverPort.send(new ChatServerCommand.stop(),
-                          serverStatusPort.toSendPort());
+          serverPort.send([new ChatServerCommand.stop(),
+                           serverStatusPort.sendPort]);
 
           // Close the last port to terminate the test.
           serverStatusPort.close();
         }
       });
 
       clientStatusPorts[i] = statusPort;
-      clientPorts[i] = spawnFunction(startChatTestClient);
-      liveClientsCount++;
-      if (liveClientsCount == clientCount) {
-        // Once all clients are running send server start message to
-        // the server. Use port 0 for an ephemeral port. The actual
-        // port will be returned with the server started
-        // message. Use a backlog equal to the client count to avoid
-        // connection issues.
-        serverPort.send(new ChatServerCommand.start("127.0.0.1", 0),
-                        serverStatusPort.toSendPort());
-      }
+      spawnChatTestClient().then((clientPort) {
+        clientPorts[i] = clientPort;
+        liveClientsCount++;
+        if (liveClientsCount == clientCount) {
+          // Once all clients are running send server start message to
+          // the server. Use port 0 for an ephemeral port. The actual
+          // port will be returned with the server started
+          // message. Use a backlog equal to the client count to avoid
+          // connection issues.
+          serverPort.send([new ChatServerCommand.start("127.0.0.1", 0),
+                           serverStatusPort.sendPort]);
+        }
+      });
     }
   }
 
   int clientCount;  // Number of clients to run.
   int messageCount;  // Number of messages per clients to send.
   int finishedClients;  // Number of clients finished.
 
   // Ports for communicating with the server.
   SendPort serverPort;
   ReceivePort serverStatusPort;
@@ skipping 22 matching lines @@
   TestMain testMain = new TestMain.run(10, 2);
 }
 
 
 void main() {
   testOneClient();
   testTwoClients();
   testTwoClientsMoreMessages();
   testTenClients();
 }