| // 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'; |
| |
| doesNotThrow() {} |
| doesThrow() { throw 'X'; } |
| |
| class PrefixMatcher extends BaseMatcher { |
| final String _prefix; |
| const PrefixMatcher(this._prefix); |
| bool matches(item, MatchState matchState) { |
| return item is String && |
| (collapseWhitespace(item)).startsWith(collapseWhitespace(_prefix)); |
| } |
| |
| Description describe(Description description) => |
| description.add('a string starting with '). |
| addDescriptionOf(collapseWhitespace(_prefix)). |
| add(' ignoring whitespace'); |
| } |
| |
| class Widget { |
| int price; |
| } |
| |
| class HasPrice extends CustomMatcher { |
| HasPrice(matcher) : |
| super("Widget with a price that is", "price", matcher); |
| featureValueOf(actual) => actual.price; |
| } |
| |
| class SimpleIterable extends IterableBase { |
| int count; |
| SimpleIterable(this.count); |
| |
| bool contains(int val) => count < val ? false : true; |
| |
| bool any(bool f(element)) { |
| for(var i = 0; i <= count; i++) { |
| if(f(i)) return true; |
| } |
| return false; |
| } |
| |
| String toString() => "<[$count]>"; |
| |
| Iterator get iterator { |
| return new SimpleIterator(count); |
| } |
| } |
| |
| class SimpleIterator implements Iterator { |
| int _count; |
| int _current; |
| |
| SimpleIterator(this._count); |
| |
| bool moveNext() { |
| if (_count > 0) { |
| _current = _count; |
| _count--; |
| return true; |
| } |
| _current = null; |
| return false; |
| } |
| |
| get current => _current; |
| } |
| |
| void main() { |
| |
| initUtils(); |
| |
| // Core matchers |
| |
| group('Core matchers', () { |
| |
| test('isTrue', () { |
| shouldPass(true, isTrue); |
| shouldFail(false, isTrue, "Expected: true but: was <false>."); |
| }); |
| |
| test('isFalse', () { |
| shouldPass(false, isFalse); |
| shouldFail(10, isFalse, "Expected: false but: was <10>."); |
| shouldFail(true, isFalse, "Expected: false but: was <true>."); |
| }); |
| |
| test('isNull', () { |
| shouldPass(null, isNull); |
| shouldFail(false, isNull, "Expected: null but: was <false>."); |
| }); |
| |
| 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 <{}>."); |
| }); |
| |
| 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 <{}>."); |
| }); |
| |
| test('throws', () { |
| shouldFail(doesNotThrow, throws, |
| "Expected: throws an exception but: no exception."); |
| shouldPass(doesThrow, throws); |
| shouldFail(true, throws, |
| "Expected: throws an exception but: not a Function or Future."); |
| }); |
| |
| 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'."); |
| }); |
| |
| 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."); |
| }); |
| |
| 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."); |
| }); |
| |
| 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."); |
| }); |
| |
| 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."); |
| }); |
| |
| 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."); |
| }); |
| |
| 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."); |
| }); |
| |
| 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."); |
| }); |
| |
| test('returnsNormally', () { |
| shouldPass(doesNotThrow, returnsNormally); |
| shouldFail(doesThrow, returnsNormally, |
| "Expected: return normally but: threw 'X'."); |
| }); |
| |
| 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.")); |
| |
| 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>."); |
| |
| b.add(0); |
| shouldFail(b, hasLength(1), |
| "Expected: an object with length of <1> " |
| "but: was <[0, 0]> with length of <2>."); |
| shouldPass(b, hasLength(2)); |
| }); |
| |
| test('scalar type mismatch', () { |
| shouldFail('error', equals(5.1), |
| matches("^Expected: <5\.1>" |
| " but: was .*:'error' \\(not type .*\\)\.\$")); |
| }); |
| |
| 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\.\$")); |
| }); |
| |
| 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\.\$")); |
| }); |
| }); |
| |
| group('Numeric Matchers', () { |
| |
| test('greaterThan', () { |
| shouldPass(10, greaterThan(9)); |
| shouldFail(9, greaterThan(10), |
| "Expected: a value greater than <10> but: was <9>."); |
| }); |
| |
| test('greaterThanOrEqualTo', () { |
| shouldPass(10, greaterThanOrEqualTo(10)); |
| shouldFail(9, greaterThanOrEqualTo(10), |
| "Expected: a value greater than or equal to <10> but: was <9>."); |
| }); |
| |
| test('lessThan', () { |
| shouldFail(10, lessThan(9), "Expected: a value less than <9> " |
| "but: was <10>."); |
| shouldPass(9, lessThan(10)); |
| }); |
| |
| test('lessThanOrEqualTo', () { |
| shouldPass(10, lessThanOrEqualTo(10)); |
| shouldFail(11, lessThanOrEqualTo(10), |
| "Expected: a value less than or equal to <10> but: was <11>."); |
| }); |
| |
| test('isZero', () { |
| shouldPass(0, isZero); |
| shouldFail(1, isZero, "Expected: a value equal to <0> but: was <1>."); |
| }); |
| |
| test('isNonZero', () { |
| shouldFail(0, isNonZero, "Expected: a value not equal to <0> " |
| "but: was <0>."); |
| shouldPass(1, isNonZero); |
| }); |
| |
| test('isPositive', () { |
| shouldFail(-1, isPositive, "Expected: a positive value " |
| "but: was <-1>."); |
| shouldFail(0, isPositive, "Expected: a positive value " |
| "but: was <0>."); |
| shouldPass(1, isPositive); |
| }); |
| |
| test('isNegative', () { |
| shouldPass(-1, isNegative); |
| shouldFail(0, isNegative, |
| "Expected: a negative value but: was <0>."); |
| }); |
| |
| test('isNonPositive', () { |
| shouldPass(-1, isNonPositive); |
| shouldPass(0, isNonPositive); |
| shouldFail(1, isNonPositive, |
| "Expected: a non-positive value but: was <1>."); |
| }); |
| |
| test('isNonNegative', () { |
| shouldPass(1, isNonNegative); |
| shouldPass(0, isNonNegative); |
| 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>."); |
| shouldFail(-1.001, closeTo(0, 1), |
| "Expected: a numeric value within <1> of <0> " |
| "but: <-1.001> differed by <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), |
| "Expected: be in range from 0 (inclusive) to 2 (inclusive) " |
| "but: was <3>."); |
| }); |
| |
| test('inExclusiveRange', () { |
| shouldFail(0, inExclusiveRange(0,2), |
| "Expected: be in range from 0 (exclusive) to 2 (exclusive) " |
| "but: was <0>."); |
| shouldPass(1, inExclusiveRange(0,2)); |
| shouldFail(2, inExclusiveRange(0,2), |
| "Expected: be in range from 0 (exclusive) to 2 (exclusive) " |
| "but: was <2>."); |
| }); |
| |
| test('inOpenClosedRange', () { |
| shouldFail(0, inOpenClosedRange(0,2), |
| "Expected: be in range from 0 (exclusive) to 2 (inclusive) " |
| "but: was <0>."); |
| shouldPass(1, inOpenClosedRange(0,2)); |
| shouldPass(2, inOpenClosedRange(0,2)); |
| }); |
| |
| 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'."); |
| }); |
| |
| test('equalsIgnoringCase', () { |
| shouldPass('hello', equalsIgnoringCase('HELLO')); |
| shouldFail('hi', equalsIgnoringCase('HELLO'), |
| "Expected: 'HELLO' ignoring case but: was 'hi'."); |
| }); |
| |
| test('equalsIgnoringWhitespace', () { |
| shouldPass(' hello world ', equalsIgnoringWhitespace('hello world')); |
| shouldFail(' helloworld ', equalsIgnoringWhitespace('hello world'), |
| "Expected: 'hello world' ignoring whitespace but: was 'helloworld'."); |
| }); |
| |
| test('startsWith', () { |
| shouldPass('hello', startsWith('')); |
| shouldPass('hello', startsWith('hell')); |
| shouldPass('hello', startsWith('hello')); |
| shouldFail('hello', startsWith('hello '), |
| "Expected: a string starting with 'hello ' but: was 'hello'."); |
| }); |
| |
| test('endsWith', () { |
| shouldPass('hello', endsWith('')); |
| shouldPass('hello', endsWith('lo')); |
| shouldPass('hello', endsWith('hello')); |
| shouldFail('hello', endsWith(' hello'), |
| "Expected: a string ending with ' hello' but: was 'hello'."); |
| }); |
| |
| test('contains', () { |
| shouldPass('hello', contains('')); |
| shouldPass('hello', contains('h')); |
| shouldPass('hello', contains('o')); |
| shouldPass('hello', contains('hell')); |
| shouldPass('hello', contains('hello')); |
| shouldFail('hello', contains(' '), |
| "Expected: contains ' ' but: was 'hello'."); |
| }); |
| |
| test('stringContainsInOrder', () { |
| shouldPass('goodbye cruel world', stringContainsInOrder([''])); |
| shouldPass('goodbye cruel world', stringContainsInOrder(['goodbye'])); |
| shouldPass('goodbye cruel world', stringContainsInOrder(['cruel'])); |
| shouldPass('goodbye cruel world', stringContainsInOrder(['world'])); |
| shouldPass('goodbye cruel world', |
| stringContainsInOrder(['good', 'bye', 'world'])); |
| shouldPass('goodbye cruel world', |
| stringContainsInOrder(['goodbye', 'cruel'])); |
| shouldPass('goodbye cruel world', |
| stringContainsInOrder(['cruel', 'world'])); |
| shouldPass('goodbye cruel world', |
| stringContainsInOrder(['goodbye', 'cruel', 'world'])); |
| shouldFail('goodbye cruel world', |
| stringContainsInOrder(['goo', 'cruel', 'bye']), |
| "Expected: a string containing 'goo', 'cruel', 'bye' in order " |
| "but: was 'goodbye cruel world'."); |
| }); |
| |
| test('matches', () { |
| shouldPass('c0d', matches('[a-z][0-9][a-z]')); |
| shouldPass('c0d', matches(new RegExp('[a-z][0-9][a-z]'))); |
| 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]>."); |
| }); |
| |
| test('contains', () { |
| var d = new SimpleIterable(3); |
| shouldPass(d, contains(2)); |
| shouldFail(d, contains(5), "Expected: contains <5> but: was <[3]>."); |
| }); |
| }); |
| |
| group('Iterable Matchers', () { |
| |
| test('isEmpty', () { |
| 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 <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]>."); |
| }); |
| |
| 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."); |
| }); |
| |
| 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."); |
| }); |
| }); |
| |
| 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}>."); |
| }); |
| |
| 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'."); |
| }); |
| |
| 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'."); |
| shouldFail(b, equals(a), |
| "Expected: <{foo: bar}> " |
| "but: different map lengths; extra map key 'bar'."); |
| shouldFail(b, equals(c), |
| "Expected: <{bar: foo, barrista: caffeine}> " |
| "but: missing map key 'barrista'."); |
| shouldFail(c, equals(b), |
| "Expected: <{foo: bar, bar: foo}> " |
| "but: missing map key 'foo'."); |
| shouldFail(a, equals(c), |
| "Expected: <{bar: foo, barrista: caffeine}> " |
| "but: different map lengths; missing map key 'bar'."); |
| shouldFail(c, equals(a), |
| "Expected: <{foo: bar}> " |
| "but: different map lengths; missing map key 'foo'."); |
| }); |
| |
| 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 <{}>."); |
| 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}>."); |
| }); |
| |
| 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'."); |
| }); |
| |
| 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('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); |
| }); |
| |
| 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(); |
| completer.complete('1'); |
| shouldFail(completer.future, throws, |
| contains("Expected future to fail, but succeeded with '1'"), |
| isAsync: true); |
| }); |
| |
| test('throws - expected to see exception', () { |
| var completer = new Completer(); |
| completer.completeError('X'); |
| shouldPass(completer.future, throws, isAsync: true); |
| }); |
| |
| test('throws - expected to see exception thrown later on', () { |
| var completer = new Completer(); |
| var chained = completer.future.then((_) { throw 'X'; }); |
| shouldPass(chained, throws, isAsync: true); |
| completer.complete('1'); |
| }); |
| |
| test('throwsA - unexpected normal completion', () { |
| var completer = new Completer(); |
| completer.complete('1'); |
| shouldFail(completer.future, throwsA(equals('X')), |
| contains("Expected future to fail, but succeeded with '1'"), |
| isAsync: true); |
| }); |
| |
| test('throwsA - correct error', () { |
| var completer = new Completer(); |
| completer.completeError('X'); |
| shouldPass(completer.future, throwsA(equals('X')), isAsync: true); |
| }); |
| |
| test('throwsA - wrong error', () { |
| var completer = new Completer(); |
| completer.completeError('X'); |
| shouldFail(completer.future, throwsA(equals('Y')), |
| "Expected: 'Y' but: was 'X'.", |
| isAsync: true); |
| }); |
| }); |
| |
| 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")); |
| }); |
| }); |
| |
| 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>.'); |
| }); |
| }); |
| } |
| |
