Log verbose output when testing pub.

pkg/scheduled_test/lib/scheduled_process.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.
 
 library scheduled_test.scheduled_process;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'scheduled_test.dart';
@@ skipping 77 matching lines @@
 
     _updateDescription(executable, arguments);
 
     _scheduleStartProcess(executable, arguments, options);
 
     _scheduleExceptionCleanup();
 
     var stdoutWithCanceller = _lineStreamWithCanceller(
         _process.then((p) => p.stdout));
     _stdoutCanceller = stdoutWithCanceller.last;
-    var stdoutTee = tee(stdoutWithCanceller.first);
-    _stdout = stdoutTee.first;
-    _stdoutLog = stdoutTee.last;
+    _stdoutLog = stdoutWithCanceller.first;
 
     var stderrWithCanceller = _lineStreamWithCanceller(
         _process.then((p) => p.stderr));
     _stderrCanceller = stderrWithCanceller.last;
-    var stderrTee = tee(stderrWithCanceller.first);
-    _stderr = stderrTee.first;
-    _stderrLog = stderrTee.last;
+    _stderrLog = stderrWithCanceller.first;
+
+    _stdout = stdoutStream();
+    _stderr = stderrStream();
   }
 
   /// Updates [_description] to reflect [executable] and [arguments], which are
   /// the same values as in [start].
   void _updateDescription(executable, arguments) {
     if (_explicitDescription) return;
     if (executable is Future) {
       _description = "future process";
     } else if (arguments is Future || arguments.any((e) => e is Future)) {
       _description = executable;
@@ skipping 61 matching lines @@
             "with exit code $exitCode.";
         }
       }), "waiting to reach shouldExit() or kill() for process "
           "'$description'");
     });
   }
 
   /// Converts a stream of bytes to a stream of lines and returns that along
   /// with a [StreamCanceller] controlling it.
   Pair<Stream<String>, StreamCanceller> _lineStreamWithCanceller(
-      Future<Stream<int>> streamFuture) {
+      Future<Stream<List<int>>> streamFuture) {
     return streamWithCanceller(futureStream(streamFuture)
         .handleError((e) => currentSchedule.signalError(e))
         .transform(new StringDecoder(_encoding))
         .transform(new LineTransformer()));
   }
 
   /// Schedule an exception handler that will clean up the process and provide
   /// debug information if an error occurs.
   void _scheduleExceptionCleanup() {
     currentSchedule.onException.schedule(() {
@@ skipping 59 matching lines @@
   Future<String> remainingStderr() {
     if (!_endScheduled) {
       throw new StateError("remainingStderr() should only be called after "
           "kill() or shouldExit().");
     }
 
     return schedule(() => _stderr.toList().then((lines) => lines.join("\n")),
         "reading the remaining stderr from process '$description'");
   }
 
+  /// Returns a stream that will emit anything the process emits via the
+  /// process's standard output from now on.
+  ///
+  /// This stream will be independent from any other methods that deal with
+  /// standard output, including other calls to [stdoutStream].
+  ///
+  /// This can be overridden by subclasses to return a derived standard output
+  /// stream. This stream will then be used for [nextLine], [nextErrLine],
+  /// [remainingStdout], and [remainingStderr].
+  Stream<String> stdoutStream() {
+    var pair = tee(_stdoutLog);
+    _stdoutLog = pair.first;
+    return pair.last;
+  }
+
+  /// Returns a stream that will emit anything the process emits via the
+  /// process's standard error from now on.
+  ///
+  /// This stream will be independent from any other methods that deal with
+  /// standard error, including other calls to [stderrStream].
+  Stream<String> stderrStream() {
+    var pair = tee(_stderrLog);
+    _stderrLog = pair.first;
+    return pair.last;
+  }
+
   /// Writes [line] to the process as stdin.
   void writeLine(String line) {
     schedule(() {
       return _process.then((p) => p.stdin.writeln('$line'));
     }, "writing '$line' to stdin for process '$description'");
   }
 
   /// Closes the process's stdin stream.
   void closeStdin() {
     schedule(() => _process.then((p) => p.stdin.close()),
@@ skipping 26 matching lines @@
     schedule(() {
       _endExpected = true;
       return _exitCode.then((exitCode) {
         if (expectedExitCode != null) {
           expect(exitCode, equals(expectedExitCode));
         }
       });
     }, "waiting for process '$description' to exit");
   }
 }