| use super::*; |
| use crate::config::Config; |
| use std::thread; |
| |
| use pretty_assertions::assert_eq; |
| |
| fn configure(host: &[&str], target: &[&str]) -> Config { |
| let mut config = Config::default_opts(); |
| // don't save toolstates |
| config.save_toolstates = None; |
| config.skip_only_host_steps = false; |
| config.dry_run = true; |
| // try to avoid spurious failures in dist where we create/delete each others file |
| let dir = config |
| .out |
| .join("tmp-rustbuild-tests") |
| .join(&thread::current().name().unwrap_or("unknown").replace(":", "-")); |
| t!(fs::create_dir_all(&dir)); |
| config.out = dir; |
| config.build = INTERNER.intern_str("A"); |
| config.hosts = vec![config.build] |
| .into_iter() |
| .chain(host.iter().map(|s| INTERNER.intern_str(s))) |
| .collect::<Vec<_>>(); |
| config.targets = config |
| .hosts |
| .clone() |
| .into_iter() |
| .chain(target.iter().map(|s| INTERNER.intern_str(s))) |
| .collect::<Vec<_>>(); |
| config |
| } |
| |
| fn first<A, B>(v: Vec<(A, B)>) -> Vec<A> { |
| v.into_iter().map(|(a, _)| a).collect::<Vec<_>>() |
| } |
| |
| #[test] |
| fn dist_baseline() { |
| let build = Build::new(configure(&[], &[])); |
| let mut builder = Builder::new(&build); |
| builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Dist), &[]); |
| |
| let a = INTERNER.intern_str("A"); |
| |
| assert_eq!(first(builder.cache.all::<dist::Docs>()), &[dist::Docs { host: a },]); |
| assert_eq!(first(builder.cache.all::<dist::Mingw>()), &[dist::Mingw { host: a },]); |
| assert_eq!( |
| first(builder.cache.all::<dist::Rustc>()), |
| &[dist::Rustc { compiler: Compiler { host: a, stage: 2 } },] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<dist::Std>()), |
| &[dist::Std { compiler: Compiler { host: a, stage: 1 }, target: a },] |
| ); |
| assert_eq!(first(builder.cache.all::<dist::Src>()), &[dist::Src]); |
| // Make sure rustdoc is only built once. |
| assert_eq!( |
| first(builder.cache.all::<tool::Rustdoc>()), |
| &[tool::Rustdoc { compiler: Compiler { host: a, stage: 2 } },] |
| ); |
| } |
| |
| #[test] |
| fn dist_with_targets() { |
| let build = Build::new(configure(&[], &["B"])); |
| let mut builder = Builder::new(&build); |
| builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Dist), &[]); |
| |
| let a = INTERNER.intern_str("A"); |
| let b = INTERNER.intern_str("B"); |
| |
| assert_eq!( |
| first(builder.cache.all::<dist::Docs>()), |
| &[dist::Docs { host: a }, dist::Docs { host: b },] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<dist::Mingw>()), |
| &[dist::Mingw { host: a }, dist::Mingw { host: b },] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<dist::Rustc>()), |
| &[dist::Rustc { compiler: Compiler { host: a, stage: 2 } },] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<dist::Std>()), |
| &[ |
| dist::Std { compiler: Compiler { host: a, stage: 1 }, target: a }, |
| dist::Std { compiler: Compiler { host: a, stage: 2 }, target: b }, |
| ] |
| ); |
| assert_eq!(first(builder.cache.all::<dist::Src>()), &[dist::Src]); |
| } |
| |
| #[test] |
| fn dist_with_hosts() { |
| let build = Build::new(configure(&["B"], &[])); |
| let mut builder = Builder::new(&build); |
| builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Dist), &[]); |
| |
| let a = INTERNER.intern_str("A"); |
| let b = INTERNER.intern_str("B"); |
| |
| assert_eq!( |
| first(builder.cache.all::<dist::Docs>()), |
| &[dist::Docs { host: a }, dist::Docs { host: b },] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<dist::Mingw>()), |
| &[dist::Mingw { host: a }, dist::Mingw { host: b },] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<dist::Rustc>()), |
| &[ |
| dist::Rustc { compiler: Compiler { host: a, stage: 2 } }, |
| dist::Rustc { compiler: Compiler { host: b, stage: 2 } }, |
| ] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<dist::Std>()), |
| &[ |
| dist::Std { compiler: Compiler { host: a, stage: 1 }, target: a }, |
| dist::Std { compiler: Compiler { host: a, stage: 1 }, target: b }, |
| ] |
| ); |
| assert_eq!(first(builder.cache.all::<dist::Src>()), &[dist::Src]); |
| } |
| |
| #[test] |
| fn dist_only_cross_host() { |
| let a = INTERNER.intern_str("A"); |
| let b = INTERNER.intern_str("B"); |
| let mut build = Build::new(configure(&["B"], &[])); |
| build.config.docs = false; |
| build.config.extended = true; |
| build.hosts = vec![b]; |
| let mut builder = Builder::new(&build); |
| builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Dist), &[]); |
| |
| assert_eq!( |
| first(builder.cache.all::<dist::Rustc>()), |
| &[dist::Rustc { compiler: Compiler { host: b, stage: 2 } },] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<compile::Rustc>()), |
| &[ |
| compile::Rustc { compiler: Compiler { host: a, stage: 0 }, target: a }, |
| compile::Rustc { compiler: Compiler { host: a, stage: 1 }, target: b }, |
| ] |
| ); |
| } |
| |
| #[test] |
| fn dist_with_targets_and_hosts() { |
| let build = Build::new(configure(&["B"], &["C"])); |
| let mut builder = Builder::new(&build); |
| builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Dist), &[]); |
| |
| let a = INTERNER.intern_str("A"); |
| let b = INTERNER.intern_str("B"); |
| let c = INTERNER.intern_str("C"); |
| |
| assert_eq!( |
| first(builder.cache.all::<dist::Docs>()), |
| &[dist::Docs { host: a }, dist::Docs { host: b }, dist::Docs { host: c },] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<dist::Mingw>()), |
| &[dist::Mingw { host: a }, dist::Mingw { host: b }, dist::Mingw { host: c },] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<dist::Rustc>()), |
| &[ |
| dist::Rustc { compiler: Compiler { host: a, stage: 2 } }, |
| dist::Rustc { compiler: Compiler { host: b, stage: 2 } }, |
| ] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<dist::Std>()), |
| &[ |
| dist::Std { compiler: Compiler { host: a, stage: 1 }, target: a }, |
| dist::Std { compiler: Compiler { host: a, stage: 1 }, target: b }, |
| dist::Std { compiler: Compiler { host: a, stage: 2 }, target: c }, |
| ] |
| ); |
| assert_eq!(first(builder.cache.all::<dist::Src>()), &[dist::Src]); |
| } |
| |
| #[test] |
| fn dist_with_target_flag() { |
| let mut config = configure(&["B"], &["C"]); |
| config.skip_only_host_steps = true; // as-if --target=C was passed |
| let build = Build::new(config); |
| let mut builder = Builder::new(&build); |
| builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Dist), &[]); |
| |
| let a = INTERNER.intern_str("A"); |
| let b = INTERNER.intern_str("B"); |
| let c = INTERNER.intern_str("C"); |
| |
| assert_eq!( |
| first(builder.cache.all::<dist::Docs>()), |
| &[dist::Docs { host: a }, dist::Docs { host: b }, dist::Docs { host: c },] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<dist::Mingw>()), |
| &[dist::Mingw { host: a }, dist::Mingw { host: b }, dist::Mingw { host: c },] |
| ); |
| assert_eq!(first(builder.cache.all::<dist::Rustc>()), &[]); |
| assert_eq!( |
| first(builder.cache.all::<dist::Std>()), |
| &[ |
| dist::Std { compiler: Compiler { host: a, stage: 1 }, target: a }, |
| dist::Std { compiler: Compiler { host: a, stage: 1 }, target: b }, |
| dist::Std { compiler: Compiler { host: a, stage: 2 }, target: c }, |
| ] |
| ); |
| assert_eq!(first(builder.cache.all::<dist::Src>()), &[]); |
| } |
| |
| #[test] |
| fn dist_with_same_targets_and_hosts() { |
| let build = Build::new(configure(&["B"], &["B"])); |
| let mut builder = Builder::new(&build); |
| builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Dist), &[]); |
| |
| let a = INTERNER.intern_str("A"); |
| let b = INTERNER.intern_str("B"); |
| |
| assert_eq!( |
| first(builder.cache.all::<dist::Docs>()), |
| &[dist::Docs { host: a }, dist::Docs { host: b },] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<dist::Mingw>()), |
| &[dist::Mingw { host: a }, dist::Mingw { host: b },] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<dist::Rustc>()), |
| &[ |
| dist::Rustc { compiler: Compiler { host: a, stage: 2 } }, |
| dist::Rustc { compiler: Compiler { host: b, stage: 2 } }, |
| ] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<dist::Std>()), |
| &[ |
| dist::Std { compiler: Compiler { host: a, stage: 1 }, target: a }, |
| dist::Std { compiler: Compiler { host: a, stage: 1 }, target: b }, |
| ] |
| ); |
| assert_eq!(first(builder.cache.all::<dist::Src>()), &[dist::Src]); |
| assert_eq!( |
| first(builder.cache.all::<compile::Std>()), |
| &[ |
| compile::Std { compiler: Compiler { host: a, stage: 0 }, target: a }, |
| compile::Std { compiler: Compiler { host: a, stage: 1 }, target: a }, |
| compile::Std { compiler: Compiler { host: a, stage: 2 }, target: a }, |
| compile::Std { compiler: Compiler { host: a, stage: 1 }, target: b }, |
| compile::Std { compiler: Compiler { host: a, stage: 2 }, target: b }, |
| ] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<compile::Assemble>()), |
| &[ |
| compile::Assemble { target_compiler: Compiler { host: a, stage: 0 } }, |
| compile::Assemble { target_compiler: Compiler { host: a, stage: 1 } }, |
| compile::Assemble { target_compiler: Compiler { host: a, stage: 2 } }, |
| compile::Assemble { target_compiler: Compiler { host: b, stage: 2 } }, |
| ] |
| ); |
| } |
| |
| #[test] |
| fn build_default() { |
| let build = Build::new(configure(&["B"], &["C"])); |
| let mut builder = Builder::new(&build); |
| builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Build), &[]); |
| |
| let a = INTERNER.intern_str("A"); |
| let b = INTERNER.intern_str("B"); |
| let c = INTERNER.intern_str("C"); |
| |
| assert_eq!( |
| first(builder.cache.all::<compile::Std>()), |
| &[ |
| compile::Std { compiler: Compiler { host: a, stage: 0 }, target: a }, |
| compile::Std { compiler: Compiler { host: a, stage: 1 }, target: a }, |
| compile::Std { compiler: Compiler { host: a, stage: 2 }, target: a }, |
| compile::Std { compiler: Compiler { host: b, stage: 2 }, target: a }, |
| compile::Std { compiler: Compiler { host: a, stage: 1 }, target: b }, |
| compile::Std { compiler: Compiler { host: a, stage: 2 }, target: b }, |
| compile::Std { compiler: Compiler { host: b, stage: 2 }, target: b }, |
| compile::Std { compiler: Compiler { host: a, stage: 2 }, target: c }, |
| compile::Std { compiler: Compiler { host: b, stage: 2 }, target: c }, |
| ] |
| ); |
| assert!(!builder.cache.all::<compile::Assemble>().is_empty()); |
| assert_eq!( |
| first(builder.cache.all::<compile::Rustc>()), |
| &[ |
| compile::Rustc { compiler: Compiler { host: a, stage: 0 }, target: a }, |
| compile::Rustc { compiler: Compiler { host: a, stage: 1 }, target: a }, |
| compile::Rustc { compiler: Compiler { host: a, stage: 2 }, target: a }, |
| compile::Rustc { compiler: Compiler { host: b, stage: 2 }, target: a }, |
| compile::Rustc { compiler: Compiler { host: a, stage: 1 }, target: b }, |
| compile::Rustc { compiler: Compiler { host: a, stage: 2 }, target: b }, |
| compile::Rustc { compiler: Compiler { host: b, stage: 2 }, target: b }, |
| ] |
| ); |
| } |
| |
| #[test] |
| fn build_with_target_flag() { |
| let mut config = configure(&["B"], &["C"]); |
| config.skip_only_host_steps = true; |
| let build = Build::new(config); |
| let mut builder = Builder::new(&build); |
| builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Build), &[]); |
| |
| let a = INTERNER.intern_str("A"); |
| let b = INTERNER.intern_str("B"); |
| let c = INTERNER.intern_str("C"); |
| |
| assert_eq!( |
| first(builder.cache.all::<compile::Std>()), |
| &[ |
| compile::Std { compiler: Compiler { host: a, stage: 0 }, target: a }, |
| compile::Std { compiler: Compiler { host: a, stage: 1 }, target: a }, |
| compile::Std { compiler: Compiler { host: a, stage: 2 }, target: a }, |
| compile::Std { compiler: Compiler { host: b, stage: 2 }, target: a }, |
| compile::Std { compiler: Compiler { host: a, stage: 1 }, target: b }, |
| compile::Std { compiler: Compiler { host: a, stage: 2 }, target: b }, |
| compile::Std { compiler: Compiler { host: b, stage: 2 }, target: b }, |
| compile::Std { compiler: Compiler { host: a, stage: 2 }, target: c }, |
| compile::Std { compiler: Compiler { host: b, stage: 2 }, target: c }, |
| ] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<compile::Assemble>()), |
| &[ |
| compile::Assemble { target_compiler: Compiler { host: a, stage: 0 } }, |
| compile::Assemble { target_compiler: Compiler { host: a, stage: 1 } }, |
| compile::Assemble { target_compiler: Compiler { host: a, stage: 2 } }, |
| compile::Assemble { target_compiler: Compiler { host: b, stage: 2 } }, |
| ] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<compile::Rustc>()), |
| &[ |
| compile::Rustc { compiler: Compiler { host: a, stage: 0 }, target: a }, |
| compile::Rustc { compiler: Compiler { host: a, stage: 1 }, target: a }, |
| compile::Rustc { compiler: Compiler { host: a, stage: 1 }, target: b }, |
| ] |
| ); |
| } |
| |
| #[test] |
| fn test_with_no_doc_stage0() { |
| let mut config = configure(&[], &[]); |
| config.stage = Some(0); |
| config.cmd = Subcommand::Test { |
| paths: vec!["src/libstd".into()], |
| test_args: vec![], |
| rustc_args: vec![], |
| fail_fast: true, |
| doc_tests: DocTests::No, |
| bless: false, |
| compare_mode: None, |
| rustfix_coverage: false, |
| pass: None, |
| }; |
| |
| let build = Build::new(config); |
| let mut builder = Builder::new(&build); |
| |
| let host = INTERNER.intern_str("A"); |
| |
| builder |
| .run_step_descriptions(&[StepDescription::from::<test::Crate>()], &["src/libstd".into()]); |
| |
| // Ensure we don't build any compiler artifacts. |
| assert!(!builder.cache.contains::<compile::Rustc>()); |
| assert_eq!( |
| first(builder.cache.all::<test::Crate>()), |
| &[test::Crate { |
| compiler: Compiler { host, stage: 0 }, |
| target: host, |
| mode: Mode::Std, |
| test_kind: test::TestKind::Test, |
| krate: INTERNER.intern_str("std"), |
| },] |
| ); |
| } |
| |
| #[test] |
| fn test_exclude() { |
| let mut config = configure(&[], &[]); |
| config.exclude = vec!["src/tools/tidy".into()]; |
| config.cmd = Subcommand::Test { |
| paths: Vec::new(), |
| test_args: Vec::new(), |
| rustc_args: Vec::new(), |
| fail_fast: true, |
| doc_tests: DocTests::No, |
| bless: false, |
| compare_mode: None, |
| rustfix_coverage: false, |
| pass: None, |
| }; |
| |
| let build = Build::new(config); |
| let builder = Builder::new(&build); |
| builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Test), &[]); |
| |
| // Ensure we have really excluded tidy |
| assert!(!builder.cache.contains::<test::Tidy>()); |
| |
| // Ensure other tests are not affected. |
| assert!(builder.cache.contains::<test::RustdocUi>()); |
| } |
| |
| #[test] |
| fn doc_default() { |
| let mut config = configure(&[], &[]); |
| config.compiler_docs = true; |
| config.cmd = Subcommand::Doc { paths: Vec::new(), open: false }; |
| let build = Build::new(config); |
| let mut builder = Builder::new(&build); |
| builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Doc), &[]); |
| let a = INTERNER.intern_str("A"); |
| |
| // error_index_generator uses stage 1 to share rustdoc artifacts with the |
| // rustdoc tool. |
| assert_eq!( |
| first(builder.cache.all::<doc::ErrorIndex>()), |
| &[doc::ErrorIndex { compiler: Compiler { host: a, stage: 1 }, target: a },] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<tool::ErrorIndex>()), |
| &[tool::ErrorIndex { compiler: Compiler { host: a, stage: 1 } }] |
| ); |
| // This is actually stage 1, but Rustdoc::run swaps out the compiler with |
| // stage minus 1 if --stage is not 0. Very confusing! |
| assert_eq!( |
| first(builder.cache.all::<tool::Rustdoc>()), |
| &[tool::Rustdoc { compiler: Compiler { host: a, stage: 2 } },] |
| ); |
| } |
| |
| #[test] |
| fn test_docs() { |
| // Behavior of `x.py test` doing various documentation tests. |
| let mut config = configure(&[], &[]); |
| config.cmd = Subcommand::Test { |
| paths: vec![], |
| test_args: vec![], |
| rustc_args: vec![], |
| fail_fast: true, |
| doc_tests: DocTests::Yes, |
| bless: false, |
| compare_mode: None, |
| rustfix_coverage: false, |
| pass: None, |
| }; |
| let build = Build::new(config); |
| let mut builder = Builder::new(&build); |
| builder.run_step_descriptions(&Builder::get_step_descriptions(Kind::Test), &[]); |
| let a = INTERNER.intern_str("A"); |
| |
| // error_index_generator uses stage 1 to share rustdoc artifacts with the |
| // rustdoc tool. |
| assert_eq!( |
| first(builder.cache.all::<doc::ErrorIndex>()), |
| &[doc::ErrorIndex { compiler: Compiler { host: a, stage: 1 }, target: a },] |
| ); |
| assert_eq!( |
| first(builder.cache.all::<tool::ErrorIndex>()), |
| &[tool::ErrorIndex { compiler: Compiler { host: a, stage: 1 } }] |
| ); |
| // Unfortunately rustdoc is built twice. Once from stage1 for compiletest |
| // (and other things), and once from stage0 for std crates. Ideally it |
| // would only be built once. If someone wants to fix this, it might be |
| // worth investigating if it would be possible to test std from stage1. |
| // Note that the stages here are +1 than what they actually are because |
| // Rustdoc::run swaps out the compiler with stage minus 1 if --stage is |
| // not 0. |
| assert_eq!( |
| first(builder.cache.all::<tool::Rustdoc>()), |
| &[ |
| tool::Rustdoc { compiler: Compiler { host: a, stage: 1 } }, |
| tool::Rustdoc { compiler: Compiler { host: a, stage: 2 } }, |
| ] |
| ); |
| } |
