Add missing newline after Actual value in fail message.

pkg/unittest/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.
 
 part of matcher;
 
 /**
  * Returns a matcher that matches empty strings, maps or iterables
  * (including collections).
  */
 const Matcher isEmpty = const _Empty();
 
-class _Empty extends BaseMatcher {
+class _Empty extends Matcher {
   const _Empty();
   bool matches(item, Map matchState) {
     if (item is Map || item is Iterable) {
       return item.isEmpty;
     } else if (item is String) {
       return item.length == 0;
     } else {
       return false;
     }
   }
   Description describe(Description description) =>
       description.add('empty');
 }
 
 /** A matcher that matches any null value. */
 const Matcher isNull = const _IsNull();
 
 /** A matcher that matches any non-null value. */
 const Matcher isNotNull = const _IsNotNull();
 
-class _IsNull extends BaseMatcher {
+class _IsNull extends Matcher {
   const _IsNull();
   bool matches(item, Map matchState) => item == null;
   Description describe(Description description) =>
       description.add('null');
 }
 
-class _IsNotNull extends BaseMatcher {
+class _IsNotNull extends Matcher {
   const _IsNotNull();
   bool matches(item, Map matchState) => item != null;
   Description describe(Description description) =>
       description.add('not null');
 }
 
 /** A matcher that matches the Boolean value true. */
 const Matcher isTrue = const _IsTrue();
 
 /** A matcher that matches anything except the Boolean value true. */
 const Matcher isFalse = const _IsFalse();
 
-class _IsTrue extends BaseMatcher {
+class _IsTrue extends Matcher {
   const _IsTrue();
   bool matches(item, Map matchState) => item == true;
   Description describe(Description description) =>
       description.add('true');
 }
 
-class _IsFalse extends BaseMatcher {
+class _IsFalse extends Matcher {
   const _IsFalse();
   bool matches(item, Map matchState) => item == false;
   Description describe(Description description) =>
       description.add('false');
 }
 
 /**
  * Returns a matches that matches if the value is the same instance
  * as [object] (`===`).
  */
 Matcher same(expected) => new _IsSameAs(expected);
 
-class _IsSameAs extends BaseMatcher {
+class _IsSameAs extends Matcher {
   final _expected;
   const _IsSameAs(this._expected);
   bool matches(item, Map matchState) => identical(item, _expected);
   // If all types were hashable we could show a hash here.
   Description describe(Description description) =>
       description.add('same instance as ').addDescriptionOf(_expected);
 }
 
 /**
  * Returns a matcher that does a deep recursive match. This only works
  * with scalars, Maps and Iterables. To handle cyclic structures a
  * recursion depth [limit] can be provided. The default limit is 100.
  */
 Matcher equals(expected, [limit=100]) =>
     expected is String
         ? new _StringEqualsMatcher(expected)
         : new _DeepMatcher(expected, limit);
 
-class _DeepMatcher extends BaseMatcher {
+class _DeepMatcher extends Matcher {
   final _expected;
   final int _limit;
   var count;
 
   _DeepMatcher(this._expected, [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];
@@ skipping 123 matching lines @@
     if (reason.length == 0 && mismatchDescription.length > 0) {
       mismatchDescription.add('is ').addDescriptionOf(item);
     } else {
       mismatchDescription.add(reason);
     }
     return mismatchDescription;
   }
 }
 
 /** A special equality matcher for strings. */
-class _StringEqualsMatcher extends BaseMatcher {
+class _StringEqualsMatcher extends Matcher {
   final String _value;
 
   _StringEqualsMatcher(this._value);
 
   bool get showActualValue => true;
 
   bool matches(item, Map matchState) => _value == item;
 
   Description describe(Description description) =>
       description.addDescriptionOf(_value);
@@ skipping 59 matching lines @@
     } else {
       buff.write(s.substring(start, start + 10));
       buff.write(' ...');
     }
   }
 }
 
 /** A matcher that matches any value. */
 const Matcher anything = const _IsAnything();
 
-class _IsAnything extends BaseMatcher {
+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).
  *
  * 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>());
  *
  * To get better error message, supply a name when creating the
  * Type wrapper; e.g.:
  *
  *     expect(bar, new isInstanceOf<Foo>('Foo'));
  *
  * Note that this does not currently work in dart2js; it will
  * match any type, and isNot(new isInstanceof<T>()) will always
  * fail. This is because dart2js currently ignores template type
  * parameters.
  */
-class isInstanceOf<T> extends BaseMatcher {
+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:
@@ skipping 31 matching lines @@
 
 /**
  * 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 BaseMatcher {
+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());
 
@@ skipping 50 matching lines @@
       mismatchDescription. add('threw ').
           addDescriptionOf(matchState['exception']);
       if (verbose) {
         mismatchDescription.add(' at ').add(matchState['stack'].toString());
       }
       return mismatchDescription;
     }
   }
 }
 
-class _ReturnsNormally extends BaseMatcher {
+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 27 matching lines @@
  *
  * bool _isException(x) => x is Exception;
  * final Matcher isException = const _Predicate(_isException, "Exception");
  * final Matcher throwsException = const _Throws(isException);
  *
  * But currently using static functions in const expressions is not supported.
  * For now the only solution for all platforms seems to be separate classes
  * for each exception type.
  */
 
-abstract class TypeMatcher extends BaseMatcher {
+abstract class TypeMatcher extends Matcher {
   final String _name;
   const TypeMatcher(this._name);
   Description describe(Description description) =>
       description.add(_name);
 }
 
 /** A matcher for FormatExceptions. */
 const isFormatException = const _FormatException();
 
 /** A matcher for functions that throw FormatException. */
@@ skipping 105 matching lines @@
   bool matches(item, Map matchState) => item is List;
 }
 
 /**
  * Returns a matcher that matches if an object has a length property
  * that matches [matcher].
  */
 Matcher hasLength(matcher) =>
     new _HasLength(wrapMatcher(matcher));
 
-class _HasLength extends BaseMatcher {
+class _HasLength extends Matcher {
   final Matcher _matcher;
   const _HasLength([Matcher matcher = null]) : this._matcher = matcher;
 
   bool matches(item, Map matchState) {
     try {
       // This is harmless code that will throw if no length property
       // but subtle enough that an optimizer shouldn't strip it out.
       if (item.length * item.length >= 0) {
         return _matcher.matches(item.length, matchState);
       }
@@ skipping 24 matching lines @@
 /**
  * Returns a matcher that matches if the match argument contains
  * the expected value. For [String]s this means substring matching;
  * for [Map]s it means the map has the key, and for [Iterable]s
  * (including [Iterable]s) it means the iterable has a matching
  * element. In the case of iterables, [expected] can itself be a
  * matcher.
  */
 Matcher contains(expected) => new _Contains(expected);
 
-class _Contains extends BaseMatcher {
+class _Contains extends Matcher {
 
   final _expected;
 
   const _Contains(this._expected);
 
   bool matches(item, Map matchState) {
     if (item is String) {
       return item.indexOf(_expected) >= 0;
     } else if (item is Iterable) {
       if (_expected is Matcher) {
@@ skipping 20 matching lines @@
     }
   }
 }
 
 /**
  * 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);
 
-class _In extends BaseMatcher {
+class _In extends Matcher {
 
   final _expected;
 
   const _In(this._expected);
 
   bool matches(item, Map matchState) {
     if (_expected is String) {
       return _expected.indexOf(item) >= 0;
     } else if (_expected is Iterable) {
       return _expected.any((e) => e == item);
     } else if (_expected is Map) {
       return _expected.containsKey(item);
     }
     return false;
   }
 
   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(Function f, [description ='satisfies function']) =>
     new _Predicate(f, description);
 
-class _Predicate extends BaseMatcher {
+class _Predicate extends Matcher {
 
   final Function _matcher;
   final String _description;
 
   const _Predicate(this._matcher, this._description);
 
   bool matches(item, Map matchState) => _matcher(item);
 
   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
  * FeatureMatcher that can make assertions about prices with:
  *
- *     class HasPrice extends FeatureMatcher {
+ *     class HasPrice extends CustomMatcher {
  *       const 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)));
  */
-class CustomMatcher extends BaseMatcher {
+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 14 matching lines @@
     var innerDescription = new StringDescription();
     _matcher.describeMismatch(matchState['feature'], innerDescription,
         matchState['state'], verbose);
     if (innerDescription.length > 0) {
       mismatchDescription.add(' which ').add(innerDescription.toString());
     }
     return mismatchDescription;
   }
 }