Support nested matchers in deep equality matching.

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) {
-      return ['is not Iterable', location];
-    }
+    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,
-                           actualIterator.current, newLocation,
-                           depth);
+          var rp = matcher(expectedIterator.current, actualIterator.current,
+              newLocation, depth);
           if (rp != null) return rp;
-          ++index;
+          index++;
         } else {
           return ['shorter than expected', newLocation];
         }
       } else if (actualIterator.moveNext()) {
         return ['longer than expected', newLocation];
       } else {
         return null;
       }

[Siggi Cherem (dart-lang), 2014/02/28 02:41:04]

since you are already fixing style :), consider changing the 5 lines above to:

if (actualIterator.moveNext()) return ['longer than expected', newL];
return null;

[Bob Nystrom, 2014/02/28 17:31:24]

Done, and then some.

     }
-    return null;
   }
 
   List _recursiveMatch(expected, actual, String location, int depth) {
-    String reason = null;
+    // If the expected value is a matcher, try to match it.
+    if (expected is Matcher) {
+      var matchState = {};
+      if (expected.matches(actual, matchState)) return null;
+
+      var description = new StringDescription();
+      expected.describe(description);
+      return ['does not match $description', location];
+    } else {
+      // Otherwise, test for equality.
+      try {
+        if (expected == actual) return null;
+      } catch (e, s) {
+        // TODO(gram): Add a test for this case.
+        return ['== threw "$e"', location];
+      }
+    }
+
+    if (depth > _limit) {
+      return ['recursion depth limit exceeded', location];
+    }
+
     // 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) {
-      // TODO(gram): Add a test for this case.
-      reason = '== threw "$e"';
-      return [reason, location];
+
+    if (expected is Iterable && canRecurse) {
+      return _compareIterables(expected, actual, _recursiveMatch, depth + 1,
+          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) {
-          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);
-                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 (expected is Map && canRecurse) {
+      if (actual is! Map) {
+        return ['expected a map', location];

[Siggi Cherem (dart-lang), 2014/02/28 02:41:04]

nit: this might fit the 1-line if:
   if(...) return ...;

[Bob Nystrom, 2014/02/28 17:31:24]

Done.

+      }
+
+      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];
         }
       }
+
+      for (var key in actual.keys) {
+        if (!expected.containsKey(key)) {
+          return ["${err}has extra map key '$key'", location];
+        }
+      }
+
+      for (var key in expected.keys) {
+        var rp = _recursiveMatch(expected[key], actual[key],
+            "${location}['${key}']", depth + 1);
+        if (rp != null) return rp;
+      }
+
+      return null;
     }
-    if (reason == null) return null;
-    return [reason, location];
+
+    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);
+      return [description.toString(), location];
+    }
+
+    // We're not adding any value to the actual value.
+    return ["", location];
   }
 
   String _match(expected, actual, Map matchState) {
     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 {
@@ skipping 673 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;
   }
 }