Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1017)

Unified Diff: pkg/matcher/test/matchers_test.dart

Issue 317733006: pkg/matcher: reapply 36881,36896 working around Issue 19173 (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: nit Created 6 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « pkg/matcher/test/iterable_matchers_test.dart ('k') | pkg/matcher/test/numeric_matchers_test.dart » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: pkg/matcher/test/matchers_test.dart
diff --git a/pkg/matcher/test/matchers_test.dart b/pkg/matcher/test/matchers_test.dart
deleted file mode 100644
index e74d0487e71fbeca8b089bf1ba5dcb6517870c50..0000000000000000000000000000000000000000
--- a/pkg/matcher/test/matchers_test.dart
+++ /dev/null
@@ -1,803 +0,0 @@
-// 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 matcher.test;
-
-import 'dart:async';
-import 'dart:collection';
-
-import 'package:matcher/matcher.dart';
-import 'package:unittest/unittest.dart' show test, group;
-
-import 'test_utils.dart';
-
-void main() {
-
- initUtils();
-
- // Core matchers
-
- group('Core matchers', () {
-
- test('isTrue', () {
- shouldPass(true, isTrue);
- shouldFail(false, isTrue, "Expected: true Actual: <false>");
- });
-
- test('isFalse', () {
- shouldPass(false, isFalse);
- shouldFail(10, isFalse, "Expected: false Actual: <10>");
- shouldFail(true, isFalse, "Expected: false Actual: <true>");
- });
-
- test('isNull', () {
- shouldPass(null, isNull);
- shouldFail(false, isNull, "Expected: null Actual: <false>");
- });
-
- test('isNotNull', () {
- shouldPass(false, isNotNull);
- shouldFail(null, isNotNull, "Expected: not null Actual: <null>");
- });
-
- test('same', () {
- var a = new Map();
- var b = new Map();
- shouldPass(a, same(a));
- shouldFail(b, same(a), "Expected: same instance as {} Actual: {}");
- });
-
- 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 Actual: {}");
- });
-
- test('throws', () {
- shouldFail(doesNotThrow, throws,
- matches(
- r"Expected: throws"
- r" Actual: <Closure(: \(\) => dynamic "
- r"from Function 'doesNotThrow': static\.)?>"
- r" Which: did not throw"));
- shouldPass(doesThrow, throws);
- shouldFail(true, throws,
- "Expected: throws"
- " Actual: <true>"
- " Which: is not a Function or Future");
- });
-
- test('throwsA', () {
- shouldPass(doesThrow, throwsA(equals('X')));
- shouldFail(doesThrow, throwsA(equals('Y')),
- matches(
- r"Expected: throws 'Y'"
- r" Actual: <Closure(: \(\) => dynamic "
- r"from Function 'doesThrow': static\.)?>"
- r" Which: threw 'X'"));
- });
-
- test('returnsNormally', () {
- shouldPass(doesNotThrow, returnsNormally);
- shouldFail(doesThrow, returnsNormally,
- matches(
- r"Expected: return normally"
- r" Actual: <Closure(: \(\) => dynamic "
- r"from Function 'doesThrow': static\.)?>"
- r" Which: 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> "
- "Actual: <0> "
- "Which: has no length property"));
-
- b.add(0);
- shouldPass(b, hasLength(1));
- shouldFail(b, hasLength(2),
- "Expected: an object with length of <2> "
- "Actual: [0] "
- "Which: has length of <1>");
-
- b.add(0);
- shouldFail(b, hasLength(1),
- "Expected: an object with length of <1> "
- "Actual: [0, 0] "
- "Which: has length of <2>");
- shouldPass(b, hasLength(2));
- });
-
- test('scalar type mismatch', () {
- shouldFail('error', equals(5.1),
- "Expected: <5.1> "
- "Actual: 'error'");
- });
-
- test('nested type mismatch', () {
- shouldFail(['error'], equals([5.1]),
- "Expected: [5.1] "
- "Actual: ['error'] "
- "Which: was 'error' instead of <5.1> at location [0]");
- });
-
- test('doubly-nested type mismatch', () {
- shouldFail([['error']], equals([[5.1]]),
- "Expected: [[5.1]] "
- "Actual: [['error']] "
- "Which: was 'error' instead of <5.1> at location [0][0]");
- });
-
- test('doubly nested inequality', () {
- var actual1 = [['foo', 'bar'], ['foo'], 3, []];
- var expected1 = [['foo', 'bar'], ['foo'], 4, []];
- var reason1 = "Expected: [['foo', 'bar'], ['foo'], 4, []] "
- "Actual: [['foo', 'bar'], ['foo'], 3, []] "
- "Which: was <3> instead of <4> at location [2]";
-
- var actual2 = [['foo', 'barry'], ['foo'], 4, []];
- var expected2 = [['foo', 'bar'], ['foo'], 4, []];
- var reason2 = "Expected: [['foo', 'bar'], ['foo'], 4, []] "
- "Actual: [['foo', 'barry'], ['foo'], 4, []] "
- "Which: was 'barry' instead of 'bar' at location [0][1]";
-
- var actual3 = [['foo', 'bar'], ['foo'], 4, {'foo':'bar'}];
- var expected3 = [['foo', 'bar'], ['foo'], 4, {'foo':'barry'}];
- var reason3 = "Expected: [['foo', 'bar'], ['foo'], 4, {'foo': 'barry'}] "
- "Actual: [['foo', 'bar'], ['foo'], 4, {'foo': 'bar'}] "
- "Which: was 'bar' instead of 'barry' at location [3]['foo']";
-
- shouldFail(actual1, equals(expected1), reason1);
- shouldFail(actual2, equals(expected2), reason2);
- shouldFail(actual3, equals(expected3), reason3);
- });
- });
-
- group('Numeric Matchers', () {
-
- test('greaterThan', () {
- shouldPass(10, greaterThan(9));
- shouldFail(9, greaterThan(10),
- "Expected: a value greater than <10> "
- "Actual: <9> "
- "Which: is not a value greater than <10>");
- });
-
- test('greaterThanOrEqualTo', () {
- shouldPass(10, greaterThanOrEqualTo(10));
- shouldFail(9, greaterThanOrEqualTo(10),
- "Expected: a value greater than or equal to <10> "
- "Actual: <9> "
- "Which: is not a value greater than or equal to <10>");
- });
-
- test('lessThan', () {
- shouldFail(10, lessThan(9),
- "Expected: a value less than <9> "
- "Actual: <10> "
- "Which: is not a value less than <9>");
- shouldPass(9, lessThan(10));
- });
-
- test('lessThanOrEqualTo', () {
- shouldPass(10, lessThanOrEqualTo(10));
- shouldFail(11, lessThanOrEqualTo(10),
- "Expected: a value less than or equal to <10> "
- "Actual: <11> "
- "Which: is not a value less than or equal to <10>");
- });
-
- test('isZero', () {
- shouldPass(0, isZero);
- shouldFail(1, isZero,
- "Expected: a value equal to <0> "
- "Actual: <1> "
- "Which: is not a value equal to <0>");
- });
-
- test('isNonZero', () {
- shouldFail(0, isNonZero,
- "Expected: a value not equal to <0> "
- "Actual: <0> "
- "Which: is not a value not equal to <0>");
- shouldPass(1, isNonZero);
- });
-
- test('isPositive', () {
- shouldFail(-1, isPositive,
- "Expected: a positive value "
- "Actual: <-1> "
- "Which: is not a positive value");
- shouldFail(0, isPositive,
- "Expected: a positive value "
- "Actual: <0> "
- "Which: is not a positive value");
- shouldPass(1, isPositive);
- });
-
- test('isNegative', () {
- shouldPass(-1, isNegative);
- shouldFail(0, isNegative,
- "Expected: a negative value "
- "Actual: <0> "
- "Which: is not a negative value");
- });
-
- test('isNonPositive', () {
- shouldPass(-1, isNonPositive);
- shouldPass(0, isNonPositive);
- shouldFail(1, isNonPositive,
- "Expected: a non-positive value "
- "Actual: <1> "
- "Which: is not a non-positive value");
- });
-
- test('isNonNegative', () {
- shouldPass(1, isNonNegative);
- shouldPass(0, isNonNegative);
- shouldFail(-1, isNonNegative,
- "Expected: a non-negative value "
- "Actual: <-1> "
- "Which: is not a non-negative value");
- });
-
- 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> "
- "Actual: <1.001> "
- "Which: differs by <1.001>");
- shouldFail(-1.001, closeTo(0, 1),
- "Expected: a numeric value within <1> of <0> "
- "Actual: <-1.001> "
- "Which: differs by <1.001>");
- });
-
- test('inInclusiveRange', () {
- shouldFail(-1, inInclusiveRange(0,2),
- "Expected: be in range from 0 (inclusive) to 2 (inclusive) "
- "Actual: <-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) "
- "Actual: <3>");
- });
-
- test('inExclusiveRange', () {
- shouldFail(0, inExclusiveRange(0,2),
- "Expected: be in range from 0 (exclusive) to 2 (exclusive) "
- "Actual: <0>");
- shouldPass(1, inExclusiveRange(0,2));
- shouldFail(2, inExclusiveRange(0,2),
- "Expected: be in range from 0 (exclusive) to 2 (exclusive) "
- "Actual: <2>");
- });
-
- test('inOpenClosedRange', () {
- shouldFail(0, inOpenClosedRange(0,2),
- "Expected: be in range from 0 (exclusive) to 2 (inclusive) "
- "Actual: <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) "
- "Actual: <2>");
- });
- });
-
- group('String Matchers', () {
-
- test('isEmpty', () {
- shouldPass('', isEmpty);
- shouldFail(null, isEmpty,
- "Expected: empty Actual: <null>");
- shouldFail(0, isEmpty,
- "Expected: empty Actual: <0>");
- shouldFail('a', isEmpty, "Expected: empty Actual: 'a'");
- });
-
- test('equalsIgnoringCase', () {
- shouldPass('hello', equalsIgnoringCase('HELLO'));
- shouldFail('hi', equalsIgnoringCase('HELLO'),
- "Expected: 'HELLO' ignoring case Actual: 'hi'");
- });
-
- test('equalsIgnoringWhitespace', () {
- shouldPass(' hello world ', equalsIgnoringWhitespace('hello world'));
- shouldFail(' helloworld ', equalsIgnoringWhitespace('hello world'),
- "Expected: 'hello world' ignoring whitespace "
- "Actual: ' helloworld ' "
- "Which: is 'helloworld' with whitespace compressed");
- });
-
- test('startsWith', () {
- shouldPass('hello', startsWith(''));
- shouldPass('hello', startsWith('hell'));
- shouldPass('hello', startsWith('hello'));
- shouldFail('hello', startsWith('hello '),
- "Expected: a string starting with 'hello ' "
- "Actual: 'hello'");
- });
-
- test('endsWith', () {
- shouldPass('hello', endsWith(''));
- shouldPass('hello', endsWith('lo'));
- shouldPass('hello', endsWith('hello'));
- shouldFail('hello', endsWith(' hello'),
- "Expected: a string ending with ' hello' "
- "Actual: '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 ' ' Actual: '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 "
- "Actual: '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]' Actual: 'cOd'");
- });
- });
-
- group('Iterable Matchers', () {
-
- test('isEmpty', () {
- shouldPass([], isEmpty);
- shouldFail([1], isEmpty, "Expected: empty Actual: [1]");
- });
-
- test('contains', () {
- var d = [1, 2];
- shouldPass(d, contains(1));
- shouldFail(d, contains(0), "Expected: contains <0> "
- "Actual: [1, 2]");
- });
-
- test('equals with matcher element', () {
- var d = ['foo', 'bar'];
- shouldPass(d, equals(['foo', startsWith('ba')]));
- shouldFail(d, equals(['foo', endsWith('ba')]),
- "Expected: ['foo', <a string ending with 'ba'>] "
- "Actual: ['foo', 'bar'] "
- "Which: does not match a string ending with 'ba' at location [1]");
- });
-
- test('isIn', () {
- var d = [1, 2];
- shouldPass(1, isIn(d));
- shouldFail(0, isIn(d), "Expected: is in [1, 2] Actual: <0>");
- });
-
- test('everyElement', () {
- var d = [1, 2];
- var e = [1, 1, 1];
- shouldFail(d, everyElement(1),
- "Expected: every element(<1>) "
- "Actual: [1, 2] "
- "Which: has value <2> which doesn't match <1> at index 1");
- shouldPass(e, everyElement(1));
- });
-
- test('nested everyElement', () {
- var d = [['foo', 'bar'], ['foo'], []];
- var e = [['foo', 'bar'], ['foo'], 3, []];
- shouldPass(d, everyElement(anyOf(isEmpty, contains('foo'))));
- shouldFail(d, everyElement(everyElement(equals('foo'))),
- "Expected: every element(every element('foo')) "
- "Actual: [['foo', 'bar'], ['foo'], []] "
- "Which: has value ['foo', 'bar'] which has value 'bar' "
- "which is different. Expected: foo Actual: bar ^ "
- "Differ at offset 0 at index 1 at index 0");
- shouldFail(d, everyElement(allOf(hasLength(greaterThan(0)),
- contains('foo'))),
- "Expected: every element((an object with length of a value "
- "greater than <0> and contains 'foo')) "
- "Actual: [['foo', 'bar'], ['foo'], []] "
- "Which: has value [] which has length of <0> at index 2");
- shouldFail(d, everyElement(allOf(contains('foo'),
- hasLength(greaterThan(0)))),
- "Expected: every element((contains 'foo' and "
- "an object with length of a value greater than <0>)) "
- "Actual: [['foo', 'bar'], ['foo'], []] "
- "Which: has value [] which doesn't match (contains 'foo' and "
- "an object with length of a value greater than <0>) at index 2");
- shouldFail(e, everyElement(allOf(contains('foo'),
- hasLength(greaterThan(0)))),
- "Expected: every element((contains 'foo' and an object with "
- "length of a value greater than <0>)) "
- "Actual: [['foo', 'bar'], ['foo'], 3, []] "
- "Which: has value <3> which is not a string, map or iterable "
- "at index 2");
- });
-
- test('anyElement', () {
- var d = [1, 2];
- var e = [1, 1, 1];
- shouldPass(d, anyElement(2));
- shouldFail(e, anyElement(2),
- "Expected: some element <2> Actual: [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 "
- "Actual: [1, 2] "
- "Which: was <1> instead of <2> at location [0]");
- });
-
- test('unorderedEquals', () {
- var d = [1, 2];
- shouldPass(d, unorderedEquals([2, 1]));
- shouldFail(d, unorderedEquals([1]),
- "Expected: equals [1] unordered "
- "Actual: [1, 2] "
- "Which: has too many elements (2 > 1)");
- shouldFail(d, unorderedEquals([3, 2, 1]),
- "Expected: equals [3, 2, 1] unordered "
- "Actual: [1, 2] "
- "Which: has too few elements (2 < 3)");
- shouldFail(d, unorderedEquals([3, 1]),
- "Expected: equals [3, 1] unordered "
- "Actual: [1, 2] "
- "Which: has no match for <3> at index 0");
- });
-
- test('unorderedMatchess', () {
- var d = [1, 2];
- shouldPass(d, unorderedMatches([2, 1]));
- shouldPass(d, unorderedMatches([greaterThan(1), greaterThan(0)]));
- shouldFail(d, unorderedMatches([greaterThan(0)]),
- "Expected: matches [a value greater than <0>] unordered "
- "Actual: [1, 2] "
- "Which: has too many elements (2 > 1)");
- shouldFail(d, unorderedMatches([3, 2, 1]),
- "Expected: matches [<3>, <2>, <1>] unordered "
- "Actual: [1, 2] "
- "Which: has too few elements (2 < 3)");
- shouldFail(d, unorderedMatches([3, 1]),
- "Expected: matches [<3>, <1>] unordered "
- "Actual: [1, 2] "
- "Which: has no match for <3> at index 0");
- shouldFail(d, unorderedMatches([greaterThan(3), greaterThan(0)]),
- "Expected: matches [a value greater than <3>, a value greater than "
- "<0>] unordered "
- "Actual: [1, 2] "
- "Which: has no match for a value greater than <3> at index 0");
- });
-
- 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] "
- "Actual: 'x' "
- "Which: is not an Iterable");
- shouldFail(c, pairwiseCompare(e, (e,a) => a <= e, "less than or equal"),
- "Expected: pairwise less than or equal [1, 4, 9] "
- "Actual: [1, 2] "
- "Which: has length 2 instead of 3");
- 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] "
- "Actual: [1, 2, 3] "
- "Which: has <1> which is not less than <1> at index 0");
- 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] "
- "Actual: [1, 2, 3] "
- "Which: has <1> which is not double <1> at index 0");
- });
- });
-
- group('Map Matchers', () {
-
- test('isEmpty', () {
- var a = new Map();
- shouldPass({}, isEmpty);
- shouldPass(a, isEmpty);
- a['foo'] = 'bar';
- shouldFail(a, isEmpty, "Expected: empty "
- "Actual: {'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'} "
- "Actual: {'foo': 'bar'} "
- "Which: is 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'} "
- "Actual: {'foo': 'bar'} "
- "Which: has different length and is missing map key 'bar'");
- shouldFail(b, equals(a),
- "Expected: {'foo': 'bar'} "
- "Actual: {'foo': 'bar', 'bar': 'foo'} "
- "Which: has different length and has extra map key 'bar'");
- shouldFail(b, equals(c),
- "Expected: {'bar': 'foo', 'barrista': 'caffeine'} "
- "Actual: {'foo': 'bar', 'bar': 'foo'} "
- "Which: is missing map key 'barrista'");
- shouldFail(c, equals(b),
- "Expected: {'foo': 'bar', 'bar': 'foo'} "
- "Actual: {'bar': 'foo', 'barrista': 'caffeine'} "
- "Which: is missing map key 'foo'");
- shouldFail(a, equals(c),
- "Expected: {'bar': 'foo', 'barrista': 'caffeine'} "
- "Actual: {'foo': 'bar'} "
- "Which: has different length and is missing map key 'bar'");
- shouldFail(c, equals(a),
- "Expected: {'foo': 'bar'} "
- "Actual: {'bar': 'foo', 'barrista': 'caffeine'} "
- "Which: has different length and is missing map key 'foo'");
- });
-
- test('equals with matcher value', () {
- var a = new Map();
- a['foo'] = 'bar';
- shouldPass(a, equals({'foo': startsWith('ba')}));
- shouldFail(a, equals({'foo': endsWith('ba')}),
- "Expected: {'foo': <a string ending with 'ba'>} "
- "Actual: {'foo': 'bar'} "
- "Which: does not match a string ending with 'ba' "
- "at location ['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' Actual: {}");
- shouldFail(10, contains('foo'),
- "Expected: contains 'foo' Actual: <10> "
- "Which: is not a string, map or iterable");
- });
-
- test('containsValue', () {
- var a = new Map();
- a['foo'] = 'bar';
- shouldPass(a, containsValue('bar'));
- shouldFail(a, containsValue('ba'),
- "Expected: contains value 'ba' "
- "Actual: {'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' "
- "Actual: {'foo': 'bar'} "
- "Which: is different. Both strings start the same, but "
- "the given value also has the following trailing characters: r");
- shouldFail(a, containsPair('fo', 'bar'),
- "Expected: contains pair 'fo' => 'bar' "
- "Actual: {'foo': 'bar'} "
- "Which: 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> "
- "Actual: {} "
- "Which: has length of <0>");
- });
- });
-
- group('Operator Matchers', () {
-
- test('anyOf', () {
- shouldFail(0, anyOf([equals(1), equals(2)]),
- "Expected: (<1> or <2>) Actual: <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>) "
- "Actual: <-1> "
- "Which: is not a value greater than <0>");
- });
- });
-
- 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' Actual: 'X' "
- "Which: is different. "
- "Expected: Y Actual: X ^ Differ at offset 0",
- isAsync: true);
- });
- });
-
- group('Predicate Matchers', () {
- test('isInstanceOf', () {
- shouldFail(0, predicate((x) => x is String, "an instance of String"),
- "Expected: an instance of String Actual: <0>");
- shouldPass('cow', predicate((x) => x is String, "an instance of String"));
- });
- });
-
- group('exception/error matchers', () {
- // TODO(gram): extend this to more types; for now this is just
- // the types being added in this CL.
-
- test('throwsCyclicInitializationError', () {
- expect(() => _Bicycle.foo, throwsCyclicInitializationError);
- });
-
- test('throwsAbstractClassInstantiationError', () {
- expect(() => new _AbstractClass(), throwsAbstractClassInstantiationError);
- });
-
- test('throwsConcurrentModificationError', () {
- expect(() {
- var a = { 'foo': 'bar' };
- for (var k in a.keys) {
- a.remove(k);
- }
- }, throwsConcurrentModificationError);
- });
-
- test('throwsNullThrownError', () {
- expect(() => throw null, throwsNullThrownError);
- });
-
- test('throwsFallThroughError', () {
- expect(() {
- var a = 0;
- switch (a) {
- case 0:
- a += 1;
- case 1:
- return;
- }
- }, throwsFallThroughError);
- });
- });
-}
-
-class _Bicycle {
- static final foo = bar();
-
- static bar() {
- return foo + 1;
- }
-}
-
-abstract class _AbstractClass {
-}
« no previous file with comments | « pkg/matcher/test/iterable_matchers_test.dart ('k') | pkg/matcher/test/numeric_matchers_test.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698