Add the ability to abort a scheduled test.

pkg/scheduled_test/lib/src/schedule.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 schedule;
 
 import 'dart:async';
 import 'dart:collection';
 
 import '../../../../pkg/unittest/lib/unittest.dart' as unittest;
@@ skipping 139 matching lines @@
         // registered in the error list and re-throw it.
         _addError(e);
         throw e;
       });
     }).whenComplete(() {
       if (_timeoutTimer != null) _timeoutTimer.cancel();
       _state = ScheduleState.DONE;
     });
   }
 
+  /// Stop the current [TaskQueue] after the current task and any out-of-band
+  /// tasks stop executing. If this is called before [this] has started running,
+  /// no tasks in the [tasks] queue will be run.
+  ///
+  /// This won't cause an error, but any errors that are otherwise signaled will
+  /// still cause the test to fail.
+  void abort() {
+    if (_state == ScheduleState.DONE) {
+      throw new StateError("abort called after the schedule has finished "

[Bob Nystrom, 2013/03/14 22:29:18]

"abort called" -> "Aborted" or "Called abort()"

[nweiz, 2013/03/14 22:37:23]

Done.

+          "running.");
+    }
+
+    currentQueue._abort();
+  }
+
   /// Signals that an out-of-band error has occurred. Using [wrapAsync] along
   /// with `throw` is usually preferable to calling this directly.
   ///
   /// The metadata in [AsyncError]s and [ScheduleError]s will be preserved.
   void signalError(error, [stackTrace]) {
     heartbeat();
 
     var scheduleError = new ScheduleError.from(this, error,
         stackTrace: stackTrace);
     if (_state == ScheduleState.DONE) {
@@ skipping 165 matching lines @@
   ScheduleError _error;
 
   /// The [SubstituteFuture] for the currently-running task in the queue, or
   /// null if no task is currently running.
   SubstituteFuture _taskFuture;
 
   /// The toal number of out-of-band callbacks that have been registered on
   /// [this].
   int _totalCallbacks = 0;
 
+  /// Whether to stop running after the current task.
+  bool _aborted = false;
+
   // TODO(nweiz): make this a read-only view when issue 8321 is fixed.
   /// The descriptions of all callbacks that are blocking the completion of
   /// [this].
   Collection<String> get pendingCallbacks => _pendingCallbacks;
   final _pendingCallbacks = new Queue<String>();
 
   /// A completer that will be completed once [_pendingCallbacks] becomes empty
   /// after the queue finishes running its tasks.
   Future get _noPendingCallbacks => _noPendingCallbacksCompleter.future;
   final Completer _noPendingCallbacksCompleter = new Completer();
@@ skipping 56 matching lines @@
     return task.result;
   }
 
   /// Runs all the tasks in this queue in order.
   Future _run() {
     _schedule._currentQueue = this;
     _schedule.heartbeat();
     return Future.forEach(_contents, (task) {
       _schedule._currentTask = task;
       if (_error != null) throw _error;
+      if (_aborted) return;
 
       _taskFuture = new SubstituteFuture(task.fn());
       return _taskFuture.whenComplete(() {
         _taskFuture = null;
         _schedule.heartbeat();
       }).catchError((e) {
         var error = new ScheduleError.from(_schedule, e);
         _signalError(error);
         throw _error;
       });
@@ skipping 13 matching lines @@
       });
     }).whenComplete(() {
       _schedule.heartbeat();
       // If the tasks were otherwise successful, make sure we throw any
       // out-of-band errors. If a task failed, make sure we throw the most
       // recent error.
       if (_error != null) throw _error;
     });
   }
 
+  /// Stops this queue after the current task and any out-of-band callbacks
+  /// finish running.
+  void _abort() {
+    assert(_schedule.state == ScheduleState.SET_UP || isRunning);
+    _aborted = true;
+  }
+
   /// Returns a function wrapping [fn] that pipes any errors into the schedule
   /// chain. This will also block [this] from completing until the returned
   /// function has been called. It's used to ensure that out-of-band callbacks
   /// are properly handled by the scheduled test.
   Function _wrapAsync(fn(arg), String description) {
     assert(_schedule.state == ScheduleState.SET_UP || isRunning);
 
     // It's possible that the queue timed out before [fn] finished.
     bool _timedOut() =>
       _schedule.currentQueue != this || pendingCallbacks.isEmpty;
@@ skipping 82 matching lines @@
           var childLines = child.toString().split("\n");
           lines.add("  $prefix ${childLines.first}");
           lines.addAll(childLines.skip(1).map((line) => "  | $line"));
         }
       }
 
       return lines.join("\n");
     }).join("\n");
   }
 }