Get rid of LocalTest.tearDown.

lib/src/backend/invoker.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.invoker;
 
 import 'dart:async';
 
 import 'package:stack_trace/stack_trace.dart';
 
 import '../frontend/expect.dart';
 import '../utils.dart';
 import 'closed_exception.dart';
 import 'live_test.dart';
 import 'live_test_controller.dart';
 import 'metadata.dart';
 import 'outstanding_callback_counter.dart';
 import 'state.dart';
 import 'suite.dart';
 import 'test.dart';
 
 /// A test in this isolate.
 class LocalTest implements Test {
   final String name;
   final Metadata metadata;
 
   /// The test body.
   final AsyncFunction _body;
 
-  /// The callback used to clean up after the test.
-  ///
-  /// This is separated out from [_body] because it needs to run once the test's
-  /// asynchronous computation has finished, even if that's different from the
-  /// completion of the main body of the test.
-  final AsyncFunction _tearDown;
-
-  LocalTest(this.name, this.metadata, body(), {tearDown()})
-      : _body = body,
-        _tearDown = tearDown;
+  LocalTest(this.name, this.metadata, body())
+      : _body = body;
 
   /// Loads a single runnable instance of this test.
   LiveTest load(Suite suite) {
     var invoker = new Invoker._(suite, this);
     return invoker.liveTest;
   }
 
   Test change({String name, Metadata metadata}) {
     if (name == name && metadata == this.metadata) return this;
     if (name == null) name = this.name;
     if (metadata == null) metadata = this.metadata;
-    return new LocalTest(name, metadata, _body, tearDown: _tearDown);
+    return new LocalTest(name, metadata, _body);
   }
 }
 
 /// The class responsible for managing the lifecycle of a single local test.
 ///
 /// The current invoker is accessible within the zone scope of the running test
 /// using [Invoker.current]. It's used to track asynchronous callbacks and
 /// report asynchronous errors.
 class Invoker {
   /// The live test being driven by the invoker.
@@ skipping 78 matching lines @@
   ///
   /// Future calls to [addOutstandingCallback] and [removeOutstandingCallback]
   /// will be ignored.
   void removeAllOutstandingCallbacks() =>
       _outstandingCallbacks.removeAllOutstandingCallbacks();
 
   /// Runs [fn] and returns once all (registered) outstanding callbacks it
   /// transitively invokes have completed.
   ///
   /// If [fn] itself returns a future, this will automatically wait until that
-  /// future completes as well.
+  /// future completes as well. Note that outstanding callbacks registered
+  /// within [fn] will *not* be registered as outstanding callback outside of
+  /// [fn].
   ///
-  /// Note that outstanding callbacks registered within [fn] will *not* be
-  /// registered as outstanding callback outside of [fn].
+  /// If [fn] produces an unhandled error, this marks the current test as
+  /// failed, removes all outstanding callbacks registered within [fn], and the
+  /// completes returned future. It does not remove any outstanding callbacks

[Bob Nystrom, 2015/09/24 16:05:02]

"and the completes returned future" no has grammar.

[nweiz, 2015/09/24 19:56:20]

Done.

+  /// registered outside of [fn].
   Future waitForOutstandingCallbacks(fn()) {
     heartbeat();
 
     var counter = new OutstandingCallbackCounter();
     runZoned(() {
       // TODO(nweiz): Use async/await here once issue 23497 has been fixed in
       // two stable versions.
-      new Future.sync(fn).then((_) => counter.removeOutstandingCallback());
+      runZoned(() {
+        new Future.sync(fn).then((_) => counter.removeOutstandingCallback());
+      }, onError: _handleError);
     }, zoneValues: {
       // Use the invoker as a key so that multiple invokers can have different
       // outstanding callback counters at once.
       this: counter
     });
 
     return counter.noOutstandingCallbacks;
   }
 
   /// Notifies the invoker that progress is being made.
@@ skipping 58 matching lines @@
         // Run the test asynchronously so that the "running" state change has
         // a chance to hit its event handler(s) before the test produces an
         // error. If an error is emitted before the first state change is
         // handled, we can end up with [onError] callbacks firing before the
         // corresponding [onStateChange], which violates the timing
         // guarantees.
         new Future(_test._body)
             .then((_) => removeOutstandingCallback());
 
         _outstandingCallbacks.noOutstandingCallbacks.then((_) {
-          if (_test._tearDown == null) return null;
-
-          // Reset the outstanding callback counter to wait for callbacks from
-          // the test's `tearDown` to complete.
-          return waitForOutstandingCallbacks(() =>
-              runZoned(_test._tearDown, onError: _handleError));
-        }).then((_) {
           if (_timeoutTimer != null) _timeoutTimer.cancel();
           _controller.setState(
               new State(Status.complete, liveTest.state.result));
 
           // Use [Timer.run] here to avoid starving the DOM or other
           // non-microtask events.
           Timer.run(_controller.completer.complete);
         });
       }, zoneValues: {
         #test.invoker: this,
         // Use the invoker as a key so that multiple invokers can have different
         // outstanding callback counters at once.
         this: outstandingCallbacksForBody
       },
           zoneSpecification: new ZoneSpecification(
               print: (self, parent, zone, line) => _controller.print(line)),
           onError: _handleError);
     });
   }
 }