Get rid of LocalTest.tearDown.

test/backend/declarer_test.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.
 
 import 'dart:async';
 
 import 'package:test/src/backend/declarer.dart';
+import 'package:test/src/backend/invoker.dart';
 import 'package:test/src/backend/suite.dart';
 import 'package:test/src/frontend/timeout.dart';
 import 'package:test/test.dart';
 
+import '../utils.dart';
+
 Declarer _declarer;
 Suite _suite;
 
 void main() {
   setUp(() {
     _declarer = new Declarer();
     _suite = new Suite([]);
   });
 
   group(".test()", () {
@@ skipping 73 matching lines @@
       _declarer.test("description 2", expectAsync(() {
         expect(tearDownRun, isFalse);
       }, max: 1));
 
       await _runTest(0);
       expect(tearDownRun, isTrue);
       await _runTest(1);
       expect(tearDownRun, isTrue);
     });
 
+    test("is run after an out-of-band failure", () async {
+      var tearDownRun;
+      _declarer.setUp(() => tearDownRun = false);
+      _declarer.tearDown(() => tearDownRun = true);
+
+      _declarer.test("description 1", expectAsync(() {
+        Invoker.current.addOutstandingCallback();
+        new Future(() => throw new TestFailure("oh no"));
+      }, max: 1));
+
+      await _runTest(0, shouldFail: true);
+      expect(tearDownRun, isTrue);
+    });
+
     test("can return a Future", () async {
       var tearDownRun = false;
       _declarer.tearDown(() {
         return new Future(() => tearDownRun = true);
       });
 
       _declarer.test("description", expectAsync(() {
         expect(tearDownRun, isFalse);
       }, max: 1));
 
       await _runTest(0);
       expect(tearDownRun, isTrue);
     });
 
+    test("isn't run until there are no outstanding callbacks", () async {
+      var outstandingCallbackRemoved = false;
+      var outstandingCallbackRemovedBeforeTeardown = false;
+      _declarer.tearDown(() {
+        outstandingCallbackRemovedBeforeTeardown = outstandingCallbackRemoved;
+      });
+
+      _declarer.test("description", () {
+        Invoker.current.addOutstandingCallback();
+        pumpEventQueue().then((_) {
+          outstandingCallbackRemoved = true;
+          Invoker.current.removeOutstandingCallback();
+        });
+      });
+
+      await _runTest(0);
+      expect(outstandingCallbackRemovedBeforeTeardown, isTrue);
+    });
+
+    test("doesn't complete until there are no outstanding callbacks", () async {
+      var outstandingCallbackRemoved = false;
+      _declarer.tearDown(() {
+        Invoker.current.addOutstandingCallback();
+        pumpEventQueue().then((_) {
+          outstandingCallbackRemoved = true;
+          Invoker.current.removeOutstandingCallback();
+        });
+      });
+
+      _declarer.test("description", () {});
+
+      await _runTest(0);
+      expect(outstandingCallbackRemoved, isTrue);
+    });
+
     test("can't be called multiple times", () {
       _declarer.tearDown(() {});
       expect(() => _declarer.tearDown(() {}), throwsStateError);
     });
   });
 
   group("in a group,", () {
     test("tests inherit the group's description", () {
       _declarer.group("group", () {
         _declarer.test("description", () {});
@@ skipping 215 matching lines @@
         });
       });
     });
   });
 }
 
 /// Runs the test at [index] defined on [_declarer].
 ///
 /// This automatically sets up an `onError` listener to ensure that the test
 /// doesn't throw any invisible exceptions.
-Future _runTest(int index) {
+Future _runTest(int index, {bool shouldFail: false}) {
   var liveTest = _declarer.tests[index].load(_suite);
-  liveTest.onError.listen(expectAsync((_) {},
-      count: 0, reason: "No errors expected for test #$index."));
+
+  liveTest.onError.listen(shouldFail
+      ? expectAsync((_) {})
+      : expectAsync((_) {},
+            count: 0, reason: "No errors expected for test #$index."));
+
   return liveTest.run();
 }