pkg/matcher: refactored code around data-structure vs execution-based matchers

pkg/matcher/lib/src/core_matchers.dart

 // Copyright (c) 2012, 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 matcher.core_matchers;
 
-import 'dart:async';
-
 import 'description.dart';
-import 'expect.dart';
 import 'interfaces.dart';
+import 'util.dart';
 
 /// Returns a matcher that matches empty strings, maps or iterables
 /// (including collections).
 const Matcher isEmpty = const _Empty();
 
 class _Empty extends Matcher {
   const _Empty();
   bool matches(item, Map matchState) {
     if (item is Map || item is Iterable) {
       return item.isEmpty;
@@ skipping 361 matching lines @@
 /// parameters.
 class isInstanceOf<T> extends Matcher {
   final String _name;
   const isInstanceOf([name = 'specified type']) : this._name = name;
   bool matches(obj, Map matchState) => obj is T;
   // The description here is lame :-(
   Description describe(Description description) =>
       description.add('an instance of ${_name}');
 }
 
-/// 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
-///     return immediately and execution will continue. Later, when the future
-///     completes, the actual expectation will run.
-const Matcher throws = const Throws();
-
-/// 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
-///     return immediately and execution will continue. Later, when the future
-///     completes, the actual expectation will run.
-///
-/// In both cases, when an exception is thrown, this will test that the exception
-/// object matches [matcher]. If [matcher] is not an instance of [Matcher], it
-/// will implicitly be treated as `equals(matcher)`.
-Matcher throwsA(matcher) => new Throws(wrapMatcher(matcher));
-
 /// A matcher that matches a function call against no exception.
 /// The function will be called once. Any exceptions will be silently swallowed.
 /// The value passed to expect() should be a reference to the function.
 /// Note that the function cannot take arguments; to handle this
 /// a wrapper will have to be created.
 const Matcher returnsNormally = const _ReturnsNormally();
 
-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 = wrapAsync((fn) => fn());
-
-      // Queue up an asynchronous expectation that validates when the future
-      // completes.
-      item.then((value) {
-        done(() {
-          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);
-        });
-      });
-      // It hasn't failed yet.
-      return true;
-    }
-
-    try {
-      item();
-      return false;
-    } catch (e, s) {
-      if (_matcher == null || _matcher.matches(e, matchState)) {
-        return true;
-      } else {
-        addStateInfo(matchState, {'exception': e, 'stack': s});
-        return false;
-      }
-    }
-  }
-
-  Description describe(Description description) {
-    if (_matcher == null) {
-      return description.add("throws");
-    } else {
-      return description.add('throws ').addDescriptionOf(_matcher);
-    }
-  }
-
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState,
-                               bool verbose) {
-    if (item is! Function && item is! Future) {
-      return mismatchDescription.add('is not a Function or Future');
-    } else if (_matcher == null || matchState['exception'] == null) {
-      return mismatchDescription.add('did not throw');
-    } else {
-      mismatchDescription. add('threw ').
-          addDescriptionOf(matchState['exception']);
-      if (verbose) {
-        mismatchDescription.add(' at ').add(matchState['stack'].toString());
-      }
-      return mismatchDescription;
-    }
-  }
-}
-
 class _ReturnsNormally extends Matcher {
   const _ReturnsNormally();
 
   bool matches(f, Map matchState) {
     try {
       f();
       return true;
     } catch (e, s) {
       addStateInfo(matchState, {'exception': e, 'stack': s});
       return false;
@@ skipping 227 matching lines @@
         addDescriptionOf(matchState['feature']);
     var innerDescription = new StringDescription();
     _matcher.describeMismatch(matchState['feature'], innerDescription,
         matchState['state'], verbose);
     if (innerDescription.length > 0) {
       mismatchDescription.add(' which ').add(innerDescription.toString());
     }
     return mismatchDescription;
   }
 }