Add Timeout.none.

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 79 matching lines @@
   }
 
   /// 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.
+  ///
+  /// Tracking this ensures that [_timeoutTimer] isn't created in a
+  /// timer-mocking zone created by the test.
+  Zone _invokerZone;
+
   /// The timer for tracking timeouts.
   ///
   /// This will be `null` until the test starts running.
   Timer _timeoutTimer;
 
   Invoker._(Suite suite, LocalTest test)
       : metadata = suite.metadata.merge(test.metadata) {
     _controller = new LiveTestController(
         suite, test, _onRun, _onCloseCompleter.complete);
   }
@@ skipping 54 matching lines @@
 
   /// 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));
-    _timeoutTimer = new Timer(timeout, () {
+    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));
-    });
+    }));
   }
 
   /// 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 18 matching lines @@
   /// The method that's run when the test is started.
   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();
 
         // 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((_) {
-          _timeoutTimer.cancel();
+          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);
     });
   }
 }