From 5e20a29b4fdc8a2d442d1093681b396dcb4b816b Mon Sep 17 00:00:00 2001
From: Robin Krahl <robin.krahl@ireas.org>
Date: Tue, 7 Jan 2020 11:18:04 +0000
Subject: Add structopt dependency in version 0.3.7

This patch series replaces argparse with structopt in the argument
handling code. As a first step, we need structopt as a dependency.

Import subrepo structopt/:structopt at efbdda4753592e27bc430fb01f7b9650b2f3174d
Import subrepo bitflags/:bitflags at 30668016aca6bd3b02c766e8347e0b4080d4c296
Import subrepo clap/:clap at 784524f7eb193e35f81082cc69454c8c21b948f7
Import subrepo heck/:heck at 093d56fbf001e1506e56dbfa38631d99b1066df1
Import subrepo proc-macro-error/:proc-macro-error at 6c4cfe79a622c5de8ae68557993542be46eacae2
Import subrepo proc-macro2/:proc-macro2 at d5d48eddca4566e5438e8a2cbed4a74e049544de
Import subrepo quote/:quote at 727436c6c137b20f0f34dde5d8fda2679b9747ad
Import subrepo rustversion/:rustversion at 0c5663313516263059ce9059ef81fc7a1cf655ca
Import subrepo syn-mid/:syn-mid at 5d3d85414a9e6674e1857ec22a87b96e04a6851a
Import subrepo syn/:syn at e87c27e87f6f4ef8919d0372bdb056d53ef0d8f3
Import subrepo textwrap/:textwrap at abcd618beae3f74841032aa5b53c1086b0a57ca2
Import subrepo unicode-segmentation/:unicode-segmentation at 637c9874c4fe0c205ff27787faf150a40295c6c3
Import subrepo unicode-width/:unicode-width at 3033826f8bf05e82724140a981d5941e48fce393
Import subrepo unicode-xid/:unicode-xid at 4baae9fffb156ba229665b972a9cd5991787ceb7
---
 clap/tests/help.rs | 1205 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1205 insertions(+)
 create mode 100644 clap/tests/help.rs

(limited to 'clap/tests/help.rs')

diff --git a/clap/tests/help.rs b/clap/tests/help.rs
new file mode 100644
index 0000000..4b15281
--- /dev/null
+++ b/clap/tests/help.rs
@@ -0,0 +1,1205 @@
+#[macro_use]
+extern crate clap;
+extern crate regex;
+
+include!("../clap-test.rs");
+
+use clap::{App, AppSettings, SubCommand, ErrorKind, Arg};
+
+static REQUIRE_DELIM_HELP: &'static str = "test 1.3
+Kevin K.
+tests stuff
+
+USAGE:
+    test --fake <some>:<val>
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+OPTIONS:
+    -f, --fake <some>:<val>    some help";
+
+static HELP: &'static str = "clap-test v1.4.8
+Kevin K. <kbknapp@gmail.com>
+tests clap library
+
+USAGE:
+    clap-test [FLAGS] [OPTIONS] [ARGS] [SUBCOMMAND]
+
+FLAGS:
+    -f, --flag       tests flags
+    -F               tests flags with exclusions
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+OPTIONS:
+    -O, --Option <option3>           specific vals [possible values: fast, slow]
+        --long-option-2 <option2>    tests long options with exclusions
+        --maxvals3 <maxvals>...      Tests 3 max vals
+        --minvals2 <minvals>...      Tests 2 min vals
+        --multvals <one> <two>       Tests multiple values, not mult occs
+        --multvalsmo <one> <two>     Tests multiple values, and mult occs
+    -o, --option <opt>...            tests options
+
+ARGS:
+    <positional>        tests positionals
+    <positional2>       tests positionals with exclusions
+    <positional3>...    tests specific values [possible values: vi, emacs]
+
+SUBCOMMANDS:
+    help      Prints this message or the help of the given subcommand(s)
+    subcmd    tests subcommands";
+
+static SC_NEGATES_REQS: &'static str = "prog 1.0
+
+USAGE:
+    prog --opt <FILE> [PATH]
+    prog [PATH] <SUBCOMMAND>
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+OPTIONS:
+    -o, --opt <FILE>    tests options
+
+ARGS:
+    <PATH>    help
+
+SUBCOMMANDS:
+    help    Prints this message or the help of the given subcommand(s)
+    test";
+
+static ARGS_NEGATE_SC: &'static str = "prog 1.0
+
+USAGE:
+    prog [FLAGS] [OPTIONS] [PATH]
+    prog <SUBCOMMAND>
+
+FLAGS:
+    -f, --flag       testing flags
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+OPTIONS:
+    -o, --opt <FILE>    tests options
+
+ARGS:
+    <PATH>    help
+
+SUBCOMMANDS:
+    help    Prints this message or the help of the given subcommand(s)
+    test";
+
+static AFTER_HELP: &'static str = "some text that comes before the help
+
+clap-test v1.4.8
+tests clap library
+
+USAGE:
+    clap-test
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+some text that comes after the help";
+
+static HIDDEN_ARGS: &'static str = "prog 1.0
+
+USAGE:
+    prog [FLAGS] [OPTIONS]
+
+FLAGS:
+    -f, --flag       testing flags
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+OPTIONS:
+    -o, --opt <FILE>    tests options";
+
+static SC_HELP: &'static str = "clap-test-subcmd 0.1
+Kevin K. <kbknapp@gmail.com>
+tests subcommands
+
+USAGE:
+    clap-test subcmd [FLAGS] [OPTIONS] [--] [scpositional]
+
+FLAGS:
+    -f, --flag       tests flags
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+OPTIONS:
+    -o, --option <scoption>...     tests options
+    -s, --subcmdarg <subcmdarg>    tests other args
+
+ARGS:
+    <scpositional>    tests positionals";
+
+static ISSUE_1046_HIDDEN_SCS: &'static str = "prog 1.0
+
+USAGE:
+    prog [FLAGS] [OPTIONS] [PATH]
+
+FLAGS:
+    -f, --flag       testing flags
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+OPTIONS:
+    -o, --opt <FILE>    tests options
+
+ARGS:
+    <PATH>    some";
+
+// Using number_of_values(1) with multiple(true) misaligns help message
+static ISSUE_760: &'static str = "ctest 0.1
+
+USAGE:
+    ctest [OPTIONS]
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+OPTIONS:
+    -O, --opt <opt>             tests options
+    -o, --option <option>...    tests options";
+
+static RIPGREP_USAGE: &'static str = "ripgrep 0.5
+
+USAGE:
+    rg [OPTIONS] <pattern> [<path> ...]
+    rg [OPTIONS] [-e PATTERN | -f FILE ]... [<path> ...]
+    rg [OPTIONS] --files [<path> ...]
+    rg [OPTIONS] --type-list
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information";
+
+
+static MULTI_SC_HELP: &'static str = "ctest-subcmd-multi 0.1
+Kevin K. <kbknapp@gmail.com>
+tests subcommands
+
+USAGE:
+    ctest subcmd multi [FLAGS] [OPTIONS]
+
+FLAGS:
+    -f, --flag       tests flags
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+OPTIONS:
+    -o, --option <scoption>...    tests options";
+
+static ISSUE_626_CUTOFF: &'static str = "ctest 0.1
+
+USAGE:
+    ctest [OPTIONS]
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+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.";
+
+static ISSUE_626_PANIC: &'static str = "ctest 0.1
+
+USAGE:
+    ctest [OPTIONS]
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+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.";
+
+static HIDE_POS_VALS: &'static str = "ctest 0.1
+
+USAGE:
+    ctest [OPTIONS]
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+OPTIONS:
+    -c, --cafe <FILE>    A coffeehouse, coffee shop, or café.
+    -p, --pos <VAL>      Some vals [possible values: fast, slow]";
+
+static FINAL_WORD_WRAPPING: &'static str = "ctest 0.1
+
+USAGE:
+    ctest
+
+FLAGS:
+    -h, --help
+            Prints help
+            information
+    -V, --version
+            Prints
+            version
+            information";
+
+static OLD_NEWLINE_CHARS: &'static str = "ctest 0.1
+
+USAGE:
+    ctest [FLAGS]
+
+FLAGS:
+    -h, --help       Prints help information
+    -m               Some help with some wrapping
+                     (Defaults to something)
+    -V, --version    Prints version information";
+
+static WRAPPING_NEWLINE_CHARS: &'static str = "ctest 0.1
+
+USAGE:
+    ctest [mode]
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+ARGS:
+    <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.";
+
+static ISSUE_688: &'static str = "ctest 0.1
+
+USAGE:
+    ctest [OPTIONS]
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+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]";
+
+static ISSUE_702: &'static str = "myapp 1.0
+foo
+bar
+
+USAGE:
+    myapp [OPTIONS] [--] [ARGS]
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+OPTIONS:
+    -l, --label <label>...    a label
+    -o, --other <other>       some other option
+    -s, --some <some>         some option
+
+ARGS:
+    <arg1>       some option
+    <arg2>...    some option";
+
+static ISSUE_777: &'static str = "A app 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
+
+FLAGS:
+    -h, --help
+            Prints help information
+
+    -V, --version
+            Prints version
+            information";
+
+static CUSTOM_VERSION_AND_HELP: &'static str = "customize 0.1
+Nobody <odysseus@example.com>
+You can customize the version and help text
+
+USAGE:
+    customize
+
+FLAGS:
+    -H, --help       Print help information
+    -v, --version    Print version information";
+
+static LAST_ARG: &'static str = "last 0.1
+
+USAGE:
+    last <TARGET> [CORPUS] [-- <ARGS>...]
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+ARGS:
+    <TARGET>     some
+    <CORPUS>     some
+    <ARGS>...    some";
+
+static LAST_ARG_SC: &'static str = "last 0.1
+
+USAGE:
+    last <TARGET> [CORPUS] [-- <ARGS>...]
+    last <SUBCOMMAND>
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+ARGS:
+    <TARGET>     some
+    <CORPUS>     some
+    <ARGS>...    some
+
+SUBCOMMANDS:
+    help    Prints this message or the help of the given subcommand(s)
+    test    some";
+
+static LAST_ARG_REQ: &'static str = "last 0.1
+
+USAGE:
+    last <TARGET> [CORPUS] -- <ARGS>...
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+ARGS:
+    <TARGET>     some
+    <CORPUS>     some
+    <ARGS>...    some";
+
+static LAST_ARG_REQ_SC: &'static str = "last 0.1
+
+USAGE:
+    last <TARGET> [CORPUS] -- <ARGS>...
+    last <SUBCOMMAND>
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+ARGS:
+    <TARGET>     some
+    <CORPUS>     some
+    <ARGS>...    some
+
+SUBCOMMANDS:
+    help    Prints this message or the help of the given subcommand(s)
+    test    some";
+
+static HIDE_DEFAULT_VAL: &'static str = "default 0.1
+
+USAGE:
+    default [OPTIONS]
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+OPTIONS:
+        --arg <argument>    Pass an argument to the program. [default: default-argument]";
+
+static LAST_ARG_USAGE: &'static str = "flamegraph 0.1
+
+USAGE:
+    flamegraph [FLAGS] [OPTIONS] [BINFILE] [-- <ARGS>...]
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+    -v, --verbose    Prints out more stuff.
+
+OPTIONS:
+    -f, --frequency <HERTZ>    The sampling frequency.
+    -t, --timeout <SECONDS>    Timeout in seconds.
+
+ARGS:
+    <BINFILE>    The path of the binary to be profiled. for a binary.
+    <ARGS>...    Any arguments you wish to pass to the being profiled.";
+
+static LAST_ARG_REQ_MULT: &'static str = "example 1.0
+
+USAGE:
+    example <FIRST>... [--] <SECOND>...
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+ARGS:
+    <FIRST>...     First
+    <SECOND>...    Second";
+
+static DEFAULT_HELP: &'static str = "ctest 1.0
+
+USAGE:
+    ctest
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information";
+
+static LONG_ABOUT: &'static str = "myapp 1.0
+foo
+something really really long, with
+multiple lines of text
+that should be displayed
+
+USAGE:
+    myapp [arg1]
+
+FLAGS:
+    -h, --help       
+            Prints help information
+
+    -V, --version    
+            Prints version information
+
+
+ARGS:
+    <arg1>    
+            some option";
+
+static HIDE_ENV_VALS: &'static str = "ctest 0.1
+
+USAGE:
+    ctest [OPTIONS]
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+OPTIONS:
+    -c, --cafe <FILE>    A coffeehouse, coffee shop, or café. [env: ENVVAR]
+    -p, --pos <VAL>      Some vals [possible values: fast, slow]";
+
+static SHOW_ENV_VALS: &'static str = "ctest 0.1
+
+USAGE:
+    ctest [OPTIONS]
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information
+
+OPTIONS:
+    -c, --cafe <FILE>    A coffeehouse, coffee shop, or café. [env: ENVVAR=MYVAL]
+    -p, --pos <VAL>      Some vals [possible values: fast, slow]";
+
+fn setup() -> App<'static, 'static> {
+    App::new("test")
+        .author("Kevin K.")
+        .about("tests stuff")
+        .version("1.3")
+}
+
+#[test]
+fn help_short() {
+    let m = setup()
+        .get_matches_from_safe(vec!["myprog", "-h"]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind, ErrorKind::HelpDisplayed);
+}
+
+#[test]
+fn help_long() {
+    let m = setup()
+        .get_matches_from_safe(vec!["myprog", "--help"]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind, ErrorKind::HelpDisplayed);
+}
+
+#[test]
+fn help_no_subcommand() {
+    let m = setup() 
+        .get_matches_from_safe(vec!["myprog", "help"]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind, ErrorKind::UnknownArgument);
+}
+
+#[test]
+fn help_subcommand() {
+    let m = setup()
+        .subcommand(SubCommand::with_name("test")
+            .about("tests things")
+            .arg_from_usage("-v --verbose 'with verbosity'"))
+        .get_matches_from_safe(vec!["myprog", "help"]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind, ErrorKind::HelpDisplayed);
+}
+
+#[test]
+fn req_last_arg_usage() {
+    let app = clap_app!(example =>
+        (version: "1.0")
+        (@arg FIRST: ... * "First")
+        (@arg SECOND: ... * +last "Second")
+    );
+    assert!(test::compare_output(app, "example --help", LAST_ARG_REQ_MULT, false));
+}
+
+#[test]
+fn args_with_last_usage() {
+    let app = App::new("flamegraph")
+        .version("0.1")
+        .setting(AppSettings::TrailingVarArg)
+        .arg(Arg::with_name("verbose")
+            .help("Prints out more stuff.")
+            .short("v")
+            .long("verbose")
+            .multiple(true)
+        )
+        .arg(Arg::with_name("timeout")
+            .help("Timeout in seconds.")
+            .short("t")
+            .long("timeout")
+            .value_name("SECONDS")
+            .takes_value(true)
+        )
+        .arg(Arg::with_name("frequency")
+            .help("The sampling frequency.")
+            .short("f")
+            .long("frequency")
+            .value_name("HERTZ")
+            .takes_value(true)
+        )
+        .arg(Arg::with_name("binary path")
+            .help("The path of the binary to be profiled. for a binary.")
+            .takes_value(true)
+            .value_name("BINFILE")
+        )
+        .arg(Arg::with_name("pass through args")
+            .help("Any arguments you wish to pass to the being profiled.")
+            .value_name("ARGS")
+            .last(true)
+            .multiple(true)
+        );
+    assert!(test::compare_output(app, "flamegraph --help", LAST_ARG_USAGE, false));
+}
+
+#[test]
+fn subcommand_short_help() {
+    let m = test::complex_app().get_matches_from_safe(vec!["clap-test", "subcmd", "-h"]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind, ErrorKind::HelpDisplayed);
+}
+
+#[test]
+fn subcommand_long_help() {
+    let m = test::complex_app().get_matches_from_safe(vec!["clap-test", "subcmd", "--help"]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind, ErrorKind::HelpDisplayed);
+}
+
+#[test]
+fn subcommand_help_rev() {
+    let m = test::complex_app().get_matches_from_safe(vec!["clap-test", "help", "subcmd"]);
+
+    assert!(m.is_err());
+    assert_eq!(m.unwrap_err().kind, ErrorKind::HelpDisplayed);
+}
+
+#[test]
+fn complex_help_output() {
+    assert!(test::compare_output(test::complex_app(), "clap-test --help", HELP, false));
+}
+
+#[test]
+fn after_and_before_help_output() {
+    let app = App::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");
+    assert!(test::compare_output(app, "clap-test --help", AFTER_HELP, false));
+}
+
+#[test]
+fn multi_level_sc_help() {
+    let app = App::new("ctest")
+        .subcommand(SubCommand::with_name("subcmd").subcommand(SubCommand::with_name("multi")
+            .about("tests subcommands")
+            .author("Kevin K. <kbknapp@gmail.com>")
+            .version("0.1")
+            .args_from_usage("
+                    -f, --flag                    'tests flags'
+                    -o, --option [scoption]...    'tests options'
+                ")));
+    assert!(test::compare_output(app, "ctest help subcmd multi", MULTI_SC_HELP, false));
+}
+
+#[test]
+fn no_wrap_help() {
+    let app = App::new("ctest")
+        .set_term_width(0)
+        .help(MULTI_SC_HELP);
+    assert!(test::compare_output(app, "ctest --help", MULTI_SC_HELP, false));
+}
+
+#[test]
+fn no_wrap_default_help() {
+    let app = App::new("ctest").version("1.0").set_term_width(0);
+    assert!(test::compare_output(app, "ctest --help", DEFAULT_HELP, false));
+}
+
+#[test]
+fn complex_subcommand_help_output() {
+    let a = test::complex_app();
+    assert!(test::compare_output(a, "clap-test subcmd --help", SC_HELP, false));
+}
+
+
+#[test]
+fn issue_626_unicode_cutoff() {
+    let app = App::new("ctest")
+        .version("0.1")
+        .set_term_width(70)
+        .arg(Arg::with_name("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.")
+            .takes_value(true));
+    assert!(test::compare_output(app, "ctest --help", ISSUE_626_CUTOFF, false));
+}
+
+#[test]
+fn hide_possible_vals() {
+    let app = App::new("ctest")
+        .version("0.1")
+        .arg(Arg::with_name("pos")
+            .short("p")
+            .long("pos")
+            .value_name("VAL")
+            .possible_values(&["fast", "slow"])
+            .help("Some vals")
+            .takes_value(true))
+        .arg(Arg::with_name("cafe")
+            .short("c")
+            .long("cafe")
+            .value_name("FILE")
+            .hide_possible_values(true)
+            .possible_values(&["fast", "slow"])
+            .help("A coffeehouse, coffee shop, or café.")
+            .takes_value(true));
+    assert!(test::compare_output(app, "ctest --help", HIDE_POS_VALS, false));
+}
+
+#[test]
+fn issue_626_panic() {
+    let app = App::new("ctest")
+        .version("0.1")
+        .set_term_width(52)
+        .arg(Arg::with_name("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.")
+           .takes_value(true));
+    assert!(test::compare_output(app, "ctest --help", ISSUE_626_PANIC, false));
+}
+
+#[test]
+fn issue_626_variable_panic() {
+    for i in 10..320 {
+        let _ = App::new("ctest")
+            .version("0.1")
+            .set_term_width(i)
+            .arg(Arg::with_name("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.")
+               .takes_value(true))
+            .get_matches_from_safe(vec!["ctest", "--help"]);
+    }
+}
+
+#[test]
+fn final_word_wrapping() {
+    let app = App::new("ctest").version("0.1").set_term_width(24);
+    assert!(test::compare_output(app, "ctest --help", FINAL_WORD_WRAPPING, false));
+}
+
+#[test]
+fn wrapping_newline_chars() {
+    let app = App::new("ctest")
+        .version("0.1")
+		.set_term_width(60)
+        .arg(Arg::with_name("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}"));
+    assert!(test::compare_output(app, "ctest --help", WRAPPING_NEWLINE_CHARS, false));
+}
+
+#[test]
+fn old_newline_chars() {
+    let app = App::new("ctest")
+        .version("0.1")
+        .arg(Arg::with_name("mode")
+            .short("m")
+            .help("Some help with some wrapping{n}(Defaults to something)"));
+    assert!(test::compare_output(app, "ctest --help", OLD_NEWLINE_CHARS, false));
+}
+
+#[test]
+fn issue_688_hidden_pos_vals() {
+    let filter_values = ["Nearest", "Linear", "Cubic", "Gaussian", "Lanczos3"];
+
+    let app1 = App::new("ctest")
+            .version("0.1")
+			.set_term_width(120)
+			.setting(AppSettings::HidePossibleValuesInHelp)
+			.arg(Arg::with_name("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")
+				.possible_values(&filter_values)
+				.takes_value(true));
+    assert!(test::compare_output(app1, "ctest --help", ISSUE_688, false));
+
+    let app2 = App::new("ctest")
+            .version("0.1")
+			.set_term_width(120)
+			.arg(Arg::with_name("filter")
+				.help("Sets the filter, or sampling method, to use for interpolation when resizing the particle \
+                images. The default is Linear (Bilinear).")
+				.long("filter")
+				.possible_values(&filter_values)
+				.takes_value(true));
+    assert!(test::compare_output(app2, "ctest --help", ISSUE_688, false));
+
+    let app3 = App::new("ctest")
+            .version("0.1")
+			.set_term_width(120)
+			.arg(Arg::with_name("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")
+				.takes_value(true));
+    assert!(test::compare_output(app3, "ctest --help", ISSUE_688, false));
+}
+
+#[test]
+fn issue_702_multiple_values() {
+    let app = App::new("myapp")
+        .version("1.0")
+        .author("foo")
+        .about("bar")
+        .arg(Arg::with_name("arg1").help("some option"))
+        .arg(Arg::with_name("arg2")
+            .multiple(true)
+            .help("some option"))
+        .arg(Arg::with_name("some")
+            .help("some option")
+            .short("s")
+            .long("some")
+            .takes_value(true))
+        .arg(Arg::with_name("other")
+            .help("some other option")
+            .short("o")
+            .long("other")
+            .takes_value(true))
+        .arg(Arg::with_name("label")
+            .help("a label")
+            .short("l")
+            .long("label")
+            .multiple(true)
+            .takes_value(true));
+    assert!(test::compare_output(app, "myapp --help", ISSUE_702, false));
+}
+
+#[test]
+fn long_about() {
+    let app = App::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::with_name("arg1").help("some option"));
+    assert!(test::compare_output(app, "myapp --help", LONG_ABOUT, false));
+}
+
+#[test]
+fn issue_760() {
+    let app = App::new("ctest")
+        .version("0.1")
+        .arg(Arg::with_name("option")
+            .help("tests options")
+            .short("o")
+            .long("option")
+            .takes_value(true)
+            .multiple(true)
+            .number_of_values(1))
+        .arg(Arg::with_name("opt")
+            .help("tests options")
+            .short("O")
+            .long("opt")
+            .takes_value(true));
+    assert!(test::compare_output(app, "ctest --help", ISSUE_760, false));
+}
+
+#[test]
+fn ripgrep_usage() {
+    let app = App::new("ripgrep")
+        .version("0.5")
+        .usage("rg [OPTIONS] <pattern> [<path> ...]
+    rg [OPTIONS] [-e PATTERN | -f FILE ]... [<path> ...]
+    rg [OPTIONS] --files [<path> ...]
+    rg [OPTIONS] --type-list");
+
+    assert!(test::compare_output(app, "rg --help", RIPGREP_USAGE, false));
+}
+
+#[test]
+fn ripgrep_usage_using_templates() {
+    let app = App::new("ripgrep")
+        .version("0.5")
+        .usage("
+    rg [OPTIONS] <pattern> [<path> ...]
+    rg [OPTIONS] [-e PATTERN | -f FILE ]... [<path> ...]
+    rg [OPTIONS] --files [<path> ...]
+    rg [OPTIONS] --type-list")
+        .template("\
+{bin} {version}
+
+USAGE:{usage}
+
+FLAGS:
+{flags}");
+
+    assert!(test::compare_output(app, "rg --help", RIPGREP_USAGE, false));
+}
+
+#[test]
+fn sc_negates_reqs() {
+    let app = App::new("prog")
+        .version("1.0")
+        .setting(AppSettings::SubcommandsNegateReqs)
+        .arg_from_usage("-o, --opt <FILE> 'tests options'")
+        .arg(Arg::with_name("PATH").help("help"))
+        .subcommand(SubCommand::with_name("test"));
+    assert!(test::compare_output(app, "prog --help", SC_NEGATES_REQS, false));
+}
+
+#[test]
+fn hidden_args() {
+    let app = App::new("prog")
+        .version("1.0")
+        .args_from_usage("-f, --flag 'testing flags'
+                          -o, --opt [FILE] 'tests options'")
+        .arg(Arg::with_name("pos").hidden(true));
+    assert!(test::compare_output(app, "prog --help", HIDDEN_ARGS, false));
+}
+
+#[test]
+fn args_negate_sc() {
+    let app = App::new("prog")
+        .version("1.0")
+        .setting(AppSettings::ArgsNegateSubcommands)
+        .args_from_usage("-f, --flag 'testing flags'
+                          -o, --opt [FILE] 'tests options'")
+        .arg(Arg::with_name("PATH").help("help"))
+        .subcommand(SubCommand::with_name("test"));
+    assert!(test::compare_output(app, "prog --help", ARGS_NEGATE_SC, false));
+}
+
+#[test]
+fn issue_1046_hidden_scs() {
+    let app = App::new("prog")
+        .version("1.0")
+        .args_from_usage("-f, --flag 'testing flags'
+                          -o, --opt [FILE] 'tests options'")
+        .arg(Arg::with_name("PATH").help("some"))
+        .subcommand(SubCommand::with_name("test").setting(AppSettings::Hidden));
+    assert!(test::compare_output(app, "prog --help", ISSUE_1046_HIDDEN_SCS, false));
+}
+
+#[test]
+fn issue_777_wrap_all_things() {
+    let app = App::new("A app 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")
+        .set_term_width(35);
+    assert!(test::compare_output(app, "ctest --help", ISSUE_777, false));
+}
+
+#[test]
+fn customize_version_and_help() {
+    let app = App::new("customize")
+        .version("0.1")
+        .author("Nobody <odysseus@example.com>")
+        .about("You can customize the version and help text")
+        .help_short("H")
+        .help_message("Print help information")
+        .version_short("v")
+        .version_message("Print version information");
+    assert!(test::compare_output(app, "customize --help", CUSTOM_VERSION_AND_HELP, false));
+}
+
+#[test]
+fn last_arg_mult_usage() {
+    let app = App::new("last")
+            .version("0.1")
+            .arg(Arg::with_name("TARGET").required(true).help("some"))
+            .arg(Arg::with_name("CORPUS").help("some"))
+            .arg(Arg::with_name("ARGS").multiple(true).last(true).help("some"));
+    assert!(test::compare_output(app, "last --help", LAST_ARG, false));
+}
+
+#[test]
+fn last_arg_mult_usage_req() {
+    let app = App::new("last")
+            .version("0.1")
+            .arg(Arg::with_name("TARGET").required(true).help("some"))
+            .arg(Arg::with_name("CORPUS").help("some"))
+            .arg(Arg::with_name("ARGS").multiple(true).last(true).required(true).help("some"));
+    assert!(test::compare_output(app, "last --help", LAST_ARG_REQ, false));
+}
+
+#[test]
+fn last_arg_mult_usage_req_with_sc() {
+    let app = App::new("last")
+            .version("0.1")
+            .setting(AppSettings::SubcommandsNegateReqs)
+            .arg(Arg::with_name("TARGET").required(true).help("some"))
+            .arg(Arg::with_name("CORPUS").help("some"))
+            .arg(Arg::with_name("ARGS").multiple(true).last(true).required(true).help("some"))
+            .subcommand(SubCommand::with_name("test").about("some"));
+    assert!(test::compare_output(app, "last --help", LAST_ARG_REQ_SC, false));
+}
+
+#[test]
+fn last_arg_mult_usage_with_sc() {
+    let app = App::new("last")
+            .version("0.1")
+            .setting(AppSettings::ArgsNegateSubcommands)
+            .arg(Arg::with_name("TARGET").required(true).help("some"))
+            .arg(Arg::with_name("CORPUS").help("some"))
+            .arg(Arg::with_name("ARGS").multiple(true).last(true).help("some"))
+            .subcommand(SubCommand::with_name("test").about("some"));
+    assert!(test::compare_output(app, "last --help", LAST_ARG_SC, false));
+}
+
+
+#[test]
+fn hidden_default_val() {
+    let app1 = App::new("default")
+        .version("0.1")
+        .set_term_width(120)
+        .arg(Arg::with_name("argument")
+             .help("Pass an argument to the program. [default: default-argument]")
+             .long("arg")
+             .default_value("default-argument")
+             .hide_default_value(true));
+    assert!(test::compare_output(app1, "default --help", HIDE_DEFAULT_VAL, false));
+
+    let app2 = App::new("default")
+        .version("0.1")
+        .set_term_width(120)
+        .arg(Arg::with_name("argument")
+             .help("Pass an argument to the program.")
+             .long("arg")
+             .default_value("default-argument"));
+    assert!(test::compare_output(app2, "default --help", HIDE_DEFAULT_VAL, false));
+}
+
+fn issue_1112_setup() -> App<'static, 'static> {
+    App::new("test")
+        .author("Kevin K.")
+        .about("tests stuff")
+        .version("1.3")
+        .arg(Arg::from_usage("-h, --help 'some help'"))
+        .subcommand(SubCommand::with_name("foo")
+            .arg(Arg::from_usage("-h, --help 'some help'")))
+}
+
+#[test]
+fn issue_1112_override_help_long() {
+    let m = issue_1112_setup()
+        .get_matches_from_safe(vec!["test", "--help"]);
+
+    assert!(m.is_ok());
+    assert!(m.unwrap().is_present("help"));
+}
+
+#[test]
+fn issue_1112_override_help_short() {
+    let m = issue_1112_setup()
+        .get_matches_from_safe(vec!["test", "-h"]);
+
+    assert!(m.is_ok());
+    assert!(m.unwrap().is_present("help"));
+}
+
+#[test]
+fn issue_1112_override_help_subcmd_long() {
+    let m = issue_1112_setup()
+        .get_matches_from_safe(vec!["test", "foo", "--help"]);
+
+    assert!(m.is_ok());
+    assert!(m.unwrap().subcommand_matches("foo").unwrap().is_present("help"));
+}
+
+#[test]
+fn issue_1112_override_help_subcmd_short() {
+    let m = issue_1112_setup()
+        .get_matches_from_safe(vec!["test", "foo", "-h"]);
+
+    assert!(m.is_ok());
+    assert!(m.unwrap().subcommand_matches("foo").unwrap().is_present("help"));
+}
+
+#[test]
+fn issue_1052_require_delim_help() {
+    let app = App::new("test")
+        .author("Kevin K.")
+        .about("tests stuff")
+        .version("1.3")
+        .arg(Arg::from_usage("-f, --fake <some> <val> 'some help'").require_delimiter(true).value_delimiter(":"));
+
+    assert!(test::compare_output(app, "test --help", REQUIRE_DELIM_HELP, false));
+}
+
+#[test]
+fn hide_env_vals() {
+    use std::env;
+
+    env::set_var("ENVVAR", "MYVAL");
+    let app = App::new("ctest")
+        .version("0.1")
+        .arg(Arg::with_name("pos")
+            .short("p")
+            .long("pos")
+            .value_name("VAL")
+            .possible_values(&["fast", "slow"])
+            .help("Some vals")
+            .takes_value(true))
+        .arg(Arg::with_name("cafe")
+            .short("c")
+            .long("cafe")
+            .value_name("FILE")
+            .hide_env_values(true)
+            .env("ENVVAR")
+            .help("A coffeehouse, coffee shop, or café.")
+            .takes_value(true));
+    assert!(test::compare_output(app, "ctest --help", HIDE_ENV_VALS, false));
+}
+
+#[test]
+fn show_env_vals() {
+    use std::env;
+
+    env::set_var("ENVVAR", "MYVAL");
+    let app = App::new("ctest")
+        .version("0.1")
+        .arg(Arg::with_name("pos")
+            .short("p")
+            .long("pos")
+            .value_name("VAL")
+            .possible_values(&["fast", "slow"])
+            .help("Some vals")
+            .takes_value(true))
+        .arg(Arg::with_name("cafe")
+            .short("c")
+            .long("cafe")
+            .value_name("FILE")
+            .hide_possible_values(true)
+            .env("ENVVAR")
+            .help("A coffeehouse, coffee shop, or café.")
+            .takes_value(true));
+    assert!(test::compare_output(app, "ctest --help", SHOW_ENV_VALS, false));
+}
+
+static ISSUE_897: &'static str = "ctest-foo 0.1
+Long about foo
+
+USAGE:
+    ctest foo
+
+FLAGS:
+    -h, --help       
+            Prints help information
+
+    -V, --version    
+            Prints version information";
+
+#[test]
+fn show_long_about_issue_897() {
+    let app = App::new("ctest")
+        .version("0.1")
+        .subcommand(SubCommand::with_name("foo")
+            .version("0.1")
+            .about("About foo")
+            .long_about("Long about foo"));
+    assert!(test::compare_output(app, "ctest foo --help", ISSUE_897, false));
+}
+
+static ISSUE_897_SHORT: &'static str = "ctest-foo 0.1
+Long about foo
+
+USAGE:
+    ctest foo
+
+FLAGS:
+    -h, --help       Prints help information
+    -V, --version    Prints version information";
+
+#[test]
+fn show_short_about_issue_897() {
+    let app = App::new("ctest")
+        .version("0.1")
+        .subcommand(SubCommand::with_name("foo")
+            .version("0.1")
+            .about("About foo")
+            .long_about("Long about foo"));
+    assert!(test::compare_output(app, "ctest foo -h", ISSUE_897_SHORT, false));
+}
-- 
cgit v1.2.1