Replace the existing unittest APIs with the new runner infrastructure.

lib/src/throws_matcher.dart

 // Copyright (c) 2014, 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 unittest.throws_matcher;
 
 import 'dart:async';
 
 import 'package:matcher/matcher.dart' hide fail, expect;
 
-import '../unittest.dart';
+import 'expect.dart';
+import 'invoker.dart';
+import 'utils.dart';
 
 /// This can be used to match two kinds of objects:
 ///
 /// * A [Function] that throws an exception when called. The function cannot
 ///   take any arguments. If you want to test that a function expecting
 ///   arguments throws, wrap it in another zero-argument function that calls
 ///   the one you want to test.
 ///
 /// * A [Future] that completes with an exception. Note that this creates an
 ///   asynchronous expectation. The call to `expect()` that includes this will
@@ skipping 19 matching lines @@
 Matcher throwsA(matcher) => new Throws(wrapMatcher(matcher));
 
 class Throws extends Matcher {
   final Matcher _matcher;
 
   const Throws([Matcher matcher]) : this._matcher = matcher;
 
   bool matches(item, Map matchState) {
     if (item is! Function && item is! Future) return false;
     if (item is Future) {
-      var done = expectAsync((fn) => fn());
-
+      Invoker.current.addOutstandingCallback();
       // Queue up an asynchronous expectation that validates when the future
       // completes.
       item.then((value) {
-        done(() {
-          fail("Expected future to fail, but succeeded with '$value'.");
-        });
+        fail("Expected future to fail, but succeeded with '$value'.");
       }, onError: (error, trace) {
-        done(() {
-          if (_matcher == null) return;
-          var reason;
-          if (trace != null) {
-            var stackTrace = trace.toString();
-            stackTrace = "  ${stackTrace.replaceAll("\n", "\n  ")}";
-            reason = "Actual exception trace:\n$stackTrace";
-          }
-          expect(error, _matcher, reason: reason);
-        });
-      });
+        if (_matcher == null) return;
+
+        var reason;
+        if (trace != null) {
+          var stackTrace = terseChain(trace).toString();
+          stackTrace = "  ${stackTrace.replaceAll("\n", "\n  ")}";
+          reason = "Actual exception trace:\n$stackTrace";
+        }
+
+        // Re-run [expect] to get the proper formatting.
+        expect(() => throw error, this, reason: reason);
+      }).then((_) => Invoker.current.removeOutstandingCallback());
       // It hasn't failed yet.
       return true;
     }
 
     try {
       item();
       return false;
     } catch (e, s) {
       if (_matcher == null || _matcher.matches(e, matchState)) {
         return true;
@@ skipping 22 matching lines @@
       mismatchDescription
           .add('threw ')
           .addDescriptionOf(matchState['exception']);
       if (verbose) {
         mismatchDescription.add(' at ').add(matchState['stack'].toString());
       }
       return mismatchDescription;
     }
   }
 }