pkg/unittest: formatter spin

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).
  */
@@ skipping 81 matching lines @@
 
 class _DeepMatcher extends Matcher {
   final _expected;
   final int _limit;
   var count;
 
   _DeepMatcher(this._expected, [limit = 1000]) : this._limit = limit;
 
   // Returns a pair (reason, location)
   List _compareIterables(expected, actual, matcher, depth, location) {
-    if (actual is !Iterable) {
+    if (actual is! Iterable) {
       return ['is not Iterable', location];
     }
     var expectedIterator = expected.iterator;
     var actualIterator = actual.iterator;
     var index = 0;
     while (true) {
       var newLocation = '${location}[${index}]';
       if (expectedIterator.moveNext()) {
         if (actualIterator.moveNext()) {
           var rp = matcher(expectedIterator.current,
@@ skipping 13 matching lines @@
     return null;
   }
 
   List _recursiveMatch(expected, actual, String location, int depth) {
     String reason = null;
     // If _limit is 1 we can only recurse one level into object.
     bool canRecurse = depth == 0 || _limit > 1;
     bool equal;
     try {
       equal = (expected == actual);
-    } catch (e,s) {
+    } catch (e, s) {
       // TODO(gram): Add a test for this case.
       reason = '== threw "$e"';
       return [reason, location];
     }
     if (equal) {
       // Do nothing.
     } else if (depth > _limit) {
       reason = 'recursion depth limit exceeded';
     } else {
       if (expected is Iterable && canRecurse) {
         List result = _compareIterables(expected, actual,
             _recursiveMatch, depth + 1, location);
         if (result != null) {
           reason = result[0];
           location = result[1];
         }
       } else if (expected is Map && canRecurse) {
-        if (actual is !Map) {
+        if (actual is! Map) {
           reason = 'expected a map';
         } else {
           var err = (expected.length == actual.length) ? '' :
                     'has different length and ';
           for (var key in expected.keys) {
             if (!actual.containsKey(key)) {
               reason = '${err}is missing map key \'$key\'';
               break;
             }
           }
           if (reason == null) {
             for (var key in actual.keys) {
               if (!expected.containsKey(key)) {
                 reason = '${err}has extra map key \'$key\'';
                 break;
               }
             }
             if (reason == null) {
               for (var key in expected.keys) {
                 var rp = _recursiveMatch(expected[key], actual[key],
-                    "${location}['${key}']", depth+1);
+                    "${location}['${key}']", depth + 1);
                 if (rp != null) {
                   reason = rp[0];
                   location = rp[1];
                   break;
                 }
               }
             }
           }
         }
       } else {
         var description = new StringDescription();
         // If we have recursed, show the expected value too; if not,
         // expect() will show it for us.
         if (depth > 0) {
           description.add('was ').
               addDescriptionOf(actual).
               add(' instead of ').
               addDescriptionOf(expected);
           reason = description.toString();
         } else {
           reason = ''; // We're not adding any value to the actual value.
         }
       }
     }
     if (reason == null) return null;
     return [reason, location];
   }
 
   String _match(expected, actual, Map matchState) {
-    var rp  = _recursiveMatch(expected, actual, '', 0);
+    var rp = _recursiveMatch(expected, actual, '', 0);
     if (rp == null) return null;
     var reason;
     if (rp[0].length > 0) {
       if (rp[1].length > 0) {
         reason = "${rp[0]} at location ${rp[1]}";
       } else {
         reason = rp[0];
       }
     } else {
       reason = '';
@@ skipping 215 matching lines @@
         });
       });
       // It hasn't failed yet.
       return true;
     }
 
     try {
       item();
       return false;
     } catch (e, s) {
-      if (_matcher == null ||_matcher.matches(e, matchState)) {
+      if (_matcher == null || _matcher.matches(e, matchState)) {
         return true;
       } else {
         addStateInfo(matchState, {'exception': e, 'stack': s});
         return false;
       }
     }
   }
 
   Description describe(Description description) {
     if (_matcher == null) {
@@ skipping 433 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;
   }
 }