Miscellaneous small improvements for scheduled_test.

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_process;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'scheduled_test.dart';
 import 'src/utils.dart';
 import 'src/value_future.dart';
 
 /// A class representing a [Process] that is scheduled to run in the course of
 /// the test. This class allows actions on the process to be scheduled
 /// synchronously. All operations on this class are scheduled.
 ///
 /// Before running the test, either [shouldExit] or [kill] must be called on
 /// this to ensure that the process terminates when expected.
 ///
 /// If the test fails, this will automatically print out any stdout and stderr
 /// from the process to aid debugging.
 class ScheduledProcess {
-  // A description of the process. Used for error reporting.
+  /// A description of the process. Used for error reporting.
   String get description => _description;
   String _description;
 
+  /// Whether a description was passed explicitly by the user.
+  bool _explicitDescription;
+
   /// The encoding used for the process's input and output streams.
   final Encoding _encoding;
 
   /// The process that's scheduled to run.
   ValueFuture<Process> _process;
 
   /// A fork of [_stdout] that records the standard output of the process. Used
   /// for debugging information.
   Stream<String> _stdoutLog;
 
@@ skipping 33 matching lines @@
   /// description of this process; it defaults to the command-line invocation.
   /// [encoding] is the [Encoding] that will be used for the process's input and
   /// output.
   ///
   /// [executable], [arguments], and [options] may be either a [Future] or a
   /// concrete value. If any are [Future]s, the process won't start until the
   /// [Future]s have completed. In addition, [arguments] may be a [List]
   /// containing a mix of strings and [Future]s.
   ScheduledProcess.start(executable, arguments,
       {options, String description, Encoding encoding: Encoding.UTF_8})
-      : _encoding = encoding {
+      : _encoding = encoding,
+        _explicitDescription = description != null,
+        _description = description {
     assert(currentSchedule.state == ScheduleState.SET_UP);
 
     _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;
 
     var stderrWithCanceller = _lineStreamWithCanceller(
         _process.then((p) => p.stderr));
     _stderrCanceller = stderrWithCanceller.last;
     var stderrTee = tee(stderrWithCanceller.first);
     _stderr = stderrTee.first;
     _stderrLog = stderrTee.last;
   }
 
   /// 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;
     } else {
       _description = "$executable ${arguments.map((a) => '"$a"').join(' ')}";
     }
   }
 
   /// Schedules the process to start and sets [_process].
@@ skipping 181 matching lines @@
     schedule(() {
       _endExpected = true;
       return _exitCode.then((exitCode) {
         if (expectedExitCode != null) {
           expect(exitCode, equals(expectedExitCode));
         }
       });
     }, "waiting for process '$description' to exit");
   }
 }