1 files changed, 154 insertions, 3 deletions

diff --git a/xtask/src/run.rs b/xtask/src/run.rs
index 32fafc84..49437d7c 100644
--- a/xtask/src/run.rs
+++ b/xtask/src/run.rs
@@ -1,17 +1,37 @@
-use std::path::PathBuf;
+use std::{
+    fs::File,
+    io::Read,
+    path::PathBuf,
+    process::{Command, Stdio},
+};
 
 use crate::{
     argument_parsing::{Backends, BuildOrCheck, ExtraArguments, Globals, PackageOpt, TestMetadata},
     cargo_command::{BuildMode, CargoCommand},
-    command_parser, RunResult,
+    command_parser, RunResult, TestRunError,
 };
-use log::error;
+use log::{error, info, Level};
 
 #[cfg(feature = "rayon")]
 use rayon::prelude::*;
 
 use iters::*;
 
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum OutputMode {
+    PipedAndCollected,
+    Inherited,
+}
+
+impl From<OutputMode> for Stdio {
+    fn from(value: OutputMode) -> Self {
+        match value {
+            OutputMode::PipedAndCollected => Stdio::piped(),
+            OutputMode::Inherited => Stdio::inherit(),
+        }
+    }
+}
+
 #[derive(Debug)]
 pub enum FinalRunResult<'c> {
     Success(CargoCommand<'c>, RunResult),
@@ -400,3 +420,134 @@ pub fn build_and_check_size<'c>(
 
     runner.run_and_coalesce()
 }
+
+pub fn run_command(command: &CargoCommand, stderr_mode: OutputMode) -> anyhow::Result<RunResult> {
+    log::info!("👟 {command}");
+
+    let mut process = Command::new(command.executable());
+
+    process
+        .args(command.args())
+        .stdout(Stdio::piped())
+        .stderr(stderr_mode);
+
+    if let Some(dir) = command.chdir() {
+        process.current_dir(dir.canonicalize()?);
+    }
+
+    let result = process.output()?;
+
+    let exit_status = result.status;
+    let stderr = String::from_utf8(result.stderr).unwrap_or("Not displayable".into());
+    let stdout = String::from_utf8(result.stdout).unwrap_or("Not displayable".into());
+
+    if command.print_stdout_intermediate() && exit_status.success() {
+        log::info!("\n{}", stdout);
+    }
+
+    if exit_status.success() {
+        log::info!("✅ Success.")
+    } else {
+        log::error!("❌ Command failed. Run to completion for the summary.");
+    }
+
+    Ok(RunResult {
+        exit_status,
+        stdout,
+        stderr,
+    })
+}
+
+/// Check if `run` was successful.
+/// returns Ok in case the run went as expected,
+/// Err otherwise
+pub fn run_successful(run: &RunResult, expected_output_file: &str) -> Result<(), TestRunError> {
+    let mut file_handle =
+        File::open(expected_output_file).map_err(|_| TestRunError::FileError {
+            file: expected_output_file.to_owned(),
+        })?;
+    let mut expected_output = String::new();
+    file_handle
+        .read_to_string(&mut expected_output)
+        .map_err(|_| TestRunError::FileError {
+            file: expected_output_file.to_owned(),
+        })?;
+
+    if expected_output != run.stdout {
+        Err(TestRunError::FileCmpError {
+            expected: expected_output.clone(),
+            got: run.stdout.clone(),
+        })
+    } else if !run.exit_status.success() {
+        Err(TestRunError::CommandError(run.clone()))
+    } else {
+        Ok(())
+    }
+}
+
+pub fn handle_results(globals: &Globals, results: Vec<FinalRunResult>) -> Result<(), ()> {
+    let errors = results.iter().filter_map(|r| {
+        if let FinalRunResult::Failed(c, r) = r {
+            Some((c, &r.stdout, &r.stderr))
+        } else {
+            None
+        }
+    });
+
+    let successes = results.iter().filter_map(|r| {
+        if let FinalRunResult::Success(c, r) = r {
+            Some((c, &r.stdout, &r.stderr))
+        } else {
+            None
+        }
+    });
+
+    let command_errors = results.iter().filter_map(|r| {
+        if let FinalRunResult::CommandError(c, e) = r {
+            Some((c, e))
+        } else {
+            None
+        }
+    });
+
+    let log_stdout_stderr = |level: Level| {
+        move |(cmd, stdout, stderr): (&CargoCommand, &String, &String)| {
+            let cmd = cmd.as_cmd_string();
+            if !stdout.is_empty() && !stderr.is_empty() {
+                log::log!(level, "\n{cmd}\nStdout:\n{stdout}\nStderr:\n{stderr}");
+            } else if !stdout.is_empty() {
+                log::log!(level, "\n{cmd}\nStdout:\n{}", stdout.trim_end());
+            } else if !stderr.is_empty() {
+                log::log!(level, "\n{cmd}\nStderr:\n{}", stderr.trim_end());
+            }
+        }
+    };
+
+    successes.for_each(|(cmd, stdout, stderr)| {
+        if globals.verbose > 0 {
+            info!("✅ Success: {cmd}\n    {}", cmd.as_cmd_string());
+        } else {
+            info!("✅ Success: {cmd}");
+        }
+
+        log_stdout_stderr(Level::Debug)((cmd, stdout, stderr));
+    });
+
+    errors.clone().for_each(|(cmd, stdout, stderr)| {
+        error!("❌ Failed: {cmd}\n    {}", cmd.as_cmd_string());
+        log_stdout_stderr(Level::Error)((cmd, stdout, stderr));
+    });
+
+    command_errors
+        .clone()
+        .for_each(|(cmd, error)| error!("❌ Failed: {cmd}\n    {}\n{error}", cmd.as_cmd_string()));
+
+    let ecount = errors.count() + command_errors.count();
+    if ecount != 0 {
+        log::error!("{ecount} commands failed.");
+        Err(())
+    } else {
+        info!("🚀🚀🚀 All tasks succeeded 🚀🚀🚀");
+        Ok(())
+    }
+}