Use the Zone API for registerException.

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 126 matching lines @@
     }, 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 of an asynchronous error.
-  ///
-  /// Note that calling this explicitly is rarely necessary, since any
-  /// otherwise-uncaught errors will be forwarded to the invoker anyway.
-  void handleError(error, [StackTrace stackTrace]) {
+  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) {
       _controller.setState(const State(Status.complete, Result.error));
     } else if (liveTest.state.result != Result.error) {
       _controller.setState(const State(Status.complete, Result.failure));
     }
 
     _controller.addError(error, stackTrace);
     _outstandingCallbacks.removeAllOutstandingCallbacks();
 
     // If a test was marked as success but then had an error, that indicates
     // that it was poorly-written and could be flaky.
     if (!afterSuccess) return;
-    handleError(
+    _handleError(
         "This test failed after it had already completed. Make sure to use "
             "[expectAsync]\n"
         "or the [completes] matcher when testing async code.",
         stackTrace);
   }
 
   /// 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(() {
         // TODO(nweiz): Reset this timer whenever the user's code interacts
         // with the library.
         var timeout = metadata.timeout.apply(new Duration(seconds: 30));
         var timer = new Timer(timeout, () {
           if (liveTest.isComplete) return;
-          handleError(
+          _handleError(
               new TimeoutException(
                   "Test timed out after ${niceDuration(timeout)}.", timeout));
         });
 
         // 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));
+              runZoned(_test._tearDown, onError: _handleError));
         }).then((_) {
           timer.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);
+          onError: _handleError);
     });
   }
 }