feat(error): Expose error building blocks
This has some limited programmatic use but the focus is on allowing people to format the errors as they wish.

Downside is that the `.text` section for the `git` example went from 547.9KiB to 566.8KiB.  `Error::formatted` is the sixth largest clap function at 6.0KiB.

Fixes #2628
Fixes #3227
Maintainer's notes:
- If we move error formatting to display time, we can provide all of the information the user needs that the user can build the error as they need (see also #2628)
--
### Discussed in https://github.com/clap-rs/clap/discussions/3226

<div type='discussions-op-text'>

<sup>Originally posted by **ducaale** December 27, 2021</sup>
In Structopt/Clap 2.x, errors from both initial-parsing and post-processing errors didn't include the Usage string. However, in Clap 3.x, post-processing errors include the usage string. Is there a way to opt-out of this new behavior in Clap 3.x?

### Structopt/Clap 2.x
```rust
// structopt = "0.3"
// anyhow = "1.0"

use std::str::FromStr;
use std::time::Duration;

use anyhow::anyhow;
use structopt::clap::{Error, ErrorKind};
use structopt::StructOpt;

pub struct Timeout(Duration);

impl FromStr for Timeout {
    type Err = anyhow::Error;

    fn from_str(sec: &str) -> anyhow::Result<Timeout> {
        let pos_sec: f64 = match sec.parse::<f64>() {
            Ok(sec) if sec.is_sign_positive() => sec,
            _ => return Err(anyhow!("Invalid seconds as connection timeout")),
        };

        let dur = Duration::from_secs_f64(pos_sec);
        Ok(Timeout(dur))
    }
}

#[derive(StructOpt)]
struct Cli {
    #[structopt(long, short)]
    config: Option<String>,

    #[structopt(long, short)]
    timeout: Option<Timeout>,
}

fn main() {
    let _ = Cli::from_args();
    Error::with_description(
        "Can't do relative and absolute version change",
        ErrorKind::ArgumentConflict,
    )
    .exit();
}
```

```
$ cargo run
error: Can't do relative and absolute version change

$ cargo run -- --timeout=-1
error: Invalid value for '--timeout <timeout>': Invalid seconds as connection timeout
```

### Clap 3.x
```rust
// clap = { version = "3.0.0-rc.9", features = ["derive"] }
// anyhow = "1.0"

use std::str::FromStr;
use std::time::Duration;

use anyhow::anyhow;
use clap::{ErrorKind, IntoApp, Parser};

pub struct Timeout(Duration);

impl FromStr for Timeout {
    type Err = anyhow::Error;

    fn from_str(sec: &str) -> anyhow::Result<Timeout> {
        let pos_sec: f64 = match sec.parse::<f64>() {
            Ok(sec) if sec.is_sign_positive() => sec,
            _ => return Err(anyhow!("Invalid seconds as connection timeout")),
        };

        let dur = Duration::from_secs_f64(pos_sec);
        Ok(Timeout(dur))
    }
}

#[derive(Parser)]
struct Cli {
    #[clap(long, short)]
    config: Option<String>,

    #[structopt(long, short)]
    timeout: Option<Timeout>,
}

fn main() {
    let _ = Cli::parse();
    let mut app = Cli::into_app();
    app.error(
        ErrorKind::ArgumentConflict,
        "Can't do relative and absolute version change",
    )
    .exit();
}
```

```
$ cargo run
error: Can't do relative and absolute version change

USAGE:
    temp-clap [OPTIONS]

For more information try --help

$ cargo run -- --timeout=-1
error: Invalid value for '--timeout <TIMEOUT>': Invalid seconds as connection timeout

For more information try --help
```

</div>
Is it possible to not show usage string in post validation errors?
diff --git a/examples/keyvalue-derive.md b/examples/keyvalue-derive.md
index 65748bc3925..6b468848590 100644
--- a/examples/keyvalue-derive.md
+++ b/examples/keyvalue-derive.md
@@ -18,13 +18,13 @@ Args { defines: [("Foo", 10), ("Alice", 30)] }
 
 $ keyvalue-derive -D Foo
 ? failed
-error: Invalid value for '-D <DEFINES>': invalid KEY=value: no `=` found in `Foo`
+error: Invalid value "Foo" for '-D <DEFINES>': invalid KEY=value: no `=` found in `Foo`
 
 For more information try --help
 
 $ keyvalue-derive -D Foo=Bar
 ? failed
-error: Invalid value for '-D <DEFINES>': invalid digit found in string
+error: Invalid value "Foo=Bar" for '-D <DEFINES>': invalid digit found in string
 
 For more information try --help
 
diff --git a/examples/tutorial_builder/README.md b/examples/tutorial_builder/README.md
index ff434fad538..08d34514c74 100644
--- a/examples/tutorial_builder/README.md
+++ b/examples/tutorial_builder/README.md
@@ -472,7 +472,7 @@ PORT = 22
 
 $ 04_02_validate foobar
 ? failed
-error: Invalid value for '<PORT>': invalid digit found in string
+error: Invalid value "foobar" for '<PORT>': invalid digit found in string
 
 For more information try --help
 
diff --git a/examples/tutorial_derive/README.md b/examples/tutorial_derive/README.md
index 1d2b5f1f2b3..0cf79e5e3fd 100644
--- a/examples/tutorial_derive/README.md
+++ b/examples/tutorial_derive/README.md
@@ -438,7 +438,7 @@ PORT = 22
 
 $ 04_02_validate_derive foobar
 ? failed
-error: Invalid value for '<PORT>': invalid digit found in string
+error: Invalid value "foobar" for '<PORT>': invalid digit found in string
 
 For more information try --help
 
diff --git a/src/error/context.rs b/src/error/context.rs
new file mode 100644
index 00000000000..985cd4d70ba
--- /dev/null
+++ b/src/error/context.rs
@@ -0,0 +1,55 @@
+/// Semantics for a piece of error information
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum ContextKind {
+    /// The cause of the error
+    InvalidSubcommand,
+    /// The cause of the error
+    InvalidArg,
+    /// Existing arguments
+    PriorArg,
+    /// Accepted values
+    ValidValue,
+    /// Rejected values
+    InvalidValue,
+    /// Number of values present
+    ActualNumValues,
+    /// Number of allowed values
+    ExpectedNumValues,
+    /// Minimum number of allowed values
+    MinValues,
+    /// Number of occurrences present
+    ActualNumOccurrences,
+    /// Maximum number of allowed occurrences
+    MaxOccurrences,
+    /// Potential fix for the user
+    SuggestedCommand,
+    /// Potential fix for the user
+    SuggestedSubcommand,
+    /// Potential fix for the user
+    SuggestedArg,
+    /// Potential fix for the user
+    SuggestedValue,
+    /// Trailing argument
+    TrailingArg,
+    /// A usage string
+    Usage,
+    /// An opaque message to the user
+    Custom,
+}
+
+/// A piece of error information
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum ContextValue {
+    /// [`ContextKind`] is self-sufficient, no additional information needed
+    None,
+    /// A single value
+    Bool(bool),
+    /// A single value
+    String(String),
+    /// Many values
+    Strings(Vec<String>),
+    /// A single value
+    Number(isize),
+}
diff --git a/src/error/kind.rs b/src/error/kind.rs
index aad353acac1..9f82e4ef050 100644
--- a/src/error/kind.rs
+++ b/src/error/kind.rs
@@ -399,3 +399,47 @@ pub enum ErrorKind {
     /// [Format error]: std::fmt::Error
     Format,
 }
+
+impl ErrorKind {
+    /// End-user description of the error case, where relevant
+    pub fn as_str(self) -> Option<&'static str> {
+        match self {
+            Self::InvalidValue => Some("One of the values isn't valid for an argument"),
+            Self::UnknownArgument => {
+                Some("Found an argument which wasn't expected or isn't valid in this context")
+            }
+            Self::InvalidSubcommand => Some("A subcommand wasn't recognized"),
+            Self::UnrecognizedSubcommand => Some("A subcommand wasn't recognized"),
+            Self::EmptyValue => Some("An argument requires a value but none was supplied"),
+            Self::NoEquals => Some("Equal is needed when assigning values to one of the arguments"),
+            Self::ValueValidation => Some("Invalid for for one of the arguments"),
+            Self::TooManyValues => Some("An argument received an unexpected value"),
+            Self::TooFewValues => Some("An argument requires more values"),
+            Self::TooManyOccurrences => Some("An argument occurred too many times"),
+            Self::WrongNumberOfValues => Some("An argument received too many or too few values"),
+            Self::ArgumentConflict => {
+                Some("An argument cannot be used with one or more of the other specified arguments")
+            }
+            Self::MissingRequiredArgument => {
+                Some("One or more required arguments were not provided")
+            }
+            Self::MissingSubcommand => Some("A subcommand is required but one was not provided"),
+            Self::UnexpectedMultipleUsage => {
+                Some("An argument was provided more than once but cannot be used multiple times")
+            }
+            Self::InvalidUtf8 => Some("Invalid UTF-8 was detected in one or more arguments"),
+            Self::DisplayHelp => None,
+            Self::DisplayHelpOnMissingArgumentOrSubcommand => None,
+            Self::DisplayVersion => None,
+            Self::ArgumentNotFound => Some("An argument wasn't found"),
+            Self::Io => None,
+            Self::Format => None,
+        }
+    }
+}
+
+impl std::fmt::Display for ErrorKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.as_str().unwrap_or_default().fmt(f)
+    }
+}
diff --git a/src/error/mod.rs b/src/error/mod.rs
index 6349661ab87..82884c3aa9c 100644
--- a/src/error/mod.rs
+++ b/src/error/mod.rs
@@ -19,8 +19,11 @@ use crate::{
     App, AppSettings,
 };
 
+mod context;
 mod kind;
 
+pub use context::ContextKind;
+pub use context::ContextValue;
 pub use kind::ErrorKind;
 
 /// Short hand for [`Result`] type
@@ -45,11 +48,12 @@ pub struct Error {
 
 #[derive(Debug)]
 struct ErrorInner {
-    /// The type of error
     kind: ErrorKind,
-    /// Formatted error message, enhancing the cause message with extra information
-    message: Message,
+    context: Vec<(ContextKind, ContextValue)>,
+    message: Option<Message>,
     source: Option<Box<dyn error::Error + Send + Sync>>,
+    help_flag: Option<&'static str>,
+    color_when: ColorChoice,
     wait_on_exit: bool,
     backtrace: Option<Backtrace>,
 }
@@ -64,7 +68,7 @@ impl Error {
     ///
     /// [`App::error`]: crate::App::error
     pub fn raw(kind: ErrorKind, message: impl std::fmt::Display) -> Self {
-        Self::new(message.to_string(), kind, false)
+        Self::new(kind).set_message(message.to_string())
     }
 
     /// Format the existing message with the App's context
@@ -72,9 +76,10 @@ impl Error {
     pub fn format(mut self, app: &mut App) -> Self {
         app._build();
         let usage = app.render_usage();
-        self.inner.message.format(app, usage);
-        self.inner.wait_on_exit = app.settings.is_set(AppSettings::WaitOnError);
-        self
+        if let Some(message) = self.inner.message.as_mut() {
+            message.format(app, usage);
+        }
+        self.with_app(app)
     }
 
     /// Type of error for programmatic processing
@@ -82,6 +87,11 @@ impl Error {
         self.inner.kind
     }
 
+    /// Additional information to further qualify the error
+    pub fn context(&self) -> impl Iterator<Item = (ContextKind, &ContextValue)> {
+        self.inner.context.iter().map(|(k, v)| (*k, v))
+    }
+
     /// Should the message be written to `stdout` or not?
     #[inline]
     pub fn use_stderr(&self) -> bool {
@@ -132,7 +142,7 @@ impl Error {
     /// };
     /// ```
     pub fn print(&self) -> io::Result<()> {
-        self.inner.message.formatted().print()
+        self.formatted().print()
     }
 
     /// Deprecated, replaced with [`App::error`]
@@ -143,13 +153,16 @@ impl Error {
         Error::raw(kind, description)
     }
 
-    pub(crate) fn new(message: impl Into<Message>, kind: ErrorKind, wait_on_exit: bool) -> Self {
+    fn new(kind: ErrorKind) -> Self {
         Self {
             inner: Box::new(ErrorInner {
                 kind,
-                message: message.into(),
+                context: Vec::new(),
+                message: None,
                 source: None,
-                wait_on_exit,
+                help_flag: None,
+                color_when: ColorChoice::Never,
+                wait_on_exit: false,
                 backtrace: Backtrace::new(),
             }),
             kind,
@@ -158,18 +171,22 @@ impl Error {
     }
 
     #[inline(never)]
-    pub(crate) fn for_app(
-        app: &App,
-        colorizer: Colorizer,
-        kind: ErrorKind,
-        info: Vec<String>,
-    ) -> Self {
-        Self::new(
-            colorizer,
-            kind,
-            app.settings.is_set(AppSettings::WaitOnError),
-        )
-        .set_info(info)
+    fn for_app(kind: ErrorKind, app: &App, colorizer: Colorizer, info: Vec<String>) -> Self {
+        Self::new(kind)
+            .set_message(colorizer)
+            .with_app(app)
+            .set_info(info)
+    }
+
+    pub(crate) fn with_app(self, app: &App) -> Self {
+        self.set_wait_on_exit(app.settings.is_set(AppSettings::WaitOnError))
+            .set_color(app.get_color())
+            .set_help_flag(get_help_flag(app))
+    }
+
+    pub(crate) fn set_message(mut self, message: impl Into<Message>) -> Self {
+        self.inner.message = Some(message.into());
+        self
     }
 
     pub(crate) fn set_info(mut self, info: Vec<String>) -> Self {
@@ -182,91 +199,122 @@ impl Error {
         self
     }
 
-    pub(crate) fn argument_conflict(
-        app: &App,
-        arg: &Arg,
-        others: Vec<String>,
-        usage: String,
-    ) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
-        let arg = arg.to_string();
-
-        start_error(&mut c, "The argument '");
-        c.warning(arg);
-        c.none("' cannot be used with");
-
-        match others.len() {
-            0 => {
-                c.none(" one or more of the other specified arguments");
-            }
-            1 => {
-                c.none(" '");
-                c.warning(&*others[0]);
-                c.none("'");
-            }
-            _ => {
-                c.none(":");
-                for v in &others {
-                    c.none("\n    ");
-                    c.warning(&**v);
-                }
-            }
-        }
+    pub(crate) fn set_color(mut self, color_when: ColorChoice) -> Self {
+        self.inner.color_when = color_when;
+        self
+    }
 
-        put_usage(&mut c, usage);
-        try_help(app, &mut c);
+    pub(crate) fn set_help_flag(mut self, help_flag: Option<&'static str>) -> Self {
+        self.inner.help_flag = help_flag;
+        self
+    }
 
-        Self::for_app(app, c, ErrorKind::ArgumentConflict, others)
+    pub(crate) fn set_wait_on_exit(mut self, yes: bool) -> Self {
+        self.inner.wait_on_exit = yes;
+        self
     }
 
-    pub(crate) fn empty_value(app: &App, good_vals: &[&str], arg: &Arg, usage: String) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
-        let arg = arg.to_string();
+    /// Does not verify if `ContextKind` is already present
+    #[inline(never)]
+    pub(crate) fn insert_context_unchecked(
+        mut self,
+        kind: ContextKind,
+        value: ContextValue,
+    ) -> Self {
+        self.inner.context.push((kind, value));
+        self
+    }
 
-        start_error(&mut c, "The argument '");
-        c.warning(&*arg);
-        c.none("' requires a value but none was supplied");
-        if !good_vals.is_empty() {
-            let good_vals: Vec<String> = good_vals
-                .iter()
-                .map(|&v| {
-                    if v.contains(char::is_whitespace) {
-                        format!("{:?}", v)
-                    } else {
-                        v.to_owned()
-                    }
-                })
-                .collect();
-            c.none("\n\t[possible values: ");
-
-            if let Some((last, elements)) = good_vals.split_last() {
-                for v in elements {
-                    c.good(v);
-                    c.none(", ");
-                }
+    /// Does not verify if `ContextKind` is already present
+    #[inline(never)]
+    pub(crate) fn extend_context_unchecked<const N: usize>(
+        mut self,
+        context: [(ContextKind, ContextValue); N],
+    ) -> Self {
+        self.inner.context.extend(context);
+        self
+    }
 
-                c.good(last);
-            }
+    #[inline(never)]
+    fn get_context(&self, kind: ContextKind) -> Option<&ContextValue> {
+        self.inner
+            .context
+            .iter()
+            .find_map(|(k, v)| (*k == kind).then(|| v))
+    }
 
-            c.none("]");
-        }
-        put_usage(&mut c, usage);
-        try_help(app, &mut c);
+    pub(crate) fn display_help(app: &App, colorizer: Colorizer) -> Self {
+        Self::for_app(ErrorKind::DisplayHelp, app, colorizer, vec![])
+    }
 
-        Self::for_app(app, c, ErrorKind::EmptyValue, vec![arg])
+    pub(crate) fn display_help_error(app: &App, colorizer: Colorizer) -> Self {
+        Self::for_app(
+            ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand,
+            app,
+            colorizer,
+            vec![],
+        )
     }
 
-    pub(crate) fn no_equals(app: &App, arg: String, usage: String) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
+    pub(crate) fn display_version(app: &App, colorizer: Colorizer) -> Self {
+        Self::for_app(ErrorKind::DisplayVersion, app, colorizer, vec![])
+    }
 
-        start_error(&mut c, "Equal sign is needed when assigning values to '");
-        c.warning(&*arg);
-        c.none("'.");
+    pub(crate) fn argument_conflict(
+        app: &App,
+        arg: &Arg,
+        mut others: Vec<String>,
+        usage: String,
+    ) -> Self {
+        let info = others.clone();
+        let others = match others.len() {
+            0 => ContextValue::None,
+            1 => ContextValue::String(others.pop().unwrap()),
+            _ => ContextValue::Strings(others),
+        };
+        Self::new(ErrorKind::ArgumentConflict)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([
+                (
+                    ContextKind::InvalidArg,
+                    ContextValue::String(arg.to_string()),
+                ),
+                (ContextKind::PriorArg, others),
+                (ContextKind::Usage, ContextValue::String(usage)),
+            ])
+    }
 
-        put_usage(&mut c, usage);
-        try_help(app, &mut c);
+    pub(crate) fn empty_value(app: &App, good_vals: &[&str], arg: &Arg, usage: String) -> Self {
+        let info = vec![arg.to_string()];
+        let mut err = Self::new(ErrorKind::EmptyValue)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([
+                (
+                    ContextKind::InvalidArg,
+                    ContextValue::String(arg.to_string()),
+                ),
+                (ContextKind::Usage, ContextValue::String(usage)),
+            ]);
+        if !good_vals.is_empty() {
+            err = err.insert_context_unchecked(
+                ContextKind::ValidValue,
+                ContextValue::Strings(good_vals.iter().map(|s| (*s).to_owned()).collect()),
+            );
+        }
+        err
+    }
 
-        Self::for_app(app, c, ErrorKind::NoEquals, vec![arg])
+    pub(crate) fn no_equals(app: &App, arg: String, usage: String) -> Self {
+        let info = vec![arg.to_string()];
+        Self::new(ErrorKind::NoEquals)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([
+                (ContextKind::InvalidArg, ContextValue::String(arg)),
+                (ContextKind::Usage, ContextValue::String(usage)),
+            ])
     }
 
     pub(crate) fn invalid_value(
@@ -276,51 +324,32 @@ impl Error {
         arg: &Arg,
         usage: String,
     ) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
-        let suffix = suggestions::did_you_mean(&bad_val, good_vals.iter()).pop();
-        let arg = arg.to_string();
-
-        let good_vals: Vec<String> = good_vals
-            .iter()
-            .map(|&v| {
-                if v.contains(char::is_whitespace) {
-                    format!("{:?}", v)
-                } else {
-                    v.to_owned()
-                }
-            })
-            .collect();
-
-        start_error(&mut c, "");
-        c.warning(format!("{:?}", bad_val));
-        c.none(" isn't a valid value for '");
-        c.warning(&*arg);
-        c.none("'\n\t[possible values: ");
-
-        if let Some((last, elements)) = good_vals.split_last() {
-            for v in elements {
-                c.good(v);
-                c.none(", ");
-            }
-
-            c.good(last);
+        let mut info = vec![arg.to_string(), bad_val.clone()];
+        info.extend(good_vals.iter().map(|s| (*s).to_owned()));
+
+        let suggestion = suggestions::did_you_mean(&bad_val, good_vals.iter()).pop();
+        let mut err = Self::new(ErrorKind::InvalidValue)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([
+                (
+                    ContextKind::InvalidArg,
+                    ContextValue::String(arg.to_string()),
+                ),
+                (ContextKind::InvalidValue, ContextValue::String(bad_val)),
+                (
+                    ContextKind::ValidValue,
+                    ContextValue::Strings(good_vals.iter().map(|s| (*s).to_owned()).collect()),
+                ),
+                (ContextKind::Usage, ContextValue::String(usage)),
+            ]);
+        if let Some(suggestion) = suggestion {
+            err = err.insert_context_unchecked(
+                ContextKind::SuggestedValue,
+                ContextValue::String(suggestion),
+            );
         }
-
-        c.none("]");
-
-        if let Some(val) = suffix {
-            c.none("\n\n\tDid you mean ");
-            c.good(format!("{:?}", val));
-            c.none("?");
-        }
-
-        put_usage(&mut c, usage);
-        try_help(app, &mut c);
-
-        let mut info = vec![arg, bad_val];
-        info.extend(good_vals);
-
-        Self::for_app(app, c, ErrorKind::InvalidValue, info)
+        err
     }
 
     pub(crate) fn invalid_subcommand(
@@ -330,36 +359,35 @@ impl Error {
         name: String,
         usage: String,
     ) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
-
-        start_error(&mut c, "The subcommand '");
-        c.warning(&*subcmd);
-        c.none("' wasn't recognized\n\n\tDid you mean ");
-        c.good(did_you_mean);
-        c.none("");
-        c.none(format!(
-            "?\n\nIf you believe you received this message in error, try re-running with '{} ",
-            name
-        ));
-        c.good("--");
-        c.none(format!(" {}'", subcmd));
-        put_usage(&mut c, usage);
-        try_help(app, &mut c);
-
-        Self::for_app(app, c, ErrorKind::InvalidSubcommand, vec![subcmd])
+        let info = vec![subcmd.clone()];
+        let suggestion = format!("{} -- {}", name, subcmd);
+        Self::new(ErrorKind::InvalidSubcommand)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([
+                (ContextKind::InvalidSubcommand, ContextValue::String(subcmd)),
+                (
+                    ContextKind::SuggestedSubcommand,
+                    ContextValue::String(did_you_mean),
+                ),
+                (
+                    ContextKind::SuggestedCommand,
+                    ContextValue::String(suggestion),
+                ),
+                (ContextKind::Usage, ContextValue::String(usage)),
+            ])
     }
 
     pub(crate) fn unrecognized_subcommand(app: &App, subcmd: String, name: String) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
-
-        start_error(&mut c, " The subcommand '");
-        c.warning(&*subcmd);
-        c.none("' wasn't recognized\n\n");
-        c.warning("USAGE:");
-        c.none(format!("\n    {} <subcommands>", name));
-        try_help(app, &mut c);
-
-        Self::for_app(app, c, ErrorKind::UnrecognizedSubcommand, vec![subcmd])
+        let info = vec![subcmd.clone()];
+        let usage = format!("USAGE:\n    {} <subcommands>", name);
+        Self::new(ErrorKind::UnrecognizedSubcommand)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([
+                (ContextKind::InvalidSubcommand, ContextValue::String(subcmd)),
+                (ContextKind::Usage, ContextValue::String(usage)),
+            ])
     }
 
     pub(crate) fn missing_required_argument(
@@ -367,47 +395,33 @@ impl Error {
         required: Vec<String>,
         usage: String,
     ) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
-
-        start_error(
-            &mut c,
-            "The following required arguments were not provided:",
-        );
-
-        for v in &required {
-            c.none("\n    ");
-            c.good(&**v);
-        }
-
-        put_usage(&mut c, usage);
-        try_help(app, &mut c);
-
-        Self::for_app(app, c, ErrorKind::MissingRequiredArgument, required)
+        let info = required.clone();
+        Self::new(ErrorKind::MissingRequiredArgument)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([
+                (ContextKind::InvalidArg, ContextValue::Strings(required)),
+                (ContextKind::Usage, ContextValue::String(usage)),
+            ])
     }
 
     pub(crate) fn missing_subcommand(app: &App, name: String, usage: String) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
-
-        start_error(&mut c, "'");
-        c.warning(name);
-        c.none("' requires a subcommand, but one was not provided");
-        put_usage(&mut c, usage);
-        try_help(app, &mut c);
-
-        Self::for_app(app, c, ErrorKind::MissingSubcommand, vec![])
+        let info = vec![];
+        Self::new(ErrorKind::MissingSubcommand)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([
+                (ContextKind::InvalidSubcommand, ContextValue::String(name)),
+                (ContextKind::Usage, ContextValue::String(usage)),
+            ])
     }
 
     pub(crate) fn invalid_utf8(app: &App, usage: String) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
-
-        start_error(
-            &mut c,
-            "Invalid UTF-8 was detected in one or more arguments",
-        );
-        put_usage(&mut c, usage);
-        try_help(app, &mut c);
-
-        Self::for_app(app, c, ErrorKind::InvalidUtf8, vec![])
+        let info = vec![];
+        Self::new(ErrorKind::InvalidUtf8)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([(ContextKind::Usage, ContextValue::String(usage))])
     }
 
     pub(crate) fn too_many_occurrences(
@@ -417,42 +431,41 @@ impl Error {
         curr_occurs: usize,
         usage: String,
     ) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
-        let were_provided = Error::singular_or_plural(curr_occurs);
-        let arg = arg.to_string();
-        let max_occurs = max_occurs.to_string();
-        let curr_occurs = curr_occurs.to_string();
-
-        start_error(&mut c, "The argument '");
-        c.warning(&*arg);
-        c.none("' allows at most ");
-        c.warning(&*max_occurs);
-        c.none(" occurrences, but ");
-        c.warning(&*curr_occurs);
-        c.none(were_provided);
-        put_usage(&mut c, usage);
-        try_help(app, &mut c);
-
-        Self::for_app(
-            app,
-            c,
-            ErrorKind::TooManyOccurrences,
-            vec![arg, curr_occurs, max_occurs],
-        )
+        let info = vec![
+            arg.to_string(),
+            curr_occurs.to_string(),
+            max_occurs.to_string(),
+        ];
+        Self::new(ErrorKind::TooManyOccurrences)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([
+                (
+                    ContextKind::InvalidArg,
+                    ContextValue::String(arg.to_string()),
+                ),
+                (
+                    ContextKind::MaxOccurrences,
+                    ContextValue::Number(max_occurs as isize),
+                ),
+                (
+                    ContextKind::ActualNumValues,
+                    ContextValue::Number(curr_occurs as isize),
+                ),
+                (ContextKind::Usage, ContextValue::String(usage)),
+            ])
     }
 
     pub(crate) fn too_many_values(app: &App, val: String, arg: String, usage: String) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
-
-        start_error(&mut c, "The value '");
-        c.warning(&*val);
-        c.none("' was provided to '");
-        c.warning(&*arg);
-        c.none("' but it wasn't expecting any more values");
-        put_usage(&mut c, usage);
-        try_help(app, &mut c);
-
-        Self::for_app(app, c, ErrorKind::TooManyValues, vec![arg, val])
+        let info = vec![arg.to_string(), val.clone()];
+        Self::new(ErrorKind::TooManyValues)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([
+                (ContextKind::InvalidArg, ContextValue::String(arg)),
+                (ContextKind::InvalidValue, ContextValue::String(val)),
+                (ContextKind::Usage, ContextValue::String(usage)),
+            ])
     }
 
     pub(crate) fn too_few_values(
@@ -462,89 +475,40 @@ impl Error {
         curr_vals: usize,
         usage: String,
     ) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
-        let were_provided = Error::singular_or_plural(curr_vals);
-        let arg = arg.to_string();
-        let min_vals = min_vals.to_string();
-        let curr_vals = curr_vals.to_string();
-
-        start_error(&mut c, "The argument '");
-        c.warning(&*arg);
-        c.none("' requires at least ");
-        c.warning(&*min_vals);
-        c.none(" values, but only ");
-        c.warning(&*curr_vals);
-        c.none(were_provided);
-        put_usage(&mut c, usage);
-        try_help(app, &mut c);
-
-        Self::for_app(
-            app,
-            c,
-            ErrorKind::TooFewValues,
-            vec![arg, curr_vals, min_vals],
-        )
+        let info = vec![arg.to_string(), curr_vals.to_string(), min_vals.to_string()];
+        Self::new(ErrorKind::TooFewValues)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([
+                (
+                    ContextKind::InvalidArg,
+                    ContextValue::String(arg.to_string()),
+                ),
+                (
+                    ContextKind::MinValues,
+                    ContextValue::Number(min_vals as isize),
+                ),
+                (
+                    ContextKind::ActualNumValues,
+                    ContextValue::Number(curr_vals as isize),
+                ),
+                (ContextKind::Usage, ContextValue::String(usage)),
+            ])
     }
 
     pub(crate) fn value_validation(
-        app: &App,
-        arg: String,
-        val: String,
-        err: Box<dyn error::Error + Send + Sync>,
-    ) -> Self {
-        let mut err = Self::value_validation_with_color(
-            arg,
-            val,
-            err,
-            app.get_color(),
-            app.settings.is_set(AppSettings::WaitOnError),
-        );
-        match &mut err.inner.message {
-            Message::Raw(_) => {
-                unreachable!("`value_validation_with_color` only deals in formatted errors")
-            }
-            Message::Formatted(c) => try_help(app, c),
-        }
-        err
-    }
-
-    pub(crate) fn value_validation_without_app(
         arg: String,
         val: String,
         err: Box<dyn error::Error + Send + Sync>,
     ) -> Self {
-        let mut err = Self::value_validation_with_color(arg, val, err, ColorChoice::Never, false);
-        match &mut err.inner.message {
-            Message::Raw(_) => {
-                unreachable!("`value_validation_with_color` only deals in formatted errors")
-            }
-            Message::Formatted(c) => {
-                c.none("\n");
-            }
-        }
-        err
-    }
-
-    fn value_validation_with_color(
-        arg: String,
-        val: String,
-        err: Box<dyn error::Error + Send + Sync>,
-        color: ColorChoice,
-        wait_on_exit: bool,
-    ) -> Self {
-        let mut c = Colorizer::new(true, color);
-
-        start_error(&mut c, "Invalid value");
-
-        c.none(" for '");
-        c.warning(&*arg);
-        c.none("'");
-
-        c.none(format!(": {}", err));
-
-        Self::new(c, ErrorKind::ValueValidation, wait_on_exit)
-            .set_info(vec![arg, val, err.to_string()])
+        let info = vec![arg.to_string(), val.to_string(), err.to_string()];
+        Self::new(ErrorKind::ValueValidation)
+            .set_info(info)
             .set_source(err)
+            .extend_context_unchecked([
+                (ContextKind::InvalidArg, ContextValue::String(arg)),
+                (ContextKind::InvalidValue, ContextValue::String(val)),
+            ])
     }
 
     pub(crate) fn wrong_number_of_values(
@@ -554,41 +518,39 @@ impl Error {
         curr_vals: usize,
         usage: String,
     ) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
-        let were_provided = Error::singular_or_plural(curr_vals);
-        let arg = arg.to_string();
-        let num_vals = num_vals.to_string();
-        let curr_vals = curr_vals.to_string();
-
-        start_error(&mut c, "The argument '");
-        c.warning(&*arg);
-        c.none("' requires ");
-        c.warning(&*num_vals);
-        c.none(" values, but ");
-        c.warning(&*curr_vals);
-        c.none(were_provided);
-        put_usage(&mut c, usage);
-        try_help(app, &mut c);
-
-        Self::for_app(
-            app,
-            c,
-            ErrorKind::WrongNumberOfValues,
-            vec![arg, curr_vals, num_vals],
-        )
+        let info = vec![arg.to_string(), curr_vals.to_string(), num_vals.to_string()];
+        Self::new(ErrorKind::WrongNumberOfValues)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([
+                (
+                    ContextKind::InvalidArg,
+                    ContextValue::String(arg.to_string()),
+                ),
+                (
+                    ContextKind::ExpectedNumValues,
+                    ContextValue::Number(num_vals as isize),
+                ),
+                (
+                    ContextKind::ActualNumValues,
+                    ContextValue::Number(curr_vals as isize),
+                ),
+                (ContextKind::Usage, ContextValue::String(usage)),
+            ])
     }
 
     pub(crate) fn unexpected_multiple_usage(app: &App, arg: &Arg, usage: String) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
-        let arg = arg.to_string();
-
-        start_error(&mut c, "The argument '");
-        c.warning(&*arg);
-        c.none("' was provided more than once, but cannot be used multiple times");
-        put_usage(&mut c, usage);
-        try_help(app, &mut c);
-
-        Self::for_app(app, c, ErrorKind::UnexpectedMultipleUsage, vec![arg])
+        let info = vec![arg.to_string()];
+        Self::new(ErrorKind::UnexpectedMultipleUsage)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([
+                (
+                    ContextKind::InvalidArg,
+                    ContextValue::String(arg.to_string()),
+                ),
+                (ContextKind::Usage, ContextValue::String(usage)),
+            ])
     }
 
     pub(crate) fn unknown_argument(
@@ -597,69 +559,436 @@ impl Error {
         did_you_mean: Option<(String, Option<String>)>,
         usage: String,
     ) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
-
-        start_error(&mut c, "Found argument '");
-        c.warning(&*arg);
-        c.none("' which wasn't expected, or isn't valid in this context");
-
-        if let Some((flag, subcmd)) = did_you_mean {
-            let flag = format!("--{}", flag);
-            c.none("\n\n\tDid you mean ");
-
-            if let Some(subcmd) = subcmd {
-                c.none("to put '");
-                c.good(flag);
-                c.none("' after the subcommand '");
-                c.good(subcmd);
-                c.none("'?");
-            } else {
-                c.none("'");
-                c.good(flag);
-                c.none("'?");
+        let info = vec![arg.to_string()];
+        let mut err = Self::new(ErrorKind::UnknownArgument)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([
+                (ContextKind::InvalidArg, ContextValue::String(arg)),
+                (ContextKind::Usage, ContextValue::String(usage)),
+            ]);
+        if let Some((flag, sub)) = did_you_mean {
+            err = err.insert_context_unchecked(
+                ContextKind::SuggestedArg,
+                ContextValue::String(format!("--{}", flag)),
+            );
+            if let Some(sub) = sub {
+                err = err.insert_context_unchecked(
+                    ContextKind::SuggestedSubcommand,
+                    ContextValue::String(sub),
+                );
             }
         }
+        err
+    }
 
-        // If the user wants to supply things like `--a-flag` or `-b` as a value,
-        // suggest `--` for disambiguation.
-        if arg.starts_with('-') {
-            c.none(format!(
-                "\n\n\tIf you tried to supply `{}` as a value rather than a flag, use `-- {}`",
-                arg, arg
-            ));
-        }
-
-        put_usage(&mut c, usage);
-        try_help(app, &mut c);
+    pub(crate) fn unnecessary_double_dash(app: &App, arg: String, usage: String) -> Self {
+        let info = vec![arg.to_string()];
+        Self::new(ErrorKind::UnknownArgument)
+            .with_app(app)
+            .set_info(info)
+            .extend_context_unchecked([
+                (ContextKind::InvalidArg, ContextValue::String(arg)),
+                (ContextKind::TrailingArg, ContextValue::Bool(true)),
+                (ContextKind::Usage, ContextValue::String(usage)),
+            ])
+    }
 
-        Self::for_app(app, c, ErrorKind::UnknownArgument, vec![arg])
+    pub(crate) fn argument_not_found_auto(arg: String) -> Self {
+        let info = vec![arg.to_string()];
+        Self::new(ErrorKind::ArgumentNotFound)
+            .set_info(info)
+            .extend_context_unchecked([(ContextKind::InvalidArg, ContextValue::String(arg))])
     }
 
-    pub(crate) fn unnecessary_double_dash(app: &App, arg: String, usage: String) -> Self {
-        let mut c = Colorizer::new(true, app.get_color());
+    fn formatted(&self) -> Cow<'_, Colorizer> {
+        if let Some(message) = self.inner.message.as_ref() {
+            message.formatted()
+        } else {
+            let mut c = Colorizer::new(self.use_stderr(), self.inner.color_when);
 
-        start_error(&mut c, "Found argument '");
-        c.warning(&*arg);
-        c.none("' which wasn't expected, or isn't valid in this context");
+            start_error(&mut c);
+
+            if !self.write_dynamic_context(&mut c) {
+                if let Some(msg) = self.kind().as_str() {
+                    c.none(msg.to_owned());
+                } else if let Some(source) = self.inner.source.as_ref() {
+                    c.none(source.to_string());
+                } else {
+                    c.none("Unknown cause");
+                }
+            }
 
-        c.none(format!(
-            "\n\n\tIf you tried to supply `{}` as a subcommand, remove the '--' before it.",
-            arg
-        ));
-        put_usage(&mut c, usage);
-        try_help(app, &mut c);
+            let usage = self.get_context(ContextKind::Usage);
+            if let Some(ContextValue::String(usage)) = usage {
+                put_usage(&mut c, usage);
+            }
 
-        Self::for_app(app, c, ErrorKind::UnknownArgument, vec![arg])
+            try_help(&mut c, self.inner.help_flag);
+
+            Cow::Owned(c)
+        }
     }
 
-    pub(crate) fn argument_not_found_auto(arg: String) -> Self {
-        let mut c = Colorizer::new(true, ColorChoice::Never);
+    #[must_use]
+    fn write_dynamic_context(&self, c: &mut Colorizer) -> bool {
+        match self.kind() {
+            ErrorKind::ArgumentConflict => {
+                let invalid_arg = self.get_context(ContextKind::InvalidArg);
+                let prior_arg = self.get_context(ContextKind::PriorArg);
+                if let (Some(ContextValue::String(invalid_arg)), Some(prior_arg)) =
+                    (invalid_arg, prior_arg)
+                {
+                    c.none("The argument '");
+                    c.warning(invalid_arg);
+                    c.none("' cannot be used with");
+
+                    match prior_arg {
+                        ContextValue::Strings(values) => {
+                            c.none(":");
+                            for v in values {
+                                c.none("\n    ");
+                                c.warning(&**v);
+                            }
+                        }
+                        ContextValue::String(value) => {
+                            c.none(" '");
+                            c.warning(value);
+                            c.none("'");
+                        }
+                        _ => {
+                            c.none(" one or more of the other specified arguments");
+                        }
+                    }
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::EmptyValue => {
+                let invalid_arg = self.get_context(ContextKind::InvalidArg);
+                if let Some(ContextValue::String(invalid_arg)) = invalid_arg {
+                    c.none("The argument '");
+                    c.warning(invalid_arg);
+                    c.none("' requires a value but none was supplied");
+
+                    let possible_values = self.get_context(ContextKind::ValidValue);
+                    if let Some(ContextValue::Strings(possible_values)) = possible_values {
+                        c.none("\n\t[possible values: ");
+                        if let Some((last, elements)) = possible_values.split_last() {
+                            for v in elements {
+                                c.good(escape(v));
+                                c.none(", ");
+                            }
+                            c.good(escape(last));
+                        }
+                        c.none("]");
+                    }
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::NoEquals => {
+                let invalid_arg = self.get_context(ContextKind::InvalidArg);
+                if let Some(ContextValue::String(invalid_arg)) = invalid_arg {
+                    c.none("Equal sign is needed when assigning values to '");
+                    c.warning(invalid_arg);
+                    c.none("'.");
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::InvalidValue => {
+                let invalid_arg = self.get_context(ContextKind::InvalidArg);
+                let invalid_value = self.get_context(ContextKind::InvalidValue);
+                if let (
+                    Some(ContextValue::String(invalid_arg)),
+                    Some(ContextValue::String(invalid_value)),
+                ) = (invalid_arg, invalid_value)
+                {
+                    c.none(quote(invalid_value));
+                    c.none(" isn't a valid value for '");
+                    c.warning(invalid_arg);
+                    c.none("'");
+
+                    let possible_values = self.get_context(ContextKind::ValidValue);
+                    if let Some(ContextValue::Strings(possible_values)) = possible_values {
+                        c.none("\n\t[possible values: ");
+                        if let Some((last, elements)) = possible_values.split_last() {
+                            for v in elements {
+                                c.good(escape(v));
+                                c.none(", ");
+                            }
+                            c.good(escape(last));
+                        }
+                        c.none("]");
+                    }
+
+                    let suggestion = self.get_context(ContextKind::SuggestedValue);
+                    if let Some(ContextValue::String(suggestion)) = suggestion {
+                        c.none("\n\n\tDid you mean ");
+                        c.good(quote(suggestion));
+                        c.none("?");
+                    }
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::InvalidSubcommand => {
+                let invalid_sub = self.get_context(ContextKind::InvalidSubcommand);
+                if let Some(ContextValue::String(invalid_sub)) = invalid_sub {
+                    c.none("The subcommand '");
+                    c.warning(invalid_sub);
+                    c.none("' wasn't recognized");
+
+                    let valid_sub = self.get_context(ContextKind::SuggestedSubcommand);
+                    if let Some(ContextValue::String(valid_sub)) = valid_sub {
+                        c.none("\n\n\tDid you mean ");
+                        c.good(valid_sub);
+                        c.none("?");
+                    }
 
-        start_error(&mut c, "The argument '");
-        c.warning(&*arg);
-        c.none("' wasn't found\n");
+                    let suggestion = self.get_context(ContextKind::SuggestedCommand);
+                    if let Some(ContextValue::String(suggestion)) = suggestion {
+                        c.none(
+            "\n\nIf you believe you received this message in error, try re-running with '",
+        );
+                        c.good(suggestion);
+                        c.none("'");
+                    }
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::UnrecognizedSubcommand => {
+                let invalid_sub = self.get_context(ContextKind::InvalidSubcommand);
+                if let Some(ContextValue::String(invalid_sub)) = invalid_sub {
+                    c.none("The subcommand '");
+                    c.warning(invalid_sub);
+                    c.none("' wasn't recognized");
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::MissingRequiredArgument => {
+                let invalid_arg = self.get_context(ContextKind::InvalidArg);
+                if let Some(ContextValue::Strings(invalid_arg)) = invalid_arg {
+                    c.none("The following required arguments were not provided:");
+                    for v in invalid_arg {
+                        c.none("\n    ");
+                        c.good(&**v);
+                    }
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::MissingSubcommand => {
+                let invalid_sub = self.get_context(ContextKind::InvalidSubcommand);
+                if let Some(ContextValue::String(invalid_sub)) = invalid_sub {
+                    c.none("'");
+                    c.warning(invalid_sub);
+                    c.none("' requires a subcommand but one was not provided");
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::InvalidUtf8 => false,
+            ErrorKind::TooManyOccurrences => {
+                let invalid_arg = self.get_context(ContextKind::InvalidArg);
+                let actual_num_occurs = self.get_context(ContextKind::ActualNumOccurrences);
+                let max_occurs = self.get_context(ContextKind::MaxOccurrences);
+                if let (
+                    Some(ContextValue::String(invalid_arg)),
+                    Some(ContextValue::Number(actual_num_occurs)),
+                    Some(ContextValue::Number(max_occurs)),
+                ) = (invalid_arg, actual_num_occurs, max_occurs)
+                {
+                    let were_provided = Error::singular_or_plural(*actual_num_occurs as usize);
+                    c.none("The argument '");
+                    c.warning(invalid_arg);
+                    c.none("' allows at most ");
+                    c.warning(max_occurs.to_string());
+                    c.none(" occurrences but ");
+                    c.warning(actual_num_occurs.to_string());
+                    c.none(were_provided);
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::TooManyValues => {
+                let invalid_arg = self.get_context(ContextKind::InvalidArg);
+                let invalid_value = self.get_context(ContextKind::InvalidValue);
+                if let (
+                    Some(ContextValue::String(invalid_arg)),
+                    Some(ContextValue::String(invalid_value)),
+                ) = (invalid_arg, invalid_value)
+                {
+                    c.none("The value '");
+                    c.warning(invalid_value);
+                    c.none("' was provided to '");
+                    c.warning(invalid_arg);
+                    c.none("' but it wasn't expecting any more values");
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::TooFewValues => {
+                let invalid_arg = self.get_context(ContextKind::InvalidArg);
+                let actual_num_values = self.get_context(ContextKind::ActualNumValues);
+                let min_values = self.get_context(ContextKind::MinValues);
+                if let (
+                    Some(ContextValue::String(invalid_arg)),
+                    Some(ContextValue::Number(actual_num_values)),
+                    Some(ContextValue::Number(min_values)),
+                ) = (invalid_arg, actual_num_values, min_values)
+                {
+                    let were_provided = Error::singular_or_plural(*actual_num_values as usize);
+                    c.none("The argument '");
+                    c.warning(invalid_arg);
+                    c.none("' requires at least ");
+                    c.warning(min_values.to_string());
+                    c.none(" values but only ");
+                    c.warning(actual_num_values.to_string());
+                    c.none(were_provided);
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::ValueValidation => {
+                let invalid_arg = self.get_context(ContextKind::InvalidArg);
+                let invalid_value = self.get_context(ContextKind::InvalidValue);
+                if let (
+                    Some(ContextValue::String(invalid_arg)),
+                    Some(ContextValue::String(invalid_value)),
+                ) = (invalid_arg, invalid_value)
+                {
+                    c.none("Invalid value ");
+                    c.warning(quote(invalid_value));
+                    c.none(" for '");
+                    c.warning(invalid_arg);
+                    if let Some(source) = self.inner.source.as_deref() {
+                        c.none("': ");
+                        c.none(source.to_string());
+                    } else {
+                        c.none("'");
+                    }
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::WrongNumberOfValues => {
+                let invalid_arg = self.get_context(ContextKind::InvalidArg);
+                let actual_num_values = self.get_context(ContextKind::ActualNumValues);
+                let num_values = self.get_context(ContextKind::ExpectedNumValues);
+                if let (
+                    Some(ContextValue::String(invalid_arg)),
+                    Some(ContextValue::Number(actual_num_values)),
+                    Some(ContextValue::Number(num_values)),
+                ) = (invalid_arg, actual_num_values, num_values)
+                {
+                    let were_provided = Error::singular_or_plural(*actual_num_values as usize);
+                    c.none("The argument '");
+                    c.warning(invalid_arg);
+                    c.none("' requires ");
+                    c.warning(num_values.to_string());
+                    c.none(" values, but ");
+                    c.warning(actual_num_values.to_string());
+                    c.none(were_provided);
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::UnexpectedMultipleUsage => {
+                let invalid_arg = self.get_context(ContextKind::InvalidArg);
+                if let Some(ContextValue::String(invalid_arg)) = invalid_arg {
+                    c.none("The argument '");
+                    c.warning(invalid_arg.to_string());
+                    c.none("' was provided more than once, but cannot be used multiple times");
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::UnknownArgument => {
+                let invalid_arg = self.get_context(ContextKind::InvalidArg);
+                if let Some(ContextValue::String(invalid_arg)) = invalid_arg {
+                    c.none("Found argument '");
+                    c.warning(invalid_arg.to_string());
+                    c.none("' which wasn't expected, or isn't valid in this context");
+
+                    let valid_sub = self.get_context(ContextKind::SuggestedSubcommand);
+                    let valid_arg = self.get_context(ContextKind::SuggestedArg);
+                    match (valid_sub, valid_arg) {
+                        (
+                            Some(ContextValue::String(valid_sub)),
+                            Some(ContextValue::String(valid_arg)),
+                        ) => {
+                            c.none("\n\n\tDid you mean ");
+                            c.none("to put '");
+                            c.good(valid_arg);
+                            c.none("' after the subcommand '");
+                            c.good(valid_sub);
+                            c.none("'?");
+                        }
+                        (None, Some(ContextValue::String(valid_arg))) => {
+                            c.none("\n\n\tDid you mean '");
+                            c.good(valid_arg);
+                            c.none("'?");
+                        }
+                        (_, _) => {}
+                    }
 
-        Self::new(c, ErrorKind::ArgumentNotFound, false).set_info(vec![arg])
+                    let invalid_arg = self.get_context(ContextKind::InvalidArg);
+                    if let Some(ContextValue::String(invalid_arg)) = invalid_arg {
+                        if invalid_arg.starts_with('-') {
+                            c.none(format!(
+                                "\n\n\tIf you tried to supply `{}` as a value rather than a flag, use `-- {}`",
+                                invalid_arg, invalid_arg
+                            ));
+                        }
+
+                        let trailing_arg = self.get_context(ContextKind::TrailingArg);
+                        if trailing_arg == Some(&ContextValue::Bool(true)) {
+                            c.none(format!(
+                            "\n\n\tIf you tried to supply `{}` as a subcommand, remove the '--' before it.",
+                            invalid_arg
+                        ));
+                        }
+                    }
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::ArgumentNotFound => {
+                let invalid_arg = self.get_context(ContextKind::InvalidArg);
+                if let Some(ContextValue::String(invalid_arg)) = invalid_arg {
+                    c.none("The argument '");
+                    c.warning(invalid_arg.to_string());
+                    c.none("' wasn't found");
+                    true
+                } else {
+                    false
+                }
+            }
+            ErrorKind::DisplayHelp
+            | ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand
+            | ErrorKind::DisplayVersion
+            | ErrorKind::Io
+            | ErrorKind::Format => false,
+        }
     }
 
     /// Returns the singular or plural form on the verb to be based on the argument's value.
@@ -694,7 +1023,7 @@ impl error::Error for Error {
 impl Display for Error {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         // Assuming `self.message` already has a trailing newline, from `try_help` or similar
-        write!(f, "{}", self.inner.message.formatted())?;
+        write!(f, "{}", self.formatted())?;
         if let Some(backtrace) = self.inner.backtrace.as_ref() {
             writeln!(f)?;
             writeln!(f, "Backtrace:")?;
@@ -704,10 +1033,9 @@ impl Display for Error {
     }
 }
 
-fn start_error(c: &mut Colorizer, msg: impl Into<String>) {
+fn start_error(c: &mut Colorizer) {
     c.error("error:");
     c.none(" ");
-    c.none(msg);
 }
 
 fn put_usage(c: &mut Colorizer, usage: impl Into<String>) {
@@ -715,20 +1043,40 @@ fn put_usage(c: &mut Colorizer, usage: impl Into<String>) {
     c.none(usage);
 }
 
-fn try_help(app: &App, c: &mut Colorizer) {
+fn get_help_flag(app: &App) -> Option<&'static str> {
     if !app.settings.is_set(AppSettings::DisableHelpFlag) {
-        c.none("\n\nFor more information try ");
-        c.good("--help");
-        c.none("\n");
+        Some("--help")
     } else if app.has_subcommands() && !app.settings.is_set(AppSettings::DisableHelpSubcommand) {
+        Some("help")
+    } else {
+        None
+    }
+}
+
+fn try_help(c: &mut Colorizer, help: Option<&str>) {
+    if let Some(help) = help {
         c.none("\n\nFor more information try ");
-        c.good("help");
+        c.good(help);
         c.none("\n");
     } else {
         c.none("\n");
     }
 }
 
+fn quote(s: impl AsRef<str>) -> String {
+    let s = s.as_ref();
+    format!("{:?}", s)
+}
+
+fn escape(s: impl AsRef<str>) -> String {
+    let s = s.as_ref();
+    if s.contains(char::is_whitespace) {
+        quote(s)
+    } else {
+        s.to_owned()
+    }
+}
+
 #[derive(Clone, Debug)]
 pub(crate) enum Message {
     Raw(String),
@@ -743,9 +1091,10 @@ impl Message {
 
                 let mut message = String::new();
                 std::mem::swap(s, &mut message);
-                start_error(&mut c, message);
+                start_error(&mut c);
+                c.none(message);
                 put_usage(&mut c, usage);
-                try_help(app, &mut c);
+                try_help(&mut c, get_help_flag(app));
                 *self = Self::Formatted(c);
             }
             Message::Formatted(_) => {}
@@ -756,7 +1105,8 @@ impl Message {
         match self {
             Message::Raw(s) => {
                 let mut c = Colorizer::new(true, ColorChoice::Never);
-                start_error(&mut c, s);
+                start_error(&mut c);
+                c.none(s);
                 Cow::Owned(c)
             }
             Message::Formatted(c) => Cow::Borrowed(c),
diff --git a/src/parse/matches/arg_matches.rs b/src/parse/matches/arg_matches.rs
index 4f4b25b51c2..de66e9e19de 100644
--- a/src/parse/matches/arg_matches.rs
+++ b/src/parse/matches/arg_matches.rs
@@ -463,7 +463,7 @@ impl ArgMatches {
                 v, name, e
             );
 
-            Error::value_validation_without_app(name.to_string(), v.to_string(), message.into())
+            Error::value_validation(name.to_string(), v.to_string(), message.into())
         })
     }
 
@@ -551,7 +551,7 @@ impl ArgMatches {
             v.parse::<R>().map_err(|e| {
                 let message = format!("The argument '{}' isn't a valid value: {}", v, e);
 
-                Error::value_validation_without_app(name.to_string(), v.to_string(), message.into())
+                Error::value_validation(name.to_string(), v.to_string(), message.into())
             })
         })
         .collect()
diff --git a/src/parse/parser.rs b/src/parse/parser.rs
index e2b4f126165..ce64941a557 100644
--- a/src/parse/parser.rs
+++ b/src/parse/parser.rs
@@ -12,7 +12,6 @@ use os_str_bytes::RawOsStr;
 use crate::build::AppSettings as AS;
 use crate::build::{App, Arg, ArgSettings};
 use crate::error::Error as ClapError;
-use crate::error::ErrorKind;
 use crate::error::Result as ClapResult;
 use crate::mkeymap::KeyType;
 use crate::output::{fmt::Colorizer, Help, HelpWriter, Usage};
@@ -502,11 +501,7 @@ impl<'help, 'app> Parser<'help, 'app> {
         } else if self.is_set(AS::SubcommandRequiredElseHelp) {
             debug!("Parser::get_matches_with: SubcommandRequiredElseHelp=true");
             let message = self.write_help_err()?;
-            return Err(ClapError::new(
-                message,
-                ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand,
-                self.app.settings.is_set(AS::WaitOnError),
-            ));
+            return Err(ClapError::display_help_error(self.app, message));
         }
 
         Validator::new(self).validate(parse_state, subcmd_name.is_some(), matcher, trailing_values)
@@ -1579,7 +1574,7 @@ impl<'help, 'app> Parser<'help, 'app> {
 
         match Help::new(HelpWriter::Buffer(&mut c), self.app, &usage, use_long).write_help() {
             Err(e) => e.into(),
-            _ => ClapError::for_app(self.app, c, ErrorKind::DisplayHelp, vec![]),
+            _ => ClapError::display_help(self.app, c),
         }
     }
 
@@ -1589,7 +1584,7 @@ impl<'help, 'app> Parser<'help, 'app> {
         let msg = self.app._render_version(use_long);
         let mut c = Colorizer::new(false, self.color_help());
         c.none(msg);
-        ClapError::for_app(self.app, c, ErrorKind::DisplayVersion, vec![])
+        ClapError::display_version(self.app, c)
     }
 }
 
diff --git a/src/parse/validator.rs b/src/parse/validator.rs
index a1a61fc660b..a6eaef3085d 100644
--- a/src/parse/validator.rs
+++ b/src/parse/validator.rs
@@ -1,6 +1,6 @@
 // Internal
 use crate::build::{arg::PossibleValue, App, AppSettings as AS, Arg, ArgSettings};
-use crate::error::{Error, ErrorKind, Result as ClapResult};
+use crate::error::{Error, Result as ClapResult};
 use crate::output::Usage;
 use crate::parse::{ArgMatcher, MatchedArg, ParseState, Parser};
 use crate::util::Id;
@@ -60,11 +60,7 @@ impl<'help, 'app, 'parser> Validator<'help, 'app, 'parser> {
             && self.p.is_set(AS::ArgRequiredElseHelp)
         {
             let message = self.p.write_help_err()?;
-            return Err(Error::new(
-                message,
-                ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand,
-                self.p.is_set(AS::WaitOnError),
-            ));
+            return Err(Error::display_help_error(self.p.app, message));
         }
         self.validate_conflicts(matcher)?;
         if !(self.p.is_set(AS::SubcommandsNegateReqs) && is_subcmd || reqs_validated) {
@@ -148,11 +144,11 @@ impl<'help, 'app, 'parser> Validator<'help, 'app, 'parser> {
                 if let Err(e) = vtor(&*val.to_string_lossy()) {
                     debug!("error");
                     return Err(Error::value_validation(
-                        self.p.app,
                         arg.to_string(),
                         val.to_string_lossy().into_owned(),
                         e,
-                    ));
+                    )
+                    .with_app(self.p.app));
                 } else {
                     debug!("good");
                 }
@@ -163,11 +159,11 @@ impl<'help, 'app, 'parser> Validator<'help, 'app, 'parser> {
                 if let Err(e) = vtor(val) {
                     debug!("error");
                     return Err(Error::value_validation(
-                        self.p.app,
                         arg.to_string(),
                         val.to_string_lossy().into(),
                         e,
-                    ));
+                    )
+                    .with_app(self.p.app));
                 } else {
                     debug!("good");
                 }

diff --git a/tests/builder/subcommands.rs b/tests/builder/subcommands.rs
index e2ada13aad8..1077f512e55 100644
--- a/tests/builder/subcommands.rs
+++ b/tests/builder/subcommands.rs
@@ -511,7 +511,7 @@ fn subcommand_not_recognized() {
     assert!(utils::compare_output(
         app,
         "fake help",
-        "error:  The subcommand 'help' wasn't recognized
+        "error: The subcommand 'help' wasn't recognized
 
 USAGE:
     fake <subcommands>
diff --git a/tests/builder/validators.rs b/tests/builder/validators.rs
index 7c9e71d7725..04885707b06 100644
--- a/tests/builder/validators.rs
+++ b/tests/builder/validators.rs
@@ -41,7 +41,7 @@ fn test_validator_msg_newline() {
 
     assert!(
         err.to_string()
-            .contains("Invalid value for '<test>': invalid digit found in string"),
+            .contains("Invalid value \"f\" for '<test>': invalid digit found in string"),
         "{}",
         err
     );

{"basic": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "quoted_app_name": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "validators::test_validator_msg_newline": {"run": "PASS", "test": "FAIL", "fix": "PASS"}, "group_macro_set_multiple": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "group_macro": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "subcommands::subcommand_not_recognized": {"run": "PASS", "test": "FAIL", "fix": "PASS"}, "arg::short": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg_impl::string_literal": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "group_macro_set_not_multiple": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg::name_explicit": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "quoted_arg_name": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg::short_and_long": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg::name_from_long": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg_impl::string_ident": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg_impl::char_ident": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "quoted_arg_long_name": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "multiarg": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg_impl::char_literal": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg::positional": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "group_macro_set_not_required": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg::name_from_value": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "group_macro_set_required": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "example_tests": {"run": "PASS", "test": "NONE", "fix": "PASS"}}
{"tests::sc_long_flag_long_opt_eq_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_if_arg_present_no_default_user_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::allow_ext_sc_when_sc_required": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_aliases::multiple_aliases_of_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "indices::indices_mult_opts": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "groups::req_group_usage_string": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::conflict_overridden": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "propagate_globals::global_arg_used_outer": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::infer_subcommands_fail_with_args2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::single_alias": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::no_propagation_by_default_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::multi_level_sc_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long1": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_ifs_wrong_val_mult_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::override_help_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "output::help::test::display_width_handles_emojis": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_long_with_alias": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::single_arg_help_with_long_format_setting": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both4": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::no_bin_name": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::conflict_output_rev_with_required": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::help_about_multi_subcmd_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "parse::matches::matched_arg::tests::test_grouped_vals_push_and_append": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::lots_o_vals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::opts_using_long_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::version_flag_from_long_version_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "groups::group_multiple_args_error": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_missing_vals::opt_default": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::option_display_multiple_values": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::option_overrides_itself": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::mut_version_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "template_help::template_unknowntag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_missing_vals::opt_present_with_empty_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "parse::matches::arg_matches::tests::test_default_values_with_shorter_lifetime": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_if_arg_present_with_default_user_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::missing_possible_value_error": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::list_correct_required_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::default_values_user_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_strict_option_short_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::no_default_ifs_arg_present": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::aliases": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::positional_required_with_requires_if_no_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::positional_min_less": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "template_help::template_notag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::option_display2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::low_index_positional_with_option": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::arg_require_group_3": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::low_index_positional_in_subcmd": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::use_long_format_for_help_subcommand_with_setting": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::subcommand_after_argument": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_occurrences::multiple_occurrences_of_flags_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "validators::test_validator_fromstr_trait": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "delimiters::opt_s_no_space_mult_no_delim": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::req_delimiter_short_with_no_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::subcommand_help_rev": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::single_positional_usage_string": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::no_auto_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::multiple_vals_pos_arg_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::infer_long_arg": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg_group::test::groups": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_missing_vals::opt_present_with_missing_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::values_per_occurrence_named": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::option_short_min_more_mult_occurs": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::infer_subcommands_fail_no_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_short_with_aliases_vis_and_hidden": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_aliases::invisible_arg_aliases_help_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::issue_626_unicode_cutoff": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::osstr_positionals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::last_arg_mult_usage_req_with_sc": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_unless_any_err": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_option_long_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg_group::test::arg_group_send_sync": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::sub_command_required": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "propagate_globals::global_arg_used_inner": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_ifs_val_present_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::conflict_output_with_required": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both5": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::issue_2624": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::conflicts_with_alongside_default": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "hidden_args::hide_subcmds_only": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::group_required_3": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::propagate_vals_down": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_normal": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "template_help::template_empty": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_missing_vals::default_missing_value_flag_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "ignore_errors::multiple_args_and_final_arg_without_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::sep_long_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "template_help::custom_template": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "global_args::propagate_global_arg_in_subcommand_to_subsubcommand_1385": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::opts_using_long_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_short_with_aliases": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_aliases::single_alias_of_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "ignore_errors::single_long_arg_without_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "error::app_error": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long_equals9": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "propagate_globals::global_flag_used_outer": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_ifs_wrong_val": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_unless_any_works_without": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::subcmd_did_you_mean_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::refuse_invalid_utf8_subcommand_when_args_are_allowed_with_allow_external_subcommands": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::issue_1158_conflicting_requirements_rev": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_with_vals1_def": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flags::flag_using_mixed": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::help_subcommand": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_short_flag_x2_short_opt_eq_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::option_max_exact": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::possible_values_of_positional_multiple": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::issue_688_hide_pos_vals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::delim_values_trailingvararg_with_delim": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long9": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::require_eq": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::allow_invalid_utf8_subcommand_args_with_allow_external_subcommands": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::opts_using_mixed": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_long_infer_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::conflict_overridden_3": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "hidden_args::hide_short_args_long_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both_equals2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::option_exact_exact_mult": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::requires_if_present_mult_pass": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::positional_multiple": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::help_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::after_and_before_long_help_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::mult_option_require_delim_overrides_itself": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::positional_display_multiple_values": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "delimiters::opt_s_default_no_delim": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_lossy_option_long_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::lots_o_vals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::opts_using_mixed2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::tests::arg_send_sync": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::leading_hyphen_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::unset_on_global_setting": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_long_infer_pass_close": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::issue_1642_long_help_spacing": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_with_vals1": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "parse::matches::arg_matches::tests::values_exact_size": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::possible_values_of_option": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::value_names_building_num_vals_for_positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::long_flag_long_opt_eq_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_long_infer_exact_match": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long_equals8": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::no_propagation_by_default_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_vals_donnot_show_in_smart_usage": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_strict_option_long_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::flag_required_2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::issue_1158_conflicting_requirements": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both8": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::positional_required_with_requires": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flags::issue_2308_multiple_dashes": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::pos_req": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_if_arg_present_no_arg_with_default": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::aaos_opts_w_other_overrides_rev_2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both_equals4": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "empty_values::no_empty_values_without_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "parse::matches::arg_matches::tests::test_default_indices_with_shorter_lifetime": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_unless_present_with_optional_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::long_about": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_short_flag_short_opt_eq_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_if_arg_present_with_value_no_arg_with_default_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "groups::req_group_with_conflict_usage_string": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::require_equals_empty_vals_pass": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_short_flag_x2_comb_short_opt_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flags::flag_using_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::arg_required_else_help_error_message": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_flag_usage": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::leading_hyphen_with_flag_after": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "parse::matches::arg_matches::tests::indices_exact_size": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::issue_1050_num_vals_and_defaults": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_unless_any_1": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::multiple_required_unless_usage_printing": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "propagate_globals::global_arg_default_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::possible_values_hidden_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::after_help_no_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::missing_required_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "output::help::test::display_width_handles_non_ascii": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_occurrences::multiple_occurrences_of_flags_large_quantity": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_long_with_aliases": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long3": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::conflict_overridden_4": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::flag_display": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::positional_possible_values": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::disabled_help_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::multiple_defaults": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::option_exact_exact": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::flag_required": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::infer_subcommands_fail_with_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "parse::matches::arg_matches::tests::os_values_exact_size": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "derive_order::derive_order": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_aliases_short::visible_short_arg_aliases_help_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::osstr_positional_user_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::req_delimiter_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::override_version_short_with_user_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::osstr_opts": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::positional_display_multiple_occurrences": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "global_args::issue_1076": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::custom_help_headers_hide_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::issue_1487": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::flag_x2_opt": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_short_flag_short_opt_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::help_required_locally_but_not_given_for_subcommand": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::help_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::aaos_option_use_delim_false": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::req_delimiter_short_with_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long_equals10": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_if_arg_present_with_value_with_default": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::issue_1480_max_values_consumes_extra_arg_3": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_unless_any_2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::arg_required_else_help_over_reqs": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::setting": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "indices::indices_mult_flags": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::arg_conflicts_with_group_with_multiple_sources": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::posix_compatible_flags_long_rev": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::require_eq_filtered_group": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "delimiters::opt_s_no_space_no_delim": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::option_required": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_with_vals3": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::require_overridden_3": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long_equals1": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::pos_mult_overrides_itself": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_long_infer_pass": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::aaos_opts_w_other_overrides_rev": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long8": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "empty_values::empty_values": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::aaos_opts_w_other_overrides": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_short_with_alias": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::option_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "display_order::very_large_display_order": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_with_vals4": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::override_help_subcommand": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::req_delimiter_long_with_equal": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "groups::required_group_multiple_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_positional_usage": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "ignore_errors::subcommand": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::long_eq_val_starts_with_eq": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::subcommand_after_argument_looks_like_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_short_flag_x2_long_opt_eq_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::app::tests::propagate_version": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "hidden_args::hide_subcmds": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::override_help_flag_using_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::subcmd_did_you_mean_output_arg_false_positives": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "hidden_args::hide_pos_args_only": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::issue_1105_empty_value_short_explicit_no_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::allow_invalid_utf8_value_of_os": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long7": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "propagate_globals::global_flag_2x_used_top_level": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "groups::group_single_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_aliases_short::multiple_short_aliases_of_option": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::option_display_single_short_alias": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::create_positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::subcommand_none_given": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage4": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::allow_invalid_utf8_external_subcommand_values_of_os": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::option_mixed": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::short_opt_x2_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::group_conflicts_with_arg": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::no_default_if_arg_present_with_value_with_default_user_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::setting_bitor": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::infer_subcommands_fail_suggestions": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::three_conflicting_arguments": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::posix_compatible_opts_long_rev": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_long_flag_short_opt_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::aaos_flags": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::refuse_invalid_utf8_subcommand_args_with_allow_external_subcommands": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::double_hyphen_as_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "parse::matches::matched_arg::tests::test_grouped_vals_first": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::issue_1722_not_emit_error_when_arg_follows_similar_to_a_subcommand": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "hidden_args::hide_long_args_short_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::arg_require_group_2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage3": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::option_use_delim_false_override_itself": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::aaos_opts": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage5": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::unset_setting": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "parse::matches::arg_matches::tests::test_default_osvalues": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both_equals6": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::short_flag_short_opt_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::flag_conflict_2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::option_exact_less": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::missing_positional_hyphen": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "empty_values::no_empty_values_without_equals_but_requires_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::app::tests::app_send_sync": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::possible_values_of_option_multiple_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::positional_multiple_2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::old_newline_chars": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_occurrences::multiple_occurrences_of_positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_strict_option_long_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::require_equals_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg_group::test::test_from": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::missing_positional_hyphen_req_error": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::arg_required_else_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::disable_help_flag_affects_help_subcommand": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::conflict_overridden_2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::global_setting": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::issue_1480_max_values_consumes_extra_arg_2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::dont_delim_values_trailingvararg": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::positional_exact_less": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::prefer_user_subcmd_help_short_1112": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::missing_positional_final_required": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::flag_display_single_short_alias": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::issue_1031_args_with_same_name": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long_equals2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::propagate_version_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::refuse_invalid_utf8_subcommand_with_allow_external_subcommands": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::sep_short_no_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::no_auto_version_mut_arg": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::positional_max_exact": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::requires_if_present_mult": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::delim_values_trailingvararg": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::issue_1437_allow_hyphen_values_for_positional_arg": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::override_help_flag_using_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "groups::group_empty": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_option_short_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::override_version_long_with_user_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::allow_negative_numbers": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::missing_positional_hyphen_far_back": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::last_arg_mult_usage_with_sc": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "hidden_args::hide_pos_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_unless_present_all": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::option_display_multiple_occurrences": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "derive_order::prefer_user_help_in_subcommand_with_derive_order": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::opts_using_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_conflict_with_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_long_flag_long_opt": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::positional_required_2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "empty_values::no_empty_values_with_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::positional_required": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::complex_subcommand_help_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::multiple_defaults_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both_equals1": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::short_eq_val_starts_with_eq": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::complex_help_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "propagate_globals::global_flag_used_top_level": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_if_val_present_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::hide_possible_vals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::require_eq": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::positional_min_more": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::issue_1052_require_delim_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_with_vals4_def": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "delimiters::opt_s_eq_no_delim": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_unless_any_works_with_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::allow_validated_utf8_external_subcommand_values_of": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "global_args::global_arg_available_in_subcommand": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::prefer_user_subcmd_help_long_1112": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::positional_multiple_3": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::subcommand_display_order": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_long_short_normal_usage_string": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::issue_1794_usage": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::option_display3": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::app::tests::global_setting": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::allow_missing_positional_no_default": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::issue_1066_allow_leading_hyphen_and_unknown_args_no_vals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::option_usage_order": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_if_arg_present_with_value_with_default_user_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::opt_user_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::option_min_less": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_missing_vals::opt_missing": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::missing_with_value_delimiter": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "indices::indices_mult_flags_combined": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_aliases_short::single_short_alias_of_option": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::aaos_opts_w_other_overrides_2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "groups::req_group_with_conflict_usage_string_only_options": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::hide_default_val": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::subcommand_short_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_missing_vals::opt_present_with_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "hidden_args::hide_long_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::args_negate_subcommands_one_level": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "parse::matches::matched_arg::tests::test_grouped_vals_removal": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::leading_hyphen_opt": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::nested_help_subcommand_with_global_setting": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::opts": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::mut_arg_version_no_auto_version": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::number_of_values_preferred_over_value_names": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::only_custom_heading_opts_no_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_if_arg_present_with_default": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::leading_hyphen_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::last_arg_mult_usage": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::last_arg_mult_usage_req": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_settings::unset_setting": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::req_last_arg_usage": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::issue_1093_allow_ext_sc": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flags::flag_using_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "groups::group_usage_use_val_name": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long6": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "empty_values::empty_values_with_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::issue_753": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::posix_compatible_flags_short_rev": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::possible_values_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::propagate_version_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::require_equals_pass": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_if_val_present_fail_error_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::issue_2279": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_unless_err": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_normal_with_alias": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::leading_hyphen_with_only_pos_follows": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::external_subcommand_looks_like_built_in": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::subcommand_placeholder_test": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::leading_hyphen_pass": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::aaos_pos_mult": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::option_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::flag_conflict_with_everything": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::add_multiple_arg": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::custom_headers_headers": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_unless_any_works_with_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_short_flag_x2_comb_short_opt_eq_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::subcommand_long_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::positional_multiple_occurrences_is_dotted": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::require_overridden_2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::issue_1031_args_with_same_name_no_more_vals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::args_negate_subcommands_two_levels": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::positional_max_less": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::require_overridden_4": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_option_short_no_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::subcommand": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::option_display_single_alias": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_lossy_positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::possible_values_of_positional_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::posix_compatible_opts_long_equals_rev": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "ignore_errors::multiple_args_and_intermittent_arg_without_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_aliases::alias_on_a_subcommand_option": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::short_non_ascii_no_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::override_help_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::pos_help_newline_lit_sq": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::final_word_wrapping": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::sep_short_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::option_exact_more": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_long_flag_x2_long_opt_eq_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "derive_order::prefer_user_help_with_derive_order": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::arg_require_group": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flags::lots_o_flags_sep": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::possible_values_of_option_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_occurrences::max_occurrences_positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both1": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::issue_1374_overrides_self_with_multiple_values": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::infer_subcommands_pass_exact_match": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::positional_max_more": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_if_val_present_ignore_case_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::option_short_min_more_single_occur": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::conflict_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::help_required_and_given": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::posix_compatible_opts_short_rev": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "borrowed::borrowed_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_unless_all_with_any": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::override_version_long_with_user_flag_no_version_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::aaos_opts_mult": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::version_flag_from_version_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_short_flag_x2_comb_long_opt_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::ignore_case_multiple": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::multiple_vals_pos_arg_delim": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "groups::empty_group": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::nonascii": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::delim_values_only_pos_follows_with_delim": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::issue_626_variable_panic": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::ripgrep_usage": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::require_delims": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::req_delimiter_complex": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flags::issue_1284_argument_in_flag_style": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both6": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::prefer_about_over_long_about_in_subcommands_list": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::positional_display_val_names": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_missing_vals::opt_default_user_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "indices::indices_mult_flags_opt_combined_eq": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_settings::unset_setting_bitor": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::flag_display_multiple_aliases": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage8": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "output::help::test::wrap_help_last_word": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::pos_help_double_lit_single_quote": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_lossy_option_long_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::sep_short_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::stop_delim_values_only_pos_follows": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::positional_min_exact": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::no_wrap_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::issue_1643_args_mutually_require_each_other": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::possible_values_of_option_multiple": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "double_require::no_duplicate_error": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_occurrences::max_occurrences_implies_multiple_occurrences": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::possible_value_arg_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_aliases::single_alias_of_option": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::app::tests::issue_2090": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::long_opt_x2_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::possible_values_alias_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::version_about_multi_subcmd": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "indices::indices_mult_opt_value_no_delim_eq": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::issue_1105_empty_value_long_explicit": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::subcommand_required_else_help_error_message": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::mult_flag_overrides_itself": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::stdin_char": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::posix_compatible_opts_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::issue_1364_no_short_options": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_short_flag_x2_comb_long_opt_eq_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::wrapping_newline_chars": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::override_version_short_with_user_flag_long_still_works": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_if_wrong_val": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_option_long_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::different_sep": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::issue_1066_allow_leading_hyphen_and_unknown_args_option": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "global_args::propagate_global_arg_to_subcommand_in_subsubcommand_2053": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::conflict_with_unused_default": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::issue_1480_max_values_consumes_extra_arg_1": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::positional_exact_exact": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_short_flag_long_opt_eq_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::positional_display_val_names_req": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_aliases_short::short_alias_on_a_subcommand_option": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "groups::group_single_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::prefer_user_help_short_1112": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::requires_if_present_val_no_present_pass": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::old_newline_variables": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::flag_conflict_with_all": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_short_with_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::require_eq_filtered": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_unless_present_any": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "error::argument_not_found_auto_has_newline": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::issue_777_wrap_all_things": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_with_vals2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::subcommand_required_else_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::infer_subcommands_pass_close": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flags::flag_using_long_with_literals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::issue_1105_empty_value_long_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "indices::indices_mult_opt_mult_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::req_delimiter_short_with_equal": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::issue_1105_empty_value_short_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_option_short_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::group_required": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::long_opt_eq_x2_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "hidden_args::hide_opt_args_only": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "hidden_args::hide_short_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "propagate_globals::global_arg_used_top_level": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_settings::setting_bitor": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::multiple_aliases": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::disable_help_subcommand": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_long_normal_usage_string": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::posix_compatible_flags_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flags::lots_o_flags_combined": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_settings::setting": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "derive_order::no_derive_order": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::multiple_value_terminator_option_other_arg": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_occurrences::max_occurrences_try_inputs": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage1": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::pos_req_mult_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::pos_req_mult_def_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_if_some_values_present_pass": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "indices::indices_mult_flags_opt_combined": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::issue_2022_get_flags_misuse": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::args_with_last_usage": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_occurrences::multiple_occurrences_of_flags_mixed": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_if_arg_present_with_value_no_arg_with_default": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_if_any_all_values_present_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::sc_negates_reqs": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::option_required_2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_short_with_alias_same_as_short_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_if_arg_present_no_arg_with_value_with_default_user_override_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_ifs_val_present_pass": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "empty_values::no_empty_values": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::multiple_positional_one_required_usage_string": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "groups::group_acts_like_arg": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "propagate_globals::global_flag_2x_used_inner": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::mut_arg_all": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long_equals5": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::issue_1047_min_zero_vals_default_val": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::flag_overrides_itself": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::osstr_opt_user_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "indices::index_flags": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::subcmd_did_you_mean_output_arg": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::require_equals_min_values_zero": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_ifs_arg_present_order": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_conflict_with_version": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::no_sep": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::positional_required_with_requires_if_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage9": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::multiple_custom_help_headers": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_if_arg_present_no_default": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::flag_display_single_alias": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "groups::group_multi_value_single_arg": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::issue_2229": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_if_arg_present_no_arg_with_value_with_default_user_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_strict_positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::arg_conflicts_with_required_group": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::override_help_about": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::sep_positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::pos_help_lit_single_quote": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::group_required_2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::mult_option_overrides_itself": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long_equals7": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::short_opt_eq_x2_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::aaos_opts_mult_req_delims": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both7": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::option_max_more": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::no_auto_version": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::incremental_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_lossy_option_short_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "double_require::help_text": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::positional_exact_more": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::leading_double_hyphen_trailingvararg": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::issue_2508_number_of_values_with_single_value_name": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_if_val_present_pass": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::sub_command_negate_required_2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::issue_626_panic": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::did_you_mean": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::require_delims_no_delim": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::ignore_hyphen_values_on_last": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::last_positional_second_to_last_mult": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::low_index_positional_with_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flags::multiple_flags_in_single": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_aliases_short::single_short_alias_of_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_with_vals5": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "delimiters::opt_default_no_delim": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::help_subcmd_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::no_wrap_default_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::show_long_about_issue_897": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_short_flag_long_opt_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::issue_2494_subcommand_is_present": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_if_arg_present_with_value_no_default": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::with_value_delimiter": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::sub_command_negate_required": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::short_flag_x2_comb_short_opt_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::only_custom_heading_pos_no_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::single_positional_required_usage_string": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_aliases::visible_arg_aliases_help_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_ifs_arg_present_user_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_aliases::multiple_aliases_of_option": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::issue_1571": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_if_arg_present_with_value_no_default_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage0": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_short_flag_x2_long_opt_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::required_group_conflicts_with_arg": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::multiple_positional_usage_string": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::subcmd_help_subcmd_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_lossy_option_short_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long_equals4": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::flag_conflict": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::leading_hyphen_with_flag_before": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_lossy_option_short_no_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::dont_collapse_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "validators::stateful_validator": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::subcommand_multiple": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_long_flag_x2_short_opt_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::conflict_output_three_conflicting": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::missing_positional_final_multiple": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::value_names_building_num_vals_from_usage": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::subcommand_help_doesnt_have_useless_help_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_positional_usage0": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_if_all_values_present_pass": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "groups::group_reqired_flags_empty": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::allow_missing_positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::no_default_if_arg_present_no_arg_with_value_with_default": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::value_names_building_num_vals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::custom_heading_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::issue_1066_allow_leading_hyphen_and_unknown_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::multiple_value_terminator_option": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_long_flag_x2_long_opt_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::requires_if_present_val": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_ifs_arg_present": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_strict_option_short_no_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::different_sep_positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_short_normal_usage_string": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::delim_values_only_pos_follows": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::args_negate_sc": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "double_require::valid_cases": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "template_help::template_author_version": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::pos_help_newline": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::single_positional_multiple_usage_string": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "parse::matches::arg_matches::tests::test_default_indices": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::posix_compatible_opts_long_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::version_flag_from_version_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long10": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::wrapping_newline_variables": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "derive_order::derive_order_subcommand_propagate": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::subcmd_did_you_mean_output_ambiguous": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::option_min_exact": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::flag_display_multiple_short_aliases": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "groups::required_group_missing_arg": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both_equals8": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_unless_any_works_with_short_err": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::ignore_case": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::values_per_occurrence_positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "template_help::with_template": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both3": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::alias_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::positionals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::require_equals_no_empty_values_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::version_flag_from_long_version_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::infer_subcommands_pass": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::sep_long_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::arg_conflicts_with_group": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::unset_global_setting": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::prefer_user_help_long_1112": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both_equals3": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both_equals7": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "error::value_validation_has_newline": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::help_about_multi_subcmd": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::long_flag_long_opt_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::possible_values_of_positional_multiple_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::escaped_whitespace_values": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_long_with_alias_same_as_long_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::issue_1105_empty_value_long_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::positional_user_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "parse::matches::arg_matches::tests::test_default_osvalues_with_shorter_lifetime": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::last_positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::ignore_invalid_utf8_with_defaults": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long4": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_if_all_values_present_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::option_exact_exact_not_mult": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::dont_propagate_version_to_help_subcommand": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::option_display_multiple_short_aliases": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::leading_hyphen_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::escaped_possible_values_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::skip_possible_values": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::ripgrep_usage_using_templates": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::issue_1073_suboptimal_flag_suggestion": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_occurrences::multiple_occurrences_of_flags_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::positional_hyphen_does_not_panic": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::issue_702_multiple_values": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::only_pos_follow": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::disabled_help_flag_and_subcommand": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::conflict_output_rev": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::missing_positional_no_hyphen": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "delimiters::opt_eq_mult_def_delim": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::mut_version_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "conflicts::two_conflicting_arguments": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "indices::index_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long_equals6": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_unless_present": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::no_version_flag_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::positional_display_required": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::help_no_subcommand": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::possible_values_of_positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::multiple_vals_with_hyphen": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_if_val_present_ignore_case_pass": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::show_short_about_issue_897": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::issue_1105_empty_value_short_explicit": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_strict_option_short_space": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::pos_required_overridden_by_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long_equals3": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "derive_order::derive_order_subcommand_propagate_with_explicit_display_order": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::ignore_validated_utf8_with_defaults": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::last_positional_no_double_dash": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::low_index_positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::allow_validated_utf8_value_of": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_both_equals5": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage7": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "indices::index_mult_opts": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::arg::test::option_display_multiple_aliases": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::posix_compatible_flags_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::short_flag_require_equals_with_minvals_zero": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::create_app": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::no_default_if_arg_present_with_value_no_default": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "posix_compatible::posix_compatible_opts_long": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_if_arg_present_with_value_no_default_user_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::option_max_less": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_if_any_all_values_present_pass": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::issue_1161_multiple_hyphen_hyphen": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "hidden_args::hide_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::require_equals_fail_message": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::subcommand_used_after_double_dash": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::pos_mult_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "indices::indices_mult_opt_value_delim_eq": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "require::required_unless_all_err": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::after_and_before_help_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_short_flag_x2_short_opt_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::arg_short_conflict_with_help": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::hide_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_short_after_long_arg": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::help_required_and_no_args": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_aliases_short::invisible_short_arg_aliases_help_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "ignore_errors::single_short_arg_without_value": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::visible_aliases_help_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::allow_negative_numbers_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::issue_760": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::pos_mult": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::issue_946": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "arg_aliases_short::multiple_short_aliases_of_flag": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "flag_subcommands::flag_subcommand_multiple": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::hide_single_possible_val": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::aaos_flags_mult": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::default_if_arg_present_no_arg_with_default_user_override": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::issue_665": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::alias": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::ignore_case_multiple_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "possible_values::ignore_case_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::positional_multiple_values_is_dotted": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage_long5": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "positionals::missing_required_2": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "delimiters::opt_eq_no_delim": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::opt_without_value_fail": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "subcommands::invisible_aliases_help_output": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_values::no_sep_positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::no_default_if_arg_present_with_value_with_default": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "version::no_version_flag_short": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "default_vals::conditional_reqs_pass": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::issue_1046_hide_scs": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "propagate_globals::global_flag_used_inner": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::unset_setting_bitor": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::app::tests::global_settings": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "build::usage_parser::test::create_option_usage6": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "help::help_required_and_given_for_subcommand": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "opts::issue_1105_empty_value_short_equals": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "utf8::invalid_utf8_positional": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "tests::sc_long_flag_x2_short_opt_eq_pos": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "parse::matches::arg_matches::tests::test_default_values": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "app_settings::color_is_global": {"run": "PASS", "test": "PASS", "fix": "PASS"}}
{"validators::test_validator_msg_newline": {"run": "PASS", "test": "FAIL", "fix": "PASS"}, "subcommands::subcommand_not_recognized": {"run": "PASS", "test": "FAIL", "fix": "PASS"}}
{"basic": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "quoted_app_name": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "group_macro_set_multiple": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "group_macro": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg::short": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg_impl::string_literal": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "group_macro_set_not_multiple": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg::name_explicit": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "quoted_arg_name": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg::short_and_long": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg::name_from_long": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg_impl::string_ident": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg_impl::char_ident": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "quoted_arg_long_name": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "multiarg": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg_impl::char_literal": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg::positional": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "group_macro_set_not_required": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "arg::name_from_value": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "group_macro_set_required": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "example_tests": {"run": "PASS", "test": "NONE", "fix": "PASS"}}
{"passed_count": 828, "failed_count": 0, "skipped_count": 0, "passed_tests": ["tests::sc_long_flag_long_opt_eq_pos", "default_vals::default_if_arg_present_no_default_user_override", "app_settings::allow_ext_sc_when_sc_required", "arg_aliases::multiple_aliases_of_flag", "indices::indices_mult_opts", "basic", "groups::req_group_usage_string", "posix_compatible::conflict_overridden", "propagate_globals::global_arg_used_outer", "build::usage_parser::test::create_option_usage2", "build::usage_parser::test::create_option_usage_both2", "app_settings::infer_subcommands_fail_with_args2", "subcommands::single_alias", "version::no_propagation_by_default_long", "help::multi_level_sc_help", "build::usage_parser::test::create_option_usage_long1", "require::required_ifs_wrong_val_mult_fail", "help::override_help_long", "output::help::test::display_width_handles_emojis", "flag_subcommands::flag_subcommand_long_with_alias", "app_settings::single_arg_help_with_long_format_setting", "build::usage_parser::test::create_option_usage_both4", "app_settings::no_bin_name", "conflicts::conflict_output_rev_with_required", "help::help_about_multi_subcmd_override", "parse::matches::matched_arg::tests::test_grouped_vals_push_and_append", "opts::lots_o_vals", "opts::opts_using_long_space", "version::version_flag_from_long_version_short", "groups::group_multiple_args_error", "default_missing_vals::opt_default", "build::arg::test::option_display_multiple_values", "posix_compatible::option_overrides_itself", "version::mut_version_short", "template_help::template_unknowntag", "default_missing_vals::opt_present_with_empty_value", "parse::matches::arg_matches::tests::test_default_values_with_shorter_lifetime", "default_vals::default_if_arg_present_with_default_user_override", "possible_values::missing_possible_value_error", "require::list_correct_required_args", "opts::default_values_user_value", "utf8::invalid_utf8_strict_option_short_equals", "default_vals::no_default_ifs_arg_present", "possible_values::aliases", "require::positional_required_with_requires_if_no_value", "multiple_values::positional_min_less", "template_help::template_notag", "build::arg::test::option_display2", "multiple_values::low_index_positional_with_option", "require::arg_require_group_3", "quoted_app_name", "multiple_values::low_index_positional_in_subcmd", "positionals::positional", "app_settings::use_long_format_for_help_subcommand_with_setting", "subcommands::subcommand_after_argument", "multiple_occurrences::multiple_occurrences_of_flags_short", "validators::test_validator_fromstr_trait", "delimiters::opt_s_no_space_mult_no_delim", "multiple_values::req_delimiter_short_with_no_space", "help::subcommand_help_rev", "positionals::single_positional_usage_string", "app_settings::no_auto_help", "opts::multiple_vals_pos_arg_equals", "opts::infer_long_arg", "validators::test_validator_msg_newline", "build::arg_group::test::groups", "default_missing_vals::opt_present_with_missing_value", "multiple_values::values_per_occurrence_named", "group_macro_set_multiple", "multiple_values::option_short_min_more_mult_occurs", "app_settings::infer_subcommands_fail_no_args", "flag_subcommands::flag_subcommand_short_with_aliases_vis_and_hidden", "arg_aliases::invisible_arg_aliases_help_output", "help::issue_626_unicode_cutoff", "default_vals::osstr_positionals", "help::last_arg_mult_usage_req_with_sc", "require::required_unless_any_err", "utf8::invalid_utf8_option_long_equals", "build::arg_group::test::arg_group_send_sync", "app_settings::sub_command_required", "propagate_globals::global_arg_used_inner", "require::required_ifs_val_present_fail", "conflicts::conflict_output_with_required", "build::usage_parser::test::create_option_usage_both5", "flag_subcommands::flag_subcommand_short", "require::issue_2624", "conflicts::conflicts_with_alongside_default", "hidden_args::hide_subcmds_only", "require::group_required_3", "app_settings::propagate_vals_down", "flag_subcommands::flag_subcommand_normal", "template_help::template_empty", "default_missing_vals::default_missing_value_flag_value", "ignore_errors::multiple_args_and_final_arg_without_value", "multiple_values::sep_long_equals", "template_help::custom_template", "global_args::propagate_global_arg_in_subcommand_to_subsubcommand_1385", "opts::opts_using_long_equals", "flag_subcommands::flag_subcommand_short_with_aliases", "arg_aliases::single_alias_of_flag", "ignore_errors::single_long_arg_without_value", "error::app_error", "build::usage_parser::test::create_option_usage_long_equals9", "propagate_globals::global_flag_used_outer", "require::required_ifs_wrong_val", "require::required_unless_any_works_without", "subcommands::subcmd_did_you_mean_output", "utf8::refuse_invalid_utf8_subcommand_when_args_are_allowed_with_allow_external_subcommands", "require::issue_1158_conflicting_requirements_rev", "build::usage_parser::test::create_option_with_vals1_def", "flags::flag_using_mixed", "help::help_subcommand", "tests::sc_short_flag_x2_short_opt_eq_pos", "multiple_values::option_max_exact", "possible_values::possible_values_of_positional_multiple", "help::issue_688_hide_pos_vals", "app_settings::delim_values_trailingvararg_with_delim", "build::usage_parser::test::create_option_usage_long9", "app_settings::require_eq", "utf8::allow_invalid_utf8_subcommand_args_with_allow_external_subcommands", "opts::opts_using_mixed", "flag_subcommands::flag_subcommand_long_infer_fail", "posix_compatible::conflict_overridden_3", "hidden_args::hide_short_args_long_help", "build::usage_parser::test::create_option_usage_both_equals2", "multiple_values::option_exact_exact_mult", "require::requires_if_present_mult_pass", "positionals::positional_multiple", "help::help_short", "help::after_and_before_long_help_output", "posix_compatible::mult_option_require_delim_overrides_itself", "build::arg::test::positional_display_multiple_values", "delimiters::opt_s_default_no_delim", "utf8::invalid_utf8_lossy_option_long_space", "positionals::lots_o_vals", "opts::opts_using_mixed2", "build::arg::tests::arg_send_sync", "app_settings::leading_hyphen_short", "require::required_if_val_present_pass", "app_settings::unset_on_global_setting", "flag_subcommands::flag_subcommand_long_infer_pass_close", "help::issue_1642_long_help_spacing", "build::usage_parser::test::create_option_with_vals1", "parse::matches::arg_matches::tests::values_exact_size", "possible_values::possible_values_of_option", "multiple_values::value_names_building_num_vals_for_positional", "tests::long_flag_long_opt_eq_pos", "flag_subcommands::flag_subcommand_long_infer_exact_match", "build::usage_parser::test::create_option_usage_long_equals8", "version::no_propagation_by_default_short", "default_vals::default_vals_donnot_show_in_smart_usage", "utf8::invalid_utf8_strict_option_long_space", "require::flag_required_2", "require::issue_1158_conflicting_requirements", "build::usage_parser::test::create_option_usage_both8", "require::positional_required_with_requires", "flags::issue_2308_multiple_dashes", "build::usage_parser::test::pos_req", "default_vals::default_if_arg_present_no_arg_with_default", "group_macro", "app_settings::aaos_opts_w_other_overrides_rev_2", "build::usage_parser::test::create_option_usage_both_equals4", "empty_values::no_empty_values_without_equals", "subcommands::subcommand_not_recognized", "parse::matches::arg_matches::tests::test_default_indices_with_shorter_lifetime", "require::required_unless_present_with_optional_value", "help::long_about", "tests::sc_short_flag_short_opt_eq_pos", "default_vals::default_if_arg_present_with_value_no_arg_with_default_fail", "groups::req_group_with_conflict_usage_string", "opts::require_equals_empty_vals_pass", "tests::sc_short_flag_x2_comb_short_opt_pos", "flags::flag_using_long", "app_settings::arg_required_else_help_error_message", "build::usage_parser::test::create_flag_usage", "opts::leading_hyphen_with_flag_after", "parse::matches::arg_matches::tests::indices_exact_size", "arg::short", "default_vals::issue_1050_num_vals_and_defaults", "require::required_unless_any_1", "require::multiple_required_unless_usage_printing", "propagate_globals::global_arg_default_value", "possible_values::possible_values_hidden_output", "help::after_help_no_args", "require::missing_required_output", "output::help::test::display_width_handles_non_ascii", "multiple_occurrences::multiple_occurrences_of_flags_large_quantity", "flag_subcommands::flag_subcommand_long_with_aliases", "build::usage_parser::test::create_option_usage_long3", "posix_compatible::conflict_overridden_4", "build::arg::test::flag_display", "positionals::positional_possible_values", "help::disabled_help_flag", "default_vals::multiple_defaults", "multiple_values::option_exact_exact", "require::flag_required", "app_settings::infer_subcommands_fail_with_args", "parse::matches::arg_matches::tests::os_values_exact_size", "derive_order::derive_order", "arg_aliases_short::visible_short_arg_aliases_help_output", "default_vals::osstr_positional_user_override", "multiple_values::req_delimiter_long", "version::override_version_short_with_user_flag", "default_vals::osstr_opts", "build::arg::test::positional_display_multiple_occurrences", "global_args::issue_1076", "help::custom_help_headers_hide_args", "help::issue_1487", "tests::flag_x2_opt", "tests::sc_short_flag_short_opt_pos", "help::help_required_locally_but_not_given_for_subcommand", "help::help_long", "app_settings::aaos_option_use_delim_false", "multiple_values::req_delimiter_short_with_space", "build::usage_parser::test::create_option_usage_long_equals10", "default_vals::default_if_arg_present_with_value_with_default", "multiple_values::issue_1480_max_values_consumes_extra_arg_3", "require::required_unless_any_2", "app_settings::arg_required_else_help_over_reqs", "app_settings::setting", "indices::indices_mult_flags", "conflicts::arg_conflicts_with_group_with_multiple_sources", "posix_compatible::posix_compatible_flags_long_rev", "require::require_eq_filtered_group", "delimiters::opt_s_no_space_no_delim", "require::option_required", "build::usage_parser::test::create_option_with_vals3", "posix_compatible::require_overridden_3", "build::usage_parser::test::create_option_usage_long_equals1", "posix_compatible::pos_mult_overrides_itself", "flag_subcommands::flag_subcommand_long_infer_pass", "app_settings::aaos_opts_w_other_overrides_rev", "build::usage_parser::test::create_option_usage_long8", "empty_values::empty_values", "app_settings::aaos_opts_w_other_overrides", "flag_subcommands::flag_subcommand_short_with_alias", "multiple_values::option_short", "display_order::very_large_display_order", "build::usage_parser::test::create_option_with_vals4", "help::override_help_subcommand", "multiple_values::req_delimiter_long_with_equal", "groups::required_group_multiple_args", "build::usage_parser::test::create_positional_usage", "ignore_errors::subcommand", "opts::long_eq_val_starts_with_eq", "subcommands::subcommand_after_argument_looks_like_help", "tests::sc_short_flag_x2_long_opt_eq_pos", "build::app::tests::propagate_version", "hidden_args::hide_subcmds", "help::override_help_flag_using_short", "subcommands::subcmd_did_you_mean_output_arg_false_positives", "hidden_args::hide_pos_args_only", "opts::issue_1105_empty_value_short_explicit_no_space", "utf8::allow_invalid_utf8_value_of_os", "build::usage_parser::test::create_option_usage_long7", "propagate_globals::global_flag_2x_used_top_level", "groups::group_single_flag", "arg_aliases_short::multiple_short_aliases_of_option", "build::arg::test::option_display_single_short_alias", "positionals::create_positional", "subcommands::subcommand_none_given", "build::usage_parser::test::create_option_usage4", "utf8::allow_invalid_utf8_external_subcommand_values_of_os", "multiple_values::option_mixed", "tests::short_opt_x2_pos", "conflicts::group_conflicts_with_arg", "default_vals::no_default_if_arg_present_with_value_with_default_user_override", "app_settings::setting_bitor", "app_settings::infer_subcommands_fail_suggestions", "conflicts::three_conflicting_arguments", "posix_compatible::posix_compatible_opts_long_rev", "tests::sc_long_flag_short_opt_pos", "app_settings::aaos_flags", "utf8::refuse_invalid_utf8_subcommand_args_with_allow_external_subcommands", "opts::double_hyphen_as_value", "parse::matches::matched_arg::tests::test_grouped_vals_first", "subcommands::issue_1722_not_emit_error_when_arg_follows_similar_to_a_subcommand", "hidden_args::hide_long_args_short_help", "require::arg_require_group_2", "build::usage_parser::test::create_option_usage3", "posix_compatible::option_use_delim_false_override_itself", "arg_impl::string_literal", "app_settings::aaos_opts", "build::usage_parser::test::create_option_usage5", "app_settings::unset_setting", "parse::matches::arg_matches::tests::test_default_osvalues", "build::usage_parser::test::create_option_usage_both_equals6", "tests::short_flag_short_opt_pos", "conflicts::flag_conflict_2", "multiple_values::option_exact_less", "app_settings::missing_positional_hyphen", "empty_values::no_empty_values_without_equals_but_requires_equals", "build::app::tests::app_send_sync", "possible_values::possible_values_of_option_multiple_fail", "positionals::positional_multiple_2", "help::old_newline_chars", "multiple_occurrences::multiple_occurrences_of_positional", "group_macro_set_not_multiple", "utf8::invalid_utf8_strict_option_long_equals", "opts::require_equals_fail", "build::arg_group::test::test_from", "app_settings::missing_positional_hyphen_req_error", "app_settings::arg_required_else_help", "help::disable_help_flag_affects_help_subcommand", "posix_compatible::conflict_overridden_2", "app_settings::global_setting", "multiple_values::issue_1480_max_values_consumes_extra_arg_2", "app_settings::dont_delim_values_trailingvararg", "multiple_values::positional_exact_less", "help::prefer_user_subcmd_help_short_1112", "help::missing_positional_final_required", "build::arg::test::flag_display_single_short_alias", "arg::name_explicit", "subcommands::issue_1031_args_with_same_name", "build::usage_parser::test::create_option_usage_long_equals2", "version::propagate_version_long", "quoted_arg_name", "utf8::refuse_invalid_utf8_subcommand_with_allow_external_subcommands", "multiple_values::sep_short_no_space", "app_settings::no_auto_version_mut_arg", "multiple_values::positional_max_exact", "require::requires_if_present_mult", "app_settings::delim_values_trailingvararg", "app_settings::issue_1437_allow_hyphen_values_for_positional_arg", "help::override_help_flag_using_long", "groups::group_empty", "utf8::invalid_utf8_option_short_equals", "version::override_version_long_with_user_flag", "app_settings::allow_negative_numbers", "app_settings::missing_positional_hyphen_far_back", "help::last_arg_mult_usage_with_sc", "hidden_args::hide_pos_args", "require::required_unless_present_all", "build::arg::test::option_display_multiple_occurrences", "derive_order::prefer_user_help_in_subcommand_with_derive_order", "opts::opts_using_short", "flag_subcommands::flag_subcommand_conflict_with_help", "tests::sc_long_flag_long_opt", "require::positional_required_2", "arg::short_and_long", "empty_values::no_empty_values_with_equals", "require::positional_required", "help::complex_subcommand_help_output", "default_vals::multiple_defaults_override", "build::usage_parser::test::create_option_usage_both_equals1", "opts::short_eq_val_starts_with_eq", "help::complex_help_output", "propagate_globals::global_flag_used_top_level", "require::required_if_val_present_fail", "help::hide_possible_vals", "require::require_eq", "multiple_values::positional_min_more", "arg::name_from_long", "help::issue_1052_require_delim_help", "build::usage_parser::test::create_option_with_vals4_def", "delimiters::opt_s_eq_no_delim", "require::required_unless_any_works_with_short", "utf8::allow_validated_utf8_external_subcommand_values_of", "global_args::global_arg_available_in_subcommand", "help::prefer_user_subcmd_help_long_1112", "positionals::positional_multiple_3", "subcommands::subcommand_display_order", "flag_subcommands::flag_subcommand_long_short_normal_usage_string", "help::issue_1794_usage", "build::arg::test::option_display3", "build::app::tests::global_setting", "app_settings::allow_missing_positional_no_default", "app_settings::issue_1066_allow_leading_hyphen_and_unknown_args_no_vals", "help::option_usage_order", "default_vals::default_if_arg_present_with_value_with_default_user_override", "default_vals::opt_user_override", "multiple_values::option_min_less", "default_missing_vals::opt_missing", "default_vals::missing_with_value_delimiter", "indices::indices_mult_flags_combined", "arg_aliases_short::single_short_alias_of_option", "app_settings::aaos_opts_w_other_overrides_2", "groups::req_group_with_conflict_usage_string_only_options", "help::hide_default_val", "help::subcommand_short_help", "default_missing_vals::opt_present_with_value", "hidden_args::hide_long_args", "app_settings::args_negate_subcommands_one_level", "parse::matches::matched_arg::tests::test_grouped_vals_removal", "app_settings::leading_hyphen_opt", "app_settings::nested_help_subcommand_with_global_setting", "default_vals::opts", "version::mut_arg_version_no_auto_version", "multiple_values::number_of_values_preferred_over_value_names", "help::only_custom_heading_opts_no_args", "default_vals::default_if_arg_present_with_default", "app_settings::leading_hyphen_long", "help::last_arg_mult_usage", "help::last_arg_mult_usage_req", "arg_settings::unset_setting", "help::req_last_arg_usage", "app_settings::issue_1093_allow_ext_sc", "flags::flag_using_short", "groups::group_usage_use_val_name", "build::usage_parser::test::create_option_usage_long6", "empty_values::empty_values_with_equals", "require::issue_753", "posix_compatible::posix_compatible_flags_short_rev", "possible_values::possible_values_output", "version::propagate_version_short", "opts::require_equals_pass", "require::required_if_val_present_fail_error_output", "opts::issue_2279", "require::required_unless_err", "flag_subcommands::flag_subcommand_normal_with_alias", "opts::leading_hyphen_with_only_pos_follows", "app_settings::external_subcommand_looks_like_built_in", "subcommands::subcommand_placeholder_test", "opts::leading_hyphen_pass", "app_settings::aaos_pos_mult", "multiple_values::option_long", "conflicts::flag_conflict_with_everything", "tests::add_multiple_arg", "help::custom_headers_headers", "require::required_unless_any_works_with_long", "tests::sc_short_flag_x2_comb_short_opt_eq_pos", "help::subcommand_long_help", "help::positional_multiple_occurrences_is_dotted", "posix_compatible::require_overridden_2", "subcommands::issue_1031_args_with_same_name_no_more_vals", "app_settings::args_negate_subcommands_two_levels", "multiple_values::positional_max_less", "posix_compatible::require_overridden_4", "utf8::invalid_utf8_option_short_no_space", "subcommands::subcommand", "build::arg::test::option_display_single_alias", "utf8::invalid_utf8_lossy_positional", "possible_values::possible_values_of_positional_fail", "posix_compatible::posix_compatible_opts_long_equals_rev", "ignore_errors::multiple_args_and_intermittent_arg_without_value", "arg_aliases::alias_on_a_subcommand_option", "opts::short_non_ascii_no_space", "help::override_help_short", "build::usage_parser::test::pos_help_newline_lit_sq", "help::final_word_wrapping", "multiple_values::sep_short_space", "multiple_values::option_exact_more", "tests::sc_long_flag_x2_long_opt_eq_pos", "derive_order::prefer_user_help_with_derive_order", "require::arg_require_group", "flags::lots_o_flags_sep", "possible_values::possible_values_of_option_fail", "multiple_occurrences::max_occurrences_positional", "build::usage_parser::test::create_option_usage_both1", "posix_compatible::issue_1374_overrides_self_with_multiple_values", "app_settings::infer_subcommands_pass_exact_match", "multiple_values::positional_max_more", "require::required_if_val_present_ignore_case_fail", "multiple_values::option_short_min_more_single_occur", "conflicts::conflict_output", "help::help_required_and_given", "posix_compatible::posix_compatible_opts_short_rev", "borrowed::borrowed_args", "require::required_unless_all_with_any", "version::override_version_long_with_user_flag_no_version_flag", "app_settings::aaos_opts_mult", "version::version_flag_from_version_short", "tests::sc_short_flag_x2_comb_long_opt_pos", "possible_values::ignore_case_multiple", "opts::multiple_vals_pos_arg_delim", "groups::empty_group", "build::usage_parser::test::nonascii", "app_settings::delim_values_only_pos_follows_with_delim", "help::issue_626_variable_panic", "help::ripgrep_usage", "opts::require_delims", "multiple_values::req_delimiter_complex", "flags::issue_1284_argument_in_flag_style", "build::usage_parser::test::create_option_usage_both6", "help::prefer_about_over_long_about_in_subcommands_list", "build::arg::test::positional_display_val_names", "default_missing_vals::opt_default_user_override", "indices::indices_mult_flags_opt_combined_eq", "arg_settings::unset_setting_bitor", "build::arg::test::flag_display_multiple_aliases", "build::usage_parser::test::create_option_usage8", "output::help::test::wrap_help_last_word", "flag_subcommands::flag_subcommand_long", "build::usage_parser::test::pos_help_double_lit_single_quote", "utf8::invalid_utf8_lossy_option_long_equals", "multiple_values::sep_short_equals", "arg_impl::string_ident", "app_settings::stop_delim_values_only_pos_follows", "multiple_values::positional_min_exact", "help::no_wrap_help", "require::issue_1643_args_mutually_require_each_other", "possible_values::possible_values_of_option_multiple", "arg_impl::char_ident", "double_require::no_duplicate_error", "multiple_occurrences::max_occurrences_implies_multiple_occurrences", "possible_values::possible_value_arg_value", "arg_aliases::single_alias_of_option", "build::app::tests::issue_2090", "tests::long_opt_x2_pos", "possible_values::possible_values_alias_output", "version::version_about_multi_subcmd", "indices::indices_mult_opt_value_no_delim_eq", "opts::issue_1105_empty_value_long_explicit", "app_settings::subcommand_required_else_help_error_message", "posix_compatible::mult_flag_overrides_itself", "opts::stdin_char", "posix_compatible::posix_compatible_opts_short", "help::issue_1364_no_short_options", "tests::sc_short_flag_x2_comb_long_opt_eq_pos", "help::wrapping_newline_chars", "version::override_version_short_with_user_flag_long_still_works", "require::required_if_wrong_val", "utf8::invalid_utf8_option_long_space", "multiple_values::different_sep", "app_settings::issue_1066_allow_leading_hyphen_and_unknown_args_option", "global_args::propagate_global_arg_to_subcommand_in_subsubcommand_2053", "conflicts::conflict_with_unused_default", "multiple_values::issue_1480_max_values_consumes_extra_arg_1", "quoted_arg_long_name", "multiple_values::positional_exact_exact", "tests::sc_short_flag_long_opt_eq_pos", "build::arg::test::positional_display_val_names_req", "arg_aliases_short::short_alias_on_a_subcommand_option", "groups::group_single_value", "help::prefer_user_help_short_1112", "require::requires_if_present_val_no_present_pass", "help::old_newline_variables", "conflicts::flag_conflict_with_all", "flag_subcommands::flag_subcommand_short_with_args", "require::require_eq_filtered", "require::required_unless_present_any", "error::argument_not_found_auto_has_newline", "help::issue_777_wrap_all_things", "build::usage_parser::test::create_option_with_vals2", "app_settings::subcommand_required_else_help", "app_settings::infer_subcommands_pass_close", "flags::flag_using_long_with_literals", "opts::issue_1105_empty_value_long_fail", "indices::indices_mult_opt_mult_flag", "multiple_values::req_delimiter_short_with_equal", "opts::issue_1105_empty_value_short_fail", "utf8::invalid_utf8_option_short_space", "require::group_required", "tests::long_opt_eq_x2_pos", "hidden_args::hide_opt_args_only", "hidden_args::hide_short_args", "propagate_globals::global_arg_used_top_level", "arg_settings::setting_bitor", "subcommands::multiple_aliases", "app_settings::disable_help_subcommand", "multiarg", "flag_subcommands::flag_subcommand_long_normal_usage_string", "posix_compatible::posix_compatible_flags_long", "flags::lots_o_flags_combined", "arg_settings::setting", "derive_order::no_derive_order", "multiple_values::multiple_value_terminator_option_other_arg", "multiple_occurrences::max_occurrences_try_inputs", "build::usage_parser::test::create_option_usage1", "build::usage_parser::test::pos_req_mult_help", "build::usage_parser::test::pos_req_mult_def_help", "require::required_if_some_values_present_pass", "indices::indices_mult_flags_opt_combined", "opts::issue_2022_get_flags_misuse", "help::args_with_last_usage", "multiple_occurrences::multiple_occurrences_of_flags_mixed", "default_vals::default_if_arg_present_with_value_no_arg_with_default", "require::required_if_any_all_values_present_fail", "help::sc_negates_reqs", "require::option_required_2", "flag_subcommands::flag_subcommand_short_with_alias_same_as_short_flag", "default_vals::default_if_arg_present_no_arg_with_value_with_default_user_override_fail", "require::required_ifs_val_present_pass", "empty_values::no_empty_values", "positionals::multiple_positional_one_required_usage_string", "groups::group_acts_like_arg", "propagate_globals::global_flag_2x_used_inner", "tests::mut_arg_all", "build::usage_parser::test::create_option_usage_long_equals5", "opts::issue_1047_min_zero_vals_default_val", "posix_compatible::flag_overrides_itself", "default_vals::osstr_opt_user_override", "indices::index_flags", "subcommands::subcmd_did_you_mean_output_arg", "opts::require_equals_min_values_zero", "default_vals::default_ifs_arg_present_order", "flag_subcommands::flag_subcommand_conflict_with_version", "multiple_values::no_sep", "require::positional_required_with_requires_if_value", "build::usage_parser::test::create_option_usage9", "help::multiple_custom_help_headers", "default_vals::default_if_arg_present_no_default", "build::arg::test::flag_display_single_alias", "groups::group_multi_value_single_arg", "multiple_values::issue_2229", "default_vals::default_if_arg_present_no_arg_with_value_with_default_user_override", "utf8::invalid_utf8_strict_positional", "conflicts::arg_conflicts_with_required_group", "help::override_help_about", "multiple_values::sep_positional", "build::usage_parser::test::pos_help_lit_single_quote", "require::group_required_2", "posix_compatible::mult_option_overrides_itself", "build::usage_parser::test::create_option_usage_long_equals7", "tests::short_opt_eq_x2_pos", "app_settings::aaos_opts_mult_req_delims", "build::usage_parser::test::create_option_usage_both7", "multiple_values::option_max_more", "app_settings::no_auto_version", "posix_compatible::incremental_override", "utf8::invalid_utf8_lossy_option_short_space", "double_require::help_text", "multiple_values::positional_exact_more", "app_settings::leading_double_hyphen_trailingvararg", "help::issue_2508_number_of_values_with_single_value_name", "app_settings::sub_command_negate_required_2", "help::issue_626_panic", "opts::did_you_mean", "opts::require_delims_no_delim", "positionals::ignore_hyphen_values_on_last", "positionals::last_positional_second_to_last_mult", "multiple_values::low_index_positional_with_flag", "flags::multiple_flags_in_single", "arg_aliases_short::single_short_alias_of_flag", "build::usage_parser::test::create_option_with_vals5", "delimiters::opt_default_no_delim", "help::help_subcmd_help", "help::no_wrap_default_help", "help::show_long_about_issue_897", "tests::sc_short_flag_long_opt_pos", "subcommands::issue_2494_subcommand_is_present", "default_vals::default_if_arg_present_with_value_no_default", "default_vals::with_value_delimiter", "app_settings::sub_command_negate_required", "tests::short_flag_x2_comb_short_opt_pos", "help::only_custom_heading_pos_no_args", "positionals::single_positional_required_usage_string", "arg_aliases::visible_arg_aliases_help_output", "default_vals::default_ifs_arg_present_user_override", "arg_impl::char_literal", "arg_aliases::multiple_aliases_of_option", "help::issue_1571", "default_vals::default_if_arg_present_with_value_no_default_fail", "arg::positional", "build::usage_parser::test::create_option_usage0", "tests::sc_short_flag_x2_long_opt_pos", "conflicts::required_group_conflicts_with_arg", "positionals::multiple_positional_usage_string", "help::subcmd_help_subcmd_help", "utf8::invalid_utf8_lossy_option_short_equals", "build::usage_parser::test::create_option_usage_long_equals4", "conflicts::flag_conflict", "opts::leading_hyphen_with_flag_before", "utf8::invalid_utf8_lossy_option_short_no_space", "app_settings::dont_collapse_args", "validators::stateful_validator", "subcommands::subcommand_multiple", "tests::sc_long_flag_x2_short_opt_pos", "conflicts::conflict_output_three_conflicting", "help::missing_positional_final_multiple", "build::usage_parser::test::value_names_building_num_vals_from_usage", "help::subcommand_help_doesnt_have_useless_help_flag", "build::usage_parser::test::create_positional_usage0", "require::required_if_all_values_present_pass", "groups::group_reqired_flags_empty", "app_settings::allow_missing_positional", "default_vals::no_default_if_arg_present_no_arg_with_value_with_default", "multiple_values::value_names_building_num_vals", "help::custom_heading_pos", "app_settings::issue_1066_allow_leading_hyphen_and_unknown_args", "multiple_values::multiple_value_terminator_option", "tests::sc_long_flag_x2_long_opt_pos", "require::requires_if_present_val", "default_vals::default_ifs_arg_present", "utf8::invalid_utf8_strict_option_short_no_space", "multiple_values::different_sep_positional", "flag_subcommands::flag_subcommand_short_normal_usage_string", "app_settings::delim_values_only_pos_follows", "help::args_negate_sc", "double_require::valid_cases", "template_help::template_author_version", "build::usage_parser::test::pos_help_newline", "positionals::single_positional_multiple_usage_string", "parse::matches::arg_matches::tests::test_default_indices", "posix_compatible::posix_compatible_opts_long_equals", "multiple_values::positional", "version::version_flag_from_version_long", "build::usage_parser::test::create_option_usage_long10", "build::usage_parser::test::create_option_usage_long2", "help::wrapping_newline_variables", "derive_order::derive_order_subcommand_propagate", "subcommands::subcmd_did_you_mean_output_ambiguous", "multiple_values::option_min_exact", "build::arg::test::flag_display_multiple_short_aliases", "groups::required_group_missing_arg", "build::usage_parser::test::create_option_usage_both_equals8", "require::required_unless_any_works_with_short_err", "possible_values::ignore_case", "multiple_values::values_per_occurrence_positional", "template_help::with_template", "build::usage_parser::test::create_option_usage_both3", "subcommands::alias_help", "default_vals::positionals", "opts::require_equals_no_empty_values_fail", "version::version_flag_from_long_version_long", "app_settings::infer_subcommands_pass", "multiple_values::sep_long_space", "conflicts::arg_conflicts_with_group", "app_settings::unset_global_setting", "help::prefer_user_help_long_1112", "build::usage_parser::test::create_option_usage_both_equals3", "build::usage_parser::test::create_option_usage_both_equals7", "error::value_validation_has_newline", "help::help_about_multi_subcmd", "tests::long_flag_long_opt_pos", "possible_values::possible_values_of_positional_multiple_fail", "help::escaped_whitespace_values", "flag_subcommands::flag_subcommand_long_with_alias_same_as_long_flag", "opts::issue_1105_empty_value_long_equals", "default_vals::positional_user_override", "group_macro_set_not_required", "parse::matches::arg_matches::tests::test_default_osvalues_with_shorter_lifetime", "positionals::last_positional", "utf8::ignore_invalid_utf8_with_defaults", "build::usage_parser::test::create_option_usage_long4", "require::required_if_all_values_present_fail", "multiple_values::option_exact_exact_not_mult", "help::dont_propagate_version_to_help_subcommand", "build::arg::test::option_display_multiple_short_aliases", "opts::leading_hyphen_fail", "possible_values::escaped_possible_values_output", "app_settings::skip_possible_values", "help::ripgrep_usage_using_templates", "opts::issue_1073_suboptimal_flag_suggestion", "multiple_occurrences::multiple_occurrences_of_flags_long", "positionals::positional_hyphen_does_not_panic", "help::issue_702_multiple_values", "positionals::only_pos_follow", "help::disabled_help_flag_and_subcommand", "conflicts::conflict_output_rev", "app_settings::missing_positional_no_hyphen", "delimiters::opt_eq_mult_def_delim", "version::mut_version_long", "conflicts::two_conflicting_arguments", "indices::index_flag", "build::usage_parser::test::create_option_usage_long_equals6", "require::required_unless_present", "version::no_version_flag_long", "build::arg::test::positional_display_required", "help::help_no_subcommand", "possible_values::possible_values_of_positional", "multiple_values::multiple_vals_with_hyphen", "require::required_if_val_present_ignore_case_pass", "help::show_short_about_issue_897", "opts::issue_1105_empty_value_short_explicit", "utf8::invalid_utf8_strict_option_short_space", "posix_compatible::pos_required_overridden_by_flag", "build::usage_parser::test::create_option_usage_long_equals3", "derive_order::derive_order_subcommand_propagate_with_explicit_display_order", "utf8::ignore_validated_utf8_with_defaults", "positionals::last_positional_no_double_dash", "multiple_values::low_index_positional", "utf8::allow_validated_utf8_value_of", "build::usage_parser::test::create_option_usage_both_equals5", "build::usage_parser::test::create_option_usage7", "indices::index_mult_opts", "build::arg::test::option_display_multiple_aliases", "posix_compatible::posix_compatible_flags_short", "require::short_flag_require_equals_with_minvals_zero", "tests::create_app", "default_vals::no_default_if_arg_present_with_value_no_default", "posix_compatible::posix_compatible_opts_long", "arg::name_from_value", "default_vals::default_if_arg_present_with_value_no_default_user_override", "multiple_values::option_max_less", "require::required_if_any_all_values_present_pass", "subcommands::issue_1161_multiple_hyphen_hyphen", "group_macro_set_required", "hidden_args::hide_args", "opts::require_equals_fail_message", "subcommands::subcommand_used_after_double_dash", "build::usage_parser::test::pos_mult_help", "indices::indices_mult_opt_value_delim_eq", "require::required_unless_all_err", "help::after_and_before_help_output", "tests::sc_short_flag_x2_short_opt_pos", "help::arg_short_conflict_with_help", "help::hide_args", "flag_subcommands::flag_subcommand_short_after_long_arg", "help::help_required_and_no_args", "arg_aliases_short::invisible_short_arg_aliases_help_output", "ignore_errors::single_short_arg_without_value", "subcommands::visible_aliases_help_output", "app_settings::allow_negative_numbers_fail", "help::issue_760", "build::usage_parser::test::pos_mult", "positionals::issue_946", "arg_aliases_short::multiple_short_aliases_of_flag", "flag_subcommands::flag_subcommand_multiple", "help::hide_single_possible_val", "app_settings::aaos_flags_mult", "default_vals::default_if_arg_present_no_arg_with_default_user_override", "build::usage_parser::test::issue_665", "possible_values::alias", "possible_values::ignore_case_multiple_fail", "possible_values::ignore_case_fail", "example_tests", "help::positional_multiple_values_is_dotted", "build::usage_parser::test::create_option_usage_long5", "positionals::missing_required_2", "delimiters::opt_eq_no_delim", "default_vals::opt_without_value_fail", "subcommands::invisible_aliases_help_output", "multiple_values::no_sep_positional", "default_vals::no_default_if_arg_present_with_value_with_default", "version::no_version_flag_short", "default_vals::conditional_reqs_pass", "help::issue_1046_hide_scs", "propagate_globals::global_flag_used_inner", "app_settings::unset_setting_bitor", "build::app::tests::global_settings", "build::usage_parser::test::create_option_usage6", "help::help_required_and_given_for_subcommand", "opts::issue_1105_empty_value_short_equals", "utf8::invalid_utf8_positional", "tests::sc_long_flag_x2_short_opt_eq_pos", "parse::matches::arg_matches::tests::test_default_values", "app_settings::color_is_global"], "failed_tests": [], "skipped_tests": []}
{"passed_count": 805, "failed_count": 2, "skipped_count": 0, "passed_tests": ["tests::sc_long_flag_long_opt_eq_pos", "default_vals::default_if_arg_present_no_default_user_override", "app_settings::allow_ext_sc_when_sc_required", "arg_aliases::multiple_aliases_of_flag", "indices::indices_mult_opts", "groups::req_group_usage_string", "posix_compatible::conflict_overridden", "propagate_globals::global_arg_used_outer", "build::usage_parser::test::create_option_usage2", "build::usage_parser::test::create_option_usage_both2", "app_settings::infer_subcommands_fail_with_args2", "subcommands::single_alias", "version::no_propagation_by_default_long", "help::multi_level_sc_help", "build::usage_parser::test::create_option_usage_long1", "require::required_ifs_wrong_val_mult_fail", "help::override_help_long", "output::help::test::display_width_handles_emojis", "flag_subcommands::flag_subcommand_long_with_alias", "app_settings::single_arg_help_with_long_format_setting", "build::usage_parser::test::create_option_usage_both4", "app_settings::no_bin_name", "help::help_about_multi_subcmd_override", "conflicts::conflict_output_rev_with_required", "parse::matches::matched_arg::tests::test_grouped_vals_push_and_append", "opts::lots_o_vals", "opts::opts_using_long_space", "version::version_flag_from_long_version_short", "groups::group_multiple_args_error", "default_missing_vals::opt_default", "build::arg::test::option_display_multiple_values", "posix_compatible::option_overrides_itself", "version::mut_version_short", "template_help::template_unknowntag", "default_missing_vals::opt_present_with_empty_value", "parse::matches::arg_matches::tests::test_default_values_with_shorter_lifetime", "default_vals::default_if_arg_present_with_default_user_override", "possible_values::missing_possible_value_error", "require::list_correct_required_args", "opts::default_values_user_value", "utf8::invalid_utf8_strict_option_short_equals", "default_vals::no_default_ifs_arg_present", "possible_values::aliases", "require::positional_required_with_requires_if_no_value", "multiple_values::positional_min_less", "template_help::template_notag", "build::arg::test::option_display2", "multiple_values::low_index_positional_with_option", "require::arg_require_group_3", "multiple_values::low_index_positional_in_subcmd", "app_settings::use_long_format_for_help_subcommand_with_setting", "positionals::positional", "subcommands::subcommand_after_argument", "multiple_occurrences::multiple_occurrences_of_flags_short", "validators::test_validator_fromstr_trait", "delimiters::opt_s_no_space_mult_no_delim", "multiple_values::req_delimiter_short_with_no_space", "help::subcommand_help_rev", "positionals::single_positional_usage_string", "app_settings::no_auto_help", "opts::multiple_vals_pos_arg_equals", "opts::infer_long_arg", "build::arg_group::test::groups", "default_missing_vals::opt_present_with_missing_value", "multiple_values::values_per_occurrence_named", "multiple_values::option_short_min_more_mult_occurs", "app_settings::infer_subcommands_fail_no_args", "flag_subcommands::flag_subcommand_short_with_aliases_vis_and_hidden", "arg_aliases::invisible_arg_aliases_help_output", "help::issue_626_unicode_cutoff", "default_vals::osstr_positionals", "help::last_arg_mult_usage_req_with_sc", "require::required_unless_any_err", "utf8::invalid_utf8_option_long_equals", "build::arg_group::test::arg_group_send_sync", "app_settings::sub_command_required", "propagate_globals::global_arg_used_inner", "require::required_ifs_val_present_fail", "conflicts::conflict_output_with_required", "build::usage_parser::test::create_option_usage_both5", "flag_subcommands::flag_subcommand_short", "require::issue_2624", "conflicts::conflicts_with_alongside_default", "hidden_args::hide_subcmds_only", "require::group_required_3", "app_settings::propagate_vals_down", "flag_subcommands::flag_subcommand_normal", "template_help::template_empty", "default_missing_vals::default_missing_value_flag_value", "ignore_errors::multiple_args_and_final_arg_without_value", "multiple_values::sep_long_equals", "template_help::custom_template", "global_args::propagate_global_arg_in_subcommand_to_subsubcommand_1385", "opts::opts_using_long_equals", "flag_subcommands::flag_subcommand_short_with_aliases", "arg_aliases::single_alias_of_flag", "error::app_error", "ignore_errors::single_long_arg_without_value", "build::usage_parser::test::create_option_usage_long_equals9", "propagate_globals::global_flag_used_outer", "require::required_unless_any_works_without", "require::required_ifs_wrong_val", "utf8::refuse_invalid_utf8_subcommand_when_args_are_allowed_with_allow_external_subcommands", "subcommands::subcmd_did_you_mean_output", "require::issue_1158_conflicting_requirements_rev", "build::usage_parser::test::create_option_with_vals1_def", "flags::flag_using_mixed", "help::help_subcommand", "tests::sc_short_flag_x2_short_opt_eq_pos", "multiple_values::option_max_exact", "possible_values::possible_values_of_positional_multiple", "help::issue_688_hide_pos_vals", "app_settings::delim_values_trailingvararg_with_delim", "build::usage_parser::test::create_option_usage_long9", "app_settings::require_eq", "utf8::allow_invalid_utf8_subcommand_args_with_allow_external_subcommands", "opts::opts_using_mixed", "flag_subcommands::flag_subcommand_long_infer_fail", "posix_compatible::conflict_overridden_3", "hidden_args::hide_short_args_long_help", "build::usage_parser::test::create_option_usage_both_equals2", "multiple_values::option_exact_exact_mult", "require::requires_if_present_mult_pass", "positionals::positional_multiple", "help::help_short", "help::after_and_before_long_help_output", "posix_compatible::mult_option_require_delim_overrides_itself", "build::arg::test::positional_display_multiple_values", "delimiters::opt_s_default_no_delim", "utf8::invalid_utf8_lossy_option_long_space", "positionals::lots_o_vals", "opts::opts_using_mixed2", "build::arg::tests::arg_send_sync", "app_settings::leading_hyphen_short", "require::required_if_val_present_pass", "app_settings::unset_on_global_setting", "flag_subcommands::flag_subcommand_long_infer_pass_close", "help::issue_1642_long_help_spacing", "build::usage_parser::test::create_option_with_vals1", "parse::matches::arg_matches::tests::values_exact_size", "possible_values::possible_values_of_option", "multiple_values::value_names_building_num_vals_for_positional", "tests::long_flag_long_opt_eq_pos", "flag_subcommands::flag_subcommand_long_infer_exact_match", "build::usage_parser::test::create_option_usage_long_equals8", "version::no_propagation_by_default_short", "default_vals::default_vals_donnot_show_in_smart_usage", "utf8::invalid_utf8_strict_option_long_space", "require::flag_required_2", "require::issue_1158_conflicting_requirements", "build::usage_parser::test::create_option_usage_both8", "require::positional_required_with_requires", "flags::issue_2308_multiple_dashes", "build::usage_parser::test::pos_req", "default_vals::default_if_arg_present_no_arg_with_default", "app_settings::aaos_opts_w_other_overrides_rev_2", "build::usage_parser::test::create_option_usage_both_equals4", "empty_values::no_empty_values_without_equals", "parse::matches::arg_matches::tests::test_default_indices_with_shorter_lifetime", "require::required_unless_present_with_optional_value", "help::long_about", "tests::sc_short_flag_short_opt_eq_pos", "default_vals::default_if_arg_present_with_value_no_arg_with_default_fail", "groups::req_group_with_conflict_usage_string", "opts::require_equals_empty_vals_pass", "tests::sc_short_flag_x2_comb_short_opt_pos", "app_settings::arg_required_else_help_error_message", "flags::flag_using_long", "build::usage_parser::test::create_flag_usage", "opts::leading_hyphen_with_flag_after", "parse::matches::arg_matches::tests::indices_exact_size", "default_vals::issue_1050_num_vals_and_defaults", "require::required_unless_any_1", "require::multiple_required_unless_usage_printing", "propagate_globals::global_arg_default_value", "possible_values::possible_values_hidden_output", "help::after_help_no_args", "require::missing_required_output", "output::help::test::display_width_handles_non_ascii", "multiple_occurrences::multiple_occurrences_of_flags_large_quantity", "flag_subcommands::flag_subcommand_long_with_aliases", "build::usage_parser::test::create_option_usage_long3", "posix_compatible::conflict_overridden_4", "build::arg::test::flag_display", "positionals::positional_possible_values", "help::disabled_help_flag", "default_vals::multiple_defaults", "multiple_values::option_exact_exact", "require::flag_required", "app_settings::infer_subcommands_fail_with_args", "parse::matches::arg_matches::tests::os_values_exact_size", "derive_order::derive_order", "arg_aliases_short::visible_short_arg_aliases_help_output", "default_vals::osstr_positional_user_override", "multiple_values::req_delimiter_long", "version::override_version_short_with_user_flag", "default_vals::osstr_opts", "build::arg::test::positional_display_multiple_occurrences", "global_args::issue_1076", "help::custom_help_headers_hide_args", "help::issue_1487", "tests::flag_x2_opt", "tests::sc_short_flag_short_opt_pos", "help::help_required_locally_but_not_given_for_subcommand", "help::help_long", "app_settings::aaos_option_use_delim_false", "multiple_values::req_delimiter_short_with_space", "build::usage_parser::test::create_option_usage_long_equals10", "default_vals::default_if_arg_present_with_value_with_default", "multiple_values::issue_1480_max_values_consumes_extra_arg_3", "require::required_unless_any_2", "app_settings::arg_required_else_help_over_reqs", "app_settings::setting", "indices::indices_mult_flags", "conflicts::arg_conflicts_with_group_with_multiple_sources", "posix_compatible::posix_compatible_flags_long_rev", "require::require_eq_filtered_group", "delimiters::opt_s_no_space_no_delim", "require::option_required", "build::usage_parser::test::create_option_with_vals3", "posix_compatible::require_overridden_3", "build::usage_parser::test::create_option_usage_long_equals1", "posix_compatible::pos_mult_overrides_itself", "flag_subcommands::flag_subcommand_long_infer_pass", "app_settings::aaos_opts_w_other_overrides_rev", "build::usage_parser::test::create_option_usage_long8", "empty_values::empty_values", "app_settings::aaos_opts_w_other_overrides", "flag_subcommands::flag_subcommand_short_with_alias", "display_order::very_large_display_order", "multiple_values::option_short", "build::usage_parser::test::create_option_with_vals4", "help::override_help_subcommand", "multiple_values::req_delimiter_long_with_equal", "groups::required_group_multiple_args", "build::usage_parser::test::create_positional_usage", "ignore_errors::subcommand", "opts::long_eq_val_starts_with_eq", "subcommands::subcommand_after_argument_looks_like_help", "tests::sc_short_flag_x2_long_opt_eq_pos", "build::app::tests::propagate_version", "hidden_args::hide_subcmds", "help::override_help_flag_using_short", "subcommands::subcmd_did_you_mean_output_arg_false_positives", "hidden_args::hide_pos_args_only", "opts::issue_1105_empty_value_short_explicit_no_space", "utf8::allow_invalid_utf8_value_of_os", "build::usage_parser::test::create_option_usage_long7", "propagate_globals::global_flag_2x_used_top_level", "groups::group_single_flag", "arg_aliases_short::multiple_short_aliases_of_option", "build::arg::test::option_display_single_short_alias", "positionals::create_positional", "subcommands::subcommand_none_given", "build::usage_parser::test::create_option_usage4", "utf8::allow_invalid_utf8_external_subcommand_values_of_os", "multiple_values::option_mixed", "tests::short_opt_x2_pos", "conflicts::group_conflicts_with_arg", "default_vals::no_default_if_arg_present_with_value_with_default_user_override", "app_settings::setting_bitor", "app_settings::infer_subcommands_fail_suggestions", "conflicts::three_conflicting_arguments", "posix_compatible::posix_compatible_opts_long_rev", "tests::sc_long_flag_short_opt_pos", "app_settings::aaos_flags", "utf8::refuse_invalid_utf8_subcommand_args_with_allow_external_subcommands", "opts::double_hyphen_as_value", "parse::matches::matched_arg::tests::test_grouped_vals_first", "subcommands::issue_1722_not_emit_error_when_arg_follows_similar_to_a_subcommand", "hidden_args::hide_long_args_short_help", "require::arg_require_group_2", "build::usage_parser::test::create_option_usage3", "posix_compatible::option_use_delim_false_override_itself", "app_settings::aaos_opts", "build::usage_parser::test::create_option_usage5", "app_settings::unset_setting", "parse::matches::arg_matches::tests::test_default_osvalues", "build::usage_parser::test::create_option_usage_both_equals6", "tests::short_flag_short_opt_pos", "conflicts::flag_conflict_2", "multiple_values::option_exact_less", "app_settings::missing_positional_hyphen", "empty_values::no_empty_values_without_equals_but_requires_equals", "build::app::tests::app_send_sync", "possible_values::possible_values_of_option_multiple_fail", "positionals::positional_multiple_2", "help::old_newline_chars", "multiple_occurrences::multiple_occurrences_of_positional", "utf8::invalid_utf8_strict_option_long_equals", "opts::require_equals_fail", "build::arg_group::test::test_from", "app_settings::arg_required_else_help", "app_settings::missing_positional_hyphen_req_error", "help::disable_help_flag_affects_help_subcommand", "posix_compatible::conflict_overridden_2", "app_settings::global_setting", "multiple_values::issue_1480_max_values_consumes_extra_arg_2", "app_settings::dont_delim_values_trailingvararg", "multiple_values::positional_exact_less", "help::prefer_user_subcmd_help_short_1112", "help::missing_positional_final_required", "build::arg::test::flag_display_single_short_alias", "subcommands::issue_1031_args_with_same_name", "build::usage_parser::test::create_option_usage_long_equals2", "version::propagate_version_long", "utf8::refuse_invalid_utf8_subcommand_with_allow_external_subcommands", "multiple_values::sep_short_no_space", "app_settings::no_auto_version_mut_arg", "multiple_values::positional_max_exact", "require::requires_if_present_mult", "app_settings::delim_values_trailingvararg", "app_settings::issue_1437_allow_hyphen_values_for_positional_arg", "help::override_help_flag_using_long", "groups::group_empty", "utf8::invalid_utf8_option_short_equals", "version::override_version_long_with_user_flag", "app_settings::allow_negative_numbers", "app_settings::missing_positional_hyphen_far_back", "hidden_args::hide_pos_args", "help::last_arg_mult_usage_with_sc", "require::required_unless_present_all", "build::arg::test::option_display_multiple_occurrences", "derive_order::prefer_user_help_in_subcommand_with_derive_order", "opts::opts_using_short", "flag_subcommands::flag_subcommand_conflict_with_help", "tests::sc_long_flag_long_opt", "require::positional_required_2", "empty_values::no_empty_values_with_equals", "require::positional_required", "help::complex_subcommand_help_output", "default_vals::multiple_defaults_override", "build::usage_parser::test::create_option_usage_both_equals1", "opts::short_eq_val_starts_with_eq", "help::complex_help_output", "propagate_globals::global_flag_used_top_level", "require::required_if_val_present_fail", "help::hide_possible_vals", "require::require_eq", "multiple_values::positional_min_more", "help::issue_1052_require_delim_help", "build::usage_parser::test::create_option_with_vals4_def", "delimiters::opt_s_eq_no_delim", "require::required_unless_any_works_with_short", "utf8::allow_validated_utf8_external_subcommand_values_of", "global_args::global_arg_available_in_subcommand", "help::prefer_user_subcmd_help_long_1112", "positionals::positional_multiple_3", "subcommands::subcommand_display_order", "flag_subcommands::flag_subcommand_long_short_normal_usage_string", "help::issue_1794_usage", "build::arg::test::option_display3", "build::app::tests::global_setting", "app_settings::allow_missing_positional_no_default", "app_settings::issue_1066_allow_leading_hyphen_and_unknown_args_no_vals", "help::option_usage_order", "default_vals::default_if_arg_present_with_value_with_default_user_override", "default_vals::opt_user_override", "multiple_values::option_min_less", "default_missing_vals::opt_missing", "default_vals::missing_with_value_delimiter", "indices::indices_mult_flags_combined", "arg_aliases_short::single_short_alias_of_option", "app_settings::aaos_opts_w_other_overrides_2", "groups::req_group_with_conflict_usage_string_only_options", "help::hide_default_val", "help::subcommand_short_help", "default_missing_vals::opt_present_with_value", "hidden_args::hide_long_args", "app_settings::args_negate_subcommands_one_level", "parse::matches::matched_arg::tests::test_grouped_vals_removal", "app_settings::leading_hyphen_opt", "app_settings::nested_help_subcommand_with_global_setting", "default_vals::opts", "version::mut_arg_version_no_auto_version", "multiple_values::number_of_values_preferred_over_value_names", "help::only_custom_heading_opts_no_args", "default_vals::default_if_arg_present_with_default", "app_settings::leading_hyphen_long", "help::last_arg_mult_usage", "help::last_arg_mult_usage_req", "arg_settings::unset_setting", "help::req_last_arg_usage", "app_settings::issue_1093_allow_ext_sc", "flags::flag_using_short", "groups::group_usage_use_val_name", "build::usage_parser::test::create_option_usage_long6", "empty_values::empty_values_with_equals", "require::issue_753", "posix_compatible::posix_compatible_flags_short_rev", "possible_values::possible_values_output", "version::propagate_version_short", "opts::require_equals_pass", "require::required_if_val_present_fail_error_output", "opts::issue_2279", "require::required_unless_err", "flag_subcommands::flag_subcommand_normal_with_alias", "opts::leading_hyphen_with_only_pos_follows", "app_settings::external_subcommand_looks_like_built_in", "subcommands::subcommand_placeholder_test", "opts::leading_hyphen_pass", "app_settings::aaos_pos_mult", "multiple_values::option_long", "conflicts::flag_conflict_with_everything", "tests::add_multiple_arg", "help::custom_headers_headers", "require::required_unless_any_works_with_long", "tests::sc_short_flag_x2_comb_short_opt_eq_pos", "help::subcommand_long_help", "help::positional_multiple_occurrences_is_dotted", "posix_compatible::require_overridden_2", "subcommands::issue_1031_args_with_same_name_no_more_vals", "app_settings::args_negate_subcommands_two_levels", "multiple_values::positional_max_less", "posix_compatible::require_overridden_4", "utf8::invalid_utf8_option_short_no_space", "subcommands::subcommand", "build::arg::test::option_display_single_alias", "utf8::invalid_utf8_lossy_positional", "possible_values::possible_values_of_positional_fail", "posix_compatible::posix_compatible_opts_long_equals_rev", "ignore_errors::multiple_args_and_intermittent_arg_without_value", "arg_aliases::alias_on_a_subcommand_option", "help::override_help_short", "opts::short_non_ascii_no_space", "build::usage_parser::test::pos_help_newline_lit_sq", "help::final_word_wrapping", "multiple_values::sep_short_space", "multiple_values::option_exact_more", "tests::sc_long_flag_x2_long_opt_eq_pos", "derive_order::prefer_user_help_with_derive_order", "require::arg_require_group", "flags::lots_o_flags_sep", "possible_values::possible_values_of_option_fail", "multiple_occurrences::max_occurrences_positional", "build::usage_parser::test::create_option_usage_both1", "posix_compatible::issue_1374_overrides_self_with_multiple_values", "app_settings::infer_subcommands_pass_exact_match", "multiple_values::positional_max_more", "require::required_if_val_present_ignore_case_fail", "multiple_values::option_short_min_more_single_occur", "conflicts::conflict_output", "help::help_required_and_given", "posix_compatible::posix_compatible_opts_short_rev", "borrowed::borrowed_args", "require::required_unless_all_with_any", "version::override_version_long_with_user_flag_no_version_flag", "app_settings::aaos_opts_mult", "version::version_flag_from_version_short", "tests::sc_short_flag_x2_comb_long_opt_pos", "possible_values::ignore_case_multiple", "opts::multiple_vals_pos_arg_delim", "groups::empty_group", "build::usage_parser::test::nonascii", "app_settings::delim_values_only_pos_follows_with_delim", "help::ripgrep_usage", "help::issue_626_variable_panic", "opts::require_delims", "multiple_values::req_delimiter_complex", "flags::issue_1284_argument_in_flag_style", "build::usage_parser::test::create_option_usage_both6", "help::prefer_about_over_long_about_in_subcommands_list", "build::arg::test::positional_display_val_names", "default_missing_vals::opt_default_user_override", "indices::indices_mult_flags_opt_combined_eq", "arg_settings::unset_setting_bitor", "build::arg::test::flag_display_multiple_aliases", "build::usage_parser::test::create_option_usage8", "output::help::test::wrap_help_last_word", "flag_subcommands::flag_subcommand_long", "build::usage_parser::test::pos_help_double_lit_single_quote", "utf8::invalid_utf8_lossy_option_long_equals", "multiple_values::sep_short_equals", "app_settings::stop_delim_values_only_pos_follows", "multiple_values::positional_min_exact", "help::no_wrap_help", "require::issue_1643_args_mutually_require_each_other", "possible_values::possible_values_of_option_multiple", "double_require::no_duplicate_error", "multiple_occurrences::max_occurrences_implies_multiple_occurrences", "possible_values::possible_value_arg_value", "arg_aliases::single_alias_of_option", "build::app::tests::issue_2090", "tests::long_opt_x2_pos", "possible_values::possible_values_alias_output", "version::version_about_multi_subcmd", "indices::indices_mult_opt_value_no_delim_eq", "opts::issue_1105_empty_value_long_explicit", "app_settings::subcommand_required_else_help_error_message", "posix_compatible::mult_flag_overrides_itself", "opts::stdin_char", "posix_compatible::posix_compatible_opts_short", "help::issue_1364_no_short_options", "tests::sc_short_flag_x2_comb_long_opt_eq_pos", "help::wrapping_newline_chars", "version::override_version_short_with_user_flag_long_still_works", "require::required_if_wrong_val", "utf8::invalid_utf8_option_long_space", "multiple_values::different_sep", "app_settings::issue_1066_allow_leading_hyphen_and_unknown_args_option", "global_args::propagate_global_arg_to_subcommand_in_subsubcommand_2053", "conflicts::conflict_with_unused_default", "multiple_values::issue_1480_max_values_consumes_extra_arg_1", "multiple_values::positional_exact_exact", "tests::sc_short_flag_long_opt_eq_pos", "build::arg::test::positional_display_val_names_req", "arg_aliases_short::short_alias_on_a_subcommand_option", "groups::group_single_value", "help::prefer_user_help_short_1112", "require::requires_if_present_val_no_present_pass", "help::old_newline_variables", "conflicts::flag_conflict_with_all", "flag_subcommands::flag_subcommand_short_with_args", "require::require_eq_filtered", "require::required_unless_present_any", "error::argument_not_found_auto_has_newline", "help::issue_777_wrap_all_things", "build::usage_parser::test::create_option_with_vals2", "app_settings::infer_subcommands_pass_close", "app_settings::subcommand_required_else_help", "flags::flag_using_long_with_literals", "opts::issue_1105_empty_value_long_fail", "indices::indices_mult_opt_mult_flag", "multiple_values::req_delimiter_short_with_equal", "opts::issue_1105_empty_value_short_fail", "utf8::invalid_utf8_option_short_space", "require::group_required", "tests::long_opt_eq_x2_pos", "hidden_args::hide_opt_args_only", "hidden_args::hide_short_args", "propagate_globals::global_arg_used_top_level", "arg_settings::setting_bitor", "subcommands::multiple_aliases", "app_settings::disable_help_subcommand", "flag_subcommands::flag_subcommand_long_normal_usage_string", "posix_compatible::posix_compatible_flags_long", "flags::lots_o_flags_combined", "arg_settings::setting", "derive_order::no_derive_order", "multiple_values::multiple_value_terminator_option_other_arg", "multiple_occurrences::max_occurrences_try_inputs", "build::usage_parser::test::create_option_usage1", "build::usage_parser::test::pos_req_mult_help", "build::usage_parser::test::pos_req_mult_def_help", "require::required_if_some_values_present_pass", "indices::indices_mult_flags_opt_combined", "opts::issue_2022_get_flags_misuse", "help::args_with_last_usage", "multiple_occurrences::multiple_occurrences_of_flags_mixed", "default_vals::default_if_arg_present_with_value_no_arg_with_default", "require::required_if_any_all_values_present_fail", "help::sc_negates_reqs", "require::option_required_2", "flag_subcommands::flag_subcommand_short_with_alias_same_as_short_flag", "default_vals::default_if_arg_present_no_arg_with_value_with_default_user_override_fail", "require::required_ifs_val_present_pass", "empty_values::no_empty_values", "positionals::multiple_positional_one_required_usage_string", "groups::group_acts_like_arg", "propagate_globals::global_flag_2x_used_inner", "tests::mut_arg_all", "build::usage_parser::test::create_option_usage_long_equals5", "opts::issue_1047_min_zero_vals_default_val", "posix_compatible::flag_overrides_itself", "default_vals::osstr_opt_user_override", "indices::index_flags", "subcommands::subcmd_did_you_mean_output_arg", "opts::require_equals_min_values_zero", "default_vals::default_ifs_arg_present_order", "flag_subcommands::flag_subcommand_conflict_with_version", "multiple_values::no_sep", "require::positional_required_with_requires_if_value", "build::usage_parser::test::create_option_usage9", "help::multiple_custom_help_headers", "default_vals::default_if_arg_present_no_default", "build::arg::test::flag_display_single_alias", "groups::group_multi_value_single_arg", "multiple_values::issue_2229", "default_vals::default_if_arg_present_no_arg_with_value_with_default_user_override", "utf8::invalid_utf8_strict_positional", "conflicts::arg_conflicts_with_required_group", "help::override_help_about", "multiple_values::sep_positional", "build::usage_parser::test::pos_help_lit_single_quote", "require::group_required_2", "posix_compatible::mult_option_overrides_itself", "build::usage_parser::test::create_option_usage_long_equals7", "tests::short_opt_eq_x2_pos", "app_settings::aaos_opts_mult_req_delims", "build::usage_parser::test::create_option_usage_both7", "multiple_values::option_max_more", "app_settings::no_auto_version", "posix_compatible::incremental_override", "utf8::invalid_utf8_lossy_option_short_space", "double_require::help_text", "multiple_values::positional_exact_more", "app_settings::leading_double_hyphen_trailingvararg", "positionals::ignore_hyphen_values_on_last", "app_settings::sub_command_negate_required_2", "help::issue_626_panic", "opts::did_you_mean", "opts::require_delims_no_delim", "positionals::last_positional_second_to_last_mult", "help::issue_2508_number_of_values_with_single_value_name", "multiple_values::low_index_positional_with_flag", "flags::multiple_flags_in_single", "arg_aliases_short::single_short_alias_of_flag", "build::usage_parser::test::create_option_with_vals5", "delimiters::opt_default_no_delim", "help::help_subcmd_help", "help::no_wrap_default_help", "help::show_long_about_issue_897", "tests::sc_short_flag_long_opt_pos", "subcommands::issue_2494_subcommand_is_present", "default_vals::default_if_arg_present_with_value_no_default", "default_vals::with_value_delimiter", "app_settings::sub_command_negate_required", "tests::short_flag_x2_comb_short_opt_pos", "help::only_custom_heading_pos_no_args", "positionals::single_positional_required_usage_string", "arg_aliases::visible_arg_aliases_help_output", "default_vals::default_ifs_arg_present_user_override", "arg_aliases::multiple_aliases_of_option", "help::issue_1571", "default_vals::default_if_arg_present_with_value_no_default_fail", "build::usage_parser::test::create_option_usage0", "tests::sc_short_flag_x2_long_opt_pos", "conflicts::required_group_conflicts_with_arg", "positionals::multiple_positional_usage_string", "help::subcmd_help_subcmd_help", "utf8::invalid_utf8_lossy_option_short_equals", "build::usage_parser::test::create_option_usage_long_equals4", "conflicts::flag_conflict", "opts::leading_hyphen_with_flag_before", "utf8::invalid_utf8_lossy_option_short_no_space", "app_settings::dont_collapse_args", "validators::stateful_validator", "subcommands::subcommand_multiple", "tests::sc_long_flag_x2_short_opt_pos", "conflicts::conflict_output_three_conflicting", "help::missing_positional_final_multiple", "build::usage_parser::test::value_names_building_num_vals_from_usage", "help::subcommand_help_doesnt_have_useless_help_flag", "build::usage_parser::test::create_positional_usage0", "require::required_if_all_values_present_pass", "groups::group_reqired_flags_empty", "app_settings::allow_missing_positional", "default_vals::no_default_if_arg_present_no_arg_with_value_with_default", "multiple_values::value_names_building_num_vals", "help::custom_heading_pos", "app_settings::issue_1066_allow_leading_hyphen_and_unknown_args", "multiple_values::multiple_value_terminator_option", "tests::sc_long_flag_x2_long_opt_pos", "require::requires_if_present_val", "default_vals::default_ifs_arg_present", "utf8::invalid_utf8_strict_option_short_no_space", "multiple_values::different_sep_positional", "flag_subcommands::flag_subcommand_short_normal_usage_string", "app_settings::delim_values_only_pos_follows", "help::args_negate_sc", "double_require::valid_cases", "template_help::template_author_version", "build::usage_parser::test::pos_help_newline", "positionals::single_positional_multiple_usage_string", "parse::matches::arg_matches::tests::test_default_indices", "posix_compatible::posix_compatible_opts_long_equals", "multiple_values::positional", "version::version_flag_from_version_long", "build::usage_parser::test::create_option_usage_long2", "build::usage_parser::test::create_option_usage_long10", "help::wrapping_newline_variables", "derive_order::derive_order_subcommand_propagate", "subcommands::subcmd_did_you_mean_output_ambiguous", "multiple_values::option_min_exact", "build::arg::test::flag_display_multiple_short_aliases", "groups::required_group_missing_arg", "build::usage_parser::test::create_option_usage_both_equals8", "require::required_unless_any_works_with_short_err", "possible_values::ignore_case", "multiple_values::values_per_occurrence_positional", "template_help::with_template", "build::usage_parser::test::create_option_usage_both3", "subcommands::alias_help", "default_vals::positionals", "opts::require_equals_no_empty_values_fail", "version::version_flag_from_long_version_long", "app_settings::infer_subcommands_pass", "multiple_values::sep_long_space", "conflicts::arg_conflicts_with_group", "app_settings::unset_global_setting", "help::prefer_user_help_long_1112", "build::usage_parser::test::create_option_usage_both_equals3", "build::usage_parser::test::create_option_usage_both_equals7", "error::value_validation_has_newline", "help::help_about_multi_subcmd", "tests::long_flag_long_opt_pos", "possible_values::possible_values_of_positional_multiple_fail", "opts::issue_1105_empty_value_long_equals", "flag_subcommands::flag_subcommand_long_with_alias_same_as_long_flag", "help::escaped_whitespace_values", "default_vals::positional_user_override", "parse::matches::arg_matches::tests::test_default_osvalues_with_shorter_lifetime", "positionals::last_positional", "utf8::ignore_invalid_utf8_with_defaults", "build::usage_parser::test::create_option_usage_long4", "require::required_if_all_values_present_fail", "multiple_values::option_exact_exact_not_mult", "help::dont_propagate_version_to_help_subcommand", "build::arg::test::option_display_multiple_short_aliases", "opts::leading_hyphen_fail", "possible_values::escaped_possible_values_output", "app_settings::skip_possible_values", "help::ripgrep_usage_using_templates", "opts::issue_1073_suboptimal_flag_suggestion", "multiple_occurrences::multiple_occurrences_of_flags_long", "positionals::positional_hyphen_does_not_panic", "help::issue_702_multiple_values", "positionals::only_pos_follow", "help::disabled_help_flag_and_subcommand", "conflicts::conflict_output_rev", "app_settings::missing_positional_no_hyphen", "delimiters::opt_eq_mult_def_delim", "version::mut_version_long", "conflicts::two_conflicting_arguments", "indices::index_flag", "build::usage_parser::test::create_option_usage_long_equals6", "require::required_unless_present", "version::no_version_flag_long", "build::arg::test::positional_display_required", "help::help_no_subcommand", "possible_values::possible_values_of_positional", "multiple_values::multiple_vals_with_hyphen", "require::required_if_val_present_ignore_case_pass", "help::show_short_about_issue_897", "opts::issue_1105_empty_value_short_explicit", "utf8::invalid_utf8_strict_option_short_space", "posix_compatible::pos_required_overridden_by_flag", "build::usage_parser::test::create_option_usage_long_equals3", "derive_order::derive_order_subcommand_propagate_with_explicit_display_order", "utf8::ignore_validated_utf8_with_defaults", "positionals::last_positional_no_double_dash", "multiple_values::low_index_positional", "utf8::allow_validated_utf8_value_of", "build::usage_parser::test::create_option_usage_both_equals5", "build::usage_parser::test::create_option_usage7", "indices::index_mult_opts", "build::arg::test::option_display_multiple_aliases", "posix_compatible::posix_compatible_flags_short", "require::short_flag_require_equals_with_minvals_zero", "tests::create_app", "default_vals::no_default_if_arg_present_with_value_no_default", "posix_compatible::posix_compatible_opts_long", "default_vals::default_if_arg_present_with_value_no_default_user_override", "multiple_values::option_max_less", "require::required_if_any_all_values_present_pass", "subcommands::issue_1161_multiple_hyphen_hyphen", "hidden_args::hide_args", "opts::require_equals_fail_message", "subcommands::subcommand_used_after_double_dash", "build::usage_parser::test::pos_mult_help", "indices::indices_mult_opt_value_delim_eq", "require::required_unless_all_err", "tests::sc_short_flag_x2_short_opt_pos", "help::after_and_before_help_output", "help::arg_short_conflict_with_help", "help::hide_args", "flag_subcommands::flag_subcommand_short_after_long_arg", "help::help_required_and_no_args", "arg_aliases_short::invisible_short_arg_aliases_help_output", "ignore_errors::single_short_arg_without_value", "subcommands::visible_aliases_help_output", "app_settings::allow_negative_numbers_fail", "help::issue_760", "build::usage_parser::test::pos_mult", "positionals::issue_946", "arg_aliases_short::multiple_short_aliases_of_flag", "flag_subcommands::flag_subcommand_multiple", "help::hide_single_possible_val", "app_settings::aaos_flags_mult", "default_vals::default_if_arg_present_no_arg_with_default_user_override", "build::usage_parser::test::issue_665", "possible_values::alias", "possible_values::ignore_case_multiple_fail", "possible_values::ignore_case_fail", "help::positional_multiple_values_is_dotted", "build::usage_parser::test::create_option_usage_long5", "positionals::missing_required_2", "delimiters::opt_eq_no_delim", "default_vals::opt_without_value_fail", "subcommands::invisible_aliases_help_output", "multiple_values::no_sep_positional", "default_vals::no_default_if_arg_present_with_value_with_default", "version::no_version_flag_short", "default_vals::conditional_reqs_pass", "help::issue_1046_hide_scs", "propagate_globals::global_flag_used_inner", "app_settings::unset_setting_bitor", "build::app::tests::global_settings", "build::usage_parser::test::create_option_usage6", "help::help_required_and_given_for_subcommand", "opts::issue_1105_empty_value_short_equals", "utf8::invalid_utf8_positional", "tests::sc_long_flag_x2_short_opt_eq_pos", "parse::matches::arg_matches::tests::test_default_values", "app_settings::color_is_global"], "failed_tests": ["subcommands::subcommand_not_recognized", "validators::test_validator_msg_newline"], "skipped_tests": []}
{"passed_count": 828, "failed_count": 0, "skipped_count": 0, "passed_tests": ["tests::sc_long_flag_long_opt_eq_pos", "default_vals::default_if_arg_present_no_default_user_override", "app_settings::allow_ext_sc_when_sc_required", "arg_aliases::multiple_aliases_of_flag", "indices::indices_mult_opts", "basic", "groups::req_group_usage_string", "posix_compatible::conflict_overridden", "propagate_globals::global_arg_used_outer", "build::usage_parser::test::create_option_usage2", "build::usage_parser::test::create_option_usage_both2", "app_settings::infer_subcommands_fail_with_args2", "subcommands::single_alias", "version::no_propagation_by_default_long", "help::multi_level_sc_help", "build::usage_parser::test::create_option_usage_long1", "require::required_ifs_wrong_val_mult_fail", "help::override_help_long", "output::help::test::display_width_handles_emojis", "flag_subcommands::flag_subcommand_long_with_alias", "app_settings::single_arg_help_with_long_format_setting", "build::usage_parser::test::create_option_usage_both4", "app_settings::no_bin_name", "conflicts::conflict_output_rev_with_required", "help::help_about_multi_subcmd_override", "parse::matches::matched_arg::tests::test_grouped_vals_push_and_append", "opts::lots_o_vals", "opts::opts_using_long_space", "version::version_flag_from_long_version_short", "groups::group_multiple_args_error", "default_missing_vals::opt_default", "build::arg::test::option_display_multiple_values", "posix_compatible::option_overrides_itself", "version::mut_version_short", "template_help::template_unknowntag", "default_missing_vals::opt_present_with_empty_value", "parse::matches::arg_matches::tests::test_default_values_with_shorter_lifetime", "default_vals::default_if_arg_present_with_default_user_override", "possible_values::missing_possible_value_error", "require::list_correct_required_args", "opts::default_values_user_value", "utf8::invalid_utf8_strict_option_short_equals", "default_vals::no_default_ifs_arg_present", "possible_values::aliases", "require::positional_required_with_requires_if_no_value", "multiple_values::positional_min_less", "template_help::template_notag", "build::arg::test::option_display2", "multiple_values::low_index_positional_with_option", "require::arg_require_group_3", "quoted_app_name", "multiple_values::low_index_positional_in_subcmd", "positionals::positional", "app_settings::use_long_format_for_help_subcommand_with_setting", "subcommands::subcommand_after_argument", "multiple_occurrences::multiple_occurrences_of_flags_short", "validators::test_validator_fromstr_trait", "delimiters::opt_s_no_space_mult_no_delim", "multiple_values::req_delimiter_short_with_no_space", "help::subcommand_help_rev", "positionals::single_positional_usage_string", "app_settings::no_auto_help", "opts::multiple_vals_pos_arg_equals", "opts::infer_long_arg", "validators::test_validator_msg_newline", "build::arg_group::test::groups", "default_missing_vals::opt_present_with_missing_value", "multiple_values::values_per_occurrence_named", "group_macro_set_multiple", "multiple_values::option_short_min_more_mult_occurs", "app_settings::infer_subcommands_fail_no_args", "flag_subcommands::flag_subcommand_short_with_aliases_vis_and_hidden", "arg_aliases::invisible_arg_aliases_help_output", "help::issue_626_unicode_cutoff", "default_vals::osstr_positionals", "help::last_arg_mult_usage_req_with_sc", "require::required_unless_any_err", "utf8::invalid_utf8_option_long_equals", "build::arg_group::test::arg_group_send_sync", "app_settings::sub_command_required", "propagate_globals::global_arg_used_inner", "require::required_ifs_val_present_fail", "conflicts::conflict_output_with_required", "build::usage_parser::test::create_option_usage_both5", "flag_subcommands::flag_subcommand_short", "require::issue_2624", "conflicts::conflicts_with_alongside_default", "hidden_args::hide_subcmds_only", "require::group_required_3", "app_settings::propagate_vals_down", "flag_subcommands::flag_subcommand_normal", "template_help::template_empty", "default_missing_vals::default_missing_value_flag_value", "ignore_errors::multiple_args_and_final_arg_without_value", "multiple_values::sep_long_equals", "template_help::custom_template", "global_args::propagate_global_arg_in_subcommand_to_subsubcommand_1385", "opts::opts_using_long_equals", "flag_subcommands::flag_subcommand_short_with_aliases", "arg_aliases::single_alias_of_flag", "ignore_errors::single_long_arg_without_value", "error::app_error", "build::usage_parser::test::create_option_usage_long_equals9", "propagate_globals::global_flag_used_outer", "require::required_ifs_wrong_val", "require::required_unless_any_works_without", "subcommands::subcmd_did_you_mean_output", "utf8::refuse_invalid_utf8_subcommand_when_args_are_allowed_with_allow_external_subcommands", "require::issue_1158_conflicting_requirements_rev", "build::usage_parser::test::create_option_with_vals1_def", "flags::flag_using_mixed", "help::help_subcommand", "tests::sc_short_flag_x2_short_opt_eq_pos", "multiple_values::option_max_exact", "possible_values::possible_values_of_positional_multiple", "help::issue_688_hide_pos_vals", "app_settings::delim_values_trailingvararg_with_delim", "build::usage_parser::test::create_option_usage_long9", "app_settings::require_eq", "utf8::allow_invalid_utf8_subcommand_args_with_allow_external_subcommands", "opts::opts_using_mixed", "flag_subcommands::flag_subcommand_long_infer_fail", "posix_compatible::conflict_overridden_3", "hidden_args::hide_short_args_long_help", "build::usage_parser::test::create_option_usage_both_equals2", "multiple_values::option_exact_exact_mult", "require::requires_if_present_mult_pass", "positionals::positional_multiple", "help::help_short", "help::after_and_before_long_help_output", "posix_compatible::mult_option_require_delim_overrides_itself", "build::arg::test::positional_display_multiple_values", "delimiters::opt_s_default_no_delim", "utf8::invalid_utf8_lossy_option_long_space", "positionals::lots_o_vals", "opts::opts_using_mixed2", "build::arg::tests::arg_send_sync", "app_settings::leading_hyphen_short", "require::required_if_val_present_pass", "app_settings::unset_on_global_setting", "flag_subcommands::flag_subcommand_long_infer_pass_close", "help::issue_1642_long_help_spacing", "build::usage_parser::test::create_option_with_vals1", "parse::matches::arg_matches::tests::values_exact_size", "possible_values::possible_values_of_option", "multiple_values::value_names_building_num_vals_for_positional", "tests::long_flag_long_opt_eq_pos", "flag_subcommands::flag_subcommand_long_infer_exact_match", "build::usage_parser::test::create_option_usage_long_equals8", "version::no_propagation_by_default_short", "default_vals::default_vals_donnot_show_in_smart_usage", "utf8::invalid_utf8_strict_option_long_space", "require::flag_required_2", "require::issue_1158_conflicting_requirements", "build::usage_parser::test::create_option_usage_both8", "require::positional_required_with_requires", "flags::issue_2308_multiple_dashes", "build::usage_parser::test::pos_req", "default_vals::default_if_arg_present_no_arg_with_default", "group_macro", "app_settings::aaos_opts_w_other_overrides_rev_2", "build::usage_parser::test::create_option_usage_both_equals4", "empty_values::no_empty_values_without_equals", "subcommands::subcommand_not_recognized", "parse::matches::arg_matches::tests::test_default_indices_with_shorter_lifetime", "require::required_unless_present_with_optional_value", "help::long_about", "tests::sc_short_flag_short_opt_eq_pos", "default_vals::default_if_arg_present_with_value_no_arg_with_default_fail", "groups::req_group_with_conflict_usage_string", "opts::require_equals_empty_vals_pass", "tests::sc_short_flag_x2_comb_short_opt_pos", "app_settings::arg_required_else_help_error_message", "flags::flag_using_long", "build::usage_parser::test::create_flag_usage", "opts::leading_hyphen_with_flag_after", "parse::matches::arg_matches::tests::indices_exact_size", "arg::short", "default_vals::issue_1050_num_vals_and_defaults", "require::required_unless_any_1", "require::multiple_required_unless_usage_printing", "propagate_globals::global_arg_default_value", "possible_values::possible_values_hidden_output", "help::after_help_no_args", "require::missing_required_output", "output::help::test::display_width_handles_non_ascii", "multiple_occurrences::multiple_occurrences_of_flags_large_quantity", "flag_subcommands::flag_subcommand_long_with_aliases", "build::usage_parser::test::create_option_usage_long3", "posix_compatible::conflict_overridden_4", "build::arg::test::flag_display", "positionals::positional_possible_values", "help::disabled_help_flag", "default_vals::multiple_defaults", "multiple_values::option_exact_exact", "require::flag_required", "app_settings::infer_subcommands_fail_with_args", "parse::matches::arg_matches::tests::os_values_exact_size", "derive_order::derive_order", "arg_aliases_short::visible_short_arg_aliases_help_output", "default_vals::osstr_positional_user_override", "multiple_values::req_delimiter_long", "version::override_version_short_with_user_flag", "default_vals::osstr_opts", "build::arg::test::positional_display_multiple_occurrences", "global_args::issue_1076", "help::custom_help_headers_hide_args", "help::issue_1487", "tests::flag_x2_opt", "tests::sc_short_flag_short_opt_pos", "help::help_required_locally_but_not_given_for_subcommand", "help::help_long", "app_settings::aaos_option_use_delim_false", "multiple_values::req_delimiter_short_with_space", "build::usage_parser::test::create_option_usage_long_equals10", "default_vals::default_if_arg_present_with_value_with_default", "multiple_values::issue_1480_max_values_consumes_extra_arg_3", "require::required_unless_any_2", "app_settings::arg_required_else_help_over_reqs", "app_settings::setting", "indices::indices_mult_flags", "conflicts::arg_conflicts_with_group_with_multiple_sources", "posix_compatible::posix_compatible_flags_long_rev", "require::require_eq_filtered_group", "delimiters::opt_s_no_space_no_delim", "require::option_required", "build::usage_parser::test::create_option_with_vals3", "posix_compatible::require_overridden_3", "build::usage_parser::test::create_option_usage_long_equals1", "posix_compatible::pos_mult_overrides_itself", "flag_subcommands::flag_subcommand_long_infer_pass", "app_settings::aaos_opts_w_other_overrides_rev", "build::usage_parser::test::create_option_usage_long8", "empty_values::empty_values", "app_settings::aaos_opts_w_other_overrides", "flag_subcommands::flag_subcommand_short_with_alias", "multiple_values::option_short", "display_order::very_large_display_order", "build::usage_parser::test::create_option_with_vals4", "help::override_help_subcommand", "multiple_values::req_delimiter_long_with_equal", "groups::required_group_multiple_args", "build::usage_parser::test::create_positional_usage", "ignore_errors::subcommand", "opts::long_eq_val_starts_with_eq", "subcommands::subcommand_after_argument_looks_like_help", "tests::sc_short_flag_x2_long_opt_eq_pos", "build::app::tests::propagate_version", "hidden_args::hide_subcmds", "help::override_help_flag_using_short", "subcommands::subcmd_did_you_mean_output_arg_false_positives", "hidden_args::hide_pos_args_only", "opts::issue_1105_empty_value_short_explicit_no_space", "utf8::allow_invalid_utf8_value_of_os", "build::usage_parser::test::create_option_usage_long7", "propagate_globals::global_flag_2x_used_top_level", "groups::group_single_flag", "arg_aliases_short::multiple_short_aliases_of_option", "build::arg::test::option_display_single_short_alias", "positionals::create_positional", "subcommands::subcommand_none_given", "build::usage_parser::test::create_option_usage4", "utf8::allow_invalid_utf8_external_subcommand_values_of_os", "multiple_values::option_mixed", "tests::short_opt_x2_pos", "conflicts::group_conflicts_with_arg", "default_vals::no_default_if_arg_present_with_value_with_default_user_override", "app_settings::setting_bitor", "app_settings::infer_subcommands_fail_suggestions", "conflicts::three_conflicting_arguments", "posix_compatible::posix_compatible_opts_long_rev", "tests::sc_long_flag_short_opt_pos", "app_settings::aaos_flags", "utf8::refuse_invalid_utf8_subcommand_args_with_allow_external_subcommands", "opts::double_hyphen_as_value", "parse::matches::matched_arg::tests::test_grouped_vals_first", "subcommands::issue_1722_not_emit_error_when_arg_follows_similar_to_a_subcommand", "hidden_args::hide_long_args_short_help", "require::arg_require_group_2", "build::usage_parser::test::create_option_usage3", "posix_compatible::option_use_delim_false_override_itself", "arg_impl::string_literal", "app_settings::aaos_opts", "build::usage_parser::test::create_option_usage5", "app_settings::unset_setting", "parse::matches::arg_matches::tests::test_default_osvalues", "build::usage_parser::test::create_option_usage_both_equals6", "tests::short_flag_short_opt_pos", "conflicts::flag_conflict_2", "multiple_values::option_exact_less", "app_settings::missing_positional_hyphen", "empty_values::no_empty_values_without_equals_but_requires_equals", "build::app::tests::app_send_sync", "possible_values::possible_values_of_option_multiple_fail", "positionals::positional_multiple_2", "help::old_newline_chars", "multiple_occurrences::multiple_occurrences_of_positional", "group_macro_set_not_multiple", "utf8::invalid_utf8_strict_option_long_equals", "opts::require_equals_fail", "build::arg_group::test::test_from", "app_settings::arg_required_else_help", "app_settings::missing_positional_hyphen_req_error", "help::disable_help_flag_affects_help_subcommand", "posix_compatible::conflict_overridden_2", "app_settings::global_setting", "multiple_values::issue_1480_max_values_consumes_extra_arg_2", "app_settings::dont_delim_values_trailingvararg", "multiple_values::positional_exact_less", "help::prefer_user_subcmd_help_short_1112", "help::missing_positional_final_required", "build::arg::test::flag_display_single_short_alias", "arg::name_explicit", "subcommands::issue_1031_args_with_same_name", "build::usage_parser::test::create_option_usage_long_equals2", "version::propagate_version_long", "quoted_arg_name", "utf8::refuse_invalid_utf8_subcommand_with_allow_external_subcommands", "multiple_values::sep_short_no_space", "app_settings::no_auto_version_mut_arg", "multiple_values::positional_max_exact", "require::requires_if_present_mult", "app_settings::delim_values_trailingvararg", "app_settings::issue_1437_allow_hyphen_values_for_positional_arg", "help::override_help_flag_using_long", "groups::group_empty", "utf8::invalid_utf8_option_short_equals", "version::override_version_long_with_user_flag", "app_settings::allow_negative_numbers", "app_settings::missing_positional_hyphen_far_back", "hidden_args::hide_pos_args", "help::last_arg_mult_usage_with_sc", "require::required_unless_present_all", "build::arg::test::option_display_multiple_occurrences", "derive_order::prefer_user_help_in_subcommand_with_derive_order", "opts::opts_using_short", "flag_subcommands::flag_subcommand_conflict_with_help", "tests::sc_long_flag_long_opt", "require::positional_required_2", "arg::short_and_long", "empty_values::no_empty_values_with_equals", "require::positional_required", "help::complex_subcommand_help_output", "default_vals::multiple_defaults_override", "build::usage_parser::test::create_option_usage_both_equals1", "opts::short_eq_val_starts_with_eq", "help::complex_help_output", "propagate_globals::global_flag_used_top_level", "require::required_if_val_present_fail", "help::hide_possible_vals", "require::require_eq", "multiple_values::positional_min_more", "arg::name_from_long", "help::issue_1052_require_delim_help", "build::usage_parser::test::create_option_with_vals4_def", "delimiters::opt_s_eq_no_delim", "require::required_unless_any_works_with_short", "utf8::allow_validated_utf8_external_subcommand_values_of", "global_args::global_arg_available_in_subcommand", "help::prefer_user_subcmd_help_long_1112", "positionals::positional_multiple_3", "subcommands::subcommand_display_order", "help::issue_1794_usage", "flag_subcommands::flag_subcommand_long_short_normal_usage_string", "build::arg::test::option_display3", "build::app::tests::global_setting", "app_settings::allow_missing_positional_no_default", "app_settings::issue_1066_allow_leading_hyphen_and_unknown_args_no_vals", "help::option_usage_order", "default_vals::default_if_arg_present_with_value_with_default_user_override", "default_vals::opt_user_override", "multiple_values::option_min_less", "default_missing_vals::opt_missing", "default_vals::missing_with_value_delimiter", "indices::indices_mult_flags_combined", "arg_aliases_short::single_short_alias_of_option", "app_settings::aaos_opts_w_other_overrides_2", "groups::req_group_with_conflict_usage_string_only_options", "help::hide_default_val", "help::subcommand_short_help", "default_missing_vals::opt_present_with_value", "hidden_args::hide_long_args", "app_settings::args_negate_subcommands_one_level", "parse::matches::matched_arg::tests::test_grouped_vals_removal", "app_settings::leading_hyphen_opt", "app_settings::nested_help_subcommand_with_global_setting", "default_vals::opts", "version::mut_arg_version_no_auto_version", "multiple_values::number_of_values_preferred_over_value_names", "help::only_custom_heading_opts_no_args", "default_vals::default_if_arg_present_with_default", "app_settings::leading_hyphen_long", "help::last_arg_mult_usage_req", "help::last_arg_mult_usage", "arg_settings::unset_setting", "help::req_last_arg_usage", "app_settings::issue_1093_allow_ext_sc", "flags::flag_using_short", "groups::group_usage_use_val_name", "build::usage_parser::test::create_option_usage_long6", "empty_values::empty_values_with_equals", "require::issue_753", "posix_compatible::posix_compatible_flags_short_rev", "possible_values::possible_values_output", "version::propagate_version_short", "opts::require_equals_pass", "require::required_if_val_present_fail_error_output", "opts::issue_2279", "require::required_unless_err", "flag_subcommands::flag_subcommand_normal_with_alias", "opts::leading_hyphen_with_only_pos_follows", "app_settings::external_subcommand_looks_like_built_in", "subcommands::subcommand_placeholder_test", "opts::leading_hyphen_pass", "app_settings::aaos_pos_mult", "multiple_values::option_long", "conflicts::flag_conflict_with_everything", "tests::add_multiple_arg", "require::required_unless_any_works_with_long", "help::custom_headers_headers", "tests::sc_short_flag_x2_comb_short_opt_eq_pos", "help::subcommand_long_help", "help::positional_multiple_occurrences_is_dotted", "posix_compatible::require_overridden_2", "subcommands::issue_1031_args_with_same_name_no_more_vals", "app_settings::args_negate_subcommands_two_levels", "multiple_values::positional_max_less", "posix_compatible::require_overridden_4", "utf8::invalid_utf8_option_short_no_space", "subcommands::subcommand", "build::arg::test::option_display_single_alias", "utf8::invalid_utf8_lossy_positional", "possible_values::possible_values_of_positional_fail", "posix_compatible::posix_compatible_opts_long_equals_rev", "ignore_errors::multiple_args_and_intermittent_arg_without_value", "arg_aliases::alias_on_a_subcommand_option", "help::override_help_short", "opts::short_non_ascii_no_space", "build::usage_parser::test::pos_help_newline_lit_sq", "help::final_word_wrapping", "multiple_values::sep_short_space", "multiple_values::option_exact_more", "tests::sc_long_flag_x2_long_opt_eq_pos", "derive_order::prefer_user_help_with_derive_order", "require::arg_require_group", "flags::lots_o_flags_sep", "possible_values::possible_values_of_option_fail", "multiple_occurrences::max_occurrences_positional", "build::usage_parser::test::create_option_usage_both1", "posix_compatible::issue_1374_overrides_self_with_multiple_values", "app_settings::infer_subcommands_pass_exact_match", "multiple_values::positional_max_more", "require::required_if_val_present_ignore_case_fail", "multiple_values::option_short_min_more_single_occur", "conflicts::conflict_output", "help::help_required_and_given", "posix_compatible::posix_compatible_opts_short_rev", "borrowed::borrowed_args", "require::required_unless_all_with_any", "version::override_version_long_with_user_flag_no_version_flag", "app_settings::aaos_opts_mult", "version::version_flag_from_version_short", "tests::sc_short_flag_x2_comb_long_opt_pos", "possible_values::ignore_case_multiple", "opts::multiple_vals_pos_arg_delim", "groups::empty_group", "build::usage_parser::test::nonascii", "app_settings::delim_values_only_pos_follows_with_delim", "help::ripgrep_usage", "help::issue_626_variable_panic", "opts::require_delims", "multiple_values::req_delimiter_complex", "flags::issue_1284_argument_in_flag_style", "build::usage_parser::test::create_option_usage_both6", "help::prefer_about_over_long_about_in_subcommands_list", "build::arg::test::positional_display_val_names", "default_missing_vals::opt_default_user_override", "indices::indices_mult_flags_opt_combined_eq", "arg_settings::unset_setting_bitor", "build::arg::test::flag_display_multiple_aliases", "build::usage_parser::test::create_option_usage8", "output::help::test::wrap_help_last_word", "flag_subcommands::flag_subcommand_long", "build::usage_parser::test::pos_help_double_lit_single_quote", "utf8::invalid_utf8_lossy_option_long_equals", "multiple_values::sep_short_equals", "arg_impl::string_ident", "app_settings::stop_delim_values_only_pos_follows", "multiple_values::positional_min_exact", "help::no_wrap_help", "require::issue_1643_args_mutually_require_each_other", "possible_values::possible_values_of_option_multiple", "arg_impl::char_ident", "double_require::no_duplicate_error", "multiple_occurrences::max_occurrences_implies_multiple_occurrences", "possible_values::possible_value_arg_value", "arg_aliases::single_alias_of_option", "build::app::tests::issue_2090", "tests::long_opt_x2_pos", "possible_values::possible_values_alias_output", "version::version_about_multi_subcmd", "indices::indices_mult_opt_value_no_delim_eq", "opts::issue_1105_empty_value_long_explicit", "app_settings::subcommand_required_else_help_error_message", "posix_compatible::mult_flag_overrides_itself", "opts::stdin_char", "posix_compatible::posix_compatible_opts_short", "help::issue_1364_no_short_options", "tests::sc_short_flag_x2_comb_long_opt_eq_pos", "help::wrapping_newline_chars", "version::override_version_short_with_user_flag_long_still_works", "require::required_if_wrong_val", "utf8::invalid_utf8_option_long_space", "multiple_values::different_sep", "app_settings::issue_1066_allow_leading_hyphen_and_unknown_args_option", "global_args::propagate_global_arg_to_subcommand_in_subsubcommand_2053", "conflicts::conflict_with_unused_default", "multiple_values::issue_1480_max_values_consumes_extra_arg_1", "quoted_arg_long_name", "multiple_values::positional_exact_exact", "tests::sc_short_flag_long_opt_eq_pos", "build::arg::test::positional_display_val_names_req", "arg_aliases_short::short_alias_on_a_subcommand_option", "groups::group_single_value", "help::prefer_user_help_short_1112", "require::requires_if_present_val_no_present_pass", "help::old_newline_variables", "conflicts::flag_conflict_with_all", "flag_subcommands::flag_subcommand_short_with_args", "require::require_eq_filtered", "require::required_unless_present_any", "error::argument_not_found_auto_has_newline", "help::issue_777_wrap_all_things", "build::usage_parser::test::create_option_with_vals2", "app_settings::infer_subcommands_pass_close", "app_settings::subcommand_required_else_help", "flags::flag_using_long_with_literals", "opts::issue_1105_empty_value_long_fail", "indices::indices_mult_opt_mult_flag", "multiple_values::req_delimiter_short_with_equal", "opts::issue_1105_empty_value_short_fail", "utf8::invalid_utf8_option_short_space", "require::group_required", "tests::long_opt_eq_x2_pos", "hidden_args::hide_opt_args_only", "hidden_args::hide_short_args", "propagate_globals::global_arg_used_top_level", "arg_settings::setting_bitor", "subcommands::multiple_aliases", "app_settings::disable_help_subcommand", "multiarg", "flag_subcommands::flag_subcommand_long_normal_usage_string", "posix_compatible::posix_compatible_flags_long", "flags::lots_o_flags_combined", "arg_settings::setting", "derive_order::no_derive_order", "multiple_values::multiple_value_terminator_option_other_arg", "multiple_occurrences::max_occurrences_try_inputs", "build::usage_parser::test::create_option_usage1", "build::usage_parser::test::pos_req_mult_help", "build::usage_parser::test::pos_req_mult_def_help", "require::required_if_some_values_present_pass", "indices::indices_mult_flags_opt_combined", "opts::issue_2022_get_flags_misuse", "help::args_with_last_usage", "multiple_occurrences::multiple_occurrences_of_flags_mixed", "default_vals::default_if_arg_present_with_value_no_arg_with_default", "require::required_if_any_all_values_present_fail", "help::sc_negates_reqs", "require::option_required_2", "flag_subcommands::flag_subcommand_short_with_alias_same_as_short_flag", "default_vals::default_if_arg_present_no_arg_with_value_with_default_user_override_fail", "require::required_ifs_val_present_pass", "empty_values::no_empty_values", "positionals::multiple_positional_one_required_usage_string", "groups::group_acts_like_arg", "propagate_globals::global_flag_2x_used_inner", "tests::mut_arg_all", "build::usage_parser::test::create_option_usage_long_equals5", "opts::issue_1047_min_zero_vals_default_val", "posix_compatible::flag_overrides_itself", "default_vals::osstr_opt_user_override", "indices::index_flags", "subcommands::subcmd_did_you_mean_output_arg", "opts::require_equals_min_values_zero", "default_vals::default_ifs_arg_present_order", "flag_subcommands::flag_subcommand_conflict_with_version", "multiple_values::no_sep", "require::positional_required_with_requires_if_value", "build::usage_parser::test::create_option_usage9", "help::multiple_custom_help_headers", "default_vals::default_if_arg_present_no_default", "build::arg::test::flag_display_single_alias", "groups::group_multi_value_single_arg", "multiple_values::issue_2229", "default_vals::default_if_arg_present_no_arg_with_value_with_default_user_override", "utf8::invalid_utf8_strict_positional", "conflicts::arg_conflicts_with_required_group", "help::override_help_about", "multiple_values::sep_positional", "build::usage_parser::test::pos_help_lit_single_quote", "require::group_required_2", "posix_compatible::mult_option_overrides_itself", "build::usage_parser::test::create_option_usage_long_equals7", "tests::short_opt_eq_x2_pos", "app_settings::aaos_opts_mult_req_delims", "build::usage_parser::test::create_option_usage_both7", "multiple_values::option_max_more", "app_settings::no_auto_version", "posix_compatible::incremental_override", "utf8::invalid_utf8_lossy_option_short_space", "double_require::help_text", "multiple_values::positional_exact_more", "app_settings::leading_double_hyphen_trailingvararg", "positionals::ignore_hyphen_values_on_last", "app_settings::sub_command_negate_required_2", "help::issue_626_panic", "opts::require_delims_no_delim", "positionals::last_positional_second_to_last_mult", "opts::did_you_mean", "help::issue_2508_number_of_values_with_single_value_name", "multiple_values::low_index_positional_with_flag", "flags::multiple_flags_in_single", "arg_aliases_short::single_short_alias_of_flag", "build::usage_parser::test::create_option_with_vals5", "delimiters::opt_default_no_delim", "help::help_subcmd_help", "help::no_wrap_default_help", "help::show_long_about_issue_897", "tests::sc_short_flag_long_opt_pos", "subcommands::issue_2494_subcommand_is_present", "default_vals::default_if_arg_present_with_value_no_default", "default_vals::with_value_delimiter", "app_settings::sub_command_negate_required", "tests::short_flag_x2_comb_short_opt_pos", "help::only_custom_heading_pos_no_args", "positionals::single_positional_required_usage_string", "arg_aliases::visible_arg_aliases_help_output", "default_vals::default_ifs_arg_present_user_override", "arg_impl::char_literal", "arg_aliases::multiple_aliases_of_option", "help::issue_1571", "default_vals::default_if_arg_present_with_value_no_default_fail", "arg::positional", "build::usage_parser::test::create_option_usage0", "tests::sc_short_flag_x2_long_opt_pos", "conflicts::required_group_conflicts_with_arg", "positionals::multiple_positional_usage_string", "help::subcmd_help_subcmd_help", "utf8::invalid_utf8_lossy_option_short_equals", "build::usage_parser::test::create_option_usage_long_equals4", "conflicts::flag_conflict", "opts::leading_hyphen_with_flag_before", "utf8::invalid_utf8_lossy_option_short_no_space", "app_settings::dont_collapse_args", "validators::stateful_validator", "subcommands::subcommand_multiple", "tests::sc_long_flag_x2_short_opt_pos", "conflicts::conflict_output_three_conflicting", "help::missing_positional_final_multiple", "build::usage_parser::test::value_names_building_num_vals_from_usage", "help::subcommand_help_doesnt_have_useless_help_flag", "build::usage_parser::test::create_positional_usage0", "require::required_if_all_values_present_pass", "groups::group_reqired_flags_empty", "app_settings::allow_missing_positional", "default_vals::no_default_if_arg_present_no_arg_with_value_with_default", "multiple_values::value_names_building_num_vals", "help::custom_heading_pos", "app_settings::issue_1066_allow_leading_hyphen_and_unknown_args", "multiple_values::multiple_value_terminator_option", "tests::sc_long_flag_x2_long_opt_pos", "require::requires_if_present_val", "default_vals::default_ifs_arg_present", "utf8::invalid_utf8_strict_option_short_no_space", "multiple_values::different_sep_positional", "flag_subcommands::flag_subcommand_short_normal_usage_string", "app_settings::delim_values_only_pos_follows", "help::args_negate_sc", "double_require::valid_cases", "template_help::template_author_version", "build::usage_parser::test::pos_help_newline", "positionals::single_positional_multiple_usage_string", "parse::matches::arg_matches::tests::test_default_indices", "posix_compatible::posix_compatible_opts_long_equals", "multiple_values::positional", "version::version_flag_from_version_long", "build::usage_parser::test::create_option_usage_long10", "build::usage_parser::test::create_option_usage_long2", "help::wrapping_newline_variables", "derive_order::derive_order_subcommand_propagate", "subcommands::subcmd_did_you_mean_output_ambiguous", "multiple_values::option_min_exact", "build::arg::test::flag_display_multiple_short_aliases", "groups::required_group_missing_arg", "build::usage_parser::test::create_option_usage_both_equals8", "require::required_unless_any_works_with_short_err", "possible_values::ignore_case", "multiple_values::values_per_occurrence_positional", "template_help::with_template", "build::usage_parser::test::create_option_usage_both3", "subcommands::alias_help", "default_vals::positionals", "opts::require_equals_no_empty_values_fail", "version::version_flag_from_long_version_long", "app_settings::infer_subcommands_pass", "multiple_values::sep_long_space", "conflicts::arg_conflicts_with_group", "app_settings::unset_global_setting", "help::prefer_user_help_long_1112", "build::usage_parser::test::create_option_usage_both_equals3", "build::usage_parser::test::create_option_usage_both_equals7", "error::value_validation_has_newline", "help::help_about_multi_subcmd", "tests::long_flag_long_opt_pos", "possible_values::possible_values_of_positional_multiple_fail", "help::escaped_whitespace_values", "flag_subcommands::flag_subcommand_long_with_alias_same_as_long_flag", "opts::issue_1105_empty_value_long_equals", "default_vals::positional_user_override", "group_macro_set_not_required", "parse::matches::arg_matches::tests::test_default_osvalues_with_shorter_lifetime", "positionals::last_positional", "utf8::ignore_invalid_utf8_with_defaults", "build::usage_parser::test::create_option_usage_long4", "require::required_if_all_values_present_fail", "multiple_values::option_exact_exact_not_mult", "help::dont_propagate_version_to_help_subcommand", "build::arg::test::option_display_multiple_short_aliases", "opts::leading_hyphen_fail", "possible_values::escaped_possible_values_output", "app_settings::skip_possible_values", "help::ripgrep_usage_using_templates", "opts::issue_1073_suboptimal_flag_suggestion", "multiple_occurrences::multiple_occurrences_of_flags_long", "positionals::positional_hyphen_does_not_panic", "help::issue_702_multiple_values", "positionals::only_pos_follow", "help::disabled_help_flag_and_subcommand", "conflicts::conflict_output_rev", "app_settings::missing_positional_no_hyphen", "delimiters::opt_eq_mult_def_delim", "version::mut_version_long", "conflicts::two_conflicting_arguments", "indices::index_flag", "build::usage_parser::test::create_option_usage_long_equals6", "require::required_unless_present", "version::no_version_flag_long", "build::arg::test::positional_display_required", "help::help_no_subcommand", "possible_values::possible_values_of_positional", "multiple_values::multiple_vals_with_hyphen", "require::required_if_val_present_ignore_case_pass", "help::show_short_about_issue_897", "opts::issue_1105_empty_value_short_explicit", "utf8::invalid_utf8_strict_option_short_space", "posix_compatible::pos_required_overridden_by_flag", "build::usage_parser::test::create_option_usage_long_equals3", "derive_order::derive_order_subcommand_propagate_with_explicit_display_order", "utf8::ignore_validated_utf8_with_defaults", "positionals::last_positional_no_double_dash", "multiple_values::low_index_positional", "utf8::allow_validated_utf8_value_of", "build::usage_parser::test::create_option_usage_both_equals5", "build::usage_parser::test::create_option_usage7", "indices::index_mult_opts", "build::arg::test::option_display_multiple_aliases", "posix_compatible::posix_compatible_flags_short", "require::short_flag_require_equals_with_minvals_zero", "tests::create_app", "default_vals::no_default_if_arg_present_with_value_no_default", "posix_compatible::posix_compatible_opts_long", "arg::name_from_value", "default_vals::default_if_arg_present_with_value_no_default_user_override", "multiple_values::option_max_less", "require::required_if_any_all_values_present_pass", "subcommands::issue_1161_multiple_hyphen_hyphen", "group_macro_set_required", "hidden_args::hide_args", "opts::require_equals_fail_message", "subcommands::subcommand_used_after_double_dash", "build::usage_parser::test::pos_mult_help", "indices::indices_mult_opt_value_delim_eq", "require::required_unless_all_err", "tests::sc_short_flag_x2_short_opt_pos", "help::after_and_before_help_output", "help::arg_short_conflict_with_help", "help::hide_args", "flag_subcommands::flag_subcommand_short_after_long_arg", "help::help_required_and_no_args", "arg_aliases_short::invisible_short_arg_aliases_help_output", "ignore_errors::single_short_arg_without_value", "subcommands::visible_aliases_help_output", "app_settings::allow_negative_numbers_fail", "help::issue_760", "build::usage_parser::test::pos_mult", "positionals::issue_946", "arg_aliases_short::multiple_short_aliases_of_flag", "flag_subcommands::flag_subcommand_multiple", "help::hide_single_possible_val", "app_settings::aaos_flags_mult", "default_vals::default_if_arg_present_no_arg_with_default_user_override", "build::usage_parser::test::issue_665", "possible_values::alias", "possible_values::ignore_case_multiple_fail", "possible_values::ignore_case_fail", "example_tests", "help::positional_multiple_values_is_dotted", "build::usage_parser::test::create_option_usage_long5", "positionals::missing_required_2", "delimiters::opt_eq_no_delim", "default_vals::opt_without_value_fail", "subcommands::invisible_aliases_help_output", "multiple_values::no_sep_positional", "default_vals::no_default_if_arg_present_with_value_with_default", "version::no_version_flag_short", "default_vals::conditional_reqs_pass", "help::issue_1046_hide_scs", "propagate_globals::global_flag_used_inner", "app_settings::unset_setting_bitor", "build::app::tests::global_settings", "build::usage_parser::test::create_option_usage6", "help::help_required_and_given_for_subcommand", "opts::issue_1105_empty_value_short_equals", "utf8::invalid_utf8_positional", "tests::sc_long_flag_x2_short_opt_eq_pos", "parse::matches::arg_matches::tests::test_default_values", "app_settings::color_is_global"], "failed_tests": [], "skipped_tests": []}