Add pretty-printing to unittest and more thoroughly print values.

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';
 import 'dart:collection';
 part 'test_utils.dart';
 
@@ skipping 89 matching lines @@
 
     test('isNotNull', () {
       shouldPass(false, isNotNull);
       shouldFail(null, isNotNull, "Expected: not null but: was <null>.");
     });
 
     test('same', () {
       var a = new Map();
       var b = new Map();
       shouldPass(a, same(a));
-      shouldFail(b, same(a), "Expected: same instance as <{}> but: was <{}>.");
+      shouldFail(b, same(a), "Expected: same instance as {} but: was {}.");
     });
 
     test('equals', () {
       var a = new Map();
       var b = new Map();
       shouldPass(a, equals(a));
       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 <{}>.");
+      shouldFail(a, isNot(anything), "Expected: not anything but: was {}.");
     });
 
     test('throws', () {
       shouldFail(doesNotThrow, throws,
-        "Expected: throws an exception but: no exception.");
+          "Expected: throws an exception but: no exception. "
+          "Actual: <Closure: (dynamic) => dynamic "
+              "from Function 'doesNotThrow': static.>");
       shouldPass(doesThrow, throws);
       shouldFail(true, throws,
-          "Expected: throws an exception but: not a Function or Future.");
+          "Expected: throws an exception but: not a Function or Future. "
+          "Actual: <true>");
     });
 
     test('throwsA', () {
       shouldPass(doesThrow, throwsA(equals('X')));
       shouldFail(doesThrow, throwsA(equals('Y')),
-        "Expected: throws an exception which matches 'Y' "
-        "but:  exception 'X' does not match 'Y'.");
+          "Expected: throws an exception which matches 'Y' "
+          "but:  exception 'X' does not match 'Y'. "
+          "Actual: <Closure: (dynamic) => dynamic "
+              "from Function 'doesThrow': static.>");
     });
 
     test('throwsFormatException', () {
       shouldPass(() { throw new FormatException(''); },
           throwsFormatException);
       shouldFail(() { throw new Exception(); },
           throwsFormatException,
-        "Expected: throws an exception which matches FormatException "
-        "but:  exception <Exception> does not match FormatException.");
+          "Expected: throws an exception which matches FormatException "
+          "but:  exception <Exception> does not match FormatException. "
+          "Actual: <Closure: (dynamic) => dynamic>");
     });
 
     test('throwsArgumentError', () {
       shouldPass(() { throw new ArgumentError(''); },
           throwsArgumentError);
       shouldFail(() { throw new Exception(); },
           throwsArgumentError,
-        "Expected: throws an exception which matches ArgumentError "
-        "but:  exception <Exception> does not match "
-            "ArgumentError.");
+          "Expected: throws an exception which matches ArgumentError "
+          "but:  exception <Exception> does not match "
+              "ArgumentError. "
+          "Actual: <Closure: (dynamic) => dynamic>");
     });
 
     test('throwsRangeError', () {
       shouldPass(() { throw new RangeError(0); },
           throwsRangeError);
       shouldFail(() { throw new Exception(); },
           throwsRangeError,
-        "Expected: throws an exception which matches RangeError "
-        "but:  exception <Exception> does not match RangeError.");
+          "Expected: throws an exception which matches RangeError "
+          "but:  exception <Exception> does not match RangeError. "
+          "Actual: <Closure: (dynamic) => dynamic>");
     });
 
     test('throwsNoSuchMethodError', () {
       shouldPass(() { throw new NoSuchMethodError(null, '', null, null); },
           throwsNoSuchMethodError);
       shouldFail(() { throw new Exception(); },
           throwsNoSuchMethodError,
-        "Expected: throws an exception which matches NoSuchMethodError "
-        "but:  exception <Exception> does not match "
-            "NoSuchMethodError.");
+          "Expected: throws an exception which matches NoSuchMethodError "
+          "but:  exception <Exception> does not match "
+              "NoSuchMethodError. "
+          "Actual: <Closure: (dynamic) => dynamic>");
     });
 
     test('throwsUnimplementedError', () {
       shouldPass(() { throw new UnimplementedError(''); },
           throwsUnimplementedError);
       shouldFail(() { throw new Exception(); },
           throwsUnimplementedError,
-        "Expected: throws an exception which matches UnimplementedError "
-        "but:  exception <Exception> does not match "
-            "UnimplementedError.");
+          "Expected: throws an exception which matches UnimplementedError "
+          "but:  exception <Exception> does not match "
+              "UnimplementedError. "
+          "Actual: <Closure: (dynamic) => dynamic>");
     });
 
     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.");
+          "Expected: throws an exception which matches UnsupportedError "
+          "but:  exception <Exception> does not match "

[gram, 2013/05/17 01:00:30]

I think now that we have Expected and Actual both capitalized we should
capitalize But: too.

[nweiz, 2013/05/17 19:50:56]

Done.

+              "UnsupportedError. "
+          "Actual: <Closure: (dynamic) => dynamic>");
     });
 
     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.");
+          "Expected: throws an exception which matches StateError "
+          "but:  exception <Exception> does not match "
+              "StateError. "
+          "Actual: <Closure: (dynamic) => dynamic>");
     });
 
     test('returnsNormally', () {
       shouldPass(doesNotThrow, returnsNormally);
       shouldFail(doesThrow, returnsNormally,
-        "Expected: return normally but: threw 'X'.");
+          "Expected: return normally but: threw 'X'. "
+          "Actual: <Closure: (dynamic) => dynamic "
+              "from Function 'doesThrow': static.>");
     });
 
     test('hasLength', () {
       var a = new Map();
       var b = new List();
       shouldPass(a, hasLength(0));
       shouldPass(b, hasLength(0));
       shouldPass('a', hasLength(1));
       shouldFail(0, hasLength(0), new PrefixMatcher(
-        "Expected: an object with length of <0> "
-        "but: was <0> has no length property."));
+          "Expected: an object with length of <0> "
+          "but: had no length property."
+          "Actual: <0>"));
 
       b.add(0);
       shouldPass(b, hasLength(1));
       shouldFail(b, hasLength(2),
-        "Expected: an object with length of <2> "
-        "but: was <[0]> with length of <1>.");
+          "Expected: an object with length of <2> "
+          "but: had length of <1>. "
+          "Actual: [0]");
 
       b.add(0);
       shouldFail(b, hasLength(1),
-        "Expected: an object with length of <1> "
-        "but: was <[0, 0]> with length of <2>.");
+          "Expected: an object with length of <1> "
+          "but: had length of <2>. "
+          "Actual: [0, 0]");
       shouldPass(b, hasLength(2));
     });
 
     test('scalar type mismatch', () {
       shouldFail('error', equals(5.1),
-          matches("^Expected: <5\.1>"
-                  "     but: was .*:'error' \\(not type .*\\)\.\$"));
+          "Expected: <5.1> "
+          "but: was 'error'.");
     });
 
     test('nested type mismatch', () {
       shouldFail(['error'], equals([5.1]),
-          matches(r"^Expected: <\[5\.1\]>"
-                  "     but: expected double:<5\.1> "
-                  "but was .*:'error' mismatch at position 0\.\$"));
+          "Expected: [5.1] "
+          "but: expected <5.1> but was 'error' mismatch at position 0. "
+          "Actual: ['error']");
     });
 
     test('doubly-nested type mismatch', () {
       shouldFail([['error']], equals([[5.1]]),
-          matches(r"^Expected: <\[\[5\.1\]\]>"
-                  "     but: expected double:<5\.1> "
-                  "but was .*:'error' mismatch at position 0 "
-                  "mismatch at position 0\.\$"));
+          "Expected: [[5.1]] "
+          "but: expected <5.1> but was 'error' "
+          "mismatch at position 0 mismatch at position 0. "
+          "Actual: [['error']]");
     });
   });
 
   group('Numeric Matchers', () {
 
     test('greaterThan', () {
       shouldPass(10, greaterThan(9));
       shouldFail(9, greaterThan(10),
         "Expected: a value greater than <10> but: was <9>.");
     });
@@ skipping 54 matching lines @@
       shouldFail(-1, isNonNegative,
         "Expected: a non-negative value but: was <-1>.");
     });
 
     test('closeTo', () {
       shouldPass(0, closeTo(0, 1));
       shouldPass(-1, closeTo(0, 1));
       shouldPass(1, closeTo(0, 1));
       shouldFail(1.001, closeTo(0, 1),
           "Expected: a numeric value within <1> of <0> "
-          "but: <1.001> differed by <1.001>.");
+          "but: differed by <1.001>. "
+          "Actual: <1.001>");
       shouldFail(-1.001, closeTo(0, 1),
           "Expected: a numeric value within <1> of <0> "
-          "but: <-1.001> differed by <1.001>.");
+          "but: differed by <1.001>. "
+          "Actual: <-1.001>");
     });
 
     test('inInclusiveRange', () {
       shouldFail(-1, inInclusiveRange(0,2),
           "Expected: be in range from 0 (inclusive) to 2 (inclusive) "
           "but: was <-1>.");
       shouldPass(0, inInclusiveRange(0,2));
       shouldPass(1, inInclusiveRange(0,2));
       shouldPass(2, inInclusiveRange(0,2));
       shouldFail(3, inInclusiveRange(0,2),
@@ skipping 102 matching lines @@
       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]>.");
+      shouldFail(e, isEmpty, "Expected: empty but: was SimpleIterable:[1].");
     });
 
     test('contains', () {
       var d = new SimpleIterable(3);
       shouldPass(d, contains(2));
-      shouldFail(d, contains(5), "Expected: contains <5> but: was <[3]>.");
+      shouldFail(d, contains(5),
+          "Expected: contains <5> "
+          "but: was SimpleIterable:[3, 2, 1].");
     });
   });
 
   group('Iterable Matchers', () {
 
     test('isEmpty', () {
       shouldPass([], isEmpty);
-      shouldFail([1], isEmpty, "Expected: empty but: was <[1]>.");
+      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]>.");
+      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>.");
+      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 <2> at position 1.");
       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]>.");
+          "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: expected <2> but was <1> mismatch at position 0.");
+          "Expected: equals [2, 1] ordered "
+          "but: expected <2> but was <1> mismatch at position 0. "
+          "Actual: [1, 2]");
     });
 
     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).");
+          "Expected: equals [1] unordered "
+          "but: has too many elements (2 > 1). "
+          "Actual: [1, 2]");
       shouldFail(d, unorderedEquals([3, 2, 1]),
-          "Expected: equals <[3, 2, 1]> unordered "
-          "but: has too few elements (2 < 3).");
+          "Expected: equals [3, 2, 1] unordered "
+          "but: has too few elements (2 < 3). "
+          "Actual: [1, 2]");
       shouldFail(d, unorderedEquals([3, 1]),
-          "Expected: equals <[3, 1]> unordered "
-          "but: has no match for element <3> at position 0.");
+          "Expected: equals [3, 1] unordered "
+          "but: has no match for element <3> at position 0. "
+          "Actual: [1, 2]");
     });
 
     test('pairwise compare', () {
       var c = [1, 2];
       var d = [1, 2, 3];
       var e = [1, 4, 9];
       shouldFail('x', pairwiseCompare(e, (e,a) => a <= e,
           "less than or equal"),
-          "Expected: pairwise less than or equal <[1, 4, 9]> but: "
-          "not an Iterable.");
+          "Expected: pairwise less than or equal [1, 4, 9] "
+          "but: not an Iterable. "
+          "Actual: 'x'");
       shouldFail(c, pairwiseCompare(e, (e,a) => a <= e, "less than or equal"),
-          "Expected: pairwise less than or equal <[1, 4, 9]> but: "
-          "length was 2 instead of 3.");
+          "Expected: pairwise less than or equal [1, 4, 9] "
+          "but: length was 2 instead of 3. "
+          "Actual: [1, 2]");
       shouldPass(d, pairwiseCompare(e, (e,a) => a <= e, "less than or equal"));
       shouldFail(d, pairwiseCompare(e, (e,a) => a < e, "less than"),
-          "Expected: pairwise less than <[1, 4, 9]> but: "
-          "<1> not less than <1> at position 0.");
+          "Expected: pairwise less than [1, 4, 9] "
+          "but: <1> not less than <1> at position 0. "
+          "Actual: [1, 2, 3]");
       shouldPass(d, pairwiseCompare(e, (e,a) => a * a == e, "square root of"));
       shouldFail(d, pairwiseCompare(e, (e,a) => a + a == e, "double"),
-          "Expected: pairwise double <[1, 4, 9]> but: "
-          "<1> not double <1> at position 0.");
+          "Expected: pairwise double [1, 4, 9] "
+          "but: <1> not double <1> at position 0. "
+          "Actual: [1, 2, 3]");
     });
   });
 
   group('Map Matchers', () {
 
     test('isEmpty', () {
       var a = new Map();
       shouldPass({}, isEmpty);
       shouldPass(a, isEmpty);
       a['foo'] = 'bar';
-      shouldFail(a, isEmpty, "Expected: empty but: was <{foo: bar}>.");
+      shouldFail(a, isEmpty, "Expected: empty but: was {'foo': 'bar'}.");
     });
 
     test('equals', () {
       var a = new Map();
       a['foo'] = 'bar';
       var b = new Map();
       b['foo'] = 'bar';
       var c = new Map();
       c['bar'] = 'foo';
       shouldPass(a, equals(b));
       shouldFail(b, equals(c),
-          "Expected: <{bar: foo}> but: missing map key 'bar'.");
+          "Expected: {'bar': 'foo'} but: missing map key 'bar'. "
+          "Actual: {'foo': 'bar'}");
     });
 
     test('equals with different lengths', () {
       var a = new LinkedHashMap();
       a['foo'] = 'bar';
       var b = new LinkedHashMap();
       b['foo'] = 'bar';
       b['bar'] = 'foo';
       var c = new LinkedHashMap();
       c['bar'] = 'foo';
       c['barrista'] = 'caffeine';
       shouldFail(a, equals(b),
-          "Expected: <{foo: bar, bar: foo}> "
-          "but: different map lengths; missing map key 'bar'.");
+          "Expected: {'foo': 'bar', 'bar': 'foo'} "
+          "but: different map lengths; missing map key 'bar'. "
+          "Actual: {'foo': 'bar'}");
       shouldFail(b, equals(a),
-          "Expected: <{foo: bar}> "
-          "but: different map lengths; extra map key 'bar'.");
+          "Expected: {'foo': 'bar'} "
+          "but: different map lengths; extra map key 'bar'. "
+          "Actual: {'foo': 'bar', 'bar': 'foo'}");
       shouldFail(b, equals(c),
-          "Expected: <{bar: foo, barrista: caffeine}> "
-          "but: missing map key 'barrista'.");
+          "Expected: {'bar': 'foo', 'barrista': 'caffeine'} "
+          "but: missing map key 'barrista'. "
+          "Actual: {'foo': 'bar', 'bar': 'foo'}");
       shouldFail(c, equals(b),
-          "Expected: <{foo: bar, bar: foo}> "
-          "but: missing map key 'foo'.");
+          "Expected: {'foo': 'bar', 'bar': 'foo'} "
+          "but: missing map key 'foo'. "
+          "Actual: {'bar': 'foo', 'barrista': 'caffeine'}");
       shouldFail(a, equals(c),
-          "Expected: <{bar: foo, barrista: caffeine}> "
-          "but: different map lengths; missing map key 'bar'.");
+          "Expected: {'bar': 'foo', 'barrista': 'caffeine'} "
+          "but: different map lengths; missing map key 'bar'. "
+          "Actual: {'foo': 'bar'}");
       shouldFail(c, equals(a),
-          "Expected: <{foo: bar}> "
-          "but: different map lengths; missing map key 'foo'.");
+          "Expected: {'foo': 'bar'} "
+          "but: different map lengths; missing map key 'foo'. "
+          "Actual: {'bar': 'foo', 'barrista': 'caffeine'}");
     });
 
     test('contains', () {
       var a = new Map();
       a['foo'] = 'bar';
       var b = new Map();
       shouldPass(a, contains('foo'));
       shouldFail(b, contains('foo'),
-          "Expected: contains 'foo' but: was <{}>.");
+          "Expected: contains 'foo' but: was {}.");
       shouldFail(10, contains('foo'),
           "Expected: contains 'foo' but: was <10>.");
     });
 
     test('containsValue', () {
       var a = new Map();
       a['foo'] = 'bar';
       shouldPass(a, containsValue('bar'));
       shouldFail(a, containsValue('ba'),
-          "Expected: contains value 'ba' but: was <{foo: bar}>.");
+          "Expected: contains value 'ba' but: was {'foo': 'bar'}.");
     });

[gram, 2013/05/17 01:00:30]

You seem to have established a new pattern for output of the form:

Expected: <something>
But: <reason>
Actual: <value>

This and some other matchers are not following that pattern but I think they
should; i.e. in this case something like:

Expected: contains value 'ba'
But: value 'ba' not found
Actual: {'foo': 'bar'}.

There are more cases above and below.

[nweiz, 2013/05/17 19:50:56]

It seems weird to me when the "But" clause would just be "the thing we expected
to be true wasn't." If that doesn't provide any additional information, I think
it makes sense just to display the actual value.

For example, in this case, saying "But: value 'ba' not found" doesn't provide
any information that "Expected: contains value 'ba'" doesn't.

[gram, 2013/05/17 20:38:32]

I agree with you that it could be weird, but having a consistent format lends
itself better to automated tools that might post-process the test output.

OTOH I guess you could argue that the "Actual:" part is an optional extension of
the non-optional "but:" part, and that it is still easy enough to post-process,
so my feelings are mixed about this. I'll leave it as your call.

On 2013/05/17 19:50:56, nweiz wrote:

[nweiz, 2013/05/17 21:07:21]

I think there's room to improve and normalize these, but I think it's out of
scope for this change, so I'm going to leave it for now.

 
     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'.");
+          "but:  contains key 'foo' but with value was 'bar'. "
+          "Actual: {'foo': 'bar'}");
       shouldFail(a, containsPair('fo', 'bar'),
           "Expected: contains pair 'fo' => 'bar' "
-          "but: <{foo: bar}> doesn't contain key 'fo'.");
+          "but: doesn't contain key 'fo'. "
+          "Actual: {'foo': 'bar'}");
     });
 
     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>.");
+          "but: had length of <0>. "
+          "Actual: {}");
     });
   });
 
   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>.");
+          "but: was <-1> (a value greater than <0>).");

[gram, 2013/05/17 01:00:30]

Another inconsistent case.

[nweiz, 2013/05/17 19:50:56]

This case is weird. If all of the uses of [allOf] looked just like this, I'd
agree; something like "but: wasn't a value greater than <0>" would look better.
However, [allOf] needs to call [describeMismatch] on the matcher that failed, to
give it a change to provide its own description of the failure if it's more
complex. It's also important that we provide enough information for the user to
tell which of the matchers failed. So I think something like this current format
is necessary.

     });
   });
 
   group('Future Matchers', () {
 
     test('completes - unexpected error', () {
       var completer = new Completer();
       completer.completeError('X');
       shouldFail(completer.future, completes,
           contains('Expected future to complete successfully, '
                    'but it failed with X'),
           isAsync: true);

[gram, 2013/05/17 01:00:30]

Inconsistent pattern here and more below

[nweiz, 2013/05/17 19:50:56]

I think the future matchers just work completely differently than the stuff I'm
changing.

     });
 
     test('completes - successfully', () {
       var completer = new Completer();
       completer.complete('1');
       shouldPass(completer.future, completes, isAsync: true);
     });
 
     test('throws - unexpected to see normal completion', () {
       var completer = new Completer();
@@ skipping 47 matching lines @@
     });
   });
 
   group('Feature Matchers', () {
     test("Feature Matcher", () {
       var w = new Widget();
       w.price = 10;
       shouldPass(w, new HasPrice(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>.');
+          "Expected: Widget with a price that is a value greater than <10> "
+          "but: price was <10>. "
+          "Actual: <Instance of 'Widget'>");
     });
   });
 }