Make sure to drain stderr in tests so that spawned process doesn't hang.

utils/pub/log.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.
 
 /// Message logging.
 library log;
 
 import 'dart:io';
 import 'io.dart';
 
-typedef LogFn(Level level, message);
+typedef LogFn(Entry entry);
 final Map<Level, LogFn> _loggers = new Map<Level, LogFn>();
 
 /// The list of recorded log messages. Will only be recorded if
 /// [recordTranscript()] is called.
 List<Entry> _transcript;
 
 /// An enum type for defining the different logging levels. By default, [ERROR]
 /// and [WARNING] messages are printed to sterr. [MESSAGE] messages are printed
 /// to stdout, and others are ignored.
 class Level {
@@ skipping 20 matching lines @@
   const Level._(this.name);
   final String name;
 
   String toString() => name;
   int get hashCode => name.hashCode;
 }
 
 /// A single log entry.
 class Entry {
   final Level level;
-  final String message;
+  final List<String> lines;
 
-  Entry(this.level, this.message);
+  Entry(this.level, this.lines);
 }
 
 /// Logs [message] at [Level.ERROR].
 void error(message) => write(Level.ERROR, message);
 
 /// Logs [message] at [Level.WARNING].
 void warning(message) => write(Level.WARNING, message);
 
 /// Logs [message] at [Level.MESSAGE].
 void message(message) => write(Level.MESSAGE, message);
 
 /// Logs [message] at [Level.IO].
 void io(message) => write(Level.IO, message);
 
 /// Logs [message] at [Level.FINE].
 void fine(message) => write(Level.FINE, message);
 
 /// Logs [message] at [level].
 void write(Level level, message) {
   if (_loggers.isEmpty) showNormal();
 
+  var lines = message.toString().split(NEWLINE_PATTERN);
+  var entry = new Entry(level, lines);
+
   var logFn = _loggers[level];
-  if (logFn != null) logFn(level, message);
+  if (logFn != null) logFn(entry);
 
-  if (_transcript != null) {
-    _transcript.add(new Entry(level, '$message'));
-  }
+  if (_transcript != null) _transcript.add(entry);
 }
 
 /// Logs an asynchronous IO operation. Logs [startMessage] before the operation
 /// starts, then when [operation] completes, invokes [endMessage] with the
 /// completion value and logs the result of that. Returns a future that
 /// completes after the logging is done.
 ///
 /// If [endMessage] is omitted, then logs "Begin [startMessage]" before the
 /// operation and "End [startMessage]" after it.
 Future ioAsync(String startMessage, Future operation,
@@ skipping 55 matching lines @@
   _transcript = <Entry>[];
 }
 
 /// If [recordTranscript()] was called, then prints the previously recorded log
 /// transcript to stderr.
 void dumpTranscript() {
   if (_transcript == null) return;
 
   stderr.writeString('---- Log transcript ----\n');
   for (var entry in _transcript) {
-    _logToStderrWithLabel(entry.level, entry.message);
+    _logToStderrWithLabel(entry);
   }
   stderr.writeString('---- End log transcript ----\n');
 }
 
 /// Sets the verbosity to "normal", which shows errors, warnings, and messages.
 void showNormal() {
   _loggers[Level.ERROR]   = _logToStderr;
   _loggers[Level.WARNING] = _logToStderr;
   _loggers[Level.MESSAGE] = _logToStdout;
   _loggers[Level.IO]      = null;
@@ skipping 13 matching lines @@
 /// Sets the verbosity to "all", which logs ALL the things.
 void showAll() {
   _loggers[Level.ERROR]   = _logToStderrWithLabel;
   _loggers[Level.WARNING] = _logToStderrWithLabel;
   _loggers[Level.MESSAGE] = _logToStdoutWithLabel;
   _loggers[Level.IO]      = _logToStderrWithLabel;
   _loggers[Level.FINE]    = _logToStderrWithLabel;
 }
 
 /// Log function that prints the message to stdout.
-void _logToStdout(Level level, message) {
-  print('$message');
+void _logToStdout(Entry entry) {
+  _logToStream(stdout, entry, showLabel: false);
 }
 
 /// Log function that prints the message to stdout with the level name.
-void _logToStdoutWithLabel(Level level, message) {
-  print(_splitAndPrefix(level, message));
+void _logToStdoutWithLabel(Entry entry) {
+  _logToStream(stdout, entry, showLabel: true);
 }
 
 /// Log function that prints the message to stderr.
-void _logToStderr(Level level, message) {
-  stderr.writeString('$message\n');
+void _logToStderr(Entry entry) {
+  _logToStream(stderr, entry, showLabel: false);
 }
 
 /// Log function that prints the message to stderr with the level name.
-void _logToStderrWithLabel(Level level, message) {
-  stderr.writeString(_splitAndPrefix(level, message));
-  stderr.writeString('\n');
+void _logToStderrWithLabel(Entry entry) {
+  _logToStream(stderr, entry, showLabel: true);
 }
 
-/// Add the level prefix to the first line of [message] and prefix subsequent
-/// lines with "|".
-String _splitAndPrefix(Level level, message) {
-  // TODO(rnystrom): We're doing lots of splitting and joining in here. If that
-  // becomes a performance problem, we can optimize this to write directly to
-  // stdout/stderr a line at a time.
-  return "$level: ${Strings.join(message.toString().split('\n'), '\n    | ')}";
+void _logToStream(OutputStream stream, Entry entry, {bool showLabel}) {
+  bool firstLine = true;
+  for (var line in entry.lines) {
+    if (showLabel) {
+      if (firstLine) {
+        stream.writeString(entry.level.name);
+        stream.writeString(': ');
+      } else {
+        stream.writeString('    | ');
+      }
+    }
+
+    stream.writeString(line);
+    stream.writeString('\n');
+
+    firstLine = false;
+  }
 }