Don't early-exit teardowns after a signal.

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 38 matching lines @@
 /// 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.
   ///
   /// This provides a view into the state of the test being executed.
   LiveTest get liveTest => _controller.liveTest;
   LiveTestController _controller;
 
+  bool get _closable => Zone.current[_closableKey];
+
+  /// An opaque object used as a key in the zone value map to identify
+  /// [_closable].
+  ///
+  /// This is an instance variable to ensure that multiple invokers don't step
+  /// on one anothers' toes.
+  final _closableKey = new Object();
+
   /// Whether the test has been closed.
   ///
   /// Once the test is closed, [expect] and [expectAsync] will throw
   /// [ClosedException]s whenever accessed to help the test stop executing as
   /// soon as possible.
-  bool get closed => _onCloseCompleter.isCompleted;
+  bool get closed => _closable && _onCloseCompleter.isCompleted;
 
   /// A future that completes once the test has been closed.
-  Future get onClose => _onCloseCompleter.future;
+  Future get onClose => _closable
+      ? _onCloseCompleter.future
+      : new Completer().future;

[kevmoo, 2015/10/01 02:21:23]

Wha? Please explain...

[nweiz, 2015/10/01 21:16:27]

This is just a future that will never fire.

   final _onCloseCompleter = new Completer();
 
   /// The test being run.
   LocalTest get _test => liveTest.test as LocalTest;
 
   /// The test metadata merged with the suite metadata.
   final Metadata metadata;
 
   /// The outstanding callback counter for the current zone.
   OutstandingCallbackCounter get _outstandingCallbacks {
-    var counter = Zone.current[this];
+    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.");
   }
 
+  /// 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.
   static Invoker get current {
     // TODO(nweiz): Use a private symbol when dart2js supports it (issue 17526).
     return Zone.current[#test.invoker];
   }
 
   /// The zone that the top level of [_test.body] is running in.
   ///
@@ skipping 57 matching lines @@
     heartbeat();
 
     var counter = new OutstandingCallbackCounter();
     runZoned(() {
       // TODO(nweiz): Use async/await here once issue 23497 has been fixed in
       // two stable versions.
       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
+      _counterKey: counter
     });
 
     return counter.noOutstandingCallbacks;
   }
 
+  /// 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 = metadata.timeout.apply(new Duration(seconds: 30));
     if (timeout == null) return;
@@ skipping 61 matching lines @@
               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
+        _counterKey: outstandingCallbacksForBody,
+        _closableKey: true
       },
           zoneSpecification: new ZoneSpecification(
               print: (self, parent, zone, line) => _controller.print(line)),
           onError: _handleError);
     });
   }
 }