dart:io | "Improve" raw_server_socket_cancel_test to not leave client sockets hanging.

tests/standalone/io/raw_server_socket_cancel_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:async";
 import "dart:io";
 import "dart:isolate";
 
-void testCancelResubscribeServerSocket() {
-  const int socketCount = 10;
+void testCancelResubscribeServerSocket(int socketCount, int backlog) {
   var acceptCount = 0;
   var doneCount = 0;
   var closeCount = 0;
   var errorCount = 0;
 
   ReceivePort port = new ReceivePort();
 
-  RawServerSocket.bind().then((server) {
+  RawServerSocket.bind("127.0.0.1", 0, backlog).then((server) {
     Expect.isTrue(server.port > 0);
 
     void checkDone() {
       if (doneCount == socketCount &&
           closeCount + errorCount == socketCount) {
         port.close();
       }
     }
 
-    // Subscribe the server socket. Then cancel subscription and
-    // subscribe again.
     var subscription;
     subscription = server.listen((client) {
+      client.writeEventsEnabled = false;
+      client.listen((event) {
+        switch(event) {
+          case RawSocketEvent.READ:
+            client.read();
+            break;
+          case RawSocketEvent.READ_CLOSED:
+            client.shutdown(SocketDirection.SEND);
+            break;
+          case RawSocketEvent.WRITE:
+            Expect.fail("No write event expected");
+            break;
+        }
+      });
+
       if (++acceptCount == socketCount / 2) {
+        // Cancel subscription and then attempt to resubscribe.
         subscription.cancel();
         Timer.run(() {
           subscription = server.listen((_) {
-            // Close on cancel, so no more events.
+            // Server socket is closed on cancel, so no more events.
             Expect.fail("Event after closed through cancel");
           });
         });
       }
-      // Close the client socket.
-      client.close();
     });
 
     // Connect a number of sockets.
     for (int i = 0; i < socketCount; i++) {
       RawSocket.connect("127.0.0.1", server.port).then((socket) {
-        socket.writeEventsEnabled = false;
         var subscription;
         subscription = socket.listen((event) {
-          Expect.equals(RawSocketEvent.READ_CLOSED, event);
-          socket.close();
-          closeCount++;
+          switch(event) {
+            case RawSocketEvent.READ:
+              Expect.fail("No read event expected");
+              break;
+            case RawSocketEvent.READ_CLOSED:
+              closeCount++;
+              checkDone();
+              break;
+            case RawSocketEvent.WRITE:
+              socket.write([1,2,3]);

[Bill Hesse, 2013/03/05 11:52:44]

We don't care if this write succeeds.  I'll put in a comment saying that. 
Otherwise, it looks like an error that we don't use the return value.

+              socket.shutdown(SocketDirection.SEND);
+              break;
+          }
+        },
+        onDone: () {
+          doneCount++;
           checkDone();
         },
-        onDone: () { doneCount++; checkDone(); },
-        onError: (e) { errorCount++; checkDone(); });
+        onError: (e) {
+          // "Connection reset by peer" errors are handled here.
+          errorCount++;
+          checkDone();
+        });
       }).catchError((e) {
-        errorCount++; checkDone();
+        // "Connection actively refused by host" errors are handled here.
+        errorCount++;
+        checkDone();
       });
     }
   });
 }
 
 void main() {
-  testCancelResubscribeServerSocket();
+  testCancelResubscribeServerSocket(10, 20);
+  testCancelResubscribeServerSocket(20, 5);
 }