Don't throw an error if a scheduled process exits early.

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:convert';
 import 'dart:io';
 
@@ skipping 47 matching lines @@
 
   /// A canceller that controls both [_stderr] and [_stderrLog].
   StreamCanceller _stderrCanceller;
 
   /// The exit code of the process that's scheduled to run. This will naturally
   /// only complete once the process has terminated.
   ValueFuture<int> _exitCode;
 
   /// Whether the user has scheduled the end of this process by calling either
   /// [shouldExit] or [kill].
-  var _endScheduled = false;
+  bool get _endScheduled => _scheduledExitTask != null;
 
-  /// The task that runs immediately before this process is scheduled to end. If
-  /// the process ends during this task, we treat that as expected.
-  Task _taskBeforeEnd;
+  /// The task where this process is scheduled to exit -- either by waiting to
+  /// exit ([shouldExit]) or by killing the process ([kill]).
+  ///
+  /// It's legal for the process to exit before this task runs. This can happen
+  /// for example if there's still standard output to read from the process
+  /// after it exits.
+  Task _scheduledExitTask;
 
-  /// Whether the process is expected to terminate at this point.
-  var _endExpected = false;
+  /// The task during which the process actually exited.
+  Task _actualExitTask;
 
   /// Schedules a process to start. [executable], [arguments],
   /// [workingDirectory], and [environment] have the same meaning as for
   /// [Process.start]. [description] is a string 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], [workingDirectory], and [environment] 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]
@@ skipping 80 matching lines @@
 
   /// Listens for [_process] to exit and passes the exit code to
   /// [exitCodeCompleter]. If the process completes earlier than expected, an
   /// exception will be signaled to the schedule.
   void _handleExit(Completer exitCodeCompleter) {
     // We purposefully avoid using wrapFuture here. If an error occurs while a
     // process is running, we want the schedule to move to the onException
     // queue where the process will be killed, rather than blocking the tasks
     // queue waiting for the process to exit.
     _process.then((p) => Chain.track(p.exitCode)).then((exitCode) {
-      if (_endExpected) {
-        exitCodeCompleter.complete(exitCode);
-        return;
-      }
-
-      wrapFuture(pumpEventQueue().then((_) {
-        if (currentSchedule.currentTask != _taskBeforeEnd) return null;
-        // If we're one task before the end was scheduled, wait for that task
-        // to complete and pump the event queue so that _endExpected will be
-        // set.
-        return _taskBeforeEnd.result.then((_) => pumpEventQueue());
-      }).then((_) {
-        exitCodeCompleter.complete(exitCode);
-
-        if (!_endExpected) {
-          fail("Process '$description' ended earlier than scheduled "
-               "with exit code $exitCode.");
-        }
-      }), "waiting to reach shouldExit() or kill() for process "
-          "'$description'");
+      _actualExitTask = currentSchedule.currentTask;
+      exitCodeCompleter.complete(exitCode);
     });
   }
 
   /// 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<List<int>>> streamFuture) {
     return streamWithCanceller(futureStream(streamFuture)
         .handleError(currentSchedule.signalError)
         .map((chunk) {
@@ skipping 11 matching lines @@
   void _scheduleExceptionCleanup() {
     currentSchedule.onException.schedule(() {
       _stdoutCanceller();
       _stderrCanceller();
 
       if (!_process.hasValue) return null;
 
       var killedPrematurely = false;
       if (!_exitCode.hasValue) {
         killedPrematurely = true;
-        _endExpected = true;
         _process.value.kill(ProcessSignal.SIGKILL);
         // Ensure that the onException queue waits for the process to actually
         // exit after being killed.
         wrapFuture(_process.value.exitCode, "waiting for process "
             "'$description' to die");
       }
 
       return Future.wait([
         _stdoutLog.toList(),
         _stderrLog.toList()
       ]).then((results) {
         var stdout = results[0].join("\n");
         var stderr = results[1].join("\n");
 
-        var exitDescription = killedPrematurely
-            ? "Process was killed prematurely."
-            : "Process exited with exit code ${_exitCode.value}.";
+        var exitDescription;
+        if (killedPrematurely) {
+          exitDescription = "Process was killed prematurely.";
+        } else {
+          exitDescription = "Process exited with exit code ${_exitCode.value}";
+          if (_actualExitTask != _scheduledExitTask) {
+            var taskString = _actualExitTask.toString();
+            if (taskString.contains("\n")) {
+              exitDescription += " in task:\n${prefixLines(taskString)}";
+            } else {
+              exitDescription += " in task $taskString";
+            }
+          }
+          exitDescription += ".";
+        }
+
         currentSchedule.addDebugInfo(
             "Results of running '$description':\n"
             "$exitDescription\n"
             "Standard output:\n"
             "${prefixLines(stdout)}\n"
             "Standard error:\n"
             "${prefixLines(stderr)}");
       });
     }, "cleaning up process '$description'");
   }
@@ skipping 67 matching lines @@
     schedule(() => _process.then((p) => p.stdin.close()),
         "closing stdin for process '$description'");
   }
 
   /// Kills the process, and waits until it's dead.
   void kill() {
     if (_endScheduled) {
       throw new StateError("shouldExit() or kill() already called.");
     }
 
-    _endScheduled = true;
-    _taskBeforeEnd = currentSchedule.tasks.contents.last;
     schedule(() {
-      _endExpected = true;
       return _process
           .then((p) => p.kill(ProcessSignal.SIGKILL))
           .then((_) => _exitCode);
     }, "waiting for process '$description' to die");
+    _scheduledExitTask = currentSchedule.tasks.contents.last;
   }
 
   /// Waits for the process to exit, and verifies that the exit code matches
   /// [expectedExitCode] (if given).
   void shouldExit([int expectedExitCode]) {
     if (_endScheduled) {
       throw new StateError("shouldExit() or kill() already called.");
     }
 
-    _endScheduled = true;
-    _taskBeforeEnd = currentSchedule.tasks.contents.last;
     schedule(() {
-      _endExpected = true;
       return _exitCode.then((exitCode) {
         if (expectedExitCode != null) {
           expect(exitCode, equals(expectedExitCode));
         }
       });
     }, "waiting for process '$description' to exit");
+    _scheduledExitTask = currentSchedule.tasks.contents.last;
   }
 }