clap/tests/builder/help.rs

#![cfg(feature = "help")]

use clap::{arg, builder::PossibleValue, error::ErrorKind, Arg, ArgAction, ArgGroup, Command};

use super::utils;

fn setup() -> Command {
    Command::new("test")
        .author("Kevin K.")
        .about("tests stuff")
        .version("1.3")
}

fn empty_args() -> impl IntoIterator<Item = String> {
    std::iter::empty()
}

#[test]
fn help_short() {
    let m = setup().try_get_matches_from(vec!["myprog", "-h"]);

    assert!(m.is_err());
    assert_eq!(m.unwrap_err().kind(), ErrorKind::DisplayHelp);
}

#[test]
fn help_long() {
    let m = setup().try_get_matches_from(vec!["myprog", "--help"]);

    assert!(m.is_err());
    assert_eq!(m.unwrap_err().kind(), ErrorKind::DisplayHelp);
}

#[test]
fn help_no_subcommand() {
    let m = setup().try_get_matches_from(vec!["myprog", "help"]);

    assert!(m.is_err());
    assert_eq!(m.unwrap_err().kind(), ErrorKind::UnknownArgument);
}

#[test]
fn help_subcommand() {
    let m = setup()
        .subcommand(
            Command::new("test")
                .about("tests things")
                .arg(arg!(-v --verbose "with verbosity")),
        )
        .try_get_matches_from(vec!["myprog", "help"]);

    assert!(m.is_err());
    assert_eq!(m.unwrap_err().kind(), ErrorKind::DisplayHelp);
}

#[test]
#[cfg(feature = "error-context")]
fn help_multi_subcommand_error() {
    let cmd = Command::new("ctest").subcommand(
        Command::new("subcmd").subcommand(
            Command::new("multi")
                .about("tests subcommands")
                .author("Kevin K. <kbknapp@gmail.com>")
                .version("0.1")
                .arg(arg!(
                    -f --flag                    "tests flags"
                ))
                .arg(
                    arg!(
                        -o --option <scoption>    "tests options"
                    )
                    .required(false)
                    .num_args(1..)
                    .action(ArgAction::Append),
                ),
        ),
    );
    let err = cmd
        .try_get_matches_from(["ctest", "help", "subcmd", "multi", "foo"])
        .unwrap_err();

    static EXPECTED: &str = "error: unrecognized subcommand 'foo'

Usage: ctest subcmd multi [OPTIONS]

For more information, try '--help'.
";
    utils::assert_eq(EXPECTED, err.to_string());
}

#[test]
fn req_last_arg_usage() {
    static LAST_ARG_REQ_MULT: &str = "\
Usage: example <FIRST>... -- <SECOND>...

Arguments:
  <FIRST>...   First
  <SECOND>...  Second

Options:
  -h, --help     Print help
  -V, --version  Print version
";

    let cmd = Command::new("example")
        .version("1.0")
        .arg(Arg::new("FIRST").help("First").num_args(1..).required(true))
        .arg(
            Arg::new("SECOND")
                .help("Second")
                .num_args(1..)
                .required(true)
                .last(true),
        );
    utils::assert_output(cmd, "example --help", LAST_ARG_REQ_MULT, false);
}

#[test]
fn args_with_last_usage() {
    static LAST_ARG_USAGE: &str = "\
Usage: flamegraph [OPTIONS] [BINFILE] [-- <ARGS>...]

Arguments:
  [BINFILE]  The path of the binary to be profiled. for a binary.
  [ARGS]...  Any arguments you wish to pass to the being profiled.

Options:
  -v, --verbose            Prints out more stuff.
  -t, --timeout <SECONDS>  Timeout in seconds.
  -f, --frequency <HERTZ>  The sampling frequency.
  -h, --help               Print help
  -V, --version            Print version
";

    let cmd = Command::new("flamegraph")
        .version("0.1")
        .arg(
            Arg::new("verbose")
                .help("Prints out more stuff.")
                .short('v')
                .long("verbose")
                .action(ArgAction::SetTrue),
        )
        .arg(
            Arg::new("timeout")
                .help("Timeout in seconds.")
                .short('t')
                .long("timeout")
                .value_name("SECONDS"),
        )
        .arg(
            Arg::new("frequency")
                .help("The sampling frequency.")
                .short('f')
                .long("frequency")
                .value_name("HERTZ"),
        )
        .arg(
            Arg::new("binary path")
                .help("The path of the binary to be profiled. for a binary.")
                .value_name("BINFILE"),
        )
        .arg(
            Arg::new("pass through args")
                .help("Any arguments you wish to pass to the being profiled.")
                .action(ArgAction::Set)
                .num_args(1..)
                .last(true)
                .value_name("ARGS"),
        );
    utils::assert_output(cmd, "flamegraph --help", LAST_ARG_USAGE, false);
}

#[test]
fn subcommand_short_help() {
    let m = utils::complex_app().try_get_matches_from(vec!["clap-test", "subcmd", "-h"]);

    assert!(m.is_err());
    assert_eq!(m.unwrap_err().kind(), ErrorKind::DisplayHelp);
}

#[test]
fn subcommand_long_help() {
    let m = utils::complex_app().try_get_matches_from(vec!["clap-test", "subcmd", "--help"]);

    assert!(m.is_err());
    assert_eq!(m.unwrap_err().kind(), ErrorKind::DisplayHelp);
}

#[test]
fn subcommand_help_rev() {
    let m = utils::complex_app().try_get_matches_from(vec!["clap-test", "help", "subcmd"]);

    assert!(m.is_err());
    assert_eq!(m.unwrap_err().kind(), ErrorKind::DisplayHelp);
}

#[test]
fn complex_help_output() {
    static HELP: &str = "\
clap-test v1.4.8
Kevin K. <kbknapp@gmail.com>
tests clap library

Usage: clap-test [OPTIONS] [positional] [positional2] [positional3]... [COMMAND]

Commands:
  subcmd  tests subcommands
  help    Print this message or the help of the given subcommand(s)

Arguments:
  [positional]      tests positionals
  [positional2]     tests positionals with exclusions
  [positional3]...  tests specific values [possible values: vi, emacs]

Options:
  -o, --option <opt>...                  tests options
  -f, --flag...                          tests flags
  -F                                     tests flags with exclusions
      --long-option-2 <option2>          tests long options with exclusions
  -O, --option3 <option3>                specific vals [possible values: fast, slow]
      --multvals <one> <two>             Tests multiple values, not mult occs
      --multvalsmo <one> <two>           Tests multiple values, and mult occs
      --minvals2 <minvals> <minvals>...  Tests 2 min vals
      --maxvals3 <maxvals>...            Tests 3 max vals
      --optvaleq[=<optval>]              Tests optional value, require = sign
      --optvalnoeq [<optval>]            Tests optional value
  -h, --help                             Print help
  -V, --version                          Print version
";

    utils::assert_output(utils::complex_app(), "clap-test --help", HELP, false);
}

#[test]
fn after_and_before_help_output() {
    static AFTER_HELP: &str = "some text that comes before the help

tests clap library

Usage: clap-test

Options:
  -h, --help     Print help
  -V, --version  Print version

some text that comes after the help
";

    let cmd = Command::new("clap-test")
        .version("v1.4.8")
        .about("tests clap library")
        .before_help("some text that comes before the help")
        .after_help("some text that comes after the help");
    utils::assert_output(cmd.clone(), "clap-test -h", AFTER_HELP, false);
    utils::assert_output(cmd, "clap-test --help", AFTER_HELP, false);
}

#[test]
fn after_and_before_long_help_output() {
    static AFTER_HELP: &str = "some text that comes before the help

tests clap library

Usage: clap-test

Options:
  -h, --help     Print help (see more with '--help')
  -V, --version  Print version

some text that comes after the help
";

    static AFTER_LONG_HELP: &str = "some longer text that comes before the help

tests clap library

Usage: clap-test

Options:
  -h, --help
          Print help (see a summary with '-h')

  -V, --version
          Print version

some longer text that comes after the help
";

    let cmd = Command::new("clap-test")
        .version("v1.4.8")
        .about("tests clap library")
        .before_help("some text that comes before the help")
        .after_help("some text that comes after the help")
        .before_long_help("some longer text that comes before the help")
        .after_long_help("some longer text that comes after the help");
    utils::assert_output(cmd.clone(), "clap-test --help", AFTER_LONG_HELP, false);
    utils::assert_output(cmd, "clap-test -h", AFTER_HELP, false);
}

static MULTI_SC_HELP: &str = "\
tests subcommands

Usage: ctest subcmd multi [OPTIONS]

Options:
  -f, --flag                  tests flags
  -o, --option <scoption>...  tests options
  -h, --help                  Print help
  -V, --version               Print version
";

#[test]
fn multi_level_sc_help() {
    let cmd = Command::new("ctest").subcommand(
        Command::new("subcmd").subcommand(
            Command::new("multi")
                .about("tests subcommands")
                .author("Kevin K. <kbknapp@gmail.com>")
                .version("0.1")
                .arg(arg!(
                    -f --flag                    "tests flags"
                ))
                .arg(
                    arg!(
                        -o --option <scoption>    "tests options"
                    )
                    .required(false)
                    .num_args(1..)
                    .action(ArgAction::Append),
                ),
        ),
    );
    utils::assert_output(cmd, "ctest help subcmd multi", MULTI_SC_HELP, false);
}

#[test]
fn no_wrap_default_help() {
    static DEFAULT_HELP: &str = "\
Usage: ctest

Options:
  -h, --help     Print help
  -V, --version  Print version
";

    let cmd = Command::new("ctest").version("1.0").term_width(0);
    utils::assert_output(cmd, "ctest --help", DEFAULT_HELP, false);
}

#[test]
#[cfg(feature = "wrap_help")]
fn wrapped_help() {
    static WRAPPED_HELP: &str = "\
Usage: test [OPTIONS]

Options:
  -a, --all            Also do versioning for private crates (will
                       not be published)
      --exact          Specify inter dependency version numbers
                       exactly with `=`
      --no-git-commit  Do not commit version changes
      --no-git-push    Do not push generated commit and tags to git
                       remote
  -h, --help           Print help
";
    let cmd = Command::new("test")
        .term_width(67)
        .arg(
            Arg::new("all")
                .short('a')
                .long("all")
                .action(ArgAction::SetTrue)
                .help("Also do versioning for private crates (will not be published)"),
        )
        .arg(
            Arg::new("exact")
                .long("exact")
                .action(ArgAction::SetTrue)
                .help("Specify inter dependency version numbers exactly with `=`"),
        )
        .arg(
            Arg::new("no_git_commit")
                .long("no-git-commit")
                .action(ArgAction::SetTrue)
                .help("Do not commit version changes"),
        )
        .arg(
            Arg::new("no_git_push")
                .long("no-git-push")
                .action(ArgAction::SetTrue)
                .help("Do not push generated commit and tags to git remote"),
        );
    utils::assert_output(cmd, "test --help", WRAPPED_HELP, false);
}

#[test]
#[cfg(feature = "wrap_help")]
fn unwrapped_help() {
    static UNWRAPPED_HELP: &str = "\
Usage: test [OPTIONS]

Options:
  -a, --all            Also do versioning for private crates (will
                       not be published)
      --exact          Specify inter dependency version numbers
                       exactly with `=`
      --no-git-commit  Do not commit version changes
      --no-git-push    Do not push generated commit and tags to git
                       remote
  -h, --help           Print help
";
    let cmd = Command::new("test")
        .term_width(68)
        .arg(
            Arg::new("all")
                .short('a')
                .long("all")
                .action(ArgAction::SetTrue)
                .help("Also do versioning for private crates (will not be published)"),
        )
        .arg(
            Arg::new("exact")
                .long("exact")
                .action(ArgAction::SetTrue)
                .help("Specify inter dependency version numbers exactly with `=`"),
        )
        .arg(
            Arg::new("no_git_commit")
                .long("no-git-commit")
                .action(ArgAction::SetTrue)
                .help("Do not commit version changes"),
        )
        .arg(
            Arg::new("no_git_push")
                .long("no-git-push")
                .action(ArgAction::SetTrue)
                .help("Do not push generated commit and tags to git remote"),
        );
    utils::assert_output(cmd, "test --help", UNWRAPPED_HELP, false);
}

#[test]
#[cfg(feature = "wrap_help")]
fn possible_value_wrapped_help() {
    static WRAPPED_HELP: &str = "\
Usage: test [OPTIONS]

Options:
      --possible-values <possible_values>
          Possible values:
          - short_name: Long enough help message, barely warrant
            wrapping
          - second:     Short help gets handled the same

      --possible-values-with-new-line <possible_values_with_new_line>
          Possible values:
          - long enough name to trigger new line: Really long
            enough help message to clearly warrant wrapping believe
            me
          - second

      --possible-values-without-new-line <possible_values_without_new_line>
          Possible values:
          - name:   Short enough help message with no wrapping
          - second: short help

  -h, --help
          Print help (see a summary with '-h')
";
    let cmd = Command::new("test")
        .term_width(67)
        .arg(
            Arg::new("possible_values")
                .long("possible-values")
                .action(ArgAction::Set)
                .value_parser([
                    PossibleValue::new("short_name")
                        .help("Long enough help message, barely warrant wrapping"),
                    PossibleValue::new("second").help("Short help gets handled the same"),
                ]),
        )
        .arg(
            Arg::new("possible_values_with_new_line")
                .long("possible-values-with-new-line")
                .action(ArgAction::Set)
                .value_parser([
                    PossibleValue::new("long enough name to trigger new line").help(
                        "Really long enough help message to clearly warrant wrapping believe me",
                    ),
                    PossibleValue::new("second"),
                ]),
        )
        .arg(
            Arg::new("possible_values_without_new_line")
                .long("possible-values-without-new-line")
                .action(ArgAction::Set)
                .value_parser([
                    PossibleValue::new("name").help("Short enough help message with no wrapping"),
                    PossibleValue::new("second").help("short help"),
                ]),
        );
    utils::assert_output(cmd, "test --help", WRAPPED_HELP, false);
}

#[test]
fn complex_subcommand_help_output() {
    static SC_HELP: &str = "clap-test-subcmd 0.1
Kevin K. <kbknapp@gmail.com>
tests subcommands

Usage: clap-test subcmd [OPTIONS] [scpositional]

Arguments:
  [scpositional]  tests positionals

Options:
  -o, --option <scoption>...   tests options
  -f, --flag...                tests flags
  -s, --subcmdarg <subcmdarg>  tests other args
  -h, --help                   Print help
  -V, --version                Print version
";

    let a = utils::complex_app();
    utils::assert_output(a, "clap-test subcmd --help", SC_HELP, false);
}

#[test]
#[cfg(feature = "wrap_help")]
fn issue_626_unicode_cutoff() {
    static ISSUE_626_CUTOFF: &str = "\
Usage: ctest [OPTIONS]

Options:
  -c, --cafe <FILE>  A coffeehouse, coffee shop, or café is an
                     establishment which primarily serves hot coffee,
                     related coffee beverages (e.g., café latte,
                     cappuccino, espresso), tea, and other hot
                     beverages. Some coffeehouses also serve cold
                     beverages such as iced coffee and iced tea. Many
                     cafés also serve some type of food, such as light
                     snacks, muffins, or pastries.
  -h, --help         Print help
  -V, --version      Print version
";

    let cmd = Command::new("ctest").version("0.1").term_width(70).arg(
        Arg::new("cafe")
            .short('c')
            .long("cafe")
            .value_name("FILE")
            .help(
                "A coffeehouse, coffee shop, or café is an establishment \
             which primarily serves hot coffee, related coffee beverages \
             (e.g., café latte, cappuccino, espresso), tea, and other hot \
             beverages. Some coffeehouses also serve cold beverages such as \
             iced coffee and iced tea. Many cafés also serve some type of \
             food, such as light snacks, muffins, or pastries.",
            )
            .action(ArgAction::Set),
    );
    utils::assert_output(cmd, "ctest --help", ISSUE_626_CUTOFF, false);
}

static HIDE_POS_VALS: &str = "\
Usage: ctest [OPTIONS]

Options:
  -p, --pos <VAL>    Some vals [possible values: fast, slow]
  -c, --cafe <FILE>  A coffeehouse, coffee shop, or café.
  -h, --help         Print help
  -V, --version      Print version
";

#[test]
fn hide_possible_vals() {
    let cmd = Command::new("ctest")
        .version("0.1")
        .arg(
            Arg::new("pos")
                .short('p')
                .long("pos")
                .value_name("VAL")
                .value_parser(["fast", "slow"])
                .help("Some vals")
                .action(ArgAction::Set),
        )
        .arg(
            Arg::new("cafe")
                .short('c')
                .long("cafe")
                .value_name("FILE")
                .hide_possible_values(true)
                .value_parser(["fast", "slow"])
                .help("A coffeehouse, coffee shop, or café.")
                .action(ArgAction::Set),
        );
    utils::assert_output(cmd, "ctest --help", HIDE_POS_VALS, false);
}

#[test]
fn hide_single_possible_val() {
    let cmd = Command::new("ctest")
        .version("0.1")
        .arg(
            Arg::new("pos")
                .short('p')
                .long("pos")
                .value_name("VAL")
                .value_parser([
                    "fast".into(),
                    "slow".into(),
                    PossibleValue::new("secret speed").hide(true),
                ])
                .help("Some vals")
                .action(ArgAction::Set),
        )
        .arg(
            Arg::new("cafe")
                .short('c')
                .long("cafe")
                .value_name("FILE")
                .help("A coffeehouse, coffee shop, or café.")
                .action(ArgAction::Set),
        );
    utils::assert_output(cmd, "ctest --help", HIDE_POS_VALS, false);
}

#[test]
fn possible_vals_with_help() {
    static POS_VALS_HELP: &str = "\
Usage: ctest [OPTIONS]

Options:
  -p, --pos <VAL>
          Some vals

          Possible values:
          - fast
          - slow: not as fast

  -c, --cafe <FILE>
          A coffeehouse, coffee shop, or café.

  -h, --help
          Print help (see a summary with '-h')

  -V, --version
          Print version
";
    let app = Command::new("ctest")
        .version("0.1")
        .arg(
            Arg::new("pos")
                .short('p')
                .long("pos")
                .value_name("VAL")
                .value_parser([
                    PossibleValue::new("fast"),
                    PossibleValue::new("slow").help("not as fast"),
                    PossibleValue::new("secret speed").hide(true),
                ])
                .help("Some vals")
                .action(ArgAction::Set),
        )
        .arg(
            Arg::new("cafe")
                .short('c')
                .long("cafe")
                .value_name("FILE")
                .help("A coffeehouse, coffee shop, or café.")
                .action(ArgAction::Set),
        );
    utils::assert_output(app, "ctest --help", POS_VALS_HELP, false);
}

#[test]
fn hidden_possible_vals() {
    static POS_VALS_HELP: &str = "\
Usage: ctest [pos]

Arguments:
  [pos]  

Options:
  -h, --help  Print help
";
    let app = Command::new("ctest").arg(
        Arg::new("pos")
            .hide_possible_values(true)
            .value_parser([
                PossibleValue::new("fast"),
                PossibleValue::new("slow").help("not as fast"),
            ])
            .action(ArgAction::Set),
    );
    utils::assert_output(app, "ctest --help", POS_VALS_HELP, false);
}

#[test]
#[cfg(feature = "wrap_help")]
fn issue_626_panic() {
    static ISSUE_626_PANIC: &str = "\
Usage: ctest [OPTIONS]

Options:
  -c, --cafe <FILE>
          La culture du café est très développée
          dans de nombreux pays à climat chaud
          d\'Amérique, d\'Afrique et d\'Asie, dans des
          plantations qui sont cultivées pour les
          marchés d\'exportation. Le café est souvent
          une contribution majeure aux exportations
          des régions productrices.
  -h, --help
          Print help
  -V, --version
          Print version
";

    let cmd = Command::new("ctest")
        .version("0.1")
        .term_width(52)
        .arg(Arg::new("cafe")
           .short('c')
           .long("cafe")
           .value_name("FILE")
           .help("La culture du café est très développée dans de nombreux pays à climat chaud d'Amérique, \
           d'Afrique et d'Asie, dans des plantations qui sont cultivées pour les marchés d'exportation. \
           Le café est souvent une contribution majeure aux exportations des régions productrices.")
           .action(ArgAction::Set));
    utils::assert_output(cmd, "ctest --help", ISSUE_626_PANIC, false);
}

#[test]
#[cfg(feature = "wrap_help")]
fn issue_626_variable_panic() {
    for i in 10..320 {
        let _ = Command::new("ctest")
            .version("0.1")
            .term_width(i)
            .arg(Arg::new("cafe")
               .short('c')
               .long("cafe")
               .value_name("FILE")
               .help("La culture du café est très développée dans de nombreux pays à climat chaud d'Amérique, \
               d'Afrique et d'Asie, dans des plantations qui sont cultivées pour les marchés d'exportation. \
               Le café est souvent une contribution majeure aux exportations des régions productrices.")
               .action(ArgAction::Set))
            .try_get_matches_from(vec!["ctest", "--help"]);
    }
}

#[test]
#[cfg(feature = "wrap_help")]
fn final_word_wrapping() {
    static FINAL_WORD_WRAPPING: &str = "\
Usage: ctest

Options:
  -h, --help
          Print help
  -V, --version
          Print version
";

    let cmd = Command::new("ctest").version("0.1").term_width(24);
    utils::assert_output(cmd, "ctest --help", FINAL_WORD_WRAPPING, false);
}

#[test]
#[cfg(feature = "wrap_help")]
fn wrapping_newline_chars() {
    static WRAPPING_NEWLINE_CHARS: &str = "\
Usage: ctest [mode]

Arguments:
  [mode]  x, max, maximum   20 characters, contains symbols.
          l, long           Copy-friendly, 14 characters,
          contains symbols.
          m, med, medium    Copy-friendly, 8 characters,
          contains symbols.

Options:
  -h, --help     Print help
  -V, --version  Print version
";

    let cmd = Command::new("ctest")
        .version("0.1")
        .term_width(60)
        .arg(Arg::new("mode").help(
            "x, max, maximum   20 characters, contains symbols.\n\
             l, long           Copy-friendly, 14 characters, contains symbols.\n\
             m, med, medium    Copy-friendly, 8 characters, contains symbols.\n",
        ));
    utils::assert_output(cmd, "ctest --help", WRAPPING_NEWLINE_CHARS, false);
}

#[test]
#[cfg(feature = "wrap_help")]
fn wrapped_indentation() {
    static HELP: &str = "\
Usage: ctest [mode]

Arguments:
  [mode]  Some values:
            - l, long           Copy-friendly, 14
            characters, contains symbols.
            - m, med, medium    Copy-friendly, 8 characters,
            contains symbols.

Options:
  -h, --help     Print help
  -V, --version  Print version
";

    let cmd = Command::new("ctest")
        .version("0.1")
        .term_width(60)
        .arg(Arg::new("mode").help(
            "Some values:
  - l, long           Copy-friendly, 14 characters, contains symbols.
  - m, med, medium    Copy-friendly, 8 characters, contains symbols.",
        ));
    utils::assert_output(cmd, "ctest --help", HELP, false);
}

#[test]
#[cfg(feature = "wrap_help")]
fn wrapping_newline_variables() {
    static WRAPPING_NEWLINE_CHARS: &str = "\
Usage: ctest [mode]

Arguments:
  [mode]  x, max, maximum   20 characters, contains symbols.
          l, long           Copy-friendly, 14 characters,
          contains symbols.
          m, med, medium    Copy-friendly, 8 characters,
          contains symbols.

Options:
  -h, --help     Print help
  -V, --version  Print version
";

    let cmd = Command::new("ctest")
        .version("0.1")
        .term_width(60)
        .arg(Arg::new("mode").help(
            "x, max, maximum   20 characters, contains symbols.{n}\
             l, long           Copy-friendly, 14 characters, contains symbols.{n}\
             m, med, medium    Copy-friendly, 8 characters, contains symbols.{n}",
        ));
    utils::assert_output(cmd, "ctest --help", WRAPPING_NEWLINE_CHARS, false);
}

#[test]
#[cfg(feature = "wrap_help")]
fn dont_wrap_urls() {
    let cmd = Command::new("Example")
        .term_width(30)
        .subcommand(Command::new("update").arg(
            Arg::new("force-non-host")
                .help("Install toolchains that require an emulator. See https://github.com/rust-lang/rustup/wiki/Non-host-toolchains")
                .long("force-non-host")
                .action(ArgAction::SetTrue))
    );

    const EXPECTED: &str = "\
Usage: Example update [OPTIONS]

Options:
      --force-non-host
          Install toolchains
          that require an
          emulator. See
          https://github.com/rust-lang/rustup/wiki/Non-host-toolchains
  -h, --help
          Print help
";
    utils::assert_output(cmd, "Example update --help", EXPECTED, false);
}

static OLD_NEWLINE_CHARS: &str = "\
Usage: ctest [OPTIONS]

Options:
  -m             Some help with some wrapping
                 (Defaults to something)
  -h, --help     Print help
  -V, --version  Print version
";

#[test]
fn old_newline_chars() {
    let cmd = Command::new("ctest").version("0.1").arg(
        Arg::new("mode")
            .short('m')
            .action(ArgAction::SetTrue)
            .help("Some help with some wrapping\n(Defaults to something)"),
    );
    utils::assert_output(cmd, "ctest --help", OLD_NEWLINE_CHARS, false);
}

#[test]
fn old_newline_variables() {
    let cmd = Command::new("ctest").version("0.1").arg(
        Arg::new("mode")
            .short('m')
            .action(ArgAction::SetTrue)
            .help("Some help with some wrapping{n}(Defaults to something)"),
    );
    utils::assert_output(cmd, "ctest --help", OLD_NEWLINE_CHARS, false);
}

#[test]
#[cfg(feature = "wrap_help")]
fn issue_688_hide_pos_vals() {
    #[cfg(not(feature = "unstable-v5"))]
    static ISSUE_688: &str = "\
Usage: ctest [OPTIONS]

Options:
      --filter <filter>  Sets the filter, or sampling method, to use for interpolation when resizing the particle
                         images. The default is Linear (Bilinear). [possible values: Nearest, Linear, Cubic, Gaussian,
                         Lanczos3]
  -h, --help             Print help
  -V, --version          Print version
";

    #[cfg(feature = "unstable-v5")]
    static ISSUE_688: &str = "\
Usage: ctest [OPTIONS]

Options:
      --filter <filter>  Sets the filter, or sampling method, to use for interpolation when resizing
                         the particle images. The default is Linear (Bilinear). [possible values:
                         Nearest, Linear, Cubic, Gaussian, Lanczos3]
  -h, --help             Print help
  -V, --version          Print version
";

    let filter_values = ["Nearest", "Linear", "Cubic", "Gaussian", "Lanczos3"];

    let app1 = Command::new("ctest")
        .version("0.1")
			.term_width(120)
			.hide_possible_values(true)
			.arg(Arg::new("filter")
				.help("Sets the filter, or sampling method, to use for interpolation when resizing the particle \
            images. The default is Linear (Bilinear). [possible values: Nearest, Linear, Cubic, Gaussian, Lanczos3]")
				.long("filter")
				.value_parser(filter_values)
				.action(ArgAction::Set));
    utils::assert_output(app1, "ctest --help", ISSUE_688, false);

    let app2 = Command::new("ctest")
        .version("0.1")
			.term_width(120)
			.arg(Arg::new("filter")
				.help("Sets the filter, or sampling method, to use for interpolation when resizing the particle \
            images. The default is Linear (Bilinear).")
				.long("filter")
				.value_parser(filter_values)
				.action(ArgAction::Set));
    utils::assert_output(app2, "ctest --help", ISSUE_688, false);

    let app3 = Command::new("ctest")
        .version("0.1")
			.term_width(120)
			.arg(Arg::new("filter")
				.help("Sets the filter, or sampling method, to use for interpolation when resizing the particle \
            images. The default is Linear (Bilinear). [possible values: Nearest, Linear, Cubic, Gaussian, Lanczos3]")
				.long("filter")
				.action(ArgAction::Set));
    utils::assert_output(app3, "ctest --help", ISSUE_688, false);
}

#[test]
fn issue_702_multiple_values() {
    static ISSUE_702: &str = "\
bar

Usage: myapp [OPTIONS] [arg1] [arg2]...

Arguments:
  [arg1]     some option
  [arg2]...  some option

Options:
  -s, --some <some>       some option
  -o, --other <other>     some other option
  -l, --label <label>...  a label
  -h, --help              Print help
  -V, --version           Print version
";

    let cmd = Command::new("myapp")
        .version("1.0")
        .author("foo")
        .about("bar")
        .arg(Arg::new("arg1").help("some option"))
        .arg(
            Arg::new("arg2")
                .action(ArgAction::Set)
                .num_args(1..)
                .help("some option"),
        )
        .arg(
            Arg::new("some")
                .help("some option")
                .short('s')
                .long("some")
                .action(ArgAction::Set),
        )
        .arg(
            Arg::new("other")
                .help("some other option")
                .short('o')
                .long("other")
                .action(ArgAction::Set),
        )
        .arg(
            Arg::new("label")
                .help("a label")
                .short('l')
                .long("label")
                .num_args(1..)
                .action(ArgAction::Set),
        );
    utils::assert_output(cmd, "myapp --help", ISSUE_702, false);
}

#[test]
fn long_about() {
    static LONG_ABOUT: &str = "\
something really really long, with
multiple lines of text
that should be displayed

Usage: myapp [arg1]

Arguments:
  [arg1]
          some option

Options:
  -h, --help
          Print help (see a summary with '-h')

  -V, --version
          Print version
";

    let cmd = Command::new("myapp")
        .version("1.0")
        .author("foo")
        .about("bar")
        .long_about(
            "something really really long, with\nmultiple lines of text\nthat should be displayed",
        )
        .arg(Arg::new("arg1").help("some option"));
    utils::assert_output(cmd, "myapp --help", LONG_ABOUT, false);
}

#[test]
fn explicit_short_long_help() {
    static SHORT_ABOUT: &str = "\
bar

Usage: myapp [arg1]

Arguments:
  [arg1]  some option

Options:
  -?             
  -h, --help     
  -V, --version  Print version
";

    static LONG_ABOUT: &str = "\
something really really long, with
multiple lines of text
that should be displayed

Usage: myapp [arg1]

Arguments:
  [arg1]
          some option

Options:
  -?
          

  -h, --help
          

  -V, --version
          Print version
";

    let cmd = Command::new("myapp")
        .disable_help_flag(true)
        .version("1.0")
        .author("foo")
        .about("bar")
        .long_about(
            "something really really long, with\nmultiple lines of text\nthat should be displayed",
        )
        .arg(Arg::new("arg1").help("some option"))
        .arg(Arg::new("short").short('?').action(ArgAction::HelpShort))
        .arg(
            Arg::new("long")
                .short('h')
                .long("help")
                .action(ArgAction::HelpLong),
        );
    utils::assert_output(cmd.clone(), "myapp -?", SHORT_ABOUT, false);
    utils::assert_output(cmd.clone(), "myapp -h", LONG_ABOUT, false);
    utils::assert_output(cmd, "myapp --help", LONG_ABOUT, false);
}

#[test]
fn ripgrep_usage() {
    static RIPGREP_USAGE: &str = "\
Usage: rg [OPTIONS] <pattern> [<path> ...]
       rg [OPTIONS] [-e PATTERN | -f FILE ]... [<path> ...]
       rg [OPTIONS] --files [<path> ...]
       rg [OPTIONS] --type-list

Options:
  -h, --help     Print help
  -V, --version  Print version
";

    let cmd = Command::new("ripgrep").version("0.5").override_usage(
        "rg [OPTIONS] <pattern> [<path> ...]
       rg [OPTIONS] [-e PATTERN | -f FILE ]... [<path> ...]
       rg [OPTIONS] --files [<path> ...]
       rg [OPTIONS] --type-list",
    );

    utils::assert_output(cmd, "rg --help", RIPGREP_USAGE, false);
}

#[test]
fn ripgrep_usage_using_templates() {
    static RIPGREP_USAGE: &str = "\
ripgrep 0.5

Usage: rg [OPTIONS] <pattern> [<path> ...]
       rg [OPTIONS] [-e PATTERN | -f FILE ]... [<path> ...]
       rg [OPTIONS] --files [<path> ...]
       rg [OPTIONS] --type-list

Options:
  -h, --help     Print help
  -V, --version  Print version
";

    #[cfg(not(feature = "unstable-v5"))]
    let cmd = Command::new("ripgrep")
        .version("0.5")
        .override_usage(
            "\
       rg [OPTIONS] <pattern> [<path> ...]
       rg [OPTIONS] [-e PATTERN | -f FILE ]... [<path> ...]
       rg [OPTIONS] --files [<path> ...]
       rg [OPTIONS] --type-list",
        )
        .help_template(
            "\
{bin} {version}

Usage: {usage}

Options:
{options}",
        );

    #[cfg(feature = "unstable-v5")]
    let cmd = Command::new("ripgrep")
        .version("0.5")
        .override_usage(
            "\
       rg [OPTIONS] <pattern> [<path> ...]
       rg [OPTIONS] [-e PATTERN | -f FILE ]... [<path> ...]
       rg [OPTIONS] --files [<path> ...]
       rg [OPTIONS] --type-list",
        )
        .help_template(
            "\
{name} {version}

Usage: {usage}

Options:
{options}",
        );

    utils::assert_output(cmd, "rg --help", RIPGREP_USAGE, false);
}

#[test]
fn sc_negates_reqs() {
    static SC_NEGATES_REQS: &str = "\
Usage: prog --opt <FILE> [PATH]
       prog [PATH] <COMMAND>

Commands:
  test  
  help  Print this message or the help of the given subcommand(s)

Arguments:
  [PATH]  help

Options:
  -o, --opt <FILE>  tests options
  -h, --help        Print help
  -V, --version     Print version
";

    let cmd = Command::new("prog")
        .version("1.0")
        .subcommand_negates_reqs(true)
        .arg(arg!(-o --opt <FILE> "tests options").required(true))
        .arg(Arg::new("PATH").help("help"))
        .subcommand(Command::new("test"));
    utils::assert_output(cmd, "prog --help", SC_NEGATES_REQS, false);
}

#[test]
fn hide_args() {
    static HIDDEN_ARGS: &str = "\
Usage: prog [OPTIONS]

Options:
  -f, --flag        testing flags
  -o, --opt <FILE>  tests options
  -h, --help        Print help
  -V, --version     Print version
";

    let cmd = Command::new("prog")
        .version("1.0")
        .arg(arg!(-f --flag "testing flags"))
        .arg(arg!(-o --opt <FILE> "tests options"))
        .arg(Arg::new("pos").hide(true));
    utils::assert_output(cmd, "prog --help", HIDDEN_ARGS, false);
}

#[test]
fn args_negate_sc() {
    static ARGS_NEGATE_SC: &str = "\
Usage: prog [OPTIONS] [PATH]
       prog <COMMAND>

Commands:
  test  
  help  Print this message or the help of the given subcommand(s)

Arguments:
  [PATH]  help

Options:
  -f, --flag        testing flags
  -o, --opt <FILE>  tests options
  -h, --help        Print help
  -V, --version     Print version
";

    let cmd = Command::new("prog")
        .version("1.0")
        .args_conflicts_with_subcommands(true)
        .arg(arg!(-f --flag "testing flags"))
        .arg(arg!(-o --opt <FILE> "tests options"))
        .arg(Arg::new("PATH").help("help"))
        .subcommand(Command::new("test"));
    utils::assert_output(cmd, "prog --help", ARGS_NEGATE_SC, false);
}

#[test]
fn issue_1046_hide_scs() {
    static ISSUE_1046_HIDDEN_SCS: &str = "\
Usage: prog [OPTIONS] [PATH]

Arguments:
  [PATH]  some

Options:
  -f, --flag        testing flags
  -o, --opt <FILE>  tests options
  -h, --help        Print help
  -V, --version     Print version
";

    let cmd = Command::new("prog")
        .version("1.0")
        .arg(arg!(-f --flag "testing flags"))
        .arg(arg!(-o --opt <FILE> "tests options"))
        .arg(Arg::new("PATH").help("some"))
        .subcommand(Command::new("test").hide(true));
    utils::assert_output(cmd, "prog --help", ISSUE_1046_HIDDEN_SCS, false);
}

#[test]
#[cfg(feature = "wrap_help")]
fn issue_777_wrap_all_things() {
    static ISSUE_777: &str = "A cmd with a crazy very long long
long name hahaha 1.0
Some Very Long Name and crazy long
email <email@server.com>
Show how the about text is not
wrapped

Usage: ctest

Options:
  -h, --help     Print help
  -V, --version  Print version
";

    let cmd = Command::new("A cmd with a crazy very long long long name hahaha")
        .version("1.0")
        .author("Some Very Long Name and crazy long email <email@server.com>")
        .about("Show how the about text is not wrapped")
        .help_template(utils::FULL_TEMPLATE)
        .term_width(35);
    utils::assert_output(cmd, "ctest --help", ISSUE_777, false);
}

#[test]
fn dont_strip_padding_issue_5083() {
    let cmd = Command::new("test")
        .help_template("{subcommands}")
        .subcommands([
            Command::new("one"),
            Command::new("two"),
            Command::new("three"),
        ]);
    static EXPECTED: &str = "  one    
  two    
  three  
  help   Print this message or the help of the given subcommand(s)
";
    utils::assert_output(cmd, "test --help", EXPECTED, false);
}

static OVERRIDE_HELP_SHORT: &str = "\
Usage: test

Options:
  -H, --help     Print help
  -V, --version  Print version
";

#[test]
fn override_help_short() {
    let cmd = Command::new("test")
        .version("0.1")
        .arg(arg!(-H --help "Print help").action(ArgAction::Help))
        .disable_help_flag(true);

    utils::assert_output(cmd.clone(), "test --help", OVERRIDE_HELP_SHORT, false);
    utils::assert_output(cmd, "test -H", OVERRIDE_HELP_SHORT, false);
}

static OVERRIDE_HELP_LONG: &str = "\
Usage: test

Options:
  -h, --hell     Print help
  -V, --version  Print version
";

#[test]
fn override_help_long() {
    let cmd = Command::new("test")
        .version("0.1")
        .arg(arg!(-h --hell "Print help").action(ArgAction::Help))
        .disable_help_flag(true);

    utils::assert_output(cmd.clone(), "test --hell", OVERRIDE_HELP_LONG, false);
    utils::assert_output(cmd, "test -h", OVERRIDE_HELP_LONG, false);
}

static OVERRIDE_HELP_ABOUT: &str = "\
Usage: test

Options:
  -h, --help     Print custom help information
  -V, --version  Print version
";

#[test]
fn override_help_about() {
    let cmd = Command::new("test")
        .version("0.1")
        .arg(arg!(-h --help "Print custom help information").action(ArgAction::Help))
        .disable_help_flag(true);

    utils::assert_output(cmd.clone(), "test --help", OVERRIDE_HELP_ABOUT, false);
    utils::assert_output(cmd, "test -h", OVERRIDE_HELP_ABOUT, false);
}

#[test]
#[cfg(debug_assertions)]
#[should_panic = "Command conflict: Argument names must be unique, but 'help' is in use by more than one argument or group (call `cmd.disable_help_flag(true)` to remove the auto-generated `--help`)"]
fn arg_id_conflict_with_help() {
    Command::new("conflict")
        .arg(Arg::new("help").short('?').action(ArgAction::SetTrue))
        .build();
}

#[test]
#[cfg(debug_assertions)]
#[should_panic = "Command conflict: Short option names must be unique for each argument, but '-h' is in use by both 'home' and 'help' (call `cmd.disable_help_flag(true)` to remove the auto-generated `--help`)"]
fn arg_short_conflict_with_help() {
    Command::new("conflict")
        .arg(Arg::new("home").short('h').action(ArgAction::SetTrue))
        .build();
}

#[test]
#[cfg(debug_assertions)]
#[should_panic = "Command conflict: Long option names must be unique for each argument, but '--help' is in use by both 'custom-help' and 'help' (call `cmd.disable_help_flag(true)` to remove the auto-generated `--help`)"]
fn arg_long_conflict_with_help() {
    Command::new("conflict")
        .arg(
            Arg::new("custom-help")
                .long("help")
                .action(ArgAction::SetTrue),
        )
        .build();
}

#[test]
fn last_arg_mult_usage() {
    static LAST_ARG: &str = "\
Usage: last <TARGET> [CORPUS] [-- <ARGS>...]

Arguments:
  <TARGET>   some
  [CORPUS]   some
  [ARGS]...  some

Options:
  -h, --help     Print help
  -V, --version  Print version
";

    let cmd = Command::new("last")
        .version("0.1")
        .arg(Arg::new("TARGET").required(true).help("some"))
        .arg(Arg::new("CORPUS").help("some"))
        .arg(
            Arg::new("ARGS")
                .action(ArgAction::Set)
                .num_args(1..)
                .last(true)
                .help("some"),
        );
    utils::assert_output(cmd, "last --help", LAST_ARG, false);
}

#[test]
fn last_arg_mult_usage_req() {
    static LAST_ARG_REQ: &str = "\
Usage: last <TARGET> [CORPUS] -- <ARGS>...

Arguments:
  <TARGET>   some
  [CORPUS]   some
  <ARGS>...  some

Options:
  -h, --help     Print help
  -V, --version  Print version
";

    let cmd = Command::new("last")
        .version("0.1")
        .arg(Arg::new("TARGET").required(true).help("some"))
        .arg(Arg::new("CORPUS").help("some"))
        .arg(
            Arg::new("ARGS")
                .action(ArgAction::Set)
                .num_args(1..)
                .last(true)
                .required(true)
                .help("some"),
        );
    utils::assert_output(cmd, "last --help", LAST_ARG_REQ, false);
}

#[test]
fn last_arg_mult_usage_req_with_sc() {
    static LAST_ARG_REQ_SC: &str = "\
Usage: last <TARGET> [CORPUS] -- <ARGS>...
       last [TARGET] [CORPUS] <COMMAND>

Commands:
  test  some
  help  Print this message or the help of the given subcommand(s)

Arguments:
  <TARGET>   some
  [CORPUS]   some
  <ARGS>...  some

Options:
  -h, --help     Print help
  -V, --version  Print version
";

    let cmd = Command::new("last")
        .version("0.1")
        .subcommand_negates_reqs(true)
        .arg(Arg::new("TARGET").required(true).help("some"))
        .arg(Arg::new("CORPUS").help("some"))
        .arg(
            Arg::new("ARGS")
                .action(ArgAction::Set)
                .num_args(1..)
                .last(true)
                .required(true)
                .help("some"),
        )
        .subcommand(Command::new("test").about("some"));
    utils::assert_output(cmd, "last --help", LAST_ARG_REQ_SC, false);
}

#[test]
fn last_arg_mult_usage_with_sc() {
    static LAST_ARG_SC: &str = "\
Usage: last <TARGET> [CORPUS] [-- <ARGS>...]
       last <COMMAND>

Commands:
  test  some
  help  Print this message or the help of the given subcommand(s)

Arguments:
  <TARGET>   some
  [CORPUS]   some
  [ARGS]...  some

Options:
  -h, --help     Print help
  -V, --version  Print version
";

    let cmd = Command::new("last")
        .version("0.1")
        .args_conflicts_with_subcommands(true)
        .arg(Arg::new("TARGET").required(true).help("some"))
        .arg(Arg::new("CORPUS").help("some"))
        .arg(
            Arg::new("ARGS")
                .action(ArgAction::Set)
                .num_args(1..)
                .last(true)
                .help("some"),
        )
        .subcommand(Command::new("test").about("some"));
    utils::assert_output(cmd, "last --help", LAST_ARG_SC, false);
}

static HIDE_DEFAULT_VAL: &str = "\
Usage: default [OPTIONS]

Options:
      --arg <argument>  Pass an argument to the program. [default: default-argument]
  -h, --help            Print help
  -V, --version         Print version
";

#[test]
fn hide_default_val() {
    let app1 = Command::new("default").version("0.1").term_width(120).arg(
        Arg::new("argument")
            .help("Pass an argument to the program. [default: default-argument]")
            .long("arg")
            .default_value("default-argument")
            .hide_default_value(true),
    );
    utils::assert_output(app1, "default --help", HIDE_DEFAULT_VAL, false);

    let app2 = Command::new("default").version("0.1").term_width(120).arg(
        Arg::new("argument")
            .help("Pass an argument to the program.")
            .long("arg")
            .default_value("default-argument"),
    );
    utils::assert_output(app2, "default --help", HIDE_DEFAULT_VAL, false);
}

#[test]
#[cfg(feature = "wrap_help")]
fn escaped_whitespace_values() {
    #[cfg(not(feature = "unstable-v5"))]
    static ESCAPED_DEFAULT_VAL: &str = "\
Usage: default [OPTIONS]

Options:
      --arg <argument>  Pass an argument to the program. [default: \"\\n\"] [possible values: normal, \" \", \"\\n\", \"\\t\",
                        other]
  -h, --help            Print help
  -V, --version         Print version
";

    #[cfg(feature = "unstable-v5")]
    static ESCAPED_DEFAULT_VAL: &str = "\
Usage: default [OPTIONS]

Options:
      --arg <argument>  Pass an argument to the program. [default: \"\\n\"] [possible values: normal, \"
                        \", \"\\n\", \"\\t\", other]
  -h, --help            Print help
  -V, --version         Print version
";

    let app1 = Command::new("default").version("0.1").term_width(120).arg(
        Arg::new("argument")
            .help("Pass an argument to the program.")
            .long("arg")
            .default_value("\n")
            .value_parser(["normal", " ", "\n", "\t", "other"]),
    );
    utils::assert_output(app1, "default --help", ESCAPED_DEFAULT_VAL, false);
}

fn issue_1112_setup() -> Command {
    Command::new("test")
        .version("1.3")
        .disable_help_flag(true)
        .arg(
            Arg::new("help1")
                .long("help")
                .short('h')
                .help("some help")
                .action(ArgAction::SetTrue),
        )
        .subcommand(
            Command::new("foo").arg(
                Arg::new("help1")
                    .long("help")
                    .short('h')
                    .help("some help")
                    .action(ArgAction::SetTrue),
            ),
        )
}

#[test]
fn prefer_user_help_long_1112() {
    let m = issue_1112_setup().try_get_matches_from(vec!["test", "--help"]);

    assert!(m.is_ok(), "{}", m.unwrap_err());
    let m = m.unwrap();
    assert!(*m.get_one::<bool>("help1").expect("defaulted by clap"));
}

#[test]
fn prefer_user_help_short_1112() {
    let m = issue_1112_setup().try_get_matches_from(vec!["test", "-h"]);

    assert!(m.is_ok(), "{}", m.unwrap_err());
    let m = m.unwrap();
    assert!(*m.get_one::<bool>("help1").expect("defaulted by clap"));
}

#[test]
fn prefer_user_subcmd_help_long_1112() {
    let m = issue_1112_setup().try_get_matches_from(vec!["test", "foo", "--help"]);

    assert!(m.is_ok(), "{}", m.unwrap_err());
    let m = m.unwrap();
    assert!(*m
        .subcommand_matches("foo")
        .unwrap()
        .get_one::<bool>("help1")
        .expect("defaulted by clap"));
}

#[test]
fn prefer_user_subcmd_help_short_1112() {
    let m = issue_1112_setup().try_get_matches_from(vec!["test", "foo", "-h"]);

    assert!(m.is_ok(), "{}", m.unwrap_err());
    let m = m.unwrap();
    assert!(m
        .subcommand_matches("foo")
        .unwrap()
        .get_one::<bool>("help1")
        .expect("defaulted by clap"));
}

#[test]
fn issue_1052_require_delim_help() {
    static REQUIRE_DELIM_HELP: &str = "\
tests stuff

Usage: test --fake <some> <val>

Options:
  -f, --fake <some> <val>  some help
  -h, --help               Print help
  -V, --version            Print version
";

    let cmd = Command::new("test")
        .author("Kevin K.")
        .about("tests stuff")
        .version("1.3")
        .arg(
            arg!(-f --fake <s> "some help")
                .required(true)
                .value_names(["some", "val"])
                .action(ArgAction::Set)
                .value_delimiter(':'),
        );

    utils::assert_output(cmd, "test --help", REQUIRE_DELIM_HELP, false);
}

#[test]
fn custom_headers_headers() {
    static CUSTOM_HELP_SECTION: &str = "\
does stuff

Usage: test [OPTIONS] --fake <some> <val>

Options:
  -f, --fake <some> <val>  some help
  -h, --help               Print help
  -V, --version            Print version

NETWORKING:
  -n, --no-proxy  Do not use system proxy settings
      --port
";

    let cmd = Command::new("blorp")
        .author("Will M.")
        .about("does stuff")
        .version("1.4")
        .arg(
            arg!(-f --fake <s> "some help")
                .required(true)
                .value_names(["some", "val"])
                .action(ArgAction::Set)
                .value_delimiter(':'),
        )
        .next_help_heading(Some("NETWORKING"))
        .arg(
            Arg::new("no-proxy")
                .short('n')
                .long("no-proxy")
                .action(ArgAction::SetTrue)
                .help("Do not use system proxy settings"),
        )
        .args([Arg::new("port").long("port").action(ArgAction::SetTrue)]);

    utils::assert_output(cmd, "test --help", CUSTOM_HELP_SECTION, false);
}

static MULTIPLE_CUSTOM_HELP_SECTIONS: &str = "\
does stuff

Usage: test [OPTIONS] --fake <some> <val> --birthday-song <song> --birthday-song-volume <volume>

Options:
  -f, --fake <some> <val>  some help
      --style <style>      Choose musical style to play the song
  -s, --speed <SPEED>      How fast? [possible values: fast, slow]
  -h, --help               Print help
  -V, --version            Print version

NETWORKING:
  -n, --no-proxy     Do not use system proxy settings
  -a, --server-addr  Set server address

OVERRIDE SPECIAL:
  -b, --birthday-song <song>  Change which song is played for birthdays

SPECIAL:
  -v, --birthday-song-volume <volume>  Change the volume of the birthday song
";

#[test]
fn multiple_custom_help_headers() {
    let cmd = Command::new("blorp")
        .author("Will M.")
        .about("does stuff")
        .version("1.4")
        .arg(
            arg!(-f --fake <s> "some help")
                .required(true)
                .value_names(["some", "val"])
                .action(ArgAction::Set)
                .value_delimiter(':'),
        )
        .next_help_heading(Some("NETWORKING"))
        .arg(
            Arg::new("no-proxy")
                .short('n')
                .long("no-proxy")
                .action(ArgAction::SetTrue)
                .help("Do not use system proxy settings"),
        )
        .next_help_heading(Some("SPECIAL"))
        .arg(
            arg!(-b --"birthday-song" <song> "Change which song is played for birthdays")
                .required(true)
                .help_heading(Some("OVERRIDE SPECIAL")),
        )
        .arg(arg!(--style <style> "Choose musical style to play the song").help_heading(None))
        .arg(
            arg!(
                -v --"birthday-song-volume" <volume> "Change the volume of the birthday song"
            )
            .required(true),
        )
        .next_help_heading(None)
        .arg(
            Arg::new("server-addr")
                .short('a')
                .long("server-addr")
                .action(ArgAction::SetTrue)
                .help("Set server address")
                .help_heading(Some("NETWORKING")),
        )
        .arg(
            Arg::new("speed")
                .long("speed")
                .short('s')
                .value_name("SPEED")
                .value_parser(["fast", "slow"])
                .help("How fast?")
                .action(ArgAction::Set),
        );

    utils::assert_output(cmd, "test --help", MULTIPLE_CUSTOM_HELP_SECTIONS, false);
}

static CUSTOM_HELP_SECTION_HIDDEN_ARGS: &str = "\
does stuff

Usage: test [OPTIONS] --song <song> --song-volume <volume>

Options:
  -h, --help     Print help (see more with '--help')
  -V, --version  Print version

OVERRIDE SPECIAL:
  -b, --song <song>  Change which song is played for birthdays

SPECIAL:
  -v, --song-volume <volume>  Change the volume of the birthday song
";

#[test]
fn custom_help_headers_hide_args() {
    let cmd = Command::new("blorp")
        .author("Will M.")
        .about("does stuff")
        .version("1.4")
        .next_help_heading(Some("NETWORKING"))
        .arg(
            Arg::new("no-proxy")
                .short('n')
                .long("no-proxy")
                .help("Do not use system proxy settings")
                .hide_short_help(true),
        )
        .next_help_heading(Some("SPECIAL"))
        .arg(
            arg!(-b --song <song> "Change which song is played for birthdays")
                .required(true)
                .help_heading(Some("OVERRIDE SPECIAL")),
        )
        .arg(
            arg!(
                -v --"song-volume" <volume> "Change the volume of the birthday song"
            )
            .required(true),
        )
        .next_help_heading(None)
        .arg(
            Arg::new("server-addr")
                .short('a')
                .long("server-addr")
                .help("Set server address")
                .help_heading(Some("NETWORKING"))
                .hide_short_help(true),
        );

    utils::assert_output(cmd, "test -h", CUSTOM_HELP_SECTION_HIDDEN_ARGS, false);
}

static ISSUE_897: &str = "\
Long about foo

Usage: ctest foo

Options:
  -h, --help
          Print help (see a summary with '-h')

  -V, --version
          Print version
";

#[test]
fn show_long_about_issue_897() {
    let cmd = Command::new("ctest").version("0.1").subcommand(
        Command::new("foo")
            .version("0.1")
            .about("About foo")
            .long_about("Long about foo"),
    );
    utils::assert_output(cmd, "ctest foo --help", ISSUE_897, false);
}

static ISSUE_897_SHORT: &str = "\
About foo

Usage: ctest foo

Options:
  -h, --help     Print help (see more with '--help')
  -V, --version  Print version
";

#[test]
fn show_short_about_issue_897() {
    let cmd = Command::new("ctest").version("0.1").subcommand(
        Command::new("foo")
            .version("0.1")
            .about("About foo")
            .long_about("Long about foo"),
    );
    utils::assert_output(cmd, "ctest foo -h", ISSUE_897_SHORT, false);
}

#[test]
fn issue_1364_no_short_options() {
    static ISSUE_1364: &str = "\
Usage: demo [OPTIONS] [FILES]...

Arguments:
  [FILES]...  

Options:
  -f          
  -h, --help  Print help (see more with '--help')
";

    let cmd = Command::new("demo")
        .arg(Arg::new("foo").short('f').action(ArgAction::SetTrue))
        .arg(
            Arg::new("baz")
                .short('z')
                .value_name("BAZ")
                .hide_short_help(true),
        )
        .arg(
            Arg::new("files")
                .value_name("FILES")
                .action(ArgAction::Set)
                .num_args(1..),
        );

    utils::assert_output(cmd, "demo -h", ISSUE_1364, false);
}

#[rustfmt::skip]
#[test]
fn issue_1487() {
static ISSUE_1487: &str = "\
Usage: ctest <arg1|arg2>

Arguments:
  [arg1]  
  [arg2]  

Options:
  -h, --help  Print help
";

    let cmd = Command::new("test")
    .arg(Arg::new("arg1")
        .group("group1"))
    .arg(Arg::new("arg2")
        .group("group1"))
    .group(ArgGroup::new("group1")
        .args(["arg1", "arg2"])
        .required(true));
    utils::assert_output(cmd, "ctest -h", ISSUE_1487, false);
}

#[cfg(debug_assertions)]
#[test]
#[should_panic = "Command::help_expected is enabled for the Command"]
fn help_required_but_not_given() {
    Command::new("myapp")
        .help_expected(true)
        .arg(Arg::new("foo"))
        .try_get_matches_from(empty_args())
        .unwrap();
}

#[cfg(debug_assertions)]
#[test]
#[should_panic = "Command::help_expected is enabled for the Command"]
fn help_required_but_not_given_settings_after_args() {
    Command::new("myapp")
        .arg(Arg::new("foo"))
        .help_expected(true)
        .try_get_matches_from(empty_args())
        .unwrap();
}

#[cfg(debug_assertions)]
#[test]
#[should_panic = "Command::help_expected is enabled for the Command"]
fn help_required_but_not_given_for_one_of_two_arguments() {
    Command::new("myapp")
        .help_expected(true)
        .arg(Arg::new("foo"))
        .arg(Arg::new("bar").help("It does bar stuff"))
        .try_get_matches_from(empty_args())
        .unwrap();
}

#[test]
#[should_panic = "List of such arguments: delete"]
fn help_required_globally() {
    Command::new("myapp")
        .help_expected(true)
        .arg(Arg::new("foo").help("It does foo stuff"))
        .subcommand(
            Command::new("bar")
                .arg(Arg::new("create").help("creates bar"))
                .arg(Arg::new("delete")),
        )
        .try_get_matches_from(empty_args())
        .unwrap();
}

#[cfg(debug_assertions)]
#[test]
#[should_panic = "Command::help_expected is enabled for the Command"]
fn help_required_globally_but_not_given_for_subcommand() {
    Command::new("myapp")
        .help_expected(true)
        .arg(Arg::new("foo").help("It does foo stuff"))
        .subcommand(
            Command::new("bar")
                .arg(Arg::new("create").help("creates bar"))
                .arg(Arg::new("delete")),
        )
        .try_get_matches_from(empty_args())
        .unwrap();
}

#[test]
fn help_required_and_given_for_subcommand() {
    Command::new("myapp")
        .help_expected(true)
        .arg(Arg::new("foo").help("It does foo stuff"))
        .subcommand(
            Command::new("bar")
                .arg(Arg::new("create").help("creates bar"))
                .arg(Arg::new("delete").help("deletes bar")),
        )
        .try_get_matches_from(empty_args())
        .unwrap();
}

#[test]
fn help_required_and_given() {
    Command::new("myapp")
        .help_expected(true)
        .arg(Arg::new("foo").help("It does foo stuff"))
        .try_get_matches_from(empty_args())
        .unwrap();
}

#[test]
fn help_required_and_no_args() {
    Command::new("myapp")
        .help_expected(true)
        .try_get_matches_from(empty_args())
        .unwrap();
}

#[test]
fn issue_1642_long_help_spacing() {
    static ISSUE_1642: &str = "\
Usage: prog [OPTIONS]

Options:
      --config
          The config file used by the myprog must be in JSON format
          with only valid keys and may not contain other nonsense
          that cannot be read by this program. Obviously I'm going on
          and on, so I'll stop now.

  -h, --help
          Print help (see a summary with '-h')
";

    let cmd = Command::new("prog").arg(
        Arg::new("cfg")
            .long("config")
            .action(ArgAction::SetTrue)
            .long_help(
                "The config file used by the myprog must be in JSON format
with only valid keys and may not contain other nonsense
that cannot be read by this program. Obviously I'm going on
and on, so I'll stop now.",
            ),
    );
    utils::assert_output(cmd, "prog --help", ISSUE_1642, false);
}

const AFTER_HELP_NO_ARGS: &str = "\
Usage: myapp

This is after help.
";

#[test]
fn after_help_no_args() {
    let mut cmd = Command::new("myapp")
        .version("1.0")
        .disable_help_flag(true)
        .disable_version_flag(true)
        .after_help("This is after help.");

    let help = cmd.render_help().to_string();

    assert_eq!(help, AFTER_HELP_NO_ARGS);
}

#[test]
fn help_subcmd_help() {
    static HELP_SUBCMD_HELP: &str = "\
Print this message or the help of the given subcommand(s)

Usage: myapp help [COMMAND]...

Arguments:
  [COMMAND]...  Print help for the subcommand(s)
";

    let cmd = Command::new("myapp")
        .subcommand(Command::new("subcmd").subcommand(Command::new("multi").version("1.0")));

    utils::assert_output(cmd.clone(), "myapp help help", HELP_SUBCMD_HELP, false);
}

#[test]
fn subcmd_help_subcmd_help() {
    static SUBCMD_HELP_SUBCMD_HELP: &str = "\
Print this message or the help of the given subcommand(s)

Usage: myapp subcmd help [COMMAND]...

Arguments:
  [COMMAND]...  Print help for the subcommand(s)
";

    let cmd = Command::new("myapp")
        .subcommand(Command::new("subcmd").subcommand(Command::new("multi").version("1.0")));

    utils::assert_output(
        cmd.clone(),
        "myapp subcmd help help",
        SUBCMD_HELP_SUBCMD_HELP,
        false,
    );
}

#[test]
fn global_args_should_show_on_toplevel_help_message() {
    static HELP: &str = "\
Usage: myapp [OPTIONS] [COMMAND]

Commands:
  subcmd\x20\x20
  help    Print this message or the help of the given subcommand(s)

Options:
  -g, --some-global <someglobal>\x20\x20
  -h, --help                      Print help
";

    let cmd = Command::new("myapp")
        .arg(
            Arg::new("someglobal")
                .short('g')
                .long("some-global")
                .global(true),
        )
        .subcommand(Command::new("subcmd").subcommand(Command::new("multi").version("1.0")));

    utils::assert_output(cmd, "myapp help", HELP, false);
}

#[test]
fn global_args_should_not_show_on_help_message_for_help_help() {
    static HELP_HELP: &str = "\
Print this message or the help of the given subcommand(s)

Usage: myapp help [COMMAND]...

Arguments:
  [COMMAND]...  Print help for the subcommand(s)
";

    let cmd = Command::new("myapp")
        .arg(
            Arg::new("someglobal")
                .short('g')
                .long("some-global")
                .global(true),
        )
        .subcommand(Command::new("subcmd").subcommand(Command::new("multi").version("1.0")));

    utils::assert_output(cmd, "myapp help help", HELP_HELP, false);
}

#[test]
fn global_args_should_show_on_help_message_for_subcommand() {
    static HELP_SUBCMD: &str = "\
Usage: myapp subcmd [OPTIONS] [COMMAND]

Commands:
  multi\x20\x20
  help   Print this message or the help of the given subcommand(s)

Options:
  -g, --some-global <someglobal>\x20\x20
  -h, --help                      Print help
";

    let cmd = Command::new("myapp")
        .arg(
            Arg::new("someglobal")
                .short('g')
                .long("some-global")
                .global(true),
        )
        .subcommand(Command::new("subcmd").subcommand(Command::new("multi").version("1.0")));

    utils::assert_output(cmd, "myapp help subcmd", HELP_SUBCMD, false);
}

#[test]
fn global_args_should_show_on_help_message_for_nested_subcommand() {
    static HELP_SUB_SUBCMD: &str = "\
Usage: myapp subcmd multi [OPTIONS]

Options:
  -g, --some-global <someglobal>\x20\x20
  -h, --help                      Print help
  -V, --version                   Print version
";

    let cmd = Command::new("myapp")
        .arg(
            Arg::new("someglobal")
                .short('g')
                .long("some-global")
                .global(true),
        )
        .subcommand(Command::new("subcmd").subcommand(Command::new("multi").version("1.0")));

    utils::assert_output(cmd, "myapp help subcmd multi", HELP_SUB_SUBCMD, false);
}

#[test]
fn option_usage_order() {
    static OPTION_USAGE_ORDER: &str = "\
Usage: order [OPTIONS]

Options:
  -a                   
  -B                   
  -b                   
  -s                   
      --select_file    
      --select_folder  
  -x                   
  -h, --help           Print help
";

    let cmd = Command::new("order").args([
        Arg::new("a").short('a').action(ArgAction::SetTrue),
        Arg::new("B").short('B').action(ArgAction::SetTrue),
        Arg::new("b").short('b').action(ArgAction::SetTrue),
        Arg::new("save").short('s').action(ArgAction::SetTrue),
        Arg::new("select_file")
            .long("select_file")
            .action(ArgAction::SetTrue),
        Arg::new("select_folder")
            .long("select_folder")
            .action(ArgAction::SetTrue),
        Arg::new("x").short('x').action(ArgAction::SetTrue),
    ]);

    utils::assert_output(cmd, "order --help", OPTION_USAGE_ORDER, false);
}

#[test]
fn prefer_about_over_long_about_in_subcommands_list() {
    static ABOUT_IN_COMMANDS_LIST: &str = "\
Usage: about-in-subcommands-list [COMMAND]

Commands:
  sub   short about sub
  help  Print this message or the help of the given subcommand(s)

Options:
  -h, --help  Print help
";

    let cmd = Command::new("about-in-subcommands-list").subcommand(
        Command::new("sub")
            .long_about("long about sub")
            .about("short about sub"),
    );

    utils::assert_output(
        cmd,
        "about-in-subcommands-list --help",
        ABOUT_IN_COMMANDS_LIST,
        false,
    );
}

#[test]
fn issue_1794_usage() {
    static USAGE_WITH_GROUP: &str = "\
Usage: deno <pos1|--option1> [pos2]

Arguments:
  [pos1]  
  [pos2]  

Options:
      --option1  
  -h, --help     Print help
";

    let cmd = clap::Command::new("hello")
        .bin_name("deno")
        .arg(
            Arg::new("option1")
                .long("option1")
                .action(ArgAction::SetTrue),
        )
        .arg(Arg::new("pos1").action(ArgAction::Set))
        .group(
            ArgGroup::new("arg1")
                .args(["pos1", "option1"])
                .required(true),
        )
        .arg(Arg::new("pos2").action(ArgAction::Set));

    utils::assert_output(cmd, "deno --help", USAGE_WITH_GROUP, false);
}

static CUSTOM_HEADING_POS: &str = "\
Usage: test [gear] [speed]

Arguments:
  [gear]  Which gear

Options:
  -h, --help     Print help
  -V, --version  Print version

NETWORKING:
  [speed]  How fast
";

#[test]
fn custom_heading_pos() {
    let cmd = Command::new("test")
        .version("1.4")
        .arg(Arg::new("gear").help("Which gear"))
        .next_help_heading(Some("NETWORKING"))
        .arg(Arg::new("speed").help("How fast"));

    utils::assert_output(cmd, "test --help", CUSTOM_HEADING_POS, false);
}

static ONLY_CUSTOM_HEADING_OPTS_NO_ARGS: &str = "\
Usage: test [OPTIONS]

NETWORKING:
  -s, --speed <SPEED>  How fast
";

#[test]
fn only_custom_heading_opts_no_args() {
    let cmd = Command::new("test")
        .version("1.4")
        .disable_version_flag(true)
        .disable_help_flag(true)
        .arg(arg!(--help).action(ArgAction::Help).hide(true))
        .next_help_heading(Some("NETWORKING"))
        .arg(arg!(-s --speed <SPEED> "How fast"));

    utils::assert_output(cmd, "test --help", ONLY_CUSTOM_HEADING_OPTS_NO_ARGS, false);
}

static ONLY_CUSTOM_HEADING_POS_NO_ARGS: &str = "\
Usage: test [speed]

NETWORKING:
  [speed]  How fast
";

#[test]
fn only_custom_heading_pos_no_args() {
    let cmd = Command::new("test")
        .version("1.4")
        .disable_version_flag(true)
        .disable_help_flag(true)
        .arg(arg!(--help).action(ArgAction::Help).hide(true))
        .next_help_heading(Some("NETWORKING"))
        .arg(Arg::new("speed").help("How fast"));

    utils::assert_output(cmd, "test --help", ONLY_CUSTOM_HEADING_POS_NO_ARGS, false);
}

#[test]
fn issue_2508_number_of_values_with_single_value_name() {
    let cmd = Command::new("my_app")
        .arg(Arg::new("some_arg").long("some_arg").num_args(2))
        .arg(
            Arg::new("some_arg_issue")
                .long("some_arg_issue")
                .num_args(2)
                .value_name("ARG"),
        );
    utils::assert_output(
        cmd,
        "my_app --help",
        "\
Usage: my_app [OPTIONS]

Options:
      --some_arg <some_arg> <some_arg>  
      --some_arg_issue <ARG> <ARG>      
  -h, --help                            Print help
",
        false,
    );
}

#[test]
fn missing_positional_final_required() {
    let cmd = Command::new("test")
        .allow_missing_positional(true)
        .arg(Arg::new("arg1"))
        .arg(Arg::new("arg2").required(true));
    utils::assert_output(
        cmd,
        "test --help",
        "\
Usage: test [arg1] <arg2>

Arguments:
  [arg1]  
  <arg2>  

Options:
  -h, --help  Print help
",
        false,
    );
}

#[test]
fn missing_positional_final_multiple() {
    let cmd = Command::new("test")
        .allow_missing_positional(true)
        .arg(Arg::new("foo"))
        .arg(Arg::new("bar"))
        .arg(Arg::new("baz").action(ArgAction::Set).num_args(1..));
    utils::assert_output(
        cmd,
        "test --help",
        "\
Usage: test [foo] [bar] [baz]...

Arguments:
  [foo]     
  [bar]     
  [baz]...  

Options:
  -h, --help  Print help
",
        false,
    );
}

#[test]
fn positional_multiple_values_is_dotted() {
    let cmd = Command::new("test").arg(
        Arg::new("foo")
            .required(true)
            .action(ArgAction::Set)
            .num_args(1..),
    );
    utils::assert_output(
        cmd,
        "test --help",
        "\
Usage: test <foo>...

Arguments:
  <foo>...  

Options:
  -h, --help  Print help
",
        false,
    );

    let cmd = Command::new("test").arg(
        Arg::new("foo")
            .required(true)
            .action(ArgAction::Set)
            .value_name("BAR")
            .num_args(1..),
    );
    utils::assert_output(
        cmd,
        "test --help",
        "\
Usage: test <BAR>...

Arguments:
  <BAR>...  

Options:
  -h, --help  Print help
",
        false,
    );
}

#[test]
fn positional_multiple_occurrences_is_dotted() {
    let cmd = Command::new("test").arg(
        Arg::new("foo")
            .required(true)
            .action(ArgAction::Set)
            .num_args(1..)
            .action(ArgAction::Append),
    );
    utils::assert_output(
        cmd,
        "test --help",
        "\
Usage: test <foo>...

Arguments:
  <foo>...  

Options:
  -h, --help  Print help
",
        false,
    );

    let cmd = Command::new("test").arg(
        Arg::new("foo")
            .required(true)
            .action(ArgAction::Set)
            .value_name("BAR")
            .num_args(1..)
            .action(ArgAction::Append),
    );
    utils::assert_output(
        cmd,
        "test --help",
        "\
Usage: test <BAR>...

Arguments:
  <BAR>...  

Options:
  -h, --help  Print help
",
        false,
    );
}

#[test]
fn too_few_value_names_is_dotted() {
    let cmd = Command::new("test").arg(
        Arg::new("foo")
            .long("foo")
            .required(true)
            .action(ArgAction::Set)
            .num_args(3)
            .value_names(["one", "two"]),
    );
    utils::assert_output(
        cmd,
        "test --help",
        "\
Usage: test --foo <one> <two>...

Options:
      --foo <one> <two>...  
  -h, --help                Print help
",
        false,
    );
}

#[test]
#[should_panic = "Argument foo: Too many value names (2) compared to `num_args` (1)"]
fn too_many_value_names_panics() {
    Command::new("test")
        .arg(
            Arg::new("foo")
                .long("foo")
                .required(true)
                .action(ArgAction::Set)
                .num_args(1)
                .value_names(["one", "two"]),
        )
        .debug_assert()
}

#[test]
fn disabled_help_flag() {
    let res = Command::new("foo")
        .subcommand(Command::new("sub"))
        .disable_help_flag(true)
        .try_get_matches_from("foo a".split(' '));
    assert!(res.is_err());
    let err = res.unwrap_err();
    assert_eq!(err.kind(), ErrorKind::InvalidSubcommand);
}

#[test]
fn disabled_help_flag_and_subcommand() {
    let res = Command::new("foo")
        .subcommand(Command::new("sub"))
        .disable_help_flag(true)
        .disable_help_subcommand(true)
        .try_get_matches_from("foo help".split(' '));
    assert!(res.is_err());
    let err = res.unwrap_err();
    assert_eq!(err.kind(), ErrorKind::InvalidSubcommand);
    assert!(
        err.to_string().ends_with('\n'),
        "Errors should have a trailing newline, got {:?}",
        err.to_string()
    );
}

#[test]
fn override_help_subcommand() {
    let cmd = Command::new("bar")
        .subcommand(Command::new("help").arg(Arg::new("arg").action(ArgAction::Set)))
        .subcommand(Command::new("not_help").arg(Arg::new("arg").action(ArgAction::Set)))
        .disable_help_subcommand(true);
    let matches = cmd.try_get_matches_from(["bar", "help", "foo"]).unwrap();
    assert_eq!(
        matches
            .subcommand_matches("help")
            .unwrap()
            .get_one::<String>("arg")
            .map(|v| v.as_str()),
        Some("foo")
    );
}

#[test]
fn override_help_flag_using_long() {
    let cmd = Command::new("foo")
        .subcommand(Command::new("help").long_flag("help"))
        .disable_help_flag(true)
        .disable_help_subcommand(true);
    let matches = cmd.try_get_matches_from(["foo", "--help"]).unwrap();
    assert!(matches.subcommand_matches("help").is_some());
}

#[test]
fn override_help_flag_using_short() {
    let cmd = Command::new("foo")
        .disable_help_flag(true)
        .disable_help_subcommand(true)
        .subcommand(Command::new("help").short_flag('h'));
    let matches = cmd.try_get_matches_from(["foo", "-h"]).unwrap();
    assert!(matches.subcommand_matches("help").is_some());
}

#[test]
fn subcommand_help_doesnt_have_useless_help_flag() {
    // The main care-about is that the docs and behavior match.  Since the `help` subcommand
    // currently ignores the `--help` flag, the output shouldn't have it.
    let cmd = Command::new("example").subcommand(Command::new("test").about("Subcommand"));

    utils::assert_output(
        cmd,
        "example help help",
        "\
Print this message or the help of the given subcommand(s)

Usage: example help [COMMAND]...

Arguments:
  [COMMAND]...  Print help for the subcommand(s)
",
        false,
    );
}

#[test]
fn disable_help_flag_affects_help_subcommand() {
    let mut cmd = Command::new("test_app")
        .disable_help_flag(true)
        .subcommand(Command::new("test").about("Subcommand"));
    cmd.build();

    let args = cmd
        .find_subcommand("help")
        .unwrap()
        .get_arguments()
        .map(|a| a.get_id().as_str())
        .collect::<Vec<_>>();
    assert!(
        !args.contains(&"help"),
        "`help` should not be present: {args:?}"
    );
}

#[test]
fn dont_propagate_version_to_help_subcommand() {
    let cmd = clap::Command::new("example")
        .version("1.0")
        .propagate_version(true)
        .subcommand(clap::Command::new("subcommand"));

    utils::assert_output(
        cmd.clone(),
        "example help help",
        "\
Print this message or the help of the given subcommand(s)

Usage: example help [COMMAND]...

Arguments:
  [COMMAND]...  Print help for the subcommand(s)
",
        false,
    );

    cmd.debug_assert();
}

#[test]
fn help_without_short() {
    let mut cmd = clap::Command::new("test")
        .arg(arg!(-h --hex <NUM>).required(true))
        .arg(arg!(--help).action(ArgAction::Help))
        .disable_help_flag(true);

    cmd.build();
    let help = cmd.get_arguments().find(|a| a.get_id() == "help").unwrap();
    assert_eq!(help.get_short(), None);

    let m = cmd.try_get_matches_from(["test", "-h", "0x100"]).unwrap();
    assert_eq!(
        m.get_one::<String>("hex").map(|v| v.as_str()),
        Some("0x100")
    );
}

#[test]
fn parent_cmd_req_in_usage_with_help_flag() {
    static EXPECTED: &str = "\
some

Usage: parent <TARGET> <ARGS> test

Options:
  -h, --help  Print help
";
    let cmd = Command::new("parent")
        .version("0.1")
        .arg(Arg::new("TARGET").required(true).help("some"))
        .arg(
            Arg::new("ARGS")
                .action(ArgAction::Set)
                .required(true)
                .help("some"),
        )
        .subcommand(Command::new("test").about("some"));
    utils::assert_output(cmd, "parent test --help", EXPECTED, false);
}

#[test]
fn parent_cmd_req_in_usage_with_help_subcommand() {
    static EXPECTED: &str = "\
some

Usage: parent <TARGET> <ARGS> test

Options:
  -h, --help  Print help
";
    let cmd = Command::new("parent")
        .version("0.1")
        .arg(Arg::new("TARGET").required(true).help("some"))
        .arg(
            Arg::new("ARGS")
                .action(ArgAction::Set)
                .required(true)
                .help("some"),
        )
        .subcommand(Command::new("test").about("some"));
    utils::assert_output(cmd, "parent help test", EXPECTED, false);
}

#[test]
fn parent_cmd_req_in_usage_with_render_help() {
    static EXPECTED: &str = "\
some

Usage: parent <TARGET> <ARGS> test

Options:
  -h, --help  Print help
";
    let mut cmd = Command::new("parent")
        .version("0.1")
        .arg(Arg::new("TARGET").required(true).help("some"))
        .arg(
            Arg::new("ARGS")
                .action(ArgAction::Set)
                .required(true)
                .help("some"),
        )
        .subcommand(Command::new("test").about("some"));
    cmd.build();
    let subcmd = cmd.find_subcommand_mut("test").unwrap();

    let help = subcmd.render_help().to_string();
    utils::assert_eq(EXPECTED, help);
}

#[test]
fn parent_cmd_req_ignored_when_negates_reqs() {
    static MULTI_SC_HELP: &str = "\
Usage: ctest subcmd

Options:
  -h, --help  Print help
";

    let cmd = Command::new("ctest")
        .arg(arg!(<input>))
        .subcommand_negates_reqs(true)
        .subcommand(Command::new("subcmd"));
    utils::assert_output(cmd, "ctest subcmd --help", MULTI_SC_HELP, false);
}

#[test]
fn parent_cmd_req_ignored_when_conflicts() {
    static MULTI_SC_HELP: &str = "\
Usage: ctest subcmd

Options:
  -h, --help  Print help
";

    let cmd = Command::new("ctest")
        .arg(arg!(<input>))
        .args_conflicts_with_subcommands(true)
        .subcommand(Command::new("subcmd"));
    utils::assert_output(cmd, "ctest subcmd --help", MULTI_SC_HELP, false);
}

#[test]
fn no_wrap_help() {
    let cmd = Command::new("ctest")
        .term_width(0)
        .override_help(MULTI_SC_HELP);
    utils::assert_output(cmd, "ctest --help", MULTI_SC_HELP, false);
}

#[test]
fn display_name_default() {
    let mut cmd = Command::new("app").bin_name("app.exe");
    cmd.build();
    assert_eq!(cmd.get_display_name(), None);
}

#[test]
fn display_name_explicit() {
    let mut cmd = Command::new("app")
        .bin_name("app.exe")
        .display_name("app.display");
    cmd.build();
    assert_eq!(cmd.get_display_name(), Some("app.display"));
}

#[test]
fn display_name_subcommand_default() {
    let mut cmd = Command::new("parent").subcommand(Command::new("child").bin_name("child.exe"));
    cmd.build();
    assert_eq!(
        cmd.find_subcommand("child").unwrap().get_display_name(),
        Some("parent-child")
    );
}

#[test]
fn display_name_subcommand_explicit() {
    let mut cmd = Command::new("parent").subcommand(
        Command::new("child")
            .bin_name("child.exe")
            .display_name("child.display"),
    );
    cmd.build();
    assert_eq!(
        cmd.find_subcommand("child").unwrap().get_display_name(),
        Some("child.display")
    );
}

#[test]
fn flatten_basic() {
    static EXPECTED: &str = "\
parent command

Usage: parent [OPTIONS]
       parent test [OPTIONS]
       parent help [COMMAND]...

Options:
      --parent <parent>  
  -h, --help             Print help

parent test:
test command
      --child <child>  
  -h, --help           Print help

parent help:
Print this message or the help of the given subcommand(s)
  [COMMAND]...  Print help for the subcommand(s)
";
    let cmd = Command::new("parent")
        .flatten_help(true)
        .about("parent command")
        .arg(Arg::new("parent").long("parent"))
        .subcommand(
            Command::new("test")
                .about("test command")
                .arg(Arg::new("child").long("child")),
        );
    utils::assert_output(cmd, "parent -h", EXPECTED, false);
}

#[test]
fn flatten_short_help() {
    static EXPECTED: &str = "\
parent command

Usage: parent [OPTIONS]
       parent test [OPTIONS]
       parent help [COMMAND]...

Options:
      --parent <parent>  foo
  -h, --help             Print help (see more with '--help')

parent test:
test command
      --child <child>  foo
  -h, --help           Print help (see more with '--help')

parent help:
Print this message or the help of the given subcommand(s)
  [COMMAND]...  Print help for the subcommand(s)
";
    let cmd = Command::new("parent")
        .flatten_help(true)
        .about("parent command")
        .arg(
            Arg::new("parent")
                .long("parent")
                .help("foo")
                .long_help("bar"),
        )
        .subcommand(
            Command::new("test")
                .about("test command")
                .long_about("long some")
                .arg(Arg::new("child").long("child").help("foo").long_help("bar")),
        );
    utils::assert_output(cmd, "parent -h", EXPECTED, false);
}

#[test]
fn flatten_long_help() {
    static EXPECTED: &str = "\
parent command

Usage: parent [OPTIONS]
       parent test [OPTIONS]
       parent help [COMMAND]...

Options:
      --parent <parent>
          bar

  -h, --help
          Print help (see a summary with '-h')

parent test:
test command
      --child <child>
          bar

  -h, --help
          Print help (see a summary with '-h')

parent help:
Print this message or the help of the given subcommand(s)
  [COMMAND]...
          Print help for the subcommand(s)
";
    let cmd = Command::new("parent")
        .flatten_help(true)
        .about("parent command")
        .arg(
            Arg::new("parent")
                .long("parent")
                .help("foo")
                .long_help("bar"),
        )
        .subcommand(
            Command::new("test")
                .about("test command")
                .long_about("long some")
                .arg(Arg::new("child").long("child").help("foo").long_help("bar")),
        );
    utils::assert_output(cmd, "parent --help", EXPECTED, false);
}

#[test]
fn flatten_help_cmd() {
    static EXPECTED: &str = "\
parent command

Usage: parent [OPTIONS]
       parent test [OPTIONS]
       parent help [COMMAND]...

Options:
      --parent <parent>
          bar

  -h, --help
          Print help (see a summary with '-h')

parent test:
test command
      --child <child>
          bar

  -h, --help
          Print help (see a summary with '-h')

parent help:
Print this message or the help of the given subcommand(s)
  [COMMAND]...
          Print help for the subcommand(s)
";
    let cmd = Command::new("parent")
        .flatten_help(true)
        .about("parent command")
        .arg(
            Arg::new("parent")
                .long("parent")
                .help("foo")
                .long_help("bar"),
        )
        .subcommand(
            Command::new("test")
                .about("test command")
                .long_about("long some")
                .arg(Arg::new("child").long("child").help("foo").long_help("bar")),
        );
    utils::assert_output(cmd, "parent help", EXPECTED, false);
}

#[test]
fn flatten_with_global() {
    static EXPECTED: &str = "\
parent command

Usage: parent [OPTIONS]
       parent test [OPTIONS]
       parent help [COMMAND]...

Options:
      --parent <parent>  
  -h, --help             Print help

parent test:
test command
      --child <child>  
  -h, --help           Print help

parent help:
Print this message or the help of the given subcommand(s)
  [COMMAND]...  Print help for the subcommand(s)
";
    let cmd = Command::new("parent")
        .flatten_help(true)
        .about("parent command")
        .arg(Arg::new("parent").long("parent").global(true))
        .subcommand(
            Command::new("test")
                .about("test command")
                .arg(Arg::new("child").long("child")),
        );
    utils::assert_output(cmd, "parent -h", EXPECTED, false);
}

#[test]
fn flatten_arg_required() {
    static EXPECTED: &str = "\
parent command

Usage: parent --parent <parent>
       parent --parent <parent> test --child <child>
       parent --parent <parent> help [COMMAND]...

Options:
      --parent <parent>  
  -h, --help             Print help

parent --parent <parent> test:
test command
      --child <child>  
  -h, --help           Print help

parent --parent <parent> help:
Print this message or the help of the given subcommand(s)
  [COMMAND]...  Print help for the subcommand(s)
";
    let cmd = Command::new("parent")
        .flatten_help(true)
        .about("parent command")
        .arg(Arg::new("parent").long("parent").required(true))
        .subcommand(
            Command::new("test")
                .about("test command")
                .arg(Arg::new("child").long("child").required(true)),
        );
    utils::assert_output(cmd, "parent -h", EXPECTED, false);
}

#[test]
fn flatten_with_external_subcommand() {
    static EXPECTED: &str = "\
parent command

Usage: parent [OPTIONS]
       parent test [OPTIONS]
       parent help [COMMAND]...

Options:
      --parent <parent>  
  -h, --help             Print help

parent test:
test command
      --child <child>  
  -h, --help           Print help

parent help:
Print this message or the help of the given subcommand(s)
  [COMMAND]...  Print help for the subcommand(s)
";
    let cmd = Command::new("parent")
        .flatten_help(true)
        .about("parent command")
        .allow_external_subcommands(true)
        .arg(Arg::new("parent").long("parent"))
        .subcommand(
            Command::new("test")
                .about("test command")
                .arg(Arg::new("child").long("child")),
        );
    utils::assert_output(cmd, "parent -h", EXPECTED, false);
}

#[test]
fn flatten_without_subcommands() {
    static EXPECTED: &str = "\
parent command

Usage: parent [OPTIONS]

Options:
      --parent <parent>  
  -h, --help             Print help
";
    let cmd = Command::new("parent")
        .flatten_help(true)
        .about("parent command")
        .arg(Arg::new("parent").long("parent"));
    utils::assert_output(cmd, "parent -h", EXPECTED, false);
}

#[test]
fn flatten_with_subcommand_required() {
    static EXPECTED: &str = "\
parent command

Usage: parent test [OPTIONS]
       parent help [COMMAND]...

Options:
      --parent <parent>  
  -h, --help             Print help

parent test:
test command
      --child <child>  
  -h, --help           Print help

parent help:
Print this message or the help of the given subcommand(s)
  [COMMAND]...  Print help for the subcommand(s)
";
    let cmd = Command::new("parent")
        .flatten_help(true)
        .about("parent command")
        .subcommand_required(true)
        .arg(Arg::new("parent").long("parent"))
        .subcommand(
            Command::new("test")
                .about("test command")
                .arg(Arg::new("child").long("child")),
        );
    utils::assert_output(cmd, "parent -h", EXPECTED, false);
}

#[test]
fn flatten_with_args_conflicts_with_subcommands() {
    static EXPECTED: &str = "\
parent command

Usage: parent [OPTIONS]
       parent test [OPTIONS]
       parent help [COMMAND]...

Options:
      --parent <parent>  
  -h, --help             Print help

parent test:
test command
      --child <child>  
  -h, --help           Print help

parent help:
Print this message or the help of the given subcommand(s)
  [COMMAND]...  Print help for the subcommand(s)
";
    let cmd = Command::new("parent")
        .flatten_help(true)
        .about("parent command")
        .subcommand_required(true)
        .args_conflicts_with_subcommands(true)
        .arg(Arg::new("parent").long("parent"))
        .subcommand(
            Command::new("test")
                .about("test command")
                .arg(Arg::new("child").long("child")),
        );
    utils::assert_output(cmd, "parent -h", EXPECTED, false);
}

#[test]
fn flatten_single_hidden_command() {
    static EXPECTED: &str = "\
parent command

Usage: parent [OPTIONS]

Options:
      --parent <parent>  
  -h, --help             Print help
";
    let cmd = Command::new("parent")
        .flatten_help(true)
        .about("parent command")
        .arg(Arg::new("parent").long("parent"))
        .subcommand(
            Command::new("child1")
                .hide(true)
                .about("child1 command")
                .arg(Arg::new("child").long("child1")),
        );
    utils::assert_output(cmd, "parent -h", EXPECTED, false);
}

#[test]
fn flatten_hidden_command() {
    static EXPECTED: &str = "\
parent command

Usage: parent [OPTIONS]
       parent child1 [OPTIONS]
       parent child2 [OPTIONS]
       parent help [COMMAND]...

Options:
      --parent <parent>  
  -h, --help             Print help

parent child1:
child1 command
      --child1 <child>  
  -h, --help            Print help

parent child2:
child2 command
      --child2 <child>  
  -h, --help            Print help

parent help:
Print this message or the help of the given subcommand(s)
  [COMMAND]...  Print help for the subcommand(s)
";
    let cmd = Command::new("parent")
        .flatten_help(true)
        .about("parent command")
        .arg(Arg::new("parent").long("parent"))
        .subcommand(
            Command::new("child1")
                .about("child1 command")
                .arg(Arg::new("child").long("child1")),
        )
        .subcommand(
            Command::new("child2")
                .about("child2 command")
                .arg(Arg::new("child").long("child2")),
        )
        .subcommand(
            Command::new("child3")
                .hide(true)
                .about("child3 command")
                .arg(Arg::new("child").long("child3")),
        );
    utils::assert_output(cmd, "parent -h", EXPECTED, false);
}

#[test]
fn flatten_recursive() {
    static EXPECTED: &str = "\
parent command

Usage: parent [OPTIONS]
       parent child1 [OPTIONS]
       parent child1 grandchild1 [OPTIONS]
       parent child1 grandchild1 greatgrandchild1 [OPTIONS]
       parent child1 grandchild1 greatgrandchild2 [OPTIONS]
       parent child1 grandchild1 greatgrandchild3 [OPTIONS]
       parent child1 grandchild1 help [COMMAND]
       parent child1 grandchild2 [OPTIONS]
       parent child1 grandchild3 [OPTIONS]
       parent child1 help [COMMAND]
       parent child2 [OPTIONS]
       parent help [COMMAND]...

Options:
      --parent <parent>  
  -h, --help             Print help

parent child1:
child1 command
      --child1 <child>  
  -h, --help            Print help

parent child1 grandchild1:
grandchild1 command
      --grandchild1 <grandchild>  
  -h, --help                      Print help

parent child1 grandchild1 greatgrandchild1:
greatgrandchild1 command
      --greatgrandchild1 <greatgrandchild>  
  -h, --help                                Print help

parent child1 grandchild1 greatgrandchild2:
greatgrandchild2 command
      --greatgrandchild2 <greatgrandchild>  
  -h, --help                                Print help

parent child1 grandchild1 greatgrandchild3:
greatgrandchild3 command
      --greatgrandchild3 <greatgrandchild>  
  -h, --help                                Print help

parent child1 grandchild1 help:
Print this message or the help of the given subcommand(s)


parent child1 grandchild2:
grandchild2 command
      --grandchild2 <grandchild>  
  -h, --help                      Print help

parent child1 grandchild3:
grandchild3 command
      --grandchild3 <grandchild>  
  -h, --help                      Print help

parent child1 help:
Print this message or the help of the given subcommand(s)


parent child2:
child2 command
      --child2 <child>  
  -h, --help            Print help

parent help:
Print this message or the help of the given subcommand(s)
  [COMMAND]...  Print help for the subcommand(s)
";
    let cmd = Command::new("parent")
        .flatten_help(true)
        .about("parent command")
        .arg(Arg::new("parent").long("parent"))
        .subcommand(
            Command::new("child1")
                .flatten_help(true)
                .about("child1 command")
                .arg(Arg::new("child").long("child1"))
                .subcommand(
                    Command::new("grandchild1")
                        .flatten_help(true)
                        .about("grandchild1 command")
                        .arg(Arg::new("grandchild").long("grandchild1"))
                        .subcommand(
                            Command::new("greatgrandchild1")
                                .about("greatgrandchild1 command")
                                .arg(Arg::new("greatgrandchild").long("greatgrandchild1")),
                        )
                        .subcommand(
                            Command::new("greatgrandchild2")
                                .about("greatgrandchild2 command")
                                .arg(Arg::new("greatgrandchild").long("greatgrandchild2")),
                        )
                        .subcommand(
                            Command::new("greatgrandchild3")
                                .about("greatgrandchild3 command")
                                .arg(Arg::new("greatgrandchild").long("greatgrandchild3")),
                        ),
                )
                .subcommand(
                    Command::new("grandchild2")
                        .about("grandchild2 command")
                        .arg(Arg::new("grandchild").long("grandchild2")),
                )
                .subcommand(
                    Command::new("grandchild3")
                        .about("grandchild3 command")
                        .arg(Arg::new("grandchild").long("grandchild3")),
                ),
        )
        .subcommand(
            Command::new("child2")
                .about("child2 command")
                .arg(Arg::new("child").long("child2")),
        )
        .subcommand(
            Command::new("child3")
                .hide(true)
                .about("child3 command")
                .arg(Arg::new("child").long("child3"))
                .subcommand(
                    Command::new("grandchild1")
                        .flatten_help(true)
                        .about("grandchild1 command")
                        .arg(Arg::new("grandchild").long("grandchild1"))
                        .subcommand(
                            Command::new("greatgrandchild1")
                                .about("greatgrandchild1 command")
                                .arg(Arg::new("greatgrandchild").long("greatgrandchild1")),
                        )
                        .subcommand(
                            Command::new("greatgrandchild2")
                                .about("greatgrandchild2 command")
                                .arg(Arg::new("greatgrandchild").long("greatgrandchild2")),
                        )
                        .subcommand(
                            Command::new("greatgrandchild3")
                                .about("greatgrandchild3 command")
                                .arg(Arg::new("greatgrandchild").long("greatgrandchild3")),
                        ),
                )
                .subcommand(
                    Command::new("grandchild2")
                        .about("grandchild2 command")
                        .arg(Arg::new("grandchild").long("grandchild2")),
                )
                .subcommand(
                    Command::new("grandchild3")
                        .about("grandchild3 command")
                        .arg(Arg::new("grandchild").long("grandchild3")),
                ),
        );
    utils::assert_output(cmd, "parent -h", EXPECTED, false);
}

#[test]
fn flatten_not_recursive() {
    static EXPECTED: &str = "\
parent command

Usage: parent [OPTIONS]
       parent child1 [OPTIONS] [COMMAND]
       parent child2 [OPTIONS]
       parent child3 [OPTIONS]
       parent help [COMMAND]...

Options:
      --parent <parent>  
  -h, --help             Print help

parent child1:
child1 command
      --child1 <child>  
  -h, --help            Print help

parent child2:
child2 command
      --child2 <child>  
  -h, --help            Print help

parent child3:
child3 command
      --child3 <child>  
  -h, --help            Print help

parent help:
Print this message or the help of the given subcommand(s)
  [COMMAND]...  Print help for the subcommand(s)
";
    let cmd = Command::new("parent")
        .flatten_help(true)
        .about("parent command")
        .arg(Arg::new("parent").long("parent"))
        .subcommand(
            Command::new("child1")
                .about("child1 command")
                .arg(Arg::new("child").long("child1"))
                .subcommand(
                    Command::new("grandchild1")
                        .about("grandchild1 command")
                        .arg(Arg::new("grandchild").long("grandchild1")),
                )
                .subcommand(
                    Command::new("grandchild2")
                        .about("grandchild2 command")
                        .arg(Arg::new("grandchild").long("grandchild2")),
                )
                .subcommand(
                    Command::new("grandchild3")
                        .about("grandchild3 command")
                        .arg(Arg::new("grandchild").long("grandchild3")),
                ),
        )
        .subcommand(
            Command::new("child2")
                .about("child2 command")
                .arg(Arg::new("child").long("child2")),
        )
        .subcommand(
            Command::new("child3")
                .about("child3 command")
                .arg(Arg::new("child").long("child3")),
        );
    utils::assert_output(cmd, "parent -h", EXPECTED, false);
}