Roll to pickup pool changes

packages/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.
 
 import 'package:stack_trace/stack_trace.dart';
 
 import 'description.dart';
 import 'interfaces.dart';
 import 'util.dart';
 
@@ skipping 92 matching lines @@
 /// If [expected] is a [Matcher], then it matches using that. Otherwise it tests
 /// for equality using `==` on the expected value.
 ///
 /// For [Iterable]s and [Map]s, this will recursively match the elements. To
 /// handle cyclic structures a recursion depth [limit] can be provided. The
 /// default limit is 100. [Set]s will be compared order-independently.
 Matcher equals(expected, [int limit = 100]) => expected is String
     ? new _StringEqualsMatcher(expected)
     : new _DeepMatcher(expected, limit);
 
+typedef _RecursiveMatcher = List<String> Function(
+    dynamic, dynamic, String, int);
+
 class _DeepMatcher extends Matcher {
   final _expected;
   final int _limit;
-  var count;
 
   _DeepMatcher(this._expected, [int limit = 1000]) : this._limit = limit;
 
   // Returns a pair (reason, location)
-  List _compareIterables(expected, actual, matcher, depth, location) {
-    if (actual is! Iterable) return ['is not Iterable', location];
+  List<String> _compareIterables(Iterable expected, Object actual,
+      _RecursiveMatcher matcher, int depth, String location) {
+    if (actual is Iterable) {
+      var expectedIterator = expected.iterator;
+      var actualIterator = actual.iterator;
+      for (var index = 0;; index++) {
+        // Advance in lockstep.
+        var expectedNext = expectedIterator.moveNext();
+        var actualNext = actualIterator.moveNext();
 
-    var expectedIterator = expected.iterator;
-    var actualIterator = actual.iterator;
-    for (var index = 0;; index++) {
-      // Advance in lockstep.
-      var expectedNext = expectedIterator.moveNext();
-      var actualNext = actualIterator.moveNext();
+        // If we reached the end of both, we succeeded.
+        if (!expectedNext && !actualNext) return null;
 
-      // If we reached the end of both, we succeeded.
-      if (!expectedNext && !actualNext) return null;
+        // Fail if their lengths are different.
+        var newLocation = '$location[$index]';
+        if (!expectedNext) return ['longer than expected', newLocation];
+        if (!actualNext) return ['shorter than expected', newLocation];
 
-      // Fail if their lengths are different.
-      var newLocation = '${location}[${index}]';
-      if (!expectedNext) return ['longer than expected', newLocation];
-      if (!actualNext) return ['shorter than expected', newLocation];
-
-      // Match the elements.
-      var rp = matcher(
-          expectedIterator.current, actualIterator.current, newLocation, depth);
-      if (rp != null) return rp;
+        // Match the elements.
+        var rp = matcher(expectedIterator.current, actualIterator.current,
+            newLocation, depth);
+        if (rp != null) return rp;
+      }
+    } else {
+      return ['is not Iterable', location];
     }
   }
 
-  List _compareSets(Set expected, actual, matcher, depth, location) {
-    if (actual is! Iterable) return ['is not Iterable', location];
-    actual = actual.toSet();
+  List<String> _compareSets(Set expected, Object actual,
+      _RecursiveMatcher matcher, int depth, String location) {
+    if (actual is Iterable) {
+      Set other = actual.toSet();
 
-    for (var expectedElement in expected) {
-      if (actual.every((actualElement) =>
-          matcher(expectedElement, actualElement, location, depth) != null)) {
-        return ['does not contain $expectedElement', location];
+      for (var expectedElement in expected) {
+        if (other.every((actualElement) =>
+            matcher(expectedElement, actualElement, location, depth) != null)) {
+          return ['does not contain $expectedElement', location];
+        }
       }
-    }
 
-    if (actual.length > expected.length) {
-      return ['larger than expected', location];
-    } else if (actual.length < expected.length) {
-      return ['smaller than expected', location];
+      if (other.length > expected.length) {
+        return ['larger than expected', location];
+      } else if (other.length < expected.length) {
+        return ['smaller than expected', location];
+      } else {
+        return null;
+      }
     } else {
-      return null;
+      return ['is not Iterable', location];
     }
   }
 
-  List _recursiveMatch(expected, actual, String location, int depth) {
+  List<String> _recursiveMatch(
+      Object expected, Object actual, String location, int depth) {
     // If the expected value is a matcher, try to match it.
     if (expected is Matcher) {
       var matchState = {};
       if (expected.matches(actual, matchState)) return null;
 
       var description = new StringDescription();
       expected.describe(description);
       return ['does not match $description', location];
     } else {
       // Otherwise, test for equality.
@@ skipping 10 matching lines @@
     // If _limit is 1 we can only recurse one level into object.
     if (depth == 0 || _limit > 1) {
       if (expected is Set) {
         return _compareSets(
             expected, actual, _recursiveMatch, depth + 1, location);
       } else if (expected is Iterable) {
         return _compareIterables(
             expected, actual, _recursiveMatch, depth + 1, location);
       } else if (expected is Map) {
         if (actual is! Map) return ['expected a map', location];
-
-        var err = (expected.length == actual.length)
-            ? ''
-            : 'has different length and ';
+        var map = (actual as Map);
+        var err =
+            (expected.length == map.length) ? '' : 'has different length and ';
         for (var key in expected.keys) {
-          if (!actual.containsKey(key)) {
+          if (!map.containsKey(key)) {
             return ["${err}is missing map key '$key'", location];
           }
         }
 
-        for (var key in actual.keys) {
+        for (var key in map.keys) {
           if (!expected.containsKey(key)) {
             return ["${err}has extra map key '$key'", location];
           }
         }
 
         for (var key in expected.keys) {
           var rp = _recursiveMatch(
-              expected[key], actual[key], "${location}['${key}']", depth + 1);
+              expected[key], map[key], "$location['$key']", depth + 1);
           if (rp != null) return rp;
         }
 
         return null;
       }
     }
 
     var description = new StringDescription();
 
     // If we have recursed, show the expected value too; if not, expect() will
     // show it for us.
     if (depth > 0) {
       description
           .add('was ')
           .addDescriptionOf(actual)
           .add(' instead of ')
           .addDescriptionOf(expected);
       return [description.toString(), location];
     }
 
     // We're not adding any value to the actual value.
     return ["", location];
   }
 
   String _match(expected, actual, Map matchState) {
     var rp = _recursiveMatch(expected, actual, '', 0);
     if (rp == null) return null;
-    var reason;
+    String reason;
     if (rp[0].length > 0) {
       if (rp[1].length > 0) {
         reason = "${rp[0]} at location ${rp[1]}";
       } else {
         reason = rp[0];
       }
     } else {
       reason = '';
     }
     // Cache the failure reason in the matchState.
@@ skipping 69 matching lines @@
         _writeLeading(buff, escapedValue, start);
         _writeTrailing(buff, escapedValue, start);
         buff.write('\n  Actual: ');
         _writeLeading(buff, escapedItem, start);
         _writeTrailing(buff, escapedItem, start);
         buff.write('\n          ');
         for (int i = (start > 10 ? 14 : start); i > 0; i--) buff.write(' ');
         buff.write('^\n Differ at offset $start');
       }
 
-      return mismatchDescription.replace(buff.toString());
+      return mismatchDescription.add(buff.toString());
     }
   }
 
   static void _writeLeading(StringBuffer buff, String s, int start) {
     if (start > 10) {
       buff.write('... ');
       buff.write(s.substring(start - 10, start));
     } else {
       buff.write(s.substring(0, start));
     }
@@ skipping 217 matching lines @@
   Description describe(Description description) =>
       description.add('is in ').addDescriptionOf(_expected);
 }
 
 /// Returns a matcher that uses an arbitrary function that returns
 /// true or false for the actual value.
 ///
 /// For example:
 ///
 ///     expect(v, predicate((x) => ((x % 2) == 0), "is even"))
-Matcher predicate(bool f(value), [String description = 'satisfies function']) =>
+Matcher predicate<T>(bool f(T value),
+        [String description = 'satisfies function']) =>
     new _Predicate(f, description);
 
-typedef bool _PredicateFunction(value);
+typedef bool _PredicateFunction<T>(T value);
 
-class _Predicate extends Matcher {
-  final _PredicateFunction _matcher;
+class _Predicate<T> extends Matcher {
+  final _PredicateFunction<T> _matcher;
   final String _description;
 
-  const _Predicate(this._matcher, this._description);
+  _Predicate(this._matcher, this._description);
 
-  bool matches(item, Map matchState) => _matcher(item);
+  bool matches(item, Map matchState) => _matcher(item as T);
 
   Description describe(Description description) =>
       description.add(_description);
 }
 
 /// A useful utility class for implementing other matchers through inheritance.
 /// Derived classes should call the base constructor with a feature name and
 /// description, and an instance matcher, and should implement the
 /// [featureValueOf] abstract method.
 ///
 /// The feature description will typically describe the item and the feature,
 /// while the feature name will just name the feature. For example, we may
 /// have a Widget class where each Widget has a price; we could make a
 /// [CustomMatcher] that can make assertions about prices with:
 ///
-///     class HasPrice extends CustomMatcher {
-///       const HasPrice(matcher) :
-///           super("Widget with price that is", "price", matcher);
-///       featureValueOf(actual) => actual.price;
-///     }
+/// ```dart
+/// class HasPrice extends CustomMatcher {
+///   HasPrice(matcher) : super("Widget with price that is", "price", matcher);
+///   featureValueOf(actual) => actual.price;
+/// }
+/// ```
 ///
 /// and then use this for example like:
 ///
-///      expect(inventoryItem, new HasPrice(greaterThan(0)));
+/// ```dart
+/// expect(inventoryItem, new HasPrice(greaterThan(0)));
+/// ```
 class CustomMatcher extends Matcher {
   final String _featureDescription;
   final String _featureName;
   final Matcher _matcher;
 
   CustomMatcher(this._featureDescription, this._featureName, matcher)
       : this._matcher = wrapMatcher(matcher);
 
   /// Override this to extract the interesting feature.
   featureValueOf(actual) => actual;
@@ skipping 42 matching lines @@
 
     _matcher.describeMismatch(matchState['custom.feature'], innerDescription,
         matchState['state'], verbose);
 
     if (innerDescription.length > 0) {
       mismatchDescription.add(' which ').add(innerDescription.toString());
     }
     return mismatchDescription;
   }
 }