From 9d8fc50c4a989c934f9473e28022b86a07556dca Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Tue, 6 Jun 2017 12:59:04 -0700
Subject: [PATCH] rustbuild: Add `./x.py test --no-fail-fast`
This option forwards to each `cargo test` invocation, and applies the
same logic across all test steps to keep going after failures. At the
end, a brief summary line reports how many commands failed, if any.
Note that if a test program fails to even start at all, or if an
auxiliary build command related to testing fails, these are still left
to stop everything right away.
Fixes #40219.
---
src/bootstrap/check.rs | 53 ++++++++++++++++++++++++++++++++++++++-----------
src/bootstrap/flags.rs | 14 ++++++++++++-
src/bootstrap/lib.rs | 22 +++++++++++++++++++-
src/bootstrap/step.rs | 12 +++++++++--
src/build_helper/lib.rs | 38 ++++++++++++++++++++++++-----------
5 files changed, 111 insertions(+), 28 deletions(-)
diff --git a/src/bootstrap/check.rs b/src/bootstrap/check.rs
index f8f641060c44..f39a7ba61213 100644
--- a/src/bootstrap/check.rs
+++ b/src/bootstrap/check.rs
@@ -58,6 +58,29 @@ impl fmt::Display for TestKind {
}
}
+fn try_run(build: &Build, cmd: &mut Command) {
+ if build.flags.cmd.no_fail_fast() {
+ if !build.try_run(cmd) {
+ let failures = build.delayed_failures.get();
+ build.delayed_failures.set(failures + 1);
+ }
+ } else {
+ build.run(cmd);
+ }
+}
+
+#[allow(unused)]
+fn try_run_quiet(build: &Build, cmd: &mut Command) {
+ if build.flags.cmd.no_fail_fast() {
+ if !build.try_run_quiet(cmd) {
+ let failures = build.delayed_failures.get();
+ build.delayed_failures.set(failures + 1);
+ }
+ } else {
+ build.run_quiet(cmd);
+ }
+}
+
/// Runs the `linkchecker` tool as compiled in `stage` by the `host` compiler.
///
/// This tool in `src/tools` will verify the validity of all our links in the
@@ -67,8 +90,8 @@ pub fn linkcheck(build: &Build, host: &str) {
let compiler = Compiler::new(0, host);
let _time = util::timeit();
- build.run(build.tool_cmd(&compiler, "linkchecker")
- .arg(build.out.join(host).join("doc")));
+ try_run(build, build.tool_cmd(&compiler, "linkchecker")
+ .arg(build.out.join(host).join("doc")));
}
/// Runs the `cargotest` tool as compiled in `stage` by the `host` compiler.
@@ -95,9 +118,9 @@ pub fn cargotest(build: &Build, stage: u32, host: &str) {
let _time = util::timeit();
let mut cmd = Command::new(build.tool(&Compiler::new(0, host), "cargotest"));
build.prepare_tool_cmd(compiler, &mut cmd);
- build.run(cmd.env("PATH", newpath)
- .arg(&build.cargo)
- .arg(&out_dir));
+ try_run(build, cmd.env("PATH", newpath)
+ .arg(&build.cargo)
+ .arg(&out_dir));
}
/// Runs the `tidy` tool as compiled in `stage` by the `host` compiler.
@@ -113,7 +136,7 @@ pub fn tidy(build: &Build, host: &str) {
if !build.config.vendor {
cmd.arg("--no-vendor");
}
- build.run(&mut cmd);
+ try_run(build, &mut cmd);
}
fn testdir(build: &Build, host: &str) -> PathBuf {
@@ -261,7 +284,7 @@ pub fn compiletest(build: &Build,
}
let _time = util::timeit();
- build.run(&mut cmd);
+ try_run(build, &mut cmd);
}
/// Run `rustdoc --test` for all documentation in `src/doc`.
@@ -337,7 +360,7 @@ fn markdown_test(build: &Build, compiler: &Compiler, markdown: &Path) {
}
cmd.arg("--test-args").arg(test_args);
- build.run(&mut cmd);
+ try_run(build, &mut cmd);
}
/// Run all unit tests plus documentation tests for an entire crate DAG defined
@@ -388,6 +411,9 @@ pub fn krate(build: &Build,
cargo.arg("--manifest-path")
.arg(build.src.join(path).join("Cargo.toml"))
.arg("--features").arg(features);
+ if test_kind.subcommand() == "test" && build.flags.cmd.no_fail_fast() {
+ cargo.arg("--no-fail-fast");
+ }
match krate {
Some(krate) => {
@@ -452,7 +478,7 @@ pub fn krate(build: &Build,
krate_qemu(build, &compiler, target, mode);
} else {
cargo.args(&build.flags.cmd.test_args());
- build.run(&mut cargo);
+ try_run(build, &mut cargo);
}
}
@@ -521,7 +547,7 @@ fn krate_emscripten(build: &Build,
if build.config.quiet_tests {
cmd.arg("--quiet");
}
- build.run(&mut cmd);
+ try_run(build, &mut cmd);
}
}
@@ -544,7 +570,7 @@ fn krate_qemu(build: &Build,
cmd.arg("--quiet");
}
cmd.args(&build.flags.cmd.test_args());
- build.run(&mut cmd);
+ try_run(build, &mut cmd);
}
}
@@ -671,6 +697,9 @@ pub fn bootstrap(build: &Build) {
.current_dir(build.src.join("src/bootstrap"))
.env("CARGO_TARGET_DIR", build.out.join("bootstrap"))
.env("RUSTC", &build.rustc);
+ if build.flags.cmd.no_fail_fast() {
+ cmd.arg("--no-fail-fast");
+ }
cmd.arg("--").args(&build.flags.cmd.test_args());
- build.run(&mut cmd);
+ try_run(build, &mut cmd);
}
diff --git a/src/bootstrap/flags.rs b/src/bootstrap/flags.rs
index a1466d68a135..1ed759d24c54 100644
--- a/src/bootstrap/flags.rs
+++ b/src/bootstrap/flags.rs
@@ -61,6 +61,7 @@ pub enum Subcommand {
Test {
paths: Vec<PathBuf>,
test_args: Vec<String>,
+ no_fail_fast: bool,
},
Bench {
paths: Vec<PathBuf>,
@@ -137,7 +138,10 @@ To learn more about a subcommand, run `./x.py <subcommand> -h`");
// Some subcommands get extra options
match subcommand.as_str() {
- "test" => { opts.optmulti("", "test-args", "extra arguments", "ARGS"); },
+ "test" => {
+ opts.optflag("", "no-fail-fast", "Run all tests regardless of failure");
+ opts.optmulti("", "test-args", "extra arguments", "ARGS");
+ },
"bench" => { opts.optmulti("", "test-args", "extra arguments", "ARGS"); },
"dist" => { opts.optflag("", "install", "run installer as well"); },
_ => { },
@@ -260,6 +264,7 @@ Arguments:
Subcommand::Test {
paths: paths,
test_args: matches.opt_strs("test-args"),
+ no_fail_fast: matches.opt_present("no-fail-fast"),
}
}
"bench" => {
@@ -335,6 +340,13 @@ impl Subcommand {
_ => Vec::new(),
}
}
+
+ pub fn no_fail_fast(&self) -> bool {
+ match *self {
+ Subcommand::Test { no_fail_fast, .. } => no_fail_fast,
+ _ => false,
+ }
+ }
}
fn split(s: Vec<String>) -> Vec<String> {
diff --git a/src/bootstrap/lib.rs b/src/bootstrap/lib.rs
index 5e046f41673e..d2303c96d201 100644
--- a/src/bootstrap/lib.rs
+++ b/src/bootstrap/lib.rs
@@ -76,6 +76,7 @@ extern crate num_cpus;
extern crate rustc_serialize;
extern crate toml;
+use std::cell::Cell;
use std::cmp;
use std::collections::HashMap;
use std::env;
@@ -85,7 +86,7 @@ use std::io::Read;
use std::path::{Component, PathBuf, Path};
use std::process::Command;
-use build_helper::{run_silent, run_suppressed, output, mtime};
+use build_helper::{run_silent, run_suppressed, try_run_silent, try_run_suppressed, output, mtime};
use util::{exe, libdir, add_lib_path};
@@ -164,6 +165,7 @@ pub struct Build {
crates: HashMap<String, Crate>,
is_sudo: bool,
src_is_git: bool,
+ delayed_failures: Cell<usize>,
}
#[derive(Debug)]
@@ -257,6 +259,7 @@ impl Build {
lldb_python_dir: None,
is_sudo: is_sudo,
src_is_git: src_is_git,
+ delayed_failures: Cell::new(0),
}
}
@@ -847,6 +850,23 @@ impl Build {
run_suppressed(cmd)
}
+ /// Runs a command, printing out nice contextual information if it fails.
+ /// Exits if the command failed to execute at all, otherwise returns its
+ /// `status.success()`.
+ fn try_run(&self, cmd: &mut Command) -> bool {
+ self.verbose(&format!("running: {:?}", cmd));
+ try_run_silent(cmd)
+ }
+
+ /// Runs a command, printing out nice contextual information if it fails.
+ /// Exits if the command failed to execute at all, otherwise returns its
+ /// `status.success()`.
+ #[allow(unused)]
+ fn try_run_quiet(&self, cmd: &mut Command) -> bool {
+ self.verbose(&format!("running: {:?}", cmd));
+ try_run_suppressed(cmd)
+ }
+
/// Prints a message if this build is configured in verbose mode.
fn verbose(&self, msg: &str) {
if self.flags.verbose() || self.config.verbose() {
diff --git a/src/bootstrap/step.rs b/src/bootstrap/step.rs
index 17902a39df1e..f0522035127c 100644
--- a/src/bootstrap/step.rs
+++ b/src/bootstrap/step.rs
@@ -28,6 +28,7 @@
use std::collections::{BTreeMap, HashSet, HashMap};
use std::mem;
+use std::process;
use check::{self, TestKind};
use compile;
@@ -1092,8 +1093,8 @@ invalid rule dependency graph detected, was a rule added and maybe typo'd?
let (kind, paths) = match self.build.flags.cmd {
Subcommand::Build { ref paths } => (Kind::Build, &paths[..]),
Subcommand::Doc { ref paths } => (Kind::Doc, &paths[..]),
- Subcommand::Test { ref paths, test_args: _ } => (Kind::Test, &paths[..]),
- Subcommand::Bench { ref paths, test_args: _ } => (Kind::Bench, &paths[..]),
+ Subcommand::Test { ref paths, .. } => (Kind::Test, &paths[..]),
+ Subcommand::Bench { ref paths, .. } => (Kind::Bench, &paths[..]),
Subcommand::Dist { ref paths, install } => {
if install {
return vec![self.sbuild.name("install")]
@@ -1191,6 +1192,13 @@ invalid rule dependency graph detected, was a rule added and maybe typo'd?
self.build.verbose(&format!("executing step {:?}", step));
(self.rules[step.name].run)(step);
}
+
+ // Check for postponed failures from `test --no-fail-fast`.
+ let failures = self.build.delayed_failures.get();
+ if failures > 0 {
+ println!("\n{} command(s) did not execute successfully.\n", failures);
+ process::exit(1);
+ }
}
/// From the top level targets `steps` generate a topological ordering of
diff --git a/src/build_helper/lib.rs b/src/build_helper/lib.rs
index cb58a916fb79..10b0f19d6274 100644
--- a/src/build_helper/lib.rs
+++ b/src/build_helper/lib.rs
@@ -42,35 +42,49 @@ pub fn run(cmd: &mut Command) {
}
pub fn run_silent(cmd: &mut Command) {
+ if !try_run_silent(cmd) {
+ std::process::exit(1);
+ }
+}
+
+pub fn try_run_silent(cmd: &mut Command) -> bool {
let status = match cmd.status() {
Ok(status) => status,
Err(e) => fail(&format!("failed to execute command: {:?}\nerror: {}",
cmd, e)),
};
if !status.success() {
- fail(&format!("command did not execute successfully: {:?}\n\
- expected success, got: {}",
- cmd,
- status));
+ println!("\n\ncommand did not execute successfully: {:?}\n\
+ expected success, got: {}\n\n",
+ cmd,
+ status);
}
+ status.success()
}
pub fn run_suppressed(cmd: &mut Command) {
+ if !try_run_suppressed(cmd) {
+ std::process::exit(1);
+ }
+}
+
+pub fn try_run_suppressed(cmd: &mut Command) -> bool {
let output = match cmd.output() {
Ok(status) => status,
Err(e) => fail(&format!("failed to execute command: {:?}\nerror: {}",
cmd, e)),
};
if !output.status.success() {
- fail(&format!("command did not execute successfully: {:?}\n\
- expected success, got: {}\n\n\
- stdout ----\n{}\n\
- stderr ----\n{}\n",
- cmd,
- output.status,
- String::from_utf8_lossy(&output.stdout),
- String::from_utf8_lossy(&output.stderr)));
+ println!("\n\ncommand did not execute successfully: {:?}\n\
+ expected success, got: {}\n\n\
+ stdout ----\n{}\n\
+ stderr ----\n{}\n\n",
+ cmd,
+ output.status,
+ String::from_utf8_lossy(&output.stdout),
+ String::from_utf8_lossy(&output.stderr));
}
+ output.status.success()
}
pub fn gnu_target(target: &str) -> String {
--
2.13.0