Introduce Custom Test Frameworks
This commit is contained in:
John Renner
328
src/libsyntax_ext/test.rs
Normal file
328
src/libsyntax_ext/test.rs
Normal file
@@ -0,0 +1,328 @@
|
||||
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
/// The expansion from a test function to the appropriate test struct for libtest
|
||||
/// Ideally, this code would be in libtest but for efficiency and error messages it lives here.
|
||||
|
||||
use syntax::ext::base::*;
|
||||
use syntax::ext::build::AstBuilder;
|
||||
use syntax::ext::hygiene::{self, Mark, SyntaxContext};
|
||||
use syntax::attr;
|
||||
use syntax::ast;
|
||||
use syntax::print::pprust;
|
||||
use syntax::symbol::Symbol;
|
||||
use syntax_pos::{DUMMY_SP, Span};
|
||||
use syntax::source_map::{ExpnInfo, MacroAttribute};
|
||||
use std::iter;
|
||||
|
||||
pub fn expand_test(
|
||||
cx: &mut ExtCtxt,
|
||||
attr_sp: Span,
|
||||
_meta_item: &ast::MetaItem,
|
||||
item: Annotatable,
|
||||
) -> Vec<Annotatable> {
|
||||
expand_test_or_bench(cx, attr_sp, item, false)
|
||||
}
|
||||
|
||||
pub fn expand_bench(
|
||||
cx: &mut ExtCtxt,
|
||||
attr_sp: Span,
|
||||
_meta_item: &ast::MetaItem,
|
||||
item: Annotatable,
|
||||
) -> Vec<Annotatable> {
|
||||
expand_test_or_bench(cx, attr_sp, item, true)
|
||||
}
|
||||
|
||||
pub fn expand_test_or_bench(
|
||||
cx: &mut ExtCtxt,
|
||||
attr_sp: Span,
|
||||
item: Annotatable,
|
||||
is_bench: bool
|
||||
) -> Vec<Annotatable> {
|
||||
// If we're not in test configuration, remove the annotated item
|
||||
if !cx.ecfg.should_test { return vec![]; }
|
||||
|
||||
let item =
|
||||
if let Annotatable::Item(i) = item { i }
|
||||
else {
|
||||
cx.parse_sess.span_diagnostic.span_fatal(item.span(),
|
||||
"#[test] attribute is only allowed on fn items").raise();
|
||||
};
|
||||
|
||||
if let ast::ItemKind::Mac(_) = item.node {
|
||||
cx.parse_sess.span_diagnostic.span_warn(item.span,
|
||||
"#[test] attribute should not be used on macros. Use #[cfg(test)] instead.");
|
||||
return vec![Annotatable::Item(item)];
|
||||
}
|
||||
|
||||
// has_*_signature will report any errors in the type so compilation
|
||||
// will fail. We shouldn't try to expand in this case because the errors
|
||||
// would be spurious.
|
||||
if (!is_bench && !has_test_signature(cx, &item)) ||
|
||||
(is_bench && !has_bench_signature(cx, &item)) {
|
||||
return vec![Annotatable::Item(item)];
|
||||
}
|
||||
|
||||
let (sp, attr_sp) = {
|
||||
let mark = Mark::fresh(Mark::root());
|
||||
mark.set_expn_info(ExpnInfo {
|
||||
call_site: DUMMY_SP,
|
||||
def_site: None,
|
||||
format: MacroAttribute(Symbol::intern("test")),
|
||||
allow_internal_unstable: true,
|
||||
allow_internal_unsafe: false,
|
||||
local_inner_macros: false,
|
||||
edition: hygiene::default_edition(),
|
||||
});
|
||||
(item.span.with_ctxt(SyntaxContext::empty().apply_mark(mark)),
|
||||
attr_sp.with_ctxt(SyntaxContext::empty().apply_mark(mark)))
|
||||
};
|
||||
|
||||
// Gensym "test" so we can extern crate without conflicting with any local names
|
||||
let test_id = cx.ident_of("test").gensym();
|
||||
|
||||
// creates test::$name
|
||||
let test_path = |name| {
|
||||
cx.path(sp, vec![test_id, cx.ident_of(name)])
|
||||
};
|
||||
|
||||
// creates test::$name
|
||||
let should_panic_path = |name| {
|
||||
cx.path(sp, vec![test_id, cx.ident_of("ShouldPanic"), cx.ident_of(name)])
|
||||
};
|
||||
|
||||
// creates $name: $expr
|
||||
let field = |name, expr| cx.field_imm(sp, cx.ident_of(name), expr);
|
||||
|
||||
let test_fn = if is_bench {
|
||||
// A simple ident for a lambda
|
||||
let b = cx.ident_of("b");
|
||||
|
||||
cx.expr_call(sp, cx.expr_path(test_path("StaticBenchFn")), vec![
|
||||
// |b| self::test::assert_test_result(
|
||||
cx.lambda1(sp,
|
||||
cx.expr_call(sp, cx.expr_path(test_path("assert_test_result")), vec![
|
||||
// super::$test_fn(b)
|
||||
cx.expr_call(sp,
|
||||
cx.expr_path(cx.path(sp, vec![item.ident])),
|
||||
vec![cx.expr_ident(sp, b)])
|
||||
]),
|
||||
b
|
||||
)
|
||||
// )
|
||||
])
|
||||
} else {
|
||||
cx.expr_call(sp, cx.expr_path(test_path("StaticTestFn")), vec![
|
||||
// || {
|
||||
cx.lambda0(sp,
|
||||
// test::assert_test_result(
|
||||
cx.expr_call(sp, cx.expr_path(test_path("assert_test_result")), vec![
|
||||
// $test_fn()
|
||||
cx.expr_call(sp, cx.expr_path(cx.path(sp, vec![item.ident])), vec![])
|
||||
// )
|
||||
])
|
||||
// }
|
||||
)
|
||||
// )
|
||||
])
|
||||
};
|
||||
|
||||
let mut test_const = cx.item(sp, item.ident.gensym(),
|
||||
// #[test_case]
|
||||
vec![cx.attribute(attr_sp, cx.meta_word(attr_sp, Symbol::intern("test_case")))],
|
||||
// const $ident: test::TestDescAndFn =
|
||||
ast::ItemKind::Const(cx.ty(sp, ast::TyKind::Path(None, test_path("TestDescAndFn"))),
|
||||
// test::TestDescAndFn {
|
||||
cx.expr_struct(sp, test_path("TestDescAndFn"), vec![
|
||||
// desc: test::TestDesc {
|
||||
field("desc", cx.expr_struct(sp, test_path("TestDesc"), vec![
|
||||
// name: "path::to::test"
|
||||
field("name", cx.expr_call(sp, cx.expr_path(test_path("StaticTestName")),
|
||||
vec![
|
||||
cx.expr_str(sp, Symbol::intern(&item_path(
|
||||
// skip the name of the root module
|
||||
&cx.current_expansion.module.mod_path[1..],
|
||||
&item.ident
|
||||
)))
|
||||
])),
|
||||
// ignore: true | false
|
||||
field("ignore", cx.expr_bool(sp, should_ignore(&item))),
|
||||
// allow_fail: true | false
|
||||
field("allow_fail", cx.expr_bool(sp, should_fail(&item))),
|
||||
// should_panic: ...
|
||||
field("should_panic", match should_panic(cx, &item) {
|
||||
// test::ShouldPanic::No
|
||||
ShouldPanic::No => cx.expr_path(should_panic_path("No")),
|
||||
// test::ShouldPanic::Yes
|
||||
ShouldPanic::Yes(None) => cx.expr_path(should_panic_path("Yes")),
|
||||
// test::ShouldPanic::YesWithMessage("...")
|
||||
ShouldPanic::Yes(Some(sym)) => cx.expr_call(sp,
|
||||
cx.expr_path(should_panic_path("YesWithMessage")),
|
||||
vec![cx.expr_str(sp, sym)]),
|
||||
}),
|
||||
// },
|
||||
])),
|
||||
// testfn: test::StaticTestFn(...) | test::StaticBenchFn(...)
|
||||
field("testfn", test_fn)
|
||||
// }
|
||||
])
|
||||
// }
|
||||
));
|
||||
test_const = test_const.map(|mut tc| { tc.vis.node = ast::VisibilityKind::Public; tc});
|
||||
|
||||
// extern crate test as test_gensym
|
||||
let test_extern = cx.item(sp,
|
||||
test_id,
|
||||
vec![],
|
||||
ast::ItemKind::ExternCrate(Some(Symbol::intern("test")))
|
||||
);
|
||||
|
||||
debug!("Synthetic test item:\n{}\n", pprust::item_to_string(&test_const));
|
||||
|
||||
vec![
|
||||
// Access to libtest under a gensymed name
|
||||
Annotatable::Item(test_extern),
|
||||
// The generated test case
|
||||
Annotatable::Item(test_const),
|
||||
// The original item
|
||||
Annotatable::Item(item)
|
||||
]
|
||||
}
|
||||
|
||||
fn item_path(mod_path: &[ast::Ident], item_ident: &ast::Ident) -> String {
|
||||
mod_path.iter().chain(iter::once(item_ident))
|
||||
.map(|x| x.to_string()).collect::<Vec<String>>().join("::")
|
||||
}
|
||||
|
||||
enum ShouldPanic {
|
||||
No,
|
||||
Yes(Option<Symbol>),
|
||||
}
|
||||
|
||||
fn should_ignore(i: &ast::Item) -> bool {
|
||||
attr::contains_name(&i.attrs, "ignore")
|
||||
}
|
||||
|
||||
fn should_fail(i: &ast::Item) -> bool {
|
||||
attr::contains_name(&i.attrs, "allow_fail")
|
||||
}
|
||||
|
||||
fn should_panic(cx: &ExtCtxt, i: &ast::Item) -> ShouldPanic {
|
||||
match attr::find_by_name(&i.attrs, "should_panic") {
|
||||
Some(attr) => {
|
||||
let ref sd = cx.parse_sess.span_diagnostic;
|
||||
if attr.is_value_str() {
|
||||
sd.struct_span_warn(
|
||||
attr.span(),
|
||||
"attribute must be of the form: \
|
||||
`#[should_panic]` or \
|
||||
`#[should_panic(expected = \"error message\")]`"
|
||||
).note("Errors in this attribute were erroneously allowed \
|
||||
and will become a hard error in a future release.")
|
||||
.emit();
|
||||
return ShouldPanic::Yes(None);
|
||||
}
|
||||
match attr.meta_item_list() {
|
||||
// Handle #[should_panic]
|
||||
None => ShouldPanic::Yes(None),
|
||||
// Handle #[should_panic(expected = "foo")]
|
||||
Some(list) => {
|
||||
let msg = list.iter()
|
||||
.find(|mi| mi.check_name("expected"))
|
||||
.and_then(|mi| mi.meta_item())
|
||||
.and_then(|mi| mi.value_str());
|
||||
if list.len() != 1 || msg.is_none() {
|
||||
sd.struct_span_warn(
|
||||
attr.span(),
|
||||
"argument must be of the form: \
|
||||
`expected = \"error message\"`"
|
||||
).note("Errors in this attribute were erroneously \
|
||||
allowed and will become a hard error in a \
|
||||
future release.").emit();
|
||||
ShouldPanic::Yes(None)
|
||||
} else {
|
||||
ShouldPanic::Yes(msg)
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
None => ShouldPanic::No,
|
||||
}
|
||||
}
|
||||
|
||||
fn has_test_signature(cx: &ExtCtxt, i: &ast::Item) -> bool {
|
||||
let has_should_panic_attr = attr::contains_name(&i.attrs, "should_panic");
|
||||
let ref sd = cx.parse_sess.span_diagnostic;
|
||||
if let ast::ItemKind::Fn(ref decl, ref header, ref generics, _) = i.node {
|
||||
if header.unsafety == ast::Unsafety::Unsafe {
|
||||
sd.span_err(
|
||||
i.span,
|
||||
"unsafe functions cannot be used for tests"
|
||||
);
|
||||
return false
|
||||
}
|
||||
if header.asyncness.is_async() {
|
||||
sd.span_err(
|
||||
i.span,
|
||||
"async functions cannot be used for tests"
|
||||
);
|
||||
return false
|
||||
}
|
||||
|
||||
|
||||
// If the termination trait is active, the compiler will check that the output
|
||||
// type implements the `Termination` trait as `libtest` enforces that.
|
||||
let has_output = match decl.output {
|
||||
ast::FunctionRetTy::Default(..) => false,
|
||||
ast::FunctionRetTy::Ty(ref t) if t.node.is_unit() => false,
|
||||
_ => true
|
||||
};
|
||||
|
||||
if !decl.inputs.is_empty() {
|
||||
sd.span_err(i.span, "functions used as tests can not have any arguments");
|
||||
return false;
|
||||
}
|
||||
|
||||
match (has_output, has_should_panic_attr) {
|
||||
(true, true) => {
|
||||
sd.span_err(i.span, "functions using `#[should_panic]` must return `()`");
|
||||
false
|
||||
},
|
||||
(true, false) => if !generics.params.is_empty() {
|
||||
sd.span_err(i.span,
|
||||
"functions used as tests must have signature fn() -> ()");
|
||||
false
|
||||
} else {
|
||||
true
|
||||
},
|
||||
(false, _) => true
|
||||
}
|
||||
} else {
|
||||
sd.span_err(i.span, "only functions may be used as tests");
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
fn has_bench_signature(cx: &ExtCtxt, i: &ast::Item) -> bool {
|
||||
let has_sig = if let ast::ItemKind::Fn(ref decl, _, _, _) = i.node {
|
||||
// NB: inadequate check, but we're running
|
||||
// well before resolve, can't get too deep.
|
||||
decl.inputs.len() == 1
|
||||
} else {
|
||||
false
|
||||
};
|
||||
|
||||
if !has_sig {
|
||||
cx.parse_sess.span_diagnostic.span_err(i.span, "functions used as benches must have \
|
||||
signature `fn(&mut Bencher) -> impl Termination`");
|
||||
}
|
||||
|
||||
has_sig
|
||||
}
|
||||
Reference in New Issue
Block a user