Compare sets order-independently in pkg/matcher.

pkg/matcher/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.
 
 library matcher.core_matchers;
 
 import 'dart:async';
 
 import 'description.dart';
 import 'expect.dart';
@@ skipping 67 matching lines @@
 }
 
 /// Returns a matcher that matches if the value is structurally equal to
 /// [expected].
 ///
 /// If [expected] is a [Matcher], then it matches using that. Otherwise it tests
 /// for equality using `==` on the expected value.
 ///
 /// 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.
+/// 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);
 
 class _DeepMatcher extends Matcher {
   final _expected;
   final int _limit;
   var count;
 
@@ skipping 18 matching lines @@
       if (!expectedNext) return ['longer than expected', newLocation];
       if (!actualNext) return ['shorter than expected', newLocation];
 
       // Match the elements.
       var rp = matcher(expectedIterator.current, actualIterator.current,
           newLocation, depth);
       if (rp != null) return rp;
     }
   }
 
+  List _compareSets(Set expected, actual, matcher, depth, location) {
+    if (actual is! Iterable) return ['is not Iterable', location];
+    actual = actual.toSet();
+
+    for (var expectedElement in expected) {
+      if (actual.every((actualElement) =>
+          matcher(expectedElement, actualElement, location, depth) != null)) {
+        return ['does not contain $expectedElement', location];
+      }
+    }
+
+    if (actual.length > expected.length) {
+      return ['larger than expected', location];
+    } else if (actual.length < expected.length) {
+      return ['smaller than expected', location];
+    } else {
+      return null;
+    }
+  }
+
   List _recursiveMatch(expected, actual, String location, int depth) {
     // 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;
+    if (depth == 0 || _limit > 1) {
+      if (expected is Set) {
+        return _compareSets(expected, actual, _recursiveMatch, depth + 1,
+            location);
+      } else if (expected is Iterable) {
+        return _compareIterables(expected, actual, _recursiveMatch, depth + 1,
+            location);
+      } else if (expected is Map) {
+        if (actual is! Map) return ['expected a map', location];
 
-    if (expected is Iterable && canRecurse) {
-      return _compareIterables(expected, actual, _recursiveMatch, depth + 1,
-          location);
-    }
+        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];
+          }
+        }
 
-    if (expected is Map && canRecurse) {
-      if (actual is! Map) return ['expected a map', location];
+        for (var key in actual.keys) {
+          if (!expected.containsKey(key)) {
+            return ["${err}has extra map key '$key'", location];
+          }
+        }
 
-      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 expected.keys) {
+          var rp = _recursiveMatch(expected[key], actual[key],
+              "${location}['${key}']", depth + 1);
+          if (rp != null) return rp;
         }
+
+        return null;
       }
-
-      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;
     }
 
     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 ').
@@ skipping 509 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;
   }
 }