Re-submit r18349.

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 'package:unittest/unittest.dart' as unittest;
 
 import 'schedule_error.dart';
 import 'task.dart';
 
 /// The schedule of tasks to run for a single test. This has three separate task
 /// queues: [tasks], [onComplete], and [onException]. It also provides
 /// visibility into the current state of the schedule.
 class Schedule {
   /// The main task queue for the schedule. These tasks are run before the other
   /// queues and generally constitute the main test body.
   TaskQueue get tasks => _tasks;
   TaskQueue _tasks;
 
   /// The queue of tasks to run if an error is caught while running [tasks]. The
-  /// error will be available via [error]. These tasks won't be run if no error
+  /// error will be available in [errors]. These tasks won't be run if no error
   /// occurs. Note that expectation failures count as errors.
   ///
   /// This queue runs before [onComplete], and errors in [onComplete] will not
   /// cause this queue to be run.
   ///
   /// If an error occurs in a task in this queue, all further tasks will be
   /// skipped.
   TaskQueue get onException => _onException;
   TaskQueue _onException;
 
   /// The queue of tasks to run after [tasks] and possibly [onException] have
   /// run. This queue will run whether or not an error occurred. If one did, it
-  /// will be available via [error]. Note that expectation failures count as
+  /// will be available in [errors]. Note that expectation failures count as
   /// errors.
   ///
   /// This queue runs after [onException]. If an error occurs while running
-  /// [onException], that error will be available via [error] in place of the
-  /// original error.
+  /// [onException], that error will be available in [errors] after the original
+  /// error.
   ///
   /// If an error occurs in a task in this queue, all further tasks will be
   /// skipped.
   TaskQueue get onComplete => _onComplete;
   TaskQueue _onComplete;
 
   /// Returns the [Task] that's currently executing, or `null` if there is no
   /// such task. This will be `null` both before the schedule starts running and
   /// after it's finished.
   Task get currentTask => _currentTask;
   Task _currentTask;
 
   /// Whether the schedule has finished running. This is only set once
   /// [onComplete] has finished running. It will be set whether or not an
   /// exception has occurred.
   bool get done => _done;
   bool _done = false;
 
-  /// The error thrown by the task queue. This will only be set while running
-  /// [onException] and [onComplete], since an error in [tasks] will cause it to
-  /// terminate immediately.
-  ScheduleError get error => _error;
-  ScheduleError _error;
+  // TODO(nweiz): make this a read-only view once issue 8321 is fixed.
+
+  /// Errors thrown by the task queues.
+  ///
+  /// When running tasks in [tasks], this will always be empty. If an error
+  /// occurs in [tasks], it will be added to this list and then [onException]
+  /// will be run. If an error occurs there as well, it will be added to this
+  /// list and [onComplete] will be run. Errors thrown during [onComplete] will
+  /// also be added to this list, although no scheduled tasks will be run
+  /// afterwards.
+  ///
+  /// Any out-of-band callbacks that throw errors will also have those errors
+  /// added to this list.
+  final errors = <ScheduleError>[];
 
   /// The task queue that's currently being run, or `null` if there is no such
   /// queue. One of [tasks], [onException], or [onComplete]. This will be `null`
   /// before the schedule starts running.
   TaskQueue get currentQueue => _done ? null : _currentQueue;
   TaskQueue _currentQueue;
 
   /// The number of out-of-band callbacks that have been registered with
   /// [wrapAsync] but have yet to be called.
   int _pendingCallbacks = 0;
@@ skipping 15 matching lines @@
   Future run(void setUp()) {
     return new Future.immediate(null).then((_) {
       try {
         setUp();
       } catch (e, stackTrace) {
         throw new ScheduleError.from(this, e, stackTrace: stackTrace);
       }
 
       return tasks._run();
     }).catchError((e) {
-      _error = e;
-      return onException._run().then((_) {
+      errors.add(e);
+      return onException._run().catchError((innerError) {
+        // If an error occurs in a task in the onException queue, make sure it's
+        // registered in the error list and re-throw it. We could also re-throw
+        // `e`; ultimately, all the errors will be shown to the user if any
+        // ScheduleError is thrown.
+        errors.add(innerError);
+        throw innerError;
+      }).then((_) {
+        // If there are no errors in the onException queue, re-throw the
+        // original error that caused it to run.
         throw e;
       });
-    }).whenComplete(() => onComplete._run()).whenComplete(() {
+    }).whenComplete(() {
+      return onComplete._run().catchError((e) {
+        // If an error occurs in a task in the onComplete queue, make sure it's
+        // registered in the error list and re-throw it.
+        errors.add(e);
+        throw e;
+      });
+    }).whenComplete(() {
       _done = true;
     });
   }
 
   /// 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]) {
     var scheduleError = new ScheduleError.from(this, error,
         stackTrace: stackTrace, task: currentTask);
     if (_done) {
+      errors.add(scheduleError);
       throw new StateError(
           "An out-of-band error was signaled outside of wrapAsync after the "
-              "schedule finished running:"
-          "${prefixLines(scheduleError.toString())}");
+              "schedule finished running.\n"
+          "${errorString()}");
     } else if (currentQueue == null) {
       // If we're not done but there's no current queue, that means we haven't
       // started yet and thus we're in setUp or the synchronous body of the
       // function. Throwing the error will thus pipe it into the main
       // error-handling code.
       throw scheduleError;
     } else {
       _currentQueue._signalError(scheduleError);
     }
   }
@@ skipping 20 matching lines @@
       } finally {
         _pendingCallbacks--;
         if (_pendingCallbacks == 0 && _noPendingCallbacks != null) {
           _noPendingCallbacks.complete();
           _noPendingCallbacks = null;
         }
       }
     };
   }
 
+  /// Returns a string representation of all errors registered on this schedule.
+  String errorString() {
+    if (errors.isEmpty) return "The schedule had no errors.";
+    if (errors.length == 1) return errors.first.toString();
+    var errorStrings = errors.map((e) => e.toString()).join("\n================"
+        "================================================================\n");
+    return "The schedule had ${errors.length} errors:\n$errorStrings";
+  }
+
   /// Returns a [Future] that will complete once there are no pending
   /// out-of-band callbacks.
   Future _awaitNoPendingCallbacks() {
     if (_pendingCallbacks == 0) return new Future.immediate(null);
     if (_noPendingCallbacks == null) _noPendingCallbacks = new Completer();
     return _noPendingCallbacks.future;
   }
 }
 
 /// A queue of asynchronous tasks to execute in order.
@@ skipping 32 matching lines @@
     return task.result;
   }
 
   /// Runs all the tasks in this queue in order.
   Future _run() {
     _schedule._currentQueue = this;
     return Future.forEach(_contents, (task) {
       _schedule._currentTask = task;
       if (_error != null) throw _error;
       return task.fn().catchError((e) {
+        if (_error != null) _schedule.errors.add(_error);
         throw new ScheduleError.from(_schedule, e, task: task);
       });
     }).whenComplete(() {
       _schedule._currentTask = null;
       return _schedule._awaitNoPendingCallbacks();
     }).then((_) {
       if (_error != null) throw _error;
     });
   }
 
   /// Signals that an out-of-band error has been detected and the queue should
   /// stop running as soon as possible.
   void _signalError(ScheduleError error) {
+    // If multiple errors are detected while a task is running, make sure the
+    // earlier ones are recorded in the schedule.
+    if (_error != null) _schedule.errors.add(_error);
     _error = error;
   }
 
   String toString() => name;
 
   /// Returns a detailed representation of the queue as a tree of tasks. If
   /// [highlight] is passed, that task is specially highlighted.
   ///
   /// [highlight] must be a task in this queue.
   String generateTree([Task highlight]) {
     assert(highlight == null || highlight.queue == this);
     return _contents.map((task) {
       var lines = task.toString().split("\n");
       var firstLine = task == highlight ?
           "> ${lines.first}" : "* ${lines.first}";
       lines = new List.from(lines.skip(1).map((line) => "| $line"));
       lines.insertRange(0, 1, firstLine);
       return lines.join("\n");
     }).join("\n");
   }
 }