dom/webgpu/tests/cts/vendor/src/process.rs

   1 use std::{
   2     ffi::{OsStr, OsString},
   3     fmt::{self, Display},
   4     iter::once,
   5     process::{Command, Output},
   6 };
   7
   8 use format::lazy_format;
   9 use miette::{ensure, Context, IntoDiagnostic};
  10
  11 pub(crate) fn which(name: &'static str, desc: &str) -> miette::Result<OsString> {
  12     let found = ::which::which(name)
  13         .into_diagnostic()
  14         .wrap_err(lazy_format!("failed to find `{name}` executable"))?;
  15     log::debug!("using {desc} from {}", found.display());
  16     Ok(found.file_name().unwrap().to_owned())
  17 }
  18
  19 pub(crate) struct EasyCommand {
  20     inner: Command,
  21 }
  22
  23 impl EasyCommand {
  24     pub(crate) fn new<C>(cmd: C, f: impl FnOnce(&mut Command) -> &mut Command) -> Self
  25     where
  26         C: AsRef<OsStr>,
  27     {
  28         let mut cmd = Command::new(cmd);
  29         f(&mut cmd);
  30         Self { inner: cmd }
  31     }
  32
  33     pub(crate) fn spawn(&mut self) -> miette::Result<()> {
  34         log::debug!("spawning {self}…");
  35         let status = self
  36             .inner
  37             .spawn()
  38             .into_diagnostic()
  39             .wrap_err_with(|| format!("failed to spawn {self}"))?
  40             .wait()
  41             .into_diagnostic()
  42             .wrap_err_with(|| format!("failed to wait for exit code from {self}"))?;
  43         log::debug!("{self} returned {:?}", status.code());
  44         ensure!(status.success(), "{self} returned {:?}", status.code());
  45         Ok(())
  46     }
  47
  48     fn just_stdout(&mut self) -> miette::Result<Vec<u8>> {
  49         log::debug!("getting `stdout` output of {self}");
  50         let output = self
  51             .inner
  52             .output()
  53             .into_diagnostic()
  54             .wrap_err_with(|| format!("failed to execute `{self}`"))?;
  55         let Output {
  56             status,
  57             stdout: _,
  58             stderr,
  59         } = &output;
  60         log::debug!("{self} returned {:?}", status.code());
  61         ensure!(
  62             status.success(),
  63             "{self} returned {:?}; full output: {output:#?}",
  64             status.code(),
  65         );
  66         assert!(stderr.is_empty());
  67         Ok(output.stdout)
  68     }
  69
  70     pub(crate) fn just_stdout_utf8(&mut self) -> miette::Result<String> {
  71         String::from_utf8(self.just_stdout()?)
  72             .into_diagnostic()
  73             .wrap_err_with(|| format!("output of {self} was not UTF-8 (!?)"))
  74     }
  75 }
  76
  77 impl Display for EasyCommand {
  78     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  79         let Self { inner } = self;
  80         let prog = inner.get_program().to_string_lossy();
  81         let args = inner.get_args().map(|a| a.to_string_lossy());
  82         let shell_words = ::shell_words::join(once(prog).chain(args));
  83         write!(f, "`{shell_words}`")
  84     }
  85 }