Run outer tearDown()s even if inner ones fail.

lib/src/backend/group.dart

 // Copyright (c) 2015, 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 test.backend.group;
 
 import 'dart:async';
 
 import '../utils.dart';
+import 'invoker.dart';
 import 'metadata.dart';
 
 /// A group contains multiple tests and subgroups.
 ///
 /// A group has a description that is prepended to that of all nested tests and
 /// subgroups. It also has [setUp] and [tearDown] functions which are scoped to
 /// the tests and groups it contains.
 class Group {
   /// The parent group, or `null` if this is the root group.
   final Group parent;
@@ skipping 49 matching lines @@
     return new Future.value();
   }
 
   /// Run the tear-up functions for this and any parent groups.
   ///
   /// If no set-up functions are declared, this returns a [Future] that
   /// completes immediately.
   Future runTearDown() {
     // TODO(nweiz): Use async/await here once issue 23497 has been fixed in two
     // stable versions.
-    if (parent != null) {
-      return new Future.sync(() {
-        if (tearDown != null) return tearDown();
-      }).then((_) => parent.runTearDown());
+    if (parent == null) {
+      return tearDown == null ? new Future.value() : new Future.sync(tearDown);
     }
 
-    if (tearDown != null) return new Future.sync(tearDown);
-    return new Future.value();
+    return _errorsDontStopTest(() {
+      if (tearDown != null) return tearDown();
+    }).then((_) => parent.runTearDown());
+  }
+
+  /// Runs [body] with special error-handling behavior.

[kevmoo, 2015/09/24 21:07:30]

Is the case this addresses already covered in the tests?

[nweiz, 2015/09/24 21:13:07]

Yeah; the test coincidentally passed because of the specific way this used to
work, but it does exercise this behavior.

+  ///
+  /// Errors emitted [body] will still cause be the test to fail, but they won't
+  /// cause it to *stop*. In particular, they won't remove any outstanding
+  /// callbacks registered outside of [body].
+  Future _errorsDontStopTest(body()) {
+    var completer = new Completer();
+    Invoker.current.waitForOutstandingCallbacks(() {
+      new Future.sync(body).whenComplete(completer.complete);
+    });
+    return completer.future;
   }
 }