blob: 8082bd5ad224ba813c6dbdaec2d1d4cd407cce9c [file] [log] [blame]
// Copyright (c) 2016, 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.
/// A minimal, dependency-free emulation layer for a subset of the
/// unittest/test API used by the language and core library (especially HTML)
/// tests.
///
/// A number of our language and core library tests were written against the
/// unittest package, which is now deprecated in favor of the new test package.
/// The latter is much better feature-wise, but is also quite complex and has
/// many dependencies. For low-level language and core library tests, we don't
/// want to have to pull in a large number of dependencies and be able to run
/// them correctly in order to run a test, so we want to test them against
/// something simpler.
///
/// When possible, we just use the tiny expect library. But to avoid rewriting
/// all of the existing tests that use unittest, they can instead use this,
/// which shims the unittest API with as little code as possible and calls into
/// expect.
///
/// Eventually, it would be good to refactor those tests to use the expect
/// package directly and remove this.
import 'dart:async';
import 'package:expect/expect.dart';
typedef dynamic _Action();
typedef void _ExpectationFunction(Object actual);
final List<_Group> _groups = [new _Group()];
final Object isFalse = new _Expectation(Expect.isFalse);
final Object isNotNull = new _Expectation(Expect.isNotNull);
final Object isNull = new _Expectation(Expect.isNull);
final Object isTrue = new _Expectation(Expect.isTrue);
final Object returnsNormally = new _Expectation((actual) {
try {
(actual as _Action)();
} catch (error) {
Expect.fail("Expected function to return normally, but threw:\n$error");
}
});
final Object throws = new _Expectation((actual) {
Expect.throws(actual as _Action);
});
final Object throwsArgumentError = new _Expectation((actual) {
Expect.throws(actual as _Action, (error) => error is ArgumentError);
});
final Object throwsNoSuchMethodError = new _Expectation((actual) {
Expect.throws(actual as _Action, (error) => error is NoSuchMethodError);
});
final Object throwsRangeError = new _Expectation((actual) {
Expect.throws(actual as _Action, (error) => error is RangeError);
});
final Object throwsStateError = new _Expectation((actual) {
Expect.throws(actual as _Action, (error) => error is StateError);
});
final Object throwsUnsupportedError = new _Expectation((actual) {
Expect.throws(actual as _Action, (error) => error is UnsupportedError);
});
/// The test runner should call this once after running a test file.
void finishTests() {
_groups.clear();
_groups.add(new _Group());
}
void group(String description, body()) {
// TODO(rnystrom): Do something useful with the description.
_groups.add(new _Group());
try {
var result = body();
if (result is Future) {
Expect.testError("group() does not support asynchronous functions.");
}
} finally {
_groups.removeLast();
}
}
void test(String description, body()) {
// TODO(rnystrom): Do something useful with the description.
for (var group in _groups) {
if (group.setUpFunction != null) {
var result = group.setUpFunction();
if (result is Future) {
Expect.testError("setUp() does not support asynchronous functions.");
}
}
}
try {
var result = body();
if (result is Future) {
Expect.testError("test() does not support asynchronous functions.");
}
} finally {
for (var i = _groups.length - 1; i >= 0; i--) {
var group = _groups[i];
if (group.tearDownFunction != null) {
var result = group.tearDownFunction();
if (result is Future) {
Expect
.testError("tearDown() does not support asynchronous functions.");
}
}
}
}
}
void setUp(body()) {
// Can't define multiple setUps at the same level.
assert(_groups.last.setUpFunction == null);
_groups.last.setUpFunction = body;
}
void tearDown(body()) {
// Can't define multiple tearDowns at the same level.
assert(_groups.last.tearDownFunction == null);
_groups.last.tearDownFunction = body;
}
void expect(Object actual, Object expected, {String reason}) {
// TODO(rnystrom): Do something useful with reason.
if (expected is! _Expectation) {
expected = equals(expected);
}
var expectation = expected as _Expectation;
expectation.function(actual);
}
void fail(String message) {
Expect.fail(message);
}
Object equals(Object value) => new _Expectation((actual) {
Expect.deepEquals(value, actual);
});
Object notEquals(Object value) => new _Expectation((actual) {
Expect.notEquals(value, actual);
});
Object unorderedEquals(Object value) => new _Expectation((actual) {
Expect.setEquals(value, actual);
});
Object predicate(bool fn(Object value), [String description]) =>
new _Expectation((actual) {
Expect.isTrue(fn(actual), description);
});
Object inInclusiveRange(num min, num max) => new _Expectation((actual) {
var actualNum = actual as num;
if (actualNum < min || actualNum > max) {
fail("Expected $actualNum to be in the inclusive range [$min, $max].");
}
});
Object greaterThan(num value) => new _Expectation((actual) {
var actualNum = actual as num;
if (actualNum <= value) {
fail("Expected $actualNum to be greater than $value.");
}
});
Object same(Object value) => new _Expectation((actual) {
Expect.identical(value, actual);
});
Object closeTo(num value, num tolerance) => new _Expectation((actual) {
Expect.approxEquals(value, actual, tolerance);
});
/// Succeeds if the actual value is any of the given strings. Unlike matcher's
/// [anyOf], this only works with strings and requires an explicit list.
Object anyOf(List<String> expected) => new _Expectation((actual) {
for (var string in expected) {
if (actual == string) return;
}
fail("Expected $actual to be one of $expected.");
});
/// One level of group() nesting to track an optional [setUp()] and [tearDown()]
/// function for the group.
///
/// There is also an implicit top level group.
class _Group {
_Action setUpFunction;
_Action tearDownFunction;
}
/// A wrapper around an expectation function.
///
/// This function is passed the actual value and should throw an
/// [ExpectException] if the value doesn't match the expectation.
class _Expectation {
final _ExpectationFunction function;
_Expectation(this.function);
}