Mirrors/clap
2
0
Fork 0
mirror of https://github.com/clap-rs/clap synced 2024-11-10 06:44:16 +00:00
Code Issues Projects Releases Packages Wiki Activity

style: Make clippy happy

Browse source
This commit is contained in:
Ed Page 2022-11-24 07:54:25 -06:00
parent f5dcfc5bd9
commit 623ccbc152
59 changed files with 529 additions and 563 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
clap_complete/src/shells/elvish.rs
View file

@ -20,8 +20,7 @@ impl Generator for Elvish {
.get_bin_name()
.expect("crate::generate should have set the bin_name");
let mut names = vec![];
let subcommands_cases = generate_inner(cmd, "", &mut names);
let subcommands_cases = generate_inner(cmd, "");
let result = format!(
r#"
@ -67,11 +66,7 @@ fn get_tooltip<T: ToString>(help: Option<&StyledStr>, data: T) -> String {
}
}
fn generate_inner<'help>(
p: &Command,
previous_command_name: &str,
names: &mut Vec<&'help str>,
) -> String {
fn generate_inner(p: &Command, previous_command_name: &str) -> String {
debug!("generate_inner");
let command_name = if previous_command_name.is_empty() {
@ -135,7 +130,7 @@ fn generate_inner<'help>(
);
for subcommand in p.get_subcommands() {
let subcommand_subcommands_cases = generate_inner(subcommand, &command_name, names);
let subcommand_subcommands_cases = generate_inner(subcommand, &command_name);
subcommands_cases.push_str(&subcommand_subcommands_cases);
}

11
clap_complete/src/shells/powershell.rs
View file

@ -20,8 +20,7 @@ impl Generator for PowerShell {
.get_bin_name()
.expect("crate::generate should have set the bin_name");
let mut names = vec![];
let subcommands_cases = generate_inner(cmd, "", &mut names);
let subcommands_cases = generate_inner(cmd, "");
let result = format!(
r#"
@ -72,11 +71,7 @@ fn get_tooltip<T: ToString>(help: Option<&StyledStr>, data: T) -> String {
}
}
fn generate_inner<'help>(
p: &Command,
previous_command_name: &str,
names: &mut Vec<&'help str>,
) -> String {
fn generate_inner(p: &Command, previous_command_name: &str) -> String {
debug!("generate_inner");
let command_name = if previous_command_name.is_empty() {
@ -171,7 +166,7 @@ fn generate_inner<'help>(
);
for subcommand in p.get_subcommands() {
let subcommand_subcommands_cases = generate_inner(subcommand, &command_name, names);
let subcommand_subcommands_cases = generate_inner(subcommand, &command_name);
subcommands_cases.push_str(&subcommand_subcommands_cases);
}

2
clap_complete/src/shells/zsh.rs
View file

@ -646,7 +646,7 @@ fn write_positionals_of(p: &Command) -> String {
.replace(']', "\\]")
.replace('\'', "'\\''")
.replace(':', "\\:"),
value_completion = value_completion(arg).unwrap_or_else(|| "".to_string())
value_completion = value_completion(arg).unwrap_or_default()
);
debug!("write_positionals_of:iter: Wrote...{}", a);

18
clap_complete_fig/src/fig.rs
View file

@ -32,7 +32,7 @@ impl Generator for Fig {
)
.unwrap();
gen_fig_inner(command, &[], 2, cmd, &mut buffer);
gen_fig_inner(&[], 2, cmd, &mut buffer);
write!(&mut buffer, "}};\n\nexport default completion;\n").unwrap();
@ -51,13 +51,7 @@ fn escape_string(string: &str) -> String {
.replace('\r', "")
}
fn gen_fig_inner(
root_command: &str,
parent_commands: &[&str],
indent: usize,
cmd: &Command,
buffer: &mut String,
) {
fn gen_fig_inner(parent_commands: &[&str], indent: usize, cmd: &Command, buffer: &mut String) {
if cmd.has_subcommands() {
write!(buffer, "{:indent$}subcommands: [\n", "", indent = indent).unwrap();
// generate subcommands
@ -113,13 +107,7 @@ fn gen_fig_inner(
let mut parent_commands: Vec<_> = parent_commands.into();
parent_commands.push(subcommand.get_name());
gen_fig_inner(
root_command,
&parent_commands,
indent + 4,
subcommand,
buffer,
);
gen_fig_inner(&parent_commands, indent + 4, subcommand, buffer);
write!(buffer, "{:indent$}}},\n", "", indent = indent + 2).unwrap();
}

2
clap_lex/tests/lexer.rs
View file

@ -5,7 +5,7 @@ fn insert() {
assert_eq!(raw.next_os(&mut cursor), Some(std::ffi::OsStr::new("bin")));
assert_eq!(raw.next_os(&mut cursor), Some(std::ffi::OsStr::new("a")));
raw.insert(&cursor, &["1", "2", "3"]);
raw.insert(&cursor, ["1", "2", "3"]);
assert_eq!(raw.next_os(&mut cursor), Some(std::ffi::OsStr::new("1")));
assert_eq!(raw.next_os(&mut cursor), Some(std::ffi::OsStr::new("2")));
assert_eq!(raw.next_os(&mut cursor), Some(std::ffi::OsStr::new("3")));

2
clap_mangen/src/render.rs
View file

@ -300,7 +300,7 @@ fn option_environment(opt: &clap::Arg) -> Option<Vec<Inline>> {
} else if let Some(env) = opt.get_env() {
return Some(vec![
roman("May also be specified with the "),
bold(env.to_string_lossy().to_owned()),
bold(env.to_string_lossy().into_owned()),
roman(" environment variable. "),
]);
}

2
src/builder/command.rs
View file

@ -675,7 +675,7 @@ impl Command {
);
debug!("Command::try_get_matches_from_mut: Reinserting command into arguments so subcommand parser matches it");
raw_args.insert(&cursor, &[&command]);
raw_args.insert(&cursor, [&command]);
debug!("Command::try_get_matches_from_mut: Clearing name and bin_name so that displayed command name starts with applet name");
self.name = "".into();
self.bin_name = None;

2
src/builder/os_str.rs
View file

@ -116,7 +116,7 @@ impl From<&'static std::ffi::OsStr> for OsStr {
impl From<&'_ &'static std::ffi::OsStr> for OsStr {
fn from(name: &'_ &'static std::ffi::OsStr) -> Self {
Self::from_static_ref(*name)
Self::from_static_ref(name)
}
}

2
src/builder/str.rs
View file

@ -66,7 +66,7 @@ impl From<&'static str> for Str {
impl From<&'_ &'static str> for Str {
fn from(name: &'_ &'static str) -> Self {
Self::from_static_ref(*name)
Self::from_static_ref(name)
}
}

2
src/output/help.rs
View file

@ -18,7 +18,7 @@ pub(crate) fn write_help(writer: &mut StyledStr, cmd: &Command, usage: &Usage<'_
use super::HelpTemplate;
if let Some(tmpl) = cmd.get_help_template() {
for (style, content) in tmpl.iter() {
if style == None {
if style.is_none() {
HelpTemplate::new(writer, cmd, usage, use_long)
.write_templated_help(content);
} else {

4
src/output/help_template.rs
View file

@ -427,7 +427,7 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
// If it's NextLineHelp we don't care to compute how long it is because it may be
// NextLineHelp on purpose simply *because* it's so long and would throw off all other
// args alignment
should_show_arg(self.use_long, *arg)
should_show_arg(self.use_long, arg)
}) {
if longest_filter(arg) {
longest = longest.max(display_width(&arg.to_string()));
@ -674,7 +674,7 @@ impl<'cmd, 'writer> HelpTemplate<'cmd, 'writer> {
/// Will use next line help on writing args.
fn will_args_wrap(&self, args: &[&Arg], longest: usize) -> bool {
args.iter()
.filter(|arg| should_show_arg(self.use_long, *arg))
.filter(|arg| should_show_arg(self.use_long, arg))
.any(|arg| {
let spec_vals = &self.spec_vals(arg);
self.arg_next_line_help(arg, spec_vals, longest)

2
src/parser/parser.rs
View file

@ -1573,7 +1573,7 @@ impl<'cmd> Parser<'cmd> {
suggested_trailing_arg,
Usage::new(self.cmd)
.required(&required)
.create_usage_with_title(&*used),
.create_usage_with_title(&used),
)
}

30
tests/builder/app_settings.rs
View file

@ -315,7 +315,7 @@ Options:
.about("tests stuff")
.version("1.3")
.hide_possible_values(true)
.args(&[
.args([
arg!(-o --opt <opt> "some option").value_parser(["one", "two"]),
arg!([arg1] "some pos arg").value_parser(["three", "four"]),
]);
@ -327,7 +327,7 @@ Options:
fn stop_delim_values_only_pos_follows() {
let r = Command::new("onlypos")
.dont_delimit_trailing_values(true)
.args(&[arg!(f: -f <flag> "some opt"), arg!([arg] ... "some arg")])
.args([arg!(f: -f <flag> "some opt"), arg!([arg] ... "some arg")])
.try_get_matches_from(vec!["", "--", "-f", "-g,x"]);
assert!(r.is_ok(), "{}", r.unwrap_err());
let m = r.unwrap();
@ -338,7 +338,7 @@ fn stop_delim_values_only_pos_follows() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["-f", "-g,x"]
["-f", "-g,x"]
);
}
@ -355,14 +355,14 @@ fn dont_delim_values_trailingvararg() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["test", "--foo", "-Wl,-bar"]
["test", "--foo", "-Wl,-bar"]
);
}
#[test]
fn delim_values_only_pos_follows() {
let r = Command::new("onlypos")
.args(&[arg!(f: -f [flag] "some opt"), arg!([arg] ... "some arg")])
.args([arg!(f: -f [flag] "some opt"), arg!([arg] ... "some arg")])
.try_get_matches_from(vec!["", "--", "-f", "-g,x"]);
assert!(r.is_ok(), "{}", r.unwrap_err());
let m = r.unwrap();
@ -373,7 +373,7 @@ fn delim_values_only_pos_follows() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["-f", "-g,x"]
["-f", "-g,x"]
);
}
@ -389,14 +389,14 @@ fn delim_values_trailingvararg() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["test", "--foo", "-Wl,-bar"]
["test", "--foo", "-Wl,-bar"]
);
}
#[test]
fn delim_values_only_pos_follows_with_delim() {
let r = Command::new("onlypos")
.args(&[
.args([
arg!(f: -f [flag] "some opt"),
arg!([arg] ... "some arg").value_delimiter(','),
])
@ -410,7 +410,7 @@ fn delim_values_only_pos_follows_with_delim() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["-f", "-g", "x"]
["-f", "-g", "x"]
);
}
@ -430,7 +430,7 @@ fn delim_values_trailingvararg_with_delim() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["test", "--foo", "-Wl", "-bar"]
["test", "--foo", "-Wl", "-bar"]
);
}
@ -623,7 +623,7 @@ fn disable_help_subcommand() {
#[test]
fn dont_collapse_args() {
let cmd = Command::new("clap-test").version("v1.4.8").args(&[
let cmd = Command::new("clap-test").version("v1.4.8").args([
Arg::new("arg1").help("some"),
Arg::new("arg2").help("some"),
Arg::new("arg3").help("some"),
@ -1170,7 +1170,7 @@ fn aaos_opts_mult_req_delims() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["some", "other", "one", "two"]
["some", "other", "one", "two"]
);
}
@ -1201,7 +1201,7 @@ fn aaos_opts_mult() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["first", "overrides", "some", "other", "val"]
["first", "overrides", "some", "other", "val"]
);
}
@ -1219,7 +1219,7 @@ fn aaos_pos_mult() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["some", "other", "value"]
["some", "other", "value"]
);
}
@ -1240,7 +1240,7 @@ fn aaos_option_use_delim_false() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["one,two"]
["one,two"]
);
}

6
tests/builder/arg_aliases.rs
View file

@ -99,15 +99,15 @@ fn get_aliases() {
assert!(a.get_short_and_visible_aliases().is_none());
assert_eq!(
a.get_long_and_visible_aliases().unwrap(),
&["aliases", "alias4", "alias5", "alias6"]
["aliases", "alias4", "alias5", "alias6"]
);
assert_eq!(
a.get_visible_aliases().unwrap(),
&["alias4", "alias5", "alias6"]
["alias4", "alias5", "alias6"]
);
assert_eq!(
a.get_all_aliases().unwrap(),
&["alias1", "alias2", "alias3", "alias4", "alias5", "alias6"]
["alias1", "alias2", "alias3", "alias4", "alias5", "alias6"]
);
assert_eq!(a.get_visible_short_aliases().unwrap(), vec!['d', 'e', 'f']);
assert_eq!(

6
tests/builder/arg_matches.rs
View file

@ -51,7 +51,7 @@ fn ids_ignore_overridden() {
fn arg_matches_if_present_wrong_arg() {
let m = Command::new("test")
.arg(Arg::new("flag").short('f').action(ArgAction::SetTrue))
.try_get_matches_from(&["test", "-f"])
.try_get_matches_from(["test", "-f"])
.unwrap();
assert!(*m.get_one::<bool>("flag").expect("defaulted by clap"));
@ -64,7 +64,7 @@ fn arg_matches_if_present_wrong_arg() {
fn arg_matches_value_of_wrong_arg() {
let m = Command::new("test")
.arg(Arg::new("opt").short('o').action(ArgAction::Set))
.try_get_matches_from(&["test", "-o", "val"])
.try_get_matches_from(["test", "-o", "val"])
.unwrap();
assert_eq!(m.get_one::<String>("opt").map(|v| v.as_str()), Some("val"));
@ -77,7 +77,7 @@ fn arg_matches_value_of_wrong_arg() {
fn arg_matches_subcommand_matches_wrong_sub() {
let m = Command::new("test")
.subcommand(Command::new("speed"))
.try_get_matches_from(&["test", "speed"])
.try_get_matches_from(["test", "speed"])
.unwrap();
assert!(m.subcommand_matches("speed").is_some());

8
tests/builder/default_missing_vals.rs
View file

@ -176,7 +176,7 @@ fn default_missing_value_flag_value() {
.default_missing_value("true"),
);
let m = cmd.clone().try_get_matches_from(&["test"]).unwrap();
let m = cmd.clone().try_get_matches_from(["test"]).unwrap();
assert!(m.contains_id("flag"));
assert_eq!(
m.get_one::<String>("flag").map(|v| v.as_str()),
@ -189,7 +189,7 @@ fn default_missing_value_flag_value() {
let m = cmd
.clone()
.try_get_matches_from(&["test", "--flag"])
.try_get_matches_from(["test", "--flag"])
.unwrap();
assert!(m.contains_id("flag"));
assert_eq!(
@ -203,7 +203,7 @@ fn default_missing_value_flag_value() {
let m = cmd
.clone()
.try_get_matches_from(&["test", "--flag=true"])
.try_get_matches_from(["test", "--flag=true"])
.unwrap();
assert!(m.contains_id("flag"));
assert_eq!(
@ -215,7 +215,7 @@ fn default_missing_value_flag_value() {
clap::parser::ValueSource::CommandLine
);
let m = cmd.try_get_matches_from(&["test", "--flag=false"]).unwrap();
let m = cmd.try_get_matches_from(["test", "--flag=false"]).unwrap();
assert!(m.contains_id("flag"));
assert_eq!(
m.get_one::<String>("flag").map(|v| v.as_str()),

8
tests/builder/default_vals.rs
View file

@ -752,10 +752,10 @@ fn required_groups_with_default_values() {
.arg(Arg::new("arg").default_value("value"))
.group(ArgGroup::new("group").args(["arg"]).required(true));
let result = cmd.clone().try_get_matches_from(&["test"]);
let result = cmd.clone().try_get_matches_from(["test"]);
assert!(result.is_err());
let result = cmd.clone().try_get_matches_from(&["test", "value"]);
let result = cmd.clone().try_get_matches_from(["test", "value"]);
assert!(result.is_ok(), "{}", result.unwrap_err());
let m = result.unwrap();
assert!(m.contains_id("arg"));
@ -768,10 +768,10 @@ fn required_args_with_default_values() {
let cmd = Command::new("test").arg(Arg::new("arg").required(true).default_value("value"));
let result = cmd.clone().try_get_matches_from(&["test"]);
let result = cmd.clone().try_get_matches_from(["test"]);
assert!(result.is_err());
let result = cmd.clone().try_get_matches_from(&["test", "value"]);
let result = cmd.clone().try_get_matches_from(["test", "value"]);
assert!(result.is_ok(), "{}", result.unwrap_err());
let m = result.unwrap();
assert!(m.contains_id("arg"));

2
tests/builder/delimiters.rs
View file

@ -122,6 +122,6 @@ fn opt_eq_mult_def_delim() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["val1", "val2", "val3"]
["val1", "val2", "val3"]
);
}

8
tests/builder/derive_order.rs
View file

@ -21,7 +21,7 @@ Options:
let cmd = Command::new("test")
.version("1.2")
.next_display_order(None)
.args(&[
.args([
Arg::new("flag_b")
.long("flag_b")
.help("first flag")
@ -57,7 +57,7 @@ Options:
-V, --version Print version information
";
let cmd = Command::new("test").version("1.2").args(&[
let cmd = Command::new("test").version("1.2").args([
Arg::new("flag_b")
.long("flag_b")
.help("first flag")
@ -185,7 +185,7 @@ Options:
";
let cmd = Command::new("test").subcommand(
Command::new("sub").version("1.2").args(&[
Command::new("sub").version("1.2").args([
Arg::new("flag_b")
.long("flag_b")
.help("first flag")
@ -223,7 +223,7 @@ Options:
";
let cmd = Command::new("test").subcommand(
Command::new("sub").version("1.2").args(&[
Command::new("sub").version("1.2").args([
Arg::new("flag_b")
.long("flag_b")
.help("first flag")

20
tests/builder/empty_values.rs
View file

@ -7,7 +7,7 @@ use super::utils;
fn empty_values() {
let m = Command::new("config")
.arg(Arg::new("config").long("config").action(ArgAction::Set))
.try_get_matches_from(&["config", "--config", ""])
.try_get_matches_from(["config", "--config", ""])
.unwrap();
assert_eq!(m.get_one::<String>("config").map(|v| v.as_str()), Some(""));
}
@ -16,13 +16,13 @@ fn empty_values() {
fn empty_values_with_equals() {
let m = Command::new("config")
.arg(Arg::new("config").long("config").action(ArgAction::Set))
.try_get_matches_from(&["config", "--config="])
.try_get_matches_from(["config", "--config="])
.unwrap();
assert_eq!(m.get_one::<String>("config").map(|v| v.as_str()), Some(""));
let m = Command::new("config")
.arg(Arg::new("config").short('c').action(ArgAction::Set))
.try_get_matches_from(&["config", "-c="])
.try_get_matches_from(["config", "-c="])
.unwrap();
assert_eq!(m.get_one::<String>("config").map(|v| v.as_str()), Some(""))
}
@ -36,7 +36,7 @@ fn no_empty_values() {
.action(ArgAction::Set)
.value_parser(clap::builder::NonEmptyStringValueParser::new()),
)
.try_get_matches_from(&["config", "--config", ""]);
.try_get_matches_from(["config", "--config", ""]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind(), ErrorKind::InvalidValue);
@ -47,7 +47,7 @@ fn no_empty_values() {
.action(ArgAction::Set)
.value_parser(clap::builder::NonEmptyStringValueParser::new()),
)
.try_get_matches_from(&["config", "-c", ""]);
.try_get_matches_from(["config", "-c", ""]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind(), ErrorKind::InvalidValue)
}
@ -61,7 +61,7 @@ fn no_empty_values_with_equals() {
.action(ArgAction::Set)
.value_parser(clap::builder::NonEmptyStringValueParser::new()),
)
.try_get_matches_from(&["config", "--config="]);
.try_get_matches_from(["config", "--config="]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind(), ErrorKind::InvalidValue);
@ -72,7 +72,7 @@ fn no_empty_values_with_equals() {
.action(ArgAction::Set)
.value_parser(clap::builder::NonEmptyStringValueParser::new()),
)
.try_get_matches_from(&["config", "-c="]);
.try_get_matches_from(["config", "-c="]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind(), ErrorKind::InvalidValue);
}
@ -86,7 +86,7 @@ fn no_empty_values_without_equals() {
.action(ArgAction::Set)
.value_parser(clap::builder::NonEmptyStringValueParser::new()),
)
.try_get_matches_from(&["config", "--config"]);
.try_get_matches_from(["config", "--config"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind(), ErrorKind::InvalidValue);
@ -97,7 +97,7 @@ fn no_empty_values_without_equals() {
.action(ArgAction::Set)
.value_parser(clap::builder::NonEmptyStringValueParser::new()),
)
.try_get_matches_from(&["config", "-c"]);
.try_get_matches_from(["config", "-c"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind(), ErrorKind::InvalidValue)
}
@ -112,7 +112,7 @@ fn no_empty_values_without_equals_but_requires_equals() {
.value_parser(clap::builder::NonEmptyStringValueParser::new())
.require_equals(true),
);
let m = cmd.clone().try_get_matches_from(&["config", "--config"]);
let m = cmd.clone().try_get_matches_from(["config", "--config"]);
// Should error on no equals rather than empty value.
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind(), ErrorKind::NoEquals);

10
tests/builder/flags.rs
View file

@ -6,7 +6,7 @@ use super::utils;
#[test]
fn flag_using_short() {
let m = Command::new("flag")
.args(&[
.args([
arg!(-f --flag "some flag").action(ArgAction::SetTrue),
arg!(-c --color "some other flag").action(ArgAction::SetTrue),
])
@ -73,7 +73,7 @@ fn lots_o_flags_combined() {
#[test]
fn flag_using_long() {
let m = Command::new("flag")
.args(&[
.args([
arg!(--flag "some flag").action(ArgAction::SetTrue),
arg!(--color "some other flag").action(ArgAction::SetTrue),
])
@ -101,7 +101,7 @@ fn flag_using_long_with_literals() {
#[test]
fn flag_using_mixed() {
let m = Command::new("flag")
.args(&[
.args([
arg!(-f --flag "some flag").action(ArgAction::SetTrue),
arg!(-c --color "some other flag").action(ArgAction::SetTrue),
])
@ -111,7 +111,7 @@ fn flag_using_mixed() {
assert!(*m.get_one::<bool>("color").expect("defaulted by clap"));
let m = Command::new("flag")
.args(&[
.args([
arg!(-f --flag "some flag").action(ArgAction::SetTrue),
arg!(-c --color "some other flag").action(ArgAction::SetTrue),
])
@ -124,7 +124,7 @@ fn flag_using_mixed() {
#[test]
fn multiple_flags_in_single() {
let m = Command::new("multe_flags")
.args(&[
.args([
arg!(-f --flag "some flag").action(ArgAction::SetTrue),
arg!(-c --color "some other flag").action(ArgAction::SetTrue),
arg!(-d --debug "another other flag").action(ArgAction::SetTrue),

8
tests/builder/global_args.rs
View file

@ -37,7 +37,7 @@ fn propagate_global_arg_in_subcommand_to_subsubcommand_1385() {
)
.subcommand(Command::new("sub1a")),
)
.try_get_matches_from(&["foo", "sub1", "--arg1", "v1", "sub1a"])
.try_get_matches_from(["foo", "sub1", "--arg1", "v1", "sub1a"])
.unwrap();
assert_eq!(
"v1",
@ -62,7 +62,7 @@ fn propagate_global_arg_to_subcommand_in_subsubcommand_2053() {
.arg(arg!(--"sub-str" <str>).global(true))
.subcommand(Command::new("test")),
)
.try_get_matches_from(&[
.try_get_matches_from([
"cmd",
"test",
"test",
@ -86,7 +86,7 @@ fn propagate_global_arg_to_subcommand_in_subsubcommand_2053() {
#[test]
fn global_arg_available_in_subcommand() {
let m = Command::new("opt")
.args(&[
.args([
Arg::new("global")
.global(true)
.long("global")
@ -97,7 +97,7 @@ fn global_arg_available_in_subcommand() {
.action(ArgAction::SetTrue),
])
.subcommand(Command::new("ping"))
.try_get_matches_from(&["opt", "ping", "--global"])
.try_get_matches_from(["opt", "ping", "--global"])
.unwrap();
assert!(*m.get_one::<bool>("global").expect("defaulted by clap"));

6
tests/builder/grouped_values.rs
View file

@ -12,7 +12,7 @@ fn grouped_value_works() {
.num_args(1..)
.action(ArgAction::Append),
)
.try_get_matches_from(&[
.try_get_matches_from([
"cli",
"--option",
"fr_FR:mon option 1",
@ -44,7 +44,7 @@ fn issue_1026() {
.num_args(1..)
.action(ArgAction::Append),
)
.try_get_matches_from(&[
.try_get_matches_from([
"backup", "-s", "server", "-u", "user", "--target", "target1", "file1", "file2",
"file3", "--target", "target2", "file4", "file5", "file6", "file7", "--target",
"target3", "file8",
@ -237,7 +237,7 @@ fn issue_2171() {
.action(ArgAction::SetTrue),
);
let test_args = &[
let test_args = [
vec!["reproducer", "-pz", "-p"],
vec!["reproducer", "-pzp"],
vec!["reproducer", "-zpp"],

6
tests/builder/groups.rs
View file

@ -233,7 +233,7 @@ fn required_group_multiple_args() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["flag", "color"]
["flag", "color"]
);
}
@ -356,14 +356,14 @@ fn issue_1794() {
.required(true),
);
let m = cmd.clone().try_get_matches_from(&["cmd", "pos1", "pos2"]).unwrap();
let m = cmd.clone().try_get_matches_from(["cmd", "pos1", "pos2"]).unwrap();
assert_eq!(m.get_one::<String>("pos1").map(|v| v.as_str()), Some("pos1"));
assert_eq!(m.get_one::<String>("pos2").map(|v| v.as_str()), Some("pos2"));
assert!(!*m.get_one::<bool>("option1").expect("defaulted by clap"));
let m = cmd
.clone()
.try_get_matches_from(&["cmd", "--option1", "positional"]).unwrap();
.try_get_matches_from(["cmd", "--option1", "positional"]).unwrap();
assert_eq!(m.get_one::<String>("pos1").map(|v| v.as_str()), None);
assert_eq!(m.get_one::<String>("pos2").map(|v| v.as_str()), Some("positional"));
assert!(*m.get_one::<bool>("option1").expect("defaulted by clap"));

6
tests/builder/help.rs
View file

@ -2515,7 +2515,7 @@ fn override_help_subcommand() {
.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();
let matches = cmd.try_get_matches_from(["bar", "help", "foo"]).unwrap();
assert_eq!(
matches
.subcommand_matches("help")
@ -2532,7 +2532,7 @@ fn override_help_flag_using_long() {
.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();
let matches = cmd.try_get_matches_from(["foo", "--help"]).unwrap();
assert!(matches.subcommand_matches("help").is_some());
}
@ -2542,7 +2542,7 @@ fn override_help_flag_using_short() {
.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();
let matches = cmd.try_get_matches_from(["foo", "-h"]).unwrap();
assert!(matches.subcommand_matches("help").is_some());
}

14
tests/builder/hidden_args.rs
View file

@ -20,7 +20,7 @@ fn hide_args() {
.author("Kevin K.")
.about("tests stuff")
.version("1.4")
.args(&[
.args([
arg!(-f --flag "some flag").hide(true),
arg!(-F --flag2 "some other flag"),
arg!(--option <opt> "some option"),
@ -47,7 +47,7 @@ fn hide_short_args() {
.about("hides short args")
.author("Steve P.")
.version("2.31.2")
.args(&[
.args([
Arg::new("cfg")
.short('c')
.long("config")
@ -90,7 +90,7 @@ Options:
.about("hides short args")
.author("Steve P.")
.version("2.31.2")
.args(&[
.args([
Arg::new("cfg")
.short('c')
.long("config")
@ -129,7 +129,7 @@ fn hide_long_args() {
.about("hides long args")
.author("Steve P.")
.version("2.31.2")
.args(&[
.args([
Arg::new("cfg")
.short('c')
.long("config")
@ -164,7 +164,7 @@ fn hide_long_args_short_help() {
.about("hides long args")
.author("Steve P.")
.version("2.31.2")
.args(&[
.args([
Arg::new("cfg")
.short('c')
.long("config")
@ -194,7 +194,7 @@ Options:
#[test]
fn hide_pos_args() {
let cmd = Command::new("test").version("1.4").args(&[
let cmd = Command::new("test").version("1.4").args([
Arg::new("pos").help("some pos").hide(true),
Arg::new("another").help("another pos"),
]);
@ -254,7 +254,7 @@ fn hide_pos_args_only() {
.disable_version_flag(true)
.arg(arg!(-h - -help).action(ArgAction::Help).hide(true))
.arg(arg!(-v - -version).hide(true))
.args(&[Arg::new("pos").help("some pos").hide(true)]);
.args([Arg::new("pos").help("some pos").hide(true)]);
utils::assert_output(cmd, "test --help", HIDDEN_POS_ARGS_ONLY, false);
}

35
tests/builder/indices.rs
View file

@ -22,12 +22,9 @@ fn indices_mult_opts() {
assert_eq!(
m.indices_of("exclude").unwrap().collect::<Vec<_>>(),
&[2, 3, 8]
);
assert_eq!(
m.indices_of("include").unwrap().collect::<Vec<_>>(),
&[5, 6]
[2, 3, 8]
);
assert_eq!(m.indices_of("include").unwrap().collect::<Vec<_>>(), [5, 6]);
}
#[test]
@ -89,8 +86,8 @@ fn indices_mult_flags() {
.try_get_matches_from(vec!["ind", "-e", "-i", "-e", "-e", "-i"])
.unwrap();
assert_eq!(m.indices_of("exclude").unwrap().collect::<Vec<_>>(), &[4]);
assert_eq!(m.indices_of("include").unwrap().collect::<Vec<_>>(), &[5]);
assert_eq!(m.indices_of("exclude").unwrap().collect::<Vec<_>>(), [4]);
assert_eq!(m.indices_of("include").unwrap().collect::<Vec<_>>(), [5]);
}
#[test]
@ -102,8 +99,8 @@ fn indices_mult_flags_combined() {
.try_get_matches_from(vec!["ind", "-eieei"])
.unwrap();
assert_eq!(m.indices_of("exclude").unwrap().collect::<Vec<_>>(), &[4]);
assert_eq!(m.indices_of("include").unwrap().collect::<Vec<_>>(), &[5]);
assert_eq!(m.indices_of("exclude").unwrap().collect::<Vec<_>>(), [4]);
assert_eq!(m.indices_of("include").unwrap().collect::<Vec<_>>(), [5]);
}
#[test]
@ -116,9 +113,9 @@ fn indices_mult_flags_opt_combined() {
.try_get_matches_from(vec!["ind", "-eieeio", "val"])
.unwrap();
assert_eq!(m.indices_of("exclude").unwrap().collect::<Vec<_>>(), &[4]);
assert_eq!(m.indices_of("include").unwrap().collect::<Vec<_>>(), &[5]);
assert_eq!(m.indices_of("option").unwrap().collect::<Vec<_>>(), &[7]);
assert_eq!(m.indices_of("exclude").unwrap().collect::<Vec<_>>(), [4]);
assert_eq!(m.indices_of("include").unwrap().collect::<Vec<_>>(), [5]);
assert_eq!(m.indices_of("option").unwrap().collect::<Vec<_>>(), [7]);
}
#[test]
@ -131,9 +128,9 @@ fn indices_mult_flags_opt_combined_eq() {
.try_get_matches_from(vec!["ind", "-eieeio=val"])
.unwrap();
assert_eq!(m.indices_of("exclude").unwrap().collect::<Vec<_>>(), &[4]);
assert_eq!(m.indices_of("include").unwrap().collect::<Vec<_>>(), &[5]);
assert_eq!(m.indices_of("option").unwrap().collect::<Vec<_>>(), &[7]);
assert_eq!(m.indices_of("exclude").unwrap().collect::<Vec<_>>(), [4]);
assert_eq!(m.indices_of("include").unwrap().collect::<Vec<_>>(), [5]);
assert_eq!(m.indices_of("option").unwrap().collect::<Vec<_>>(), [7]);
}
#[test]
@ -151,7 +148,7 @@ fn indices_mult_opt_value_delim_eq() {
.unwrap();
assert_eq!(
m.indices_of("option").unwrap().collect::<Vec<_>>(),
&[2, 3, 4]
[2, 3, 4]
);
}
@ -167,7 +164,7 @@ fn indices_mult_opt_value_no_delim_eq() {
)
.try_get_matches_from(vec!["myapp", "-o=val1,val2,val3"])
.unwrap();
assert_eq!(m.indices_of("option").unwrap().collect::<Vec<_>>(), &[2]);
assert_eq!(m.indices_of("option").unwrap().collect::<Vec<_>>(), [2]);
}
#[test]
@ -179,6 +176,6 @@ fn indices_mult_opt_mult_flag() {
.try_get_matches_from(vec!["myapp", "-o", "val1", "-f", "-o", "val2", "-f"])
.unwrap();
assert_eq!(m.indices_of("option").unwrap().collect::<Vec<_>>(), &[2, 5]);
assert_eq!(m.indices_of("flag").unwrap().collect::<Vec<_>>(), &[6]);
assert_eq!(m.indices_of("option").unwrap().collect::<Vec<_>>(), [2, 5]);
assert_eq!(m.indices_of("flag").unwrap().collect::<Vec<_>>(), [6]);
}

6
tests/builder/multiple_occurrences.rs
View file

@ -34,14 +34,14 @@ fn multiple_occurrences_of_positional() {
let m = cmd
.clone()
.try_get_matches_from(&["test"])
.try_get_matches_from(["test"])
.expect("zero occurrences work");
assert!(!m.contains_id("multi"));
assert!(m.get_many::<String>("multi").is_none());
let m = cmd
.clone()
.try_get_matches_from(&["test", "one"])
.try_get_matches_from(["test", "one"])
.expect("single occurrence work");
assert!(m.contains_id("multi"));
assert_eq!(
@ -54,7 +54,7 @@ fn multiple_occurrences_of_positional() {
let m = cmd
.clone()
.try_get_matches_from(&["test", "one", "two", "three", "four"])
.try_get_matches_from(["test", "one", "two", "three", "four"])
.expect("many occurrences work");
assert!(m.contains_id("multi"));
assert_eq!(

24
tests/builder/multiple_values.rs
View file

@ -853,14 +853,14 @@ fn req_delimiter_long() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["val1"]
["val1"]
);
assert_eq!(
m.get_many::<String>("args")
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["val2", "val3"]
["val2", "val3"]
);
}
@ -890,14 +890,14 @@ fn req_delimiter_long_with_equal() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["val1"]
["val1"]
);
assert_eq!(
m.get_many::<String>("args")
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["val2", "val3"]
["val2", "val3"]
);
}
@ -927,14 +927,14 @@ fn req_delimiter_short_with_space() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["val1"]
["val1"]
);
assert_eq!(
m.get_many::<String>("args")
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["val2", "val3"]
["val2", "val3"]
);
}
@ -964,14 +964,14 @@ fn req_delimiter_short_with_no_space() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["val1"]
["val1"]
);
assert_eq!(
m.get_many::<String>("args")
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["val2", "val3"]
["val2", "val3"]
);
}
@ -1001,14 +1001,14 @@ fn req_delimiter_short_with_equal() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["val1"]
["val1"]
);
assert_eq!(
m.get_many::<String>("args")
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["val2", "val3"]
["val2", "val3"]
);
}
@ -1062,7 +1062,7 @@ fn req_delimiter_complex() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&[
[
"val2", "val4", "val6", "val8", "val10", "val12", "val13", "val15", "val16", "val18",
"val19", "val21", "val22", "val24", "val25",
]
@ -1072,7 +1072,7 @@ fn req_delimiter_complex() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&[
[
"val1", "val3", "val5", "val7", "val9", "val11", "val14", "val17", "val20", "val23",
"val26",
]

42
tests/builder/opts.rs
View file

@ -127,7 +127,7 @@ fn stdin_char() {
#[test]
fn opts_using_short() {
let r = Command::new("opts")
.args(&[
.args([
arg!(f: -f [flag] "some flag"),
arg!(c: -c [color] "some other flag"),
])
@ -189,7 +189,7 @@ fn lots_o_vals() {
#[test]
fn opts_using_long_space() {
let r = Command::new("opts")
.args(&[
.args([
arg!(--flag [flag] "some flag"),
arg!(--color [color] "some other flag"),
])
@ -211,7 +211,7 @@ fn opts_using_long_space() {
#[test]
fn opts_using_long_equals() {
let r = Command::new("opts")
.args(&[
.args([
arg!(--flag [flag] "some flag"),
arg!(--color [color] "some other flag"),
])
@ -233,7 +233,7 @@ fn opts_using_long_equals() {
#[test]
fn opts_using_mixed() {
let r = Command::new("opts")
.args(&[
.args([
arg!(-f --flag [flag] "some flag"),
arg!(-c --color [color] "some other flag"),
])
@ -255,7 +255,7 @@ fn opts_using_mixed() {
#[test]
fn opts_using_mixed2() {
let r = Command::new("opts")
.args(&[
.args([
arg!(-f --flag [flag] "some flag"),
arg!(-c --color [color] "some other flag"),
])
@ -334,7 +334,7 @@ fn require_delims() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["1", "2"]
["1", "2"]
);
assert!(m.contains_id("file"));
assert_eq!(
@ -361,7 +361,7 @@ fn leading_hyphen_pass() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["-2", "3"]
["-2", "3"]
);
}
@ -394,7 +394,7 @@ fn leading_hyphen_with_flag_after() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["-2", "-f"]
["-2", "-f"]
);
assert!(!*m.get_one::<bool>("f").expect("defaulted by clap"));
}
@ -413,7 +413,7 @@ fn leading_hyphen_with_flag_before() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["-2"]
["-2"]
);
assert!(*m.get_one::<bool>("f").expect("defaulted by clap"));
}
@ -436,7 +436,7 @@ fn leading_hyphen_with_only_pos_follows() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["-2"]
["-2"]
);
assert_eq!(m.get_one::<String>("arg").map(|v| v.as_str()), Some("val"));
}
@ -576,7 +576,7 @@ For more information try '--help'
fn short_non_ascii_no_space() {
let matches = Command::new("cmd")
.arg(arg!(opt: -'磨' <opt>).required(true))
.try_get_matches_from(&["test", "-磨VALUE"])
.try_get_matches_from(["test", "-磨VALUE"])
.unwrap();
assert_eq!(
@ -592,7 +592,7 @@ fn short_non_ascii_no_space() {
fn short_eq_val_starts_with_eq() {
let matches = Command::new("cmd")
.arg(arg!(opt: -f <opt>).required(true))
.try_get_matches_from(&["test", "-f==value"])
.try_get_matches_from(["test", "-f==value"])
.unwrap();
assert_eq!(
@ -608,7 +608,7 @@ fn short_eq_val_starts_with_eq() {
fn long_eq_val_starts_with_eq() {
let matches = Command::new("cmd")
.arg(arg!(opt: --foo <opt>).required(true))
.try_get_matches_from(&["test", "--foo==value"])
.try_get_matches_from(["test", "--foo==value"])
.unwrap();
assert_eq!(
@ -625,7 +625,7 @@ fn issue_2022_get_flags_misuse() {
let cmd = Command::new("test")
.next_help_heading(Some("test"))
.arg(Arg::new("a").long("a").default_value("32"));
let matches = cmd.try_get_matches_from(&[""]).unwrap();
let matches = cmd.try_get_matches_from([""]).unwrap();
assert!(matches.get_one::<String>("a").map(|v| v.as_str()).is_some())
}
@ -634,7 +634,7 @@ fn issue_2279() {
let before_help_heading = Command::new("cmd")
.arg(Arg::new("foo").short('f').default_value("bar"))
.next_help_heading(Some("This causes default_value to be ignored"))
.try_get_matches_from(&[""])
.try_get_matches_from([""])
.unwrap();
assert_eq!(
@ -647,7 +647,7 @@ fn issue_2279() {
let after_help_heading = Command::new("cmd")
.next_help_heading(Some("This causes default_value to be ignored"))
.arg(Arg::new("foo").short('f').default_value("bar"))
.try_get_matches_from(&[""])
.try_get_matches_from([""])
.unwrap();
assert_eq!(
@ -672,7 +672,7 @@ fn infer_long_arg() {
let matches = cmd
.clone()
.try_get_matches_from(&["test", "--racec=hello"])
.try_get_matches_from(["test", "--racec=hello"])
.unwrap();
assert!(!*matches
.get_one::<bool>("racetrack")
@ -684,7 +684,7 @@ fn infer_long_arg() {
let matches = cmd
.clone()
.try_get_matches_from(&["test", "--racet"])
.try_get_matches_from(["test", "--racet"])
.unwrap();
assert!(*matches
.get_one::<bool>("racetrack")
@ -696,7 +696,7 @@ fn infer_long_arg() {
let matches = cmd
.clone()
.try_get_matches_from(&["test", "--auto"])
.try_get_matches_from(["test", "--auto"])
.unwrap();
assert!(*matches
.get_one::<bool>("racetrack")
@ -710,9 +710,9 @@ fn infer_long_arg() {
.infer_long_args(true)
.arg(Arg::new("arg").long("arg").action(ArgAction::SetTrue));
let matches = cmd.clone().try_get_matches_from(&["test", "--"]).unwrap();
let matches = cmd.clone().try_get_matches_from(["test", "--"]).unwrap();
assert!(!*matches.get_one::<bool>("arg").expect("defaulted by clap"));
let matches = cmd.clone().try_get_matches_from(&["test", "--a"]).unwrap();
let matches = cmd.clone().try_get_matches_from(["test", "--a"]).unwrap();
assert!(*matches.get_one::<bool>("arg").expect("defaulted by clap"));
}

22
tests/builder/positionals.rs
View file

@ -3,7 +3,7 @@ use clap::{arg, error::ErrorKind, Arg, ArgAction, Command};
#[test]
fn only_pos_follow() {
let r = Command::new("onlypos")
.args(&[arg!(f: -f [flag] "some opt"), arg!([arg] "some arg")])
.args([arg!(f: -f [flag] "some opt"), arg!([arg] "some arg")])
.try_get_matches_from(vec!["", "--", "-f"]);
assert!(r.is_ok(), "{}", r.unwrap_err());
let m = r.unwrap();
@ -40,7 +40,7 @@ fn issue_946() {
#[test]
fn positional() {
let r = Command::new("positional")
.args(&[
.args([
arg!(-f --flag "some flag").action(ArgAction::SetTrue),
Arg::new("positional").index(1),
])
@ -57,7 +57,7 @@ fn positional() {
);
let m = Command::new("positional")
.args(&[
.args([
arg!(-f --flag "some flag").action(ArgAction::SetTrue),
Arg::new("positional").index(1),
])
@ -116,7 +116,7 @@ fn lots_o_vals() {
#[test]
fn positional_multiple() {
let r = Command::new("positional_multiple")
.args(&[
.args([
arg!(-f --flag "some flag").action(ArgAction::SetTrue),
Arg::new("positional")
.index(1)
@ -133,14 +133,14 @@ fn positional_multiple() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["test1", "test2", "test3"]
["test1", "test2", "test3"]
);
}
#[test]
fn positional_multiple_3() {
let r = Command::new("positional_multiple")
.args(&[
.args([
arg!(-f --flag "some flag").action(ArgAction::SetTrue),
Arg::new("positional")
.index(1)
@ -157,14 +157,14 @@ fn positional_multiple_3() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["test1", "test2", "test3"]
["test1", "test2", "test3"]
);
}
#[test]
fn positional_multiple_2() {
let result = Command::new("positional_multiple")
.args(&[arg!(-f --flag "some flag"), Arg::new("positional").index(1)])
.args([arg!(-f --flag "some flag"), Arg::new("positional").index(1)])
.try_get_matches_from(vec!["", "-f", "test1", "test2", "test3"]);
assert!(result.is_err());
let err = result.err().unwrap();
@ -174,7 +174,7 @@ fn positional_multiple_2() {
#[test]
fn positional_possible_values() {
let r = Command::new("positional_possible_values")
.args(&[
.args([
arg!(-f --flag "some flag").action(ArgAction::SetTrue),
Arg::new("positional").index(1).value_parser(["test123"]),
])
@ -188,7 +188,7 @@ fn positional_possible_values() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["test123"]
["test123"]
);
}
@ -285,7 +285,7 @@ fn last_positional() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["arg"]
["arg"]
);
}

4
tests/builder/posix_compatible.rs
View file

@ -326,14 +326,14 @@ fn incremental_override() {
.action(ArgAction::SetTrue),
);
let m = cmd
.try_get_matches_from_mut(&["test", "--name=ahmed", "--no-name", "--name=ali"])
.try_get_matches_from_mut(["test", "--name=ahmed", "--no-name", "--name=ali"])
.unwrap();
assert_eq!(
m.get_many::<String>("name")
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["ali"]
["ali"]
);
assert!(!*m.get_one::<bool>("no-name").expect("defaulted by clap"));
}

2
tests/builder/possible_values.rs
View file

@ -452,7 +452,7 @@ fn ignore_case_multiple() {
.unwrap()
.map(|v| v.as_str())
.collect::<Vec<_>>(),
&["TeSt123", "teST123", "tESt321"]
["TeSt123", "teST123", "tESt321"]
);
}

8
tests/builder/require.rs
View file

@ -1126,7 +1126,7 @@ For more information try '--help'
#[test]
fn issue_1158_conflicting_requirements_rev() {
let res = issue_1158_app().try_get_matches_from(&["", "--config", "some.conf"]);
let res = issue_1158_app().try_get_matches_from(["", "--config", "some.conf"]);
assert!(res.is_ok(), "{}", res.unwrap_err());
}
@ -1153,7 +1153,7 @@ fn issue_1643_args_mutually_require_each_other() {
.requires("relation_id"),
);
cmd.try_get_matches_from(&["test", "-u", "hello", "-r", "farewell"])
cmd.try_get_matches_from(["test", "-u", "hello", "-r", "farewell"])
.unwrap();
}
@ -1167,7 +1167,7 @@ fn short_flag_require_equals_with_minvals_zero() {
.require_equals(true),
)
.arg(Arg::new("unique").short('u').action(ArgAction::SetTrue))
.try_get_matches_from(&["foo", "-cu"])
.try_get_matches_from(["foo", "-cu"])
.unwrap();
assert!(m.contains_id("check"));
assert!(*m.get_one::<bool>("unique").expect("defaulted by clap"));
@ -1190,7 +1190,7 @@ fn issue_2624() {
.long("unique")
.action(ArgAction::SetTrue),
)
.try_get_matches_from(&["foo", "-cu"])
.try_get_matches_from(["foo", "-cu"])
.unwrap();
assert!(matches.contains_id("check"));
assert!(*matches

35
tests/builder/subcommands.rs
View file

@ -234,7 +234,7 @@ fn replace() {
.subcommand(
Command::new("module").subcommand(Command::new("install").about("Install module")),
)
.replace("install", &["module", "install"])
.replace("install", ["module", "install"])
.try_get_matches_from(vec!["prog", "install"])
.unwrap();
@ -403,19 +403,19 @@ fn issue_2494_subcommand_is_present() {
let m = cmd
.clone()
.try_get_matches_from(&["opt", "--global", "global"])
.try_get_matches_from(["opt", "--global", "global"])
.unwrap();
assert_eq!(m.subcommand_name().unwrap(), "global");
assert!(*m.get_one::<bool>("global").expect("defaulted by clap"));
let m = cmd
.clone()
.try_get_matches_from(&["opt", "--global"])
.try_get_matches_from(["opt", "--global"])
.unwrap();
assert!(m.subcommand_name().is_none());
assert!(*m.get_one::<bool>("global").expect("defaulted by clap"));
let m = cmd.try_get_matches_from(&["opt", "global"]).unwrap();
let m = cmd.try_get_matches_from(["opt", "global"]).unwrap();
assert_eq!(m.subcommand_name().unwrap(), "global");
assert!(!*m.get_one::<bool>("global").expect("defaulted by clap"));
}
@ -452,15 +452,15 @@ fn busybox_like_multicall() {
let m = cmd
.clone()
.try_get_matches_from(&["busybox", "true"])
.try_get_matches_from(["busybox", "true"])
.unwrap();
assert_eq!(m.subcommand_name(), Some("busybox"));
assert_eq!(m.subcommand().unwrap().1.subcommand_name(), Some("true"));
let m = cmd.clone().try_get_matches_from(&["true"]).unwrap();
let m = cmd.clone().try_get_matches_from(["true"]).unwrap();
assert_eq!(m.subcommand_name(), Some("true"));
let m = cmd.clone().try_get_matches_from(&["a.out"]);
let m = cmd.clone().try_get_matches_from(["a.out"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind(), ErrorKind::InvalidSubcommand);
}
@ -472,24 +472,21 @@ fn hostname_like_multicall() {
.subcommand(Command::new("hostname"))
.subcommand(Command::new("dnsdomainname"));
let m = cmd.clone().try_get_matches_from(&["hostname"]).unwrap();
let m = cmd.clone().try_get_matches_from(["hostname"]).unwrap();
assert_eq!(m.subcommand_name(), Some("hostname"));
let m = cmd
.clone()
.try_get_matches_from(&["dnsdomainname"])
.unwrap();
let m = cmd.clone().try_get_matches_from(["dnsdomainname"]).unwrap();
assert_eq!(m.subcommand_name(), Some("dnsdomainname"));
let m = cmd.clone().try_get_matches_from(&["a.out"]);
let m = cmd.clone().try_get_matches_from(["a.out"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind(), ErrorKind::InvalidSubcommand);
let m = cmd.try_get_matches_from_mut(&["hostname", "hostname"]);
let m = cmd.try_get_matches_from_mut(["hostname", "hostname"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind(), ErrorKind::UnknownArgument);
let m = cmd.try_get_matches_from(&["hostname", "dnsdomainname"]);
let m = cmd.try_get_matches_from(["hostname", "dnsdomainname"]);
assert!(m.is_err());
assert_eq!(m.unwrap_err().kind(), ErrorKind::UnknownArgument);
}
@ -504,7 +501,7 @@ fn bad_multicall_command_error() {
.subcommand(Command::new("foo"))
.subcommand(Command::new("bar"));
let err = cmd.clone().try_get_matches_from(&["world"]).unwrap_err();
let err = cmd.clone().try_get_matches_from(["world"]).unwrap_err();
assert_eq!(err.kind(), ErrorKind::InvalidSubcommand);
static HELLO_EXPECTED: &str = "\
error: The subcommand 'world' wasn't recognized
@ -517,7 +514,7 @@ For more information try 'help'
#[cfg(feature = "suggestions")]
{
let err = cmd.clone().try_get_matches_from(&["baz"]).unwrap_err();
let err = cmd.clone().try_get_matches_from(["baz"]).unwrap_err();
assert_eq!(err.kind(), ErrorKind::InvalidSubcommand);
static BAZ_EXPECTED: &str = "\
error: The subcommand 'baz' wasn't recognized
@ -537,13 +534,13 @@ For more information try 'help'
let err = cmd
.clone()
.try_get_matches_from(&["foo", "--help"])
.try_get_matches_from(["foo", "--help"])
.unwrap_err();
assert_eq!(err.kind(), ErrorKind::DisplayHelp);
let err = cmd
.clone()
.try_get_matches_from(&["foo", "--version"])
.try_get_matches_from(["foo", "--version"])
.unwrap_err();
assert_eq!(err.kind(), ErrorKind::DisplayVersion);
}

2
tests/builder/tests.rs
View file

@ -252,7 +252,7 @@ fn create_app() {
#[test]
fn add_multiple_arg() {
let _ = Command::new("test")
.args(&[Arg::new("test").short('s'), Arg::new("test2").short('l')])
.args([Arg::new("test").short('s'), Arg::new("test2").short('l')])
.try_get_matches_from(vec![""])
.unwrap();
}

6
tests/builder/unique_args.rs
View file

@ -5,7 +5,7 @@ fn unique_arg_names() {
use clap::{Arg, Command};
let _ = Command::new("some")
.args(&[Arg::new("arg1").short('a'), Arg::new("arg1").short('b')])
.args([Arg::new("arg1").short('a'), Arg::new("arg1").short('b')])
.try_get_matches();
}
@ -16,7 +16,7 @@ fn unique_arg_shorts() {
use clap::{Arg, Command};
let _ = Command::new("some")
.args(&[Arg::new("arg1").short('a'), Arg::new("arg2").short('a')])
.args([Arg::new("arg1").short('a'), Arg::new("arg2").short('a')])
.try_get_matches();
}
@ -27,6 +27,6 @@ fn unique_arg_longs() {
use clap::{Arg, Command};
let _ = Command::new("some")
.args(&[Arg::new("arg1").long("long"), Arg::new("arg2").long("long")])
.args([Arg::new("arg1").long("long"), Arg::new("arg2").long("long")])
.try_get_matches();
}

30
tests/derive/arguments.rs
View file

@ -24,10 +24,10 @@ fn required_argument() {
}
assert_eq!(
Opt { arg: 42 },
Opt::try_parse_from(&["test", "42"]).unwrap()
Opt::try_parse_from(["test", "42"]).unwrap()
);
assert!(Opt::try_parse_from(&["test"]).is_err());
assert!(Opt::try_parse_from(&["test", "42", "24"]).is_err());
assert!(Opt::try_parse_from(["test"]).is_err());
assert!(Opt::try_parse_from(["test", "42", "24"]).is_err());
}
#[test]
@ -39,10 +39,10 @@ fn argument_with_default() {
}
assert_eq!(
Opt { arg: 24 },
Opt::try_parse_from(&["test", "24"]).unwrap()
Opt::try_parse_from(["test", "24"]).unwrap()
);
assert_eq!(Opt { arg: 42 }, Opt::try_parse_from(&["test"]).unwrap());
assert!(Opt::try_parse_from(&["test", "42", "24"]).is_err());
assert_eq!(Opt { arg: 42 }, Opt::try_parse_from(["test"]).unwrap());
assert!(Opt::try_parse_from(["test", "42", "24"]).is_err());
}
#[test]
@ -58,7 +58,7 @@ fn auto_value_name() {
// Ensure the implicit `num_vals` is just 1
assert_eq!(
Opt { my_special_arg: 10 },
Opt::try_parse_from(&["test", "10"]).unwrap()
Opt::try_parse_from(["test", "10"]).unwrap()
);
}
@ -77,7 +77,7 @@ fn explicit_value_name() {
// Ensure the implicit `num_vals` is just 1
assert_eq!(
Opt { my_special_arg: 10 },
Opt::try_parse_from(&["test", "10"]).unwrap()
Opt::try_parse_from(["test", "10"]).unwrap()
);
}
@ -89,10 +89,10 @@ fn option_type_is_optional() {
}
assert_eq!(
Opt { arg: Some(42) },
Opt::try_parse_from(&["test", "42"]).unwrap()
Opt::try_parse_from(["test", "42"]).unwrap()
);
assert_eq!(Opt { arg: None }, Opt::try_parse_from(&["test"]).unwrap());
assert!(Opt::try_parse_from(&["test", "42", "24"]).is_err());
assert_eq!(Opt { arg: None }, Opt::try_parse_from(["test"]).unwrap());
assert!(Opt::try_parse_from(["test", "42", "24"]).is_err());
}
#[test]
@ -103,15 +103,15 @@ fn vec_type_is_multiple_values() {
}
assert_eq!(
Opt { arg: vec![24] },
Opt::try_parse_from(&["test", "24"]).unwrap()
Opt::try_parse_from(["test", "24"]).unwrap()
);
assert_eq!(Opt { arg: vec![] }, Opt::try_parse_from(&["test"]).unwrap());
assert_eq!(Opt { arg: vec![] }, Opt::try_parse_from(["test"]).unwrap());
assert_eq!(
Opt { arg: vec![24, 42] },
Opt::try_parse_from(&["test", "24", "42"]).unwrap()
Opt::try_parse_from(["test", "24", "42"]).unwrap()
);
assert_eq!(
clap::error::ErrorKind::ValueValidation,
Opt::try_parse_from(&["test", "NOPE"]).err().unwrap().kind()
Opt::try_parse_from(["test", "NOPE"]).err().unwrap().kind()
);
}

8
tests/derive/basic.rs
View file

@ -23,7 +23,7 @@ fn basic() {
}
assert_eq!(
Opt { arg: 24 },
Opt::try_parse_from(&["test", "-a24"]).unwrap()
Opt::try_parse_from(["test", "-a24"]).unwrap()
);
}
@ -35,9 +35,9 @@ fn update_basic() {
single_value: i32,
}
let mut opt = Opt::try_parse_from(&["test", "-a0"]).unwrap();
let mut opt = Opt::try_parse_from(["test", "-a0"]).unwrap();
opt.update_from(&["test", "-a42"]);
opt.update_from(["test", "-a42"]);
assert_eq!(Opt { single_value: 42 }, opt);
}
@ -47,5 +47,5 @@ fn unit_struct() {
#[derive(Parser, PartialEq, Debug)]
struct Opt;
assert_eq!(Opt {}, Opt::try_parse_from(&["test"]).unwrap());
assert_eq!(Opt {}, Opt::try_parse_from(["test"]).unwrap());
}

6
tests/derive/boxed.rs
View file

@ -27,15 +27,15 @@ fn boxed_flatten_subcommand() {
arg: Box::new(Ext { arg: 1 })
})
},
Opt::try_parse_from(&["test", "flame", "1"]).unwrap()
Opt::try_parse_from(["test", "flame", "1"]).unwrap()
);
}
#[test]
fn update_boxed_flatten_subcommand() {
let mut opt = Opt::try_parse_from(&["test", "flame", "1"]).unwrap();
let mut opt = Opt::try_parse_from(["test", "flame", "1"]).unwrap();
opt.update_from(&["test", "flame", "42"]);
opt.update_from(["test", "flame", "42"]);
assert_eq!(
Opt {

14
tests/derive/custom_string_parsers.rs
View file

@ -49,7 +49,7 @@ fn test_path_opt_simple() {
option_path_1: None,
option_path_2: Some(PathBuf::from("j.zip")),
},
PathOpt::try_parse_from(&[
PathOpt::try_parse_from([
"test", "-p", "/usr/bin", "-v", "/a/b/c", "-v", "/d/e/f", "-v", "/g/h/i", "-q",
"j.zip",
])
@ -72,16 +72,16 @@ struct HexOpt {
fn test_parse_hex() {
assert_eq!(
HexOpt { number: 5 },
HexOpt::try_parse_from(&["test", "-n", "5"]).unwrap()
HexOpt::try_parse_from(["test", "-n", "5"]).unwrap()
);
assert_eq!(
HexOpt {
number: 0x00ab_cdef
},
HexOpt::try_parse_from(&["test", "-n", "abcdef"]).unwrap()
HexOpt::try_parse_from(["test", "-n", "abcdef"]).unwrap()
);
let err = HexOpt::try_parse_from(&["test", "-n", "gg"]).unwrap_err();
let err = HexOpt::try_parse_from(["test", "-n", "gg"]).unwrap_err();
assert!(
err.to_string().contains("invalid digit found in string"),
"{}",
@ -111,7 +111,7 @@ struct NoOpOpt {
fn test_every_custom_parser() {
assert_eq!(
NoOpOpt { b: "B" },
NoOpOpt::try_parse_from(&["test", "-b=?"]).unwrap()
NoOpOpt::try_parse_from(["test", "-b=?"]).unwrap()
);
}
@ -119,7 +119,7 @@ fn test_every_custom_parser() {
fn update_every_custom_parser() {
let mut opt = NoOpOpt { b: "0" };
opt.try_update_from(&["test", "-b=?"]).unwrap();
opt.try_update_from(["test", "-b=?"]).unwrap();
assert_eq!(NoOpOpt { b: "B" }, opt);
}
@ -140,6 +140,6 @@ fn test_parser_with_default_value() {
integer: 9000,
path: PathBuf::from("src/lib.rs"),
},
DefaultedOpt::try_parse_from(&["test", "-i", "9000", "-p", "src/lib.rs",]).unwrap()
DefaultedOpt::try_parse_from(["test", "-i", "9000", "-p", "src/lib.rs",]).unwrap()
);
}

30
tests/derive/default_value.rs
View file

@ -11,8 +11,8 @@ fn default_value() {
#[arg(default_value = "3")]
arg: i32,
}
assert_eq!(Opt { arg: 3 }, Opt::try_parse_from(&["test"]).unwrap());
assert_eq!(Opt { arg: 1 }, Opt::try_parse_from(&["test", "1"]).unwrap());
assert_eq!(Opt { arg: 3 }, Opt::try_parse_from(["test"]).unwrap());
assert_eq!(Opt { arg: 1 }, Opt::try_parse_from(["test", "1"]).unwrap());
let help = utils::get_long_help::<Opt>();
assert!(help.contains("[default: 3]"));
@ -25,8 +25,8 @@ fn default_value_t() {
#[arg(default_value_t = 3)]
arg: i32,
}
assert_eq!(Opt { arg: 3 }, Opt::try_parse_from(&["test"]).unwrap());
assert_eq!(Opt { arg: 1 }, Opt::try_parse_from(&["test", "1"]).unwrap());
assert_eq!(Opt { arg: 3 }, Opt::try_parse_from(["test"]).unwrap());
assert_eq!(Opt { arg: 1 }, Opt::try_parse_from(["test", "1"]).unwrap());
let help = utils::get_long_help::<Opt>();
assert!(help.contains("[default: 3]"));
@ -39,8 +39,8 @@ fn auto_default_value_t() {
#[arg(default_value_t)]
arg: i32,
}
assert_eq!(Opt { arg: 0 }, Opt::try_parse_from(&["test"]).unwrap());
assert_eq!(Opt { arg: 1 }, Opt::try_parse_from(&["test", "1"]).unwrap());
assert_eq!(Opt { arg: 0 }, Opt::try_parse_from(["test"]).unwrap());
assert_eq!(Opt { arg: 1 }, Opt::try_parse_from(["test", "1"]).unwrap());
let help = utils::get_long_help::<Opt>();
assert!(help.contains("[default: 0]"));
@ -53,7 +53,7 @@ fn default_values_t() {
#[arg(default_values_t = vec![1, 2, 3])]
arg1: Vec<i32>,
#[arg(long, default_values_t = &[4, 5, 6])]
#[arg(long, default_values_t = [4, 5, 6])]
arg2: Vec<i32>,
#[arg(long, default_values_t = [7, 8, 9])]
@ -77,7 +77,7 @@ fn default_values_t() {
arg5: vec!["hello".to_string(), "world".to_string()],
arg6: vec!["foo".to_string(), "bar".to_string()],
},
Opt::try_parse_from(&["test"]).unwrap()
Opt::try_parse_from(["test"]).unwrap()
);
assert_eq!(
Opt {
@ -88,7 +88,7 @@ fn default_values_t() {
arg5: vec!["hello".to_string(), "world".to_string()],
arg6: vec!["foo".to_string(), "bar".to_string()],
},
Opt::try_parse_from(&["test", "1"]).unwrap()
Opt::try_parse_from(["test", "1"]).unwrap()
);
assert_eq!(
Opt {
@ -99,7 +99,7 @@ fn default_values_t() {
arg5: vec!["baz".to_string()],
arg6: vec!["foo".to_string(), "bar".to_string()],
},
Opt::try_parse_from(&["test", "--arg4", "42", "--arg4", "15", "--arg5", "baz"]).unwrap()
Opt::try_parse_from(["test", "--arg4", "42", "--arg4", "15", "--arg5", "baz"]).unwrap()
);
let help = utils::get_long_help::<Opt>();
@ -117,13 +117,13 @@ fn default_value_os_t() {
Opt {
arg: PathBuf::from("abc.def")
},
Opt::try_parse_from(&["test"]).unwrap()
Opt::try_parse_from(["test"]).unwrap()
);
assert_eq!(
Opt {
arg: PathBuf::from("ghi")
},
Opt::try_parse_from(&["test", "ghi"]).unwrap()
Opt::try_parse_from(["test", "ghi"]).unwrap()
);
let help = utils::get_long_help::<Opt>();
@ -141,7 +141,7 @@ fn default_values_os_t() {
#[arg(
long,
default_values_os_t = &[PathBuf::from("bar.baz")]
default_values_os_t = [PathBuf::from("bar.baz")]
)]
arg2: Vec<PathBuf>,
}
@ -150,14 +150,14 @@ fn default_values_os_t() {
arg1: vec![PathBuf::from("abc.def"), PathBuf::from("123.foo")],
arg2: vec![PathBuf::from("bar.baz")]
},
Opt::try_parse_from(&["test"]).unwrap()
Opt::try_parse_from(["test"]).unwrap()
);
assert_eq!(
Opt {
arg1: vec![PathBuf::from("ghi")],
arg2: vec![PathBuf::from("baz.bar"), PathBuf::from("foo.bar")]
},
Opt::try_parse_from(&["test", "ghi", "--arg2", "baz.bar", "--arg2", "foo.bar"]).unwrap()
Opt::try_parse_from(["test", "ghi", "--arg2", "baz.bar", "--arg2", "foo.bar"]).unwrap()
);
let help = utils::get_long_help::<Opt>();

4
tests/derive/deny_warnings.rs
View file

@ -31,7 +31,7 @@ fn warning_never_struct() {
Opt {
s: "foo".to_string()
},
Opt::try_parse_from(&["test", "foo"]).unwrap()
Opt::try_parse_from(["test", "foo"]).unwrap()
);
}
@ -48,6 +48,6 @@ fn warning_never_enum() {
Opt::Foo {
s: "foo".to_string()
},
Opt::try_parse_from(&["test", "foo", "foo"]).unwrap()
Opt::try_parse_from(["test", "foo", "foo"]).unwrap()
);
}

4
tests/derive/explicit_name_no_renaming.rs
View file

@ -12,14 +12,14 @@ fn explicit_short_long_no_rename() {
assert_eq!(
Opt { foo: "long".into() },
Opt::try_parse_from(&["test", "--.foo", "long"]).unwrap()
Opt::try_parse_from(["test", "--.foo", "long"]).unwrap()
);
assert_eq!(
Opt {
foo: "short".into(),
},
Opt::try_parse_from(&["test", "-.", "short"]).unwrap()
Opt::try_parse_from(["test", "-.", "short"]).unwrap()
);
}

71
tests/derive/flags.rs
View file

@ -27,24 +27,21 @@ fn bool_type_is_flag() {
alice: bool,
}
assert_eq!(Opt { alice: false }, Opt::try_parse_from(["test"]).unwrap());
assert_eq!(
Opt { alice: false },
Opt::try_parse_from(&["test"]).unwrap()
Opt { alice: true },
Opt::try_parse_from(["test", "-a"]).unwrap()
);
assert_eq!(
Opt { alice: true },
Opt::try_parse_from(&["test", "-a"]).unwrap()
Opt::try_parse_from(["test", "-a", "-a"]).unwrap()
);
assert_eq!(
Opt { alice: true },
Opt::try_parse_from(&["test", "-a", "-a"]).unwrap()
Opt::try_parse_from(["test", "--alice"]).unwrap()
);
assert_eq!(
Opt { alice: true },
Opt::try_parse_from(&["test", "--alice"]).unwrap()
);
assert!(Opt::try_parse_from(&["test", "-i"]).is_err());
assert!(Opt::try_parse_from(&["test", "-a", "foo"]).is_err());
assert!(Opt::try_parse_from(["test", "-i"]).is_err());
assert!(Opt::try_parse_from(["test", "-a", "foo"]).is_err());
}
#[test]
@ -65,19 +62,19 @@ fn non_bool_type_flag() {
bob: usize,
}
let opt = Opt::try_parse_from(&["test"]).unwrap();
let opt = Opt::try_parse_from(["test"]).unwrap();
assert_eq!(opt.alice, 5);
assert_eq!(opt.bob, 5);
let opt = Opt::try_parse_from(&["test", "-a"]).unwrap();
let opt = Opt::try_parse_from(["test", "-a"]).unwrap();
assert_eq!(opt.alice, 10);
assert_eq!(opt.bob, 5);
let opt = Opt::try_parse_from(&["test", "-b"]).unwrap();
let opt = Opt::try_parse_from(["test", "-b"]).unwrap();
assert_eq!(opt.alice, 5);
assert_eq!(opt.bob, 10);
let opt = Opt::try_parse_from(&["test", "-b", "-a"]).unwrap();
let opt = Opt::try_parse_from(["test", "-b", "-a"]).unwrap();
assert_eq!(opt.alice, 10);
assert_eq!(opt.bob, 10);
}
@ -139,26 +136,26 @@ fn count() {
assert_eq!(
Opt { alice: 0, bob: 0 },
Opt::try_parse_from(&["test"]).unwrap()
Opt::try_parse_from(["test"]).unwrap()
);
assert_eq!(
Opt { alice: 1, bob: 0 },
Opt::try_parse_from(&["test", "-a"]).unwrap()
Opt::try_parse_from(["test", "-a"]).unwrap()
);
assert_eq!(
Opt { alice: 2, bob: 0 },
Opt::try_parse_from(&["test", "-a", "-a"]).unwrap()
Opt::try_parse_from(["test", "-a", "-a"]).unwrap()
);
assert_eq!(
Opt { alice: 2, bob: 2 },
Opt::try_parse_from(&["test", "-a", "--alice", "-bb"]).unwrap()
Opt::try_parse_from(["test", "-a", "--alice", "-bb"]).unwrap()
);
assert_eq!(
Opt { alice: 3, bob: 1 },
Opt::try_parse_from(&["test", "-aaa", "--bob"]).unwrap()
Opt::try_parse_from(["test", "-aaa", "--bob"]).unwrap()
);
assert!(Opt::try_parse_from(&["test", "-i"]).is_err());
assert!(Opt::try_parse_from(&["test", "-a", "foo"]).is_err());
assert!(Opt::try_parse_from(["test", "-i"]).is_err());
assert!(Opt::try_parse_from(["test", "-a", "foo"]).is_err());
}
#[test]
@ -176,42 +173,42 @@ fn mixed_type_flags() {
alice: false,
bob: 0
},
Opt::try_parse_from(&["test"]).unwrap()
Opt::try_parse_from(["test"]).unwrap()
);
assert_eq!(
Opt {
alice: true,
bob: 0
},
Opt::try_parse_from(&["test", "-a"]).unwrap()
Opt::try_parse_from(["test", "-a"]).unwrap()
);
assert_eq!(
Opt {
alice: true,
bob: 0
},
Opt::try_parse_from(&["test", "-a"]).unwrap()
Opt::try_parse_from(["test", "-a"]).unwrap()
);
assert_eq!(
Opt {
alice: false,
bob: 1
},
Opt::try_parse_from(&["test", "-b"]).unwrap()
Opt::try_parse_from(["test", "-b"]).unwrap()
);
assert_eq!(
Opt {
alice: true,
bob: 1
},
Opt::try_parse_from(&["test", "--alice", "--bob"]).unwrap()
Opt::try_parse_from(["test", "--alice", "--bob"]).unwrap()
);
assert_eq!(
Opt {
alice: true,
bob: 4
},
Opt::try_parse_from(&["test", "-bb", "-a", "-bb"]).unwrap()
Opt::try_parse_from(["test", "-bb", "-a", "-bb"]).unwrap()
);
}
@ -240,7 +237,7 @@ fn ignore_qualified_bool_type() {
Opt {
arg: inner::bool("success".into())
},
Opt::try_parse_from(&["test", "success"]).unwrap()
Opt::try_parse_from(["test", "success"]).unwrap()
);
}
@ -254,12 +251,12 @@ fn override_implicit_action() {
assert_eq!(
Opt { arg: false },
Opt::try_parse_from(&["test", "--arg", "false"]).unwrap()
Opt::try_parse_from(["test", "--arg", "false"]).unwrap()
);
assert_eq!(
Opt { arg: true },
Opt::try_parse_from(&["test", "--arg", "true"]).unwrap()
Opt::try_parse_from(["test", "--arg", "true"]).unwrap()
);
}
@ -273,12 +270,12 @@ fn override_implicit_from_flag_positional() {
assert_eq!(
Opt { arg: false },
Opt::try_parse_from(&["test", "false"]).unwrap()
Opt::try_parse_from(["test", "false"]).unwrap()
);
assert_eq!(
Opt { arg: true },
Opt::try_parse_from(&["test", "true"]).unwrap()
Opt::try_parse_from(["test", "true"]).unwrap()
);
}
@ -297,7 +294,7 @@ fn unit_for_negation() {
arg: false,
no_arg: ()
},
Opt::try_parse_from(&["test"]).unwrap()
Opt::try_parse_from(["test"]).unwrap()
);
assert_eq!(
@ -305,7 +302,7 @@ fn unit_for_negation() {
arg: true,
no_arg: ()
},
Opt::try_parse_from(&["test", "--arg"]).unwrap()
Opt::try_parse_from(["test", "--arg"]).unwrap()
);
assert_eq!(
@ -313,7 +310,7 @@ fn unit_for_negation() {
arg: false,
no_arg: ()
},
Opt::try_parse_from(&["test", "--no-arg"]).unwrap()
Opt::try_parse_from(["test", "--no-arg"]).unwrap()
);
assert_eq!(
@ -321,7 +318,7 @@ fn unit_for_negation() {
arg: true,
no_arg: ()
},
Opt::try_parse_from(&["test", "--no-arg", "--arg"]).unwrap()
Opt::try_parse_from(["test", "--no-arg", "--arg"]).unwrap()
);
assert_eq!(
@ -329,6 +326,6 @@ fn unit_for_negation() {
arg: false,
no_arg: ()
},
Opt::try_parse_from(&["test", "--arg", "--no-arg"]).unwrap()
Opt::try_parse_from(["test", "--arg", "--no-arg"]).unwrap()
);
}

47
tests/derive/flatten.rs
View file

@ -32,10 +32,10 @@ fn flatten() {
Opt {
common: Common { arg: 42 }
},
Opt::try_parse_from(&["test", "42"]).unwrap()
Opt::try_parse_from(["test", "42"]).unwrap()
);
assert!(Opt::try_parse_from(&["test"]).is_err());
assert!(Opt::try_parse_from(&["test", "42", "24"]).is_err());
assert!(Opt::try_parse_from(["test"]).is_err());
assert!(Opt::try_parse_from(["test", "42", "24"]).is_err());
}
#[cfg(debug_assertions)]
@ -55,7 +55,7 @@ fn flatten_twice() {
#[command(flatten)]
c2: Common,
}
Opt::try_parse_from(&["test", "42", "43"]).unwrap();
Opt::try_parse_from(["test", "42", "43"]).unwrap();
}
#[test]
@ -90,14 +90,14 @@ fn flatten_in_subcommand() {
all: false,
common: Common { arg: 42 }
},
Opt::try_parse_from(&["test", "fetch", "42"]).unwrap()
Opt::try_parse_from(["test", "fetch", "42"]).unwrap()
);
assert_eq!(
Opt::Add(Add {
interactive: true,
common: Common { arg: 43 }
}),
Opt::try_parse_from(&["test", "add", "-i", "43"]).unwrap()
Opt::try_parse_from(["test", "add", "-i", "43"]).unwrap()
);
}
@ -117,14 +117,14 @@ fn update_args_with_flatten() {
let mut opt = Opt {
common: Common { arg: 42 },
};
opt.try_update_from(&["test"]).unwrap();
assert_eq!(Opt::try_parse_from(&["test", "42"]).unwrap(), opt);
opt.try_update_from(["test"]).unwrap();
assert_eq!(Opt::try_parse_from(["test", "42"]).unwrap(), opt);
let mut opt = Opt {
common: Common { arg: 42 },
};
opt.try_update_from(&["test", "52"]).unwrap();
assert_eq!(Opt::try_parse_from(&["test", "52"]).unwrap(), opt);
opt.try_update_from(["test", "52"]).unwrap();
assert_eq!(Opt::try_parse_from(["test", "52"]).unwrap(), opt);
}
#[derive(Subcommand, PartialEq, Debug)]
@ -155,35 +155,35 @@ enum Opt {
fn merge_subcommands_with_flatten() {
assert_eq!(
Opt::BaseCli(BaseCli::Command1(Command1 { arg1: 42, arg2: 44 })),
Opt::try_parse_from(&["test", "command1", "42", "44"]).unwrap()
Opt::try_parse_from(["test", "command1", "42", "44"]).unwrap()
);
assert_eq!(
Opt::Command2(Command2 { arg2: 43 }),
Opt::try_parse_from(&["test", "command2", "43"]).unwrap()
Opt::try_parse_from(["test", "command2", "43"]).unwrap()
);
}
#[test]
fn update_subcommands_with_flatten() {
let mut opt = Opt::BaseCli(BaseCli::Command1(Command1 { arg1: 12, arg2: 14 }));
opt.try_update_from(&["test", "command1", "42", "44"])
opt.try_update_from(["test", "command1", "42", "44"])
.unwrap();
assert_eq!(
Opt::try_parse_from(&["test", "command1", "42", "44"]).unwrap(),
Opt::try_parse_from(["test", "command1", "42", "44"]).unwrap(),
opt
);
let mut opt = Opt::BaseCli(BaseCli::Command1(Command1 { arg1: 12, arg2: 14 }));
opt.try_update_from(&["test", "command1", "42"]).unwrap();
opt.try_update_from(["test", "command1", "42"]).unwrap();
assert_eq!(
Opt::try_parse_from(&["test", "command1", "42", "14"]).unwrap(),
Opt::try_parse_from(["test", "command1", "42", "14"]).unwrap(),
opt
);
let mut opt = Opt::BaseCli(BaseCli::Command1(Command1 { arg1: 12, arg2: 14 }));
opt.try_update_from(&["test", "command2", "43"]).unwrap();
opt.try_update_from(["test", "command2", "43"]).unwrap();
assert_eq!(
Opt::try_parse_from(&["test", "command2", "43"]).unwrap(),
Opt::try_parse_from(["test", "command2", "43"]).unwrap(),
opt
);
}
@ -207,7 +207,7 @@ fn flatten_with_doc_comment() {
Opt {
common: Common { arg: 42 }
},
Opt::try_parse_from(&["test", "42"]).unwrap()
Opt::try_parse_from(["test", "42"]).unwrap()
);
let help = utils::get_help::<Opt>();
@ -273,10 +273,7 @@ fn optional_flatten() {
git: Option<String>,
}
assert_eq!(
Opt { source: None },
Opt::try_parse_from(&["test"]).unwrap()
);
assert_eq!(Opt { source: None }, Opt::try_parse_from(["test"]).unwrap());
assert_eq!(
Opt {
source: Some(Source {
@ -285,7 +282,7 @@ fn optional_flatten() {
git: None,
}),
},
Opt::try_parse_from(&["test", "serde"]).unwrap()
Opt::try_parse_from(["test", "serde"]).unwrap()
);
assert_eq!(
Opt {
@ -295,6 +292,6 @@ fn optional_flatten() {
git: None,
}),
},
Opt::try_parse_from(&["test", "--path=./"]).unwrap()
Opt::try_parse_from(["test", "--path=./"]).unwrap()
);
}

14
tests/derive/generic.rs
View file

@ -17,7 +17,7 @@ fn generic_struct_flatten() {
Outer {
inner: Inner { answer: 42 }
},
Outer::parse_from(&["--answer", "42"])
Outer::parse_from(["--answer", "42"])
)
}
@ -41,7 +41,7 @@ fn generic_struct_flatten_w_where_clause() {
Outer {
inner: Inner { answer: 42 }
},
Outer::parse_from(&["--answer", "42"])
Outer::parse_from(["--answer", "42"])
)
}
@ -60,7 +60,7 @@ fn generic_enum() {
assert_eq!(
GenericEnum::Start(Inner { answer: 42 }),
GenericEnum::parse_from(&["test", "start", "42"])
GenericEnum::parse_from(["test", "start", "42"])
)
}
@ -82,7 +82,7 @@ fn generic_enum_w_where_clause() {
assert_eq!(
GenericEnum::Start(Inner { answer: 42 }),
GenericEnum::parse_from(&["test", "start", "42"])
GenericEnum::parse_from(["test", "start", "42"])
)
}
@ -101,7 +101,7 @@ fn generic_w_fromstr_trait_bound() {
assert_eq!(
Opt::<isize> { answer: 42 },
Opt::<isize>::parse_from(&["--answer", "42"])
Opt::<isize>::parse_from(["--answer", "42"])
)
}
@ -121,7 +121,7 @@ fn generic_wo_trait_bound() {
answer: 42,
took: None
},
Opt::<Duration>::parse_from(&["--answer", "42"])
Opt::<Duration>::parse_from(["--answer", "42"])
)
}
@ -140,6 +140,6 @@ fn generic_where_clause_w_trailing_comma() {
assert_eq!(
Opt::<isize> { answer: 42 },
Opt::<isize>::parse_from(&["--answer", "42"])
Opt::<isize>::parse_from(["--answer", "42"])
)
}

2
tests/derive/groups.rs
View file

@ -20,7 +20,7 @@ fn test_safely_nest_parser() {
Opt {
foo: Foo { foo: true }
},
Opt::try_parse_from(&["test", "--foo"]).unwrap()
Opt::try_parse_from(["test", "--foo"]).unwrap()
);
}

2
tests/derive/help.rs
View file

@ -211,7 +211,7 @@ fn derive_generated_error_has_full_context() {
},
}
let result = Opts::try_parse_from(&["test", "sub"]);
let result = Opts::try_parse_from(["test", "sub"]);
assert!(
result.is_err(),
"`SubcommandsNegateReqs` with non-optional `req_str` should fail: {:?}",

18
tests/derive/issues.rs
View file

@ -21,11 +21,11 @@ fn issue_151_groups_within_subcommands() {
a: Opt,
}
assert!(Cli::try_parse_from(&["test"]).is_err());
assert!(Cli::try_parse_from(&["test", "--foo=v1"]).is_ok());
assert!(Cli::try_parse_from(&["test", "--bar=v2"]).is_ok());
assert!(Cli::try_parse_from(&["test", "--zebra=v3"]).is_err());
assert!(Cli::try_parse_from(&["test", "--foo=v1", "--bar=v2"]).is_ok());
assert!(Cli::try_parse_from(["test"]).is_err());
assert!(Cli::try_parse_from(["test", "--foo=v1"]).is_ok());
assert!(Cli::try_parse_from(["test", "--bar=v2"]).is_ok());
assert!(Cli::try_parse_from(["test", "--zebra=v3"]).is_err());
assert!(Cli::try_parse_from(["test", "--foo=v1", "--bar=v2"]).is_ok());
}
#[test]
@ -46,10 +46,10 @@ fn issue_289() {
TestCommand,
}
assert!(Args::try_parse_from(&["test", "some-command", "test-command"]).is_ok());
assert!(Args::try_parse_from(&["test", "some", "test-command"]).is_ok());
assert!(Args::try_parse_from(&["test", "some-command", "test"]).is_ok());
assert!(Args::try_parse_from(&["test", "some", "test"]).is_ok());
assert!(Args::try_parse_from(["test", "some-command", "test-command"]).is_ok());
assert!(Args::try_parse_from(["test", "some", "test-command"]).is_ok());
assert!(Args::try_parse_from(["test", "some-command", "test"]).is_ok());
assert!(Args::try_parse_from(["test", "some", "test"]).is_ok());
}
#[test]

54
tests/derive/naming.rs
View file

@ -12,7 +12,7 @@ fn test_standalone_long_generates_kebab_case() {
assert_eq!(
Opt { FOO_OPTION: true },
Opt::try_parse_from(&["test", "--foo-option"]).unwrap()
Opt::try_parse_from(["test", "--foo-option"]).unwrap()
);
}
@ -26,7 +26,7 @@ fn test_custom_long_overwrites_default_name() {
assert_eq!(
Opt { foo_option: true },
Opt::try_parse_from(&["test", "--foo"]).unwrap()
Opt::try_parse_from(["test", "--foo"]).unwrap()
);
}
@ -40,7 +40,7 @@ fn test_standalone_long_uses_previous_defined_custom_name() {
assert_eq!(
Opt { foo_option: true },
Opt::try_parse_from(&["test", "--foo"]).unwrap()
Opt::try_parse_from(["test", "--foo"]).unwrap()
);
}
@ -54,7 +54,7 @@ fn test_standalone_long_ignores_afterwards_defined_custom_name() {
assert_eq!(
Opt { foo_option: true },
Opt::try_parse_from(&["test", "--foo-option"]).unwrap()
Opt::try_parse_from(["test", "--foo-option"]).unwrap()
);
}
@ -68,7 +68,7 @@ fn test_standalone_long_uses_previous_defined_custom_id() {
assert_eq!(
Opt { foo_option: true },
Opt::try_parse_from(&["test", "--foo"]).unwrap()
Opt::try_parse_from(["test", "--foo"]).unwrap()
);
}
@ -82,7 +82,7 @@ fn test_standalone_long_ignores_afterwards_defined_custom_id() {
assert_eq!(
Opt { foo_option: true },
Opt::try_parse_from(&["test", "--foo-option"]).unwrap()
Opt::try_parse_from(["test", "--foo-option"]).unwrap()
);
}
@ -97,7 +97,7 @@ fn test_standalone_short_generates_kebab_case() {
assert_eq!(
Opt { FOO_OPTION: true },
Opt::try_parse_from(&["test", "-f"]).unwrap()
Opt::try_parse_from(["test", "-f"]).unwrap()
);
}
@ -111,7 +111,7 @@ fn test_custom_short_overwrites_default_name() {
assert_eq!(
Opt { foo_option: true },
Opt::try_parse_from(&["test", "-o"]).unwrap()
Opt::try_parse_from(["test", "-o"]).unwrap()
);
}
@ -125,7 +125,7 @@ fn test_standalone_short_uses_previous_defined_custom_name() {
assert_eq!(
Opt { foo_option: true },
Opt::try_parse_from(&["test", "-o"]).unwrap()
Opt::try_parse_from(["test", "-o"]).unwrap()
);
}
@ -139,7 +139,7 @@ fn test_standalone_short_ignores_afterwards_defined_custom_name() {
assert_eq!(
Opt { foo_option: true },
Opt::try_parse_from(&["test", "-f"]).unwrap()
Opt::try_parse_from(["test", "-f"]).unwrap()
);
}
@ -153,7 +153,7 @@ fn test_standalone_short_uses_previous_defined_custom_id() {
assert_eq!(
Opt { foo_option: true },
Opt::try_parse_from(&["test", "-o"]).unwrap()
Opt::try_parse_from(["test", "-o"]).unwrap()
);
}
@ -167,7 +167,7 @@ fn test_standalone_short_ignores_afterwards_defined_custom_id() {
assert_eq!(
Opt { foo_option: true },
Opt::try_parse_from(&["test", "-f"]).unwrap()
Opt::try_parse_from(["test", "-f"]).unwrap()
);
}
@ -181,7 +181,7 @@ fn test_standalone_long_uses_previous_defined_casing() {
assert_eq!(
Opt { foo_option: true },
Opt::try_parse_from(&["test", "--FOO_OPTION"]).unwrap()
Opt::try_parse_from(["test", "--FOO_OPTION"]).unwrap()
);
}
@ -195,7 +195,7 @@ fn test_standalone_short_uses_previous_defined_casing() {
assert_eq!(
Opt { foo_option: true },
Opt::try_parse_from(&["test", "-F"]).unwrap()
Opt::try_parse_from(["test", "-F"]).unwrap()
);
}
@ -210,7 +210,7 @@ fn test_standalone_long_works_with_verbatim_casing() {
assert_eq!(
Opt { _fOO_oPtiON: true },
Opt::try_parse_from(&["test", "--_fOO_oPtiON"]).unwrap()
Opt::try_parse_from(["test", "--_fOO_oPtiON"]).unwrap()
);
}
@ -224,7 +224,7 @@ fn test_standalone_short_works_with_verbatim_casing() {
assert_eq!(
Opt { _foo: true },
Opt::try_parse_from(&["test", "-_"]).unwrap()
Opt::try_parse_from(["test", "-_"]).unwrap()
);
}
@ -239,7 +239,7 @@ fn test_rename_all_is_propagated_from_struct_to_fields() {
assert_eq!(
Opt { foo: true },
Opt::try_parse_from(&["test", "--FOO"]).unwrap()
Opt::try_parse_from(["test", "--FOO"]).unwrap()
);
}
@ -262,7 +262,7 @@ fn test_rename_all_is_not_propagated_from_struct_into_flattened() {
Opt {
foo: Foo { foo: true }
},
Opt::try_parse_from(&["test", "--foo"]).unwrap()
Opt::try_parse_from(["test", "--foo"]).unwrap()
);
}
@ -276,7 +276,7 @@ fn test_lower_is_renamed() {
assert_eq!(
Opt { foo_option: true },
Opt::try_parse_from(&["test", "--foooption"]).unwrap()
Opt::try_parse_from(["test", "--foooption"]).unwrap()
);
}
@ -290,7 +290,7 @@ fn test_upper_is_renamed() {
assert_eq!(
Opt { foo_option: true },
Opt::try_parse_from(&["test", "--FOOOPTION"]).unwrap()
Opt::try_parse_from(["test", "--FOOOPTION"]).unwrap()
);
}
@ -303,7 +303,7 @@ fn test_single_word_enum_variant_is_default_renamed_into_kebab_case() {
assert_eq!(
Opt::Command { foo: 0 },
Opt::try_parse_from(&["test", "command", "0"]).unwrap()
Opt::try_parse_from(["test", "command", "0"]).unwrap()
);
}
@ -316,7 +316,7 @@ fn test_multi_word_enum_variant_is_renamed() {
assert_eq!(
Opt::FirstCommand { foo: 0 },
Opt::try_parse_from(&["test", "first-command", "0"]).unwrap()
Opt::try_parse_from(["test", "first-command", "0"]).unwrap()
);
}
@ -341,7 +341,7 @@ fn test_rename_all_is_not_propagated_from_struct_into_subcommand() {
Opt {
foo: Foo::Command { foo: true }
},
Opt::try_parse_from(&["test", "command", "--foo"]).unwrap()
Opt::try_parse_from(["test", "command", "--foo"]).unwrap()
);
}
@ -359,7 +359,7 @@ fn test_rename_all_is_propagated_from_enum_to_variants() {
assert_eq!(
Opt::FirstVariant,
Opt::try_parse_from(&["test", "FIRST_VARIANT"]).unwrap()
Opt::try_parse_from(["test", "FIRST_VARIANT"]).unwrap()
);
}
@ -379,7 +379,7 @@ fn test_rename_all_is_propagated_from_enum_to_variant_fields() {
Opt::SecondVariant {
foo: "value".into()
},
Opt::try_parse_from(&["test", "SECOND_VARIANT", "--FOO", "value"]).unwrap()
Opt::try_parse_from(["test", "SECOND_VARIANT", "--FOO", "value"]).unwrap()
);
}
@ -401,11 +401,11 @@ fn test_rename_all_is_propagation_can_be_overridden() {
assert_eq!(
Opt::FirstVariant { foo_option: true },
Opt::try_parse_from(&["test", "first-variant", "--foo-option"]).unwrap()
Opt::try_parse_from(["test", "first-variant", "--foo-option"]).unwrap()
);
assert_eq!(
Opt::SecondVariant { foo_option: true },
Opt::try_parse_from(&["test", "SECOND_VARIANT", "--foo-option"]).unwrap()
Opt::try_parse_from(["test", "SECOND_VARIANT", "--foo-option"]).unwrap()
);
}

22
tests/derive/nested_subcommands.rs
View file

@ -42,7 +42,7 @@ struct Opt2 {
#[test]
fn test_no_cmd() {
let result = Opt::try_parse_from(&["test"]);
let result = Opt::try_parse_from(["test"]);
assert!(result.is_err());
assert_eq!(
@ -51,7 +51,7 @@ fn test_no_cmd() {
verbose: 0,
cmd: None
},
Opt2::try_parse_from(&["test"]).unwrap()
Opt2::try_parse_from(["test"]).unwrap()
);
}
@ -63,7 +63,7 @@ fn test_fetch() {
verbose: 3,
cmd: Sub::Fetch {}
},
Opt::try_parse_from(&["test", "-vvv", "fetch"]).unwrap()
Opt::try_parse_from(["test", "-vvv", "fetch"]).unwrap()
);
assert_eq!(
Opt {
@ -71,7 +71,7 @@ fn test_fetch() {
verbose: 0,
cmd: Sub::Fetch {}
},
Opt::try_parse_from(&["test", "--force", "fetch"]).unwrap()
Opt::try_parse_from(["test", "--force", "fetch"]).unwrap()
);
}
@ -83,7 +83,7 @@ fn test_add() {
verbose: 0,
cmd: Sub::Add {}
},
Opt::try_parse_from(&["test", "add"]).unwrap()
Opt::try_parse_from(["test", "add"]).unwrap()
);
assert_eq!(
Opt {
@ -91,19 +91,19 @@ fn test_add() {
verbose: 2,
cmd: Sub::Add {}
},
Opt::try_parse_from(&["test", "-vv", "add"]).unwrap()
Opt::try_parse_from(["test", "-vv", "add"]).unwrap()
);
}
#[test]
fn test_badinput() {
let result = Opt::try_parse_from(&["test", "badcmd"]);
let result = Opt::try_parse_from(["test", "badcmd"]);
assert!(result.is_err());
let result = Opt::try_parse_from(&["test", "add", "--verbose"]);
let result = Opt::try_parse_from(["test", "add", "--verbose"]);
assert!(result.is_err());
let result = Opt::try_parse_from(&["test", "--badopt", "add"]);
let result = Opt::try_parse_from(["test", "--badopt", "add"]);
assert!(result.is_err());
let result = Opt::try_parse_from(&["test", "add", "--badopt"]);
let result = Opt::try_parse_from(["test", "add", "--badopt"]);
assert!(result.is_err());
}
@ -141,7 +141,7 @@ fn test_subsubcommand() {
cmd: Sub3::Quux {}
}
},
Opt3::try_parse_from(&["test", "--all", "foo", "lib.rs", "quux"]).unwrap()
Opt3::try_parse_from(["test", "--all", "foo", "lib.rs", "quux"]).unwrap()
);
}

24
tests/derive/non_literal_attributes.rs
View file

@ -50,7 +50,7 @@ fn test_slice() {
files: Vec::new(),
values: vec![],
},
Opt::try_parse_from(&["test", "-l", "1"]).unwrap()
Opt::try_parse_from(["test", "-l", "1"]).unwrap()
);
assert_eq!(
Opt {
@ -59,7 +59,7 @@ fn test_slice() {
files: Vec::new(),
values: vec![],
},
Opt::try_parse_from(&["test", "--level", "1"]).unwrap()
Opt::try_parse_from(["test", "--level", "1"]).unwrap()
);
assert_eq!(
Opt {
@ -68,7 +68,7 @@ fn test_slice() {
files: Vec::new(),
values: vec![],
},
Opt::try_parse_from(&["test", "--set-level", "1"]).unwrap()
Opt::try_parse_from(["test", "--set-level", "1"]).unwrap()
);
assert_eq!(
Opt {
@ -77,7 +77,7 @@ fn test_slice() {
files: Vec::new(),
values: vec![],
},
Opt::try_parse_from(&["test", "--lvl", "1"]).unwrap()
Opt::try_parse_from(["test", "--lvl", "1"]).unwrap()
);
}
@ -90,7 +90,7 @@ fn test_multi_args() {
files: vec!["file".to_string()],
values: vec![],
},
Opt::try_parse_from(&["test", "-l", "1", "file"]).unwrap()
Opt::try_parse_from(["test", "-l", "1", "file"]).unwrap()
);
assert_eq!(
Opt {
@ -99,13 +99,13 @@ fn test_multi_args() {
files: vec!["FILE".to_string()],
values: vec![1],
},
Opt::try_parse_from(&["test", "-l", "1", "--values", "1", "--", "FILE"]).unwrap()
Opt::try_parse_from(["test", "-l", "1", "--values", "1", "--", "FILE"]).unwrap()
);
}
#[test]
fn test_multi_args_fail() {
let result = Opt::try_parse_from(&["test", "-l", "1", "--", "FILE"]);
let result = Opt::try_parse_from(["test", "-l", "1", "--", "FILE"]);
assert!(result.is_err());
}
@ -118,9 +118,9 @@ fn test_bool() {
files: vec![],
values: vec![],
},
Opt::try_parse_from(&["test", "-l", "1", "--x=1"]).unwrap()
Opt::try_parse_from(["test", "-l", "1", "--x=1"]).unwrap()
);
let result = Opt::try_parse_from(&["test", "-l", "1", "--x", "1"]);
let result = Opt::try_parse_from(["test", "-l", "1", "--x", "1"]);
assert!(result.is_err());
assert_eq!(result.unwrap_err().kind(), ErrorKind::NoEquals);
}
@ -140,16 +140,16 @@ struct HexOpt {
fn test_parse_hex_function_path() {
assert_eq!(
HexOpt { number: 5 },
HexOpt::try_parse_from(&["test", "-n", "5"]).unwrap()
HexOpt::try_parse_from(["test", "-n", "5"]).unwrap()
);
assert_eq!(
HexOpt {
number: 0x00ab_cdef
},
HexOpt::try_parse_from(&["test", "-n", "abcdef"]).unwrap()
HexOpt::try_parse_from(["test", "-n", "abcdef"]).unwrap()
);
let err = HexOpt::try_parse_from(&["test", "-n", "gg"]).unwrap_err();
let err = HexOpt::try_parse_from(["test", "-n", "gg"]).unwrap_err();
assert!(
err.to_string().contains("invalid digit found in string"),
"{}",

114
tests/derive/options.rs
View file

@ -28,21 +28,21 @@ fn required_option() {
}
assert_eq!(
Opt { arg: 42 },
Opt::try_parse_from(&["test", "-a42"]).unwrap()
Opt::try_parse_from(["test", "-a42"]).unwrap()
);
assert_eq!(
Opt { arg: 42 },
Opt::try_parse_from(&["test", "-a", "42"]).unwrap()
Opt::try_parse_from(["test", "-a", "42"]).unwrap()
);
assert_eq!(
Opt { arg: 42 },
Opt::try_parse_from(&["test", "--arg", "42"]).unwrap()
Opt::try_parse_from(["test", "--arg", "42"]).unwrap()
);
assert_eq!(
Opt { arg: 42 },
Opt::try_parse_from(&["test", "--arg", "24", "--arg", "42"]).unwrap()
Opt::try_parse_from(["test", "--arg", "24", "--arg", "42"]).unwrap()
);
assert!(Opt::try_parse_from(&["test"]).is_err());
assert!(Opt::try_parse_from(["test"]).is_err());
}
#[test]
@ -55,13 +55,13 @@ fn option_with_default() {
}
assert_eq!(
Opt { arg: 24 },
Opt::try_parse_from(&["test", "-a24"]).unwrap()
Opt::try_parse_from(["test", "-a24"]).unwrap()
);
assert_eq!(
Opt { arg: 42 },
Opt::try_parse_from(&["test", "-a", "24", "-a", "42"]).unwrap()
Opt::try_parse_from(["test", "-a", "24", "-a", "42"]).unwrap()
);
assert_eq!(Opt { arg: 42 }, Opt::try_parse_from(&["test"]).unwrap());
assert_eq!(Opt { arg: 42 }, Opt::try_parse_from(["test"]).unwrap());
}
#[test]
@ -74,13 +74,13 @@ fn option_with_raw_default() {
}
assert_eq!(
Opt { arg: 24 },
Opt::try_parse_from(&["test", "-a24"]).unwrap()
Opt::try_parse_from(["test", "-a24"]).unwrap()
);
assert_eq!(
Opt { arg: 42 },
Opt::try_parse_from(&["test", "-a", "24", "-a", "42"]).unwrap()
Opt::try_parse_from(["test", "-a", "24", "-a", "42"]).unwrap()
);
assert_eq!(Opt { arg: 42 }, Opt::try_parse_from(&["test"]).unwrap());
assert_eq!(Opt { arg: 42 }, Opt::try_parse_from(["test"]).unwrap());
}
#[test]
@ -102,10 +102,10 @@ fn option_from_str() {
a: Option<A>,
}
assert_eq!(Opt { a: None }, Opt::try_parse_from(&["test"]).unwrap());
assert_eq!(Opt { a: None }, Opt::try_parse_from(["test"]).unwrap());
assert_eq!(
Opt { a: Some(A) },
Opt::try_parse_from(&["test", "foo"]).unwrap()
Opt::try_parse_from(["test", "foo"]).unwrap()
);
}
@ -130,11 +130,11 @@ fn vec_from_str() {
assert_eq!(
Opt { a: Vec::new() },
Opt::try_parse_from(&["test"]).unwrap()
Opt::try_parse_from(["test"]).unwrap()
);
assert_eq!(
Opt { a: vec![A] },
Opt::try_parse_from(&["test", "foo"]).unwrap()
Opt::try_parse_from(["test", "foo"]).unwrap()
);
}
@ -158,10 +158,10 @@ fn option_vec_from_str() {
a: Option<Vec<A>>,
}
assert_eq!(Opt { a: None }, Opt::try_parse_from(&["test"]).unwrap());
assert_eq!(Opt { a: None }, Opt::try_parse_from(["test"]).unwrap());
assert_eq!(
Opt { a: Some(vec![A]) },
Opt::try_parse_from(&["test", "-a", "foo"]).unwrap()
Opt::try_parse_from(["test", "-a", "foo"]).unwrap()
);
}
@ -175,13 +175,13 @@ fn option_type_is_optional() {
}
assert_eq!(
Opt { arg: Some(42) },
Opt::try_parse_from(&["test", "-a42"]).unwrap()
Opt::try_parse_from(["test", "-a42"]).unwrap()
);
assert_eq!(
Opt { arg: Some(42) },
Opt::try_parse_from(&["test", "-a", "24", "-a", "42"]).unwrap()
Opt::try_parse_from(["test", "-a", "24", "-a", "42"]).unwrap()
);
assert_eq!(Opt { arg: None }, Opt::try_parse_from(&["test"]).unwrap());
assert_eq!(Opt { arg: None }, Opt::try_parse_from(["test"]).unwrap());
}
#[test]
@ -210,7 +210,7 @@ fn required_with_option_type() {
req_str: Some(("arg").into()),
cmd: None,
},
Opt::try_parse_from(&["test", "arg"]).unwrap()
Opt::try_parse_from(["test", "arg"]).unwrap()
);
assert_eq!(
@ -218,10 +218,10 @@ fn required_with_option_type() {
req_str: None,
cmd: Some(SubCommands::ExSub { verbose: 1 }),
},
Opt::try_parse_from(&["test", "ex-sub", "-v"]).unwrap()
Opt::try_parse_from(["test", "ex-sub", "-v"]).unwrap()
);
assert!(Opt::try_parse_from(&["test"]).is_err());
assert!(Opt::try_parse_from(["test"]).is_err());
}
#[test]
@ -241,7 +241,7 @@ fn ignore_qualified_option_type() {
Opt {
arg: Some("success".into())
},
Opt::try_parse_from(&["test", "success"]).unwrap()
Opt::try_parse_from(["test", "success"]).unwrap()
);
}
@ -258,19 +258,19 @@ fn option_option_type_is_optional_value() {
Opt {
arg: Some(Some(42))
},
Opt::try_parse_from(&["test", "-a42"]).unwrap()
Opt::try_parse_from(["test", "-a42"]).unwrap()
);
assert_eq!(
Opt { arg: Some(None) },
Opt::try_parse_from(&["test", "-a"]).unwrap()
Opt::try_parse_from(["test", "-a"]).unwrap()
);
assert_eq!(
Opt {
arg: Some(Some(42))
},
Opt::try_parse_from(&["test", "-a", "24", "-a", "42"]).unwrap()
Opt::try_parse_from(["test", "-a", "24", "-a", "42"]).unwrap()
);
assert_eq!(Opt { arg: None }, Opt::try_parse_from(&["test"]).unwrap());
assert_eq!(Opt { arg: None }, Opt::try_parse_from(["test"]).unwrap());
}
#[test]
@ -302,42 +302,42 @@ fn two_option_option_types() {
arg: Some(Some(42)),
field: Some(Some("f".into()))
},
Opt::try_parse_from(&["test", "-a42", "--field", "f"]).unwrap()
Opt::try_parse_from(["test", "-a42", "--field", "f"]).unwrap()
);
assert_eq!(
Opt {
arg: Some(Some(42)),
field: Some(None)
},
Opt::try_parse_from(&["test", "-a42", "--field"]).unwrap()
Opt::try_parse_from(["test", "-a42", "--field"]).unwrap()
);
assert_eq!(
Opt {
arg: Some(None),
field: Some(None)
},
Opt::try_parse_from(&["test", "-a", "--field"]).unwrap()
Opt::try_parse_from(["test", "-a", "--field"]).unwrap()
);
assert_eq!(
Opt {
arg: Some(None),
field: Some(Some("f".into()))
},
Opt::try_parse_from(&["test", "-a", "--field", "f"]).unwrap()
Opt::try_parse_from(["test", "-a", "--field", "f"]).unwrap()
);
assert_eq!(
Opt {
arg: None,
field: Some(None)
},
Opt::try_parse_from(&["test", "--field"]).unwrap()
Opt::try_parse_from(["test", "--field"]).unwrap()
);
assert_eq!(
Opt {
arg: None,
field: None
},
Opt::try_parse_from(&["test"]).unwrap()
Opt::try_parse_from(["test"]).unwrap()
);
}
@ -351,12 +351,12 @@ fn vec_type_is_multiple_occurrences() {
}
assert_eq!(
Opt { arg: vec![24] },
Opt::try_parse_from(&["test", "-a24"]).unwrap()
Opt::try_parse_from(["test", "-a24"]).unwrap()
);
assert_eq!(Opt { arg: vec![] }, Opt::try_parse_from(&["test"]).unwrap());
assert_eq!(Opt { arg: vec![] }, Opt::try_parse_from(["test"]).unwrap());
assert_eq!(
Opt { arg: vec![24, 42] },
Opt::try_parse_from(&["test", "-a", "24", "-a", "42"]).unwrap()
Opt::try_parse_from(["test", "-a", "24", "-a", "42"]).unwrap()
);
}
@ -370,12 +370,12 @@ fn vec_type_with_required() {
}
assert_eq!(
Opt { arg: vec![24] },
Opt::try_parse_from(&["test", "-a24"]).unwrap()
Opt::try_parse_from(["test", "-a24"]).unwrap()
);
assert!(Opt::try_parse_from(&["test"]).is_err());
assert!(Opt::try_parse_from(["test"]).is_err());
assert_eq!(
Opt { arg: vec![24, 42] },
Opt::try_parse_from(&["test", "-a", "24", "-a", "42"]).unwrap()
Opt::try_parse_from(["test", "-a", "24", "-a", "42"]).unwrap()
);
}
@ -389,12 +389,12 @@ fn vec_type_with_multiple_values_only() {
}
assert_eq!(
Opt { arg: vec![24] },
Opt::try_parse_from(&["test", "-a24"]).unwrap()
Opt::try_parse_from(["test", "-a24"]).unwrap()
);
assert_eq!(Opt { arg: vec![] }, Opt::try_parse_from(&["test"]).unwrap());
assert_eq!(Opt { arg: vec![] }, Opt::try_parse_from(["test"]).unwrap());
assert_eq!(
Opt { arg: vec![24, 42] },
Opt::try_parse_from(&["test", "-a", "24", "42"]).unwrap()
Opt::try_parse_from(["test", "-a", "24", "42"]).unwrap()
);
}
@ -415,7 +415,7 @@ fn ignore_qualified_vec_type() {
Opt {
arg: vec!["success".into()]
},
Opt::try_parse_from(&["test", "success"]).unwrap()
Opt::try_parse_from(["test", "success"]).unwrap()
);
}
@ -429,17 +429,17 @@ fn option_vec_type() {
}
assert_eq!(
Opt { arg: Some(vec![1]) },
Opt::try_parse_from(&["test", "-a", "1"]).unwrap()
Opt::try_parse_from(["test", "-a", "1"]).unwrap()
);
assert_eq!(
Opt {
arg: Some(vec![1, 2])
},
Opt::try_parse_from(&["test", "-a", "1", "-a", "2"]).unwrap()
Opt::try_parse_from(["test", "-a", "1", "-a", "2"]).unwrap()
);
assert_eq!(Opt { arg: None }, Opt::try_parse_from(&["test"]).unwrap());
assert_eq!(Opt { arg: None }, Opt::try_parse_from(["test"]).unwrap());
}
#[test]
@ -452,22 +452,22 @@ fn option_vec_type_structopt_behavior() {
}
assert_eq!(
Opt { arg: Some(vec![1]) },
Opt::try_parse_from(&["test", "-a", "1"]).unwrap()
Opt::try_parse_from(["test", "-a", "1"]).unwrap()
);
assert_eq!(
Opt {
arg: Some(vec![1, 2])
},
Opt::try_parse_from(&["test", "-a", "1", "2"]).unwrap()
Opt::try_parse_from(["test", "-a", "1", "2"]).unwrap()
);
assert_eq!(
Opt { arg: Some(vec![]) },
Opt::try_parse_from(&["test", "-a"]).unwrap()
Opt::try_parse_from(["test", "-a"]).unwrap()
);
assert_eq!(Opt { arg: None }, Opt::try_parse_from(&["test"]).unwrap());
assert_eq!(Opt { arg: None }, Opt::try_parse_from(["test"]).unwrap());
}
#[test]
@ -487,7 +487,7 @@ fn two_option_vec_types() {
arg: Some(vec![1]),
b: None,
},
Opt::try_parse_from(&["test", "-a", "1"]).unwrap()
Opt::try_parse_from(["test", "-a", "1"]).unwrap()
);
assert_eq!(
@ -495,7 +495,7 @@ fn two_option_vec_types() {
arg: Some(vec![1]),
b: Some(vec![1])
},
Opt::try_parse_from(&["test", "-a", "1", "-b", "1"]).unwrap()
Opt::try_parse_from(["test", "-a", "1", "-b", "1"]).unwrap()
);
assert_eq!(
@ -503,12 +503,12 @@ fn two_option_vec_types() {
arg: Some(vec![1, 2]),
b: Some(vec![1, 2])
},
Opt::try_parse_from(&["test", "-a", "1", "-a", "2", "-b", "1", "-b", "2"]).unwrap()
Opt::try_parse_from(["test", "-a", "1", "-a", "2", "-b", "1", "-b", "2"]).unwrap()
);
assert_eq!(
Opt { arg: None, b: None },
Opt::try_parse_from(&["test"]).unwrap()
Opt::try_parse_from(["test"]).unwrap()
);
}
@ -522,7 +522,7 @@ fn explicit_value_parser() {
}
assert_eq!(
Opt { arg: 42 },
Opt::try_parse_from(&["test", "--arg", "42"]).unwrap()
Opt::try_parse_from(["test", "--arg", "42"]).unwrap()
);
}
@ -536,6 +536,6 @@ fn implicit_value_parser() {
}
assert_eq!(
Opt { arg: 42 },
Opt::try_parse_from(&["test", "--arg", "42"]).unwrap()
Opt::try_parse_from(["test", "--arg", "42"]).unwrap()
);
}

2
tests/derive/raw_bool_literal.rs
View file

@ -24,6 +24,6 @@ fn raw_bool_literal() {
a: "one".into(),
b: "--help".into()
},
Opt::try_parse_from(&["test", "one", "--", "--help"]).unwrap()
Opt::try_parse_from(["test", "one", "--", "--help"]).unwrap()
);
}

4
tests/derive/raw_idents.rs
View file

@ -12,13 +12,13 @@ fn raw_idents() {
Opt {
r#type: "long".into()
},
Opt::try_parse_from(&["test", "--type", "long"]).unwrap()
Opt::try_parse_from(["test", "--type", "long"]).unwrap()
);
assert_eq!(
Opt {
r#type: "short".into()
},
Opt::try_parse_from(&["test", "-t", "short"]).unwrap()
Opt::try_parse_from(["test", "-t", "short"]).unwrap()
);
}

14
tests/derive/skip.rs
View file

@ -18,9 +18,9 @@ fn skip_1() {
s: u32,
}
assert!(Opt::try_parse_from(&["test", "-x", "10", "20"]).is_err());
assert!(Opt::try_parse_from(["test", "-x", "10", "20"]).is_err());
let mut opt = Opt::try_parse_from(&["test", "-x", "10"]).unwrap();
let mut opt = Opt::try_parse_from(["test", "-x", "10"]).unwrap();
assert_eq!(
opt,
Opt {
@ -30,7 +30,7 @@ fn skip_1() {
);
opt.s = 42;
opt.update_from(&["test", "-x", "22"]);
opt.update_from(["test", "-x", "22"]);
assert_eq!(opt, Opt { x: 22, s: 42 });
}
@ -54,7 +54,7 @@ fn skip_2() {
}
assert_eq!(
Opt::try_parse_from(&["test", "-x", "10", "20", "30"]).unwrap(),
Opt::try_parse_from(["test", "-x", "10", "20", "30"]).unwrap(),
Opt {
x: 10,
ss: String::from(""),
@ -92,7 +92,7 @@ fn skip_enum() {
}
assert_eq!(
Opt::try_parse_from(&["test", "-n", "10"]).unwrap(),
Opt::try_parse_from(["test", "-n", "10"]).unwrap(),
Opt {
number: 10,
k: Kind::B,
@ -122,7 +122,7 @@ fn skip_help_doc_comments() {
}
assert_eq!(
Opt::try_parse_from(&["test", "-n", "10"]).unwrap(),
Opt::try_parse_from(["test", "-n", "10"]).unwrap(),
Opt {
n: 10,
a: 0,
@ -147,7 +147,7 @@ fn skip_val() {
}
assert_eq!(
Opt::try_parse_from(&["test", "-n", "10"]).unwrap(),
Opt::try_parse_from(["test", "-n", "10"]).unwrap(),
Opt {
number: 10,
k: "key".to_string(),

120
tests/derive/subcommands.rs
View file

@ -45,7 +45,7 @@ fn test_fetch() {
force: false,
repo: "origin".to_string()
},
Opt::try_parse_from(&["test", "fetch", "--all", "origin"]).unwrap()
Opt::try_parse_from(["test", "fetch", "--all", "origin"]).unwrap()
);
assert_eq!(
Opt::Fetch {
@ -53,7 +53,7 @@ fn test_fetch() {
force: true,
repo: "origin".to_string()
},
Opt::try_parse_from(&["test", "fetch", "-f", "origin"]).unwrap()
Opt::try_parse_from(["test", "fetch", "-f", "origin"]).unwrap()
);
}
@ -64,26 +64,26 @@ fn test_add() {
interactive: false,
verbose: false
},
Opt::try_parse_from(&["test", "add"]).unwrap()
Opt::try_parse_from(["test", "add"]).unwrap()
);
assert_eq!(
Opt::Add {
interactive: true,
verbose: true
},
Opt::try_parse_from(&["test", "add", "-i", "-v"]).unwrap()
Opt::try_parse_from(["test", "add", "-i", "-v"]).unwrap()
);
}
#[test]
fn test_no_parse() {
let result = Opt::try_parse_from(&["test", "badcmd", "-i", "-v"]);
let result = Opt::try_parse_from(["test", "badcmd", "-i", "-v"]);
assert!(result.is_err());
let result = Opt::try_parse_from(&["test", "add", "--badoption"]);
let result = Opt::try_parse_from(["test", "add", "--badoption"]);
assert!(result.is_err());
let result = Opt::try_parse_from(&["test"]);
let result = Opt::try_parse_from(["test"]);
assert!(result.is_err());
}
@ -100,7 +100,7 @@ fn test_hyphenated_subcommands() {
Opt2::DoSomething {
arg: "blah".to_string()
},
Opt2::try_parse_from(&["test", "do-something", "blah"]).unwrap()
Opt2::try_parse_from(["test", "do-something", "blah"]).unwrap()
);
}
@ -113,11 +113,11 @@ enum Opt3 {
#[test]
fn test_null_commands() {
assert_eq!(Opt3::Add, Opt3::try_parse_from(&["test", "add"]).unwrap());
assert_eq!(Opt3::Init, Opt3::try_parse_from(&["test", "init"]).unwrap());
assert_eq!(Opt3::Add, Opt3::try_parse_from(["test", "add"]).unwrap());
assert_eq!(Opt3::Init, Opt3::try_parse_from(["test", "init"]).unwrap());
assert_eq!(
Opt3::Fetch,
Opt3::try_parse_from(&["test", "fetch"]).unwrap()
Opt3::try_parse_from(["test", "fetch"]).unwrap()
);
}
@ -147,14 +147,14 @@ fn test_tuple_commands() {
Opt4::Add(Add {
file: "f".to_string()
}),
Opt4::try_parse_from(&["test", "add", "f"]).unwrap()
Opt4::try_parse_from(["test", "add", "f"]).unwrap()
);
assert_eq!(Opt4::Init, Opt4::try_parse_from(&["test", "init"]).unwrap());
assert_eq!(Opt4::Init, Opt4::try_parse_from(["test", "init"]).unwrap());
assert_eq!(
Opt4::Fetch(Fetch {
remote: "origin".to_string()
}),
Opt4::try_parse_from(&["test", "fetch", "origin"]).unwrap()
Opt4::try_parse_from(["test", "fetch", "origin"]).unwrap()
);
let output = utils::get_long_help::<Opt4>();
@ -187,7 +187,7 @@ fn global_passed_down() {
}
assert_eq!(
Opt::try_parse_from(&["test", "global"]).unwrap(),
Opt::try_parse_from(["test", "global"]).unwrap(),
Opt {
other: false,
sub: Subcommands::Global(GlobalCmd { other: false })
@ -195,7 +195,7 @@ fn global_passed_down() {
);
assert_eq!(
Opt::try_parse_from(&["test", "global", "--other"]).unwrap(),
Opt::try_parse_from(["test", "global", "--other"]).unwrap(),
Opt {
other: true,
sub: Subcommands::Global(GlobalCmd { other: true })
@ -220,23 +220,23 @@ fn external_subcommand() {
}
assert_eq!(
Opt::try_parse_from(&["test", "add"]).unwrap(),
Opt::try_parse_from(["test", "add"]).unwrap(),
Opt {
sub: Subcommands::Add
}
);
assert_eq!(
Opt::try_parse_from(&["test", "remove"]).unwrap(),
Opt::try_parse_from(["test", "remove"]).unwrap(),
Opt {
sub: Subcommands::Remove
}
);
assert!(Opt::try_parse_from(&["test"]).is_err());
assert!(Opt::try_parse_from(["test"]).is_err());
assert_eq!(
Opt::try_parse_from(&["test", "git", "status"]).unwrap(),
Opt::try_parse_from(["test", "git", "status"]).unwrap(),
Opt {
sub: Subcommands::Other(vec!["git".into(), "status".into()])
}
@ -260,13 +260,13 @@ fn external_subcommand_os_string() {
}
assert_eq!(
Opt::try_parse_from(&["test", "git", "status"]).unwrap(),
Opt::try_parse_from(["test", "git", "status"]).unwrap(),
Opt {
sub: Subcommands::Other(vec!["git".into(), "status".into()])
}
);
assert!(Opt::try_parse_from(&["test"]).is_err());
assert!(Opt::try_parse_from(["test"]).is_err());
}
#[test]
@ -284,13 +284,13 @@ fn external_subcommand_optional() {
}
assert_eq!(
Opt::try_parse_from(&["test", "git", "status"]).unwrap(),
Opt::try_parse_from(["test", "git", "status"]).unwrap(),
Opt {
sub: Some(Subcommands::Other(vec!["git".into(), "status".into()]))
}
);
assert_eq!(Opt::try_parse_from(&["test"]).unwrap(), Opt { sub: None });
assert_eq!(Opt::try_parse_from(["test"]).unwrap(), Opt { sub: None });
}
#[test]
@ -309,22 +309,22 @@ fn enum_in_enum_subsubcommand() {
Stop,
}
let result = Opt::try_parse_from(&["test"]);
let result = Opt::try_parse_from(["test"]);
assert!(result.is_err());
let result = Opt::try_parse_from(&["test", "list"]).unwrap();
let result = Opt::try_parse_from(["test", "list"]).unwrap();
assert_eq!(Opt::List, result);
let result = Opt::try_parse_from(&["test", "l"]).unwrap();
let result = Opt::try_parse_from(["test", "l"]).unwrap();
assert_eq!(Opt::List, result);
let result = Opt::try_parse_from(&["test", "daemon"]);
let result = Opt::try_parse_from(["test", "daemon"]);
assert!(result.is_err());
let result = Opt::try_parse_from(&["test", "daemon", "start"]).unwrap();
let result = Opt::try_parse_from(["test", "daemon", "start"]).unwrap();
assert_eq!(Opt::Daemon(DaemonCommand::Start), result);
let result = Opt::try_parse_from(&["test", "d", "start"]).unwrap();
let result = Opt::try_parse_from(["test", "d", "start"]).unwrap();
assert_eq!(Opt::Daemon(DaemonCommand::Start), result);
}
@ -350,26 +350,26 @@ fn update_subcommands() {
// Full subcommand update
let mut opt = Opt::Command1(Command1 { arg1: 12, arg2: 14 });
opt.try_update_from(&["test", "command1", "42", "44"])
opt.try_update_from(["test", "command1", "42", "44"])
.unwrap();
assert_eq!(
Opt::try_parse_from(&["test", "command1", "42", "44"]).unwrap(),
Opt::try_parse_from(["test", "command1", "42", "44"]).unwrap(),
opt
);
// Partial subcommand update
let mut opt = Opt::Command1(Command1 { arg1: 12, arg2: 14 });
opt.try_update_from(&["test", "command1", "42"]).unwrap();
opt.try_update_from(["test", "command1", "42"]).unwrap();
assert_eq!(
Opt::try_parse_from(&["test", "command1", "42", "14"]).unwrap(),
Opt::try_parse_from(["test", "command1", "42", "14"]).unwrap(),
opt
);
// Change subcommand
let mut opt = Opt::Command1(Command1 { arg1: 12, arg2: 14 });
opt.try_update_from(&["test", "command2", "43"]).unwrap();
opt.try_update_from(["test", "command2", "43"]).unwrap();
assert_eq!(
Opt::try_parse_from(&["test", "command2", "43"]).unwrap(),
Opt::try_parse_from(["test", "command2", "43"]).unwrap(),
opt
);
}
@ -410,37 +410,37 @@ fn update_sub_subcommands() {
// Full subcommand update
let mut opt = Opt::Child1(Child1::Command1(Command1 { arg1: 12, arg2: 14 }));
opt.try_update_from(&["test", "child1", "command1", "42", "44"])
opt.try_update_from(["test", "child1", "command1", "42", "44"])
.unwrap();
assert_eq!(
Opt::try_parse_from(&["test", "child1", "command1", "42", "44"]).unwrap(),
Opt::try_parse_from(["test", "child1", "command1", "42", "44"]).unwrap(),
opt
);
// Partial subcommand update
let mut opt = Opt::Child1(Child1::Command1(Command1 { arg1: 12, arg2: 14 }));
opt.try_update_from(&["test", "child1", "command1", "42"])
opt.try_update_from(["test", "child1", "command1", "42"])
.unwrap();
assert_eq!(
Opt::try_parse_from(&["test", "child1", "command1", "42", "14"]).unwrap(),
Opt::try_parse_from(["test", "child1", "command1", "42", "14"]).unwrap(),
opt
);
// Partial subcommand update
let mut opt = Opt::Child1(Child1::Command1(Command1 { arg1: 12, arg2: 14 }));
opt.try_update_from(&["test", "child1", "command2", "43"])
opt.try_update_from(["test", "child1", "command2", "43"])
.unwrap();
assert_eq!(
Opt::try_parse_from(&["test", "child1", "command2", "43"]).unwrap(),
Opt::try_parse_from(["test", "child1", "command2", "43"]).unwrap(),
opt
);
// Change subcommand
let mut opt = Opt::Child1(Child1::Command1(Command1 { arg1: 12, arg2: 14 }));
opt.try_update_from(&["test", "child2", "command2", "43"])
opt.try_update_from(["test", "child2", "command2", "43"])
.unwrap();
assert_eq!(
Opt::try_parse_from(&["test", "child2", "command2", "43"]).unwrap(),
Opt::try_parse_from(["test", "child2", "command2", "43"]).unwrap(),
opt
);
}
@ -469,29 +469,29 @@ fn update_ext_subcommand() {
// Full subcommand update
let mut opt = Opt::Ext(vec!["12".into(), "14".into()]);
opt.try_update_from(&["test", "ext", "42", "44"]).unwrap();
opt.try_update_from(["test", "ext", "42", "44"]).unwrap();
assert_eq!(
Opt::try_parse_from(&["test", "ext", "42", "44"]).unwrap(),
Opt::try_parse_from(["test", "ext", "42", "44"]).unwrap(),
opt
);
// No partial subcommand update
let mut opt = Opt::Ext(vec!["12".into(), "14".into()]);
opt.try_update_from(&["test", "ext", "42"]).unwrap();
assert_eq!(Opt::try_parse_from(&["test", "ext", "42"]).unwrap(), opt);
opt.try_update_from(["test", "ext", "42"]).unwrap();
assert_eq!(Opt::try_parse_from(["test", "ext", "42"]).unwrap(), opt);
// Change subcommand
let mut opt = Opt::Ext(vec!["12".into(), "14".into()]);
opt.try_update_from(&["test", "command2", "43"]).unwrap();
opt.try_update_from(["test", "command2", "43"]).unwrap();
assert_eq!(
Opt::try_parse_from(&["test", "command2", "43"]).unwrap(),
Opt::try_parse_from(["test", "command2", "43"]).unwrap(),
opt
);
let mut opt = Opt::Command1(Command1 { arg1: 12, arg2: 14 });
opt.try_update_from(&["test", "ext", "42", "44"]).unwrap();
opt.try_update_from(["test", "ext", "42", "44"]).unwrap();
assert_eq!(
Opt::try_parse_from(&["test", "ext", "42", "44"]).unwrap(),
Opt::try_parse_from(["test", "ext", "42", "44"]).unwrap(),
opt
);
}
@ -513,7 +513,7 @@ fn subcommand_name_not_literal() {
SubCmd1,
}
assert!(Opt::try_parse_from(&["test", "renamed"]).is_ok());
assert!(Opt::try_parse_from(["test", "renamed"]).is_ok());
}
#[test]
@ -551,26 +551,26 @@ fn skip_subcommand() {
assert!(!Subcommands::has_subcommand("other"));
assert_eq!(
Opt::try_parse_from(&["test", "add"]).unwrap(),
Opt::try_parse_from(["test", "add"]).unwrap(),
Opt {
sub: Subcommands::Add
}
);
assert_eq!(
Opt::try_parse_from(&["test", "remove"]).unwrap(),
Opt::try_parse_from(["test", "remove"]).unwrap(),
Opt {
sub: Subcommands::Remove
}
);
let res = Opt::try_parse_from(&["test", "skip"]);
let res = Opt::try_parse_from(["test", "skip"]);
assert_eq!(
res.unwrap_err().kind(),
clap::error::ErrorKind::InvalidSubcommand,
);
let res = Opt::try_parse_from(&["test", "other"]);
let res = Opt::try_parse_from(["test", "other"]);
assert_eq!(
res.unwrap_err().kind(),
clap::error::ErrorKind::InvalidSubcommand,
@ -589,17 +589,17 @@ fn built_in_subcommand_escaped() {
}
assert_eq!(
Command::try_parse_from(&["test", "install", "arg"]).unwrap(),
Command::try_parse_from(["test", "install", "arg"]).unwrap(),
Command::Install {
arg: Some(String::from("arg"))
}
);
assert_eq!(
Command::try_parse_from(&["test", "--", "install"]).unwrap(),
Command::try_parse_from(["test", "--", "install"]).unwrap(),
Command::Custom(vec![String::from("install")])
);
assert_eq!(
Command::try_parse_from(&["test", "--", "install", "arg"]).unwrap(),
Command::try_parse_from(["test", "--", "install", "arg"]).unwrap(),
Command::Custom(vec![String::from("install"), String::from("arg")])
);
}

104
tests/derive/value_enum.rs
View file

@ -27,15 +27,15 @@ fn basic() {
Opt {
arg: ArgChoice::Foo
},
Opt::try_parse_from(&["", "foo"]).unwrap()
Opt::try_parse_from(["", "foo"]).unwrap()
);
assert_eq!(
Opt {
arg: ArgChoice::Bar
},
Opt::try_parse_from(&["", "bar"]).unwrap()
Opt::try_parse_from(["", "bar"]).unwrap()
);
assert!(Opt::try_parse_from(&["", "fOo"]).is_err());
assert!(Opt::try_parse_from(["", "fOo"]).is_err());
}
#[test]
@ -62,19 +62,19 @@ fn default_value() {
Opt {
arg: ArgChoice::Foo
},
Opt::try_parse_from(&["", "foo"]).unwrap()
Opt::try_parse_from(["", "foo"]).unwrap()
);
assert_eq!(
Opt {
arg: ArgChoice::Bar
},
Opt::try_parse_from(&["", "bar"]).unwrap()
Opt::try_parse_from(["", "bar"]).unwrap()
);
assert_eq!(
Opt {
arg: ArgChoice::Bar
},
Opt::try_parse_from(&[""]).unwrap()
Opt::try_parse_from([""]).unwrap()
);
}
@ -104,28 +104,28 @@ fn vec_for_default_values_t() {
arg1: vec![ArgChoice::Foo],
arg2: vec![ArgChoice::Foo, ArgChoice::Bar]
},
Opt::try_parse_from(&["", "foo"]).unwrap()
Opt::try_parse_from(["", "foo"]).unwrap()
);
assert_eq!(
Opt {
arg1: vec![ArgChoice::Bar],
arg2: vec![ArgChoice::Foo, ArgChoice::Bar]
},
Opt::try_parse_from(&["", "bar"]).unwrap()
Opt::try_parse_from(["", "bar"]).unwrap()
);
assert_eq!(
Opt {
arg1: vec![ArgChoice::Foo, ArgChoice::Bar],
arg2: vec![ArgChoice::Foo, ArgChoice::Bar]
},
Opt::try_parse_from(&[""]).unwrap()
Opt::try_parse_from([""]).unwrap()
);
assert_eq!(
Opt {
arg1: vec![ArgChoice::Foo, ArgChoice::Bar],
arg2: vec![ArgChoice::Foo]
},
Opt::try_parse_from(&["", "--arg2", "foo"]).unwrap()
Opt::try_parse_from(["", "--arg2", "foo"]).unwrap()
);
}
@ -155,28 +155,28 @@ fn vec_for_default_values_os_t() {
arg: vec![ArgChoice::Foo],
arg2: vec![ArgChoice::Foo, ArgChoice::Bar]
},
Opt::try_parse_from(&["", "foo"]).unwrap()
Opt::try_parse_from(["", "foo"]).unwrap()
);
assert_eq!(
Opt {
arg: vec![ArgChoice::Bar],
arg2: vec![ArgChoice::Foo, ArgChoice::Bar]
},
Opt::try_parse_from(&["", "bar"]).unwrap()
Opt::try_parse_from(["", "bar"]).unwrap()
);
assert_eq!(
Opt {
arg: vec![ArgChoice::Foo, ArgChoice::Bar],
arg2: vec![ArgChoice::Foo, ArgChoice::Bar]
},
Opt::try_parse_from(&[""]).unwrap()
Opt::try_parse_from([""]).unwrap()
);
assert_eq!(
Opt {
arg: vec![ArgChoice::Foo, ArgChoice::Bar],
arg2: vec![ArgChoice::Foo]
},
Opt::try_parse_from(&["", "--arg2", "foo"]).unwrap()
Opt::try_parse_from(["", "--arg2", "foo"]).unwrap()
);
}
@ -199,15 +199,15 @@ fn multi_word_is_renamed_kebab() {
Opt {
arg: ArgChoice::FooBar
},
Opt::try_parse_from(&["", "foo-bar"]).unwrap()
Opt::try_parse_from(["", "foo-bar"]).unwrap()
);
assert_eq!(
Opt {
arg: ArgChoice::BAR_BAZ
},
Opt::try_parse_from(&["", "bar-baz"]).unwrap()
Opt::try_parse_from(["", "bar-baz"]).unwrap()
);
assert!(Opt::try_parse_from(&["", "FooBar"]).is_err());
assert!(Opt::try_parse_from(["", "FooBar"]).is_err());
}
#[test]
@ -228,9 +228,9 @@ fn variant_with_defined_casing() {
Opt {
arg: ArgChoice::FooBar
},
Opt::try_parse_from(&["", "FOO_BAR"]).unwrap()
Opt::try_parse_from(["", "FOO_BAR"]).unwrap()
);
assert!(Opt::try_parse_from(&["", "FooBar"]).is_err());
assert!(Opt::try_parse_from(["", "FooBar"]).is_err());
}
#[test]
@ -251,9 +251,9 @@ fn casing_is_propagated_from_parent() {
Opt {
arg: ArgChoice::FooBar
},
Opt::try_parse_from(&["", "FOO_BAR"]).unwrap()
Opt::try_parse_from(["", "FOO_BAR"]).unwrap()
);
assert!(Opt::try_parse_from(&["", "FooBar"]).is_err());
assert!(Opt::try_parse_from(["", "FooBar"]).is_err());
}
#[test]
@ -275,10 +275,10 @@ fn casing_propagation_is_overridden() {
Opt {
arg: ArgChoice::FooBar
},
Opt::try_parse_from(&["", "fooBar"]).unwrap()
Opt::try_parse_from(["", "fooBar"]).unwrap()
);
assert!(Opt::try_parse_from(&["", "FooBar"]).is_err());
assert!(Opt::try_parse_from(&["", "FOO_BAR"]).is_err());
assert!(Opt::try_parse_from(["", "FooBar"]).is_err());
assert!(Opt::try_parse_from(["", "FOO_BAR"]).is_err());
}
#[test]
@ -298,13 +298,13 @@ fn ignore_case() {
Opt {
arg: ArgChoice::Foo
},
Opt::try_parse_from(&["", "foo"]).unwrap()
Opt::try_parse_from(["", "foo"]).unwrap()
);
assert_eq!(
Opt {
arg: ArgChoice::Foo
},
Opt::try_parse_from(&["", "fOo"]).unwrap()
Opt::try_parse_from(["", "fOo"]).unwrap()
);
}
@ -325,9 +325,9 @@ fn ignore_case_set_to_false() {
Opt {
arg: ArgChoice::Foo
},
Opt::try_parse_from(&["", "foo"]).unwrap()
Opt::try_parse_from(["", "foo"]).unwrap()
);
assert!(Opt::try_parse_from(&["", "fOo"]).is_err());
assert!(Opt::try_parse_from(["", "fOo"]).is_err());
}
#[test]
@ -348,13 +348,13 @@ fn alias() {
Opt {
arg: ArgChoice::Totp
},
Opt::try_parse_from(&["", "totp"]).unwrap()
Opt::try_parse_from(["", "totp"]).unwrap()
);
assert_eq!(
Opt {
arg: ArgChoice::Totp
},
Opt::try_parse_from(&["", "TOTP"]).unwrap()
Opt::try_parse_from(["", "TOTP"]).unwrap()
);
}
@ -376,19 +376,19 @@ fn multiple_alias() {
Opt {
arg: ArgChoice::Totp
},
Opt::try_parse_from(&["", "totp"]).unwrap()
Opt::try_parse_from(["", "totp"]).unwrap()
);
assert_eq!(
Opt {
arg: ArgChoice::Totp
},
Opt::try_parse_from(&["", "TOTP"]).unwrap()
Opt::try_parse_from(["", "TOTP"]).unwrap()
);
assert_eq!(
Opt {
arg: ArgChoice::Totp
},
Opt::try_parse_from(&["", "t"]).unwrap()
Opt::try_parse_from(["", "t"]).unwrap()
);
}
@ -481,20 +481,20 @@ fn option_type() {
arg: Option<ArgChoice>,
}
assert_eq!(Opt { arg: None }, Opt::try_parse_from(&[""]).unwrap());
assert_eq!(Opt { arg: None }, Opt::try_parse_from([""]).unwrap());
assert_eq!(
Opt {
arg: Some(ArgChoice::Foo)
},
Opt::try_parse_from(&["", "foo"]).unwrap()
Opt::try_parse_from(["", "foo"]).unwrap()
);
assert_eq!(
Opt {
arg: Some(ArgChoice::Bar)
},
Opt::try_parse_from(&["", "bar"]).unwrap()
Opt::try_parse_from(["", "bar"]).unwrap()
);
assert!(Opt::try_parse_from(&["", "fOo"]).is_err());
assert!(Opt::try_parse_from(["", "fOo"]).is_err());
}
#[test]
@ -511,24 +511,24 @@ fn option_option_type() {
arg: Option<Option<ArgChoice>>,
}
assert_eq!(Opt { arg: None }, Opt::try_parse_from(&[""]).unwrap());
assert_eq!(Opt { arg: None }, Opt::try_parse_from([""]).unwrap());
assert_eq!(
Opt { arg: Some(None) },
Opt::try_parse_from(&["", "--arg"]).unwrap()
Opt::try_parse_from(["", "--arg"]).unwrap()
);
assert_eq!(
Opt {
arg: Some(Some(ArgChoice::Foo))
},
Opt::try_parse_from(&["", "--arg", "foo"]).unwrap()
Opt::try_parse_from(["", "--arg", "foo"]).unwrap()
);
assert_eq!(
Opt {
arg: Some(Some(ArgChoice::Bar))
},
Opt::try_parse_from(&["", "--arg", "bar"]).unwrap()
Opt::try_parse_from(["", "--arg", "bar"]).unwrap()
);
assert!(Opt::try_parse_from(&["", "--arg", "fOo"]).is_err());
assert!(Opt::try_parse_from(["", "--arg", "fOo"]).is_err());
}
#[test]
@ -545,20 +545,20 @@ fn vec_type() {
arg: Vec<ArgChoice>,
}
assert_eq!(Opt { arg: vec![] }, Opt::try_parse_from(&[""]).unwrap());
assert_eq!(Opt { arg: vec![] }, Opt::try_parse_from([""]).unwrap());
assert_eq!(
Opt {
arg: vec![ArgChoice::Foo]
},
Opt::try_parse_from(&["", "-a", "foo"]).unwrap()
Opt::try_parse_from(["", "-a", "foo"]).unwrap()
);
assert_eq!(
Opt {
arg: vec![ArgChoice::Foo, ArgChoice::Bar]
},
Opt::try_parse_from(&["", "-a", "foo", "-a", "bar"]).unwrap()
Opt::try_parse_from(["", "-a", "foo", "-a", "bar"]).unwrap()
);
assert!(Opt::try_parse_from(&["", "-a", "fOo"]).is_err());
assert!(Opt::try_parse_from(["", "-a", "fOo"]).is_err());
}
#[test]
@ -575,20 +575,20 @@ fn option_vec_type() {
arg: Option<Vec<ArgChoice>>,
}
assert_eq!(Opt { arg: None }, Opt::try_parse_from(&[""]).unwrap());
assert_eq!(Opt { arg: None }, Opt::try_parse_from([""]).unwrap());
assert_eq!(
Opt {
arg: Some(vec![ArgChoice::Foo])
},
Opt::try_parse_from(&["", "-a", "foo"]).unwrap()
Opt::try_parse_from(["", "-a", "foo"]).unwrap()
);
assert_eq!(
Opt {
arg: Some(vec![ArgChoice::Foo, ArgChoice::Bar])
},
Opt::try_parse_from(&["", "-a", "foo", "-a", "bar"]).unwrap()
Opt::try_parse_from(["", "-a", "foo", "-a", "bar"]).unwrap()
);
assert!(Opt::try_parse_from(&["", "-a", "fOo"]).is_err());
assert!(Opt::try_parse_from(["", "-a", "fOo"]).is_err());
}
#[test]
@ -616,13 +616,13 @@ fn vec_type_default_value() {
Opt {
arg: vec![ArgChoice::Foo, ArgChoice::Bar]
},
Opt::try_parse_from(&[""]).unwrap()
Opt::try_parse_from([""]).unwrap()
);
assert_eq!(
Opt {
arg: vec![ArgChoice::Foo, ArgChoice::Baz]
},
Opt::try_parse_from(&["", "-a", "foo,baz"]).unwrap()
Opt::try_parse_from(["", "-a", "foo,baz"]).unwrap()
);
}