Big merge from experimental to bleeding edge.

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 matcher;
 
 /**
  * Returns a matcher that matches empty strings, maps or collections.
  */
 const Matcher isEmpty = const _Empty();
@@ skipping 80 matching lines @@
   final _expected;
   final int _limit;
   var count;
 
   _DeepMatcher(this._expected, [limit = 1000]) : this._limit = limit;
 
   String _compareIterables(expected, actual, matcher, depth) {
     if (actual is !Iterable) {
       return 'is not Iterable';
     }
-    var expectedIterator = expected.iterator();
-    var actualIterator = actual.iterator();
+    var expectedIterator = expected.iterator;
+    var actualIterator = actual.iterator;
     var position = 0;
     String reason = null;
     while (reason == null) {
-      if (expectedIterator.hasNext) {
-        if (actualIterator.hasNext) {
-          Description r = matcher(expectedIterator.next(),
-                           actualIterator.next(),
+      if (expectedIterator.moveNext()) {
+        if (actualIterator.moveNext()) {
+          Description r = matcher(expectedIterator.current,
+                           actualIterator.current,
                            'mismatch at position ${position}',
                            depth);
           if (r != null) reason = r.toString();
           ++position;
         } else {
           reason = 'shorter than expected';
         }
-      } else if (actualIterator.hasNext) {
+      } else if (actualIterator.moveNext()) {
         reason = 'longer than expected';
       } else {
         return null;
       }
     }
     return reason;
   }
 
   Description _recursiveMatch(expected, actual, String location, int depth) {
     Description reason = null;
@@ skipping 149 matching lines @@
 class Throws extends BaseMatcher {
   final Matcher _matcher;
 
   const Throws([Matcher matcher]) :
     this._matcher = matcher;
 
   bool matches(item, MatchState matchState) {
     if (item is Future) {
       // Queue up an asynchronous expectation that validates when the future
       // completes.
-      item.onComplete(wrapAsync((future) {
-        if (future.hasValue) {
-          expect(false, isTrue, reason:
-              "Expected future to fail, but succeeded with '${future.value}'.");
-        } else if (_matcher != null) {
-          var reason;
-          if (future.stackTrace != null) {
-            var stackTrace = future.stackTrace.toString();
-            stackTrace = "  ${stackTrace.replaceAll("\n", "\n  ")}";
-            reason = "Actual exception trace:\n$stackTrace";
-          }
-          expect(future.exception, _matcher, reason: reason);
+      item.then((value) {
+        expect(false, isTrue, reason:
+            "Expected future to fail, but succeeded with '$value'.");
+      });
+
+      item.catchError((e) {
+        var reason;
+        if (e.stackTrace != null) {
+          var stackTrace = e.stackTrace.toString();
+          stackTrace = "  ${stackTrace.replaceAll("\n", "\n  ")}";
+          reason = "Actual exception trace:\n$stackTrace";
         }
-      }));
+        expect(e.error, _matcher, reason: reason);
+      });
 
       // It hasn't failed yet.
       return true;
     }
 
     try {
       item();
       return false;
     } catch (e, s) {
       if (_matcher == null ||_matcher.matches(e, matchState)) {
@@ skipping 255 matching lines @@
 
   final _expected;
 
   const _Contains(this._expected);
 
   bool matches(item, MatchState matchState) {
     if (item is String) {
       return item.indexOf(_expected) >= 0;
     } else if (item is Collection) {
       if (_expected is Matcher) {
-        return item.some((e) => _expected.matches(e, matchState));
+        return item.any((e) => _expected.matches(e, matchState));
       } else {
-        return item.some((e) => e == _expected);
+        return item.any((e) => e == _expected);
       }
     } else if (item is Map) {
       return item.containsKey(_expected);
     }
     return false;
   }
 
   Description describe(Description description) =>
       description.add('contains ').addDescriptionOf(_expected);
 }
 
 /**
  * Returns a matcher that matches if the match argument is in
  * the expected value. This is the converse of [contains].
  */
 Matcher isIn(expected) => new _In(expected);
 
 class _In extends BaseMatcher {
 
   final _expected;
 
   const _In(this._expected);
 
   bool matches(item, MatchState matchState) {
     if (_expected is String) {
       return _expected.indexOf(item) >= 0;
     } else if (_expected is Collection) {
-      return _expected.some((e) => e == item);
+      return _expected.any((e) => e == item);
     } else if (_expected is Map) {
       return _expected.containsKey(item);
     }
     return false;
   }
 
   Description describe(Description description) =>
       description.add('is in ').addDescriptionOf(_expected);
 }
 
@@ skipping 60 matching lines @@
       description.add(_featureDescription).add(' ').addDescriptionOf(_matcher);
 
   Description describeMismatch(item, Description mismatchDescription,
                                MatchState matchState, bool verbose) {
     mismatchDescription.add(_featureName).add(' ');
     _matcher.describeMismatch(matchState.state['feature'], mismatchDescription,
         matchState.state['innerState'], verbose);
     return mismatchDescription;
   }
 }