Added test setup/teardown.

tests/lib/unittest/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('matcherTest');
 #import('../../../lib/unittest/unittest.dart');
 #source('test_utils.dart');
 
 doesNotThrow() {}
 doesThrow() { throw 'X'; }
@@ skipping 44 matching lines @@
       var a = new Map();
       var b = new Map();
       shouldPass(a, same(a));
       shouldFail(b, same(a), "Expected: same instance as <{}> but: was <{}>");
     });
 
     test('equals', () {
       var a = new Map();
       var b = new Map();
       shouldPass(a, equals(a));
-      shouldFail(a, equals(b), "Expected: <{}> but: was <{}>");
+      shouldPass(a, equals(b));
     });
 
     test('anything', () {
       var a = new Map();
       shouldPass(0, anything);
       shouldPass(null, anything);
       shouldPass(a, anything);
       shouldFail(a, isNot(anything), "Expected: not anything but: was <{}>");
     });
 
     test('throws', () {
       shouldFail(doesNotThrow, throws,
         "Expected: throws an exception but: no exception");
       shouldPass(doesThrow, throws);
     });
 
+    test('throwsA', () {
+      shouldPass(doesThrow, throwsA(equals('X')));
+      shouldFail(doesThrow, throwsA(equals('Y')),
+        "Expected: throws an exception which matches 'Y' "
+        "but:  no exception or exception does not match 'Y'");
+    });
+
+    test('throwsBadNumberFormatException', () {
+      shouldPass(() { throw new BadNumberFormatException(''); },
+          throwsBadNumberFormatException);
+      shouldFail(() { throw new Exception(); },
+          throwsBadNumberFormatException,
+        "Expected: throws an exception which matches BadNumberFormatException "
+        "but:  no exception or exception does not match "
+            "BadNumberFormatException");
+    });
+
+    test('throwsIllegalArgumentException', () {
+      shouldPass(() { throw new IllegalArgumentException(''); },
+          throwsIllegalArgumentException);
+      shouldFail(() { throw new Exception(); },
+          throwsIllegalArgumentException,
+        "Expected: throws an exception which matches IllegalArgumentException "
+        "but:  no exception or exception does not match "
+            "IllegalArgumentException");
+    });
+
+    test('throwsIllegalJSRegExpException', () {
+      shouldPass(() { throw new IllegalJSRegExpException('',''); },
+          throwsIllegalJSRegExpException);
+      shouldFail(() { throw new Exception(); },
+          throwsIllegalJSRegExpException,
+        "Expected: throws an exception which matches IllegalJSRegExpException "
+        "but:  no exception or exception does not match "
+            "IllegalJSRegExpException");
+    });
+
+    test('throwsIndexOutOfRangeException', () {
+      shouldPass(() { throw new IndexOutOfRangeException(''); },
+          throwsIndexOutOfRangeException);
+      shouldFail(() { throw new Exception(); },
+          throwsIndexOutOfRangeException,
+        "Expected: throws an exception which matches IndexOutOfRangeException "
+        "but:  no exception or exception does not match "
+            "IndexOutOfRangeException");
+    });
+
+    test('throwsNoSuchMethodException', () {
+      shouldPass(() { throw new NoSuchMethodException(null, '', null); },
+          throwsNoSuchMethodException);
+      shouldFail(() { throw new Exception(); },
+          throwsNoSuchMethodException,
+        "Expected: throws an exception which matches NoSuchMethodException "
+        "but:  no exception or exception does not match "
+            "NoSuchMethodException");
+    });
+
+    test('throwsNotImplementedException', () {
+      shouldPass(() { throw new NotImplementedException(''); },
+          throwsNotImplementedException);
+      shouldFail(() { throw new Exception(); },
+          throwsNotImplementedException,
+        "Expected: throws an exception which matches NotImplementedException "
+        "but:  no exception or exception does not match "
+            "NotImplementedException");
+    });
+
+    test('throwsNullPointerException', () {
+      shouldPass(() { throw new NullPointerException(''); },
+          throwsNullPointerException);
+      shouldFail(() { throw new Exception(); },
+          throwsNullPointerException,
+        "Expected: throws an exception which matches NullPointerException "
+        "but:  no exception or exception does not match "
+            "NullPointerException");
+    });
+
+    test('throwsUnsupportedOperationException', () {
+      shouldPass(() { throw new UnsupportedOperationException(''); },
+          throwsUnsupportedOperationException);
+      shouldFail(() { throw new Exception(); },
+          throwsUnsupportedOperationException,
+        "Expected: throws an exception which matches "
+            "UnsupportedOperationException "
+        "but:  no exception or exception does not match "
+            "UnsupportedOperationException");
+    });
+
     test('returnsNormally', () {
       shouldPass(doesNotThrow, returnsNormally);
       shouldFail(doesThrow, returnsNormally,
         "Expected: return normally but: threw exception");
     });
 
     test('hasLength', () {
       var a = new Map();
       var b = new List();
       shouldPass(a, hasLength(0));
@@ skipping 126 matching lines @@
 
     test('inClosedOpenRange', () {
       shouldPass(0, inClosedOpenRange(0,2));
       shouldPass(1, inClosedOpenRange(0,2));
       shouldFail(2, inClosedOpenRange(0,2),
           "Expected: be in range from 0 (inclusive) to 2 (exclusive) "
           "but: was <2>");
     });
   });
 
-
   group('String Matchers', () {
 
     test('isEmpty', () {
       shouldPass('', isEmpty);
       shouldFail(null, isEmpty,
           "Expected: empty but: was <null>");
       shouldFail(0, isEmpty,
           "Expected: empty but: was <0>");
       shouldFail('a', isEmpty, "Expected: empty but: was 'a'");
     });
@@ skipping 69 matching lines @@
       shouldPass([], isEmpty);
       shouldFail([1], isEmpty, "Expected: empty but: was <[1]>");
     });
 
     test('contains', () {
       var d = [1, 2];
       shouldPass(d, contains(1));
       shouldFail(d, contains(0), "Expected: contains <0> but: was <[1, 2]>");
     });
 
+    test('isIn', () {
+      var d = [1, 2];
+      shouldPass(1, isIn(d));
+      shouldFail(0, isIn(d), "Expected: is in <[1, 2]> but: was <0>");
+    });
 
     test('everyElement', () {
       var d = [1, 2];
       var e = [1, 1, 1];
       shouldFail(d, everyElement(1),
           "Expected: every element <1> but: was <[1, 2]>");
       shouldPass(e, everyElement(1));
     });
 
     test('someElement', () {
       var d = [1, 2];
       var e = [1, 1, 1];
       shouldPass(d, someElement(2));
       shouldFail(e, someElement(2),
           "Expected: some element <2> but: was <[1, 1, 1]>");
     });
 
     test('orderedEquals', () {
+      shouldPass([null], orderedEquals([null]));
       var d = [1, 2];
       shouldPass(d, orderedEquals([1, 2]));
       shouldFail(d, orderedEquals([2, 1]),
           "Expected: equals <[2, 1]> ordered "
-          "but: mismatch at position 0");
+          "but: was <1> mismatch at position 0");
     });
 
     test('unorderedEquals', () {
       var d = [1, 2];
       shouldPass(d, unorderedEquals([2, 1]));
       shouldFail(d, unorderedEquals([1]),
           "Expected: equals <[1]> unordered "
           "but: has too many elements (2 > 1)");
       shouldFail(d, unorderedEquals([3, 2, 1]),
           "Expected: equals <[3, 2, 1]> unordered "
           "but: has too few elements (2 < 3)");
       shouldFail(d, unorderedEquals([3, 1]),
           "Expected: equals <[3, 1]> unordered "
-          "but: has no match for element 3 at position 0");
+          "but: has no match for element <3> at position 0");
     });
   });
 
   group('Map Matchers', () {
 
     test('isEmpty', () {
       var a = new Map();
       shouldPass({}, isEmpty);
       shouldPass(a, isEmpty);
       a['foo'] = 'bar';
@@ skipping 21 matching lines @@
 
     test('containsPair', () {
       var a = new Map();
       a['foo'] = 'bar';
       shouldPass(a, containsPair('foo', 'bar'));
       shouldFail(a, containsPair('foo', 'ba'),
           "Expected: contains pair 'foo' => 'ba' "
           "but:  contains key 'foo' but with value was 'bar'");
       shouldFail(a, containsPair('fo', 'bar'),
           "Expected: contains pair 'fo' => 'bar' "
-          "but: <{foo: bar}>' doesn't contain key ''fo'");
+          "but: <{foo: bar}> doesn't contain key 'fo'");
     });
 
     test('hasLength', () {
       var a = new Map();
       a['foo'] = 'bar';
       var b = new Map();
       shouldPass(a, hasLength(1));
       shouldFail(b, hasLength(1),
           "Expected: an object with length of <1> "
           "but: was <{}> with length of <0>");
     });
   });
 
   group('Operator Matchers', () {
 
     test('anyOf', () {
       shouldFail(0, anyOf([equals(1), equals(2)]),
           "Expected: (<1> or <2>) but: was <0>");
       shouldPass(1, anyOf([equals(1), equals(2)]));
     });
 
     test('allOf', () {
       shouldPass(1, allOf([lessThan(10), greaterThan(0)]));
       shouldFail(-1, allOf([lessThan(10), greaterThan(0)]),
           "Expected: (a value less than <10> and a value greater than <0>) "
           "but: a value greater than <0> was <-1>");
     });
   });
+
+  group('Predicate Matchers', () {
+    test('isInstanceOf', () {
+      shouldFail(0, predicate((x) => x is String, "an instance of String"),
+        "Expected: an instance of String but: was <0>");
+      shouldPass('cow', predicate((x) => x is String, "an instance of String"));
+    });
+  });
 }