pkg/unittest: dartfmt

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 unittest.matcher;
 
 /**
  * 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;
     } else if (item is String) {
       return item.length == 0;
     } else {
       return false;
     }
   }
-  Description describe(Description description) =>
-      description.add('empty');
+  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 Matcher {
   const _IsNull();
   bool matches(item, Map matchState) => item == null;
-  Description describe(Description description) =>
-      description.add('null');
+  Description describe(Description description) => description.add('null');
 }
 
 class _IsNotNull extends Matcher {
   const _IsNotNull();
   bool matches(item, Map matchState) => item != null;
-  Description describe(Description description) =>
-      description.add('not 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 Matcher {
   const _IsTrue();
   bool matches(item, Map matchState) => item == true;
-  Description describe(Description description) =>
-      description.add('true');
+  Description describe(Description description) => description.add('true');
 }
 
 class _IsFalse extends Matcher {
   const _IsFalse();
   bool matches(item, Map matchState) => item == false;
-  Description describe(Description description) =>
-      description.add('false');
+  Description describe(Description description) => description.add('false');
 }
 
 /**
  * Returns a matches that matches if the value is the same instance
  * as [expected], using [identical].
  */
 Matcher same(expected) => new _IsSameAs(expected);
 
 class _IsSameAs extends Matcher {
   final _expected;
@@ skipping 18 matching lines @@
 Matcher equals(expected, [limit=100]) =>
     expected is String
         ? new _StringEqualsMatcher(expected)
         : new _DeepMatcher(expected, limit);
 
 class _DeepMatcher extends Matcher {
   final _expected;
   final int _limit;
   var count;
 
-  _DeepMatcher(this._expected, [limit = 1000]) : this._limit = limit;
+  _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];
 
     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 194 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');
+  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 Matcher {
   final String _name;
-  const isInstanceOf([name = 'specified type']) : this._name = 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
@@ skipping 32 matching lines @@
  * 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;
+  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'."));
@@ skipping 96 matching lines @@
  * 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 Matcher {
   final String _name;
   const TypeMatcher(this._name);
-  Description describe(Description description) =>
-      description.add(_name);
+  Description describe(Description description) => description.add(_name);
 }
 
 /** A matcher for FormatExceptions. */
 const isFormatException = const _FormatException();
 
 /** A matcher for functions that throw FormatException. */
-const Matcher throwsFormatException =
-    const Throws(isFormatException);
+const Matcher throwsFormatException = const Throws(isFormatException);
 
 class _FormatException extends TypeMatcher {
-  const _FormatException() : super("FormatException");
+  const _FormatException(): super("FormatException");
   bool matches(item, Map matchState) => item is FormatException;
 }
 
 /** A matcher for Exceptions. */
 const isException = const _Exception();
 
 /** A matcher for functions that throw Exception. */
 const Matcher throwsException = const Throws(isException);
 
 class _Exception extends TypeMatcher {
-  const _Exception() : super("Exception");
+  const _Exception(): super("Exception");
   bool matches(item, Map matchState) => item is Exception;
 }
 
 /** A matcher for ArgumentErrors. */
 const isArgumentError = const _ArgumentError();
 
 /** A matcher for functions that throw ArgumentError. */
-const Matcher throwsArgumentError =
-    const Throws(isArgumentError);
+const Matcher throwsArgumentError = const Throws(isArgumentError);
 
 class _ArgumentError extends TypeMatcher {
-  const _ArgumentError() : super("ArgumentError");
+  const _ArgumentError(): super("ArgumentError");
   bool matches(item, Map matchState) => item is ArgumentError;
 }
 
 /** A matcher for RangeErrors. */
 const isRangeError = const _RangeError();
 
 /** A matcher for functions that throw RangeError. */
-const Matcher throwsRangeError =
-    const Throws(isRangeError);
+const Matcher throwsRangeError = const Throws(isRangeError);
 
 class _RangeError extends TypeMatcher {
-  const _RangeError() : super("RangeError");
+  const _RangeError(): super("RangeError");
   bool matches(item, Map matchState) => item is RangeError;
 }
 
 /** A matcher for NoSuchMethodErrors. */
 const isNoSuchMethodError = const _NoSuchMethodError();
 
 /** A matcher for functions that throw NoSuchMethodError. */
-const Matcher throwsNoSuchMethodError =
-    const Throws(isNoSuchMethodError);
+const Matcher throwsNoSuchMethodError = const Throws(isNoSuchMethodError);
 
 class _NoSuchMethodError extends TypeMatcher {
-  const _NoSuchMethodError() : super("NoSuchMethodError");
+  const _NoSuchMethodError(): super("NoSuchMethodError");
   bool matches(item, Map matchState) => item is NoSuchMethodError;
 }
 
 /** A matcher for UnimplementedErrors. */
 const isUnimplementedError = const _UnimplementedError();
 
 /** A matcher for functions that throw Exception. */
-const Matcher throwsUnimplementedError =
-    const Throws(isUnimplementedError);
+const Matcher throwsUnimplementedError = const Throws(isUnimplementedError);
 
 class _UnimplementedError extends TypeMatcher {
-  const _UnimplementedError() : super("UnimplementedError");
+  const _UnimplementedError(): super("UnimplementedError");
   bool matches(item, Map matchState) => item is UnimplementedError;
 }
 
 /** A matcher for UnsupportedError. */
 const isUnsupportedError = const _UnsupportedError();
 
 /** A matcher for functions that throw UnsupportedError. */
 const Matcher throwsUnsupportedError = const Throws(isUnsupportedError);
 
 class _UnsupportedError extends TypeMatcher {
-  const _UnsupportedError() :
-      super("UnsupportedError");
+  const _UnsupportedError(): super("UnsupportedError");
   bool matches(item, Map matchState) => item is UnsupportedError;
 }
 
 /** A matcher for StateErrors. */
 const isStateError = const _StateError();
 
 /** A matcher for functions that throw StateError. */
-const Matcher throwsStateError =
-    const Throws(isStateError);
+const Matcher throwsStateError = const Throws(isStateError);
 
 class _StateError extends TypeMatcher {
-  const _StateError() : super("StateError");
+  const _StateError(): super("StateError");
   bool matches(item, Map matchState) => item is StateError;
 }
 
 /** A matcher for FallThroughError. */
 const isFallThroughError = const _FallThroughError();
 
 /** A matcher for functions that throw FallThroughError. */
-const Matcher throwsFallThroughError =
-    const Throws(isFallThroughError);
+const Matcher throwsFallThroughError = const Throws(isFallThroughError);
 
 class _FallThroughError extends TypeMatcher {
-  const _FallThroughError() : super("FallThroughError");
+  const _FallThroughError(): super("FallThroughError");
   bool matches(item, Map matchState) => item is FallThroughError;
 }
 
 /** A matcher for NullThrownError. */
 const isNullThrownError = const _NullThrownError();
 
 /** A matcher for functions that throw NullThrownError. */
-const Matcher throwsNullThrownError =
-    const Throws(isNullThrownError);
+const Matcher throwsNullThrownError = const Throws(isNullThrownError);
 
 class _NullThrownError extends TypeMatcher {
-  const _NullThrownError() : super("NullThrownError");
+  const _NullThrownError(): super("NullThrownError");
   bool matches(item, Map matchState) => item is NullThrownError;
 }
 
 /** A matcher for ConcurrentModificationError. */
 const isConcurrentModificationError = const _ConcurrentModificationError();
 
 /** A matcher for functions that throw ConcurrentModificationError. */
 const Matcher throwsConcurrentModificationError =
     const Throws(isConcurrentModificationError);
 
 class _ConcurrentModificationError extends TypeMatcher {
-  const _ConcurrentModificationError() : super("ConcurrentModificationError");
+  const _ConcurrentModificationError(): super("ConcurrentModificationError");
   bool matches(item, Map matchState) => item is ConcurrentModificationError;
 }
 
 /** A matcher for AbstractClassInstantiationError. */
 const isAbstractClassInstantiationError =
     const _AbstractClassInstantiationError();
 
 /** A matcher for functions that throw AbstractClassInstantiationError. */
 const Matcher throwsAbstractClassInstantiationError =
     const Throws(isAbstractClassInstantiationError);
 
 class _AbstractClassInstantiationError extends TypeMatcher {
   const _AbstractClassInstantiationError() :
   super("AbstractClassInstantiationError");
   bool matches(item, Map matchState) => item is AbstractClassInstantiationError;
 }
 
 /** A matcher for CyclicInitializationError. */
 const isCyclicInitializationError = const _CyclicInitializationError();
 
 /** A matcher for functions that throw CyclicInitializationError. */
 const Matcher throwsCyclicInitializationError =
     const Throws(isCyclicInitializationError);
 
 class _CyclicInitializationError extends TypeMatcher {
-  const _CyclicInitializationError() : super("CyclicInitializationError");
+  const _CyclicInitializationError(): super("CyclicInitializationError");
   bool matches(item, Map matchState) => item is CyclicInitializationError;
 }
 
 /** A matcher for Map types. */
 const isMap = const _IsMap();
 
 class _IsMap extends TypeMatcher {
-  const _IsMap() : super("Map");
+  const _IsMap(): super("Map");
   bool matches(item, Map matchState) => item is Map;
 }
 
 /** A matcher for List types. */
 const isList = const _IsList();
 
 class _IsList extends TypeMatcher {
-  const _IsList() : super("List");
+  const _IsList(): super("List");
   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));
+Matcher hasLength(matcher) => new _HasLength(wrapMatcher(matcher));
 
 class _HasLength extends Matcher {
   final Matcher _matcher;
-  const _HasLength([Matcher matcher = null]) : this._matcher = matcher;

[Siggi Cherem (dart-lang), 2014/03/21 20:00:45]

btw - I'm not sure I agree with this one, I filed: dartbug.com/17642

[kevmoo, 2014/03/21 20:13:02]

Good to have the bug. Being consistent is the most important bit.

+  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);
       }
     } catch (e) {
       return false;
@@ skipping 90 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(Function f, [description ='satisfies function']) =>
+Matcher predicate(Function f, [description = 'satisfies function']) =>
     new _Predicate(f, description);
 
 class _Predicate extends Matcher {
 
   final Function _matcher;
   final String _description;
 
   const _Predicate(this._matcher, this._description);
 
   bool matches(item, Map matchState) => _matcher(item);
@@ skipping 50 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;
   }
 }