106 lines
3.0 KiB
Rust
106 lines
3.0 KiB
Rust
import std::test;
|
|
import std::istr;
|
|
import std::option;
|
|
import std::either;
|
|
import std::vec;
|
|
|
|
#[test]
|
|
fn do_not_run_ignored_tests() {
|
|
let ran = @mutable false;
|
|
let f = bind fn (ran: @mutable bool) { *ran = true; }(ran);
|
|
|
|
let desc = {name: ~"whatever", fn: f, ignore: true};
|
|
|
|
test::run_test(desc, test::default_test_to_task);
|
|
|
|
assert (*ran == false);
|
|
}
|
|
|
|
#[test]
|
|
fn ignored_tests_result_in_ignored() {
|
|
fn f() { }
|
|
let desc = {name: ~"whatever", fn: f, ignore: true};
|
|
let res = test::run_test(desc, test::default_test_to_task).wait();
|
|
assert (res == test::tr_ignored);
|
|
}
|
|
|
|
#[test]
|
|
fn first_free_arg_should_be_a_filter() {
|
|
let args = [~"progname", ~"filter"];
|
|
check (vec::is_not_empty(args));
|
|
let opts = alt test::parse_opts(args) { either::left(o) { o } };
|
|
assert (istr::eq(~"filter", option::get(opts.filter)));
|
|
}
|
|
|
|
#[test]
|
|
fn parse_ignored_flag() {
|
|
let args = [~"progname", ~"filter", ~"--ignored"];
|
|
check (vec::is_not_empty(args));
|
|
let opts = alt test::parse_opts(args) { either::left(o) { o } };
|
|
assert (opts.run_ignored);
|
|
}
|
|
|
|
#[test]
|
|
fn filter_for_ignored_option() {
|
|
// When we run ignored tests the test filter should filter out all the
|
|
// unignored tests and flip the ignore flag on the rest to false
|
|
|
|
let opts = {filter: option::none, run_ignored: true};
|
|
let tests =
|
|
[{name: ~"1", fn: fn () { }, ignore: true},
|
|
{name: ~"2", fn: fn () { }, ignore: false}];
|
|
let filtered = test::filter_tests(opts, tests);
|
|
|
|
assert (vec::len(filtered) == 1u);
|
|
assert (filtered[0].name == ~"1");
|
|
assert (filtered[0].ignore == false);
|
|
}
|
|
|
|
#[test]
|
|
fn sort_tests() {
|
|
let opts = {filter: option::none, run_ignored: false};
|
|
|
|
let names =
|
|
[~"sha1::test", ~"int::test_to_str", ~"int::test_pow",
|
|
~"test::do_not_run_ignored_tests",
|
|
~"test::ignored_tests_result_in_ignored",
|
|
~"test::first_free_arg_should_be_a_filter",
|
|
~"test::parse_ignored_flag", ~"test::filter_for_ignored_option",
|
|
~"test::sort_tests"];
|
|
let tests =
|
|
{
|
|
let testfn = fn () { };
|
|
let tests = [];
|
|
for name: istr in names {
|
|
let test = {name: name, fn: testfn, ignore: false};
|
|
tests += [test];
|
|
}
|
|
tests
|
|
};
|
|
let filtered = test::filter_tests(opts, tests);
|
|
|
|
let expected =
|
|
[~"int::test_pow", ~"int::test_to_str", ~"sha1::test",
|
|
~"test::do_not_run_ignored_tests",
|
|
~"test::filter_for_ignored_option",
|
|
~"test::first_free_arg_should_be_a_filter",
|
|
~"test::ignored_tests_result_in_ignored",
|
|
~"test::parse_ignored_flag",
|
|
~"test::sort_tests"];
|
|
|
|
check vec::same_length(expected, filtered);
|
|
let pairs = vec::zip(expected, filtered);
|
|
|
|
|
|
for (a, b) in pairs { assert (a == b.name); }
|
|
}
|
|
|
|
// Local Variables:
|
|
// mode: rust;
|
|
// fill-column: 78;
|
|
// indent-tabs-mode: nil
|
|
// c-basic-offset: 4
|
|
// buffer-file-coding-system: utf-8-unix
|
|
// compile-command: "make -k -C .. 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
|
|
// End:
|