Keep track of when a socket has been destroyed

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";
@@ skipping 139 matching lines @@
     List<int> expected = createTestData();
     for (int i = 0; i < messageSize; i++) {
       Expect.equals(expected[i], data[i]);
     }
   }
 
   RawServerSocket.bind(InternetAddress.LOOPBACK_IP_V4, 0).then((server) {
     server.listen((client) {
       int bytesRead = 0;
       int bytesWritten = 0;
+      bool closedEventReceived = false;
       List<int> data = new List<int>(messageSize);
 
       client.writeEventsEnabled = false;
       client.listen((event) {
         switch (event) {
           case RawSocketEvent.READ:
             Expect.isTrue(bytesWritten == 0);
             Expect.isTrue(client.available() > 0);
             var buffer = client.read();
             data.setRange(bytesRead, bytesRead + buffer.length, buffer);
@@ skipping 10 matching lines @@
             if (bytesWritten < data.length) {
               client.writeEventsEnabled = true;
             }
             if (bytesWritten == data.length) {
               client.shutdown(SocketDirection.SEND);
             }
             break;
           case RawSocketEvent.READ_CLOSED:
             server.close();
             break;
+          case RawSocketEvent.CLOSED:
+            Expect.isFalse(closedEventReceived);
+            closedEventReceived = true;
+            break;
           default: throw "Unexpected event $event";
         }
-      });
+      },
+      onDone: () => Expect.isTrue(closedEventReceived));
     });
 
     RawSocket.connect("127.0.0.1", server.port).then((socket) {
       int bytesRead = 0;
       int bytesWritten = 0;
+      bool closedEventReceived = false;
       List<int> data = createTestData();
 
       socket.listen((event) {
         switch (event) {
           case RawSocketEvent.READ:
             Expect.isTrue(socket.available() > 0);
             var buffer = socket.read();
             data.setRange(bytesRead, bytesRead + buffer.length, buffer);
             bytesRead += buffer.length;
             break;
           case RawSocketEvent.WRITE:
             Expect.isTrue(bytesRead == 0);
             Expect.isFalse(socket.writeEventsEnabled);
             bytesWritten += socket.write(
                 data, bytesWritten, data.length - bytesWritten);
             if (bytesWritten < data.length) {
               socket.writeEventsEnabled = true;
             } else {
               data = new List<int>(messageSize);
             }
             break;
           case RawSocketEvent.READ_CLOSED:
             verifyTestData(data);
             socket.close();
             break;
+          case RawSocketEvent.CLOSED:
+            Expect.isFalse(closedEventReceived);
+            closedEventReceived = true;
+            break;
           default: throw "Unexpected event $event";
         }
       },
-      onDone: () => port.close());
+      onDone: () {
+        Expect.isTrue(closedEventReceived);
+        port.close();
+      });
     });
   });
 }
 
 testPauseServerSocket() {
   const int socketCount = 10;
   var acceptCount = 0;
   var resumed = false;
 
   ReceivePort port = new ReceivePort();
@@ skipping 35 matching lines @@
   int bytesWritten = 0;
   int bytesRead = 0;
   var writeSubscription;
   var readSubscription;
 
   ReceivePort port = new ReceivePort();
 
   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:
             if (pauseResumeCount == loopCount) return;
             Expect.isFalse(client.writeEventsEnabled);
             Expect.equals(0, bytesRead);  // Checks that reader is paused.
             bytesWritten += client.write(
                 data, bytesWritten, data.length - bytesWritten);
             // Ensure all data is written. When done disable the write
             // event and resume the receiver.
             if (bytesWritten == data.length) {
               writeSubscription.pause();
               bytesWritten = 0;
               connected.future.then((_) { readSubscription.resume(); });
             }
             client.writeEventsEnabled = true;
             break;
           case RawSocketEvent.READ_CLOSED:
             client.close();
             server.close();
             break;
+          case RawSocketEvent.CLOSED:
+          Expect.isFalse(closedEventReceived);
+            closedEventReceived = true;
+            break;
           default: throw "Unexpected event $event";
         }
-      });
+      },
+      onDone: () => Expect.isTrue(closedEventReceived));
     });
 
     RawSocket.connect("127.0.0.1", server.port).then((socket) {
+      bool closedEventReceived = false;
       socket.writeEventsEnabled = false;
       readSubscription = socket.listen((event) {
         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();
               } 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 close event";
+            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() {
   testArguments();
   testSimpleBind();
   testCloseOneEnd("client");
   testCloseOneEnd("server");
   testInvalidBind();
   testSimpleConnect();
   testServerListenAfterConnect();
   testSimpleReadWrite();
   testPauseServerSocket();
   testPauseSocket();
 }