Add an [unorderedMatches] matcher to unittest.

pkg/unittest/lib/src/iterable_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 which matches [Iterable]s in which all elements
  * match the given [matcher].
  */
@@ skipping 90 matching lines @@
   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);
     }
   }
 }
+
 /**
  * Returns a matcher which matches [Iterable]s that have the same
  * length and the same elements as [expected], but not necessarily in
  * the same order. Note that this is O(n^2) so should only be used on
  * small objects.
  */
 Matcher unorderedEquals(Iterable expected) =>
     new _UnorderedEquals(expected);
 
 class _UnorderedEquals extends Matcher {
   Iterable _expected;
 
   _UnorderedEquals(Iterable this._expected);
 
   String _test(item) {
     if (item is !Iterable) {
       return 'not iterable';
     }
     // Check the lengths are the same.
     var expectedLength = _expected.length;
     var actualLength = item.length;
     if (expectedLength > actualLength) {
       return 'has too few elements (${actualLength} < ${expectedLength})';
     } else if (expectedLength < actualLength) {
       return 'has too many elements (${actualLength} > ${expectedLength})';
     }
     List<bool> matched = new List<bool>(actualLength);

[Siggi Cherem (dart-lang), 2013/12/17 00:32:03]

might be worth adjusting this too (use the filled constructor like you did
below)

     for (var i = 0; i < actualLength; i++) {
       matched[i] = false;
     }
     var expectedPosition = 0;
     for (var expectedElement in _expected) {
       var actualPosition = 0;
       var gotMatch = false;
       for (var actualElement in item) {
         if (!matched[actualPosition]) {
           if (expectedElement == actualElement) {
@@ skipping 38 matching lines @@
           addDescriptionOf(item).
           add(' not an Iterable');
     } else {
       return super.describeMismatch(item, mismatchDescription, matchState,
         verbose);
     }
   }
 }
 
 /**
+ * Returns a matcher which matches [Iterable]s whose elements match the matchers
+ * in [expected], but not necessarily in the same order.
+ *
+ *  Note that this is `O(n^2)` and so should only be used on small objects.
+ */
+Matcher unorderedMatches(Iterable expected) =>
+    new _UnorderedMatches(expected);
+
+class _UnorderedMatches extends Matcher {

[Siggi Cherem (dart-lang), 2013/12/17 00:32:03]

seems like there is a lot of code in common here and with _UnorderedEquals. Is
there any way we could combine some of this code? For example, pass in a
equality sub-matcher here as a default?

[nweiz, 2013/12/17 03:33:47]

I intentionally avoided going too deep on modifying existing unittest stuff,
since it's nearing the end of its life and it seemed like it wouldn't be effort
well-spent. If you'd like me to, I can, but I don't think it will provide much
value.

[Siggi Cherem (dart-lang), 2013/12/17 18:48:45]

I think it is worth the effort for the matchers library.

I agree that unittest needs to be rewritten and we shouldn't try to change it
much, but I had that in mind only for the core of unittest (the running logic
and declarations). I think 'matchers' and 'mock' are fine as they are, or can be
upgraded incrementally, so we should keep maintaining them. I actually thought
we will pull them into separate packages and let unittest (and any future
testing package) re-export them.

+  final List<Matcher> _expected;
+
+  _UnorderedMatches(Iterable expected)
+      : _expected = expected.map(wrapMatcher).toList();
+
+  String _test(item) {
+    if (item is !Iterable) return 'not iterable';
+    item = item.toList();
+
+    // Check the lengths are the same.
+    if (_expected.length > item.length) {
+      return 'has too few elements (${item.length} < ${_expected.length})';
+    } else if (_expected.length < item.length) {
+      return 'has too many elements (${item.length} > ${_expected.length})';
+    }
+
+    var matched = new List<bool>.filled(item.length, false);
+    var expectedPosition = 0;
+    for (var expectedMatcher in _expected) {
+      var actualPosition = 0;
+      var gotMatch = false;
+      for (var actualElement in item) {
+        if (!matched[actualPosition]) {
+          if (expectedMatcher.matches(actualElement, {})) {
+            matched[actualPosition] = gotMatch = true;
+            break;
+          }
+        }
+        ++actualPosition;
+      }
+
+      if (!gotMatch) {
+        return new StringDescription()
+            .add('has no match for ')
+            .addDescriptionOf(expectedMatcher)
+            .add(' at index ${expectedPosition}')
+            .toString();
+      }
+
+      ++expectedPosition;
+    }
+    return null;
+  }
+
+  bool matches(item, Map mismatchState) => _test(item) == null;
+
+  Description describe(Description description) =>
+    description
+      .add('matches ')
+      .addAll('[', ', ', ']', _expected)
+      .add(' unordered');
+
+  Description describeMismatch(item, Description mismatchDescription,
+                               Map matchState, bool verbose) =>
+      mismatchDescription.add(_test(item));
+}
+
+/**
  * A pairwise matcher for iterable. You can pass an arbitrary [comparator]
  * function that takes an expected and actual argument which will be applied
  * to each pair in order. [description]  should be a meaningful name for
  * the comparator.
  */
 Matcher pairwiseCompare(Iterable expected, Function comparator,
     String description) =>
         new _PairwiseCompare(expected, comparator, description);
 
 class _PairwiseCompare extends _IterableMatcher {
@@ skipping 34 matching lines @@
       return mismatchDescription.
           add('has ').
           addDescriptionOf(matchState["actual"]).
           add(' which is not $_description ').
           addDescriptionOf(matchState["expected"]).
           add(' at index ${matchState["index"]}');
     }
   }
 }