From 5e20a29b4fdc8a2d442d1093681b396dcb4b816b Mon Sep 17 00:00:00 2001 From: Robin Krahl Date: Tue, 7 Jan 2020 11:18:04 +0000 Subject: Add structopt dependency in version 0.3.7 This patch series replaces argparse with structopt in the argument handling code. As a first step, we need structopt as a dependency. Import subrepo structopt/:structopt at efbdda4753592e27bc430fb01f7b9650b2f3174d Import subrepo bitflags/:bitflags at 30668016aca6bd3b02c766e8347e0b4080d4c296 Import subrepo clap/:clap at 784524f7eb193e35f81082cc69454c8c21b948f7 Import subrepo heck/:heck at 093d56fbf001e1506e56dbfa38631d99b1066df1 Import subrepo proc-macro-error/:proc-macro-error at 6c4cfe79a622c5de8ae68557993542be46eacae2 Import subrepo proc-macro2/:proc-macro2 at d5d48eddca4566e5438e8a2cbed4a74e049544de Import subrepo quote/:quote at 727436c6c137b20f0f34dde5d8fda2679b9747ad Import subrepo rustversion/:rustversion at 0c5663313516263059ce9059ef81fc7a1cf655ca Import subrepo syn-mid/:syn-mid at 5d3d85414a9e6674e1857ec22a87b96e04a6851a Import subrepo syn/:syn at e87c27e87f6f4ef8919d0372bdb056d53ef0d8f3 Import subrepo textwrap/:textwrap at abcd618beae3f74841032aa5b53c1086b0a57ca2 Import subrepo unicode-segmentation/:unicode-segmentation at 637c9874c4fe0c205ff27787faf150a40295c6c3 Import subrepo unicode-width/:unicode-width at 3033826f8bf05e82724140a981d5941e48fce393 Import subrepo unicode-xid/:unicode-xid at 4baae9fffb156ba229665b972a9cd5991787ceb7 --- clap/tests/multiple_values.rs | 1122 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1122 insertions(+) create mode 100644 clap/tests/multiple_values.rs (limited to 'clap/tests/multiple_values.rs') diff --git a/clap/tests/multiple_values.rs b/clap/tests/multiple_values.rs new file mode 100644 index 0000000..551aff1 --- /dev/null +++ b/clap/tests/multiple_values.rs @@ -0,0 +1,1122 @@ +extern crate clap; + +use clap::{App, Arg, ErrorKind, SubCommand}; + +#[test] +fn option_long() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .long("option") + .help("multiple options") + .takes_value(true) + .multiple(true)) + .get_matches_from_safe(vec![ + "", + "--option", "val1", + "--option", "val2", + "--option", "val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 3); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn option_short() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .takes_value(true) + .multiple(true)) + .get_matches_from_safe(vec![ + "", + "-o", "val1", + "-o", "val2", + "-o", "val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 3); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn option_mixed() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .long("option") + .short("o") + .help("multiple options") + .takes_value(true) + .multiple(true)) + .get_matches_from_safe(vec![ + "", + "-o", "val1", + "--option", "val2", + "--option", "val3", + "-o", "val4", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 4); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3", "val4"]); +} + +#[test] +fn option_exact_exact() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .takes_value(true) + .multiple(true) + .number_of_values(3)) + .get_matches_from_safe(vec![ + "", + "-o", "val1", + "-o", "val2", + "-o", "val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 3); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn option_exact_exact_not_mult() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .takes_value(true) + .number_of_values(3)) + .get_matches_from_safe(vec![ + "", + "-o", "val1", "val2", "val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn option_exact_exact_mult() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .takes_value(true) + .multiple(true) + .number_of_values(3)) + .get_matches_from_safe(vec![ + "", + "-o", "val1", "val2", "val3", + "-o", "val4", "val5", "val6", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 2); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3", "val4", "val5", "val6"]); +} + +#[test] +fn option_exact_less() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .takes_value(true) + .multiple(true) + .number_of_values(3)) + .get_matches_from_safe(vec![ + "", + "-o", "val1", + "-o", "val2", + ]); + + assert!(m.is_err()); + assert_eq!(m.unwrap_err().kind, ErrorKind::WrongNumberOfValues); +} + +#[test] +fn option_exact_more() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .takes_value(true) + .multiple(true) + .number_of_values(3)) + .get_matches_from_safe(vec![ + "", + "-o", "val1", + "-o", "val2", + "-o", "val3", + "-o", "val4", + ]); + + assert!(m.is_err()); + assert_eq!(m.unwrap_err().kind, ErrorKind::WrongNumberOfValues); +} + +#[test] +fn option_min_exact() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .takes_value(true) + .multiple(true) + .min_values(3)) + .get_matches_from_safe(vec![ + "", + "-o", "val1", + "-o", "val2", + "-o", "val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 3); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn option_min_less() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .takes_value(true) + .multiple(true) + .min_values(3)) + .get_matches_from_safe(vec![ + "", + "-o", "val1", + "-o", "val2", + ]); + + assert!(m.is_err()); + assert_eq!(m.unwrap_err().kind, ErrorKind::TooFewValues); +} + +#[test] +fn option_short_min_more_mult_occurs() { + let m = App::new("multiple_values") + .arg(Arg::with_name("arg") + .required(true)) + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .takes_value(true) + .multiple(true) + .min_values(3)) + .get_matches_from_safe(vec![ + "", + "pos", + "-o", "val1", + "-o", "val2", + "-o", "val3", + "-o", "val4", + ]); + + let m = m.map_err(|e| println!("failed to unwrap err with error kind {:?}", e.kind)).unwrap(); + + assert!(m.is_present("option")); + assert!(m.is_present("arg")); + assert_eq!(m.occurrences_of("option"), 4); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3", "val4"]); + assert_eq!(m.value_of("arg"), Some("pos")); +} + +#[test] +fn option_short_min_more_single_occur() { + let m = App::new("multiple_values") + .arg(Arg::with_name("arg") + .required(true)) + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .takes_value(true) + .multiple(true) + .min_values(3)) + .get_matches_from_safe(vec![ + "", + "pos", + "-o", "val1", + "val2", + "val3", + "val4", + ]); + + let m = m.map_err(|e| println!("failed to unwrap err with error kind {:#?}", e)).unwrap(); + + assert!(m.is_present("option")); + assert!(m.is_present("arg")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3", "val4"]); + assert_eq!(m.value_of("arg"), Some("pos")); +} + +#[test] +fn option_max_exact() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .takes_value(true) + .multiple(true) + .max_values(3)) + .get_matches_from_safe(vec![ + "", + "-o", "val1", + "-o", "val2", + "-o", "val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 3); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn option_max_less() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .takes_value(true) + .multiple(true) + .max_values(3)) + .get_matches_from_safe(vec![ + "", + "-o", "val1", + "-o", "val2", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 2); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2"]); +} + +#[test] +fn option_max_more() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .takes_value(true) + .multiple(true) + .max_values(3)) + .get_matches_from_safe(vec![ + "", + "-o", "val1", + "-o", "val2", + "-o", "val3", + "-o", "val4", + ]); + + assert!(m.is_err()); + assert_eq!(m.unwrap_err().kind, ErrorKind::TooManyValues); +} + +#[test] +fn positional() { + let m = App::new("multiple_values") + .arg(Arg::with_name("pos") + .help("multiple positionals") + .multiple(true)) + .get_matches_from_safe(vec!["myprog", "val1", "val2", "val3"]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("pos")); + assert_eq!(m.occurrences_of("pos"), 3); + assert_eq!(m.values_of("pos").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn positional_exact_exact() { + let m = App::new("multiple_values") + .arg(Arg::with_name("pos") + .help("multiple positionals") + .number_of_values(3)) + .get_matches_from_safe(vec!["myprog", "val1", "val2", "val3"]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("pos")); + assert_eq!(m.occurrences_of("pos"), 3); + assert_eq!(m.values_of("pos").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn positional_exact_less() { + let m = App::new("multiple_values") + .arg(Arg::with_name("pos") + .help("multiple positionals") + .number_of_values(3)) + .get_matches_from_safe(vec!["myprog", "val1", "val2"]); + + assert!(m.is_err()); + assert_eq!(m.unwrap_err().kind, ErrorKind::WrongNumberOfValues); +} + +#[test] +fn positional_exact_more() { + let m = App::new("multiple_values") + .arg(Arg::with_name("pos") + .help("multiple positionals") + .number_of_values(3)) + .get_matches_from_safe(vec!["myprog", "val1", "val2", "val3", "val4"]); + + assert!(m.is_err()); + assert_eq!(m.unwrap_err().kind, ErrorKind::WrongNumberOfValues); +} + +#[test] +fn positional_min_exact() { + let m = App::new("multiple_values") + .arg(Arg::with_name("pos") + .help("multiple positionals") + .min_values(3)) + .get_matches_from_safe(vec!["myprog", "val1", "val2", "val3"]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("pos")); + assert_eq!(m.occurrences_of("pos"), 3); + assert_eq!(m.values_of("pos").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn positional_min_less() { + let m = App::new("multiple_values") + .arg(Arg::with_name("pos") + .help("multiple positionals") + .min_values(3)) + .get_matches_from_safe(vec!["myprog", "val1", "val2"]); + + assert!(m.is_err()); + assert_eq!(m.unwrap_err().kind, ErrorKind::TooFewValues); +} + +#[test] +fn positional_min_more() { + let m = App::new("multiple_values") + .arg(Arg::with_name("pos") + .help("multiple positionals") + .min_values(3)) + .get_matches_from_safe(vec!["myprog", "val1", "val2", "val3", "val4"]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("pos")); + assert_eq!(m.occurrences_of("pos"), 4); + assert_eq!(m.values_of("pos").unwrap().collect::>(), ["val1", "val2", "val3", "val4"]); +} + +#[test] +fn positional_max_exact() { + let m = App::new("multiple_values") + .arg(Arg::with_name("pos") + .help("multiple positionals") + .max_values(3)) + .get_matches_from_safe(vec!["myprog", "val1", "val2", "val3"]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("pos")); + assert_eq!(m.occurrences_of("pos"), 3); + assert_eq!(m.values_of("pos").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn positional_max_less() { + let m = App::new("multiple_values") + .arg(Arg::with_name("pos") + .help("multiple positionals") + .max_values(3)) + .get_matches_from_safe(vec!["myprog", "val1", "val2"]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("pos")); + assert_eq!(m.occurrences_of("pos"), 2); + assert_eq!(m.values_of("pos").unwrap().collect::>(), ["val1", "val2"]); +} + +#[test] +fn positional_max_more() { + let m = App::new("multiple_values") + .arg(Arg::with_name("pos") + .help("multiple positionals") + .max_values(3)) + .get_matches_from_safe(vec!["myprog", "val1", "val2", "val3", "val4"]); + + assert!(m.is_err()); + assert_eq!(m.unwrap_err().kind, ErrorKind::TooManyValues); +} + +#[test] +fn sep_long_equals() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .long("option") + .use_delimiter(true) + .help("multiple options") + .takes_value(true) + .multiple(true)) + .get_matches_from_safe(vec![ + "", + "--option=val1,val2,val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn sep_long_space() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .long("option") + .use_delimiter(true) + .help("multiple options") + .takes_value(true) + .multiple(true)) + .get_matches_from_safe(vec![ + "", + "--option", + "val1,val2,val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn sep_short_equals() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .use_delimiter(true) + .takes_value(true) + .multiple(true)) + .get_matches_from_safe(vec![ + "", + "-o=val1,val2,val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn sep_short_space() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .use_delimiter(true) + .takes_value(true) + .multiple(true)) + .get_matches_from_safe(vec![ + "", + "-o", + "val1,val2,val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn sep_short_no_space() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .help("multiple options") + .use_delimiter(true) + .takes_value(true) + .multiple(true)) + .get_matches_from_safe(vec![ + "", + "-oval1,val2,val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn sep_positional() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .help("multiple options") + .use_delimiter(true) + .multiple(true)) + .get_matches_from_safe(vec![ + "", + "val1,val2,val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn different_sep() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .long("option") + .help("multiple options") + .takes_value(true) + .value_delimiter(";")) + .get_matches_from_safe(vec![ + "", + "--option=val1;val2;val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn different_sep_positional() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .help("multiple options") + .value_delimiter(";")) + .get_matches_from_safe(vec![ + "", + "val1;val2;val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.values_of("option").unwrap().collect::>(), ["val1", "val2", "val3"]); +} + +#[test] +fn no_sep() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .long("option") + .help("multiple options") + .takes_value(true) + .use_delimiter(false)) + .get_matches_from_safe(vec![ + "", + "--option=val1,val2,val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.value_of("option").unwrap(), "val1,val2,val3"); +} + +#[test] +fn no_sep_positional() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .help("multiple options") + .use_delimiter(false)) + .get_matches_from_safe(vec![ + "", + "val1,val2,val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.value_of("option").unwrap(), "val1,val2,val3"); +} + +#[test] +fn req_delimiter_long() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .long("option") + .multiple(true) + .use_delimiter(true) + .require_delimiter(true) + .takes_value(true)) + .arg(Arg::with_name("args") + .multiple(true) + .index(1)) + .get_matches_from_safe(vec![ + "", + "--option", "val1", "val2", "val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.values_of("option").unwrap().collect::>(), &["val1"]); + assert_eq!(m.values_of("args").unwrap().collect::>(), &["val2", "val3"]); +} + +#[test] +fn req_delimiter_long_with_equal() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .long("option") + .multiple(true) + .use_delimiter(true) + .require_delimiter(true) + .takes_value(true)) + .arg(Arg::with_name("args") + .multiple(true) + .index(1)) + .get_matches_from_safe(vec![ + "", + "--option=val1", "val2", "val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.values_of("option").unwrap().collect::>(), &["val1"]); + assert_eq!(m.values_of("args").unwrap().collect::>(), &["val2", "val3"]); +} + +#[test] +fn req_delimiter_short_with_space() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .multiple(true) + .use_delimiter(true) + .require_delimiter(true) + .takes_value(true)) + .arg(Arg::with_name("args") + .multiple(true) + .index(1)) + .get_matches_from_safe(vec![ + "", + "-o", "val1", "val2", "val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.values_of("option").unwrap().collect::>(), &["val1"]); + assert_eq!(m.values_of("args").unwrap().collect::>(), &["val2", "val3"]); +} + +#[test] +fn req_delimiter_short_with_no_space() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("o") + .multiple(true) + .use_delimiter(true) + .require_delimiter(true) + .takes_value(true)) + .arg(Arg::with_name("args") + .multiple(true) + .index(1)) + .get_matches_from_safe(vec![ + "", + "-oval1", "val2", "val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.values_of("option").unwrap().collect::>(), &["val1"]); + assert_eq!(m.values_of("args").unwrap().collect::>(), &["val2", "val3"]); +} + +#[test] +fn req_delimiter_short_with_equal() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .short("option") + .multiple(true) + .use_delimiter(true) + .require_delimiter(true) + .takes_value(true)) + .arg(Arg::with_name("args") + .multiple(true) + .index(1)) + .get_matches_from_safe(vec![ + "", + "-o=val1", "val2", "val3", + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 1); + assert_eq!(m.values_of("option").unwrap().collect::>(), &["val1"]); + assert_eq!(m.values_of("args").unwrap().collect::>(), &["val2", "val3"]); +} + +#[test] +fn req_delimiter_complex() { + let m = App::new("multiple_values") + .arg(Arg::with_name("option") + .long("option") + .short("o") + .multiple(true) + .use_delimiter(true) + .require_delimiter(true) + .takes_value(true)) + .arg(Arg::with_name("args") + .multiple(true) + .index(1)) + .get_matches_from_safe(vec![ + "", + "val1", + "-oval2", "val3", + "-o", "val4", "val5", + "-o=val6", "val7", + "--option=val8", "val9", + "--option", "val10", "val11", + "-oval12,val13", "val14", + "-o", "val15,val16", "val17", + "-o=val18,val19", "val20", + "--option=val21,val22", "val23", + "--option", "val24,val25", "val26" + ]); + + assert!(m.is_ok()); + let m = m.unwrap(); + + assert!(m.is_present("option")); + assert_eq!(m.occurrences_of("option"), 10); + assert_eq!(m.values_of("option").unwrap().collect::>(), + &["val2", "val4", "val6", "val8", "val10", "val12", "val13", "val15", + "val16", "val18", "val19", "val21", "val22", "val24", "val25"]); + assert_eq!(m.values_of("args").unwrap().collect::>(), + &["val1", "val3", "val5", "val7", "val9", "val11", "val14", "val17", + "val20", "val23", "val26"]); +} + +#[test] +#[should_panic] +fn low_index_positional_not_required() { + let _ = App::new("lip") + .arg(Arg::with_name("files") + .index(1) + .required(true) + .multiple(true)) + .arg(Arg::with_name("target") + .index(2)) + .get_matches_from_safe(vec![ + "lip", + "file1", "file2", + "file3", "target", + ]); +} + +#[test] +#[should_panic] +fn low_index_positional_last_multiple_too() { + let _ = App::new("lip") + .arg(Arg::with_name("files") + .index(1) + .required(true) + .multiple(true)) + .arg(Arg::with_name("target") + .index(2) + .required(true) + .multiple(true)) + .get_matches_from_safe(vec![ + "lip", + "file1", "file2", + "file3", "target", + ]); +} + +#[test] +#[should_panic] +fn low_index_positional_too_far_back() { + let _ = App::new("lip") + .arg(Arg::with_name("files") + .index(1) + .required(true) + .multiple(true)) + .arg(Arg::with_name("target") + .required(true) + .index(2)) + .arg(Arg::with_name("target2") + .required(true) + .index(3)) + .get_matches_from_safe(vec![ + "lip", + "file1", "file2", + "file3", "target", + ]); +} + +#[test] +fn low_index_positional() { + let m = App::new("lip") + .arg(Arg::with_name("files") + .index(1) + .required(true) + .multiple(true)) + .arg(Arg::with_name("target") + .index(2) + .required(true)) + .get_matches_from_safe(vec![ + "lip", + "file1", "file2", + "file3", "target", + ]); + + assert!(m.is_ok(), "{:?}", m.unwrap_err().kind); + let m = m.unwrap(); + + assert!(m.is_present("files")); + assert_eq!(m.occurrences_of("files"), 3); + assert!(m.is_present("target")); + assert_eq!(m.occurrences_of("target"), 1); + assert_eq!(m.values_of("files").unwrap().collect::>(), ["file1", "file2", "file3"]); + assert_eq!(m.value_of("target").unwrap(), "target"); +} + +#[test] +fn low_index_positional_in_subcmd() { + let m = App::new("lip") + .subcommand(SubCommand::with_name("test") + .arg(Arg::with_name("files") + .index(1) + .required(true) + .multiple(true)) + .arg(Arg::with_name("target") + .index(2) + .required(true))) + .get_matches_from_safe(vec![ + "lip", "test", + "file1", "file2", + "file3", "target" + ]); + + assert!(m.is_ok(), "{:?}", m.unwrap_err().kind); + let m = m.unwrap(); + let sm = m.subcommand_matches("test").unwrap(); + + assert!(sm.is_present("files")); + assert_eq!(sm.occurrences_of("files"), 3); + assert!(sm.is_present("target")); + assert_eq!(sm.occurrences_of("target"), 1); + assert_eq!(sm.values_of("files").unwrap().collect::>(), ["file1", "file2", "file3"]); + assert_eq!(sm.value_of("target").unwrap(), "target"); +} + +#[test] +fn low_index_positional_with_option() { + let m = App::new("lip") + .arg(Arg::with_name("files") + .required(true) + .index(1) + .multiple(true)) + .arg(Arg::with_name("target") + .index(2) + .required(true)) + .arg(Arg::with_name("opt") + .long("option") + .takes_value(true)) + .get_matches_from_safe(vec![ + "lip", + "file1", "file2", + "file3", "target", + "--option", "test" + ]); + + assert!(m.is_ok(), "{:?}", m.unwrap_err().kind); + let m = m.unwrap(); + + assert!(m.is_present("files")); + assert_eq!(m.occurrences_of("files"), 3); + assert!(m.is_present("target")); + assert_eq!(m.occurrences_of("target"), 1); + assert_eq!(m.values_of("files").unwrap().collect::>(), ["file1", "file2", "file3"]); + assert_eq!(m.value_of("target").unwrap(), "target"); + assert_eq!(m.value_of("opt").unwrap(), "test"); +} + +#[test] +fn low_index_positional_with_flag() { + let m = App::new("lip") + .arg(Arg::with_name("files") + .index(1) + .required(true) + .multiple(true)) + .arg(Arg::with_name("target") + .index(2) + .required(true)) + .arg(Arg::with_name("flg") + .long("flag")) + .get_matches_from_safe(vec![ + "lip", + "file1", "file2", + "file3", "target", + "--flag" + ]); + + assert!(m.is_ok(), "{:?}", m.unwrap_err().kind); + let m = m.unwrap(); + + assert!(m.is_present("files")); + assert_eq!(m.occurrences_of("files"), 3); + assert!(m.is_present("target")); + assert_eq!(m.occurrences_of("target"), 1); + assert_eq!(m.values_of("files").unwrap().collect::>(), ["file1", "file2", "file3"]); + assert_eq!(m.value_of("target").unwrap(), "target"); + assert!(m.is_present("flg")); +} + +#[test] +fn multiple_value_terminator_option() { + let m = App::new("lip") + .arg(Arg::with_name("files") + .short("f") + .value_terminator(";") + .multiple(true)) + .arg(Arg::with_name("other")) + .get_matches_from_safe(vec![ + "lip", + "-f", "val1", "val2", ";", + "otherval" + ]); + + assert!(m.is_ok(), "{:?}", m.unwrap_err().kind); + let m = m.unwrap(); + + assert!(m.is_present("other")); + assert_eq!(m.occurrences_of("other"), 1); + assert!(m.is_present("files")); + assert_eq!(m.values_of("files").unwrap().collect::>(), ["val1", "val2"]); + assert_eq!(m.value_of("other"), Some("otherval")); +} + +#[test] +fn multiple_value_terminator_option_other_arg() { + let m = App::new("lip") + .arg(Arg::with_name("files") + .short("f") + .value_terminator(";") + .multiple(true)) + .arg(Arg::with_name("other")) + .arg(Arg::with_name("flag") + .short("-F")) + .get_matches_from_safe(vec![ + "lip", + "-f", "val1", "val2", + "-F", + "otherval" + ]); + + assert!(m.is_ok(), "{:?}", m.unwrap_err().kind); + let m = m.unwrap(); + + assert!(m.is_present("other")); + assert!(m.is_present("files")); + assert_eq!(m.values_of("files").unwrap().collect::>(), ["val1", "val2"]); + assert_eq!(m.value_of("other"), Some("otherval")); + assert!(m.is_present("flag")); +} + +#[test] +fn multiple_vals_with_hyphen() { + let res = App::new("do") + .arg(Arg::with_name("cmds") + .multiple(true) + .allow_hyphen_values(true) + .value_terminator(";")) + .arg(Arg::with_name("location")) + .get_matches_from_safe(vec!["do", "find", "-type", "f", "-name", "special", ";", "/home/clap"]); + assert!(res.is_ok(), "{:?}", res.unwrap_err().kind); + + let m = res.unwrap(); + let cmds: Vec<_> = m.values_of("cmds").unwrap().collect(); + assert_eq!(&cmds, &["find", "-type", "f", "-name", "special"]); + assert_eq!(m.value_of("location"), Some("/home/clap")); +} -- cgit v1.2.1