636467251

Build Type

github

Committed by GitHub

Commit Message

Merge 4aa4c3eee into 63612496c

Pull Request Pull Request #2399: Implement NoEquals error

Run Details

30 of 30 new or added lines in 4 files covered. (100.0%)

10937 of 12747 relevant lines covered (85.8%)

13.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.61

/tests/opts.rs

mod utils;

use clap::{App, Arg, ArgMatches, ArgSettings, ErrorKind};

#[cfg(feature = "suggestions")]
static DYM: &str =
    "error: Found argument '--optio' which wasn't expected, or isn't valid in this context

\tDid you mean '--option'?

\tIf you tried to supply `--optio` as a value rather than a flag, use `-- --optio`

USAGE:
    clap-test --option <opt>...

For more information try --help";

#[cfg(feature = "suggestions")]
static DYM_ISSUE_1073: &str =
    "error: Found argument '--files-without-matches' which wasn't expected, or isn't valid in this context

\tDid you mean '--files-without-match'?

\tIf you tried to supply `--files-without-matches` as a value rather than a flag, use `-- --files-without-matches`

USAGE:
    ripgrep-616 --files-without-match

For more information try --help";

#[test]
fn require_equals_fail() {
    let res = App::new("prog")
        .arg(
            Arg::new("cfg")
                .setting(ArgSettings::RequireEquals)
                .setting(ArgSettings::TakesValue)
                .long("config"),
        )
        .try_get_matches_from(vec!["prog", "--config", "file.conf"]);
    assert!(res.is_err());
    assert_eq!(res.unwrap_err().kind, ErrorKind::NoEquals);
}

#[test]
fn require_equals_fail_message() {
    static NO_EQUALS: &str = "error: Equal sign is needed when assigning values to '--config=<cfg>'.

USAGE:
    prog [OPTIONS]

For more information try --help";
    let app = App::new("prog").arg(
        Arg::new("cfg")
            .setting(ArgSettings::RequireEquals)
            .setting(ArgSettings::TakesValue)
            .long("config"),
    );
    assert!(utils::compare_output(
        app,
        "prog --config file.conf",
        NO_EQUALS,
        true
    ));
}

#[test]
fn require_equals_min_values_zero() {
    let res = App::new("prog")
        .arg(
            Arg::new("cfg")
                .setting(ArgSettings::RequireEquals)
                .min_values(0)
                .long("config"),
        )
        .arg(Arg::new("cmd"))
        .try_get_matches_from(vec!["prog", "--config", "cmd"]);
    assert!(res.is_ok());
    let m = res.unwrap();
    assert!(m.is_present("cfg"));
    assert_eq!(m.value_of("cmd"), Some("cmd"));
}

#[test]
fn double_hyphen_as_value() {
    let res = App::new("prog")
        .arg(
            Arg::new("cfg")
                .setting(ArgSettings::AllowHyphenValues)
                .long("config"),
        )
        .try_get_matches_from(vec!["prog", "--config", "--"]);
    assert!(res.is_ok(), "{:?}", res);
    assert_eq!(res.unwrap().value_of("cfg"), Some("--"));
}

#[test]
fn require_equals_no_empty_values_fail() {
    let res = App::new("prog")
        .arg(
            Arg::new("cfg")
                .setting(ArgSettings::RequireEquals)
                .long("config"),
        )
        .arg(Arg::new("some"))
        .try_get_matches_from(vec!["prog", "--config=", "file.conf"]);
    assert!(res.is_err());
    assert_eq!(res.unwrap_err().kind, ErrorKind::EmptyValue);
}

#[test]
fn require_equals_empty_vals_pass() {
    let res = App::new("prog")
        .arg(
            Arg::new("cfg")
                .setting(ArgSettings::RequireEquals)
                .setting(ArgSettings::AllowEmptyValues)
                .long("config"),
        )
        .try_get_matches_from(vec!["prog", "--config="]);
    assert!(res.is_ok());
}

#[test]
fn require_equals_pass() {
    let res = App::new("prog")
        .arg(
            Arg::new("cfg")
                .setting(ArgSettings::RequireEquals)
                .long("config"),
        )
        .try_get_matches_from(vec!["prog", "--config=file.conf"]);
    assert!(res.is_ok());
}

#[test]
fn stdin_char() {
    let r = App::new("opts")
        .arg(Arg::from("-f [flag] 'some flag'"))
        .try_get_matches_from(vec!["", "-f", "-"]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert!(m.is_present("f"));
    assert_eq!(m.value_of("f").unwrap(), "-");
}

#[test]
fn opts_using_short() {
    let r = App::new("opts")
        .args(&[
            Arg::from("-f [flag] 'some flag'"),
            Arg::from("-c [color] 'some other flag'"),
        ])
        .try_get_matches_from(vec!["", "-f", "some", "-c", "other"]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert!(m.is_present("f"));
    assert_eq!(m.value_of("f").unwrap(), "some");
    assert!(m.is_present("c"));
    assert_eq!(m.value_of("c").unwrap(), "other");
}

#[test]
fn lots_o_vals() {
    let r = App::new("opts")
        .arg(Arg::from("-o [opt]... 'some opt'"))
        .try_get_matches_from(vec![
            "", "-o", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
            "some", "some",
        ]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert!(m.is_present("o"));
    assert_eq!(m.values_of("o").unwrap().count(), 297); // i.e. more than u8
}

#[test]
fn opts_using_long_space() {
    let r = App::new("opts")
        .args(&[
            Arg::from("--flag [flag] 'some flag'"),
            Arg::from("--color [color] 'some other flag'"),
        ])
        .try_get_matches_from(vec!["", "--flag", "some", "--color", "other"]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert!(m.is_present("flag"));
    assert_eq!(m.value_of("flag").unwrap(), "some");
    assert!(m.is_present("color"));
    assert_eq!(m.value_of("color").unwrap(), "other");
}

#[test]
fn opts_using_long_equals() {
    let r = App::new("opts")
        .args(&[
            Arg::from("--flag [flag] 'some flag'"),
            Arg::from("--color [color] 'some other flag'"),
        ])
        .try_get_matches_from(vec!["", "--flag=some", "--color=other"]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert!(m.is_present("flag"));
    assert_eq!(m.value_of("flag").unwrap(), "some");
    assert!(m.is_present("color"));
    assert_eq!(m.value_of("color").unwrap(), "other");
}

#[test]
fn opts_using_mixed() {
    let r = App::new("opts")
        .args(&[
            Arg::from("-f, --flag [flag] 'some flag'"),
            Arg::from("-c, --color [color] 'some other flag'"),
        ])
        .try_get_matches_from(vec!["", "-f", "some", "--color", "other"]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert!(m.is_present("flag"));
    assert_eq!(m.value_of("flag").unwrap(), "some");
    assert!(m.is_present("color"));
    assert_eq!(m.value_of("color").unwrap(), "other");
}

#[test]
fn opts_using_mixed2() {
    let r = App::new("opts")
        .args(&[
            Arg::from("-f, --flag [flag] 'some flag'"),
            Arg::from("-c, --color [color] 'some other flag'"),
        ])
        .try_get_matches_from(vec!["", "--flag=some", "-c", "other"]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert!(m.is_present("flag"));
    assert_eq!(m.value_of("flag").unwrap(), "some");
    assert!(m.is_present("color"));
    assert_eq!(m.value_of("color").unwrap(), "other");
}

#[test]
fn default_values_user_value() {
    let r = App::new("df")
        .arg(Arg::from("-o [opt] 'some opt'").default_value("default"))
        .try_get_matches_from(vec!["", "-o", "value"]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert!(m.is_present("o"));
    assert_eq!(m.value_of("o").unwrap(), "value");
}

#[test]
fn multiple_vals_pos_arg_equals() {
    let r = App::new("mvae")
        .arg(Arg::from("-o [opt]... 'some opt'"))
        .arg(Arg::from("[file] 'some file'"))
        .try_get_matches_from(vec!["", "-o=1", "some"]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert!(m.is_present("o"));
    assert_eq!(m.value_of("o").unwrap(), "1");
    assert!(m.is_present("file"));
    assert_eq!(m.value_of("file").unwrap(), "some");
}

#[test]
fn multiple_vals_pos_arg_delim() {
    let r = App::new("mvae")
        .arg(Arg::from("-o [opt]... 'some opt'").setting(ArgSettings::UseValueDelimiter))
        .arg(Arg::from("[file] 'some file'"))
        .try_get_matches_from(vec!["", "-o", "1,2", "some"]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert!(m.is_present("o"));
    assert_eq!(m.values_of("o").unwrap().collect::<Vec<_>>(), &["1", "2"]);
    assert!(m.is_present("file"));
    assert_eq!(m.value_of("file").unwrap(), "some");
}

#[test]
fn require_delims_no_delim() {
    let r = App::new("mvae")
        .arg(Arg::from("-o [opt]... 'some opt'").setting(ArgSettings::RequireDelimiter))
        .arg(Arg::from("[file] 'some file'"))
        .try_get_matches_from(vec!["mvae", "-o", "1", "2", "some"]);
    assert!(r.is_err());
    let err = r.unwrap_err();
    assert_eq!(err.kind, ErrorKind::UnknownArgument);
}

#[test]
fn require_delims() {
    let r = App::new("mvae")
        .arg(Arg::from("-o [opt]... 'some opt'").setting(ArgSettings::RequireDelimiter))
        .arg(Arg::from("[file] 'some file'"))
        .try_get_matches_from(vec!["", "-o", "1,2", "some"]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert!(m.is_present("o"));
    assert_eq!(m.values_of("o").unwrap().collect::<Vec<_>>(), &["1", "2"]);
    assert!(m.is_present("file"));
    assert_eq!(m.value_of("file").unwrap(), "some");
}

#[test]
fn leading_hyphen_pass() {
    let r = App::new("mvae")
        .arg(Arg::from("-o [opt]... 'some opt'").setting(ArgSettings::AllowHyphenValues))
        .try_get_matches_from(vec!["", "-o", "-2", "3"]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert!(m.is_present("o"));
    assert_eq!(m.values_of("o").unwrap().collect::<Vec<_>>(), &["-2", "3"]);
}

#[test]
fn leading_hyphen_fail() {
    let r = App::new("mvae")
        .arg(Arg::from("-o [opt] 'some opt'"))
        .try_get_matches_from(vec!["", "-o", "-2"]);
    assert!(r.is_err());
    let m = r.unwrap_err();
    assert_eq!(m.kind, ErrorKind::UnknownArgument);
}

#[test]
fn leading_hyphen_with_flag_after() {
    let r = App::new("mvae")
        .arg(Arg::from("-o [opt]... 'some opt'").setting(ArgSettings::AllowHyphenValues))
        .arg("-f 'some flag'")
        .try_get_matches_from(vec!["", "-o", "-2", "-f"]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert!(m.is_present("o"));
    assert_eq!(m.values_of("o").unwrap().collect::<Vec<_>>(), &["-2", "-f"]);
    assert!(!m.is_present("f"));
}

#[test]
fn leading_hyphen_with_flag_before() {
    let r = App::new("mvae")
        .arg(Arg::from("-o [opt]... 'some opt'").setting(ArgSettings::AllowHyphenValues))
        .arg("-f 'some flag'")
        .try_get_matches_from(vec!["", "-f", "-o", "-2"]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert!(m.is_present("o"));
    assert_eq!(m.values_of("o").unwrap().collect::<Vec<_>>(), &["-2"]);
    assert!(m.is_present("f"));
}

#[test]
fn leading_hyphen_with_only_pos_follows() {
    let r = App::new("mvae")
        .arg(
            Arg::from("-o [opt]... 'some opt'")
                .number_of_values(1)
                .setting(ArgSettings::AllowHyphenValues),
        )
        .arg("[arg] 'some arg'")
        .try_get_matches_from(vec!["", "-o", "-2", "--", "val"]);
    assert!(r.is_ok(), "{:?}", r);
    let m = r.unwrap();
    assert!(m.is_present("o"));
    assert_eq!(m.values_of("o").unwrap().collect::<Vec<_>>(), &["-2"]);
    assert_eq!(m.value_of("arg"), Some("val"));
}

#[test]
#[cfg(feature = "suggestions")]
fn did_you_mean() {
    assert!(utils::compare_output(
        utils::complex_app(),
        "clap-test --optio=foo",
        DYM,
        true
    ));
}

#[test]
fn issue_665() {
    let res = App::new("tester")
        .arg("-v, --reroll-count=[N] 'Mark the patch series as PATCH vN'")
        .arg(Arg::from(
"--subject-prefix [Subject-Prefix] 'Use [Subject-Prefix] instead of the standard [PATCH] prefix'") )
        .try_get_matches_from(vec!["test", "--subject-prefix", "-v", "2"]);

    assert!(res.is_err());
    assert_eq!(res.unwrap_err().kind, ErrorKind::EmptyValue);
}

#[test]
fn issue_1047_min_zero_vals_default_val() {
    let m = App::new("foo")
        .arg(
            Arg::new("del")
                .short('d')
                .long("del")
                .setting(ArgSettings::RequireEquals)
                .min_values(0)
                .default_missing_value("default"),
        )
        .get_matches_from(vec!["foo", "-d"]);
    assert_eq!(m.occurrences_of("del"), 1);
    assert_eq!(m.value_of("del"), Some("default"));
}

fn issue_1105_setup(argv: Vec<&'static str>) -> Result<ArgMatches, clap::Error> {
    App::new("opts")
        .arg(Arg::from("-o, --option [opt] 'some option'").setting(ArgSettings::AllowEmptyValues))
        .arg(Arg::from("--flag 'some flag'"))
        .try_get_matches_from(argv)
}

#[test]
fn issue_1105_empty_value_long_fail() {
    let r = issue_1105_setup(vec!["app", "--option", "--flag"]);
    assert!(r.is_err());
    assert_eq!(r.unwrap_err().kind, ErrorKind::EmptyValue);
}

#[test]
fn issue_1105_empty_value_long_explicit() {
    let r = issue_1105_setup(vec!["app", "--option", ""]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert_eq!(m.value_of("option"), Some(""));
}

#[test]
fn issue_1105_empty_value_long_equals() {
    let r = issue_1105_setup(vec!["app", "--option="]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert_eq!(m.value_of("option"), Some(""));
}

#[test]
fn issue_1105_empty_value_short_fail() {
    let r = issue_1105_setup(vec!["app", "-o", "--flag"]);
    assert!(r.is_err());
    assert_eq!(r.unwrap_err().kind, ErrorKind::EmptyValue);
}

#[test]
fn issue_1105_empty_value_short_explicit() {
    let r = issue_1105_setup(vec!["app", "-o", ""]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert_eq!(m.value_of("option"), Some(""));
}

#[test]
fn issue_1105_empty_value_short_equals() {
    let r = issue_1105_setup(vec!["app", "-o="]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert_eq!(m.value_of("option"), Some(""));
}

#[test]
fn issue_1105_empty_value_short_explicit_no_space() {
    let r = issue_1105_setup(vec!["app", "-o", ""]);
    assert!(r.is_ok());
    let m = r.unwrap();
    assert_eq!(m.value_of("option"), Some(""));
}

#[test]
#[cfg(feature = "suggestions")]
fn issue_1073_suboptimal_flag_suggestion() {
    let app = App::new("ripgrep-616")
        .arg(Arg::new("files-with-matches").long("files-with-matches"))
        .arg(Arg::new("files-without-match").long("files-without-match"));
    assert!(utils::compare_output(
        app,
        "ripgrep-616 --files-without-matches",
        DYM_ISSUE_1073,
        true
    ));
}

#[test]
fn short_non_ascii_no_space() {
    let matches = App::new("app")
        .arg("<opt> -磨 <opt>")
        .get_matches_from(&["test", "-磨VALUE"]);

    assert_eq!("VALUE", matches.value_of("opt").unwrap());
}

#[test]
fn short_eq_val_starts_with_eq() {
    let matches = App::new("app")
        .arg("<opt> -f <opt>")
        .get_matches_from(&["test", "-f==value"]);

    assert_eq!("=value", matches.value_of("opt").unwrap());
}

#[test]
fn long_eq_val_starts_with_eq() {
    let matches = App::new("app")
        .arg("<opt> --foo <opt>")
        .get_matches_from(&["test", "--foo==value"]);

    assert_eq!("=value", matches.value_of("opt").unwrap());
}

#[test]
fn issue_2022_get_flags_misuse() {
    let app = App::new("test")
        .help_heading("test")
        .arg(Arg::new("a").long("a").default_value("32"));
    let matches = app.get_matches_from(&[""]);
    assert!(matches.value_of("a").is_some())
}

#[test]
fn issue_2279() {
    let before_help_heading = App::new("app")
        .arg(Arg::new("foo").short('f').default_value("bar"))
        .help_heading("This causes default_value to be ignored")
        .get_matches_from(&[""]);

    assert_eq!(before_help_heading.value_of("foo"), Some("bar"));

    let after_help_heading = App::new("app")
        .help_heading("This causes default_value to be ignored")
        .arg(Arg::new("foo").short('f').default_value("bar"))
        .get_matches_from(&[""]);

    assert_eq!(after_help_heading.value_of("foo"), Some("bar"));
}

1	mod utils;
2
3	use clap::{App, Arg, ArgMatches, ArgSettings, ErrorKind};
4
5	#[cfg(feature = "suggestions")]
6	static DYM: &str =
7	"error: Found argument '--optio' which wasn't expected, or isn't valid in this context
8
9	\tDid you mean '--option'?
10
11	\tIf you tried to supply `--optio` as a value rather than a flag, use `-- --optio`
12
13	USAGE:
14	clap-test --option <opt>...
15
16	For more information try --help";
17
18	#[cfg(feature = "suggestions")]
19	static DYM_ISSUE_1073: &str =
20	"error: Found argument '--files-without-matches' which wasn't expected, or isn't valid in this context
21
22	\tDid you mean '--files-without-match'?
23
24	\tIf you tried to supply `--files-without-matches` as a value rather than a flag, use `-- --files-without-matches`
25
26	USAGE:
27	ripgrep-616 --files-without-match
28
29	For more information try --help";
30
31	#[test]
32	fn require_equals_fail() {	3✔
33	let res = App::new("prog")
34	.arg(
35	Arg::new("cfg")	1✔
36	.setting(ArgSettings::RequireEquals)
37	.setting(ArgSettings::TakesValue)
38	.long("config"),
39	)
40	.try_get_matches_from(vec!["prog", "--config", "file.conf"]);	1✔
41	assert!(res.is_err());	1✔
42	assert_eq!(res.unwrap_err().kind, ErrorKind::NoEquals);	1✔
43	}
44
45	#[test]
46	fn require_equals_fail_message() {	3✔
47	static NO_EQUALS: &str = "error: Equal sign is needed when assigning values to '--config=<cfg>'.
48
49	USAGE:
50	prog [OPTIONS]
51
52	For more information try --help";
53	let app = App::new("prog").arg(
54	Arg::new("cfg")	1✔
55	.setting(ArgSettings::RequireEquals)
56	.setting(ArgSettings::TakesValue)
57	.long("config"),
58	);
59	assert!(utils::compare_output(	1✔
60	app,	1✔
61	"prog --config file.conf",
62	NO_EQUALS,
63	true
64	));
65	}
66
67	#[test]
68	fn require_equals_min_values_zero() {	3✔
69	let res = App::new("prog")
70	.arg(
71	Arg::new("cfg")	1✔
72	.setting(ArgSettings::RequireEquals)
73	.min_values(0)
74	.long("config"),
75	)
76	.arg(Arg::new("cmd"))	1✔
77	.try_get_matches_from(vec!["prog", "--config", "cmd"]);	1✔
78	assert!(res.is_ok());	1✔
79	let m = res.unwrap();	1✔
80	assert!(m.is_present("cfg"));	1✔
81	assert_eq!(m.value_of("cmd"), Some("cmd"));	1✔
82	}
83
84	#[test]
85	fn double_hyphen_as_value() {	3✔
86	let res = App::new("prog")
87	.arg(
88	Arg::new("cfg")	1✔
89	.setting(ArgSettings::AllowHyphenValues)
90	.long("config"),
91	)
92	.try_get_matches_from(vec!["prog", "--config", "--"]);	1✔
93	assert!(res.is_ok(), "{:?}", res);	1✔
94	assert_eq!(res.unwrap().value_of("cfg"), Some("--"));	1✔
95	}
96
97	#[test]
98	fn require_equals_no_empty_values_fail() {	3✔
99	let res = App::new("prog")
100	.arg(
101	Arg::new("cfg")	1✔
102	.setting(ArgSettings::RequireEquals)
103	.long("config"),
104	)
105	.arg(Arg::new("some"))	1✔
106	.try_get_matches_from(vec!["prog", "--config=", "file.conf"]);	1✔
107	assert!(res.is_err());	1✔
108	assert_eq!(res.unwrap_err().kind, ErrorKind::EmptyValue);	1✔
109	}
110
111	#[test]
112	fn require_equals_empty_vals_pass() {	3✔
113	let res = App::new("prog")
114	.arg(
115	Arg::new("cfg")	1✔
116	.setting(ArgSettings::RequireEquals)
117	.setting(ArgSettings::AllowEmptyValues)
118	.long("config"),
119	)
120	.try_get_matches_from(vec!["prog", "--config="]);	1✔
121	assert!(res.is_ok());	1✔
122	}
123
124	#[test]
125	fn require_equals_pass() {	3✔
126	let res = App::new("prog")
127	.arg(
128	Arg::new("cfg")	1✔
129	.setting(ArgSettings::RequireEquals)
130	.long("config"),
131	)
132	.try_get_matches_from(vec!["prog", "--config=file.conf"]);	1✔
133	assert!(res.is_ok());	1✔
134	}
135
136	#[test]
137	fn stdin_char() {	3✔
138	let r = App::new("opts")
139	.arg(Arg::from("-f [flag] 'some flag'"))	1✔
140	.try_get_matches_from(vec!["", "-f", "-"]);	1✔
141	assert!(r.is_ok());	1✔
142	let m = r.unwrap();	1✔
143	assert!(m.is_present("f"));	1✔
144	assert_eq!(m.value_of("f").unwrap(), "-");	1✔
145	}
146
147	#[test]
148	fn opts_using_short() {	3✔
149	let r = App::new("opts")
150	.args(&[	1✔
151	Arg::from("-f [flag] 'some flag'"),	1✔
152	Arg::from("-c [color] 'some other flag'"),	1✔
153	])
154	.try_get_matches_from(vec!["", "-f", "some", "-c", "other"]);	2✔
155	assert!(r.is_ok());	1✔
156	let m = r.unwrap();	1✔
157	assert!(m.is_present("f"));	1✔
158	assert_eq!(m.value_of("f").unwrap(), "some");	1✔
159	assert!(m.is_present("c"));	1✔
160	assert_eq!(m.value_of("c").unwrap(), "other");	1✔
161	}
162
163	#[test]
164	fn lots_o_vals() {	3✔
165	let r = App::new("opts")
166	.arg(Arg::from("-o [opt]... 'some opt'"))	1✔
167	.try_get_matches_from(vec![	1✔
168	"", "-o", "some", "some", "some", "some", "some", "some", "some", "some", "some",
169	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
170	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
171	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
172	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
173	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
174	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
175	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
176	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
177	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
178	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
179	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
180	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
181	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
182	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
183	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
184	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
185	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
186	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
187	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
188	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
189	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
190	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
191	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
192	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
193	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
194	"some", "some", "some", "some", "some", "some", "some", "some", "some", "some", "some",
195	"some", "some",
196	]);
197	assert!(r.is_ok());	1✔
198	let m = r.unwrap();	1✔
199	assert!(m.is_present("o"));	1✔
200	assert_eq!(m.values_of("o").unwrap().count(), 297); // i.e. more than u8	1✔
201	}
202
203	#[test]
204	fn opts_using_long_space() {	3✔
205	let r = App::new("opts")
206	.args(&[	1✔
207	Arg::from("--flag [flag] 'some flag'"),	1✔
208	Arg::from("--color [color] 'some other flag'"),	1✔
209	])
210	.try_get_matches_from(vec!["", "--flag", "some", "--color", "other"]);	2✔
211	assert!(r.is_ok());	1✔
212	let m = r.unwrap();	1✔
213	assert!(m.is_present("flag"));	1✔
214	assert_eq!(m.value_of("flag").unwrap(), "some");	1✔
215	assert!(m.is_present("color"));	1✔
216	assert_eq!(m.value_of("color").unwrap(), "other");	1✔
217	}
218
219	#[test]
220	fn opts_using_long_equals() {	3✔
221	let r = App::new("opts")
222	.args(&[	1✔
223	Arg::from("--flag [flag] 'some flag'"),	1✔
224	Arg::from("--color [color] 'some other flag'"),	1✔
225	])
226	.try_get_matches_from(vec!["", "--flag=some", "--color=other"]);	2✔
227	assert!(r.is_ok());	1✔
228	let m = r.unwrap();	1✔
229	assert!(m.is_present("flag"));	1✔
230	assert_eq!(m.value_of("flag").unwrap(), "some");	1✔
231	assert!(m.is_present("color"));	1✔
232	assert_eq!(m.value_of("color").unwrap(), "other");	1✔
233	}
234
235	#[test]
236	fn opts_using_mixed() {	3✔
237	let r = App::new("opts")
238	.args(&[	1✔
239	Arg::from("-f, --flag [flag] 'some flag'"),	1✔
240	Arg::from("-c, --color [color] 'some other flag'"),	1✔
241	])
242	.try_get_matches_from(vec!["", "-f", "some", "--color", "other"]);	2✔
243	assert!(r.is_ok());	1✔
244	let m = r.unwrap();	1✔
245	assert!(m.is_present("flag"));	1✔
246	assert_eq!(m.value_of("flag").unwrap(), "some");	1✔
247	assert!(m.is_present("color"));	1✔
248	assert_eq!(m.value_of("color").unwrap(), "other");	1✔
249	}
250
251	#[test]
252	fn opts_using_mixed2() {	3✔
253	let r = App::new("opts")
254	.args(&[	1✔
255	Arg::from("-f, --flag [flag] 'some flag'"),	1✔
256	Arg::from("-c, --color [color] 'some other flag'"),	1✔
257	])
258	.try_get_matches_from(vec!["", "--flag=some", "-c", "other"]);	2✔
259	assert!(r.is_ok());	1✔
260	let m = r.unwrap();	1✔
261	assert!(m.is_present("flag"));	1✔
262	assert_eq!(m.value_of("flag").unwrap(), "some");	1✔
263	assert!(m.is_present("color"));	1✔
264	assert_eq!(m.value_of("color").unwrap(), "other");	1✔
265	}
266
267	#[test]
268	fn default_values_user_value() {	3✔
269	let r = App::new("df")
270	.arg(Arg::from("-o [opt] 'some opt'").default_value("default"))	1✔
271	.try_get_matches_from(vec!["", "-o", "value"]);	1✔
272	assert!(r.is_ok());	1✔
273	let m = r.unwrap();	1✔
274	assert!(m.is_present("o"));	1✔
275	assert_eq!(m.value_of("o").unwrap(), "value");	1✔
276	}
277
278	#[test]
279	fn multiple_vals_pos_arg_equals() {	3✔
280	let r = App::new("mvae")
281	.arg(Arg::from("-o [opt]... 'some opt'"))	1✔
282	.arg(Arg::from("[file] 'some file'"))	1✔
283	.try_get_matches_from(vec!["", "-o=1", "some"]);	1✔
284	assert!(r.is_ok());	1✔
285	let m = r.unwrap();	1✔
286	assert!(m.is_present("o"));	1✔
287	assert_eq!(m.value_of("o").unwrap(), "1");	1✔
288	assert!(m.is_present("file"));	1✔
289	assert_eq!(m.value_of("file").unwrap(), "some");	1✔
290	}
291
292	#[test]
293	fn multiple_vals_pos_arg_delim() {	3✔
294	let r = App::new("mvae")
295	.arg(Arg::from("-o [opt]... 'some opt'").setting(ArgSettings::UseValueDelimiter))	1✔
296	.arg(Arg::from("[file] 'some file'"))	1✔
297	.try_get_matches_from(vec!["", "-o", "1,2", "some"]);	1✔
298	assert!(r.is_ok());	1✔
299	let m = r.unwrap();	1✔
300	assert!(m.is_present("o"));	1✔
301	assert_eq!(m.values_of("o").unwrap().collect::<Vec<_>>(), &["1", "2"]);	1✔
302	assert!(m.is_present("file"));	1✔
303	assert_eq!(m.value_of("file").unwrap(), "some");	1✔
304	}
305
306	#[test]
307	fn require_delims_no_delim() {	3✔
308	let r = App::new("mvae")
309	.arg(Arg::from("-o [opt]... 'some opt'").setting(ArgSettings::RequireDelimiter))	1✔
310	.arg(Arg::from("[file] 'some file'"))	1✔
311	.try_get_matches_from(vec!["mvae", "-o", "1", "2", "some"]);	1✔
312	assert!(r.is_err());	1✔
313	let err = r.unwrap_err();	1✔
314	assert_eq!(err.kind, ErrorKind::UnknownArgument);	1✔
315	}
316
317	#[test]
318	fn require_delims() {	3✔
319	let r = App::new("mvae")
320	.arg(Arg::from("-o [opt]... 'some opt'").setting(ArgSettings::RequireDelimiter))	1✔
321	.arg(Arg::from("[file] 'some file'"))	1✔
322	.try_get_matches_from(vec!["", "-o", "1,2", "some"]);	1✔
323	assert!(r.is_ok());	1✔
324	let m = r.unwrap();	1✔
325	assert!(m.is_present("o"));	1✔
326	assert_eq!(m.values_of("o").unwrap().collect::<Vec<_>>(), &["1", "2"]);	1✔
327	assert!(m.is_present("file"));	1✔
328	assert_eq!(m.value_of("file").unwrap(), "some");	1✔
329	}
330
331	#[test]
332	fn leading_hyphen_pass() {	3✔
333	let r = App::new("mvae")
334	.arg(Arg::from("-o [opt]... 'some opt'").setting(ArgSettings::AllowHyphenValues))	1✔
335	.try_get_matches_from(vec!["", "-o", "-2", "3"]);	1✔
336	assert!(r.is_ok());	1✔
337	let m = r.unwrap();	1✔
338	assert!(m.is_present("o"));	1✔
339	assert_eq!(m.values_of("o").unwrap().collect::<Vec<_>>(), &["-2", "3"]);	1✔
340	}
341
342	#[test]
343	fn leading_hyphen_fail() {	3✔
344	let r = App::new("mvae")
345	.arg(Arg::from("-o [opt] 'some opt'"))	1✔
346	.try_get_matches_from(vec!["", "-o", "-2"]);	1✔
347	assert!(r.is_err());	1✔
348	let m = r.unwrap_err();	1✔
349	assert_eq!(m.kind, ErrorKind::UnknownArgument);	1✔
350	}
351
352	#[test]
353	fn leading_hyphen_with_flag_after() {	3✔
354	let r = App::new("mvae")
355	.arg(Arg::from("-o [opt]... 'some opt'").setting(ArgSettings::AllowHyphenValues))	1✔
356	.arg("-f 'some flag'")
357	.try_get_matches_from(vec!["", "-o", "-2", "-f"]);	1✔
358	assert!(r.is_ok());	1✔
359	let m = r.unwrap();	1✔
360	assert!(m.is_present("o"));	1✔
361	assert_eq!(m.values_of("o").unwrap().collect::<Vec<_>>(), &["-2", "-f"]);	1✔
362	assert!(!m.is_present("f"));	1✔
363	}
364
365	#[test]
366	fn leading_hyphen_with_flag_before() {	3✔
367	let r = App::new("mvae")
368	.arg(Arg::from("-o [opt]... 'some opt'").setting(ArgSettings::AllowHyphenValues))	1✔
369	.arg("-f 'some flag'")
370	.try_get_matches_from(vec!["", "-f", "-o", "-2"]);	1✔
371	assert!(r.is_ok());	1✔
372	let m = r.unwrap();	1✔
373	assert!(m.is_present("o"));	1✔
374	assert_eq!(m.values_of("o").unwrap().collect::<Vec<_>>(), &["-2"]);	1✔
375	assert!(m.is_present("f"));	1✔
376	}
377
378	#[test]
379	fn leading_hyphen_with_only_pos_follows() {	3✔
380	let r = App::new("mvae")
381	.arg(
382	Arg::from("-o [opt]... 'some opt'")	1✔
383	.number_of_values(1)
384	.setting(ArgSettings::AllowHyphenValues),
385	)
386	.arg("[arg] 'some arg'")
387	.try_get_matches_from(vec!["", "-o", "-2", "--", "val"]);	1✔
388	assert!(r.is_ok(), "{:?}", r);	1✔
389	let m = r.unwrap();	1✔
390	assert!(m.is_present("o"));	1✔
391	assert_eq!(m.values_of("o").unwrap().collect::<Vec<_>>(), &["-2"]);	1✔
392	assert_eq!(m.value_of("arg"), Some("val"));	1✔
393	}
394
395	#[test]
396	#[cfg(feature = "suggestions")]
397	fn did_you_mean() {	3✔
398	assert!(utils::compare_output(	1✔
399	utils::complex_app(),	1✔
400	"clap-test --optio=foo",
401	DYM,
402	true
403	));
404	}
405
406	#[test]
407	fn issue_665() {	3✔
408	let res = App::new("tester")
409	.arg("-v, --reroll-count=[N] 'Mark the patch series as PATCH vN'")
410	.arg(Arg::from(	1✔
411	"--subject-prefix [Subject-Prefix] 'Use [Subject-Prefix] instead of the standard [PATCH] prefix'") )	×
412	.try_get_matches_from(vec!["test", "--subject-prefix", "-v", "2"]);	1✔
413
414	assert!(res.is_err());	1✔
415	assert_eq!(res.unwrap_err().kind, ErrorKind::EmptyValue);	1✔
416	}
417
418	#[test]
419	fn issue_1047_min_zero_vals_default_val() {	3✔
420	let m = App::new("foo")
421	.arg(
422	Arg::new("del")	1✔
423	.short('d')
424	.long("del")
425	.setting(ArgSettings::RequireEquals)
426	.min_values(0)
427	.default_missing_value("default"),
428	)
429	.get_matches_from(vec!["foo", "-d"]);	1✔
430	assert_eq!(m.occurrences_of("del"), 1);	1✔
431	assert_eq!(m.value_of("del"), Some("default"));	1✔
432	}
433
434	fn issue_1105_setup(argv: Vec<&'static str>) -> Result<ArgMatches, clap::Error> {	1✔
435	App::new("opts")
436	.arg(Arg::from("-o, --option [opt] 'some option'").setting(ArgSettings::AllowEmptyValues))	2✔
437	.arg(Arg::from("--flag 'some flag'"))	2✔
438	.try_get_matches_from(argv)	2✔
439	}
440
441	#[test]
442	fn issue_1105_empty_value_long_fail() {	3✔
443	let r = issue_1105_setup(vec!["app", "--option", "--flag"]);	1✔
444	assert!(r.is_err());	1✔
445	assert_eq!(r.unwrap_err().kind, ErrorKind::EmptyValue);	1✔
446	}
447
448	#[test]
449	fn issue_1105_empty_value_long_explicit() {	3✔
450	let r = issue_1105_setup(vec!["app", "--option", ""]);	1✔
451	assert!(r.is_ok());	1✔
452	let m = r.unwrap();	1✔
453	assert_eq!(m.value_of("option"), Some(""));	1✔
454	}
455
456	#[test]
457	fn issue_1105_empty_value_long_equals() {	3✔
458	let r = issue_1105_setup(vec!["app", "--option="]);	1✔
459	assert!(r.is_ok());	1✔
460	let m = r.unwrap();	1✔
461	assert_eq!(m.value_of("option"), Some(""));	1✔
462	}
463
464	#[test]
465	fn issue_1105_empty_value_short_fail() {	3✔
466	let r = issue_1105_setup(vec!["app", "-o", "--flag"]);	1✔
467	assert!(r.is_err());	1✔
468	assert_eq!(r.unwrap_err().kind, ErrorKind::EmptyValue);	1✔
469	}
470
471	#[test]
472	fn issue_1105_empty_value_short_explicit() {	3✔
473	let r = issue_1105_setup(vec!["app", "-o", ""]);	1✔
474	assert!(r.is_ok());	1✔
475	let m = r.unwrap();	1✔
476	assert_eq!(m.value_of("option"), Some(""));	1✔
477	}
478
479	#[test]
480	fn issue_1105_empty_value_short_equals() {	3✔
481	let r = issue_1105_setup(vec!["app", "-o="]);	1✔
482	assert!(r.is_ok());	1✔
483	let m = r.unwrap();	1✔
484	assert_eq!(m.value_of("option"), Some(""));	1✔
485	}
486
487	#[test]
488	fn issue_1105_empty_value_short_explicit_no_space() {	3✔
489	let r = issue_1105_setup(vec!["app", "-o", ""]);	1✔
490	assert!(r.is_ok());	1✔
491	let m = r.unwrap();	1✔
492	assert_eq!(m.value_of("option"), Some(""));	1✔
493	}
494
495	#[test]
496	#[cfg(feature = "suggestions")]
497	fn issue_1073_suboptimal_flag_suggestion() {	3✔
498	let app = App::new("ripgrep-616")
499	.arg(Arg::new("files-with-matches").long("files-with-matches"))	1✔
500	.arg(Arg::new("files-without-match").long("files-without-match"));	1✔
501	assert!(utils::compare_output(	1✔
502	app,	1✔
503	"ripgrep-616 --files-without-matches",
504	DYM_ISSUE_1073,
505	true
506	));
507	}
508
509	#[test]
510	fn short_non_ascii_no_space() {	3✔
511	let matches = App::new("app")
512	.arg("<opt> -磨 <opt>")
513	.get_matches_from(&["test", "-磨VALUE"]);
514
515	assert_eq!("VALUE", matches.value_of("opt").unwrap());	1✔
516	}
517
518	#[test]
519	fn short_eq_val_starts_with_eq() {	3✔
520	let matches = App::new("app")
521	.arg("<opt> -f <opt>")
522	.get_matches_from(&["test", "-f==value"]);
523
524	assert_eq!("=value", matches.value_of("opt").unwrap());	1✔
525	}
526
527	#[test]
528	fn long_eq_val_starts_with_eq() {	3✔
529	let matches = App::new("app")
530	.arg("<opt> --foo <opt>")
531	.get_matches_from(&["test", "--foo==value"]);
532
533	assert_eq!("=value", matches.value_of("opt").unwrap());	1✔
534	}
535
536	#[test]
537	fn issue_2022_get_flags_misuse() {	3✔
538	let app = App::new("test")
539	.help_heading("test")
540	.arg(Arg::new("a").long("a").default_value("32"));	1✔
541	let matches = app.get_matches_from(&[""]);	1✔
542	assert!(matches.value_of("a").is_some())	1✔
543	}
544
545	#[test]
546	fn issue_2279() {	3✔
547	let before_help_heading = App::new("app")
548	.arg(Arg::new("foo").short('f').default_value("bar"))	1✔
549	.help_heading("This causes default_value to be ignored")
550	.get_matches_from(&[""]);
551
552	assert_eq!(before_help_heading.value_of("foo"), Some("bar"));	1✔
553
554	let after_help_heading = App::new("app")
555	.help_heading("This causes default_value to be ignored")
556	.arg(Arg::new("foo").short('f').default_value("bar"))	1✔
557	.get_matches_from(&[""]);
558
559	assert_eq!(after_help_heading.value_of("foo"), Some("bar"));	1✔
560	}

clap-rs / clap / 636467251

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous