Add coverage tool to standalone tests

tools/coverage.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.
 
 // This test forks a second vm process that runs a dart script as
 // a debug target, single stepping through the entire program, and
 // recording each breakpoint. At the end, a coverage map of the source
 // is printed.
 //
 // Usage: dart coverage.dart [--wire] [--verbose] target_script.dart
@@ skipping 159 matching lines @@
     var stdoutStringStream = targetProcess.stdout
         .transform(new StringDecoder())
         .transform(new LineTransformer());
     stdoutStringStream.listen((line) {
       if (showDebuggeeOutput) {
         print("TARG: $line");
       }
       if (line.startsWith("Debugger listening")) {
         RegExp portExpr = new RegExp(r"\d+");
         var port = portExpr.stringMatch(line);
-        print("Debug target found listening at port '$port'");
+        var pid = targetProcess.pid;
+        print("Coverage target process (pid $pid) found "
+              "listening on port $port.");
         openConnection(int.parse(port));
       }
     });
 
     var stderrStringStream = targetProcess.stderr
         .transform(new StringDecoder())
         .transform(new LineTransformer());
     stderrStringStream.listen((line) {
       if (showDebuggeeOutput) {
         print("TARG: $line");
@@ skipping 29 matching lines @@
         assert(libraryId != null);
       }
       if (msg["params"]["reason"] == "breakpoint") {
         Program.recordBp(this, msg);
       }
     } else {
       error("Error: unknown debugger event received");
     }
   }
 
-  // Handle one JSON message object and match it to the
-  // expected events and responses in the debugging script.
+  // Handle one JSON message object.
   void handleMessage(Map<String,dynamic> receivedMsg) {
     currentMessage = receivedMsg;
     if (receivedMsg["event"] != null) {
       handleEvent(receivedMsg);
       if (errorsDetected) {
-        error("Error while handling debugger event");
-        error("Event received from debug target: $receivedMsg");
+        error("Error while handling event message");
+        error("Event received from coverage target: $receivedMsg");
       }
     } else if (receivedMsg["id"] != null) {
       // This is a response to the last command we sent.
       int id = receivedMsg["id"];
       assert(outstandingCommand != null);
       assert(outstandingCommand.msg["id"] == id);
       outstandingCommand.handleResponse(receivedMsg);
       outstandingCommand = null;
     } else {
       error("Unexpected message from target");
     }
   }
 
-  // Handle data received over the wire from the debug target
+  // Handle data received over the wire from the coverage target
   // process. Split input from JSON wire format into individual
   // message objects (maps).
   void handleMessages() {
     var msg = responses.getNextMessage();
     while (msg != null) {
       if (verboseWire) print("RECV: $msg");
       if (responses.haveGarbage()) {
         error("Error: leftover text after message: '${responses.buffer}'");
         error("Previous message may be malformed, was: '$msg'");
         cleanup();
         return;
       }
       var msgObj = JSON.parse(msg);
       handleMessage(msgObj);
       if (errorsDetected) {
-        error("Error while handling message from debug target");
-        error("Message received from debug target: $msg");
+        error("Error while handling message from coverage target");
+        error("Message received from coverage target: $msg");
         cleanup();
         return;
       }
       if (shutdownEventSeen) {
         if (outstandingCommand != null) {
           error("Error: outstanding command when shutdown received");
         }
         cleanup();
         return;
       }
@@ skipping 40 matching lines @@
           (str) {
             try {
               responses.append(str);
               handleMessages();
             } catch(e, trace) {
               print("Unexpected exception:\n$e\n$trace");
               cleanup();
             }
           },
           onDone: () {
-            print("Connection closed by debug target");
+            print("Connection closed by coverage target");
             cleanup();
           },
           onError: (e) {
-            print("Error '$e' detected in input stream from debug target");
+            print("Error '$e' detected in input stream from coverage target");
             cleanup();
           });
       },
       onError: (e) {
-        String msg = "Error while connecting to debugee: $e";
+        String msg = "Error while connecting to coverage target: $e";
         var trace = getAttachedStackTrace(e);
         if (trace != null) msg += "\nStackTrace: $trace";
         error(msg);
         cleanup();
      });
   }
 
   void cleanup() {
     if (cleanupDone) return;
     if (socket != null) {
       socket.close().catchError((error) {
         // Print this directly in addition to adding it to the
         // error message queue, in case the error message queue
         // gets printed before this error handler is called.
         print("Error occurred while closing socket: $error");
         error("Error while closing socket: $error");
       });
     }
     var targetPid = targetProcess.pid;
-    print("Sending kill signal to process $targetPid...");
+    print("Sending kill signal to process $targetPid.");
     targetProcess.kill();
     // If the process was already dead exitCode is already
     // available and we call exit() in the next event loop cycle.
     // Otherwise this will wait for the process to exit.
 
     targetProcess.exitCode.then((exitCode) {
-      print("process $targetPid terminated with exit code $exitCode.");
+      print("Process $targetPid terminated with exit code $exitCode.");
       if (errorsDetected) {
         print("\n===== Errors detected: =====");
         for (int i = 0; i < errors.length; i++) print(errors[i]);
         print("============================\n");
       }
       Program.printCoverage();
       exit(errors.length);
     });
     cleanupDone = true;
   }
 }
 
 
-// Class to buffer wire protocol data from debug target and
+// Class to buffer wire protocol data from coverage target and
 // break it down to individual json messages.
 class JsonBuffer {
   String buffer = null;
 
   append(String s) {
     if (buffer == null || buffer.length == 0) {
       buffer = s;
     } else {
       buffer = buffer.concat(s);
     }
@@ skipping 92 matching lines @@
         targetOpts.add(str);
         break;
     }
   }
 
   Process.start(options.executable, targetOpts).then((Process process) {
     process.stdin.close();
     var debugger = new Debugger(process);
   });
 }