diff options
Diffstat (limited to 'third_party/rust/clap/src/usage_parser.rs')
| -rw-r--r-- | third_party/rust/clap/src/usage_parser.rs | 1347 |
1 files changed, 1347 insertions, 0 deletions
diff --git a/third_party/rust/clap/src/usage_parser.rs b/third_party/rust/clap/src/usage_parser.rs new file mode 100644 index 0000000000..f6d5ac6069 --- /dev/null +++ b/third_party/rust/clap/src/usage_parser.rs @@ -0,0 +1,1347 @@ +// Internal +use INTERNAL_ERROR_MSG; +use args::Arg; +use args::settings::ArgSettings; +use map::VecMap; + +#[derive(PartialEq, Debug)] +enum UsageToken { + Name, + ValName, + Short, + Long, + Help, + Multiple, + Unknown, +} + +#[doc(hidden)] +#[derive(Debug)] +pub struct UsageParser<'a> { + usage: &'a str, + pos: usize, + start: usize, + prev: UsageToken, + explicit_name_set: bool, +} + +impl<'a> UsageParser<'a> { + fn new(usage: &'a str) -> Self { + debugln!("UsageParser::new: usage={:?}", usage); + UsageParser { + usage: usage, + pos: 0, + start: 0, + prev: UsageToken::Unknown, + explicit_name_set: false, + } + } + + pub fn from_usage(usage: &'a str) -> Self { + debugln!("UsageParser::from_usage;"); + UsageParser::new(usage) + } + + pub fn parse(mut self) -> Arg<'a, 'a> { + debugln!("UsageParser::parse;"); + let mut arg = Arg::default(); + loop { + debugln!("UsageParser::parse:iter: pos={};", self.pos); + self.stop_at(token); + if let Some(&c) = self.usage.as_bytes().get(self.pos) { + match c { + b'-' => self.short_or_long(&mut arg), + b'.' => self.multiple(&mut arg), + b'\'' => self.help(&mut arg), + _ => self.name(&mut arg), + } + } else { + break; + } + } + debug_assert!( + !arg.b.name.is_empty(), + format!( + "No name found for Arg when parsing usage string: {}", + self.usage + ) + ); + arg.v.num_vals = match arg.v.val_names { + Some(ref v) if v.len() >= 2 => Some(v.len() as u64), + _ => None, + }; + debugln!("UsageParser::parse: vals...{:?}", arg.v.val_names); + arg + } + + fn name(&mut self, arg: &mut Arg<'a, 'a>) { + debugln!("UsageParser::name;"); + if *self.usage + .as_bytes() + .get(self.pos) + .expect(INTERNAL_ERROR_MSG) == b'<' && !self.explicit_name_set + { + arg.setb(ArgSettings::Required); + } + self.pos += 1; + self.stop_at(name_end); + let name = &self.usage[self.start..self.pos]; + if self.prev == UsageToken::Unknown { + debugln!("UsageParser::name: setting name...{}", name); + arg.b.name = name; + if arg.s.long.is_none() && arg.s.short.is_none() { + debugln!("UsageParser::name: explicit name set..."); + self.explicit_name_set = true; + self.prev = UsageToken::Name; + } + } else { + debugln!("UsageParser::name: setting val name...{}", name); + if let Some(ref mut v) = arg.v.val_names { + let len = v.len(); + v.insert(len, name); + } else { + let mut v = VecMap::new(); + v.insert(0, name); + arg.v.val_names = Some(v); + arg.setb(ArgSettings::TakesValue); + } + self.prev = UsageToken::ValName; + } + } + + fn stop_at<F>(&mut self, f: F) + where + F: Fn(u8) -> bool, + { + debugln!("UsageParser::stop_at;"); + self.start = self.pos; + self.pos += self.usage[self.start..] + .bytes() + .take_while(|&b| f(b)) + .count(); + } + + fn short_or_long(&mut self, arg: &mut Arg<'a, 'a>) { + debugln!("UsageParser::short_or_long;"); + self.pos += 1; + if *self.usage + .as_bytes() + .get(self.pos) + .expect(INTERNAL_ERROR_MSG) == b'-' + { + self.pos += 1; + self.long(arg); + return; + } + self.short(arg) + } + + fn long(&mut self, arg: &mut Arg<'a, 'a>) { + debugln!("UsageParser::long;"); + self.stop_at(long_end); + let name = &self.usage[self.start..self.pos]; + if !self.explicit_name_set { + debugln!("UsageParser::long: setting name...{}", name); + arg.b.name = name; + } + debugln!("UsageParser::long: setting long...{}", name); + arg.s.long = Some(name); + self.prev = UsageToken::Long; + } + + fn short(&mut self, arg: &mut Arg<'a, 'a>) { + debugln!("UsageParser::short;"); + let start = &self.usage[self.pos..]; + let short = start.chars().nth(0).expect(INTERNAL_ERROR_MSG); + debugln!("UsageParser::short: setting short...{}", short); + arg.s.short = Some(short); + if arg.b.name.is_empty() { + // --long takes precedence but doesn't set self.explicit_name_set + let name = &start[..short.len_utf8()]; + debugln!("UsageParser::short: setting name...{}", name); + arg.b.name = name; + } + self.prev = UsageToken::Short; + } + + // "something..." + fn multiple(&mut self, arg: &mut Arg) { + debugln!("UsageParser::multiple;"); + let mut dot_counter = 1; + let start = self.pos; + let mut bytes = self.usage[start..].bytes(); + while bytes.next() == Some(b'.') { + dot_counter += 1; + self.pos += 1; + if dot_counter == 3 { + debugln!("UsageParser::multiple: setting multiple"); + arg.setb(ArgSettings::Multiple); + if arg.is_set(ArgSettings::TakesValue) { + arg.setb(ArgSettings::UseValueDelimiter); + arg.unsetb(ArgSettings::ValueDelimiterNotSet); + if arg.v.val_delim.is_none() { + arg.v.val_delim = Some(','); + } + } + self.prev = UsageToken::Multiple; + self.pos += 1; + break; + } + } + } + + fn help(&mut self, arg: &mut Arg<'a, 'a>) { + debugln!("UsageParser::help;"); + self.stop_at(help_start); + self.start = self.pos + 1; + self.pos = self.usage.len() - 1; + debugln!( + "UsageParser::help: setting help...{}", + &self.usage[self.start..self.pos] + ); + arg.b.help = Some(&self.usage[self.start..self.pos]); + self.pos += 1; // Move to next byte to keep from thinking ending ' is a start + self.prev = UsageToken::Help; + } +} + +#[inline] +fn name_end(b: u8) -> bool { b != b']' && b != b'>' } + +#[inline] +fn token(b: u8) -> bool { b != b'\'' && b != b'.' && b != b'<' && b != b'[' && b != b'-' } + +#[inline] +fn long_end(b: u8) -> bool { + b != b'\'' && b != b'.' && b != b'<' && b != b'[' && b != b'=' && b != b' ' +} + +#[inline] +fn help_start(b: u8) -> bool { b != b'\'' } + +#[cfg(test)] +mod test { + use args::Arg; + use args::ArgSettings; + + #[test] + fn create_flag_usage() { + let a = Arg::from_usage("[flag] -f 'some help info'"); + assert_eq!(a.b.name, "flag"); + assert_eq!(a.s.short.unwrap(), 'f'); + assert!(a.s.long.is_none()); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(!a.is_set(ArgSettings::Multiple)); + assert!(a.v.val_names.is_none()); + assert!(a.v.num_vals.is_none()); + + let b = Arg::from_usage("[flag] --flag 'some help info'"); + assert_eq!(b.b.name, "flag"); + assert_eq!(b.s.long.unwrap(), "flag"); + assert!(b.s.short.is_none()); + assert_eq!(b.b.help.unwrap(), "some help info"); + assert!(!b.is_set(ArgSettings::Multiple)); + assert!(a.v.val_names.is_none()); + assert!(a.v.num_vals.is_none()); + + let b = Arg::from_usage("--flag 'some help info'"); + assert_eq!(b.b.name, "flag"); + assert_eq!(b.s.long.unwrap(), "flag"); + assert!(b.s.short.is_none()); + assert_eq!(b.b.help.unwrap(), "some help info"); + assert!(!b.is_set(ArgSettings::Multiple)); + assert!(b.v.val_names.is_none()); + assert!(b.v.num_vals.is_none()); + + let c = Arg::from_usage("[flag] -f --flag 'some help info'"); + assert_eq!(c.b.name, "flag"); + assert_eq!(c.s.short.unwrap(), 'f'); + assert_eq!(c.s.long.unwrap(), "flag"); + assert_eq!(c.b.help.unwrap(), "some help info"); + assert!(!c.is_set(ArgSettings::Multiple)); + assert!(c.v.val_names.is_none()); + assert!(c.v.num_vals.is_none()); + + let d = Arg::from_usage("[flag] -f... 'some help info'"); + assert_eq!(d.b.name, "flag"); + assert_eq!(d.s.short.unwrap(), 'f'); + assert!(d.s.long.is_none()); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(d.is_set(ArgSettings::Multiple)); + assert!(d.v.val_names.is_none()); + assert!(d.v.num_vals.is_none()); + + let e = Arg::from_usage("[flag] -f --flag... 'some help info'"); + assert_eq!(e.b.name, "flag"); + assert_eq!(e.s.long.unwrap(), "flag"); + assert_eq!(e.s.short.unwrap(), 'f'); + assert_eq!(e.b.help.unwrap(), "some help info"); + assert!(e.is_set(ArgSettings::Multiple)); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); + + let e = Arg::from_usage("-f --flag... 'some help info'"); + assert_eq!(e.b.name, "flag"); + assert_eq!(e.s.long.unwrap(), "flag"); + assert_eq!(e.s.short.unwrap(), 'f'); + assert_eq!(e.b.help.unwrap(), "some help info"); + assert!(e.is_set(ArgSettings::Multiple)); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); + + let e = Arg::from_usage("--flags"); + assert_eq!(e.b.name, "flags"); + assert_eq!(e.s.long.unwrap(), "flags"); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); + + let e = Arg::from_usage("--flags..."); + assert_eq!(e.b.name, "flags"); + assert_eq!(e.s.long.unwrap(), "flags"); + assert!(e.is_set(ArgSettings::Multiple)); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); + + let e = Arg::from_usage("[flags] -f"); + assert_eq!(e.b.name, "flags"); + assert_eq!(e.s.short.unwrap(), 'f'); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); + + let e = Arg::from_usage("[flags] -f..."); + assert_eq!(e.b.name, "flags"); + assert_eq!(e.s.short.unwrap(), 'f'); + assert!(e.is_set(ArgSettings::Multiple)); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); + + let a = Arg::from_usage("-f 'some help info'"); + assert_eq!(a.b.name, "f"); + assert_eq!(a.s.short.unwrap(), 'f'); + assert!(a.s.long.is_none()); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(!a.is_set(ArgSettings::Multiple)); + assert!(a.v.val_names.is_none()); + assert!(a.v.num_vals.is_none()); + + let e = Arg::from_usage("-f"); + assert_eq!(e.b.name, "f"); + assert_eq!(e.s.short.unwrap(), 'f'); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); + + let e = Arg::from_usage("-f..."); + assert_eq!(e.b.name, "f"); + assert_eq!(e.s.short.unwrap(), 'f'); + assert!(e.is_set(ArgSettings::Multiple)); + assert!(e.v.val_names.is_none()); + assert!(e.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage0() { + // Short only + let a = Arg::from_usage("[option] -o [opt] 'some help info'"); + assert_eq!(a.b.name, "option"); + assert_eq!(a.s.short.unwrap(), 'o'); + assert!(a.s.long.is_none()); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(!a.is_set(ArgSettings::Multiple)); + assert!(a.is_set(ArgSettings::TakesValue)); + assert!(!a.is_set(ArgSettings::Required)); + assert_eq!( + a.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(a.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage1() { + let b = Arg::from_usage("-o [opt] 'some help info'"); + assert_eq!(b.b.name, "o"); + assert_eq!(b.s.short.unwrap(), 'o'); + assert!(b.s.long.is_none()); + assert_eq!(b.b.help.unwrap(), "some help info"); + assert!(!b.is_set(ArgSettings::Multiple)); + assert!(b.is_set(ArgSettings::TakesValue)); + assert!(!b.is_set(ArgSettings::Required)); + assert_eq!( + b.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(b.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage2() { + let c = Arg::from_usage("<option> -o <opt> 'some help info'"); + assert_eq!(c.b.name, "option"); + assert_eq!(c.s.short.unwrap(), 'o'); + assert!(c.s.long.is_none()); + assert_eq!(c.b.help.unwrap(), "some help info"); + assert!(!c.is_set(ArgSettings::Multiple)); + assert!(c.is_set(ArgSettings::TakesValue)); + assert!(c.is_set(ArgSettings::Required)); + assert_eq!( + c.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage3() { + let d = Arg::from_usage("-o <opt> 'some help info'"); + assert_eq!(d.b.name, "o"); + assert_eq!(d.s.short.unwrap(), 'o'); + assert!(d.s.long.is_none()); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(!d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::TakesValue)); + assert!(d.is_set(ArgSettings::Required)); + assert_eq!( + d.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(d.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage4() { + let a = Arg::from_usage("[option] -o [opt]... 'some help info'"); + assert_eq!(a.b.name, "option"); + assert_eq!(a.s.short.unwrap(), 'o'); + assert!(a.s.long.is_none()); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(a.is_set(ArgSettings::Multiple)); + assert!(a.is_set(ArgSettings::TakesValue)); + assert!(!a.is_set(ArgSettings::Required)); + assert_eq!( + a.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(a.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage5() { + let a = Arg::from_usage("[option]... -o [opt] 'some help info'"); + assert_eq!(a.b.name, "option"); + assert_eq!(a.s.short.unwrap(), 'o'); + assert!(a.s.long.is_none()); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(a.is_set(ArgSettings::Multiple)); + assert!(a.is_set(ArgSettings::TakesValue)); + assert!(!a.is_set(ArgSettings::Required)); + assert_eq!( + a.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(a.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage6() { + let b = Arg::from_usage("-o [opt]... 'some help info'"); + assert_eq!(b.b.name, "o"); + assert_eq!(b.s.short.unwrap(), 'o'); + assert!(b.s.long.is_none()); + assert_eq!(b.b.help.unwrap(), "some help info"); + assert!(b.is_set(ArgSettings::Multiple)); + assert!(b.is_set(ArgSettings::TakesValue)); + assert!(!b.is_set(ArgSettings::Required)); + assert_eq!( + b.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(b.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage7() { + let c = Arg::from_usage("<option> -o <opt>... 'some help info'"); + assert_eq!(c.b.name, "option"); + assert_eq!(c.s.short.unwrap(), 'o'); + assert!(c.s.long.is_none()); + assert_eq!(c.b.help.unwrap(), "some help info"); + assert!(c.is_set(ArgSettings::Multiple)); + assert!(c.is_set(ArgSettings::TakesValue)); + assert!(c.is_set(ArgSettings::Required)); + assert_eq!( + c.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage8() { + let c = Arg::from_usage("<option>... -o <opt> 'some help info'"); + assert_eq!(c.b.name, "option"); + assert_eq!(c.s.short.unwrap(), 'o'); + assert!(c.s.long.is_none()); + assert_eq!(c.b.help.unwrap(), "some help info"); + assert!(c.is_set(ArgSettings::Multiple)); + assert!(c.is_set(ArgSettings::TakesValue)); + assert!(c.is_set(ArgSettings::Required)); + assert_eq!( + c.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage9() { + let d = Arg::from_usage("-o <opt>... 'some help info'"); + assert_eq!(d.b.name, "o"); + assert_eq!(d.s.short.unwrap(), 'o'); + assert!(d.s.long.is_none()); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::TakesValue)); + assert!(d.is_set(ArgSettings::Required)); + assert_eq!( + d.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(d.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long1() { + let a = Arg::from_usage("[option] --opt [opt] 'some help info'"); + assert_eq!(a.b.name, "option"); + assert_eq!(a.s.long.unwrap(), "opt"); + assert!(a.s.short.is_none()); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(!a.is_set(ArgSettings::Multiple)); + assert!(a.is_set(ArgSettings::TakesValue)); + assert!(!a.is_set(ArgSettings::Required)); + assert_eq!( + a.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(a.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long2() { + let b = Arg::from_usage("--opt [option] 'some help info'"); + assert_eq!(b.b.name, "opt"); + assert_eq!(b.s.long.unwrap(), "opt"); + assert!(b.s.short.is_none()); + assert_eq!(b.b.help.unwrap(), "some help info"); + assert!(!b.is_set(ArgSettings::Multiple)); + assert!(b.is_set(ArgSettings::TakesValue)); + assert!(!b.is_set(ArgSettings::Required)); + assert_eq!( + b.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(b.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long3() { + let c = Arg::from_usage("<option> --opt <opt> 'some help info'"); + assert_eq!(c.b.name, "option"); + assert_eq!(c.s.long.unwrap(), "opt"); + assert!(c.s.short.is_none()); + assert_eq!(c.b.help.unwrap(), "some help info"); + assert!(!c.is_set(ArgSettings::Multiple)); + assert!(c.is_set(ArgSettings::TakesValue)); + assert!(c.is_set(ArgSettings::Required)); + assert_eq!( + c.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long4() { + let d = Arg::from_usage("--opt <option> 'some help info'"); + assert_eq!(d.b.name, "opt"); + assert_eq!(d.s.long.unwrap(), "opt"); + assert!(d.s.short.is_none()); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(!d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::TakesValue)); + assert!(d.is_set(ArgSettings::Required)); + assert_eq!( + d.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(d.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long5() { + let a = Arg::from_usage("[option] --opt [opt]... 'some help info'"); + assert_eq!(a.b.name, "option"); + assert_eq!(a.s.long.unwrap(), "opt"); + assert!(a.s.short.is_none()); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(a.is_set(ArgSettings::Multiple)); + assert!(a.is_set(ArgSettings::TakesValue)); + assert!(!a.is_set(ArgSettings::Required)); + assert_eq!( + a.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(a.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long6() { + let a = Arg::from_usage("[option]... --opt [opt] 'some help info'"); + assert_eq!(a.b.name, "option"); + assert_eq!(a.s.long.unwrap(), "opt"); + assert!(a.s.short.is_none()); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(a.is_set(ArgSettings::Multiple)); + assert!(a.is_set(ArgSettings::TakesValue)); + assert!(!a.is_set(ArgSettings::Required)); + assert_eq!( + a.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(a.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long7() { + let b = Arg::from_usage("--opt [option]... 'some help info'"); + assert_eq!(b.b.name, "opt"); + assert_eq!(b.s.long.unwrap(), "opt"); + assert!(b.s.short.is_none()); + assert_eq!(b.b.help.unwrap(), "some help info"); + assert!(b.is_set(ArgSettings::Multiple)); + assert!(b.is_set(ArgSettings::TakesValue)); + assert!(!b.is_set(ArgSettings::Required)); + assert_eq!( + b.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(b.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long8() { + let c = Arg::from_usage("<option> --opt <opt>... 'some help info'"); + assert_eq!(c.b.name, "option"); + assert_eq!(c.s.long.unwrap(), "opt"); + assert!(c.s.short.is_none()); + assert_eq!(c.b.help.unwrap(), "some help info"); + assert!(c.is_set(ArgSettings::Multiple)); + assert!(c.is_set(ArgSettings::TakesValue)); + assert!(c.is_set(ArgSettings::Required)); + assert_eq!( + c.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long9() { + let c = Arg::from_usage("<option>... --opt <opt> 'some help info'"); + assert_eq!(c.b.name, "option"); + assert_eq!(c.s.long.unwrap(), "opt"); + assert!(c.s.short.is_none()); + assert_eq!(c.b.help.unwrap(), "some help info"); + assert!(c.is_set(ArgSettings::Multiple)); + assert!(c.is_set(ArgSettings::TakesValue)); + assert!(c.is_set(ArgSettings::Required)); + assert_eq!( + c.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long10() { + let d = Arg::from_usage("--opt <option>... 'some help info'"); + assert_eq!(d.b.name, "opt"); + assert_eq!(d.s.long.unwrap(), "opt"); + assert!(d.s.short.is_none()); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::TakesValue)); + assert!(d.is_set(ArgSettings::Required)); + assert_eq!( + d.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(d.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long_equals1() { + let a = Arg::from_usage("[option] --opt=[opt] 'some help info'"); + assert_eq!(a.b.name, "option"); + assert_eq!(a.s.long.unwrap(), "opt"); + assert!(a.s.short.is_none()); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(!a.is_set(ArgSettings::Multiple)); + assert!(a.is_set(ArgSettings::TakesValue)); + assert!(!a.is_set(ArgSettings::Required)); + assert_eq!( + a.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(a.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long_equals2() { + let b = Arg::from_usage("--opt=[option] 'some help info'"); + assert_eq!(b.b.name, "opt"); + assert_eq!(b.s.long.unwrap(), "opt"); + assert!(b.s.short.is_none()); + assert_eq!(b.b.help.unwrap(), "some help info"); + assert!(!b.is_set(ArgSettings::Multiple)); + assert!(b.is_set(ArgSettings::TakesValue)); + assert!(!b.is_set(ArgSettings::Required)); + assert_eq!( + b.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(b.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long_equals3() { + let c = Arg::from_usage("<option> --opt=<opt> 'some help info'"); + assert_eq!(c.b.name, "option"); + assert_eq!(c.s.long.unwrap(), "opt"); + assert!(c.s.short.is_none()); + assert_eq!(c.b.help.unwrap(), "some help info"); + assert!(!c.is_set(ArgSettings::Multiple)); + assert!(c.is_set(ArgSettings::TakesValue)); + assert!(c.is_set(ArgSettings::Required)); + assert_eq!( + c.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long_equals4() { + let d = Arg::from_usage("--opt=<option> 'some help info'"); + assert_eq!(d.b.name, "opt"); + assert_eq!(d.s.long.unwrap(), "opt"); + assert!(d.s.short.is_none()); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(!d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::TakesValue)); + assert!(d.is_set(ArgSettings::Required)); + assert_eq!( + d.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(d.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long_equals5() { + let a = Arg::from_usage("[option] --opt=[opt]... 'some help info'"); + assert_eq!(a.b.name, "option"); + assert_eq!(a.s.long.unwrap(), "opt"); + assert!(a.s.short.is_none()); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(a.is_set(ArgSettings::Multiple)); + assert!(a.is_set(ArgSettings::TakesValue)); + assert!(!a.is_set(ArgSettings::Required)); + assert_eq!( + a.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(a.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long_equals6() { + let a = Arg::from_usage("[option]... --opt=[opt] 'some help info'"); + assert_eq!(a.b.name, "option"); + assert_eq!(a.s.long.unwrap(), "opt"); + assert!(a.s.short.is_none()); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(a.is_set(ArgSettings::Multiple)); + assert!(a.is_set(ArgSettings::TakesValue)); + assert!(!a.is_set(ArgSettings::Required)); + assert_eq!( + a.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(a.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long_equals7() { + let b = Arg::from_usage("--opt=[option]... 'some help info'"); + assert_eq!(b.b.name, "opt"); + assert_eq!(b.s.long.unwrap(), "opt"); + assert!(b.s.short.is_none()); + assert_eq!(b.b.help.unwrap(), "some help info"); + assert!(b.is_set(ArgSettings::Multiple)); + assert!(b.is_set(ArgSettings::TakesValue)); + assert!(!b.is_set(ArgSettings::Required)); + assert_eq!( + b.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(b.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long_equals8() { + let c = Arg::from_usage("<option> --opt=<opt>... 'some help info'"); + assert_eq!(c.b.name, "option"); + assert_eq!(c.s.long.unwrap(), "opt"); + assert!(c.s.short.is_none()); + assert_eq!(c.b.help.unwrap(), "some help info"); + assert!(c.is_set(ArgSettings::Multiple)); + assert!(c.is_set(ArgSettings::TakesValue)); + assert!(c.is_set(ArgSettings::Required)); + assert_eq!( + c.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long_equals9() { + let c = Arg::from_usage("<option>... --opt=<opt> 'some help info'"); + assert_eq!(c.b.name, "option"); + assert_eq!(c.s.long.unwrap(), "opt"); + assert!(c.s.short.is_none()); + assert_eq!(c.b.help.unwrap(), "some help info"); + assert!(c.is_set(ArgSettings::Multiple)); + assert!(c.is_set(ArgSettings::TakesValue)); + assert!(c.is_set(ArgSettings::Required)); + assert_eq!( + c.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_long_equals10() { + let d = Arg::from_usage("--opt=<option>... 'some help info'"); + assert_eq!(d.b.name, "opt"); + assert_eq!(d.s.long.unwrap(), "opt"); + assert!(d.s.short.is_none()); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::TakesValue)); + assert!(d.is_set(ArgSettings::Required)); + assert_eq!( + d.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(d.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both1() { + let a = Arg::from_usage("[option] -o --opt [option] 'some help info'"); + assert_eq!(a.b.name, "option"); + assert_eq!(a.s.long.unwrap(), "opt"); + assert_eq!(a.s.short.unwrap(), 'o'); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(!a.is_set(ArgSettings::Multiple)); + assert!(a.is_set(ArgSettings::TakesValue)); + assert!(!a.is_set(ArgSettings::Required)); + assert_eq!( + a.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(a.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both2() { + let b = Arg::from_usage("-o --opt [option] 'some help info'"); + assert_eq!(b.b.name, "opt"); + assert_eq!(b.s.long.unwrap(), "opt"); + assert_eq!(b.s.short.unwrap(), 'o'); + assert_eq!(b.b.help.unwrap(), "some help info"); + assert!(!b.is_set(ArgSettings::Multiple)); + assert!(b.is_set(ArgSettings::TakesValue)); + assert!(!b.is_set(ArgSettings::Required)); + assert_eq!( + b.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(b.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both3() { + let c = Arg::from_usage("<option> -o --opt <opt> 'some help info'"); + assert_eq!(c.b.name, "option"); + assert_eq!(c.s.long.unwrap(), "opt"); + assert_eq!(c.s.short.unwrap(), 'o'); + assert_eq!(c.b.help.unwrap(), "some help info"); + assert!(!c.is_set(ArgSettings::Multiple)); + assert!(c.is_set(ArgSettings::TakesValue)); + assert!(c.is_set(ArgSettings::Required)); + assert_eq!( + c.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both4() { + let d = Arg::from_usage("-o --opt <option> 'some help info'"); + assert_eq!(d.b.name, "opt"); + assert_eq!(d.s.long.unwrap(), "opt"); + assert_eq!(d.s.short.unwrap(), 'o'); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(!d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::TakesValue)); + assert!(d.is_set(ArgSettings::Required)); + assert_eq!( + d.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(d.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both5() { + let a = Arg::from_usage("[option]... -o --opt [option] 'some help info'"); + assert_eq!(a.b.name, "option"); + assert_eq!(a.s.long.unwrap(), "opt"); + assert_eq!(a.s.short.unwrap(), 'o'); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(a.is_set(ArgSettings::Multiple)); + assert!(a.is_set(ArgSettings::TakesValue)); + assert!(!a.is_set(ArgSettings::Required)); + assert_eq!( + a.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(a.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both6() { + let b = Arg::from_usage("-o --opt [option]... 'some help info'"); + assert_eq!(b.b.name, "opt"); + assert_eq!(b.s.long.unwrap(), "opt"); + assert_eq!(b.s.short.unwrap(), 'o'); + assert_eq!(b.b.help.unwrap(), "some help info"); + assert!(b.is_set(ArgSettings::Multiple)); + assert!(b.is_set(ArgSettings::TakesValue)); + assert!(!b.is_set(ArgSettings::Required)); + assert_eq!( + b.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(b.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both7() { + let c = Arg::from_usage("<option>... -o --opt <opt> 'some help info'"); + assert_eq!(c.b.name, "option"); + assert_eq!(c.s.long.unwrap(), "opt"); + assert_eq!(c.s.short.unwrap(), 'o'); + assert_eq!(c.b.help.unwrap(), "some help info"); + assert!(c.is_set(ArgSettings::Multiple)); + assert!(c.is_set(ArgSettings::TakesValue)); + assert!(c.is_set(ArgSettings::Required)); + assert_eq!( + c.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both8() { + let d = Arg::from_usage("-o --opt <option>... 'some help info'"); + assert_eq!(d.b.name, "opt"); + assert_eq!(d.s.long.unwrap(), "opt"); + assert_eq!(d.s.short.unwrap(), 'o'); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::TakesValue)); + assert!(d.is_set(ArgSettings::Required)); + assert_eq!( + d.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(d.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both_equals1() { + let a = Arg::from_usage("[option] -o --opt=[option] 'some help info'"); + assert_eq!(a.b.name, "option"); + assert_eq!(a.s.long.unwrap(), "opt"); + assert_eq!(a.s.short.unwrap(), 'o'); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(!a.is_set(ArgSettings::Multiple)); + assert!(a.is_set(ArgSettings::TakesValue)); + assert!(!a.is_set(ArgSettings::Required)); + assert_eq!( + a.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(a.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both_equals2() { + let b = Arg::from_usage("-o --opt=[option] 'some help info'"); + assert_eq!(b.b.name, "opt"); + assert_eq!(b.s.long.unwrap(), "opt"); + assert_eq!(b.s.short.unwrap(), 'o'); + assert_eq!(b.b.help.unwrap(), "some help info"); + assert!(!b.is_set(ArgSettings::Multiple)); + assert!(b.is_set(ArgSettings::TakesValue)); + assert!(!b.is_set(ArgSettings::Required)); + assert_eq!( + b.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(b.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both_equals3() { + let c = Arg::from_usage("<option> -o --opt=<opt> 'some help info'"); + assert_eq!(c.b.name, "option"); + assert_eq!(c.s.long.unwrap(), "opt"); + assert_eq!(c.s.short.unwrap(), 'o'); + assert_eq!(c.b.help.unwrap(), "some help info"); + assert!(!c.is_set(ArgSettings::Multiple)); + assert!(c.is_set(ArgSettings::TakesValue)); + assert!(c.is_set(ArgSettings::Required)); + assert_eq!( + c.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both_equals4() { + let d = Arg::from_usage("-o --opt=<option> 'some help info'"); + assert_eq!(d.b.name, "opt"); + assert_eq!(d.s.long.unwrap(), "opt"); + assert_eq!(d.s.short.unwrap(), 'o'); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(!d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::TakesValue)); + assert!(d.is_set(ArgSettings::Required)); + assert_eq!( + d.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(d.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both_equals5() { + let a = Arg::from_usage("[option]... -o --opt=[option] 'some help info'"); + assert_eq!(a.b.name, "option"); + assert_eq!(a.s.long.unwrap(), "opt"); + assert_eq!(a.s.short.unwrap(), 'o'); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(a.is_set(ArgSettings::Multiple)); + assert!(a.is_set(ArgSettings::TakesValue)); + assert!(!a.is_set(ArgSettings::Required)); + assert_eq!( + a.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(a.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both_equals6() { + let b = Arg::from_usage("-o --opt=[option]... 'some help info'"); + assert_eq!(b.b.name, "opt"); + assert_eq!(b.s.long.unwrap(), "opt"); + assert_eq!(b.s.short.unwrap(), 'o'); + assert_eq!(b.b.help.unwrap(), "some help info"); + assert!(b.is_set(ArgSettings::Multiple)); + assert!(b.is_set(ArgSettings::TakesValue)); + assert!(!b.is_set(ArgSettings::Required)); + assert_eq!( + b.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(b.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both_equals7() { + let c = Arg::from_usage("<option>... -o --opt=<opt> 'some help info'"); + assert_eq!(c.b.name, "option"); + assert_eq!(c.s.long.unwrap(), "opt"); + assert_eq!(c.s.short.unwrap(), 'o'); + assert_eq!(c.b.help.unwrap(), "some help info"); + assert!(c.is_set(ArgSettings::Multiple)); + assert!(c.is_set(ArgSettings::TakesValue)); + assert!(c.is_set(ArgSettings::Required)); + assert_eq!( + c.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"opt"] + ); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn create_option_usage_both_equals8() { + let d = Arg::from_usage("-o --opt=<option>... 'some help info'"); + assert_eq!(d.b.name, "opt"); + assert_eq!(d.s.long.unwrap(), "opt"); + assert_eq!(d.s.short.unwrap(), 'o'); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::TakesValue)); + assert!(d.is_set(ArgSettings::Required)); + assert_eq!( + d.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"option"] + ); + assert!(d.v.num_vals.is_none()); + } + + #[test] + fn create_option_with_vals1() { + let d = Arg::from_usage("-o <file> <mode> 'some help info'"); + assert_eq!(d.b.name, "o"); + assert!(d.s.long.is_none()); + assert_eq!(d.s.short.unwrap(), 'o'); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(!d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::TakesValue)); + assert!(d.is_set(ArgSettings::Required)); + assert_eq!( + d.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"file", &"mode"] + ); + assert_eq!(d.v.num_vals.unwrap(), 2); + } + + #[test] + fn create_option_with_vals2() { + let d = Arg::from_usage("-o <file> <mode>... 'some help info'"); + assert_eq!(d.b.name, "o"); + assert!(d.s.long.is_none()); + assert_eq!(d.s.short.unwrap(), 'o'); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::TakesValue)); + assert!(d.is_set(ArgSettings::Required)); + assert_eq!( + d.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"file", &"mode"] + ); + assert_eq!(d.v.num_vals.unwrap(), 2); + } + + #[test] + fn create_option_with_vals3() { + let d = Arg::from_usage("--opt <file> <mode>... 'some help info'"); + assert_eq!(d.b.name, "opt"); + assert!(d.s.short.is_none()); + assert_eq!(d.s.long.unwrap(), "opt"); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::TakesValue)); + assert!(d.is_set(ArgSettings::Required)); + assert_eq!( + d.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"file", &"mode"] + ); + assert_eq!(d.v.num_vals.unwrap(), 2); + } + + #[test] + fn create_option_with_vals4() { + let d = Arg::from_usage("[myopt] --opt <file> <mode> 'some help info'"); + assert_eq!(d.b.name, "myopt"); + assert!(d.s.short.is_none()); + assert_eq!(d.s.long.unwrap(), "opt"); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(!d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::TakesValue)); + assert!(!d.is_set(ArgSettings::Required)); + assert_eq!( + d.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"file", &"mode"] + ); + assert_eq!(d.v.num_vals.unwrap(), 2); + } + + #[test] + fn create_option_with_vals5() { + let d = Arg::from_usage("--opt <file> <mode> 'some help info'"); + assert_eq!(d.b.name, "opt"); + assert!(d.s.short.is_none()); + assert_eq!(d.s.long.unwrap(), "opt"); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(!d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::TakesValue)); + assert!(d.is_set(ArgSettings::Required)); + assert_eq!(d.v.num_vals.unwrap(), 2); + } + + #[test] + fn create_positional_usage() { + let a = Arg::from_usage("[pos] 'some help info'"); + assert_eq!(a.b.name, "pos"); + assert_eq!(a.b.help.unwrap(), "some help info"); + assert!(!a.is_set(ArgSettings::Multiple)); + assert!(!a.is_set(ArgSettings::Required)); + assert!(a.v.val_names.is_none()); + assert!(a.v.num_vals.is_none()); + } + + #[test] + fn create_positional_usage0() { + let b = Arg::from_usage("<pos> 'some help info'"); + assert_eq!(b.b.name, "pos"); + assert_eq!(b.b.help.unwrap(), "some help info"); + assert!(!b.is_set(ArgSettings::Multiple)); + assert!(b.is_set(ArgSettings::Required)); + assert!(b.v.val_names.is_none()); + assert!(b.v.num_vals.is_none()); + } + + #[test] + fn pos_mult_help() { + let c = Arg::from_usage("[pos]... 'some help info'"); + assert_eq!(c.b.name, "pos"); + assert_eq!(c.b.help.unwrap(), "some help info"); + assert!(c.is_set(ArgSettings::Multiple)); + assert!(!c.is_set(ArgSettings::Required)); + assert!(c.v.val_names.is_none()); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn pos_help_lit_single_quote() { + let c = Arg::from_usage("[pos]... 'some help\' info'"); + assert_eq!(c.b.name, "pos"); + assert_eq!(c.b.help.unwrap(), "some help' info"); + assert!(c.is_set(ArgSettings::Multiple)); + assert!(!c.is_set(ArgSettings::Required)); + assert!(c.v.val_names.is_none()); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn pos_help_double_lit_single_quote() { + let c = Arg::from_usage("[pos]... 'some \'help\' info'"); + assert_eq!(c.b.name, "pos"); + assert_eq!(c.b.help.unwrap(), "some 'help' info"); + assert!(c.is_set(ArgSettings::Multiple)); + assert!(!c.is_set(ArgSettings::Required)); + assert!(c.v.val_names.is_none()); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn pos_help_newline() { + let c = Arg::from_usage( + "[pos]... 'some help{n}\ + info'", + ); + assert_eq!(c.b.name, "pos"); + assert_eq!(c.b.help.unwrap(), "some help{n}info"); + assert!(c.is_set(ArgSettings::Multiple)); + assert!(!c.is_set(ArgSettings::Required)); + assert!(c.v.val_names.is_none()); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn pos_help_newline_lit_sq() { + let c = Arg::from_usage( + "[pos]... 'some help\' stuff{n}\ + info'", + ); + assert_eq!(c.b.name, "pos"); + assert_eq!(c.b.help.unwrap(), "some help' stuff{n}info"); + assert!(c.is_set(ArgSettings::Multiple)); + assert!(!c.is_set(ArgSettings::Required)); + assert!(c.v.val_names.is_none()); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn pos_req_mult_help() { + let d = Arg::from_usage("<pos>... 'some help info'"); + assert_eq!(d.b.name, "pos"); + assert_eq!(d.b.help.unwrap(), "some help info"); + assert!(d.is_set(ArgSettings::Multiple)); + assert!(d.is_set(ArgSettings::Required)); + assert!(d.v.val_names.is_none()); + assert!(d.v.num_vals.is_none()); + } + + #[test] + fn pos_req() { + let b = Arg::from_usage("<pos>"); + assert_eq!(b.b.name, "pos"); + assert!(!b.is_set(ArgSettings::Multiple)); + assert!(b.is_set(ArgSettings::Required)); + assert!(b.v.val_names.is_none()); + assert!(b.v.num_vals.is_none()); + } + + #[test] + fn pos_mult() { + let c = Arg::from_usage("[pos]..."); + assert_eq!(c.b.name, "pos"); + assert!(c.is_set(ArgSettings::Multiple)); + assert!(!c.is_set(ArgSettings::Required)); + assert!(c.v.val_names.is_none()); + assert!(c.v.num_vals.is_none()); + } + + #[test] + fn nonascii() { + let a = Arg::from_usage("<ASCII> 'üñíčöĐ€'"); + assert_eq!(a.b.name, "ASCII"); + assert_eq!(a.b.help, Some("üñíčöĐ€")); + let a = Arg::from_usage("<üñíčöĐ€> 'ASCII'"); + assert_eq!(a.b.name, "üñíčöĐ€"); + assert_eq!(a.b.help, Some("ASCII")); + let a = Arg::from_usage("<üñíčöĐ€> 'üñíčöĐ€'"); + assert_eq!(a.b.name, "üñíčöĐ€"); + assert_eq!(a.b.help, Some("üñíčöĐ€")); + let a = Arg::from_usage("-ø 'ø'"); + assert_eq!(a.b.name, "ø"); + assert_eq!(a.s.short, Some('ø')); + assert_eq!(a.b.help, Some("ø")); + let a = Arg::from_usage("--üñíčöĐ€ 'Nōṫ ASCII'"); + assert_eq!(a.b.name, "üñíčöĐ€"); + assert_eq!(a.s.long, Some("üñíčöĐ€")); + assert_eq!(a.b.help, Some("Nōṫ ASCII")); + let a = Arg::from_usage("[ñämê] --ôpt=[üñíčöĐ€] 'hælp'"); + assert_eq!(a.b.name, "ñämê"); + assert_eq!(a.s.long, Some("ôpt")); + assert_eq!( + a.v.val_names.unwrap().values().collect::<Vec<_>>(), + [&"üñíčöĐ€"] + ); + assert_eq!(a.b.help, Some("hælp")); + } +} |