src/libsyntax/test.rs

   1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 // Code that generates a test runner to run all the tests in a crate
  12
  13 #![allow(dead_code)]
  14 #![allow(unused_imports)]
  15 use self::HasTestSignature::*;
  16
  17 use std::slice;
  18 use std::mem;
  19 use std::vec;
  20 use ast_util::*;
  21 use attr::AttrMetaMethods;
  22 use attr;
  23 use codemap::{DUMMY_SP, Span, ExpnInfo, NameAndSpan, MacroAttribute};
  24 use codemap;
  25 use diagnostic;
  26 use config;
  27 use ext::base::ExtCtxt;
  28 use ext::build::AstBuilder;
  29 use ext::expand::ExpansionConfig;
  30 use fold::{Folder, MoveMap};
  31 use fold;
  32 use owned_slice::OwnedSlice;
  33 use parse::token::InternedString;
  34 use parse::{token, ParseSess};
  35 use print::pprust;
  36 use {ast, ast_util};
  37 use ptr::P;
  38 use util::small_vector::SmallVector;
  39
  40 enum ShouldFail {
  41     No,
  42     Yes(Option<InternedString>),
  43 }
  44
  45 struct Test {
  46     span: Span,
  47     path: Vec<ast::Ident> ,
  48     bench: bool,
  49     ignore: bool,
  50     should_fail: ShouldFail
  51 }
  52
  53 struct TestCtxt<'a> {
  54     sess: &'a ParseSess,
  55     span_diagnostic: &'a diagnostic::SpanHandler,
  56     path: Vec<ast::Ident>,
  57     ext_cx: ExtCtxt<'a>,
  58     testfns: Vec<Test>,
  59     reexport_test_harness_main: Option<InternedString>,
  60     is_test_crate: bool,
  61     config: ast::CrateConfig,
  62
  63     // top-level re-export submodule, filled out after folding is finished
  64     toplevel_reexport: Option<ast::Ident>,
  65 }
  66
  67 // Traverse the crate, collecting all the test functions, eliding any
  68 // existing main functions, and synthesizing a main test harness
  69 pub fn modify_for_testing(sess: &ParseSess,
  70                           cfg: &ast::CrateConfig,
  71                           krate: ast::Crate,
  72                           span_diagnostic: &diagnostic::SpanHandler) -> ast::Crate {
  73     // We generate the test harness when building in the 'test'
  74     // configuration, either with the '--test' or '--cfg test'
  75     // command line options.
  76     let should_test = attr::contains_name(&krate.config[], "test");
  77
  78     // Check for #[reexport_test_harness_main = "some_name"] which
  79     // creates a `use some_name = __test::main;`. This needs to be
  80     // unconditional, so that the attribute is still marked as used in
  81     // non-test builds.
  82     let reexport_test_harness_main =
  83         attr::first_attr_value_str_by_name(&krate.attrs[],
  84                                            "reexport_test_harness_main");
  85
  86     if should_test {
  87         generate_test_harness(sess, reexport_test_harness_main, krate, cfg, span_diagnostic)
  88     } else {
  89         strip_test_functions(krate)
  90     }
  91 }
  92
  93 struct TestHarnessGenerator<'a> {
  94     cx: TestCtxt<'a>,
  95     tests: Vec<ast::Ident>,
  96
  97     // submodule name, gensym'd identifier for re-exports
  98     tested_submods: Vec<(ast::Ident, ast::Ident)>,
  99 }
 100
 101 impl<'a> fold::Folder for TestHarnessGenerator<'a> {
 102     fn fold_crate(&mut self, c: ast::Crate) -> ast::Crate {
 103         let mut folded = fold::noop_fold_crate(c, self);
 104
 105         // Add a special __test module to the crate that will contain code
 106         // generated for the test harness
 107         let (mod_, reexport) = mk_test_module(&mut self.cx);
 108         folded.module.items.push(mod_);
 109         match reexport {
 110             Some(re) => folded.module.view_items.push(re),
 111             None => {}
 112         }
 113         folded
 114     }
 115
 116     fn fold_item(&mut self, i: P<ast::Item>) -> SmallVector<P<ast::Item>> {
 117         let ident = i.ident;
 118         if ident.name != token::special_idents::invalid.name {
 119             self.cx.path.push(ident);
 120         }
 121         debug!("current path: {}",
 122                ast_util::path_name_i(&self.cx.path[]));
 123
 124         if is_test_fn(&self.cx, &*i) || is_bench_fn(&self.cx, &*i) {
 125             match i.node {
 126                 ast::ItemFn(_, ast::Unsafety::Unsafe, _, _, _) => {
 127                     let diag = self.cx.span_diagnostic;
 128                     diag.span_fatal(i.span,
 129                                     "unsafe functions cannot be used for \
 130                                      tests");
 131                 }
 132                 _ => {
 133                     debug!("this is a test function");
 134                     let test = Test {
 135                         span: i.span,
 136                         path: self.cx.path.clone(),
 137                         bench: is_bench_fn(&self.cx, &*i),
 138                         ignore: is_ignored(&*i),
 139                         should_fail: should_fail(&*i)
 140                     };
 141                     self.cx.testfns.push(test);
 142                     self.tests.push(i.ident);
 143                     // debug!("have {} test/bench functions",
 144                     //        cx.testfns.len());
 145                 }
 146             }
 147         }
 148
 149         // We don't want to recurse into anything other than mods, since
 150         // mods or tests inside of functions will break things
 151         let res = match i.node {
 152             ast::ItemMod(..) => fold::noop_fold_item(i, self),
 153             _ => SmallVector::one(i),
 154         };
 155         if ident.name != token::special_idents::invalid.name {
 156             self.cx.path.pop();
 157         }
 158         res
 159     }
 160
 161     fn fold_mod(&mut self, m: ast::Mod) -> ast::Mod {
 162         let tests = mem::replace(&mut self.tests, Vec::new());
 163         let tested_submods = mem::replace(&mut self.tested_submods, Vec::new());
 164         let mut mod_folded = fold::noop_fold_mod(m, self);
 165         let tests = mem::replace(&mut self.tests, tests);
 166         let tested_submods = mem::replace(&mut self.tested_submods, tested_submods);
 167
 168         // Remove any #[main] from the AST so it doesn't clash with
 169         // the one we're going to add. Only if compiling an executable.
 170
 171         mod_folded.items = mem::replace(&mut mod_folded.items, vec![]).move_map(|item| {
 172             item.map(|ast::Item {id, ident, attrs, node, vis, span}| {
 173                 ast::Item {
 174                     id: id,
 175                     ident: ident,
 176                     attrs: attrs.into_iter().filter_map(|attr| {
 177                         if !attr.check_name("main") {
 178                             Some(attr)
 179                         } else {
 180                             None
 181                         }
 182                     }).collect(),
 183                     node: node,
 184                     vis: vis,
 185                     span: span
 186                 }
 187             })
 188         });
 189
 190         if !tests.is_empty() || !tested_submods.is_empty() {
 191             let (it, sym) = mk_reexport_mod(&mut self.cx, tests, tested_submods);
 192             mod_folded.items.push(it);
 193
 194             if !self.cx.path.is_empty() {
 195                 self.tested_submods.push((self.cx.path[self.cx.path.len()-1], sym));
 196             } else {
 197                 debug!("pushing nothing, sym: {:?}", sym);
 198                 self.cx.toplevel_reexport = Some(sym);
 199             }
 200         }
 201
 202         mod_folded
 203     }
 204 }
 205
 206 fn mk_reexport_mod(cx: &mut TestCtxt, tests: Vec<ast::Ident>,
 207                    tested_submods: Vec<(ast::Ident, ast::Ident)>) -> (P<ast::Item>, ast::Ident) {
 208     let mut view_items = Vec::new();
 209     let super_ = token::str_to_ident("super");
 210
 211     view_items.extend(tests.into_iter().map(|r| {
 212         cx.ext_cx.view_use_simple(DUMMY_SP, ast::Public,
 213                                   cx.ext_cx.path(DUMMY_SP, vec![super_, r]))
 214     }));
 215     view_items.extend(tested_submods.into_iter().map(|(r, sym)| {
 216         let path = cx.ext_cx.path(DUMMY_SP, vec![super_, r, sym]);
 217         cx.ext_cx.view_use_simple_(DUMMY_SP, ast::Public, r, path)
 218     }));
 219
 220     let reexport_mod = ast::Mod {
 221         inner: DUMMY_SP,
 222         view_items: view_items,
 223         items: Vec::new(),
 224     };
 225
 226     let sym = token::gensym_ident("__test_reexports");
 227     let it = P(ast::Item {
 228         ident: sym.clone(),
 229         attrs: Vec::new(),
 230         id: ast::DUMMY_NODE_ID,
 231         node: ast::ItemMod(reexport_mod),
 232         vis: ast::Public,
 233         span: DUMMY_SP,
 234     });
 235
 236     (it, sym)
 237 }
 238
 239 fn generate_test_harness(sess: &ParseSess,
 240                          reexport_test_harness_main: Option<InternedString>,
 241                          krate: ast::Crate,
 242                          cfg: &ast::CrateConfig,
 243                          sd: &diagnostic::SpanHandler) -> ast::Crate {
 244     let mut cx: TestCtxt = TestCtxt {
 245         sess: sess,
 246         span_diagnostic: sd,
 247         ext_cx: ExtCtxt::new(sess, cfg.clone(),
 248                              ExpansionConfig::default("test".to_string())),
 249         path: Vec::new(),
 250         testfns: Vec::new(),
 251         reexport_test_harness_main: reexport_test_harness_main,
 252         is_test_crate: is_test_crate(&krate),
 253         config: krate.config.clone(),
 254         toplevel_reexport: None,
 255     };
 256
 257     cx.ext_cx.bt_push(ExpnInfo {
 258         call_site: DUMMY_SP,
 259         callee: NameAndSpan {
 260             name: "test".to_string(),
 261             format: MacroAttribute,
 262             span: None
 263         }
 264     });
 265
 266     let mut fold = TestHarnessGenerator {
 267         cx: cx,
 268         tests: Vec::new(),
 269         tested_submods: Vec::new(),
 270     };
 271     let res = fold.fold_crate(krate);
 272     fold.cx.ext_cx.bt_pop();
 273     return res;
 274 }
 275
 276 fn strip_test_functions(krate: ast::Crate) -> ast::Crate {
 277     // When not compiling with --test we should not compile the
 278     // #[test] functions
 279     config::strip_items(krate, |attrs| {
 280         !attr::contains_name(&attrs[], "test") &&
 281         !attr::contains_name(&attrs[], "bench")
 282     })
 283 }
 284
 285 #[derive(PartialEq)]
 286 enum HasTestSignature {
 287     Yes,
 288     No,
 289     NotEvenAFunction,
 290 }
 291
 292
 293 fn is_test_fn(cx: &TestCtxt, i: &ast::Item) -> bool {
 294     let has_test_attr = attr::contains_name(&i.attrs[], "test");
 295
 296     fn has_test_signature(i: &ast::Item) -> HasTestSignature {
 297         match &i.node {
 298           &ast::ItemFn(ref decl, _, _, ref generics, _) => {
 299             let no_output = match decl.output {
 300                 ast::Return(ref ret_ty) => match ret_ty.node {
 301                     ast::TyTup(ref tys) if tys.is_empty() => true,
 302                     _ => false,
 303                 },
 304                 ast::NoReturn(_) => false
 305             };
 306             if decl.inputs.is_empty()
 307                    && no_output
 308                    && !generics.is_parameterized() {
 309                 Yes
 310             } else {
 311                 No
 312             }
 313           }
 314           _ => NotEvenAFunction,
 315         }
 316     }
 317
 318     if has_test_attr {
 319         let diag = cx.span_diagnostic;
 320         match has_test_signature(i) {
 321             Yes => {},
 322             No => diag.span_err(i.span, "functions used as tests must have signature fn() -> ()"),
 323             NotEvenAFunction => diag.span_err(i.span,
 324                                               "only functions may be used as tests"),
 325         }
 326     }
 327
 328     return has_test_attr && has_test_signature(i) == Yes;
 329 }
 330
 331 fn is_bench_fn(cx: &TestCtxt, i: &ast::Item) -> bool {
 332     let has_bench_attr = attr::contains_name(&i.attrs[], "bench");
 333
 334     fn has_test_signature(i: &ast::Item) -> bool {
 335         match i.node {
 336             ast::ItemFn(ref decl, _, _, ref generics, _) => {
 337                 let input_cnt = decl.inputs.len();
 338                 let no_output = match decl.output {
 339                     ast::Return(ref ret_ty) => match ret_ty.node {
 340                         ast::TyTup(ref tys) if tys.is_empty() => true,
 341                         _ => false,
 342                     },
 343                     ast::NoReturn(_) => false
 344                 };
 345                 let tparm_cnt = generics.ty_params.len();
 346                 // NB: inadequate check, but we're running
 347                 // well before resolve, can't get too deep.
 348                 input_cnt == 1u
 349                     && no_output && tparm_cnt == 0u
 350             }
 351           _ => false
 352         }
 353     }
 354
 355     if has_bench_attr && !has_test_signature(i) {
 356         let diag = cx.span_diagnostic;
 357         diag.span_err(i.span, "functions used as benches must have signature \
 358                       `fn(&mut Bencher) -> ()`");
 359     }
 360
 361     return has_bench_attr && has_test_signature(i);
 362 }
 363
 364 fn is_ignored(i: &ast::Item) -> bool {
 365     i.attrs.iter().any(|attr| attr.check_name("ignore"))
 366 }
 367
 368 fn should_fail(i: &ast::Item) -> ShouldFail {
 369     match i.attrs.iter().find(|attr| attr.check_name("should_fail")) {
 370         Some(attr) => {
 371             let msg = attr.meta_item_list()
 372                 .and_then(|list| list.iter().find(|mi| mi.check_name("expected")))
 373                 .and_then(|mi| mi.value_str());
 374             ShouldFail::Yes(msg)
 375         }
 376         None => ShouldFail::No,
 377     }
 378 }
 379
 380 /*
 381
 382 We're going to be building a module that looks more or less like:
 383
 384 mod __test {
 385   extern crate test (name = "test", vers = "...");
 386   fn main() {
 387     test::test_main_static(&::os::args()[], tests)
 388   }
 389
 390   static tests : &'static [test::TestDescAndFn] = &[
 391     ... the list of tests in the crate ...
 392   ];
 393 }
 394
 395 */
 396
 397 fn mk_std(cx: &TestCtxt) -> ast::ViewItem {
 398     let id_test = token::str_to_ident("test");
 399     let (vi, vis) = if cx.is_test_crate {
 400         (ast::ViewItemUse(
 401             P(nospan(ast::ViewPathSimple(id_test,
 402                                          path_node(vec!(id_test)),
 403                                          ast::DUMMY_NODE_ID)))),
 404          ast::Public)
 405     } else {
 406         (ast::ViewItemExternCrate(id_test, None, ast::DUMMY_NODE_ID),
 407          ast::Inherited)
 408     };
 409     ast::ViewItem {
 410         node: vi,
 411         attrs: Vec::new(),
 412         vis: vis,
 413         span: DUMMY_SP
 414     }
 415 }
 416
 417 fn mk_test_module(cx: &mut TestCtxt) -> (P<ast::Item>, Option<ast::ViewItem>) {
 418     // Link to test crate
 419     let view_items = vec!(mk_std(cx));
 420
 421     // A constant vector of test descriptors.
 422     let tests = mk_tests(cx);
 423
 424     // The synthesized main function which will call the console test runner
 425     // with our list of tests
 426     let mainfn = (quote_item!(&mut cx.ext_cx,
 427         pub fn main() {
 428             #![main]
 429             use std::slice::AsSlice;
 430             test::test_main_static(::std::os::args().as_slice(), TESTS);
 431         }
 432     )).unwrap();
 433
 434     let testmod = ast::Mod {
 435         inner: DUMMY_SP,
 436         view_items: view_items,
 437         items: vec!(mainfn, tests),
 438     };
 439     let item_ = ast::ItemMod(testmod);
 440
 441     let mod_ident = token::gensym_ident("__test");
 442     let allow_unstable = {
 443         let unstable = P(nospan(ast::MetaWord(InternedString::new("unstable"))));
 444         let allow = P(nospan(ast::MetaList(InternedString::new("allow"),
 445                                            vec![unstable])));
 446         attr::mk_attr_inner(attr::mk_attr_id(), allow)
 447     };
 448     let item = ast::Item {
 449         ident: mod_ident,
 450         id: ast::DUMMY_NODE_ID,
 451         node: item_,
 452         vis: ast::Public,
 453         span: DUMMY_SP,
 454         attrs: vec![allow_unstable],
 455     };
 456     let reexport = cx.reexport_test_harness_main.as_ref().map(|s| {
 457         // building `use <ident> = __test::main`
 458         let reexport_ident = token::str_to_ident(s.get());
 459
 460         let use_path =
 461             nospan(ast::ViewPathSimple(reexport_ident,
 462                                        path_node(vec![mod_ident, token::str_to_ident("main")]),
 463                                        ast::DUMMY_NODE_ID));
 464
 465         ast::ViewItem {
 466             node: ast::ViewItemUse(P(use_path)),
 467             attrs: vec![],
 468             vis: ast::Inherited,
 469             span: DUMMY_SP
 470         }
 471     });
 472
 473     debug!("Synthetic test module:\n{}\n", pprust::item_to_string(&item));
 474
 475     (P(item), reexport)
 476 }
 477
 478 fn nospan<T>(t: T) -> codemap::Spanned<T> {
 479     codemap::Spanned { node: t, span: DUMMY_SP }
 480 }
 481
 482 fn path_node(ids: Vec<ast::Ident> ) -> ast::Path {
 483     ast::Path {
 484         span: DUMMY_SP,
 485         global: false,
 486         segments: ids.into_iter().map(|identifier| ast::PathSegment {
 487             identifier: identifier,
 488             parameters: ast::PathParameters::none(),
 489         }).collect()
 490     }
 491 }
 492
 493 fn mk_tests(cx: &TestCtxt) -> P<ast::Item> {
 494     // The vector of test_descs for this crate
 495     let test_descs = mk_test_descs(cx);
 496
 497     // FIXME #15962: should be using quote_item, but that stringifies
 498     // __test_reexports, causing it to be reinterned, losing the
 499     // gensym information.
 500     let sp = DUMMY_SP;
 501     let ecx = &cx.ext_cx;
 502     let struct_type = ecx.ty_path(ecx.path(sp, vec![ecx.ident_of("self"),
 503                                                     ecx.ident_of("test"),
 504                                                     ecx.ident_of("TestDescAndFn")]));
 505     let static_lt = ecx.lifetime(sp, token::special_idents::static_lifetime.name);
 506     // &'static [self::test::TestDescAndFn]
 507     let static_type = ecx.ty_rptr(sp,
 508                                   ecx.ty(sp, ast::TyVec(struct_type)),
 509                                   Some(static_lt),
 510                                   ast::MutImmutable);
 511     // static TESTS: $static_type = &[...];
 512     ecx.item_const(sp,
 513                    ecx.ident_of("TESTS"),
 514                    static_type,
 515                    test_descs)
 516 }
 517
 518 fn is_test_crate(krate: &ast::Crate) -> bool {
 519     match attr::find_crate_name(&krate.attrs[]) {
 520         Some(ref s) if "test" == &s.get()[] => true,
 521         _ => false
 522     }
 523 }
 524
 525 fn mk_test_descs(cx: &TestCtxt) -> P<ast::Expr> {
 526     debug!("building test vector from {} tests", cx.testfns.len());
 527
 528     P(ast::Expr {
 529         id: ast::DUMMY_NODE_ID,
 530         node: ast::ExprAddrOf(ast::MutImmutable,
 531             P(ast::Expr {
 532                 id: ast::DUMMY_NODE_ID,
 533                 node: ast::ExprVec(cx.testfns.iter().map(|test| {
 534                     mk_test_desc_and_fn_rec(cx, test)
 535                 }).collect()),
 536                 span: DUMMY_SP,
 537             })),
 538         span: DUMMY_SP,
 539     })
 540 }
 541
 542 fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> P<ast::Expr> {
 543     // FIXME #15962: should be using quote_expr, but that stringifies
 544     // __test_reexports, causing it to be reinterned, losing the
 545     // gensym information.
 546
 547     let span = test.span;
 548     let path = test.path.clone();
 549     let ecx = &cx.ext_cx;
 550     let self_id = ecx.ident_of("self");
 551     let test_id = ecx.ident_of("test");
 552
 553     // creates self::test::$name
 554     let test_path = |&: name| {
 555         ecx.path(span, vec![self_id, test_id, ecx.ident_of(name)])
 556     };
 557     // creates $name: $expr
 558     let field = |&: name, expr| ecx.field_imm(span, ecx.ident_of(name), expr);
 559
 560     debug!("encoding {}", ast_util::path_name_i(&path[]));
 561
 562     // path to the #[test] function: "foo::bar::baz"
 563     let path_string = ast_util::path_name_i(&path[]);
 564     let name_expr = ecx.expr_str(span, token::intern_and_get_ident(&path_string[]));
 565
 566     // self::test::StaticTestName($name_expr)
 567     let name_expr = ecx.expr_call(span,
 568                                   ecx.expr_path(test_path("StaticTestName")),
 569                                   vec![name_expr]);
 570
 571     let ignore_expr = ecx.expr_bool(span, test.ignore);
 572     let should_fail_path = |&: name| {
 573         ecx.path(span, vec![self_id, test_id, ecx.ident_of("ShouldFail"), ecx.ident_of(name)])
 574     };
 575     let fail_expr = match test.should_fail {
 576         ShouldFail::No => ecx.expr_path(should_fail_path("No")),
 577         ShouldFail::Yes(ref msg) => {
 578             let path = should_fail_path("Yes");
 579             let arg = match *msg {
 580                 Some(ref msg) => ecx.expr_some(span, ecx.expr_str(span, msg.clone())),
 581                 None => ecx.expr_none(span),
 582             };
 583             ecx.expr_call(span, ecx.expr_path(path), vec![arg])
 584         }
 585     };
 586
 587     // self::test::TestDesc { ... }
 588     let desc_expr = ecx.expr_struct(
 589         span,
 590         test_path("TestDesc"),
 591         vec![field("name", name_expr),
 592              field("ignore", ignore_expr),
 593              field("should_fail", fail_expr)]);
 594
 595
 596     let mut visible_path = match cx.toplevel_reexport {
 597         Some(id) => vec![id],
 598         None => {
 599             let diag = cx.span_diagnostic;
 600             diag.handler.bug("expected to find top-level re-export name, but found None");
 601         }
 602     };
 603     visible_path.extend(path.into_iter());
 604
 605     let fn_expr = ecx.expr_path(ecx.path_global(span, visible_path));
 606
 607     let variant_name = if test.bench { "StaticBenchFn" } else { "StaticTestFn" };
 608     // self::test::$variant_name($fn_expr)
 609     let testfn_expr = ecx.expr_call(span, ecx.expr_path(test_path(variant_name)), vec![fn_expr]);
 610
 611     // self::test::TestDescAndFn { ... }
 612     ecx.expr_struct(span,
 613                     test_path("TestDescAndFn"),
 614                     vec![field("desc", desc_expr),
 615                          field("testfn", testfn_expr)])
 616 }