aboutsummaryrefslogtreecommitdiff
path: root/clap/src/usage_parser.rs
diff options
context:
space:
mode:
Diffstat (limited to 'clap/src/usage_parser.rs')
-rw-r--r--clap/src/usage_parser.rs1347
1 files changed, 1347 insertions, 0 deletions
diff --git a/clap/src/usage_parser.rs b/clap/src/usage_parser.rs
new file mode 100644
index 0000000..f6d5ac6
--- /dev/null
+++ b/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"));
+ }
+}
generated by cgit v1.2.1 (git 2.18.0) at 2024-05-18 23:43:18 +0000