Wait for a timed-out test's tear-down logic.

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';
 
@@ skipping 74 matching lines @@
   LocalTest get _test => liveTest.test as LocalTest;
 
   /// The outstanding callback counter for the current zone.
   OutstandingCallbackCounter get _outstandingCallbacks {
     var counter = Zone.current[_counterKey];
     if (counter != null) return counter;
     throw new StateError("Can't add or remove outstanding callbacks outside "
         "of a test body.");
   }
 
+  /// All the zones created by [waitForOutstandingCallbacks], in the order they
+  /// were created.
+  ///
+  /// This is used to throw timeout errors in the most recent zone.
+  final _outstandingCallbackZones = <Zone>[];
+
   /// An opaque object used as a key in the zone value map to identify
   /// [_outstandingCallbacks].
   ///
   /// This is an instance variable to ensure that multiple invokers don't step
   /// on one anothers' toes.
   final _counterKey = new Object();
 
   /// The current invoker, or `null` if none is defined.
   ///
   /// An invoker is only set within the zone scope of a running test.
@@ skipping 52 matching lines @@
   ///
   /// If [fn] itself returns a future, this will automatically wait until that
   /// future completes as well. 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
   /// completes the returned future. It does not remove any outstanding
   /// callbacks registered outside of [fn].
+  ///
+  /// If the test times out, the *most recent* call to
+  /// [waitForOutstandingCallbacks] will treat that error as occurring within
+  /// [fn]—that is, it will complete immediately.
   Future waitForOutstandingCallbacks(fn()) {
     heartbeat();
 
+    var zone;
     var counter = new OutstandingCallbackCounter();
     runZoned(() {
       // TODO(nweiz): Use async/await here once issue 23497 has been fixed in
       // two stable versions.
       runZoned(() {
+        zone = Zone.current;
+        _outstandingCallbackZones.add(zone);
         new Future.sync(fn).then((_) => counter.removeOutstandingCallback());
       }, onError: _handleError);
     }, zoneValues: {
       _counterKey: counter
     });
 
-    return counter.noOutstandingCallbacks;
+    return counter.noOutstandingCallbacks.whenComplete(() {
+      _outstandingCallbackZones.remove(zone);
+    });
   }
 
   /// Runs [fn] in a zone where [closed] is always `false`.
   ///
   /// This is useful for running code that should be able to register callbacks
   /// and interact with the test framework normally even when the invoker is
   /// closed, for example cleanup code.
   unclosable(fn()) {
     heartbeat();
 
     return runZoned(fn, zoneValues: {
       _closableKey: false
     });
   }
 
   /// Notifies the invoker that progress is being made.
   ///
   /// Each heartbeat resets the timeout timer. This helps ensure that
   /// long-running tests that still make progress don't time out.
   void heartbeat() {
     if (liveTest.isComplete) return;
     if (_timeoutTimer != null) _timeoutTimer.cancel();
 
     var timeout = liveTest.test.metadata.timeout
         .apply(new Duration(seconds: 30));
     if (timeout == null) return;
-    _timeoutTimer = _invokerZone.createTimer(timeout,
-        Zone.current.bindCallback(() {
-      if (liveTest.isComplete) return;
-      _handleError(
-          new TimeoutException(
-              "Test timed out after ${niceDuration(timeout)}.", timeout));
-    }));
+    _timeoutTimer = _invokerZone.createTimer(timeout, () {
+      _outstandingCallbackZones.last.run(() {
+        if (liveTest.isComplete) return;
+        _handleError(
+            new TimeoutException(
+                "Test timed out after ${niceDuration(timeout)}.", timeout));
+      });
+    });
   }
 
   /// Notifies the invoker of an asynchronous error.
   void _handleError(error, [StackTrace stackTrace]) {
     if (stackTrace == null) stackTrace = new Chain.current();
 
     var afterSuccess = liveTest.isComplete &&
         liveTest.state.result == Result.success;
 
     if (error is! TestFailure) {
@@ skipping 19 matching lines @@
   void _onRun() {
     _controller.setState(const State(Status.running, Result.success));
 
     var outstandingCallbacksForBody = new OutstandingCallbackCounter();
 
     // TODO(nweiz): Use async/await here once issue 23497 has been fixed in two
     // stable versions.
     Chain.capture(() {
       runZonedWithValues(() {
         _invokerZone = Zone.current;
-
-        heartbeat();
+        _outstandingCallbackZones.add(Zone.current);
 
         // 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());
 
@@ skipping 12 matching lines @@
         // outstanding callback counters at once.
         _counterKey: outstandingCallbacksForBody,
         _closableKey: true
       },
           zoneSpecification: new ZoneSpecification(
               print: (self, parent, zone, line) => _controller.print(line)),
           onError: _handleError);
     });
   }
 }