Updated contains and isEmpty matches to use iterables.

pkg/unittest/test/matchers_test.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 unittestTests;
 import 'package:unittest/unittest.dart';
 import 'dart:async';
 part 'test_utils.dart';
 
 doesNotThrow() {}
@@ skipping 16 matching lines @@
 class Widget {
   int price;
 }
 
 class HasPrice extends CustomMatcher {
   const HasPrice(matcher) :
     super("Widget with a price that is", "price", matcher);
   featureValueOf(actual) => actual.price;
 }
 
+class SimpleIterable extends Iterable {
+  int count;
+  SimpleIterable(this.count);
+  
+  bool contains(int val) => count < val ? false : true;
+  
+  bool any(bool f(element)) {
+    for(var i = 0; i <= count; i++) {
+      if(f(i)) return true;
+    }
+    return false;
+  }
+  
+  String toString() => "<[$count]>";
+
+  Iterator get iterator {
+    return new SimpleIterator(count);
+  }
+}
+
+class SimpleIterator implements Iterator {
+  int _count;
+  int _current;
+
+  SimpleIterator(this._count);
+
+  bool moveNext() {
+    if (_count > 0) {
+      _current = _count;
+      _count--;
+      return true;
+    }
+    _current = null;
+    return false;
+  }
+
+  get current => _current;
+}
+
 void main() {
 
   initUtils();
 
   // Core matchers
 
   group('Core matchers', () {
 
     test('isTrue', () {
       shouldPass(true, isTrue);
@@ skipping 111 matching lines @@
 
     test('throwsUnsupportedError', () {
       shouldPass(() { throw new UnsupportedError(''); },
           throwsUnsupportedError);
       shouldFail(() { throw new Exception(); },
           throwsUnsupportedError,
         "Expected: throws an exception which matches UnsupportedError "
         "but:  exception <Exception> does not match "
             "UnsupportedError.");
     });
+    
+    test('throwsStateError', () {
+      shouldPass(() { throw new StateError(''); },
+          throwsStateError);
+      shouldFail(() { throw new Exception(); },
+          throwsStateError,
+        "Expected: throws an exception which matches StateError "
+        "but:  exception <Exception> does not match "
+            "StateError.");
+    });
 
     test('returnsNormally', () {
       shouldPass(doesNotThrow, returnsNormally);
       shouldFail(doesThrow, returnsNormally,
         "Expected: return normally but: threw 'X'.");
     });
 
     test('hasLength', () {
       var a = new Map();
       var b = new List();
@@ skipping 203 matching lines @@
     });
 
     test('matches', () {
       shouldPass('c0d', matches('[a-z][0-9][a-z]'));
       shouldPass('c0d', matches(new RegExp('[a-z][0-9][a-z]')));
       shouldFail('cOd', matches('[a-z][0-9][a-z]'),
           "Expected: match '[a-z][0-9][a-z]' but: was 'cOd'.");
     });
   });
 
+  group('Iterable Matchers', () {
+    test('isEmpty', () {
+      var d = new SimpleIterable(0);
+      var e = new SimpleIterable(1);
+      shouldPass(d, isEmpty);
+      shouldFail(e, isEmpty, "Expected: empty but: was <[1]>.");
+    });
+    
+    test('contains', () {
+      var d = new SimpleIterable(3);
+      shouldPass(d, contains(2));
+      shouldFail(d, contains(5), "Expected: contains <5> but: was <[3]>.");
+    });
+  });
+  
   group('Collection Matchers', () {
 
     test('isEmpty', () {
       shouldPass([], isEmpty);
       shouldFail([1], isEmpty, "Expected: empty but: was <[1]>.");
     });
 
     test('contains', () {
       var d = [1, 2];
       shouldPass(d, contains(1));
@@ skipping 188 matching lines @@
       var w = new Widget();
       w.price = 10;
       shouldPass(w, new HasPrice(greaterThan(0)));
       shouldFail(w, new HasPrice(greaterThan(10)),
           'Expected: Widget with a price that is a value greater than <10> '
           'but: price was <10>.');
     });
   });
 }