Added test setup/teardown.

lib/unittest/collection_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.
 
 /**
  * Returns a matcher which matches [Collection]s in which all elements
  * match the given [matcher].
  */
 Matcher everyElement(matcher) => new _EveryElement(wrapMatcher(matcher));
 
@@ skipping 25 matching lines @@
     return item.some( (e) => _matcher.matches(e) );
   }
 
   Description describe(Description description) =>
       description.add('some element ').addDescriptionOf(_matcher);
 }
 
 /**
  * Returns a matcher which matches [Iterable]s that have the same
  * length and the same elements as [expected], and in the same order.
+ * This is equivalent to equals but does not recurse.
  */
+
 Matcher orderedEquals(Iterable expected) => new _OrderedEquals(expected);
 
 class _OrderedEquals extends BaseMatcher {
-  Iterable _expected;
+  final Iterable _expected;
+  Matcher _matcher;
 
-  _OrderedEquals(this._expected);
-
-  String _test(item) {
-    return _compareIterables(_expected, item,
-      (expected, actual, location) => expected == actual? null : location);
+  _OrderedEquals(this._expected) {
+    _matcher = equals(_expected, 1);
   }
 
-  bool matches(item) => (_test(item) == null);
+  bool matches(item) => (item is Iterable) && _matcher.matches(item);
 
   Description describe(Description description) =>
       description.add('equals ').addDescriptionOf(_expected).add(' ordered');
 
-  Description describeMismatch(item, Description mismatchDescription) =>
-      mismatchDescription.add(_test(item));
+  Description describeMismatch(item, Description mismatchDescription) {
+    if (item is !Iterable) {
+      return mismatchDescription.add('not an Iterable');
+    } else {
+      return _matcher.describeMismatch(item, mismatchDescription);
+    }
+  }
 }
-
 /**
  * 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 BaseMatcher {
@@ skipping 39 matching lines @@
       for (var actualElement in item) {
         if (!matched[actualPosition]) {
           if (expectedElement == actualElement) {
             matched[actualPosition] = gotMatch = true;
             break;
           }
         }
         ++actualPosition;
       }
       if (!gotMatch) {
-        return 'has no match for element ${expectedElement} '
-               'at position ${expectedPosition}';
+        Description reason = new StringDescription();
+        reason.add('has no match for element ').
+            addDescriptionOf(expectedElement).
+            add(' at position ${expectedPosition}');
+        return reason.toString();
       }
       ++expectedPosition;
     }
     return null;
   }
 
   bool matches(item) => (_test(item) == null);
 
   Description describe(Description description) =>
       description.add('equals ').addDescriptionOf(_expected).add(' unordered');
 
   Description describeMismatch(item, Description mismatchDescription) =>
       mismatchDescription.add(_test(item));
 }
 
 /**
  * Collection matchers match against [Collection]s. We add this intermediate
  * class to give better mismatch error messages than the base Matcher class.
  */
-
-/*abstract*/ class _CollectionMatcher extends BaseMatcher {
+/* abstract */ class _CollectionMatcher extends BaseMatcher {
   const _CollectionMatcher();
   Description describeMismatch(item, Description mismatchDescription) {
     if (item is !Collection) {
       return mismatchDescription.
           addDescriptionOf(item).
           add(' not a collection');
     } else {
       return super.describeMismatch(item, mismatchDescription);
     }
   }
 }