use super::{
args::{CheckClippyTargets, Ignored, Target, TestTargets},
manifest,
};
use std::{
collections::HashSet,
io::{Error, StderrLock, Write as _},
path::{Path, PathBuf},
process::{Command, Stdio},
};
pub(crate) enum ToolchainErr {
CommandFail(Command, Error),
CommandNoStatus(Command, String),
CommandErr(Command, String, i32),
StdoutNotUtf8(Command),
StderrNotUtf8(Command),
UnexpectedOutput(Command, String),
MsrvTooHigh,
MsrvNotCompatibleWithInstalledMsrv(Version),
}
impl ToolchainErr {
pub(crate) fn write(self, mut stderr: StderrLock<'_>) -> Result<(), Error> {
match self {
Self::CommandFail(cmd, err) => stderr
.write_all(cmd.get_program().to_string_lossy().as_bytes())
.and_then(|()| {
cmd.get_args().try_fold((), |(), arg| {
stderr.write_all(b" ").and_then(|()| {
stderr
.write_all(arg.to_string_lossy().as_bytes())
})
}).and_then(|()| writeln!(stderr, " erred: {err}"))
}),
Self::CommandNoStatus(cmd, err) => stderr
.write_all(cmd.get_program().to_string_lossy().as_bytes())
.and_then(|()| {
cmd.get_args().try_fold((), |(), arg| {
stderr.write_all(b" ").and_then(|()| {
stderr
.write_all(arg.to_string_lossy().as_bytes())
})
}).and_then(|()| {
if err.is_empty() {
writeln!(stderr, " did not return a status code and didn't write anything to stderr.")
} else {
writeln!(stderr, " did not return a status code but wrote the following to stderr: {err}")
}
})
}),
Self::CommandErr(cmd, err, status) => stderr
.write_all(cmd.get_program().to_string_lossy().as_bytes())
.and_then(|()| {
cmd.get_args().try_fold((), |(), arg| {
stderr.write_all(b" ").and_then(|()| {
stderr
.write_all(arg.to_string_lossy().as_bytes())
})
}).and_then(|()| {
if err.is_empty() {
writeln!(stderr, " returned status code {status} but didn't write anything to stderr.")
} else {
writeln!(stderr, " returned status code {status} and wrote the following to stderr: {err}")
}
})
}),
Self::StdoutNotUtf8(cmd) => stderr
.write_all(cmd.get_program().to_string_lossy().as_bytes())
.and_then(|()| {
cmd.get_args().try_fold((), |(), arg| {
stderr.write_all(b" ").and_then(|()| {
stderr
.write_all(arg.to_string_lossy().as_bytes())
})
}).and_then(|()| writeln!(stderr, " wrote invalid UTF-8 to stdout."))
}),
Self::StderrNotUtf8(cmd) => stderr
.write_all(cmd.get_program().to_string_lossy().as_bytes())
.and_then(|()| {
cmd.get_args().try_fold((), |(), arg| {
stderr.write_all(b" ").and_then(|()| {
stderr
.write_all(arg.to_string_lossy().as_bytes())
})
}).and_then(|()| writeln!(stderr, " wrote invalid UTF-8 to stderr."))
}),
Self::UnexpectedOutput(cmd, output) => stderr
.write_all(cmd.get_program().to_string_lossy().as_bytes())
.and_then(|()| {
cmd.get_args().try_fold((), |(), arg| {
stderr.write_all(b" ").and_then(|()| {
stderr
.write_all(arg.to_string_lossy().as_bytes())
})
}).and_then(|()| writeln!(stderr, " wrote the following unexpected data to stdout: {output}"))
}),
Self::MsrvTooHigh => writeln!(stderr, "MSRV is higher than cargo stable."),
Self::MsrvNotCompatibleWithInstalledMsrv(version)=> writeln!(stderr, "cargo +<MSRV> -V returned '{}.{}.{}' which is inconsistent with the defined MSRV.", version.major, version.minor, version.patch),
}
}
}
pub(crate) enum CargoErr {
CommandFail(Command, Error),
CommandNoStatus(Command, String, String),
CommandErr(Command, String, String),
StdoutNotUtf8(Command),
StderrNotUtf8(Command),
CompileErrDefault(Command),
CompileErrNoFeatures(Command),
}
impl CargoErr {
pub(crate) fn write(self, mut stderr: StderrLock<'_>) -> Result<(), Error> {
match self {
Self::CommandFail(cmd, err) => writeln!(stderr, "{err}").map(|()| cmd),
Self::CommandNoStatus(cmd, err, out) => if out.is_empty() {
Ok(())
} else {
writeln!(stderr, "{out}")
}
.and_then(|()| {
if err.is_empty() {
writeln!(stderr, "Missing status code and nothing written to stderr.")
} else {
writeln!(
stderr,
"Missing status code, but the following was written to stderr: {err}"
)
}
.map(|()| cmd)
}),
Self::CommandErr(cmd, err, out) => if out.is_empty() {
Ok(())
} else {
writeln!(stderr, "{out}")
}
.and_then(|()| {
if err.is_empty() {
Ok(cmd)
} else {
writeln!(stderr, "{err}").map(|()| cmd)
}
}),
Self::StdoutNotUtf8(cmd) => {
writeln!(stderr, "Invalid UTF-8 written to stdout.").map(|()| cmd)
}
Self::StderrNotUtf8(cmd) => {
writeln!(stderr, "Invalid UTF-8 written to stderr.").map(|()| cmd)
}
Self::CompileErrDefault(cmd) => {
writeln!(stderr, "compile_error! raised on default feature.").map(|()| cmd)
}
Self::CompileErrNoFeatures(cmd) => writeln!(
stderr,
"compile_error! raised with no features when a default feature does not exist."
)
.map(|()| cmd),
}
.and_then(|cmd| {
stderr
.write_all(cmd.get_program().to_string_lossy().as_bytes())
.and_then(|()| {
cmd.get_args()
.try_fold((), |(), arg| {
stderr
.write_all(b" ")
.and_then(|()| stderr.write_all(arg.to_string_lossy().as_bytes()))
})
.and_then(|()| writeln!(stderr))
})
})
}
}
#[cfg_attr(test, derive(PartialEq))]
pub(crate) struct Version {
pub major: u64,
pub minor: u64,
pub patch: u64,
}
const PLUS_STABLE: &str = "+stable";
const RUSTUP_HOME: &str = "RUSTUP_HOME";
const CARGO_HOME: &str = "CARGO_HOME";
#[expect(
variant_size_differences,
reason = "fine. This doesn't get triggered if the other variants were unit variants despite Toolchain being the same size."
)]
#[derive(Clone, Copy)]
pub(crate) enum Toolchain<'a> {
Stable,
Default(bool),
Msrv(&'a str),
}
impl Toolchain<'_> {
#[expect(unsafe_code, reason = "comments justify correctness")]
fn parse_stdout(cmd: Command, stdout: Vec<u8>) -> Result<Version, Box<ToolchainErr>> {
const CARGO: &[u8; 6] = b"cargo ";
if let Ok(utf8) = String::from_utf8(stdout) {
utf8.as_bytes()
.split_at_checked(CARGO.len())
.and_then(|(pref, rem)| {
if pref == CARGO {
let mut iter = rem.split(|b| *b == b'.');
if let Some(fst) = iter.next()
&& let Ok(major) = manifest::parse_int(unsafe {
str::from_utf8_unchecked(fst)
})
&& let Some(snd) = iter.next()
&& let Ok(minor) = manifest::parse_int(unsafe {
str::from_utf8_unchecked(snd)
})
&& let Some(lst) = iter.next()
&& iter.next().is_none()
&& let Some(lst_fst) = lst.split(|b| *b == b' ').next()
&& let Ok(patch) = manifest::parse_int(unsafe {
str::from_utf8_unchecked(lst_fst)
})
{
Some(Version {
major,
minor,
patch,
})
} else {
None
}
} else {
None
}
})
.ok_or_else(|| Box::new(ToolchainErr::UnexpectedOutput(cmd, utf8)))
} else {
Err(Box::new(ToolchainErr::StdoutNotUtf8(cmd)))
}
}
pub(crate) fn get_version(
self,
rustup_home: Option<&Path>,
cargo_path: &Path,
cargo_home: Option<&Path>,
) -> Result<Version, Box<ToolchainErr>> {
let mut cmd = Command::new(cargo_path);
if let Some(env) = rustup_home {
_ = cmd.env(RUSTUP_HOME, env);
}
if let Some(env) = cargo_home {
_ = cmd.env(CARGO_HOME, env);
}
match self {
Self::Stable => {
_ = cmd.arg(PLUS_STABLE);
}
Self::Default(_) => {}
Self::Msrv(val) => {
_ = cmd.arg(val);
}
}
match cmd
.arg("-V")
.stderr(Stdio::piped())
.stdin(Stdio::null())
.stdout(Stdio::piped())
.output()
{
Ok(output) => {
if let Some(status_code) = output.status.code() {
if status_code == 0i32 {
Self::parse_stdout(cmd, output.stdout)
} else if let Ok(err) = String::from_utf8(output.stderr) {
Err(Box::new(ToolchainErr::CommandErr(cmd, err, status_code)))
} else {
Err(Box::new(ToolchainErr::StderrNotUtf8(cmd)))
}
} else if let Ok(err) = String::from_utf8(output.stderr) {
Err(Box::new(ToolchainErr::CommandNoStatus(cmd, err)))
} else {
Err(Box::new(ToolchainErr::StderrNotUtf8(cmd)))
}
}
Err(e) => Err(Box::new(ToolchainErr::CommandFail(cmd, e))),
}
}
}
const DASH_DASH_ALL_TARGETS: &str = "--all-targets";
const DASH_DASH_BENCHES: &str = "--benches";
const DASH_DASH_BINS: &str = "--bins";
const DASH_DASH_EXAMPLES: &str = "--examples";
const DASH_DASH_LIB: &str = "--lib";
const DASH_DASH_TESTS: &str = "--tests";
const DASH_P: &str = "-p";
const DASH_Q: &str = "-q";
const DASH_DASH_COLOR: &str = "--color";
const ALWAYS: &str = "always";
const NEVER: &str = "never";
const DASH_DASH_NO_DEFAULT_FEATURES: &str = "--no-default-features";
const DASH_DASH_FEATURES: &str = "--features";
const DASH_DASH: &str = "--";
const DEFAULT: &str = "default";
const DASH_DASH_IGNORE_RUST_VERSION: &str = "--ignore-rust-version";
pub(crate) struct Options<'toolchain, 'package, 'errs> {
pub toolchain: Toolchain<'toolchain>,
pub rustup_home: Option<PathBuf>,
pub cargo_path: PathBuf,
pub cargo_home: Option<PathBuf>,
pub package_name: &'package str,
pub color: bool,
pub ignore_compile_errors: bool,
pub default_feature_does_not_exist: bool,
pub non_terminating_errors: &'errs mut HashSet<String>,
}
fn execute_command(
mut cmd: Command,
options: &mut Options<'_, '_, '_>,
features: &str,
) -> Result<(), Box<CargoErr>> {
match cmd.stdout(Stdio::piped()).output() {
Ok(output) => {
if let Some(code) = output.status.code() {
match code {
0i32 => {
if !output.stderr.is_empty() {
_ = options.non_terminating_errors.insert(
match String::from_utf8(output.stderr) {
Ok(err) => err,
Err(e) => e.to_string(),
},
);
}
Ok(())
}
101i32 => {
const COMPILE_ERROR: &[u8; 14] = b"compile_error!";
if output
.stderr
.windows(COMPILE_ERROR.len())
.any(|window| window == COMPILE_ERROR)
{
if options.ignore_compile_errors {
if features == DEFAULT {
Err(Box::new(CargoErr::CompileErrDefault(cmd)))
} else if options.default_feature_does_not_exist
&& features.is_empty()
{
Err(Box::new(CargoErr::CompileErrNoFeatures(cmd)))
} else {
Ok(())
}
} else if let Ok(err) = String::from_utf8(output.stderr) {
if let Ok(stdout) = String::from_utf8(output.stdout) {
Err(Box::new(CargoErr::CommandErr(cmd, err, stdout)))
} else {
Err(Box::new(CargoErr::StdoutNotUtf8(cmd)))
}
} else {
Err(Box::new(CargoErr::StderrNotUtf8(cmd)))
}
} else if let Ok(err) = String::from_utf8(output.stderr) {
if let Ok(stdout) = String::from_utf8(output.stdout) {
Err(Box::new(CargoErr::CommandErr(cmd, err, stdout)))
} else {
Err(Box::new(CargoErr::StdoutNotUtf8(cmd)))
}
} else {
Err(Box::new(CargoErr::StderrNotUtf8(cmd)))
}
}
_ => {
if let Ok(err) = String::from_utf8(output.stderr) {
if let Ok(stdout) = String::from_utf8(output.stdout) {
Err(Box::new(CargoErr::CommandErr(cmd, err, stdout)))
} else {
Err(Box::new(CargoErr::StdoutNotUtf8(cmd)))
}
} else {
Err(Box::new(CargoErr::StderrNotUtf8(cmd)))
}
}
}
} else if let Ok(err) = String::from_utf8(output.stderr) {
if let Ok(stdout) = String::from_utf8(output.stdout) {
Err(Box::new(CargoErr::CommandNoStatus(cmd, err, stdout)))
} else {
Err(Box::new(CargoErr::StdoutNotUtf8(cmd)))
}
} else {
Err(Box::new(CargoErr::StderrNotUtf8(cmd)))
}
}
Err(e) => Err(Box::new(CargoErr::CommandFail(cmd, e))),
}
}
pub(crate) struct Check;
impl Check {
pub(crate) fn run(
options: &mut Options<'_, '_, '_>,
targets: CheckClippyTargets,
features: &str,
) -> Result<(), Box<CargoErr>> {
let mut c = Command::new(options.cargo_path.as_path());
_ = c.stderr(Stdio::piped()).stdin(Stdio::null());
if let Some(ref env) = options.rustup_home {
_ = c.env(RUSTUP_HOME, env);
}
if let Some(ref env) = options.cargo_home {
_ = c.env(CARGO_HOME, env);
}
let ignore_msrv = match options.toolchain {
Toolchain::Stable => {
_ = c.arg(PLUS_STABLE);
false
}
Toolchain::Default(ignore_msrv) => ignore_msrv,
Toolchain::Msrv(ref msrv) => {
_ = c.arg(msrv);
false
}
};
_ = c
.arg("check")
.arg(DASH_P)
.arg(options.package_name)
.arg(DASH_Q);
match targets {
CheckClippyTargets::Default => {}
CheckClippyTargets::All => {
_ = c.arg(DASH_DASH_ALL_TARGETS);
}
CheckClippyTargets::Targets(tar) => {
if tar.contains(Target::Benches) {
_ = c.arg(DASH_DASH_BENCHES);
}
if tar.contains(Target::Bins) {
_ = c.arg(DASH_DASH_BINS);
}
if tar.contains(Target::Examples) {
_ = c.arg(DASH_DASH_EXAMPLES);
}
if tar.contains(Target::Lib) {
_ = c.arg(DASH_DASH_LIB);
}
if tar.contains(Target::Tests) {
_ = c.arg(DASH_DASH_TESTS);
}
}
}
if ignore_msrv {
_ = c.arg(DASH_DASH_IGNORE_RUST_VERSION);
}
_ = c
.arg(DASH_DASH_COLOR)
.arg(if options.color { ALWAYS } else { NEVER })
.arg(DASH_DASH_NO_DEFAULT_FEATURES);
if !features.is_empty() {
_ = c.arg(DASH_DASH_FEATURES).arg(features);
}
execute_command(c, options, features)
}
}
pub(crate) struct Clippy;
impl Clippy {
pub(crate) fn run(
options: &mut Options<'_, '_, '_>,
targets: CheckClippyTargets,
deny_warnings: bool,
features: &str,
) -> Result<(), Box<CargoErr>> {
let mut c = Command::new(options.cargo_path.as_path());
_ = c.stderr(Stdio::piped()).stdin(Stdio::null());
if let Some(ref env) = options.rustup_home {
_ = c.env(RUSTUP_HOME, env);
}
if let Some(ref env) = options.cargo_home {
_ = c.env(CARGO_HOME, env);
}
let ignore_msrv = match options.toolchain {
Toolchain::Stable => {
_ = c.arg(PLUS_STABLE);
false
}
Toolchain::Default(ignore_msrv) => ignore_msrv,
Toolchain::Msrv(ref msrv) => {
_ = c.arg(msrv);
false
}
};
_ = c
.arg("clippy")
.arg(DASH_P)
.arg(options.package_name)
.arg(DASH_Q);
match targets {
CheckClippyTargets::Default => {}
CheckClippyTargets::All => {
_ = c.arg(DASH_DASH_ALL_TARGETS);
}
CheckClippyTargets::Targets(tar) => {
if tar.contains(Target::Benches) {
_ = c.arg(DASH_DASH_BENCHES);
}
if tar.contains(Target::Bins) {
_ = c.arg(DASH_DASH_BINS);
}
if tar.contains(Target::Examples) {
_ = c.arg(DASH_DASH_EXAMPLES);
}
if tar.contains(Target::Lib) {
_ = c.arg(DASH_DASH_LIB);
}
if tar.contains(Target::Tests) {
_ = c.arg(DASH_DASH_TESTS);
}
}
}
if ignore_msrv {
_ = c.arg(DASH_DASH_IGNORE_RUST_VERSION);
}
_ = c
.arg(DASH_DASH_COLOR)
.arg(if options.color { ALWAYS } else { NEVER })
.arg(DASH_DASH_NO_DEFAULT_FEATURES);
if !features.is_empty() {
_ = c.arg(DASH_DASH_FEATURES).arg(features);
}
if deny_warnings {
_ = c.arg(DASH_DASH).arg("-Dwarnings");
}
execute_command(c, options, features)
}
}
pub(crate) struct Test;
impl Test {
pub(crate) fn run(
options: &mut Options<'_, '_, '_>,
targets: TestTargets,
ignored: Ignored,
features: &str,
) -> Result<(), Box<CargoErr>> {
const DASH_DASH_IGNORED: &str = "--ignored";
const DASH_DASH_INCLUDE_IGNORED: &str = "--include-ignored";
let mut c = Command::new(options.cargo_path.as_path());
_ = c.stderr(Stdio::piped()).stdin(Stdio::null());
if let Some(ref env) = options.rustup_home {
_ = c.env(RUSTUP_HOME, env);
}
if let Some(ref env) = options.cargo_home {
_ = c.env(CARGO_HOME, env);
}
let ignore_msrv = match options.toolchain {
Toolchain::Stable => {
_ = c.arg(PLUS_STABLE);
false
}
Toolchain::Default(ignore_msrv) => ignore_msrv,
Toolchain::Msrv(ref msrv) => {
_ = c.arg(msrv);
false
}
};
_ = c
.arg("test")
.arg(DASH_P)
.arg(options.package_name)
.arg(DASH_Q);
match targets {
TestTargets::Default => {}
TestTargets::All => {
_ = c.arg(DASH_DASH_ALL_TARGETS);
}
TestTargets::Targets(tar) => {
if tar.contains(Target::Benches) {
_ = c.arg(DASH_DASH_BENCHES);
}
if tar.contains(Target::Bins) {
_ = c.arg(DASH_DASH_BINS);
}
if tar.contains(Target::Examples) {
_ = c.arg(DASH_DASH_EXAMPLES);
}
if tar.contains(Target::Lib) {
_ = c.arg(DASH_DASH_LIB);
}
if tar.contains(Target::Tests) {
_ = c.arg(DASH_DASH_TESTS);
}
}
TestTargets::Doc => {
_ = c.arg("--doc");
}
}
if ignore_msrv {
_ = c.arg(DASH_DASH_IGNORE_RUST_VERSION);
}
_ = c
.arg(DASH_DASH_COLOR)
.arg(if options.color { ALWAYS } else { NEVER })
.arg(DASH_DASH_NO_DEFAULT_FEATURES);
if !features.is_empty() {
_ = c.arg(DASH_DASH_FEATURES).arg(features);
}
_ = c
.arg(DASH_DASH)
.arg(DASH_DASH_COLOR)
.arg(if options.color { ALWAYS } else { NEVER });
match ignored {
Ignored::None => {}
Ignored::Only => {
_ = c.arg(DASH_DASH_IGNORED);
}
Ignored::Include => {
_ = c.arg(DASH_DASH_INCLUDE_IGNORED);
}
}
execute_command(c, options, features)
}
}
#[cfg(test)]
mod tests {
use super::{Command, Toolchain, ToolchainErr, Version};
#[expect(clippy::cognitive_complexity, reason = "a lot of tests")]
#[test]
fn toolchain_parse() {
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), vec![255]), Err(e) if matches!(*e, ToolchainErr::StdoutNotUtf8(_)))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), Vec::new()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v.is_empty()))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.2".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1.2"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.2.3.".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1.2.3."))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.2.3a".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1.2.3a"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b" cargo 1.2.3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == " cargo 1.2.3"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"Cargo 1.2.3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "Cargo 1.2.3"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.00.0".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1.00.0"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.2.03".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1.2.03"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo -1.2.3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo -1.2.3"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo1.2.3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo1.2.3"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.2.3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1.2.3"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo\t1.2.3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo\t1.2.3"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1..3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1..3"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1."))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 111111111111111111111111.2.3".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 111111111111111111111111.2.3"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.2.3.4".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1.2.3.4"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 1.2.3-nightly".to_vec()), Err(e) if matches!(*e, ToolchainErr::UnexpectedOutput(_, ref v) if v == "cargo 1.2.3-nightly"))
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 18446744073709551615.18446744073709551615.18446744073709551615".to_vec()), Ok(v) if v == Version { major: u64::MAX, minor: u64::MAX, patch: u64::MAX, })
);
assert!(
matches!(Toolchain::parse_stdout(Command::new(""), b"cargo 0.0.0 asdflk 0023n0=lk0932(!@#V)\x00".to_vec()), Ok(v) if v == Version { major: 0, minor: 0, patch: 0, })
);
}
}