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::DefaultReturn(..) => true,
 301                 _ => false
 302             };
 303             if decl.inputs.is_empty()
 304                    && no_output
 305                    && !generics.is_parameterized() {
 306                 Yes
 307             } else {
 308                 No
 309             }
 310           }
 311           _ => NotEvenAFunction,
 312         }
 313     }
 314
 315     if has_test_attr {
 316         let diag = cx.span_diagnostic;
 317         match has_test_signature(i) {
 318             Yes => {},
 319             No => diag.span_err(i.span, "functions used as tests must have signature fn() -> ()"),
 320             NotEvenAFunction => diag.span_err(i.span,
 321                                               "only functions may be used as tests"),
 322         }
 323     }
 324
 325     return has_test_attr && has_test_signature(i) == Yes;
 326 }
 327
 328 fn is_bench_fn(cx: &TestCtxt, i: &ast::Item) -> bool {
 329     let has_bench_attr = attr::contains_name(&i.attrs[], "bench");
 330
 331     fn has_test_signature(i: &ast::Item) -> bool {
 332         match i.node {
 333             ast::ItemFn(ref decl, _, _, ref generics, _) => {
 334                 let input_cnt = decl.inputs.len();
 335                 let no_output = match decl.output {
 336                     ast::DefaultReturn(..) => true,
 337                     _ => false
 338                 };
 339                 let tparm_cnt = generics.ty_params.len();
 340                 // NB: inadequate check, but we're running
 341                 // well before resolve, can't get too deep.
 342                 input_cnt == 1u
 343                     && no_output && tparm_cnt == 0u
 344             }
 345           _ => false
 346         }
 347     }
 348
 349     if has_bench_attr && !has_test_signature(i) {
 350         let diag = cx.span_diagnostic;
 351         diag.span_err(i.span, "functions used as benches must have signature \
 352                       `fn(&mut Bencher) -> ()`");
 353     }
 354
 355     return has_bench_attr && has_test_signature(i);
 356 }
 357
 358 fn is_ignored(i: &ast::Item) -> bool {
 359     i.attrs.iter().any(|attr| attr.check_name("ignore"))
 360 }
 361
 362 fn should_fail(i: &ast::Item) -> ShouldFail {
 363     match i.attrs.iter().find(|attr| attr.check_name("should_fail")) {
 364         Some(attr) => {
 365             let msg = attr.meta_item_list()
 366                 .and_then(|list| list.iter().find(|mi| mi.check_name("expected")))
 367                 .and_then(|mi| mi.value_str());
 368             ShouldFail::Yes(msg)
 369         }
 370         None => ShouldFail::No,
 371     }
 372 }
 373
 374 /*
 375
 376 We're going to be building a module that looks more or less like:
 377
 378 mod __test {
 379   extern crate test (name = "test", vers = "...");
 380   fn main() {
 381     test::test_main_static(&::os::args()[], tests)
 382   }
 383
 384   static tests : &'static [test::TestDescAndFn] = &[
 385     ... the list of tests in the crate ...
 386   ];
 387 }
 388
 389 */
 390
 391 fn mk_std(cx: &TestCtxt) -> ast::ViewItem {
 392     let id_test = token::str_to_ident("test");
 393     let (vi, vis) = if cx.is_test_crate {
 394         (ast::ViewItemUse(
 395             P(nospan(ast::ViewPathSimple(id_test,
 396                                          path_node(vec!(id_test)),
 397                                          ast::DUMMY_NODE_ID)))),
 398          ast::Public)
 399     } else {
 400         (ast::ViewItemExternCrate(id_test, None, ast::DUMMY_NODE_ID),
 401          ast::Inherited)
 402     };
 403     ast::ViewItem {
 404         node: vi,
 405         attrs: Vec::new(),
 406         vis: vis,
 407         span: DUMMY_SP
 408     }
 409 }
 410
 411 fn mk_test_module(cx: &mut TestCtxt) -> (P<ast::Item>, Option<ast::ViewItem>) {
 412     // Link to test crate
 413     let view_items = vec!(mk_std(cx));
 414
 415     // A constant vector of test descriptors.
 416     let tests = mk_tests(cx);
 417
 418     // The synthesized main function which will call the console test runner
 419     // with our list of tests
 420     let mainfn = (quote_item!(&mut cx.ext_cx,
 421         pub fn main() {
 422             #![main]
 423             use std::slice::AsSlice;
 424             test::test_main_static(::std::os::args().as_slice(), TESTS);
 425         }
 426     )).unwrap();
 427
 428     let testmod = ast::Mod {
 429         inner: DUMMY_SP,
 430         view_items: view_items,
 431         items: vec!(mainfn, tests),
 432     };
 433     let item_ = ast::ItemMod(testmod);
 434
 435     let mod_ident = token::gensym_ident("__test");
 436     let allow_unstable = {
 437         let unstable = P(nospan(ast::MetaWord(InternedString::new("unstable"))));
 438         let allow = P(nospan(ast::MetaList(InternedString::new("allow"),
 439                                            vec![unstable])));
 440         attr::mk_attr_inner(attr::mk_attr_id(), allow)
 441     };
 442     let item = ast::Item {
 443         ident: mod_ident,
 444         id: ast::DUMMY_NODE_ID,
 445         node: item_,
 446         vis: ast::Public,
 447         span: DUMMY_SP,
 448         attrs: vec![allow_unstable],
 449     };
 450     let reexport = cx.reexport_test_harness_main.as_ref().map(|s| {
 451         // building `use <ident> = __test::main`
 452         let reexport_ident = token::str_to_ident(s.get());
 453
 454         let use_path =
 455             nospan(ast::ViewPathSimple(reexport_ident,
 456                                        path_node(vec![mod_ident, token::str_to_ident("main")]),
 457                                        ast::DUMMY_NODE_ID));
 458
 459         ast::ViewItem {
 460             node: ast::ViewItemUse(P(use_path)),
 461             attrs: vec![],
 462             vis: ast::Inherited,
 463             span: DUMMY_SP
 464         }
 465     });
 466
 467     debug!("Synthetic test module:\n{}\n", pprust::item_to_string(&item));
 468
 469     (P(item), reexport)
 470 }
 471
 472 fn nospan<T>(t: T) -> codemap::Spanned<T> {
 473     codemap::Spanned { node: t, span: DUMMY_SP }
 474 }
 475
 476 fn path_node(ids: Vec<ast::Ident> ) -> ast::Path {
 477     ast::Path {
 478         span: DUMMY_SP,
 479         global: false,
 480         segments: ids.into_iter().map(|identifier| ast::PathSegment {
 481             identifier: identifier,
 482             parameters: ast::PathParameters::none(),
 483         }).collect()
 484     }
 485 }
 486
 487 fn mk_tests(cx: &TestCtxt) -> P<ast::Item> {
 488     // The vector of test_descs for this crate
 489     let test_descs = mk_test_descs(cx);
 490
 491     // FIXME #15962: should be using quote_item, but that stringifies
 492     // __test_reexports, causing it to be reinterned, losing the
 493     // gensym information.
 494     let sp = DUMMY_SP;
 495     let ecx = &cx.ext_cx;
 496     let struct_type = ecx.ty_path(ecx.path(sp, vec![ecx.ident_of("self"),
 497                                                     ecx.ident_of("test"),
 498                                                     ecx.ident_of("TestDescAndFn")]));
 499     let static_lt = ecx.lifetime(sp, token::special_idents::static_lifetime.name);
 500     // &'static [self::test::TestDescAndFn]
 501     let static_type = ecx.ty_rptr(sp,
 502                                   ecx.ty(sp, ast::TyVec(struct_type)),
 503                                   Some(static_lt),
 504                                   ast::MutImmutable);
 505     // static TESTS: $static_type = &[...];
 506     ecx.item_const(sp,
 507                    ecx.ident_of("TESTS"),
 508                    static_type,
 509                    test_descs)
 510 }
 511
 512 fn is_test_crate(krate: &ast::Crate) -> bool {
 513     match attr::find_crate_name(&krate.attrs[]) {
 514         Some(ref s) if "test" == &s.get()[] => true,
 515         _ => false
 516     }
 517 }
 518
 519 fn mk_test_descs(cx: &TestCtxt) -> P<ast::Expr> {
 520     debug!("building test vector from {} tests", cx.testfns.len());
 521
 522     P(ast::Expr {
 523         id: ast::DUMMY_NODE_ID,
 524         node: ast::ExprAddrOf(ast::MutImmutable,
 525             P(ast::Expr {
 526                 id: ast::DUMMY_NODE_ID,
 527                 node: ast::ExprVec(cx.testfns.iter().map(|test| {
 528                     mk_test_desc_and_fn_rec(cx, test)
 529                 }).collect()),
 530                 span: DUMMY_SP,
 531             })),
 532         span: DUMMY_SP,
 533     })
 534 }
 535
 536 fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> P<ast::Expr> {
 537     // FIXME #15962: should be using quote_expr, but that stringifies
 538     // __test_reexports, causing it to be reinterned, losing the
 539     // gensym information.
 540
 541     let span = test.span;
 542     let path = test.path.clone();
 543     let ecx = &cx.ext_cx;
 544     let self_id = ecx.ident_of("self");
 545     let test_id = ecx.ident_of("test");
 546
 547     // creates self::test::$name
 548     let test_path = |&: name| {
 549         ecx.path(span, vec![self_id, test_id, ecx.ident_of(name)])
 550     };
 551     // creates $name: $expr
 552     let field = |&: name, expr| ecx.field_imm(span, ecx.ident_of(name), expr);
 553
 554     debug!("encoding {}", ast_util::path_name_i(&path[]));
 555
 556     // path to the #[test] function: "foo::bar::baz"
 557     let path_string = ast_util::path_name_i(&path[]);
 558     let name_expr = ecx.expr_str(span, token::intern_and_get_ident(&path_string[]));
 559
 560     // self::test::StaticTestName($name_expr)
 561     let name_expr = ecx.expr_call(span,
 562                                   ecx.expr_path(test_path("StaticTestName")),
 563                                   vec![name_expr]);
 564
 565     let ignore_expr = ecx.expr_bool(span, test.ignore);
 566     let should_fail_path = |&: name| {
 567         ecx.path(span, vec![self_id, test_id, ecx.ident_of("ShouldFail"), ecx.ident_of(name)])
 568     };
 569     let fail_expr = match test.should_fail {
 570         ShouldFail::No => ecx.expr_path(should_fail_path("No")),
 571         ShouldFail::Yes(ref msg) => {
 572             let path = should_fail_path("Yes");
 573             let arg = match *msg {
 574                 Some(ref msg) => ecx.expr_some(span, ecx.expr_str(span, msg.clone())),
 575                 None => ecx.expr_none(span),
 576             };
 577             ecx.expr_call(span, ecx.expr_path(path), vec![arg])
 578         }
 579     };
 580
 581     // self::test::TestDesc { ... }
 582     let desc_expr = ecx.expr_struct(
 583         span,
 584         test_path("TestDesc"),
 585         vec![field("name", name_expr),
 586              field("ignore", ignore_expr),
 587              field("should_fail", fail_expr)]);
 588
 589
 590     let mut visible_path = match cx.toplevel_reexport {
 591         Some(id) => vec![id],
 592         None => {
 593             let diag = cx.span_diagnostic;
 594             diag.handler.bug("expected to find top-level re-export name, but found None");
 595         }
 596     };
 597     visible_path.extend(path.into_iter());
 598
 599     let fn_expr = ecx.expr_path(ecx.path_global(span, visible_path));
 600
 601     let variant_name = if test.bench { "StaticBenchFn" } else { "StaticTestFn" };
 602     // self::test::$variant_name($fn_expr)
 603     let testfn_expr = ecx.expr_call(span, ecx.expr_path(test_path(variant_name)), vec![fn_expr]);
 604
 605     // self::test::TestDescAndFn { ... }
 606     ecx.expr_struct(span,
 607                     test_path("TestDescAndFn"),
 608                     vec![field("desc", desc_expr),
 609                          field("testfn", testfn_expr)])
 610 }