Another attempt at fixing the Socket tests.

runtime/bin/socket_impl.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.
 
 
 class _SocketBase {
   // Bit flags used when communicating between the eventhandler and
   // dart code. The EVENT flags are used to indicate events of
   // interest when sending a message from dart code to the
   // eventhandler. When receiving a message from the eventhandler the
@@ skipping 40 matching lines @@
           if (_closedWrite) _close();
         }
 
         var eventHandler = _handlerMap[i];
         if (eventHandler != null) {
           // Unregister the out handler before executing it.
           if (i == _OUT_EVENT) _setHandler(i, null);
 
           // Don't call the in handler if there is no data available
           // after all.
-          if (i == _IN_EVENT && this is _Socket && available() == 0) {
+          if ((i == _IN_EVENT) && (this is _Socket) && (available() == 0)) {
             continue;
           }
           eventHandler();
         }
       }
     }
     _canActivateHandlers = true;
     _activateHandlers();
   }
 
@@ skipping 53 matching lines @@
       }
     } else if (_handler != null) {
       // This is to support closing sockets created but never assigned
       // any actual socket.
       _handler.close();
       _handler = null;
     }
   }
 
   void _closeWrite() {
-    if (_closedRead) {
-      _close();
-    } else {
-      _sendToEventHandler(1 << _SHUTDOWN_WRITE_COMMAND);
+    if (_id >= 0) {
+      if (_closedRead) {
+        _close();
+      } else {
+        _sendToEventHandler(1 << _SHUTDOWN_WRITE_COMMAND);
+      }
+      _closedWrite = true;
     }
-    _closedWrite = true;
   }
 
   void _closeRead() {
-    if (_closedWrite) {
-      _close();
-    } else {
-      _sendToEventHandler(1 << _SHUTDOWN_READ_COMMAND);
+    if (_id >= 0) {
+      if (_closedWrite) {
+        _close();
+      } else {
+        _sendToEventHandler(1 << _SHUTDOWN_READ_COMMAND);
+      }
+      _closedRead = true;
     }
-    _closedRead = true;
   }
 
   void _close() {
-    _sendToEventHandler(1 << _CLOSE_COMMAND);
-    _handler.close();
-    _handler = null;
-    _id = -1;
+    if (_id >= 0) {
+      _sendToEventHandler(1 << _CLOSE_COMMAND);
+      _handler.close();
+      _handler = null;
+      _id = -1;
+    }
   }
 
   void _sendToEventHandler(int data) {
     if (_handler === null) {
       _handler = new ReceivePort();
       _handler.receive((var message, ignored) { _multiplex(message); });
     }
+    assert(_id >= 0);
     _EventHandler._sendData(_id, _handler, data);
   }
 
   abstract bool _isListenSocket();
   abstract bool _isPipe();
 
   // Socket id is set from native. -1 indicates that the socket was closed.
   int _id;
 
   // Dedicated ReceivePort for socket events.
@@ skipping 201 matching lines @@
   }
 
   void set dataHandler(void callback()) {
     if (_inputStream != null) throw new StreamException(
             "Cannot set data handler when input stream is used");
     _dataHandler = callback;
   }
 
   void set closeHandler(void callback()) {
     if (_inputStream != null) throw new StreamException(
-            "Cannot set data handler when input stream is used");
+            "Cannot set close handler when input stream is used");
     _closeHandler = callback;
   }
 
   bool _isListenSocket() => false;
 
   bool _isPipe() => _pipe;
 
   InputStream get inputStream() {
     if (_inputStream === null) {
       if (_handlerMap[_IN_EVENT] !== null ||
@@ skipping 62 matching lines @@
   bool _seenFirstOutEvent = false;
   bool _closedRead = false;
   bool _closedWrite = false;
   bool _pipe = false;
   Function _clientConnectHandler;
   Function _clientWriteHandler;
   SocketInputStream _inputStream;
   SocketOutputStream _outputStream;
 }