Update charted to 0.4.8 and roll

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.
 
-library matcher.core_matchers;
+import 'package:stack_trace/stack_trace.dart';
 
 import 'description.dart';
 import 'interfaces.dart';
 import 'util.dart';
 
 /// Returns a matcher that matches the isEmpty property.
 const Matcher isEmpty = const _Empty();
 
 class _Empty extends Matcher {
   const _Empty();
@@ skipping 100 matching lines @@
   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];
 
     var expectedIterator = expected.iterator;
     var actualIterator = actual.iterator;
-    for (var index = 0; ; index++) {
+    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;
 
       // Fail if their lengths are different.
       var newLocation = '${location}[${index}]';
       if (!expectedNext) return ['longer than expected', newLocation];
@@ skipping 119 matching lines @@
   }
 
   bool matches(item, Map matchState) =>
       _match(_expected, item, matchState) == null;
 
   Description describe(Description description) =>
       description.addDescriptionOf(_expected);
 
   Description describeMismatch(
       item, Description mismatchDescription, Map matchState, bool verbose) {
-    var reason = matchState['reason'];
+    var reason = matchState['reason'] ?? '';
     // If we didn't get a good reason, that would normally be a
     // simple 'is <value>' message. We only add that if the mismatch
     // description is non empty (so we are supplementing the mismatch
     // description).
     if (reason.length == 0 && mismatchDescription.length > 0) {
       mismatchDescription.add('is ').addDescriptionOf(item);
     } else {
       mismatchDescription.add(reason);
     }
     return mismatchDescription;
@@ skipping 26 matching lines @@
           ? escapedItem.length
           : escapedValue.length;
       var start = 0;
       for (; start < minLength; start++) {
         if (escapedValue.codeUnitAt(start) != escapedItem.codeUnitAt(start)) {
           break;
         }
       }
       if (start == minLength) {
         if (escapedValue.length < escapedItem.length) {
-          buff.write(' Both strings start the same, but the given value also'
+          buff.write(' Both strings start the same, but the actual value also'
               ' has the following trailing characters: ');
           _writeTrailing(buff, escapedItem, escapedValue.length);
         } else {
-          buff.write(' Both strings start the same, but the given value is'
+          buff.write(' Both strings start the same, but the actual value is'
               ' missing the following trailing characters: ');
           _writeTrailing(buff, escapedValue, escapedItem.length);
         }
       } else {
         buff.write('\nExpected: ');
         _writeLeading(buff, escapedValue, start);
         _writeTrailing(buff, escapedValue, start);
         buff.write('\n  Actual: ');
         _writeLeading(buff, escapedItem, start);
         _writeTrailing(buff, escapedItem, start);
@@ skipping 28 matching lines @@
 /// A matcher that matches any value.
 const Matcher anything = const _IsAnything();
 
 class _IsAnything extends Matcher {
   const _IsAnything();
   bool matches(item, Map matchState) => true;
   Description describe(Description description) => description.add('anything');
 }
 
 /// Returns a matcher that matches if an object is an instance
-/// of [type] (or a subtype).
+/// of [T] (or a subtype).
 ///
 /// As types are not first class objects in Dart we can only
 /// approximate this test by using a generic wrapper class.
 ///
 /// For example, to test whether 'bar' is an instance of type
 /// 'Foo', we would write:
 ///
 ///     expect(bar, new isInstanceOf<Foo>());
 class isInstanceOf<T> extends Matcher {
   const isInstanceOf();
@@ skipping 146 matching lines @@
     }
     return false;
   }
 
   Description describe(Description description) =>
       description.add('contains ').addDescriptionOf(_expected);
 
   Description describeMismatch(
       item, Description mismatchDescription, Map matchState, bool verbose) {
     if (item is String || item is Iterable || item is Map) {
-      return super.describeMismatch(
-          item, mismatchDescription, matchState, verbose);
+      return super
+          .describeMismatch(item, mismatchDescription, matchState, verbose);
     } else {
       return mismatchDescription.add('is not a string, map or iterable');
     }
   }
 }
 
 /// Returns a matcher that matches if the match argument is in
 /// the expected value. This is the converse of [contains].
 Matcher isIn(expected) => new _In(expected);
 
@@ skipping 64 matching lines @@
   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;
 
   bool matches(item, Map matchState) {
-    var f = featureValueOf(item);
-    if (_matcher.matches(f, matchState)) return true;
-    addStateInfo(matchState, {'feature': f});
+    try {
+      var f = featureValueOf(item);
+      if (_matcher.matches(f, matchState)) return true;
+      addStateInfo(matchState, {'custom.feature': f});
+    } catch (exception, stack) {
+      addStateInfo(matchState, {
+        'custom.exception': exception.toString(),
+        'custom.stack': new Chain.forTrace(stack)
+            .foldFrames(
+                (frame) =>
+                    frame.package == 'test' ||
+                    frame.package == 'stream_channel' ||
+                    frame.package == 'matcher',
+                terse: true)
+            .toString()
+      });
+    }
     return false;
   }
 
   Description describe(Description description) =>
       description.add(_featureDescription).add(' ').addDescriptionOf(_matcher);
 
   Description describeMismatch(
       item, Description mismatchDescription, Map matchState, bool verbose) {
+    if (matchState['custom.exception'] != null) {
+      mismatchDescription
+          .add('threw ')
+          .addDescriptionOf(matchState['custom.exception'])
+          .add('\n')
+          .add(matchState['custom.stack'].toString());
+      return mismatchDescription;
+    }
+
     mismatchDescription
         .add('has ')
         .add(_featureName)
         .add(' with value ')
-        .addDescriptionOf(matchState['feature']);
+        .addDescriptionOf(matchState['custom.feature']);
     var innerDescription = new StringDescription();
-    _matcher.describeMismatch(
-        matchState['feature'], innerDescription, matchState['state'], verbose);
+
+    _matcher.describeMismatch(matchState['custom.feature'], innerDescription,
+        matchState['state'], verbose);
+
     if (innerDescription.length > 0) {
       mismatchDescription.add(' which ').add(innerDescription.toString());
     }
     return mismatchDescription;
   }
 }