IO resource tracking. Add test that we correctly remove closed sockets

runtime/observatory/tests/service/tcp_socket_closing_service_test.dart

Index: runtime/observatory/tests/service/tcp_socket_closing_service_test.dart
diff --git a/runtime/observatory/tests/service/tcp_socket_closing_service_test.dart b/runtime/observatory/tests/service/tcp_socket_closing_service_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..aef55714c7445c9448a4660e0eaf94118160b351
--- /dev/null
+++ b/runtime/observatory/tests/service/tcp_socket_closing_service_test.dart
@@ -0,0 +1,74 @@
+// Copyright (c) 2015, 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.
+
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io' as io;
+import 'package:observatory/service_io.dart';
+import 'package:unittest/unittest.dart';
+import 'test_helper.dart';
+
+
+/// Test that we correctly remove sockets that have been closed from the list
+/// of open sockets. We explictly leave one socket open.
+
+Future setup() async {
+  var serverSocket = await io.ServerSocket.bind('127.0.0.1', 0);
+  serverSocket.listen((s) {
+    s.drain();
+    s.close();
+  });
+  var socket = await io.Socket.connect("127.0.0.1", serverSocket.port);
+  socket.write("foobar");
+  socket.write("foobar");
+
+  await socket.flush();
+  await socket.close();
+  await socket.drain();
+
+  var socket2 = await io.Socket.connect("127.0.0.1", serverSocket.port);
+  socket2.write("foobarfoobar");
+  await socket2.flush();
+  await socket2.close();
+  await socket2.drain();
+  await serverSocket.close();
+
+  var server = await io.RawDatagramSocket.bind('127.0.0.1', 0);
+  server.listen((io.RawSocketEvent event) {
+    if(event == io.RawSocketEvent.READ) {
+      io.Datagram dg = server.receive();
+      dg.data.forEach((x) => true);
+      server.close();
+    }
+  });
+  var client = await io.RawDatagramSocket.bind('127.0.0.1', 0);
+  client.send(UTF8.encoder.convert('foobar'),
+              new io.InternetAddress('127.0.0.1'), server.port);
+  client.close();
+
+  // The one socket to expect.
+  await io.ServerSocket.bind('127.0.0.1', 0);
+}
+
+var tests = [
+  // Initial.
+  (Isolate isolate) async {
+    var result = await isolate.invokeRpcNoUpgrade('__getOpenSockets', {});
+    expect(result['type'], equals('_opensockets'));
+    // We expect only one socket to be open, the server socket create at the
+    // end of test.
+    expect(result['data'].length, equals(1));
+    var server = await isolate.invokeRpcNoUpgrade(
+        '__getSocketByID', { 'id' : result['data'][0]['id'] });
+    expect(server['listening'], isTrue);
+    expect(server['last_read'], equals(0));
+    expect(server['total_read'], equals(0));
+    expect(server['last_write'], equals(0));
+    expect(server['total_written'], equals(0));
+    expect(server['write_count'], equals(0));
+    expect(server['read_count'], equals(0));
+  },
+];
+
+main(args) async => runIsolateTests(args, tests, testeeBefore:setup);