diff --git a/.status b/.status
index 2c78d67..d5b5794 100644
--- a/.status
+++ b/.status
@@ -4,21 +4,11 @@
 
 # Skip non-test files ending with "_test".
 packages/*: Skip
-packages/*: Skip
 */packages/*: Skip
 */*/packages/*: Skip
 */*/*/packages/*: Skip
 */*/*/*packages/*: Skip
 */*/*/*/*packages/*: Skip
-*/*/packages/*: Skip
-*/*/packages/*: Skip
-*/packages/*: Skip
-*/*/packages/*: Skip
-*/*/*/packages/*: Skip
-*/*/*/*packages/*: Skip
-*/*/*/*/*packages/*: Skip
-*/*/*/*packages/*: Skip
-*/*/*/*/*packages/*: Skip
 
 # Only run tests from the build directory, since we don't care about the
 # difference between transformed an untransformed code.
@@ -34,4 +24,4 @@
 # The minified matcher tests test that the minified names of Dart types are
 # printed. Unminified versions of these tests exist that test the behavior when
 # not minified.
-matcher/test/*_minified_test: Skip # DO NOT COPY THIS UNLESS YOU WORK ON DART2JS
+*_minified_test: Skip # DO NOT COPY THIS UNLESS YOU WORK ON DART2JS
diff --git a/README.md b/README.md
index cf165c1..beff308 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,7 @@
 Support for specifying test expectations, such as for unit tests.
 
 The matcher library provides a third-generation assertion mechanism, drawing
-inspiration from [Hamcrest](http://code.google.com/p/hamcrest/).
+inspiration from [Hamcrest](https://code.google.com/p/hamcrest/).
 
 For more information, see
-[Unit Testing with Dart](http://www.dartlang.org/articles/dart-unit-tests/).
+[Unit Testing with Dart](https://www.dartlang.org/articles/dart-unit-tests/).
diff --git a/codereview.settings b/codereview.settings
index 22ad841..2fd4dde 100644
--- a/codereview.settings
+++ b/codereview.settings
@@ -1,3 +1,3 @@
-CODE_REVIEW_SERVER: http://codereview.chromium.org/
+CODE_REVIEW_SERVER: https://codereview.chromium.org/
 VIEW_VC: https://github.com/dart-lang/matcher/commit/
 CC_LIST: reviews@dartlang.org
\ No newline at end of file
diff --git a/lib/mirror_matchers.dart b/lib/mirror_matchers.dart
index f397128..d244831 100644
--- a/lib/mirror_matchers.dart
+++ b/lib/mirror_matchers.dart
@@ -14,7 +14,7 @@
 /// with name [name], and optionally, if that property in turn satisfies
 /// a [matcher].
 Matcher hasProperty(String name, [matcher]) =>
-  new _HasProperty(name, matcher == null ? null : wrapMatcher(matcher));
+    new _HasProperty(name, matcher == null ? null : wrapMatcher(matcher));
 
 class _HasProperty extends Matcher {
   final String _name;
@@ -35,8 +35,10 @@
     bool isInstanceGetter =
         candidate is MethodMirror && candidate.isGetter && !candidate.isStatic;
     if (!(isInstanceField || isInstanceGetter)) {
-      addStateInfo(matchState, {'reason':
-          'has a member named "$_name", but it is not an instance property'});
+      addStateInfo(matchState, {
+        'reason':
+            'has a member named "$_name", but it is not an instance property'
+      });
       return false;
     }
     if (_matcher == null) return true;
@@ -56,17 +58,18 @@
     return description;
   }
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     var reason = matchState == null ? null : matchState['reason'];
     if (reason != null) {
       mismatchDescription.add(reason);
     } else {
-      mismatchDescription.add('has property "$_name" with value ').
-        addDescriptionOf(matchState['value']);
+      mismatchDescription
+          .add('has property "$_name" with value ')
+          .addDescriptionOf(matchState['value']);
       var innerDescription = new StringDescription();
-      _matcher.describeMismatch(matchState['value'], innerDescription,
-          matchState['state'], verbose);
+      _matcher.describeMismatch(
+          matchState['value'], innerDescription, matchState['state'], verbose);
       if (innerDescription.length > 0) {
         mismatchDescription.add(' which ').add(innerDescription.toString());
       }
diff --git a/lib/src/core_matchers.dart b/lib/src/core_matchers.dart
index a8ae365..abecb76 100644
--- a/lib/src/core_matchers.dart
+++ b/lib/src/core_matchers.dart
@@ -106,10 +106,9 @@
 /// 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);
+Matcher equals(expected, [int limit = 100]) => expected is String
+    ? new _StringEqualsMatcher(expected)
+    : new _DeepMatcher(expected, limit);
 
 class _DeepMatcher extends Matcher {
   final _expected;
@@ -138,8 +137,8 @@
       if (!actualNext) return ['shorter than expected', newLocation];
 
       // Match the elements.
-      var rp = matcher(expectedIterator.current, actualIterator.current,
-          newLocation, depth);
+      var rp = matcher(
+          expectedIterator.current, actualIterator.current, newLocation, depth);
       if (rp != null) return rp;
     }
   }
@@ -177,7 +176,7 @@
       // Otherwise, test for equality.
       try {
         if (expected == actual) return null;
-      } catch (e, s) {
+      } catch (e) {
         // TODO(gram): Add a test for this case.
         return ['== threw "$e"', location];
       }
@@ -188,16 +187,17 @@
     // 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);
+        return _compareSets(
+            expected, actual, _recursiveMatch, depth + 1, location);
       } else if (expected is Iterable) {
-        return _compareIterables(expected, actual, _recursiveMatch, depth + 1,
-            location);
+        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 err = (expected.length == actual.length)
+            ? ''
+            : 'has different length and ';
         for (var key in expected.keys) {
           if (!actual.containsKey(key)) {
             return ["${err}is missing map key '$key'", location];
@@ -211,8 +211,8 @@
         }
 
         for (var key in expected.keys) {
-          var rp = _recursiveMatch(expected[key], actual[key],
-              "${location}['${key}']", depth + 1);
+          var rp = _recursiveMatch(
+              expected[key], actual[key], "${location}['${key}']", depth + 1);
           if (rp != null) return rp;
         }
 
@@ -225,10 +225,11 @@
     // 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);
+      description
+          .add('was ')
+          .addDescriptionOf(actual)
+          .add(' instead of ')
+          .addDescriptionOf(expected);
       return [description.toString(), location];
     }
 
@@ -258,10 +259,10 @@
       _match(_expected, item, matchState) == null;
 
   Description describe(Description description) =>
-    description.addDescriptionOf(_expected);
+      description.addDescriptionOf(_expected);
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     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
@@ -289,8 +290,8 @@
   Description describe(Description description) =>
       description.addDescriptionOf(_value);
 
-  Description describeMismatch(item, Description mismatchDescription,
-      Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     if (item is! String) {
       return mismatchDescription.addDescriptionOf(item).add('is not a string');
     } else {
@@ -298,8 +299,9 @@
       buff.write('is different.');
       var escapedItem = _escape(item);
       var escapedValue = _escape(_value);
-      int minLength = escapedItem.length < escapedValue.length ?
-          escapedItem.length : escapedValue.length;
+      int minLength = escapedItem.length < escapedValue.length
+          ? escapedItem.length
+          : escapedValue.length;
       int start;
       for (start = 0; start < minLength; start++) {
         if (escapedValue.codeUnitAt(start) != escapedItem.codeUnitAt(start)) {
@@ -416,9 +418,8 @@
   Description describe(Description description) =>
       description.add("return normally");
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState,
-                               bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     mismatchDescription.add('threw ').addDescriptionOf(matchState['exception']);
     if (verbose) {
       mismatchDescription.add(' at ').add(matchState['stack'].toString());
@@ -490,17 +491,17 @@
   }
 
   Description describe(Description description) =>
-    description.add('an object with length of ').
-        addDescriptionOf(_matcher);
+      description.add('an object with length of ').addDescriptionOf(_matcher);
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     try {
       // We want to generate a different description if there is no length
       // property; we use the same trick as in matches().
       if (item.length * item.length >= 0) {
-        return mismatchDescription.add('has length of ').
-            addDescriptionOf(item.length);
+        return mismatchDescription
+            .add('has length of ')
+            .addDescriptionOf(item.length);
       }
     } catch (e) {}
     return mismatchDescription.add('has no length property');
@@ -539,11 +540,11 @@
   Description describe(Description description) =>
       description.add('contains ').addDescriptionOf(_expected);
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  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');
     }
@@ -637,13 +638,16 @@
   Description describe(Description description) =>
       description.add(_featureDescription).add(' ').addDescriptionOf(_matcher);
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
-    mismatchDescription.add('has ').add(_featureName).add(' with value ').
-        addDescriptionOf(matchState['feature']);
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
+    mismatchDescription
+        .add('has ')
+        .add(_featureName)
+        .add(' with value ')
+        .addDescriptionOf(matchState['feature']);
     var innerDescription = new StringDescription();
-    _matcher.describeMismatch(matchState['feature'], innerDescription,
-        matchState['state'], verbose);
+    _matcher.describeMismatch(
+        matchState['feature'], innerDescription, matchState['state'], verbose);
     if (innerDescription.length > 0) {
       mismatchDescription.add(' which ').add(innerDescription.toString());
     }
diff --git a/lib/src/description.dart b/lib/src/description.dart
index f03934d..1da5a3a 100644
--- a/lib/src/description.dart
+++ b/lib/src/description.dart
@@ -51,8 +51,8 @@
   /// Append an [Iterable] [list] of objects to the description, using the
   /// specified [separator] and framing the list with [start]
   /// and [end].
-  Description addAll(String start, String separator, String end,
-                       Iterable list) {
+  Description addAll(
+      String start, String separator, String end, Iterable list) {
     var separate = false;
     add(start);
     for (var item in list) {
diff --git a/lib/src/error_matchers.dart b/lib/src/error_matchers.dart
index fd0445c..821e731 100644
--- a/lib/src/error_matchers.dart
+++ b/lib/src/error_matchers.dart
@@ -11,7 +11,7 @@
 const Matcher isArgumentError = const _ArgumentError();
 
 class _ArgumentError extends TypeMatcher {
-  const _ArgumentError(): super("ArgumentError");
+  const _ArgumentError() : super("ArgumentError");
   bool matches(item, Map matchState) => item is ArgumentError;
 }
 
@@ -20,7 +20,7 @@
     const _ConcurrentModificationError();
 
 class _ConcurrentModificationError extends TypeMatcher {
-  const _ConcurrentModificationError(): super("ConcurrentModificationError");
+  const _ConcurrentModificationError() : super("ConcurrentModificationError");
   bool matches(item, Map matchState) => item is ConcurrentModificationError;
 }
 
@@ -28,7 +28,7 @@
 const Matcher isCyclicInitializationError = const _CyclicInitializationError();
 
 class _CyclicInitializationError extends TypeMatcher {
-  const _CyclicInitializationError(): super("CyclicInitializationError");
+  const _CyclicInitializationError() : super("CyclicInitializationError");
   bool matches(item, Map matchState) => item is CyclicInitializationError;
 }
 
@@ -36,20 +36,15 @@
 const Matcher isException = const _Exception();
 
 class _Exception extends TypeMatcher {
-  const _Exception(): super("Exception");
+  const _Exception() : super("Exception");
   bool matches(item, Map matchState) => item is Exception;
 }
 
-class _FallThroughError extends TypeMatcher {
-  const _FallThroughError(): super("FallThroughError");
-  bool matches(item, Map matchState) => item is FallThroughError;
-}
-
 /// A matcher for FormatExceptions.
 const Matcher isFormatException = const _FormatException();
 
 class _FormatException extends TypeMatcher {
-  const _FormatException(): super("FormatException");
+  const _FormatException() : super("FormatException");
   bool matches(item, Map matchState) => item is FormatException;
 }
 
@@ -57,7 +52,7 @@
 const Matcher isNoSuchMethodError = const _NoSuchMethodError();
 
 class _NoSuchMethodError extends TypeMatcher {
-  const _NoSuchMethodError(): super("NoSuchMethodError");
+  const _NoSuchMethodError() : super("NoSuchMethodError");
   bool matches(item, Map matchState) => item is NoSuchMethodError;
 }
 
@@ -65,7 +60,7 @@
 const Matcher isNullThrownError = const _NullThrownError();
 
 class _NullThrownError extends TypeMatcher {
-  const _NullThrownError(): super("NullThrownError");
+  const _NullThrownError() : super("NullThrownError");
   bool matches(item, Map matchState) => item is NullThrownError;
 }
 
@@ -73,7 +68,7 @@
 const Matcher isRangeError = const _RangeError();
 
 class _RangeError extends TypeMatcher {
-  const _RangeError(): super("RangeError");
+  const _RangeError() : super("RangeError");
   bool matches(item, Map matchState) => item is RangeError;
 }
 
@@ -81,7 +76,7 @@
 const Matcher isStateError = const _StateError();
 
 class _StateError extends TypeMatcher {
-  const _StateError(): super("StateError");
+  const _StateError() : super("StateError");
   bool matches(item, Map matchState) => item is StateError;
 }
 
@@ -89,7 +84,7 @@
 const Matcher isUnimplementedError = const _UnimplementedError();
 
 class _UnimplementedError extends TypeMatcher {
-  const _UnimplementedError(): super("UnimplementedError");
+  const _UnimplementedError() : super("UnimplementedError");
   bool matches(item, Map matchState) => item is UnimplementedError;
 }
 
@@ -97,6 +92,6 @@
 const Matcher isUnsupportedError = const _UnsupportedError();
 
 class _UnsupportedError extends TypeMatcher {
-  const _UnsupportedError(): super("UnsupportedError");
+  const _UnsupportedError() : super("UnsupportedError");
   bool matches(item, Map matchState) => item is UnsupportedError;
 }
diff --git a/lib/src/expect.dart b/lib/src/expect.dart
index 1bfa36e..08eb68e 100644
--- a/lib/src/expect.dart
+++ b/lib/src/expect.dart
@@ -32,8 +32,8 @@
   /// some cases how much [matchState] information is used. It will use
   /// these to create a detailed error message (typically by calling
   /// an [ErrorFormatter]) and then call [fail] with this message.
-  void failMatch(actual, Matcher matcher, String reason,
-                 Map matchState, bool verbose);
+  void failMatch(
+      actual, Matcher matcher, String reason, Map matchState, bool verbose);
 }
 
 /// The ErrorFormatter type is used for functions that
@@ -42,8 +42,8 @@
 /// which is used by the default failure handler. If the failure handler
 /// is replaced it may be desirable to replace the [stringDescription]
 /// error formatter with another.
-typedef String ErrorFormatter(actual, Matcher matcher, String reason,
-  Map matchState, bool verbose);
+typedef String ErrorFormatter(
+    actual, Matcher matcher, String reason, Map matchState, bool verbose);
 
 /// This Function is used by certain Matchers to catch certain exceptions.
 ///
@@ -75,8 +75,8 @@
 /// In some cases extra diagnostic info can be produced on failure (for
 /// example, stack traces on mismatched exceptions). To enable these,
 /// [verbose] should be specified as true;
-void expect(actual, matcher, {String reason, FailureHandler failureHandler,
-            bool verbose : false}) {
+void expect(actual, matcher,
+    {String reason, FailureHandler failureHandler, bool verbose: false}) {
   matcher = wrapMatcher(matcher);
   bool doesMatch;
   var matchState = {};
@@ -116,8 +116,8 @@
   void fail(String reason) {
     throw new TestFailure(reason);
   }
-  void failMatch(actual, Matcher matcher, String reason,
-      Map matchState, bool verbose) {
+  void failMatch(
+      actual, Matcher matcher, String reason, Map matchState, bool verbose) {
     fail(_assertErrorFormatter(actual, matcher, reason, matchState, verbose));
   }
 }
@@ -145,8 +145,8 @@
 ErrorFormatter _assertErrorFormatter = null;
 
 // The default error formatter implementation.
-String _defaultErrorFormatter(actual, Matcher matcher, String reason,
-    Map matchState, bool verbose) {
+String _defaultErrorFormatter(
+    actual, Matcher matcher, String reason, Map matchState, bool verbose) {
   var description = new StringDescription();
   description.add('Expected: ').addDescriptionOf(matcher).add('\n');
   description.add('  Actual: ').addDescriptionOf(actual).add('\n');
diff --git a/lib/src/future_matchers.dart b/lib/src/future_matchers.dart
index 615b588..bdbd62f 100644
--- a/lib/src/future_matchers.dart
+++ b/lib/src/future_matchers.dart
@@ -46,11 +46,13 @@
     var done = wrapAsync((fn) => fn(), _id);
 
     item.then((value) {
-      done(() { if (_matcher != null) expect(value, _matcher); });
+      done(() {
+        if (_matcher != null) expect(value, _matcher);
+      });
     }, onError: (error, trace) {
       var id = _id == '' ? '' : '${_id} ';
       var reason = 'Expected future ${id}to complete successfully, '
-                   'but it failed with ${error}';
+          'but it failed with ${error}';
       if (trace != null) {
         var stackTrace = trace.toString();
         stackTrace = '  ${stackTrace.replaceAll('\n', '\n  ')}';
diff --git a/lib/src/interfaces.dart b/lib/src/interfaces.dart
index f3f0755..984d862 100644
--- a/lib/src/interfaces.dart
+++ b/lib/src/interfaces.dart
@@ -54,6 +54,7 @@
   /// A few matchers make use of the [verbose] flag to provide detailed
   /// information that is not typically included but can be of help in
   /// diagnosing failures, such as stack traces.
-  Description describeMismatch(item, Description mismatchDescription,
-      Map matchState, bool verbose) => mismatchDescription;
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) =>
+      mismatchDescription;
 }
diff --git a/lib/src/iterable_matchers.dart b/lib/src/iterable_matchers.dart
index 60ef32d..118575a 100644
--- a/lib/src/iterable_matchers.dart
+++ b/lib/src/iterable_matchers.dart
@@ -36,16 +36,18 @@
   Description describe(Description description) =>
       description.add('every element(').addDescriptionOf(_matcher).add(')');
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     if (matchState['index'] != null) {
       var index = matchState['index'];
       var element = matchState['element'];
-      mismatchDescription.add('has value ').addDescriptionOf(element).
-          add(' which ');
+      mismatchDescription
+          .add('has value ')
+          .addDescriptionOf(element)
+          .add(' which ');
       var subDescription = new StringDescription();
-      _matcher.describeMismatch(element, subDescription, matchState['state'],
-          verbose);
+      _matcher.describeMismatch(
+          element, subDescription, matchState['state'], verbose);
       if (subDescription.length > 0) {
         mismatchDescription.add(subDescription.toString());
       } else {
@@ -55,8 +57,8 @@
       mismatchDescription.add(' at index $index');
       return mismatchDescription;
     }
-    return super.describeMismatch(item, mismatchDescription,
-          matchState, verbose);
+    return super.describeMismatch(
+        item, mismatchDescription, matchState, verbose);
   }
 }
 
@@ -97,13 +99,13 @@
   Description describe(Description description) =>
       description.add('equals ').addDescriptionOf(_expected).add(' ordered');
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
-    if (item is !Iterable) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
+    if (item is! Iterable) {
       return mismatchDescription.add('is not an Iterable');
     } else {
-      return _matcher.describeMismatch(item, mismatchDescription,
-          matchState, verbose);
+      return _matcher.describeMismatch(
+          item, mismatchDescription, matchState, verbose);
     }
   }
 }
@@ -121,26 +123,23 @@
       : super(expected.map(equals)),
         _expectedValues = expected.toList();
 
-  Description describe(Description description) =>
-    description
-        .add('equals ')
-        .addDescriptionOf(_expectedValues)
-        .add(' unordered');
+  Description describe(Description description) => description
+      .add('equals ')
+      .addDescriptionOf(_expectedValues)
+      .add(' unordered');
 }
 
 /// Iterable matchers match against [Iterable]s. We add this intermediate
 /// class to give better mismatch error messages than the base Matcher class.
 abstract class _IterableMatcher extends Matcher {
   const _IterableMatcher();
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     if (item is! Iterable) {
-      return mismatchDescription.
-          addDescriptionOf(item).
-          add(' not an Iterable');
+      return mismatchDescription.addDescriptionOf(item).add(' not an Iterable');
     } else {
-      return super.describeMismatch(item, mismatchDescription, matchState,
-          verbose);
+      return super.describeMismatch(
+          item, mismatchDescription, matchState, verbose);
     }
   }
 }
@@ -198,14 +197,13 @@
 
   bool matches(item, Map mismatchState) => _test(item) == null;
 
-  Description describe(Description description) =>
-    description
+  Description describe(Description description) => description
       .add('matches ')
       .addAll('[', ', ', ']', _expected)
       .add(' unordered');
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) =>
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) =>
       mismatchDescription.add(_test(item));
 }
 
@@ -214,8 +212,8 @@
 /// The [comparator] function, taking an expected and an actual argument, and
 /// returning whether they match, will be applied to each pair in order.
 /// [description] should be a meaningful name for the comparator.
-Matcher pairwiseCompare(Iterable expected, bool comparator(a, b),
-    String description) =>
+Matcher pairwiseCompare(
+    Iterable expected, bool comparator(a, b), String description) =>
         new _PairwiseCompare(expected, comparator, description);
 
 typedef bool _Comparator(a, b);
@@ -235,8 +233,11 @@
     for (var e in _expected) {
       iterator.moveNext();
       if (!_comparator(e, iterator.current)) {
-        addStateInfo(matchState, {'index': i, 'expected': e,
-            'actual': iterator.current});
+        addStateInfo(matchState, {
+          'index': i,
+          'expected': e,
+          'actual': iterator.current
+        });
         return false;
       }
       i++;
@@ -247,20 +248,20 @@
   Description describe(Description description) =>
       description.add('pairwise $_description ').addDescriptionOf(_expected);
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
-    if (item is !Iterable) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
+    if (item is! Iterable) {
       return mismatchDescription.add('is not an Iterable');
     } else if (item.length != _expected.length) {
-      return mismatchDescription.
-          add('has length ${item.length} instead of ${_expected.length}');
+      return mismatchDescription
+          .add('has length ${item.length} instead of ${_expected.length}');
     } else {
-      return mismatchDescription.
-          add('has ').
-          addDescriptionOf(matchState["actual"]).
-          add(' which is not $_description ').
-          addDescriptionOf(matchState["expected"]).
-          add(' at index ${matchState["index"]}');
+      return mismatchDescription
+          .add('has ')
+          .addDescriptionOf(matchState["actual"])
+          .add(' which is not $_description ')
+          .addDescriptionOf(matchState["expected"])
+          .add(' at index ${matchState["index"]}');
     }
   }
 }
diff --git a/lib/src/map_matchers.dart b/lib/src/map_matchers.dart
index 623b380..8facbf5 100644
--- a/lib/src/map_matchers.dart
+++ b/lib/src/map_matchers.dart
@@ -32,24 +32,29 @@
   const _ContainsMapping(this._key, Matcher this._valueMatcher);
 
   bool matches(item, Map matchState) =>
-      item.containsKey(_key) &&
-      _valueMatcher.matches(item[_key], matchState);
+      item.containsKey(_key) && _valueMatcher.matches(item[_key], matchState);
 
   Description describe(Description description) {
-    return description.add('contains pair ').addDescriptionOf(_key).
-          add(' => ').addDescriptionOf(_valueMatcher);
+    return description
+        .add('contains pair ')
+        .addDescriptionOf(_key)
+        .add(' => ')
+        .addDescriptionOf(_valueMatcher);
   }
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     if (!item.containsKey(_key)) {
-      return mismatchDescription.add(" doesn't contain key ")
+      return mismatchDescription
+          .add(" doesn't contain key ")
           .addDescriptionOf(_key);
     } else {
-      mismatchDescription.add(' contains key ').addDescriptionOf(_key).
-          add(' but with value ');
-      _valueMatcher.describeMismatch(item[_key], mismatchDescription,
-          matchState, verbose);
+      mismatchDescription
+          .add(' contains key ')
+          .addDescriptionOf(_key)
+          .add(' but with value ');
+      _valueMatcher.describeMismatch(
+          item[_key], mismatchDescription, matchState, verbose);
       return mismatchDescription;
     }
   }
diff --git a/lib/src/numeric_matchers.dart b/lib/src/numeric_matchers.dart
index 03134dd..770999d 100644
--- a/lib/src/numeric_matchers.dart
+++ b/lib/src/numeric_matchers.dart
@@ -9,51 +9,46 @@
 /// Returns a matcher which matches if the match argument is greater
 /// than the given [value].
 Matcher greaterThan(value) =>
-  new _OrderingComparison(value, false, false, true, 'a value greater than');
+    new _OrderingComparison(value, false, false, true, 'a value greater than');
 
 /// Returns a matcher which matches if the match argument is greater
 /// than or equal to the given [value].
-Matcher greaterThanOrEqualTo(value) =>
-  new _OrderingComparison(value, true, false, true,
-      'a value greater than or equal to');
+Matcher greaterThanOrEqualTo(value) => new _OrderingComparison(
+    value, true, false, true, 'a value greater than or equal to');
 
 /// Returns a matcher which matches if the match argument is less
 /// than the given [value].
 Matcher lessThan(value) =>
-  new _OrderingComparison(value, false, true, false, 'a value less than');
+    new _OrderingComparison(value, false, true, false, 'a value less than');
 
 /// Returns a matcher which matches if the match argument is less
 /// than or equal to the given [value].
-Matcher lessThanOrEqualTo(value) =>
-  new _OrderingComparison(value, true, true, false,
-      'a value less than or equal to');
+Matcher lessThanOrEqualTo(value) => new _OrderingComparison(
+    value, true, true, false, 'a value less than or equal to');
 
 /// A matcher which matches if the match argument is zero.
 const Matcher isZero =
-  const _OrderingComparison(0, true, false, false, 'a value equal to');
-
+    const _OrderingComparison(0, true, false, false, 'a value equal to');
 
 /// A matcher which matches if the match argument is non-zero.
 const Matcher isNonZero =
-  const _OrderingComparison(0, false, true, true, 'a value not equal to');
+    const _OrderingComparison(0, false, true, true, 'a value not equal to');
 
 /// A matcher which matches if the match argument is positive.
 const Matcher isPositive =
-  const _OrderingComparison(0, false, false, true, 'a positive value', false);
+    const _OrderingComparison(0, false, false, true, 'a positive value', false);
 
 /// A matcher which matches if the match argument is zero or negative.
-const Matcher isNonPositive =
-  const _OrderingComparison(0, true, true, false,
-      'a non-positive value', false);
+const Matcher isNonPositive = const _OrderingComparison(
+    0, true, true, false, 'a non-positive value', false);
 
 /// A matcher which matches if the match argument is negative.
 const Matcher isNegative =
-  const _OrderingComparison(0, false, true, false, 'a negative value', false);
+    const _OrderingComparison(0, false, true, false, 'a negative value', false);
 
 /// A matcher which matches if the match argument is zero or positive.
-const Matcher isNonNegative =
-  const _OrderingComparison(0, true, false, true,
-      'a non-negative value', false);
+const Matcher isNonNegative = const _OrderingComparison(
+    0, true, false, true, 'a non-negative value', false);
 
 bool _isNumeric(value) {
   return value is num;
@@ -75,14 +70,10 @@
   /// Whether to include the expected value in the description
   final bool _valueInDescription;
 
-  const _OrderingComparison(
-    this._value,
-    this._equalValue,
-    this._lessThanValue,
-    this._greaterThanValue,
-    this._comparisonDescription,
-    [bool valueInDescription = true]) :
-      this._valueInDescription = valueInDescription;
+  const _OrderingComparison(this._value, this._equalValue, this._lessThanValue,
+      this._greaterThanValue, this._comparisonDescription,
+      [bool valueInDescription = true])
+      : this._valueInDescription = valueInDescription;
 
   bool matches(item, Map matchState) {
     if (item == _value) {
@@ -96,15 +87,17 @@
 
   Description describe(Description description) {
     if (_valueInDescription) {
-      return description.add(_comparisonDescription).add(' ').
-          addDescriptionOf(_value);
+      return description
+          .add(_comparisonDescription)
+          .add(' ')
+          .addDescriptionOf(_value);
     } else {
       return description.add(_comparisonDescription);
     }
   }
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     mismatchDescription.add('is not ');
     return describe(mismatchDescription);
   }
@@ -131,22 +124,20 @@
     return (diff <= _delta);
   }
 
-  Description describe(Description description) =>
-    description.add('a numeric value within ').
-        addDescriptionOf(_delta).
-        add(' of ').
-        addDescriptionOf(_value);
+  Description describe(Description description) => description
+      .add('a numeric value within ')
+      .addDescriptionOf(_delta)
+      .add(' of ')
+      .addDescriptionOf(_value);
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
-    if (item is !num) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
+    if (item is! num) {
       return mismatchDescription.add(' not numeric');
     } else {
       var diff = item - _value;
       if (diff < 0) diff = -diff;
-      return mismatchDescription.
-          add(' differs by ').
-          addDescriptionOf(diff);
+      return mismatchDescription.add(' differs by ').addDescriptionOf(diff);
     }
   }
 }
@@ -175,8 +166,8 @@
   final num _low, _high;
   final bool _lowMatchValue, _highMatchValue;
 
-  const _InRange(this._low, this._high,
-    this._lowMatchValue, this._highMatchValue);
+  const _InRange(
+      this._low, this._high, this._lowMatchValue, this._highMatchValue);
 
   bool matches(value, Map matchState) {
     if (value is! num) {
@@ -194,20 +185,18 @@
     return true;
   }
 
-  Description describe(Description description) =>
-      description.add("be in range from "
-        "$_low (${_lowMatchValue ? 'inclusive' : 'exclusive'}) to "
-        "$_high (${_highMatchValue ? 'inclusive' : 'exclusive'})");
+  Description describe(Description description) => description.add(
+      "be in range from "
+      "$_low (${_lowMatchValue ? 'inclusive' : 'exclusive'}) to "
+      "$_high (${_highMatchValue ? 'inclusive' : 'exclusive'})");
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
-    if (item is !num) {
-      return mismatchDescription.
-          addDescriptionOf(item).
-          add(' not numeric');
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
+    if (item is! num) {
+      return mismatchDescription.addDescriptionOf(item).add(' not numeric');
     } else {
-      return super.describeMismatch(item, mismatchDescription,
-          matchState, verbose);
+      return super.describeMismatch(
+          item, mismatchDescription, matchState, verbose);
     }
   }
 }
diff --git a/lib/src/operator_matchers.dart b/lib/src/operator_matchers.dart
index 4661b7d..6824c5b 100644
--- a/lib/src/operator_matchers.dart
+++ b/lib/src/operator_matchers.dart
@@ -18,7 +18,7 @@
   bool matches(item, Map matchState) => !_matcher.matches(item, matchState);
 
   Description describe(Description description) =>
-    description.add('not ').addDescriptionOf(_matcher);
+      description.add('not ').addDescriptionOf(_matcher);
 }
 
 /// This returns a matcher that matches if all of the matchers passed as
@@ -27,13 +27,7 @@
 /// Instead of passing the matchers separately they can be passed as a single
 /// List argument. Any argument that is not a matcher is implicitly wrapped in a
 /// Matcher to check for equality.
-Matcher allOf(arg0,
-             [arg1 = null,
-              arg2 = null,
-              arg3 = null,
-              arg4 = null,
-              arg5 = null,
-              arg6 = null]) {
+Matcher allOf(arg0, [arg1, arg2, arg3, arg4, arg5, arg6]) {
   return new _AllOf(_wrapArgs(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
 }
 
@@ -43,20 +37,20 @@
   const _AllOf(this._matchers);
 
   bool matches(item, Map matchState) {
-     for (var matcher in _matchers) {
-       if (!matcher.matches(item, matchState)) {
+    for (var matcher in _matchers) {
+      if (!matcher.matches(item, matchState)) {
         addStateInfo(matchState, {'matcher': matcher});
-         return false;
-       }
-     }
-     return true;
+        return false;
+      }
+    }
+    return true;
   }
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     var matcher = matchState['matcher'];
-    matcher.describeMismatch(item, mismatchDescription,
-        matchState['state'], verbose);
+    matcher.describeMismatch(
+        item, mismatchDescription, matchState['state'], verbose);
     return mismatchDescription;
   }
 
@@ -74,13 +68,7 @@
 ///
 /// Any argument that is not a matcher is implicitly wrapped in a
 /// Matcher to check for equality.
-Matcher anyOf(arg0,
-               [arg1 = null,
-                arg2 = null,
-                arg3 = null,
-                arg4 = null,
-                arg5 = null,
-                arg6 = null]) {
+Matcher anyOf(arg0, [arg1, arg2, arg3, arg4, arg5, arg6]) {
   return new _AnyOf(_wrapArgs(arg0, arg1, arg2, arg3, arg4, arg5, arg6));
 }
 
@@ -99,25 +87,27 @@
   }
 
   Description describe(Description description) =>
-    description.addAll('(', ' or ', ')', _matchers);
+      description.addAll('(', ' or ', ')', _matchers);
 }
 
 List<Matcher> _wrapArgs(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
   Iterable<Matcher> matchers;
   if (arg0 is List) {
-    if (arg1 != null || arg2 != null || arg3 != null || arg4 != null ||
-        arg5 != null || arg6 != null) {
+    if (arg1 != null ||
+        arg2 != null ||
+        arg3 != null ||
+        arg4 != null ||
+        arg5 != null ||
+        arg6 != null) {
       throw new ArgumentError('If arg0 is a List, all other arguments must be'
           ' null.');
     }
 
     matchers = arg0;
   } else {
-    matchers = [arg0, arg1, arg2, arg3, arg4, arg5, arg6]
-        .where((e) => e != null);
+    matchers =
+        [arg0, arg1, arg2, arg3, arg4, arg5, arg6].where((e) => e != null);
   }
 
-  return matchers
-      .map((e) => wrapMatcher(e))
-      .toList();
+  return matchers.map((e) => wrapMatcher(e)).toList();
 }
diff --git a/lib/src/pretty_print.dart b/lib/src/pretty_print.dart
index eb13448..df93dbb 100644
--- a/lib/src/pretty_print.dart
+++ b/lib/src/pretty_print.dart
@@ -80,8 +80,9 @@
     } else if (object is String) {
       // Escape strings and print each line on its own line.
       var lines = object.split("\n");
-      return "'" + lines.map(_escapeString)
-          .join("\\n'\n${_indent(indent + 2)}'") + "'";
+      return "'" +
+          lines.map(_escapeString).join("\\n'\n${_indent(indent + 2)}'") +
+          "'";
     } else {
       var value = object.toString().replaceAll("\n", _indent(indent) + "\n");
       var defaultToString = value.startsWith("Instance of ");
@@ -93,8 +94,11 @@
       // Print the type of objects with custom [toString] methods. Primitive
       // objects and objects that don't implement a custom [toString] don't need
       // to have their types printed.
-      if (object is num || object is bool || object is Function ||
-          object == null || defaultToString) {
+      if (object is num ||
+          object is bool ||
+          object is Function ||
+          object == null ||
+          defaultToString) {
         return value;
       } else {
         return "${_typeName(object)}:$value";
@@ -129,19 +133,20 @@
 /// This doesn't add quotes to the string, but it does escape single quote
 /// characters so that single quotes can be applied externally.
 String _escapeString(String source) =>
-  source.split("").map(_escapeChar).join("");
+    source.split("").map(_escapeChar).join("");
 
 /// Return the escaped form of a character [ch].
 String _escapeChar(String ch) {
-  if (ch == "'")
-    return "\\'";
-  else if (ch == '\n')
-    return '\\n';
-  else if (ch == '\r')
-    return '\\r';
-  else if (ch == '\t')
-    return '\\t';
-  else
-    return ch;
+  switch (ch) {
+    case "'":
+      return "\\'";
+    case '\n':
+      return '\\n';
+    case '\r':
+      return '\\r';
+    case '\t':
+      return '\\t';
+    default:
+      return ch;
+  }
 }
-
diff --git a/lib/src/prints_matcher.dart b/lib/src/prints_matcher.dart
index 8faa895..be6abe3 100644
--- a/lib/src/prints_matcher.dart
+++ b/lib/src/prints_matcher.dart
@@ -31,8 +31,8 @@
     if (item is! Function) return false;
 
     var buffer = new StringBuffer();
-    var result = runZoned(item, zoneSpecification:
-        new ZoneSpecification(print: (_, __, ____, line) {
+    var result = runZoned(item,
+        zoneSpecification: new ZoneSpecification(print: (_, __, ____, line) {
       buffer.writeln(line);
     }));
 
@@ -50,8 +50,8 @@
   Description describe(Description description) =>
       description.add('prints ').addDescriptionOf(_matcher);
 
-  Description describeMismatch(item, Description description, Map matchState,
-      bool verbose) {
+  Description describeMismatch(
+      item, Description description, Map matchState, bool verbose) {
     var actual = matchState.remove('prints.actual');
     if (actual == null) return description;
     if (actual.isEmpty) return description.add("printed nothing.");
@@ -60,8 +60,9 @@
 
     // Create a new description for the matcher because at least
     // [_StringEqualsMatcher] replaces the previous contents of the description.
-    var innerMismatch = _matcher.describeMismatch(
-        actual, new StringDescription(), matchState, verbose).toString();
+    var innerMismatch = _matcher
+        .describeMismatch(actual, new StringDescription(), matchState, verbose)
+        .toString();
 
     if (innerMismatch.isNotEmpty) {
       description.add('\n   Which: ').add(innerMismatch.toString());
diff --git a/lib/src/string_matchers.dart b/lib/src/string_matchers.dart
index 616a4b6..c93963f 100644
--- a/lib/src/string_matchers.dart
+++ b/lib/src/string_matchers.dart
@@ -57,17 +57,18 @@
       item is String && _matchValue == collapseWhitespace(item);
 
   Description describe(Description description) =>
-    description.addDescriptionOf(_matchValue).add(' ignoring whitespace');
+      description.addDescriptionOf(_matchValue).add(' ignoring whitespace');
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     if (item is String) {
-      return mismatchDescription.add('is ').
-          addDescriptionOf(collapseWhitespace(item)).
-          add(' with whitespace compressed');
+      return mismatchDescription
+          .add('is ')
+          .addDescriptionOf(collapseWhitespace(item))
+          .add(' with whitespace compressed');
     } else {
-      return super.describeMismatch(item, mismatchDescription,
-          matchState, verbose);
+      return super.describeMismatch(
+          item, mismatchDescription, matchState, verbose);
     }
   }
 }
@@ -130,9 +131,8 @@
     return true;
   }
 
-  Description describe(Description description) =>
-      description.addAll('a string containing ', ', ', ' in order',
-                                                  _substrings);
+  Description describe(Description description) => description.addAll(
+      'a string containing ', ', ', ' in order', _substrings);
 }
 
 /// Returns a matcher that matches if the match argument is a string and
@@ -156,7 +156,7 @@
   }
 
   bool matches(item, Map matchState) =>
-    item is String ? _regexp.hasMatch(item) : false;
+      item is String ? _regexp.hasMatch(item) : false;
 
   Description describe(Description description) =>
       description.add("match '${_regexp.pattern}'");
@@ -166,15 +166,13 @@
 // class to give better mismatch error messages than the base Matcher class.
 abstract class _StringMatcher extends Matcher {
   const _StringMatcher();
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
+  Description describeMismatch(
+      item, Description mismatchDescription, Map matchState, bool verbose) {
     if (!(item is String)) {
-      return mismatchDescription.
-          addDescriptionOf(item).
-          add(' not a string');
+      return mismatchDescription.addDescriptionOf(item).add(' not a string');
     } else {
-      return super.describeMismatch(item, mismatchDescription,
-          matchState, verbose);
+      return super.describeMismatch(
+          item, mismatchDescription, matchState, verbose);
     }
   }
 }
diff --git a/lib/src/throws_matcher.dart b/lib/src/throws_matcher.dart
index b3a5323..461c585 100644
--- a/lib/src/throws_matcher.dart
+++ b/lib/src/throws_matcher.dart
@@ -93,16 +93,16 @@
     }
   }
 
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState,
-                               bool verbose) {
+  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']);
+      mismatchDescription
+          .add('threw ')
+          .addDescriptionOf(matchState['exception']);
       if (verbose) {
         mismatchDescription.add(' at ').add(matchState['stack'].toString());
       }
@@ -110,4 +110,3 @@
     }
   }
 }
-
diff --git a/pubspec.yaml b/pubspec.yaml
index fe137e6..3988f16 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: matcher
-version: 0.11.4
+version: 0.11.4+1
 author: Dart Team <misc@dartlang.org>
 description: Support for specifying test expectations
 homepage: https://github.com/dart-lang/matcher
diff --git a/test/core_matchers_test.dart b/test/core_matchers_test.dart
index be9758e..7024894 100644
--- a/test/core_matchers_test.dart
+++ b/test/core_matchers_test.dart
@@ -65,12 +65,32 @@
 
     shouldPass(set2, equals(set1));
     shouldPass(numbers, equals(set1));
-    shouldFail([1, 2, 3, 4, 5, 6, 7, 8, 9], equals(set1), matches(
-        r"Expected: .*:\[1, 2, 3, 4, 5, 6, 7, 8, 9, 10\]"
+    shouldFail([
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9
+    ], equals(set1), matches(r"Expected: .*:\[1, 2, 3, 4, 5, 6, 7, 8, 9, 10\]"
         r"  Actual: \[1, 2, 3, 4, 5, 6, 7, 8, 9\]"
         r"   Which: does not contain 10"));
-    shouldFail([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], equals(set1), matches(
-        r"Expected: .*:\[1, 2, 3, 4, 5, 6, 7, 8, 9, 10\]"
+    shouldFail([
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11
+    ], equals(set1), matches(r"Expected: .*:\[1, 2, 3, 4, 5, 6, 7, 8, 9, 10\]"
         r"  Actual: \[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11\]"
         r"   Which: larger than expected"));
   });
@@ -85,12 +105,10 @@
 
   test('returnsNormally', () {
     shouldPass(doesNotThrow, returnsNormally);
-    shouldFail(doesThrow, returnsNormally,
-        matches(
-            r"Expected: return normally"
-            r"  Actual: <Closure(: \(\) => dynamic "
-            r"from Function 'doesThrow': static\.)?>"
-            r"   Which: threw 'X'"));
+    shouldFail(doesThrow, returnsNormally, matches(r"Expected: return normally"
+        r"  Actual: <Closure(: \(\) => dynamic "
+        r"from Function 'doesThrow': static\.)?>"
+        r"   Which: threw 'X'"));
   });
 
   test('hasLength', () {
@@ -106,35 +124,30 @@
 
     b.add(0);
     shouldPass(b, hasLength(1));
-    shouldFail(b, hasLength(2),
-        "Expected: an object with length of <2> "
+    shouldFail(b, hasLength(2), "Expected: an object with length of <2> "
         "Actual: [0] "
         "Which: has length of <1>");
 
     b.add(0);
-    shouldFail(b, hasLength(1),
-        "Expected: an object with length of <1> "
+    shouldFail(b, hasLength(1), "Expected: an object with length of <1> "
         "Actual: [0, 0] "
         "Which: has length of <2>");
     shouldPass(b, hasLength(2));
   });
 
   test('scalar type mismatch', () {
-    shouldFail('error', equals(5.1),
-        "Expected: <5.1> "
+    shouldFail('error', equals(5.1), "Expected: <5.1> "
         "Actual: 'error'");
   });
 
   test('nested type mismatch', () {
-    shouldFail(['error'], equals([5.1]),
-        "Expected: [5.1] "
+    shouldFail(['error'], equals([5.1]), "Expected: [5.1] "
         "Actual: ['error'] "
         "Which: was 'error' instead of <5.1> at location [0]");
   });
 
   test('doubly-nested type mismatch', () {
-    shouldFail([['error']], equals([[5.1]]),
-        "Expected: [[5.1]] "
+    shouldFail([['error']], equals([[5.1]]), "Expected: [[5.1]] "
         "Actual: [['error']] "
         "Which: was 'error' instead of <5.1> at location [0][0]");
   });
@@ -152,8 +165,8 @@
         "Actual: [['foo', 'barry'], ['foo'], 4, []] "
         "Which: was 'barry' instead of 'bar' at location [0][1]";
 
-    var actual3 = [['foo', 'bar'], ['foo'], 4, {'foo':'bar'}];
-    var expected3 = [['foo', 'bar'], ['foo'], 4, {'foo':'barry'}];
+    var actual3 = [['foo', 'bar'], ['foo'], 4, {'foo': 'bar'}];
+    var expected3 = [['foo', 'bar'], ['foo'], 4, {'foo': 'barry'}];
     var reason3 = "Expected: [['foo', 'bar'], ['foo'], 4, {'foo': 'barry'}] "
         "Actual: [['foo', 'bar'], ['foo'], 4, {'foo': 'bar'}] "
         "Which: was 'bar' instead of 'barry' at location [3]['foo']";
diff --git a/test/future_matchers_test.dart b/test/future_matchers_test.dart
index 6fac0de..4e21ea2 100644
--- a/test/future_matchers_test.dart
+++ b/test/future_matchers_test.dart
@@ -17,10 +17,9 @@
   test('completes - unexpected error', () {
     var completer = new Completer();
     completer.completeError('X');
-    shouldFail(completer.future, completes,
-        contains('Expected future to complete successfully, '
-                 'but it failed with X'),
-        isAsync: true);
+    shouldFail(completer.future, completes, contains(
+        'Expected future to complete successfully, '
+        'but it failed with X'), isAsync: true);
   });
 
   test('completes - successfully', () {
@@ -33,8 +32,8 @@
     var completer = new Completer();
     completer.complete('1');
     shouldFail(completer.future, throws,
-      contains("Expected future to fail, but succeeded with '1'"),
-      isAsync: true);
+        contains("Expected future to fail, but succeeded with '1'"),
+        isAsync: true);
   });
 
   test('throws - expected to see exception', () {
@@ -45,7 +44,9 @@
 
   test('throws - expected to see exception thrown later on', () {
     var completer = new Completer();
-    var chained = completer.future.then((_) { throw 'X'; });
+    var chained = completer.future.then((_) {
+      throw 'X';
+    });
     shouldPass(chained, throws, isAsync: true);
     completer.complete('1');
   });
@@ -54,8 +55,8 @@
     var completer = new Completer();
     completer.complete('1');
     shouldFail(completer.future, throwsA(equals('X')),
-      contains("Expected future to fail, but succeeded with '1'"),
-      isAsync: true);
+        contains("Expected future to fail, but succeeded with '1'"),
+        isAsync: true);
   });
 
   test('throwsA - correct error', () {
@@ -70,7 +71,6 @@
     shouldFail(completer.future, throwsA(equals('Y')),
         "Expected: 'Y' Actual: 'X' "
         "Which: is different. "
-        "Expected: Y Actual: X ^ Differ at offset 0",
-        isAsync: true);
+        "Expected: Y Actual: X ^ Differ at offset 0", isAsync: true);
   });
 }
diff --git a/test/iterable_matchers_test.dart b/test/iterable_matchers_test.dart
index 91d5335..da454fb 100644
--- a/test/iterable_matchers_test.dart
+++ b/test/iterable_matchers_test.dart
@@ -47,8 +47,7 @@
   test('everyElement', () {
     var d = [1, 2];
     var e = [1, 1, 1];
-    shouldFail(d, everyElement(1),
-        "Expected: every element(<1>) "
+    shouldFail(d, everyElement(1), "Expected: every element(<1>) "
         "Actual: [1, 2] "
         "Which: has value <2> which doesn't match <1> at index 1");
     shouldPass(e, everyElement(1));
@@ -64,21 +63,21 @@
         "Which: has value ['foo', 'bar'] which has value 'bar' "
         "which is different. Expected: foo Actual: bar ^ "
         "Differ at offset 0 at index 1 at index 0");
-    shouldFail(d, everyElement(allOf(hasLength(greaterThan(0)),
-        contains('foo'))),
-         "Expected: every element((an object with length of a value "
-         "greater than <0> and contains 'foo')) "
-         "Actual: [['foo', 'bar'], ['foo'], []] "
-         "Which: has value [] which has length of <0> at index 2");
-    shouldFail(d, everyElement(allOf(contains('foo'),
-        hasLength(greaterThan(0)))),
+    shouldFail(d,
+        everyElement(allOf(hasLength(greaterThan(0)), contains('foo'))),
+        "Expected: every element((an object with length of a value "
+        "greater than <0> and contains 'foo')) "
+        "Actual: [['foo', 'bar'], ['foo'], []] "
+        "Which: has value [] which has length of <0> at index 2");
+    shouldFail(d,
+        everyElement(allOf(contains('foo'), hasLength(greaterThan(0)))),
         "Expected: every element((contains 'foo' and "
         "an object with length of a value greater than <0>)) "
         "Actual: [['foo', 'bar'], ['foo'], []] "
         "Which: has value [] which doesn't match (contains 'foo' and "
         "an object with length of a value greater than <0>) at index 2");
-    shouldFail(e, everyElement(allOf(contains('foo'),
-        hasLength(greaterThan(0)))),
+    shouldFail(e,
+        everyElement(allOf(contains('foo'), hasLength(greaterThan(0)))),
         "Expected: every element((contains 'foo' and an object with "
         "length of a value greater than <0>)) "
         "Actual: [['foo', 'bar'], ['foo'], 3, []] "
@@ -90,16 +89,15 @@
     var d = [1, 2];
     var e = [1, 1, 1];
     shouldPass(d, anyElement(2));
-    shouldFail(e, anyElement(2),
-        "Expected: some element <2> Actual: [1, 1, 1]");
+    shouldFail(
+        e, anyElement(2), "Expected: some element <2> Actual: [1, 1, 1]");
   });
 
   test('orderedEquals', () {
     shouldPass([null], orderedEquals([null]));
     var d = [1, 2];
     shouldPass(d, orderedEquals([1, 2]));
-    shouldFail(d, orderedEquals([2, 1]),
-        "Expected: equals [2, 1] ordered "
+    shouldFail(d, orderedEquals([2, 1]), "Expected: equals [2, 1] ordered "
         "Actual: [1, 2] "
         "Which: was <1> instead of <2> at location [0]");
   });
@@ -107,16 +105,14 @@
   test('unorderedEquals', () {
     var d = [1, 2];
     shouldPass(d, unorderedEquals([2, 1]));
-    shouldFail(d, unorderedEquals([1]),
-        "Expected: equals [1] unordered "
+    shouldFail(d, unorderedEquals([1]), "Expected: equals [1] unordered "
         "Actual: [1, 2] "
         "Which: has too many elements (2 > 1)");
     shouldFail(d, unorderedEquals([3, 2, 1]),
         "Expected: equals [3, 2, 1] unordered "
         "Actual: [1, 2] "
         "Which: has too few elements (2 < 3)");
-    shouldFail(d, unorderedEquals([3, 1]),
-        "Expected: equals [3, 1] unordered "
+    shouldFail(d, unorderedEquals([3, 1]), "Expected: equals [3, 1] unordered "
         "Actual: [1, 2] "
         "Which: has no match for <3> at index 0");
   });
@@ -139,7 +135,7 @@
         "Which: has no match for <3> at index 0");
     shouldFail(d, unorderedMatches([greaterThan(3), greaterThan(0)]),
         "Expected: matches [a value greater than <3>, a value greater than "
-            "<0>] unordered "
+        "<0>] unordered "
         "Actual: [1, 2] "
         "Which: has no match for a value greater than <3> at index 0");
   });
@@ -148,22 +144,21 @@
     var c = [1, 2];
     var d = [1, 2, 3];
     var e = [1, 4, 9];
-    shouldFail('x', pairwiseCompare(e, (e,a) => a <= e,
-        "less than or equal"),
+    shouldFail('x', pairwiseCompare(e, (e, a) => a <= e, "less than or equal"),
         "Expected: pairwise less than or equal [1, 4, 9] "
         "Actual: 'x' "
         "Which: is not an Iterable");
-    shouldFail(c, pairwiseCompare(e, (e,a) => a <= e, "less than or equal"),
+    shouldFail(c, pairwiseCompare(e, (e, a) => a <= e, "less than or equal"),
         "Expected: pairwise less than or equal [1, 4, 9] "
         "Actual: [1, 2] "
         "Which: has length 2 instead of 3");
-    shouldPass(d, pairwiseCompare(e, (e,a) => a <= e, "less than or equal"));
-    shouldFail(d, pairwiseCompare(e, (e,a) => a < e, "less than"),
+    shouldPass(d, pairwiseCompare(e, (e, a) => a <= e, "less than or equal"));
+    shouldFail(d, pairwiseCompare(e, (e, a) => a < e, "less than"),
         "Expected: pairwise less than [1, 4, 9] "
         "Actual: [1, 2, 3] "
         "Which: has <1> which is not less than <1> at index 0");
-    shouldPass(d, pairwiseCompare(e, (e,a) => a * a == e, "square root of"));
-    shouldFail(d, pairwiseCompare(e, (e,a) => a + a == e, "double"),
+    shouldPass(d, pairwiseCompare(e, (e, a) => a * a == e, "square root of"));
+    shouldFail(d, pairwiseCompare(e, (e, a) => a + a == e, "double"),
         "Expected: pairwise double [1, 4, 9] "
         "Actual: [1, 2, 3] "
         "Which: has <1> which is not double <1> at index 0");
diff --git a/test/matchers_minified_test.dart b/test/matchers_minified_test.dart
index 4b39d42..d9ee582 100644
--- a/test/matchers_minified_test.dart
+++ b/test/matchers_minified_test.dart
@@ -22,81 +22,82 @@
 
   group('Core matchers', () {
     test('throwsFormatException', () {
-      shouldPass(() { throw new FormatException(''); },
-          throwsFormatException);
-      shouldFail(() { throw new Exception(); },
-          throwsFormatException,
-          matches(
-              r"Expected: throws FormatException +"
-              r"Actual: <Closure(: \(\) => dynamic)?> +"
-              r"Which: threw " + _MINIFIED_NAME + r":<Exception>"));
+      shouldPass(() {
+        throw new FormatException('');
+      }, throwsFormatException);
+      shouldFail(() {
+        throw new Exception();
+      }, throwsFormatException, matches(r"Expected: throws FormatException +"
+          r"Actual: <Closure(: \(\) => dynamic)?> +"
+          r"Which: threw " + _MINIFIED_NAME + r":<Exception>"));
     });
 
     test('throwsArgumentError', () {
-      shouldPass(() { throw new ArgumentError(''); },
-          throwsArgumentError);
-      shouldFail(() { throw new Exception(); },
-          throwsArgumentError,
-          matches(
-              r"Expected: throws ArgumentError +"
-              r"Actual: <Closure(: \(\) => dynamic)?> +"
-              r"Which: threw " + _MINIFIED_NAME + r":<Exception>"));
+      shouldPass(() {
+        throw new ArgumentError('');
+      }, throwsArgumentError);
+      shouldFail(() {
+        throw new Exception();
+      }, throwsArgumentError, matches(r"Expected: throws ArgumentError +"
+          r"Actual: <Closure(: \(\) => dynamic)?> +"
+          r"Which: threw " + _MINIFIED_NAME + r":<Exception>"));
     });
 
     test('throwsRangeError', () {
-      shouldPass(() { throw new RangeError(0); },
-          throwsRangeError);
-      shouldFail(() { throw new Exception(); },
-          throwsRangeError,
-          matches(
-              r"Expected: throws RangeError +"
-              r"Actual: <Closure(: \(\) => dynamic)?> +"
-              r"Which: threw " + _MINIFIED_NAME + r":<Exception>"));
+      shouldPass(() {
+        throw new RangeError(0);
+      }, throwsRangeError);
+      shouldFail(() {
+        throw new Exception();
+      }, throwsRangeError, matches(r"Expected: throws RangeError +"
+          r"Actual: <Closure(: \(\) => dynamic)?> +"
+          r"Which: threw " + _MINIFIED_NAME + r":<Exception>"));
     });
 
     test('throwsNoSuchMethodError', () {
       shouldPass(() {
         throw new NoSuchMethodError(null, const Symbol(''), null, null);
       }, throwsNoSuchMethodError);
-      shouldFail(() { throw new Exception(); },
-          throwsNoSuchMethodError,
-          matches(
-              r"Expected: throws NoSuchMethodError +"
+      shouldFail(() {
+        throw new Exception();
+      }, throwsNoSuchMethodError, matches(
+          r"Expected: throws NoSuchMethodError +"
               r"Actual: <Closure(: \(\) => dynamic)?> +"
               r"Which: threw " + _MINIFIED_NAME + r":<Exception>"));
     });
 
     test('throwsUnimplementedError', () {
-      shouldPass(() { throw new UnimplementedError(''); },
-          throwsUnimplementedError);
-      shouldFail(() { throw new Exception(); },
-          throwsUnimplementedError,
-          matches(
-              r"Expected: throws UnimplementedError +"
+      shouldPass(() {
+        throw new UnimplementedError('');
+      }, throwsUnimplementedError);
+      shouldFail(() {
+        throw new Exception();
+      }, throwsUnimplementedError, matches(
+          r"Expected: throws UnimplementedError +"
               r"Actual: <Closure(: \(\) => dynamic)?> +"
               r"Which: threw " + _MINIFIED_NAME + r":<Exception>"));
     });
 
     test('throwsUnsupportedError', () {
-      shouldPass(() { throw new UnsupportedError(''); },
-          throwsUnsupportedError);
-      shouldFail(() { throw new Exception(); },
-          throwsUnsupportedError,
-          matches(
-              r"Expected: throws UnsupportedError +"
-              r"Actual: <Closure(: \(\) => dynamic)?> +"
-              r"Which: threw " + _MINIFIED_NAME + r":<Exception>"));
+      shouldPass(() {
+        throw new UnsupportedError('');
+      }, throwsUnsupportedError);
+      shouldFail(() {
+        throw new Exception();
+      }, throwsUnsupportedError, matches(r"Expected: throws UnsupportedError +"
+          r"Actual: <Closure(: \(\) => dynamic)?> +"
+          r"Which: threw " + _MINIFIED_NAME + r":<Exception>"));
     });
 
     test('throwsStateError', () {
-      shouldPass(() { throw new StateError(''); },
-          throwsStateError);
-      shouldFail(() { throw new Exception(); },
-          throwsStateError,
-          matches(
-              r"Expected: throws StateError +"
-              r"Actual: <Closure(: \(\) => dynamic)?> +"
-              r"Which: threw " + _MINIFIED_NAME + r":<Exception>"));
+      shouldPass(() {
+        throw new StateError('');
+      }, throwsStateError);
+      shouldFail(() {
+        throw new Exception();
+      }, throwsStateError, matches(r"Expected: throws StateError +"
+          r"Actual: <Closure(: \(\) => dynamic)?> +"
+          r"Which: threw " + _MINIFIED_NAME + r":<Exception>"));
     });
   });
 
@@ -113,17 +114,15 @@
       var d = new SimpleIterable(0);
       var e = new SimpleIterable(1);
       shouldPass(e, isNotEmpty);
-      shouldFail(d, isNotEmpty,
-          matches(r"Expected: non-empty +Actual: " + _MINIFIED_NAME + r":\[\]"));
+      shouldFail(d, isNotEmpty, matches(
+          r"Expected: non-empty +Actual: " + _MINIFIED_NAME + r":\[\]"));
     });
 
     test('contains', () {
       var d = new SimpleIterable(3);
       shouldPass(d, contains(2));
-      shouldFail(d, contains(5),
-          matches(
-              r"Expected: contains <5> +"
-              r"Actual: " + _MINIFIED_NAME + r":\[3, 2, 1\]"));
+      shouldFail(d, contains(5), matches(r"Expected: contains <5> +"
+          r"Actual: " + _MINIFIED_NAME + r":\[3, 2, 1\]"));
     });
   });
 
@@ -133,10 +132,9 @@
       w.price = 10;
       shouldPass(w, new HasPrice(10));
       shouldPass(w, new HasPrice(greaterThan(0)));
-      shouldFail(w, new HasPrice(greaterThan(10)),
-          matches(
-              r"Expected: Widget with a price that is a value greater than "
-                  r"<10> +"
+      shouldFail(w, new HasPrice(greaterThan(10)), matches(
+          r"Expected: Widget with a price that is a value greater than "
+              r"<10> +"
               r"Actual: <Instance of '" + _MINIFIED_NAME + r"'> +"
               r"Which: has price with value <10> which is not "
               r"a value greater than <10>"));
diff --git a/test/matchers_unminified_test.dart b/test/matchers_unminified_test.dart
index 6947884..b9ea535 100644
--- a/test/matchers_unminified_test.dart
+++ b/test/matchers_unminified_test.dart
@@ -20,82 +20,82 @@
 
   group('Core matchers', () {
     test('throwsFormatException', () {
-      shouldPass(() { throw new FormatException(''); },
-          throwsFormatException);
-      shouldFail(() { throw new Exception(); },
-          throwsFormatException,
-          matches(
-              r"Expected: throws FormatException +"
-              r"Actual: <Closure(: \(\) => dynamic)?> +"
-              r"Which: threw \?:<Exception>"));
-
+      shouldPass(() {
+        throw new FormatException('');
+      }, throwsFormatException);
+      shouldFail(() {
+        throw new Exception();
+      }, throwsFormatException, matches(r"Expected: throws FormatException +"
+          r"Actual: <Closure(: \(\) => dynamic)?> +"
+          r"Which: threw \?:<Exception>"));
     });
 
     test('throwsArgumentError', () {
-      shouldPass(() { throw new ArgumentError(''); },
-          throwsArgumentError);
-      shouldFail(() { throw new Exception(); },
-          throwsArgumentError,
-          matches(
-              r"Expected: throws ArgumentError +"
-              r"Actual: <Closure(: \(\) => dynamic)?> +"
-              r"Which: threw \?:<Exception>"));
+      shouldPass(() {
+        throw new ArgumentError('');
+      }, throwsArgumentError);
+      shouldFail(() {
+        throw new Exception();
+      }, throwsArgumentError, matches(r"Expected: throws ArgumentError +"
+          r"Actual: <Closure(: \(\) => dynamic)?> +"
+          r"Which: threw \?:<Exception>"));
     });
 
     test('throwsRangeError', () {
-      shouldPass(() { throw new RangeError(0); },
-          throwsRangeError);
-      shouldFail(() { throw new Exception(); },
-          throwsRangeError,
-          matches(
-              r"Expected: throws RangeError +"
-              r"Actual: <Closure(: \(\) => dynamic)?> +"
-              r"Which: threw \?:<Exception>"));
+      shouldPass(() {
+        throw new RangeError(0);
+      }, throwsRangeError);
+      shouldFail(() {
+        throw new Exception();
+      }, throwsRangeError, matches(r"Expected: throws RangeError +"
+          r"Actual: <Closure(: \(\) => dynamic)?> +"
+          r"Which: threw \?:<Exception>"));
     });
 
     test('throwsNoSuchMethodError', () {
       shouldPass(() {
-          throw new NoSuchMethodError(null, const Symbol(''), null, null);
+        throw new NoSuchMethodError(null, const Symbol(''), null, null);
       }, throwsNoSuchMethodError);
-      shouldFail(() { throw new Exception(); },
-          throwsNoSuchMethodError,
-          matches(
-              r"Expected: throws NoSuchMethodError +"
-              r"Actual: <Closure(: \(\) => dynamic)?> +"
-              r"Which: threw \?:<Exception>"));
+      shouldFail(() {
+        throw new Exception();
+      }, throwsNoSuchMethodError, matches(
+          r"Expected: throws NoSuchMethodError +"
+          r"Actual: <Closure(: \(\) => dynamic)?> +"
+          r"Which: threw \?:<Exception>"));
     });
 
     test('throwsUnimplementedError', () {
-      shouldPass(() { throw new UnimplementedError(''); },
-          throwsUnimplementedError);
-      shouldFail(() { throw new Exception(); },
-          throwsUnimplementedError,
-          matches(
-              r"Expected: throws UnimplementedError +"
-              r"Actual: <Closure(: \(\) => dynamic)?> +"
-              r"Which: threw \?:<Exception>"));
+      shouldPass(() {
+        throw new UnimplementedError('');
+      }, throwsUnimplementedError);
+      shouldFail(() {
+        throw new Exception();
+      }, throwsUnimplementedError, matches(
+          r"Expected: throws UnimplementedError +"
+          r"Actual: <Closure(: \(\) => dynamic)?> +"
+          r"Which: threw \?:<Exception>"));
     });
 
     test('throwsUnsupportedError', () {
-      shouldPass(() { throw new UnsupportedError(''); },
-          throwsUnsupportedError);
-      shouldFail(() { throw new Exception(); },
-          throwsUnsupportedError,
-          matches(
-              r"Expected: throws UnsupportedError +"
-              r"Actual: <Closure(: \(\) => dynamic)?> +"
-              r"Which: threw \?:<Exception>"));
+      shouldPass(() {
+        throw new UnsupportedError('');
+      }, throwsUnsupportedError);
+      shouldFail(() {
+        throw new Exception();
+      }, throwsUnsupportedError, matches(r"Expected: throws UnsupportedError +"
+          r"Actual: <Closure(: \(\) => dynamic)?> +"
+          r"Which: threw \?:<Exception>"));
     });
 
     test('throwsStateError', () {
-      shouldPass(() { throw new StateError(''); },
-          throwsStateError);
-      shouldFail(() { throw new Exception(); },
-          throwsStateError,
-          matches(
-              r"Expected: throws StateError +"
-              r"Actual: <Closure(: \(\) => dynamic)?> +"
-              r"Which: threw \?:<Exception>"));
+      shouldPass(() {
+        throw new StateError('');
+      }, throwsStateError);
+      shouldFail(() {
+        throw new Exception();
+      }, throwsStateError, matches(r"Expected: throws StateError +"
+          r"Actual: <Closure(: \(\) => dynamic)?> +"
+          r"Which: threw \?:<Exception>"));
     });
   });
 
@@ -116,12 +116,10 @@
           "Actual: SimpleIterable:[]");
     });
 
-
     test('contains', () {
       var d = new SimpleIterable(3);
       shouldPass(d, contains(2));
-      shouldFail(d, contains(5),
-          "Expected: contains <5> "
+      shouldFail(d, contains(5), "Expected: contains <5> "
           "Actual: SimpleIterable:[3, 2, 1]");
     });
   });
diff --git a/test/mirror_matchers_test.dart b/test/mirror_matchers_test.dart
index ebe90e4..90d7c46 100644
--- a/test/mirror_matchers_test.dart
+++ b/test/mirror_matchers_test.dart
@@ -17,7 +17,6 @@
 }
 
 void main() {
-
   initUtils();
 
   test('hasProperty', () {
diff --git a/test/numeric_matchers_test.dart b/test/numeric_matchers_test.dart
index 60347bd..7ced6b4 100644
--- a/test/numeric_matchers_test.dart
+++ b/test/numeric_matchers_test.dart
@@ -14,23 +14,21 @@
 
   test('greaterThan', () {
     shouldPass(10, greaterThan(9));
-    shouldFail(9, greaterThan(10),
-      "Expected: a value greater than <10> "
-      "Actual: <9> "
-      "Which: is not a value greater than <10>");
+    shouldFail(9, greaterThan(10), "Expected: a value greater than <10> "
+        "Actual: <9> "
+        "Which: is not a value greater than <10>");
   });
 
   test('greaterThanOrEqualTo', () {
     shouldPass(10, greaterThanOrEqualTo(10));
     shouldFail(9, greaterThanOrEqualTo(10),
-      "Expected: a value greater than or equal to <10> "
-      "Actual: <9> "
-      "Which: is not a value greater than or equal to <10>");
+        "Expected: a value greater than or equal to <10> "
+        "Actual: <9> "
+        "Which: is not a value greater than or equal to <10>");
   });
 
   test('lessThan', () {
-    shouldFail(10, lessThan(9),
-        "Expected: a value less than <9> "
+    shouldFail(10, lessThan(9), "Expected: a value less than <9> "
         "Actual: <10> "
         "Which: is not a value less than <9>");
     shouldPass(9, lessThan(10));
@@ -39,34 +37,30 @@
   test('lessThanOrEqualTo', () {
     shouldPass(10, lessThanOrEqualTo(10));
     shouldFail(11, lessThanOrEqualTo(10),
-      "Expected: a value less than or equal to <10> "
-      "Actual: <11> "
-      "Which: is not a value less than or equal to <10>");
+        "Expected: a value less than or equal to <10> "
+        "Actual: <11> "
+        "Which: is not a value less than or equal to <10>");
   });
 
   test('isZero', () {
     shouldPass(0, isZero);
-    shouldFail(1, isZero,
-        "Expected: a value equal to <0> "
+    shouldFail(1, isZero, "Expected: a value equal to <0> "
         "Actual: <1> "
         "Which: is not a value equal to <0>");
   });
 
   test('isNonZero', () {
-    shouldFail(0, isNonZero,
-        "Expected: a value not equal to <0> "
+    shouldFail(0, isNonZero, "Expected: a value not equal to <0> "
         "Actual: <0> "
         "Which: is not a value not equal to <0>");
     shouldPass(1, isNonZero);
   });
 
   test('isPositive', () {
-    shouldFail(-1, isPositive,
-        "Expected: a positive value "
+    shouldFail(-1, isPositive, "Expected: a positive value "
         "Actual: <-1> "
         "Which: is not a positive value");
-    shouldFail(0, isPositive,
-        "Expected: a positive value "
+    shouldFail(0, isPositive, "Expected: a positive value "
         "Actual: <0> "
         "Which: is not a positive value");
     shouldPass(1, isPositive);
@@ -74,8 +68,7 @@
 
   test('isNegative', () {
     shouldPass(-1, isNegative);
-    shouldFail(0, isNegative,
-        "Expected: a negative value "
+    shouldFail(0, isNegative, "Expected: a negative value "
         "Actual: <0> "
         "Which: is not a negative value");
   });
@@ -83,8 +76,7 @@
   test('isNonPositive', () {
     shouldPass(-1, isNonPositive);
     shouldPass(0, isNonPositive);
-    shouldFail(1, isNonPositive,
-        "Expected: a non-positive value "
+    shouldFail(1, isNonPositive, "Expected: a non-positive value "
         "Actual: <1> "
         "Which: is not a non-positive value");
   });
@@ -92,10 +84,9 @@
   test('isNonNegative', () {
     shouldPass(1, isNonNegative);
     shouldPass(0, isNonNegative);
-    shouldFail(-1, isNonNegative,
-      "Expected: a non-negative value "
-      "Actual: <-1> "
-      "Which: is not a non-negative value");
+    shouldFail(-1, isNonNegative, "Expected: a non-negative value "
+        "Actual: <-1> "
+        "Which: is not a non-negative value");
   });
 
   test('closeTo', () {
@@ -113,39 +104,39 @@
   });
 
   test('inInclusiveRange', () {
-    shouldFail(-1, inInclusiveRange(0,2),
+    shouldFail(-1, inInclusiveRange(0, 2),
         "Expected: be in range from 0 (inclusive) to 2 (inclusive) "
         "Actual: <-1>");
-    shouldPass(0, inInclusiveRange(0,2));
-    shouldPass(1, inInclusiveRange(0,2));
-    shouldPass(2, inInclusiveRange(0,2));
-    shouldFail(3, inInclusiveRange(0,2),
+    shouldPass(0, inInclusiveRange(0, 2));
+    shouldPass(1, inInclusiveRange(0, 2));
+    shouldPass(2, inInclusiveRange(0, 2));
+    shouldFail(3, inInclusiveRange(0, 2),
         "Expected: be in range from 0 (inclusive) to 2 (inclusive) "
         "Actual: <3>");
   });
 
   test('inExclusiveRange', () {
-    shouldFail(0, inExclusiveRange(0,2),
+    shouldFail(0, inExclusiveRange(0, 2),
         "Expected: be in range from 0 (exclusive) to 2 (exclusive) "
         "Actual: <0>");
-    shouldPass(1, inExclusiveRange(0,2));
-    shouldFail(2, inExclusiveRange(0,2),
+    shouldPass(1, inExclusiveRange(0, 2));
+    shouldFail(2, inExclusiveRange(0, 2),
         "Expected: be in range from 0 (exclusive) to 2 (exclusive) "
         "Actual: <2>");
   });
 
   test('inOpenClosedRange', () {
-    shouldFail(0, inOpenClosedRange(0,2),
+    shouldFail(0, inOpenClosedRange(0, 2),
         "Expected: be in range from 0 (exclusive) to 2 (inclusive) "
         "Actual: <0>");
-    shouldPass(1, inOpenClosedRange(0,2));
-    shouldPass(2, inOpenClosedRange(0,2));
+    shouldPass(1, inOpenClosedRange(0, 2));
+    shouldPass(2, inOpenClosedRange(0, 2));
   });
 
   test('inClosedOpenRange', () {
-    shouldPass(0, inClosedOpenRange(0,2));
-    shouldPass(1, inClosedOpenRange(0,2));
-    shouldFail(2, inClosedOpenRange(0,2),
+    shouldPass(0, inClosedOpenRange(0, 2));
+    shouldPass(1, inClosedOpenRange(0, 2));
+    shouldFail(2, inClosedOpenRange(0, 2),
         "Expected: be in range from 0 (inclusive) to 2 (exclusive) "
         "Actual: <2>");
   });
diff --git a/test/operator_matchers_test.dart b/test/operator_matchers_test.dart
index f82abaa..b92986c 100644
--- a/test/operator_matchers_test.dart
+++ b/test/operator_matchers_test.dart
@@ -14,13 +14,13 @@
 
   test('anyOf', () {
     // with a list
-    shouldFail(0, anyOf([equals(1), equals(2)]),
-        "Expected: (<1> or <2>) Actual: <0>");
+    shouldFail(
+        0, anyOf([equals(1), equals(2)]), "Expected: (<1> or <2>) Actual: <0>");
     shouldPass(1, anyOf([equals(1), equals(2)]));
 
     // with individual items
-    shouldFail(0, anyOf(equals(1), equals(2)),
-        "Expected: (<1> or <2>) Actual: <0>");
+    shouldFail(
+        0, anyOf(equals(1), equals(2)), "Expected: (<1> or <2>) Actual: <0>");
     shouldPass(1, anyOf(equals(1), equals(2)));
   });
 
@@ -40,10 +40,10 @@
         "Which: is not a value greater than <0>");
 
     // with maximum items
-    shouldPass(1, allOf(lessThan(10), lessThan(9), lessThan(8), lessThan(7),
-                        lessThan(6), lessThan(5), lessThan(4)));
+    shouldPass(1, allOf(lessThan(10), lessThan(9), lessThan(8),
+        lessThan(7), lessThan(6), lessThan(5), lessThan(4)));
     shouldFail(4, allOf(lessThan(10), lessThan(9), lessThan(8), lessThan(7),
-        lessThan(6), lessThan(5), lessThan(4)),
+            lessThan(6), lessThan(5), lessThan(4)),
         "Expected: (a value less than <10> and a value less than <9> and a "
         "value less than <8> and a value less than <7> and a value less than "
         "<6> and a value less than <5> and a value less than <4>) "
@@ -53,7 +53,7 @@
 
   test('If the first argument is a List, the rest must be null', () {
     expect(() => allOf([], 5), throwsArgumentError);
-    expect(() => anyOf([], null, null, null, null, null, 42),
-        throwsArgumentError);
+    expect(
+        () => anyOf([], null, null, null, null, null, 42), throwsArgumentError);
   });
 }
diff --git a/test/pretty_print_test.dart b/test/pretty_print_test.dart
index 27bbfad..b8bd847 100644
--- a/test/pretty_print_test.dart
+++ b/test/pretty_print_test.dart
@@ -14,8 +14,7 @@
     expect(prettyPrint(12.13), equals('<12.13>'));
     expect(prettyPrint(true), equals('<true>'));
     expect(prettyPrint(null), equals('<null>'));
-    expect(prettyPrint(() => 12),
-        matches(r'<Closure(: \(\) => dynamic)?>'));
+    expect(prettyPrint(() => 12), matches(r'<Closure(: \(\) => dynamic)?>'));
   });
 
   group('with a string', () {
@@ -24,15 +23,14 @@
     });
 
     test('containing newlines', () {
-      expect(prettyPrint('foo\nbar\nbaz'), equals(
-          "'foo\\n'\n"
+      expect(prettyPrint('foo\nbar\nbaz'), equals("'foo\\n'\n"
           "  'bar\\n'\n"
           "  'baz'"));
     });
 
     test('containing escapable characters', () {
-      expect(prettyPrint("foo\rbar\tbaz'qux"),
-          equals("'foo\\rbar\\tbaz\\'qux'"));
+      expect(
+          prettyPrint("foo\rbar\tbaz'qux"), equals("'foo\\rbar\\tbaz\\'qux'"));
     });
   });
 
@@ -78,10 +76,8 @@
     });
 
     test("factors indentation into maxLineLength", () {
-      expect(prettyPrint([
-        "foo\nbar",
-        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
-      ], maxLineLength: 30), equals("[\n"
+      expect(prettyPrint(["foo\nbar", [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],],
+          maxLineLength: 30), equals("[\n"
           "  'foo\\n'\n"
           "    'bar',\n"
           "  [\n"
@@ -173,17 +169,16 @@
 
     test("factors indentation into maxLineLength", () {
       expect(prettyPrint(["foo\nbar", {'0': 1, '2': 3, '4': 5, '6': 7}],
-              maxLineLength: 32),
-          equals("[\n"
-              "  'foo\\n'\n"
-              "    'bar',\n"
-              "  {\n"
-              "    '0': 1,\n"
-              "    '2': 3,\n"
-              "    '4': 5,\n"
-              "    '6': 7\n"
-              "  }\n"
-              "]"));
+          maxLineLength: 32), equals("[\n"
+          "  'foo\\n'\n"
+          "    'bar',\n"
+          "  {\n"
+          "    '0': 1,\n"
+          "    '2': 3,\n"
+          "    '4': 5,\n"
+          "    '6': 7\n"
+          "  }\n"
+          "]"));
     });
 
     test("that's under maxItems", () {
diff --git a/test/pretty_print_unminified_test.dart b/test/pretty_print_unminified_test.dart
index 81e7db5..c8b2035 100644
--- a/test/pretty_print_unminified_test.dart
+++ b/test/pretty_print_unminified_test.dart
@@ -42,8 +42,8 @@
     });
 
     test('with a custom [toString] and a private name', () {
-      expect(prettyPrint(new _PrivateName()),
-          equals('?:<string representation>'));
+      expect(
+          prettyPrint(new _PrivateName()), equals('?:<string representation>'));
     });
   });
 
@@ -54,8 +54,7 @@
     });
 
     test("that's not a list and has a private name", () {
-      expect(prettyPrint(new _PrivateNameIterable()),
-          equals("?:[1, 2, 3]"));
+      expect(prettyPrint(new _PrivateNameIterable()), equals("?:[1, 2, 3]"));
     });
   });
 }
diff --git a/test/prints_matcher_test.dart b/test/prints_matcher_test.dart
index 9c7dd4c..7680953 100644
--- a/test/prints_matcher_test.dart
+++ b/test/prints_matcher_test.dart
@@ -79,29 +79,24 @@
 
     test("describes a failure nicely", () {
       shouldFail(() => new Future(() => print("Hello, world!")),
-          prints("Goodbye, world!\n"),
-          "Expected: 'Goodbye, world!\\n' ''"
+          prints("Goodbye, world!\n"), "Expected: 'Goodbye, world!\\n' ''"
           "  Actual: 'Hello, world!\\n' ''"
           "   Which: is different. "
           "Expected: Goodbye, w ... "
           "  Actual: Hello, wor ... "
-          "          ^ Differ at offset 0",
-          isAsync: true);
+          "          ^ Differ at offset 0", isAsync: true);
     });
 
     test("describes a failure with a non-descriptive Matcher nicely", () {
       shouldFail(() => new Future(() => print("Hello, world!")),
-          prints(contains("Goodbye")),
-          "Expected: contains 'Goodbye'"
-          "  Actual: 'Hello, world!\\n' ''",
-          isAsync: true);
+          prints(contains("Goodbye")), "Expected: contains 'Goodbye'"
+          "  Actual: 'Hello, world!\\n' ''", isAsync: true);
     });
 
     test("describes a failure with no text nicely", () {
       shouldFail(() => new Future.value(), prints(contains("Goodbye")),
           "Expected: contains 'Goodbye'"
-          "  Actual: ''",
-          isAsync: true);
+          "  Actual: ''", isAsync: true);
     });
   });
 }
diff --git a/test/string_matchers_test.dart b/test/string_matchers_test.dart
index e2efadf..7a7acbd 100644
--- a/test/string_matchers_test.dart
+++ b/test/string_matchers_test.dart
@@ -29,13 +29,13 @@
     shouldPass('a', isNot(isEmpty));
     shouldFail('', isNot(isEmpty), 'Expected: not empty Actual: \'\'');
     shouldFail(null, isNot(isEmpty),
-      startsWith('Expected: not empty  Actual: <null>'));
+        startsWith('Expected: not empty  Actual: <null>'));
   });
 
   test('isNotEmpty', () {
     shouldFail('', isNotEmpty, startsWith("Expected: non-empty  Actual: ''"));
-    shouldFail(null, isNotEmpty,
-        startsWith("Expected: non-empty  Actual: <null>"));
+    shouldFail(
+        null, isNotEmpty, startsWith("Expected: non-empty  Actual: <null>"));
     shouldFail(0, isNotEmpty, startsWith("Expected: non-empty  Actual: <0>"));
     shouldPass('a', isNotEmpty);
   });
@@ -78,8 +78,8 @@
     shouldPass('hello', contains('o'));
     shouldPass('hello', contains('hell'));
     shouldPass('hello', contains('hello'));
-    shouldFail('hello', contains(' '),
-        "Expected: contains ' ' Actual: 'hello'");
+    shouldFail(
+        'hello', contains(' '), "Expected: contains ' ' Actual: 'hello'");
   });
 
   test('stringContainsInOrder', () {
@@ -87,18 +87,18 @@
     shouldPass('goodbye cruel world', stringContainsInOrder(['goodbye']));
     shouldPass('goodbye cruel world', stringContainsInOrder(['cruel']));
     shouldPass('goodbye cruel world', stringContainsInOrder(['world']));
+    shouldPass(
+        'goodbye cruel world', stringContainsInOrder(['good', 'bye', 'world']));
+    shouldPass(
+        'goodbye cruel world', stringContainsInOrder(['goodbye', 'cruel']));
+    shouldPass(
+        'goodbye cruel world', stringContainsInOrder(['cruel', 'world']));
     shouldPass('goodbye cruel world',
-               stringContainsInOrder(['good', 'bye', 'world']));
-    shouldPass('goodbye cruel world',
-               stringContainsInOrder(['goodbye', 'cruel']));
-    shouldPass('goodbye cruel world',
-               stringContainsInOrder(['cruel', 'world']));
-    shouldPass('goodbye cruel world',
-      stringContainsInOrder(['goodbye', 'cruel', 'world']));
+        stringContainsInOrder(['goodbye', 'cruel', 'world']));
     shouldFail('goodbye cruel world',
-      stringContainsInOrder(['goo', 'cruel', 'bye']),
-      "Expected: a string containing 'goo', 'cruel', 'bye' in order "
-      "Actual: 'goodbye cruel world'");
+        stringContainsInOrder(['goo', 'cruel', 'bye']),
+        "Expected: a string containing 'goo', 'cruel', 'bye' in order "
+        "Actual: 'goodbye cruel world'");
   });
 
   test('matches', () {
diff --git a/test/test_common.dart b/test/test_common.dart
index 93f45f3..c360fe7 100644
--- a/test/test_common.dart
+++ b/test/test_common.dart
@@ -56,4 +56,3 @@
 
   int get current => _current;
 }
-
diff --git a/test/test_utils.dart b/test/test_utils.dart
index c29bec9..4df8e2e 100644
--- a/test/test_utils.dart
+++ b/test/test_utils.dart
@@ -65,7 +65,9 @@
 }
 
 doesNotThrow() {}
-doesThrow() { throw 'X'; }
+doesThrow() {
+  throw 'X';
+}
 
 class PrefixMatcher extends Matcher {
   final String _prefix;
@@ -75,8 +77,8 @@
         (collapseWhitespace(item)).startsWith(collapseWhitespace(_prefix));
   }
 
-  Description describe(Description description) =>
-    description.add('a string starting with ').
-        addDescriptionOf(collapseWhitespace(_prefix)).
-        add(' ignoring whitespace');
+  Description describe(Description description) => description
+      .add('a string starting with ')
+      .addDescriptionOf(collapseWhitespace(_prefix))
+      .add(' ignoring whitespace');
 }
diff --git a/test/throws_matchers_test.dart b/test/throws_matchers_test.dart
index 74ff82d..f766002 100644
--- a/test/throws_matchers_test.dart
+++ b/test/throws_matchers_test.dart
@@ -12,40 +12,32 @@
 void main() {
   initUtils();
 
-
   test('throws', () {
-    shouldFail(doesNotThrow, throws,
-        matches(
-            r"Expected: throws"
-            r"  Actual: <Closure(: \(\) => dynamic "
-            r"from Function 'doesNotThrow': static\.)?>"
-            r"   Which: did not throw"));
+    shouldFail(doesNotThrow, throws, matches(r"Expected: throws"
+        r"  Actual: <Closure(: \(\) => dynamic "
+        r"from Function 'doesNotThrow': static\.)?>"
+        r"   Which: did not throw"));
     shouldPass(doesThrow, throws);
-    shouldFail(true, throws,
-        "Expected: throws"
+    shouldFail(true, throws, "Expected: throws"
         "  Actual: <true>"
         "   Which: is not a Function or Future");
   });
 
   test('throwsA', () {
     shouldPass(doesThrow, throwsA(equals('X')));
-    shouldFail(doesThrow, throwsA(equals('Y')),
-        matches(
-            r"Expected: throws 'Y'"
-            r"  Actual: <Closure(: \(\) => dynamic "
-            r"from Function 'doesThrow': static\.)?>"
-            r"   Which: threw 'X'"));
+    shouldFail(doesThrow, throwsA(equals('Y')), matches(r"Expected: throws 'Y'"
+        r"  Actual: <Closure(: \(\) => dynamic "
+        r"from Function 'doesThrow': static\.)?>"
+        r"   Which: threw 'X'"));
   });
 
   test('throwsA', () {
     shouldPass(doesThrow, throwsA(equals('X')));
-    shouldFail(doesThrow, throwsA(equals('Y')),
-        matches("Expected: throws 'Y'.*"
+    shouldFail(doesThrow, throwsA(equals('Y')), matches("Expected: throws 'Y'.*"
         "Actual: <Closure.*"
         "Which: threw 'X'"));
   });
 
-
   group('exception/error matchers', () {
     test('throwsCyclicInitializationError', () {
       expect(() => _Bicycle.foo, throwsCyclicInitializationError);
@@ -53,7 +45,7 @@
 
     test('throwsConcurrentModificationError', () {
       expect(() {
-        var a = { 'foo': 'bar' };
+        var a = {'foo': 'bar'};
         for (var k in a.keys) {
           a.remove(k);
         }
@@ -73,4 +65,3 @@
     return foo + 1;
   }
 }
-