Added hasProperty matcher.

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.
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:unittest/unittest.dart';
 
 import 'test_common.dart';
@@ skipping 185 matching lines @@
     test('lessThanOrEqualTo', () {
       shouldPass(10, lessThanOrEqualTo(10));
       shouldFail(11, lessThanOrEqualTo(10),
         "Expected: a value less than or equal to <10> "
         "Actual: <11> "
         "Which: is not a value less than or equal to <10>");
     });
 
     test('isZero', () {
       shouldPass(0, isZero);
-      shouldFail(1, isZero, 
+      shouldFail(1, isZero,
           "Expected: a value equal to <0> "
           "Actual: <1> "
           "Which: is not a value equal to <0>");
     });
 
     test('isNonZero', () {
       shouldFail(0, isNonZero,
           "Expected: a value not equal to <0> "
           "Actual: <0> "
           "Which: is not a value not equal to <0>");
       shouldPass(1, isNonZero);
     });
 
     test('isPositive', () {
       shouldFail(-1, isPositive,
           "Expected: a positive value "
           "Actual: <-1> "
           "Which: is not a positive value");
-      shouldFail(0, isPositive, 
+      shouldFail(0, isPositive,
           "Expected: a positive value "
           "Actual: <0> "
           "Which: is not a positive value");
       shouldPass(1, isPositive);
     });
 
     test('isNegative', () {
       shouldPass(-1, isNegative);
       shouldFail(0, isNegative,
           "Expected: a negative value "
@@ skipping 185 matching lines @@
     test('nested everyElement', () {
       var d = [['foo', 'bar'], ['foo'], []];
       var e = [['foo', 'bar'], ['foo'], 3, []];
       shouldPass(d, everyElement(anyOf(isEmpty, contains('foo'))));
       shouldFail(d, everyElement(everyElement(equals('foo'))),
           "Expected: every element(every element('foo')) "
           "Actual: [['foo', 'bar'], ['foo'], []] "
           "Which: has value ['foo', 'bar'] which has value 'bar' "
           "which is different. Expected: foo Actual: bar ^ "
           "Differ at offset 0 at index 1 at index 0");
-      shouldFail(d, everyElement(allOf(hasLength(greaterThan(0)), 
+      shouldFail(d, everyElement(allOf(hasLength(greaterThan(0)),
           contains('foo'))),
            "Expected: every element((an object with length of a value "
            "greater than <0> and contains 'foo')) "
            "Actual: [['foo', 'bar'], ['foo'], []] "
            "Which: has value [] which has length of <0> at index 2");
       shouldFail(d, everyElement(allOf(contains('foo'),
           hasLength(greaterThan(0)))),
           "Expected: every element((contains 'foo' and "
           "an object with length of a value greater than <0>)) "
           "Actual: [['foo', 'bar'], ['foo'], []] "
@@ skipping 296 matching lines @@
       expect(() {
         var a = 0;
         switch (a) {
           case 0:
             a += 1;
           case 1:
             return;
         }
       }, throwsFallThroughError);
     });
+
+    test('hasProperty', () {
+      var foo = [3];
+      expect(foo, hasProperty('length', 1));
+      expect(() => expect(foo, hasProperty('foo')),
+        throwsA(predicate((x) => x is TestFailure &&
+          x.toString().contains('No property named foo'))));
+      expect(() => expect(foo, hasProperty('length', 2)),
+        throwsA(predicate((x) => x is TestFailure &&
+          x.toString().contains(
+            'has property length with value <1>'))));
+
+    });
   });
 }
 
 class Bicycle {
   static var foo = bar();
 
   static bar() {
     return foo + 1;
   }
 
   X() {
     print(foo);
   }
 }
- 
+
 abstract class Abstraction {
   void norealization();
 }