Update dart:io tests to use asyncStart/asyncEnd

tests/standalone/io/raw_socket_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 "package:expect/expect.dart";
 import "dart:async";
 import "dart:io";
-import "dart:isolate";
+
+import "package:async_helper/async_helper.dart";
+import "package:expect/expect.dart";
 
 void testArguments() {
   Expect.throws(() => RawServerSocket.bind("127.0.0.1", 65536));
   Expect.throws(() => RawServerSocket.bind("127.0.0.1", -1));
   Expect.throws(() => RawServerSocket.bind("127.0.0.1", 0, backlog: -1));
 }
 
 void testSimpleBind() {
-  ReceivePort port = new ReceivePort();
+  asyncStart();
   RawServerSocket.bind(InternetAddress.LOOPBACK_IP_V4, 0).then((s) {
     Expect.isTrue(s.port > 0);
-    port.close();
+    asyncEnd();
   });
 }
 
 void testInvalidBind() {
-  int count = 0;
-  ReceivePort port = new ReceivePort();
-  port.receive((_, __) { count++; if (count == 3) port.close(); });
-
   // Bind to a unknown DNS name.
+  asyncStart();
   RawServerSocket.bind("ko.faar.__hest__", 0)
       .then((_) { Expect.fail("Failure expected"); } )
       .catchError((error) {
         Expect.isTrue(error is SocketException);
-        port.toSendPort().send(1);
+        asyncEnd();
       });
 
   // Bind to an unavaliable IP-address.
+  asyncStart();
   RawServerSocket.bind("8.8.8.8", 0)
       .then((_) { Expect.fail("Failure expected"); } )
       .catchError((error) {
         Expect.isTrue(error is SocketException);
-        port.toSendPort().send(1);
+        asyncEnd();
       });
 
   // Bind to a port already in use.
+  asyncStart();
   RawServerSocket.bind(InternetAddress.LOOPBACK_IP_V4, 0)
       .then((s) {
           RawServerSocket.bind(InternetAddress.LOOPBACK_IP_V4, s.port)
             .then((t) {
               Expect.fail("Multiple listens on same port");
               port.toSendPort().send(1);
             })
             .catchError((error) {
               Expect.isTrue(error is SocketException);
-              port.toSendPort().send(1);
+              asyncEnd();
             });
       });
 }
 
 void testSimpleConnect() {
-  ReceivePort port = new ReceivePort();
+  asyncStart();
   RawServerSocket.bind(InternetAddress.LOOPBACK_IP_V4, 0).then((server) {
     server.listen((_) { });
     RawSocket.connect("127.0.0.1", server.port).then((_) {
       server.close();
-      port.close();
+      asyncEnd();
     });
   });
 }
 
 void testCloseOneEnd(String toClose) {
-  ReceivePort port = new ReceivePort();
+  asyncStart();
   Completer serverDone = new Completer();
   Completer serverEndDone = new Completer();
   Completer clientEndDone = new Completer();
   Future.wait([serverDone.future, serverEndDone.future, clientEndDone.future])
       .then((_) {
-        port.close();
+        asyncEnd();
       });
   RawServerSocket.bind(InternetAddress.LOOPBACK_IP_V4, 0).then((server) {
     server.listen((serverConnection) {
       serverConnection.listen((event) {
         if (toClose == "server" || event == RawSocketEvent.READ_CLOSED) {
           serverConnection.shutdown(SocketDirection.SEND);
         }
       },
       onDone: () {
         serverEndDone.complete(null);
@@ skipping 10 matching lines @@
       },
       onDone: () {
         clientEndDone.complete(null);
         server.close();
       });
     });
   });
 }
 
 void testServerListenAfterConnect() {
-  ReceivePort port = new ReceivePort();
+  asyncStart();
   RawServerSocket.bind(InternetAddress.LOOPBACK_IP_V4, 0).then((server) {
     Expect.isTrue(server.port > 0);
     RawSocket.connect("127.0.0.1", server.port).then((_) {
       server.listen((_) {
         server.close();
-        port.close();
+        asyncEnd();
       });
     });
   });
 }
 
 void testSimpleReadWrite({bool dropReads}) {
   // This test creates a server and a client connects. The client then
   // writes and the server echos. When the server has finished its
   // echo it half-closes. When the client gets the close event is
   // closes fully.
-  ReceivePort port = new ReceivePort();
+  asyncStart();
 
   const messageSize = 1000;
   int serverReadCount = 0;
   int clientReadCount = 0;
 
   List<int> createTestData() {
     return new List<int>.generate(messageSize, (index) => index & 0xff);
   }
 
   void verifyTestData(List<int> data) {
@@ skipping 96 matching lines @@
             break;
           case RawSocketEvent.CLOSED:
             Expect.isFalse(closedEventReceived);
             closedEventReceived = true;
             break;
           default: throw "Unexpected event $event";
         }
       },
       onDone: () {
         Expect.isTrue(closedEventReceived);
-        port.close();
+        asyncEnd();
       });
     });
   });
 }
 
 testPauseServerSocket() {
   const int socketCount = 10;
   var acceptCount = 0;
   var resumed = false;
 
-  ReceivePort port = new ReceivePort();
-
+  asyncStart();
   RawServerSocket.bind(InternetAddress.LOOPBACK_IP_V4, 0).then((server) {
     Expect.isTrue(server.port > 0);
     var subscription = server.listen((_) {
       Expect.isTrue(resumed);
       if (++acceptCount == socketCount) {
         server.close();
-        port.close();
+        asyncEnd();
       }
     });
 
     // Pause the server socket subscription and resume it after having
     // connected a number client sockets. Then connect more client
     // sockets.
     subscription.pause();
     var connectCount = 0;
     for (int i = 0; i < socketCount / 2; i++) {
       RawSocket.connect("127.0.0.1", server.port).then((_) {
@@ skipping 12 matching lines @@
 void testPauseSocket() {
   const messageSize = 1000;
   const loopCount = 10;
   Completer connected = new Completer();
   int pauseResumeCount = 0;
   int bytesWritten = 0;
   int bytesRead = 0;
   var writeSubscription;
   var readSubscription;
 
-  ReceivePort port = new ReceivePort();
-
+  asyncStart();
   RawServerSocket.bind(InternetAddress.LOOPBACK_IP_V4, 0).then((server) {
     Expect.isTrue(server.port > 0);
     server.listen((client) {
       bool closedEventReceived = false;
       List<int> data = new List<int>.filled(messageSize, 0);
       writeSubscription = client.listen((event) {
         switch (event) {
           case RawSocketEvent.READ:
             throw "Unexpected read event";
           case RawSocketEvent.WRITE:
@@ skipping 32 matching lines @@
         switch (event) {
           case RawSocketEvent.READ:
             Expect.equals(0, bytesWritten);  // Checks that writer is paused.
             Expect.isTrue(socket.available() > 0);
             var buffer = socket.read();
             bytesRead += buffer.length;
             // Ensure all data is read. When done pause and resume the sender
             if (bytesRead == messageSize) {
               if (++pauseResumeCount == loopCount) {
                 socket.close();
-                port.close();
+                asyncEnd();
               } else {
                 readSubscription.pause();
               }
               // Always resume writer as it needs the read closed
               // event when done.
               bytesRead = 0;
               writeSubscription.resume();
             }
             break;
           case RawSocketEvent.WRITE:
             throw "Unexpected write event";
           case RawSocketEvent.READ_CLOSED:
             throw "Unexpected read closed event";
           case RawSocketEvent.CLOSED:
           Expect.isFalse(closedEventReceived);
             closedEventReceived = true;
             break;
           default: throw "Unexpected event $event";
         }
       },
       onDone: () => Expect.isTrue(closedEventReceived));
       readSubscription.pause();
       connected.complete(true);
     });
   });
 }
 
 main() {
+  asyncStart();
   testArguments();
   testSimpleBind();
   testCloseOneEnd("client");
   testCloseOneEnd("server");
   testInvalidBind();
   testSimpleConnect();
   testServerListenAfterConnect();
   testSimpleReadWrite(dropReads: false);
   testSimpleReadWrite(dropReads: true);
   testPauseServerSocket();
   testPauseSocket();
+  asyncEnd();
 }