Some unit test fixes

lib/unittest/expect.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.
 
 /**
  * This is the main assertion function. It asserts that [actual]
  * matches the [matcher]. [reason] is optional and is typically
  * not supplied, as a reason can be generated from the matcher.
  * If [reason] is included it is appended to the reason generated
  * by the matcher.
@@ skipping 14 matching lines @@
  *     expect(foo <= bar);
  *
  * expect() is a 3rd generation assertion mechanism, drawing
  * inspiration from [Hamcrest] and Ladislav Thon's [dart-matchers]
  * library.
  *
  * See [Hamcrest] http://en.wikipedia.org/wiki/Hamcrest
  *     [Hamcrest] http://http://code.google.com/p/hamcrest/
  *     [dart-matchers] https://github.com/Ladicek/dart-matchers
  */
 void expect(actual, [matcherOrReason = null, String reason = '']) {

[eub, 2012/06/15 21:02:49]

BTW, I imagine you had prior review discussion of splitting this into
    assert(predicate_expression, [reason]
and
    expect(actual, matcher, [reason])
?

[gram, 2012/06/15 21:25:55]

Yes - the aim is to have just one expect(), but to have it support shorthand
cases, such as:

expect(foo);

expect(foo, 10);

as well as:

expect(foo, isTrue);

expect(foo, equals(10));

The only controversy comes from the ambiguous:

expect(foo, "bar");

which we currently treat as an assert(foo) reason bar.

Given that we have named arguments, we could change this to not overload the
second argument, while still asserting in there is no matcher, so:

expect(foo, "bar") means expect(foo, equals("bar"))

and the previous case would need to be:

expect(foo, reason:"bar");

I'm quite open to that change if you think it is an improvement but I'd like to
make that a separate CL.

-  if (matcherOrReason is Matcher) {
+  if (actual is bool && 
+     (matcherOrReason == null || matcherOrReason is String)) {
+    // Treat this as an assert(predicate, reason).
+    if (!actual) {
+      reason = (matcherOrReason == null) ? 'Assertion failed' : matcherOrReason;
+      // Make sure we have a failure handler configured.
+      configureExpectHandler(_assertFailureHandler);
+      _assertFailureHandler.fail(reason);
+    }
+  } else {
+    // Treat this as an expect(value, matcher, [reason]).
+    if (matcherOrReason is! Matcher) {
+      matcherOrReason = wrapMatcher(matcherOrReason);
+    }
     var doesMatch;
     try {
       doesMatch = matcherOrReason.matches(actual);
     } catch (var e, var trace) {
       doesMatch = false;
       if (reason == '') {
         reason = '${(e is String) ? e : e.toString()} at $trace';
       }
     }
     if (!doesMatch) {
       // Make sure we have a failure handler configured.
       configureExpectHandler(_assertFailureHandler);
       _assertFailureHandler.failMatch(actual, matcherOrReason, reason);
     }
-  } else {
-    if (!actual) {
-      reason = (matcherOrReason == null) ? 'Assertion failed' : matcherOrReason;
-      // Make sure we have a failure handler configured.
-      configureExpectHandler(_assertFailureHandler);
-      _assertFailureHandler.fail(reason);
-    }
   }
 }
 
 /**
  * Takes an argument and returns an equivalent matcher.
  * If the argument is already a matcher this does nothing, else it
  * generates an equals matcher for the argument.
  */
 Matcher wrapMatcher(x) => ((x is Matcher) ? x : equals(x));
 
@@ skipping 48 matching lines @@
  * formatter is returned; this allows custom expect handlers to easily
  * get a reference to the default formatter.
  */
 ErrorFormatter configureExpectFormatter([ErrorFormatter formatter = null]) {
   if (formatter == null) {
     formatter = _defaultErrorFormatter;
   }
   return _assertErrorFormatter = formatter;
 }