Modified unittest to use new argument syntax.

pkg/unittest/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 unittest;
 
 /**
  * Returns a matcher that matches empty strings, maps or collections.
  */
 const Matcher isEmpty = const _Empty();
 
 class _Empty extends BaseMatcher {
   const _Empty();
   bool matches(item, MatchState matchState) {
     if (item is Map || item is Collection) {
@@ skipping 193 matching lines @@
  *
  * For example, to test whether 'bar' is an instance of type
  * 'Foo', we would write:
  *
  *     expect(bar, new isInstanceOf<Foo>());
  *
  * To get better error message, supply a name when creating the
  * Type wrapper; e.g.:
  *
  *     expect(bar, new isInstanceOf<Foo>('Foo'));
+ *
+ * Note that this does not currently work in dart2js; it will
+ * match any type, and isNot(new isInstanceof<T>()) will always
+ * fail. This is because dart2js currently ignores template type
+ * parameters.
  */
 class isInstanceOf<T> extends BaseMatcher {
   final String _name;
   const isInstanceOf([name = 'specified type']) : this._name = name;
   bool matches(obj, MatchState matchState) => obj is T;
   // The description here is lame :-(
   Description describe(Description description) =>
       description.add('an instance of ${_name}');
 }
 
@@ skipping 45 matching lines @@
 
   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(expectAsync1((future) {
         if (future.hasValue) {
-          expect(false, isTrue,
+          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);
+          expect(future.exception, _matcher, reason: reason);
         }
       }));
 
       // It hasn't failed yet.
       return true;
     }
 
     try {
       item();
       return false;
@@ skipping 83 matching lines @@
  *
  * bool _isException(x) => x is Exception;
  * final Matcher isException = const _Predicate(_isException, "Exception");
  * final Matcher throwsException = const _Throws(isException);
  *
  * But currently using static functions in const expressions is not supported.
  * For now the only solution for all platforms seems to be separate classes
  * for each exception type.
  */
 
-abstract class ExceptionMatcher extends BaseMatcher {
+abstract class TypeMatcher extends BaseMatcher {
   final String _name;
-  const ExceptionMatcher(this._name);
+  const TypeMatcher(this._name);
   Description describe(Description description) =>
       description.add(_name);
 }
 
 /** A matcher for FormatExceptions. */
 const isFormatException = const _FormatException();
 
-/** A matcher for functions that throw FormatException */
+/** A matcher for functions that throw FormatException. */
 const Matcher throwsFormatException =
     const Throws(isFormatException);
 
-class _FormatException extends ExceptionMatcher {
+class _FormatException extends TypeMatcher {
   const _FormatException() : super("FormatException");
   bool matches(item, MatchState matchState) => item is FormatException;
 }
 
 /** A matcher for Exceptions. */
 const isException = const _Exception();
 
-/** A matcher for functions that throw Exception */
+/** A matcher for functions that throw Exception. */
 const Matcher throwsException = const Throws(isException);
 
-class _Exception extends ExceptionMatcher {
+class _Exception extends TypeMatcher {
   const _Exception() : super("Exception");
   bool matches(item, MatchState matchState) => item is Exception;
 }
 
 /** A matcher for ArgumentErrors. */
 const isArgumentError = const _ArgumentError();
 
-/** A matcher for functions that throw ArgumentError */
+/** A matcher for functions that throw ArgumentError. */
 const Matcher throwsArgumentError =
     const Throws(isArgumentError);
 
-class _ArgumentError extends ExceptionMatcher {
+class _ArgumentError extends TypeMatcher {
   const _ArgumentError() : super("ArgumentError");
   bool matches(item, MatchState matchState) => item is ArgumentError;
 }
 
 /** A matcher for IllegalJSRegExpExceptions. */
 const isIllegalJSRegExpException = const _IllegalJSRegExpException();
 
-/** A matcher for functions that throw IllegalJSRegExpException */
+/** A matcher for functions that throw IllegalJSRegExpException. */
 const Matcher throwsIllegalJSRegExpException =
     const Throws(isIllegalJSRegExpException);
 
-class _IllegalJSRegExpException extends ExceptionMatcher {
+class _IllegalJSRegExpException extends TypeMatcher {
   const _IllegalJSRegExpException() : super("IllegalJSRegExpException");
   bool matches(item, MatchState matchState) => item is IllegalJSRegExpException;
 }
 
 /** A matcher for IndexOutOfRangeExceptions. */
 const isIndexOutOfRangeException = const _IndexOutOfRangeException();
 
-/** A matcher for functions that throw IndexOutOfRangeException */
+/** A matcher for functions that throw IndexOutOfRangeException. */
 const Matcher throwsIndexOutOfRangeException =
     const Throws(isIndexOutOfRangeException);
 
-class _IndexOutOfRangeException extends ExceptionMatcher {
+class _IndexOutOfRangeException extends TypeMatcher {
   const _IndexOutOfRangeException() : super("IndexOutOfRangeException");
   bool matches(item, MatchState matchState) => item is IndexOutOfRangeException;
 }
 
 /** A matcher for NoSuchMethodErrors. */
 const isNoSuchMethodError = const _NoSuchMethodError();
 
-/** A matcher for functions that throw NoSuchMethodError */
+/** A matcher for functions that throw NoSuchMethodError. */
 const Matcher throwsNoSuchMethodError =
     const Throws(isNoSuchMethodError);
 
-class _NoSuchMethodError extends ExceptionMatcher {
+class _NoSuchMethodError extends TypeMatcher {
   const _NoSuchMethodError() : super("NoSuchMethodError");
   bool matches(item, MatchState matchState) => item is NoSuchMethodError;
 }
 
 /** A matcher for NotImplementedExceptions. */
 const isNotImplementedException = const _NotImplementedException();
 
-/** A matcher for functions that throw Exception */
+/** A matcher for functions that throw Exception. */
 const Matcher throwsNotImplementedException =
     const Throws(isNotImplementedException);
 
-class _NotImplementedException extends ExceptionMatcher {
+class _NotImplementedException extends TypeMatcher {
   const _NotImplementedException() : super("NotImplementedException");
   bool matches(item, MatchState matchState) => item is NotImplementedException;
 }
 
 /** A matcher for NullPointerExceptions. */
 const isNullPointerException = const _NullPointerException();
 
-/** A matcher for functions that throw NotNullPointerException */
+/** A matcher for functions that throw NotNullPointerException. */
 const Matcher throwsNullPointerException =
     const Throws(isNullPointerException);
 
-class _NullPointerException extends ExceptionMatcher {
+class _NullPointerException extends TypeMatcher {
   const _NullPointerException() : super("NullPointerException");
   bool matches(item, MatchState matchState) => item is NullPointerException;
 }
 
-/** A matcher for UnsupportedErrors. */
+/** A matcher for UnsupportedError. */
 const isUnsupportedError = const _UnsupportedError();
 
-/** A matcher for functions that throw UnsupportedError */
-const Matcher throwsUnsupportedError =
-    const Throws(isUnsupportedError);
+/** A matcher for functions that throw UnsupportedError. */
+const Matcher throwsUnsupportedError = const Throws(isUnsupportedError);
 
-class _UnsupportedError extends ExceptionMatcher {
+class _UnsupportedError extends TypeMatcher {
   const _UnsupportedError() :
       super("UnsupportedError");
-  bool matches(item, MatchState matchState) =>
-      item is UnsupportedError;
+  bool matches(item, MatchState matchState) => item is UnsupportedError;
+}
+
+/** A matcher for Map types. */
+const isMap = const _IsMap();
+
+class _IsMap extends TypeMatcher {
+  const _IsMap() : super("Map");
+  bool matches(item, MatchState matchState) => item is Map;
+}
+
+/** A matcher for List types. */
+const isList = const _IsList();
+
+class _IsList extends TypeMatcher {
+  const _IsList() : super("List");
+  bool matches(item, MatchState matchState) => item is List;
 }
 
 /**
  * Returns a matcher that matches if an object has a length property
  * that matches [matcher].
  */
 Matcher hasLength(matcher) =>
     new _HasLength(wrapMatcher(matcher));
 
 class _HasLength extends BaseMatcher {
@@ skipping 83 matching lines @@
   }
 
   Description describe(Description description) =>
       description.add('is in ').addDescriptionOf(_expected);
 }
 
 /**
  * Returns a matcher that uses an arbitrary function that returns
  * true or false for the actual value.
  */
-Matcher predicate(f, {description: 'satisfies function'}) =>
+Matcher predicate(f, [description ='satisfies function']) =>
     new _Predicate(f, description);
 
 class _Predicate extends BaseMatcher {
 
   final _matcher;
   final String _description;
 
   const _Predicate(this._matcher, this._description);
 
   bool matches(item, MatchState matchState) => _matcher(item);
@@ skipping 16 matching lines @@
  *     class HasPrice extends FeatureMatcher {
  *       const HasPrice(matcher) :
  *           super("Widget with price that is", "price", matcher);
  *       featureValueOf(actual) => actual.price;
  *     }
  *
  * and then use this for example like:
  *
  *      expect(inventoryItem, new HasPrice(greaterThan(0)));
  */
-abstract class CustomMatcher extends BaseMatcher {
+class CustomMatcher extends BaseMatcher {
   final String _featureDescription;
   final String _featureName;
   final Matcher _matcher;
 
   const CustomMatcher(this._featureDescription, this._featureName,
       this._matcher);
 
-  /** Implement this to extract the interesting feature.*/
-  featureValueOf(actual);
+  /** Override this to extract the interesting feature.*/
+  featureValueOf(actual) => actual;
 
   bool matches(item, MatchState matchState) {
     var f = featureValueOf(item);
     if (_matcher.matches(f, matchState)) return true;
     matchState.state = { 'innerState': matchState.state, 'feature': f };
     return false;
   }
 
   Description describe(Description description) =>
       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;
   }
 }