vendor/clap/src/build/usage_parser.rs

   1 #![allow(deprecated)]
   2
   3 // Internal
   4 use crate::{
   5     build::{Arg, ArgSettings},
   6     INTERNAL_ERROR_MSG,
   7 };
   8
   9 #[derive(PartialEq, Debug)]
  10 enum UsageToken {
  11     Name,
  12     ValName,
  13     Short,
  14     Long,
  15     Help,
  16     Multiple,
  17     Unknown,
  18     Default,
  19 }
  20
  21 #[derive(Debug)]
  22 pub(crate) struct UsageParser<'help> {
  23     usage: &'help str,
  24     pos: usize,
  25     start: usize,
  26     prev: UsageToken,
  27     explicit_name_set: bool,
  28 }
  29
  30 impl<'help> UsageParser<'help> {
  31     fn new(usage: &'help str) -> Self {
  32         debug!("new: usage={:?}", usage);
  33         UsageParser {
  34             usage,
  35             pos: 0,
  36             start: 0,
  37             prev: UsageToken::Unknown,
  38             explicit_name_set: false,
  39         }
  40     }
  41
  42     pub(crate) fn from_usage(usage: &'help str) -> Self {
  43         debug!("UsageParser::from_usage");
  44         UsageParser::new(usage)
  45     }
  46
  47     pub(crate) fn parse(mut self) -> Arg<'help> {
  48         debug!("UsageParser::parse");
  49         let mut arg = Arg::default();
  50         loop {
  51             debug!("UsageParser::parse:iter: pos={}", self.pos);
  52             self.stop_at(token);
  53             if let Some(&c) = self.usage.as_bytes().get(self.pos) {
  54                 match c {
  55                     b'-' => self.short_or_long(&mut arg),
  56                     b'.' => self.multiple(&mut arg),
  57                     b'@' => self.default(&mut arg),
  58                     b'\'' => self.help(&mut arg),
  59                     _ => self.name(&mut arg),
  60                 }
  61             } else {
  62                 break;
  63             }
  64         }
  65
  66         debug!("UsageParser::parse: vals...{:?}", arg.val_names);
  67         arg
  68     }
  69
  70     fn name(&mut self, arg: &mut Arg<'help>) {
  71         debug!("UsageParser::name");
  72         if *self
  73             .usage
  74             .as_bytes()
  75             .get(self.pos)
  76             .expect(INTERNAL_ERROR_MSG)
  77             == b'<'
  78             && !self.explicit_name_set
  79         {
  80             arg.settings.set(ArgSettings::Required);
  81         }
  82         self.pos += 1;
  83         self.stop_at(name_end);
  84         let name = &self.usage[self.start..self.pos];
  85         if self.prev == UsageToken::Unknown {
  86             debug!("UsageParser::name: setting name...{}", name);
  87             arg.id = name.into();
  88             arg.name = name;
  89             if arg.long.is_none() && arg.short.is_none() {
  90                 debug!("name: explicit name set...");
  91                 self.explicit_name_set = true;
  92                 self.prev = UsageToken::Name;
  93             }
  94         } else {
  95             debug!("UsageParser::name: setting val name...{}", name);
  96             if arg.val_names.is_empty() {
  97                 arg.settings.set(ArgSettings::TakesValue);
  98             }
  99             let len = arg.val_names.len();
 100             arg.val_names.insert(len, name);
 101             self.prev = UsageToken::ValName;
 102         }
 103     }
 104
 105     fn stop_at<F>(&mut self, f: F)
 106     where
 107         F: Fn(u8) -> bool,
 108     {
 109         debug!("UsageParser::stop_at");
 110         self.start = self.pos;
 111         self.pos += self.usage[self.start..]
 112             .bytes()
 113             .take_while(|&b| f(b))
 114             .count();
 115     }
 116
 117     fn short_or_long(&mut self, arg: &mut Arg<'help>) {
 118         debug!("UsageParser::short_or_long");
 119         self.pos += 1;
 120         if *self
 121             .usage
 122             .as_bytes()
 123             .get(self.pos)
 124             .expect(INTERNAL_ERROR_MSG)
 125             == b'-'
 126         {
 127             self.pos += 1;
 128             self.long(arg);
 129             return;
 130         }
 131         self.short(arg)
 132     }
 133
 134     fn long(&mut self, arg: &mut Arg<'help>) {
 135         debug!("UsageParser::long");
 136         self.stop_at(long_end);
 137         let name = &self.usage[self.start..self.pos];
 138         if !self.explicit_name_set {
 139             debug!("UsageParser::long: setting name...{}", name);
 140             arg.id = name.into();
 141             arg.name = name;
 142         }
 143         debug!("UsageParser::long: setting long...{}", name);
 144         arg.long = Some(name);
 145         self.prev = UsageToken::Long;
 146     }
 147
 148     fn short(&mut self, arg: &mut Arg<'help>) {
 149         debug!("UsageParser::short");
 150         let start = &self.usage[self.pos..];
 151         let short = start.chars().next().expect(INTERNAL_ERROR_MSG);
 152         debug!("UsageParser::short: setting short...{}", short);
 153         arg.short = Some(short);
 154         if arg.name.is_empty() {
 155             // --long takes precedence but doesn't set self.explicit_name_set
 156             let name = &start[..short.len_utf8()];
 157             debug!("UsageParser::short: setting name...{}", name);
 158             arg.id = name.into();
 159             arg.name = name;
 160         }
 161         self.prev = UsageToken::Short;
 162     }
 163
 164     // "something..."
 165     fn multiple(&mut self, arg: &mut Arg) {
 166         debug!("UsageParser::multiple");
 167         let mut dot_counter = 1;
 168         let start = self.pos;
 169         let mut bytes = self.usage[start..].bytes();
 170         while bytes.next() == Some(b'.') {
 171             dot_counter += 1;
 172             self.pos += 1;
 173             if dot_counter == 3 {
 174                 debug!("UsageParser::multiple: setting multiple");
 175                 arg.settings.set(ArgSettings::MultipleOccurrences);
 176                 if arg.is_takes_value_set() {
 177                     arg.settings.set(ArgSettings::MultipleValues);
 178                     arg.settings.set(ArgSettings::UseValueDelimiter);
 179                     arg.val_delim.get_or_insert(',');
 180                 }
 181                 self.prev = UsageToken::Multiple;
 182                 self.pos += 1;
 183                 break;
 184             }
 185         }
 186     }
 187
 188     fn help(&mut self, arg: &mut Arg<'help>) {
 189         debug!("UsageParser::help");
 190         self.stop_at(help_start);
 191         self.start = self.pos + 1;
 192         self.pos = self.usage.len() - 1;
 193         debug!(
 194             "UsageParser::help: setting help...{}",
 195             &self.usage[self.start..self.pos]
 196         );
 197         arg.help = Some(&self.usage[self.start..self.pos]);
 198         self.pos += 1; // Move to next byte to keep from thinking ending ' is a start
 199         self.prev = UsageToken::Help;
 200     }
 201
 202     fn default(&mut self, arg: &mut Arg<'help>) {
 203         debug!(
 204             "UsageParser::default: from=\"{}\"",
 205             &self.usage[self.pos..self.usage.len()]
 206         );
 207         self.pos += 1; // Skip @
 208         self.stop_at(default_value_end); // Find first space after value
 209         debug!(
 210             "UsageParser::default: setting default...\"{}\"",
 211             &self.usage[self.start..self.pos]
 212         );
 213         arg.settings.set(ArgSettings::TakesValue);
 214         arg.default_vals = vec![std::ffi::OsStr::new(&self.usage[self.start..self.pos])];
 215         self.prev = UsageToken::Default;
 216     }
 217 }
 218
 219 #[inline]
 220 fn name_end(b: u8) -> bool {
 221     b != b']' && b != b'>'
 222 }
 223
 224 #[inline]
 225 fn token(b: u8) -> bool {
 226     b != b'\'' && b != b'.' && b != b'<' && b != b'[' && b != b'-' && b != b'@'
 227 }
 228
 229 #[inline]
 230 fn long_end(b: u8) -> bool {
 231     b != b'\'' && b != b'.' && b != b'<' && b != b'[' && b != b'=' && b != b' '
 232 }
 233
 234 #[inline]
 235 fn help_start(b: u8) -> bool {
 236     b != b'\''
 237 }
 238
 239 #[inline]
 240 fn default_value_end(b: u8) -> bool {
 241     b != b' '
 242 }
 243
 244 #[cfg(test)]
 245 mod test {
 246     #![allow(deprecated)]
 247
 248     use crate::build::{Arg, ArgSettings};
 249
 250     #[allow(clippy::cognitive_complexity)]
 251     #[test]
 252     fn create_flag_usage() {
 253         let a = Arg::from_usage("[flag] -f 'some help info'");
 254         assert_eq!(a.name, "flag");
 255         assert_eq!(a.short.unwrap(), 'f');
 256         assert!(a.long.is_none());
 257         assert_eq!(a.help.unwrap(), "some help info");
 258         assert!(!a.is_multiple_occurrences_set());
 259         assert!(a.val_names.is_empty());
 260
 261         let a = Arg::from_usage("[flag] --flag 'some help info'");
 262         assert_eq!(a.name, "flag");
 263         assert_eq!(a.long.unwrap(), "flag");
 264         assert!(a.short.is_none());
 265         assert_eq!(a.help.unwrap(), "some help info");
 266         assert!(!a.is_multiple_occurrences_set());
 267         assert!(a.val_names.is_empty());
 268
 269         let a = Arg::from_usage("--flag 'some help info'");
 270         assert_eq!(a.name, "flag");
 271         assert_eq!(a.long.unwrap(), "flag");
 272         assert!(a.short.is_none());
 273         assert_eq!(a.help.unwrap(), "some help info");
 274         assert!(!a.is_multiple_occurrences_set());
 275         assert!(a.val_names.is_empty());
 276
 277         let a = Arg::from_usage("[flag] -f --flag 'some help info'");
 278         assert_eq!(a.name, "flag");
 279         assert_eq!(a.short.unwrap(), 'f');
 280         assert_eq!(a.long.unwrap(), "flag");
 281         assert_eq!(a.help.unwrap(), "some help info");
 282         assert!(!a.is_multiple_occurrences_set());
 283         assert!(a.val_names.is_empty());
 284
 285         let a = Arg::from_usage("[flag] -f... 'some help info'");
 286         assert_eq!(a.name, "flag");
 287         assert_eq!(a.short.unwrap(), 'f');
 288         assert!(a.long.is_none());
 289         assert_eq!(a.help.unwrap(), "some help info");
 290         assert!(a.is_multiple_occurrences_set());
 291         assert!(a.val_names.is_empty());
 292
 293         let a = Arg::from_usage("[flag] -f --flag... 'some help info'");
 294         assert_eq!(a.name, "flag");
 295         assert_eq!(a.long.unwrap(), "flag");
 296         assert_eq!(a.short.unwrap(), 'f');
 297         assert_eq!(a.help.unwrap(), "some help info");
 298         assert!(a.is_multiple_occurrences_set());
 299         assert!(a.val_names.is_empty());
 300
 301         let a = Arg::from_usage("-f --flag... 'some help info'");
 302         assert_eq!(a.name, "flag");
 303         assert_eq!(a.long.unwrap(), "flag");
 304         assert_eq!(a.short.unwrap(), 'f');
 305         assert_eq!(a.help.unwrap(), "some help info");
 306         assert!(a.is_multiple_occurrences_set());
 307         assert!(a.val_names.is_empty());
 308
 309         let a = Arg::from_usage("--flags");
 310         assert_eq!(a.name, "flags");
 311         assert_eq!(a.long.unwrap(), "flags");
 312         assert!(a.val_names.is_empty());
 313
 314         let a = Arg::from_usage("--flags...");
 315         assert_eq!(a.name, "flags");
 316         assert_eq!(a.long.unwrap(), "flags");
 317         assert!(a.is_multiple_occurrences_set());
 318         assert!(a.val_names.is_empty());
 319
 320         let a = Arg::from_usage("[flags] -f");
 321         assert_eq!(a.name, "flags");
 322         assert_eq!(a.short.unwrap(), 'f');
 323         assert!(a.val_names.is_empty());
 324
 325         let a = Arg::from_usage("[flags] -f...");
 326         assert_eq!(a.name, "flags");
 327         assert_eq!(a.short.unwrap(), 'f');
 328         assert!(a.is_multiple_occurrences_set());
 329         assert!(a.val_names.is_empty());
 330
 331         let a = Arg::from_usage("-f 'some help info'");
 332         assert_eq!(a.name, "f");
 333         assert_eq!(a.short.unwrap(), 'f');
 334         assert!(a.long.is_none());
 335         assert_eq!(a.help.unwrap(), "some help info");
 336         assert!(!a.is_multiple_occurrences_set());
 337         assert!(a.val_names.is_empty());
 338
 339         let a = Arg::from_usage("-f");
 340         assert_eq!(a.name, "f");
 341         assert_eq!(a.short.unwrap(), 'f');
 342         assert!(a.val_names.is_empty());
 343
 344         let a = Arg::from_usage("-f...");
 345         assert_eq!(a.name, "f");
 346         assert_eq!(a.short.unwrap(), 'f');
 347         assert!(a.is_multiple_occurrences_set());
 348         assert!(a.val_names.is_empty());
 349     }
 350
 351     #[test]
 352     fn create_option_usage0() {
 353         // Short only
 354         let a = Arg::from_usage("[option] -o [opt] 'some help info'");
 355         assert_eq!(a.name, "option");
 356         assert_eq!(a.short.unwrap(), 'o');
 357         assert!(a.long.is_none());
 358         assert_eq!(a.help.unwrap(), "some help info");
 359         assert!(!a.is_multiple_occurrences_set());
 360         assert!(!a.is_multiple_values_set());
 361         assert!(a.is_takes_value_set());
 362         assert!(!a.is_required_set());
 363         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 364     }
 365
 366     #[test]
 367     fn create_option_usage1() {
 368         let a = Arg::from_usage("-o [opt] 'some help info'");
 369         assert_eq!(a.name, "o");
 370         assert_eq!(a.short.unwrap(), 'o');
 371         assert!(a.long.is_none());
 372         assert_eq!(a.help.unwrap(), "some help info");
 373         assert!(!a.is_multiple_occurrences_set());
 374         assert!(!a.is_multiple_values_set());
 375         assert!(a.is_takes_value_set());
 376         assert!(!a.is_required_set());
 377         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 378     }
 379
 380     #[test]
 381     fn create_option_usage2() {
 382         let a = Arg::from_usage("<option> -o <opt> 'some help info'");
 383         assert_eq!(a.name, "option");
 384         assert_eq!(a.short.unwrap(), 'o');
 385         assert!(a.long.is_none());
 386         assert_eq!(a.help.unwrap(), "some help info");
 387         assert!(!a.is_multiple_occurrences_set());
 388         assert!(!a.is_multiple_values_set());
 389         assert!(a.is_takes_value_set());
 390         assert!(a.is_required_set());
 391         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 392     }
 393
 394     #[test]
 395     fn create_option_usage3() {
 396         let a = Arg::from_usage("-o <opt> 'some help info'");
 397         assert_eq!(a.name, "o");
 398         assert_eq!(a.short.unwrap(), 'o');
 399         assert!(a.long.is_none());
 400         assert_eq!(a.help.unwrap(), "some help info");
 401         assert!(!a.is_multiple_occurrences_set());
 402         assert!(!a.is_multiple_values_set());
 403         assert!(a.is_takes_value_set());
 404         assert!(a.is_required_set());
 405         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 406     }
 407
 408     #[test]
 409     fn create_option_usage4() {
 410         let a = Arg::from_usage("[option] -o [opt]... 'some help info'");
 411         assert_eq!(a.name, "option");
 412         assert_eq!(a.short.unwrap(), 'o');
 413         assert!(a.long.is_none());
 414         assert_eq!(a.help.unwrap(), "some help info");
 415         assert!(a.is_multiple_occurrences_set());
 416         assert!(a.is_multiple_values_set());
 417         assert!(a.is_takes_value_set());
 418         assert!(!a.is_required_set());
 419         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 420     }
 421
 422     #[test]
 423     fn create_option_usage5() {
 424         let a = Arg::from_usage("[option]... -o [opt] 'some help info'");
 425         assert_eq!(a.name, "option");
 426         assert_eq!(a.short.unwrap(), 'o');
 427         assert!(a.long.is_none());
 428         assert_eq!(a.help.unwrap(), "some help info");
 429         assert!(a.is_multiple_occurrences_set());
 430         assert!(!a.is_multiple_values_set());
 431         assert!(a.is_takes_value_set());
 432         assert!(!a.is_required_set());
 433         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 434     }
 435
 436     #[test]
 437     fn create_option_usage6() {
 438         let a = Arg::from_usage("-o [opt]... 'some help info'");
 439         assert_eq!(a.name, "o");
 440         assert_eq!(a.short.unwrap(), 'o');
 441         assert!(a.long.is_none());
 442         assert_eq!(a.help.unwrap(), "some help info");
 443         assert!(a.is_multiple_occurrences_set());
 444         assert!(a.is_multiple_values_set());
 445         assert!(a.is_takes_value_set());
 446         assert!(!a.is_required_set());
 447         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 448     }
 449
 450     #[test]
 451     fn create_option_usage7() {
 452         let a = Arg::from_usage("<option> -o <opt>... 'some help info'");
 453         assert_eq!(a.name, "option");
 454         assert_eq!(a.short.unwrap(), 'o');
 455         assert!(a.long.is_none());
 456         assert_eq!(a.help.unwrap(), "some help info");
 457         assert!(a.is_multiple_occurrences_set());
 458         assert!(a.is_multiple_values_set());
 459         assert!(a.is_takes_value_set());
 460         assert!(a.is_required_set());
 461         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 462     }
 463
 464     #[test]
 465     fn create_option_usage8() {
 466         let a = Arg::from_usage("<option>... -o <opt> 'some help info'");
 467         assert_eq!(a.name, "option");
 468         assert_eq!(a.short.unwrap(), 'o');
 469         assert!(a.long.is_none());
 470         assert_eq!(a.help.unwrap(), "some help info");
 471         assert!(a.is_multiple_occurrences_set());
 472         assert!(!a.is_multiple_values_set());
 473         assert!(a.is_takes_value_set());
 474         assert!(a.is_required_set());
 475         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 476     }
 477
 478     #[test]
 479     fn create_option_usage9() {
 480         let a = Arg::from_usage("-o <opt>... 'some help info'");
 481         assert_eq!(a.name, "o");
 482         assert_eq!(a.short.unwrap(), 'o');
 483         assert!(a.long.is_none());
 484         assert_eq!(a.help.unwrap(), "some help info");
 485         assert!(a.is_multiple_occurrences_set());
 486         assert!(a.is_multiple_values_set());
 487         assert!(a.is_takes_value_set());
 488         assert!(a.is_required_set());
 489         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 490     }
 491
 492     #[test]
 493     fn create_option_usage_long1() {
 494         let a = Arg::from_usage("[option] --opt [opt] 'some help info'");
 495         assert_eq!(a.name, "option");
 496         assert_eq!(a.long.unwrap(), "opt");
 497         assert!(a.short.is_none());
 498         assert_eq!(a.help.unwrap(), "some help info");
 499         assert!(!a.is_multiple_occurrences_set());
 500         assert!(!a.is_multiple_values_set());
 501         assert!(a.is_takes_value_set());
 502         assert!(!a.is_required_set());
 503         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 504     }
 505
 506     #[test]
 507     fn create_option_usage_long2() {
 508         let a = Arg::from_usage("--opt [option] 'some help info'");
 509         assert_eq!(a.name, "opt");
 510         assert_eq!(a.long.unwrap(), "opt");
 511         assert!(a.short.is_none());
 512         assert_eq!(a.help.unwrap(), "some help info");
 513         assert!(!a.is_multiple_occurrences_set());
 514         assert!(!a.is_multiple_values_set());
 515         assert!(a.is_takes_value_set());
 516         assert!(!a.is_required_set());
 517         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 518     }
 519
 520     #[test]
 521     fn create_option_usage_long3() {
 522         let a = Arg::from_usage("<option> --opt <opt> 'some help info'");
 523         assert_eq!(a.name, "option");
 524         assert_eq!(a.long.unwrap(), "opt");
 525         assert!(a.short.is_none());
 526         assert_eq!(a.help.unwrap(), "some help info");
 527         assert!(!a.is_multiple_occurrences_set());
 528         assert!(!a.is_multiple_values_set());
 529         assert!(a.is_takes_value_set());
 530         assert!(a.is_required_set());
 531         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 532     }
 533
 534     #[test]
 535     fn create_option_usage_long4() {
 536         let a = Arg::from_usage("--opt <option> 'some help info'");
 537         assert_eq!(a.name, "opt");
 538         assert_eq!(a.long.unwrap(), "opt");
 539         assert!(a.short.is_none());
 540         assert_eq!(a.help.unwrap(), "some help info");
 541         assert!(!a.is_multiple_occurrences_set());
 542         assert!(!a.is_multiple_values_set());
 543         assert!(a.is_takes_value_set());
 544         assert!(a.is_required_set());
 545         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 546     }
 547
 548     #[test]
 549     fn create_option_usage_long5() {
 550         let a = Arg::from_usage("[option] --opt [opt]... 'some help info'");
 551         assert_eq!(a.name, "option");
 552         assert_eq!(a.long.unwrap(), "opt");
 553         assert!(a.short.is_none());
 554         assert_eq!(a.help.unwrap(), "some help info");
 555         assert!(a.is_multiple_occurrences_set());
 556         assert!(a.is_multiple_values_set());
 557         assert!(a.is_takes_value_set());
 558         assert!(!a.is_required_set());
 559         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 560     }
 561
 562     #[test]
 563     fn create_option_usage_long6() {
 564         let a = Arg::from_usage("[option]... --opt [opt] 'some help info'");
 565         assert_eq!(a.name, "option");
 566         assert_eq!(a.long.unwrap(), "opt");
 567         assert!(a.short.is_none());
 568         assert_eq!(a.help.unwrap(), "some help info");
 569         assert!(a.is_multiple_occurrences_set());
 570         assert!(!a.is_multiple_values_set());
 571         assert!(a.is_takes_value_set());
 572         assert!(!a.is_required_set());
 573         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 574     }
 575
 576     #[test]
 577     fn create_option_usage_long7() {
 578         let a = Arg::from_usage("--opt [option]... 'some help info'");
 579         assert_eq!(a.name, "opt");
 580         assert_eq!(a.long.unwrap(), "opt");
 581         assert!(a.short.is_none());
 582         assert_eq!(a.help.unwrap(), "some help info");
 583         assert!(a.is_multiple_occurrences_set());
 584         assert!(a.is_multiple_values_set());
 585         assert!(a.is_takes_value_set());
 586         assert!(!a.is_required_set());
 587         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 588     }
 589
 590     #[test]
 591     fn create_option_usage_long8() {
 592         let a = Arg::from_usage("<option> --opt <opt>... 'some help info'");
 593         assert_eq!(a.name, "option");
 594         assert_eq!(a.long.unwrap(), "opt");
 595         assert!(a.short.is_none());
 596         assert_eq!(a.help.unwrap(), "some help info");
 597         assert!(a.is_multiple_occurrences_set());
 598         assert!(a.is_multiple_values_set());
 599         assert!(a.is_takes_value_set());
 600         assert!(a.is_required_set());
 601         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 602     }
 603
 604     #[test]
 605     fn create_option_usage_long9() {
 606         let a = Arg::from_usage("<option>... --opt <opt> 'some help info'");
 607         assert_eq!(a.name, "option");
 608         assert_eq!(a.long.unwrap(), "opt");
 609         assert!(a.short.is_none());
 610         assert_eq!(a.help.unwrap(), "some help info");
 611         assert!(a.is_multiple_occurrences_set());
 612         assert!(!a.is_multiple_values_set());
 613         assert!(a.is_takes_value_set());
 614         assert!(a.is_required_set());
 615         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 616     }
 617
 618     #[test]
 619     fn create_option_usage_long10() {
 620         let a = Arg::from_usage("--opt <option>... 'some help info'");
 621         assert_eq!(a.name, "opt");
 622         assert_eq!(a.long.unwrap(), "opt");
 623         assert!(a.short.is_none());
 624         assert_eq!(a.help.unwrap(), "some help info");
 625         assert!(a.is_multiple_occurrences_set());
 626         assert!(a.is_multiple_values_set());
 627         assert!(a.is_takes_value_set());
 628         assert!(a.is_required_set());
 629         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 630     }
 631
 632     #[test]
 633     fn create_option_usage_long_equals1() {
 634         let a = Arg::from_usage("[option] --opt=[opt] 'some help info'");
 635         assert_eq!(a.name, "option");
 636         assert_eq!(a.long.unwrap(), "opt");
 637         assert!(a.short.is_none());
 638         assert_eq!(a.help.unwrap(), "some help info");
 639         assert!(!a.is_multiple_occurrences_set());
 640         assert!(!a.is_multiple_values_set());
 641         assert!(a.is_takes_value_set());
 642         assert!(!a.is_required_set());
 643         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 644     }
 645
 646     #[test]
 647     fn create_option_usage_long_equals2() {
 648         let a = Arg::from_usage("--opt=[option] 'some help info'");
 649         assert_eq!(a.name, "opt");
 650         assert_eq!(a.long.unwrap(), "opt");
 651         assert!(a.short.is_none());
 652         assert_eq!(a.help.unwrap(), "some help info");
 653         assert!(!a.is_multiple_occurrences_set());
 654         assert!(!a.is_multiple_values_set());
 655         assert!(a.is_takes_value_set());
 656         assert!(!a.is_required_set());
 657         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 658     }
 659
 660     #[test]
 661     fn create_option_usage_long_equals3() {
 662         let a = Arg::from_usage("<option> --opt=<opt> 'some help info'");
 663         assert_eq!(a.name, "option");
 664         assert_eq!(a.long.unwrap(), "opt");
 665         assert!(a.short.is_none());
 666         assert_eq!(a.help.unwrap(), "some help info");
 667         assert!(!a.is_multiple_occurrences_set());
 668         assert!(!a.is_multiple_values_set());
 669         assert!(a.is_takes_value_set());
 670         assert!(a.is_required_set());
 671         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 672     }
 673
 674     #[test]
 675     fn create_option_usage_long_equals4() {
 676         let a = Arg::from_usage("--opt=<option> 'some help info'");
 677         assert_eq!(a.name, "opt");
 678         assert_eq!(a.long.unwrap(), "opt");
 679         assert!(a.short.is_none());
 680         assert_eq!(a.help.unwrap(), "some help info");
 681         assert!(!a.is_multiple_occurrences_set());
 682         assert!(!a.is_multiple_values_set());
 683         assert!(a.is_takes_value_set());
 684         assert!(a.is_required_set());
 685         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 686     }
 687
 688     #[test]
 689     fn create_option_usage_long_equals5() {
 690         let a = Arg::from_usage("[option] --opt=[opt]... 'some help info'");
 691         assert_eq!(a.name, "option");
 692         assert_eq!(a.long.unwrap(), "opt");
 693         assert!(a.short.is_none());
 694         assert_eq!(a.help.unwrap(), "some help info");
 695         assert!(a.is_multiple_occurrences_set());
 696         assert!(a.is_multiple_values_set());
 697         assert!(a.is_takes_value_set());
 698         assert!(!a.is_required_set());
 699         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 700     }
 701
 702     #[test]
 703     fn create_option_usage_long_equals6() {
 704         let a = Arg::from_usage("[option]... --opt=[opt] 'some help info'");
 705         assert_eq!(a.name, "option");
 706         assert_eq!(a.long.unwrap(), "opt");
 707         assert!(a.short.is_none());
 708         assert_eq!(a.help.unwrap(), "some help info");
 709         assert!(a.is_multiple_occurrences_set());
 710         assert!(!a.is_multiple_values_set());
 711         assert!(a.is_takes_value_set());
 712         assert!(!a.is_required_set());
 713         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 714     }
 715
 716     #[test]
 717     fn create_option_usage_long_equals7() {
 718         let a = Arg::from_usage("--opt=[option]... 'some help info'");
 719         assert_eq!(a.name, "opt");
 720         assert_eq!(a.long.unwrap(), "opt");
 721         assert!(a.short.is_none());
 722         assert_eq!(a.help.unwrap(), "some help info");
 723         assert!(a.is_multiple_occurrences_set());
 724         assert!(a.is_multiple_values_set());
 725         assert!(a.is_takes_value_set());
 726         assert!(!a.is_required_set());
 727         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 728     }
 729
 730     #[test]
 731     fn create_option_usage_long_equals8() {
 732         let a = Arg::from_usage("<option> --opt=<opt>... 'some help info'");
 733         assert_eq!(a.name, "option");
 734         assert_eq!(a.long.unwrap(), "opt");
 735         assert!(a.short.is_none());
 736         assert_eq!(a.help.unwrap(), "some help info");
 737         assert!(a.is_multiple_occurrences_set());
 738         assert!(a.is_multiple_values_set());
 739         assert!(a.is_takes_value_set());
 740         assert!(a.is_required_set());
 741         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 742     }
 743
 744     #[test]
 745     fn create_option_usage_long_equals9() {
 746         let a = Arg::from_usage("<option>... --opt=<opt> 'some help info'");
 747         assert_eq!(a.name, "option");
 748         assert_eq!(a.long.unwrap(), "opt");
 749         assert!(a.short.is_none());
 750         assert_eq!(a.help.unwrap(), "some help info");
 751         assert!(a.is_multiple_occurrences_set());
 752         assert!(!a.is_multiple_values_set());
 753         assert!(a.is_takes_value_set());
 754         assert!(a.is_required_set());
 755         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 756     }
 757
 758     #[test]
 759     fn create_option_usage_long_equals10() {
 760         let a = Arg::from_usage("--opt=<option>... 'some help info'");
 761         assert_eq!(a.name, "opt");
 762         assert_eq!(a.long.unwrap(), "opt");
 763         assert!(a.short.is_none());
 764         assert_eq!(a.help.unwrap(), "some help info");
 765         assert!(a.is_multiple_occurrences_set());
 766         assert!(a.is_multiple_values_set());
 767         assert!(a.is_takes_value_set());
 768         assert!(a.is_required_set());
 769         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 770     }
 771
 772     #[test]
 773     fn create_option_usage_both1() {
 774         let a = Arg::from_usage("[option] -o --opt [option] 'some help info'");
 775         assert_eq!(a.name, "option");
 776         assert_eq!(a.long.unwrap(), "opt");
 777         assert_eq!(a.short.unwrap(), 'o');
 778         assert_eq!(a.help.unwrap(), "some help info");
 779         assert!(!a.is_multiple_occurrences_set());
 780         assert!(!a.is_multiple_values_set());
 781         assert!(a.is_takes_value_set());
 782         assert!(!a.is_required_set());
 783         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 784     }
 785
 786     #[test]
 787     fn create_option_usage_both2() {
 788         let a = Arg::from_usage("-o --opt [option] 'some help info'");
 789         assert_eq!(a.name, "opt");
 790         assert_eq!(a.long.unwrap(), "opt");
 791         assert_eq!(a.short.unwrap(), 'o');
 792         assert_eq!(a.help.unwrap(), "some help info");
 793         assert!(!a.is_multiple_occurrences_set());
 794         assert!(!a.is_multiple_values_set());
 795         assert!(a.is_takes_value_set());
 796         assert!(!a.is_required_set());
 797         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 798     }
 799
 800     #[test]
 801     fn create_option_usage_both3() {
 802         let a = Arg::from_usage("<option> -o --opt <opt> 'some help info'");
 803         assert_eq!(a.name, "option");
 804         assert_eq!(a.long.unwrap(), "opt");
 805         assert_eq!(a.short.unwrap(), 'o');
 806         assert_eq!(a.help.unwrap(), "some help info");
 807         assert!(!a.is_multiple_occurrences_set());
 808         assert!(!a.is_multiple_values_set());
 809         assert!(a.is_takes_value_set());
 810         assert!(a.is_required_set());
 811         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 812     }
 813
 814     #[test]
 815     fn create_option_usage_both4() {
 816         let a = Arg::from_usage("-o --opt <option> 'some help info'");
 817         assert_eq!(a.name, "opt");
 818         assert_eq!(a.long.unwrap(), "opt");
 819         assert_eq!(a.short.unwrap(), 'o');
 820         assert_eq!(a.help.unwrap(), "some help info");
 821         assert!(!a.is_multiple_occurrences_set());
 822         assert!(!a.is_multiple_values_set());
 823         assert!(a.is_takes_value_set());
 824         assert!(a.is_required_set());
 825         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 826     }
 827
 828     #[test]
 829     fn create_option_usage_both5() {
 830         let a = Arg::from_usage("[option]... -o --opt [option] 'some help info'");
 831         assert_eq!(a.name, "option");
 832         assert_eq!(a.long.unwrap(), "opt");
 833         assert_eq!(a.short.unwrap(), 'o');
 834         assert_eq!(a.help.unwrap(), "some help info");
 835         assert!(a.is_multiple_occurrences_set());
 836         assert!(!a.is_multiple_values_set());
 837         assert!(a.is_takes_value_set());
 838         assert!(!a.is_required_set());
 839         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 840     }
 841
 842     #[test]
 843     fn create_option_usage_both6() {
 844         let a = Arg::from_usage("-o --opt [option]... 'some help info'");
 845         assert_eq!(a.name, "opt");
 846         assert_eq!(a.long.unwrap(), "opt");
 847         assert_eq!(a.short.unwrap(), 'o');
 848         assert_eq!(a.help.unwrap(), "some help info");
 849         assert!(a.is_multiple_occurrences_set());
 850         assert!(a.is_multiple_values_set());
 851         assert!(a.is_takes_value_set());
 852         assert!(!a.is_required_set());
 853         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 854     }
 855
 856     #[test]
 857     fn create_option_usage_both7() {
 858         let a = Arg::from_usage("<option>... -o --opt <opt> 'some help info'");
 859         assert_eq!(a.name, "option");
 860         assert_eq!(a.long.unwrap(), "opt");
 861         assert_eq!(a.short.unwrap(), 'o');
 862         assert_eq!(a.help.unwrap(), "some help info");
 863         assert!(a.is_multiple_occurrences_set());
 864         assert!(!a.is_multiple_values_set());
 865         assert!(a.is_takes_value_set());
 866         assert!(a.is_required_set());
 867         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 868     }
 869
 870     #[test]
 871     fn create_option_usage_both8() {
 872         let a = Arg::from_usage("-o --opt <option>... 'some help info'");
 873         assert_eq!(a.name, "opt");
 874         assert_eq!(a.long.unwrap(), "opt");
 875         assert_eq!(a.short.unwrap(), 'o');
 876         assert_eq!(a.help.unwrap(), "some help info");
 877         assert!(a.is_multiple_occurrences_set());
 878         assert!(a.is_multiple_values_set());
 879         assert!(a.is_takes_value_set());
 880         assert!(a.is_required_set());
 881         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 882     }
 883
 884     #[test]
 885     fn create_option_usage_both_equals1() {
 886         let a = Arg::from_usage("[option] -o --opt=[option] 'some help info'");
 887         assert_eq!(a.name, "option");
 888         assert_eq!(a.long.unwrap(), "opt");
 889         assert_eq!(a.short.unwrap(), 'o');
 890         assert_eq!(a.help.unwrap(), "some help info");
 891         assert!(!a.is_multiple_occurrences_set());
 892         assert!(!a.is_multiple_values_set());
 893         assert!(a.is_takes_value_set());
 894         assert!(!a.is_required_set());
 895         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 896     }
 897
 898     #[test]
 899     fn create_option_usage_both_equals2() {
 900         let a = Arg::from_usage("-o --opt=[option] 'some help info'");
 901         assert_eq!(a.name, "opt");
 902         assert_eq!(a.long.unwrap(), "opt");
 903         assert_eq!(a.short.unwrap(), 'o');
 904         assert_eq!(a.help.unwrap(), "some help info");
 905         assert!(!a.is_multiple_occurrences_set());
 906         assert!(!a.is_multiple_values_set());
 907         assert!(a.is_takes_value_set());
 908         assert!(!a.is_required_set());
 909         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 910     }
 911
 912     #[test]
 913     fn create_option_usage_both_equals3() {
 914         let a = Arg::from_usage("<option> -o --opt=<opt> 'some help info'");
 915         assert_eq!(a.name, "option");
 916         assert_eq!(a.long.unwrap(), "opt");
 917         assert_eq!(a.short.unwrap(), 'o');
 918         assert_eq!(a.help.unwrap(), "some help info");
 919         assert!(!a.is_multiple_occurrences_set());
 920         assert!(!a.is_multiple_values_set());
 921         assert!(a.is_takes_value_set());
 922         assert!(a.is_required_set());
 923         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 924     }
 925
 926     #[test]
 927     fn create_option_usage_both_equals4() {
 928         let a = Arg::from_usage("-o --opt=<option> 'some help info'");
 929         assert_eq!(a.name, "opt");
 930         assert_eq!(a.long.unwrap(), "opt");
 931         assert_eq!(a.short.unwrap(), 'o');
 932         assert_eq!(a.help.unwrap(), "some help info");
 933         assert!(!a.is_multiple_occurrences_set());
 934         assert!(!a.is_multiple_values_set());
 935         assert!(a.is_takes_value_set());
 936         assert!(a.is_required_set());
 937         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 938     }
 939
 940     #[test]
 941     fn create_option_usage_both_equals5() {
 942         let a = Arg::from_usage("[option]... -o --opt=[option] 'some help info'");
 943         assert_eq!(a.name, "option");
 944         assert_eq!(a.long.unwrap(), "opt");
 945         assert_eq!(a.short.unwrap(), 'o');
 946         assert_eq!(a.help.unwrap(), "some help info");
 947         assert!(a.is_multiple_occurrences_set());
 948         assert!(!a.is_multiple_values_set());
 949         assert!(a.is_takes_value_set());
 950         assert!(!a.is_required_set());
 951         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 952     }
 953
 954     #[test]
 955     fn create_option_usage_both_equals6() {
 956         let a = Arg::from_usage("-o --opt=[option]... 'some help info'");
 957         assert_eq!(a.name, "opt");
 958         assert_eq!(a.long.unwrap(), "opt");
 959         assert_eq!(a.short.unwrap(), 'o');
 960         assert_eq!(a.help.unwrap(), "some help info");
 961         assert!(a.is_multiple_occurrences_set());
 962         assert!(a.is_multiple_values_set());
 963         assert!(a.is_takes_value_set());
 964         assert!(!a.is_required_set());
 965         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 966     }
 967
 968     #[test]
 969     fn create_option_usage_both_equals7() {
 970         let a = Arg::from_usage("<option>... -o --opt=<opt> 'some help info'");
 971         assert_eq!(a.name, "option");
 972         assert_eq!(a.long.unwrap(), "opt");
 973         assert_eq!(a.short.unwrap(), 'o');
 974         assert_eq!(a.help.unwrap(), "some help info");
 975         assert!(a.is_multiple_occurrences_set());
 976         assert!(!a.is_multiple_values_set());
 977         assert!(a.is_takes_value_set());
 978         assert!(a.is_required_set());
 979         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"opt"]);
 980     }
 981
 982     #[test]
 983     fn create_option_usage_both_equals8() {
 984         let a = Arg::from_usage("-o --opt=<option>... 'some help info'");
 985         assert_eq!(a.name, "opt");
 986         assert_eq!(a.long.unwrap(), "opt");
 987         assert_eq!(a.short.unwrap(), 'o');
 988         assert_eq!(a.help.unwrap(), "some help info");
 989         assert!(a.is_multiple_occurrences_set());
 990         assert!(a.is_multiple_values_set());
 991         assert!(a.is_takes_value_set());
 992         assert!(a.is_required_set());
 993         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"option"]);
 994     }
 995
 996     #[test]
 997     fn create_option_with_vals1() {
 998         let a = Arg::from_usage("-o <file> <mode> 'some help info'");
 999         assert_eq!(a.name, "o");
1000         assert!(a.long.is_none());
1001         assert_eq!(a.short.unwrap(), 'o');
1002         assert_eq!(a.help.unwrap(), "some help info");
1003         assert!(!a.is_multiple_occurrences_set());
1004         assert!(!a.is_multiple_values_set());
1005         assert!(a.is_takes_value_set());
1006         assert!(a.is_required_set());
1007         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"file", &"mode"]);
1008     }
1009
1010     #[test]
1011     fn create_option_with_vals2() {
1012         let a = Arg::from_usage("-o <file> <mode>... 'some help info'");
1013         assert_eq!(a.name, "o");
1014         assert!(a.long.is_none());
1015         assert_eq!(a.short.unwrap(), 'o');
1016         assert_eq!(a.help.unwrap(), "some help info");
1017         assert!(a.is_multiple_occurrences_set());
1018         assert!(a.is_multiple_values_set());
1019         assert!(a.is_takes_value_set());
1020         assert!(a.is_required_set());
1021         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"file", &"mode"]);
1022     }
1023
1024     #[test]
1025     fn create_option_with_vals3() {
1026         let a = Arg::from_usage("--opt <file> <mode>... 'some help info'");
1027         assert_eq!(a.name, "opt");
1028         assert!(a.short.is_none());
1029         assert_eq!(a.long.unwrap(), "opt");
1030         assert_eq!(a.help.unwrap(), "some help info");
1031         assert!(a.is_multiple_occurrences_set());
1032         assert!(a.is_multiple_values_set());
1033         assert!(a.is_takes_value_set());
1034         assert!(a.is_required_set());
1035         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"file", &"mode"]);
1036     }
1037
1038     #[test]
1039     fn create_option_with_vals4() {
1040         let a = Arg::from_usage("[myopt] --opt <file> <mode> 'some help info'");
1041         assert_eq!(a.name, "myopt");
1042         assert!(a.short.is_none());
1043         assert_eq!(a.long.unwrap(), "opt");
1044         assert_eq!(a.help.unwrap(), "some help info");
1045         assert!(!a.is_multiple_occurrences_set());
1046         assert!(!a.is_multiple_values_set());
1047         assert!(a.is_takes_value_set());
1048         assert!(!a.is_required_set());
1049         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"file", &"mode"]);
1050     }
1051
1052     #[test]
1053     fn create_option_with_vals5() {
1054         let a = Arg::from_usage("--opt <file> <mode> 'some help info'");
1055         assert_eq!(a.name, "opt");
1056         assert!(a.short.is_none());
1057         assert_eq!(a.long.unwrap(), "opt");
1058         assert_eq!(a.help.unwrap(), "some help info");
1059         assert!(!a.is_multiple_occurrences_set());
1060         assert!(!a.is_multiple_values_set());
1061         assert!(a.is_takes_value_set());
1062         assert!(a.is_required_set());
1063     }
1064
1065     #[test]
1066     fn create_positional_usage() {
1067         let a = Arg::from_usage("[pos] 'some help info'");
1068         assert_eq!(a.name, "pos");
1069         assert_eq!(a.help.unwrap(), "some help info");
1070         assert!(!a.is_multiple_occurrences_set());
1071         assert!(!a.is_multiple_values_set());
1072         assert!(!a.is_required_set());
1073         assert!(a.val_names.is_empty());
1074     }
1075
1076     #[test]
1077     fn create_positional_usage0() {
1078         let a = Arg::from_usage("<pos> 'some help info'");
1079         assert_eq!(a.name, "pos");
1080         assert_eq!(a.help.unwrap(), "some help info");
1081         assert!(!a.is_multiple_occurrences_set());
1082         assert!(!a.is_multiple_values_set());
1083         assert!(a.is_required_set());
1084         assert!(a.val_names.is_empty());
1085     }
1086
1087     #[test]
1088     fn pos_mult_help() {
1089         let a = Arg::from_usage("[pos]... 'some help info'");
1090         assert_eq!(a.name, "pos");
1091         assert_eq!(a.help.unwrap(), "some help info");
1092         assert!(a.is_multiple_occurrences_set());
1093         assert!(!a.is_multiple_values_set());
1094         assert!(!a.is_required_set());
1095         assert!(a.val_names.is_empty());
1096     }
1097
1098     #[test]
1099     fn pos_help_lit_single_quote() {
1100         let a = Arg::from_usage("[pos]... 'some help\' info'");
1101         assert_eq!(a.name, "pos");
1102         assert_eq!(a.help.unwrap(), "some help' info");
1103         assert!(a.is_multiple_occurrences_set());
1104         assert!(!a.is_multiple_values_set());
1105         assert!(!a.is_required_set());
1106         assert!(a.val_names.is_empty());
1107     }
1108
1109     #[test]
1110     fn pos_help_double_lit_single_quote() {
1111         let a = Arg::from_usage("[pos]... 'some \'help\' info'");
1112         assert_eq!(a.name, "pos");
1113         assert_eq!(a.help.unwrap(), "some 'help' info");
1114         assert!(a.is_multiple_occurrences_set());
1115         assert!(!a.is_multiple_values_set());
1116         assert!(!a.is_required_set());
1117         assert!(a.val_names.is_empty());
1118     }
1119
1120     #[test]
1121     fn pos_help_newline() {
1122         let a = Arg::from_usage(
1123             "[pos]... 'some help{n}\
1124              info'",
1125         );
1126         assert_eq!(a.name, "pos");
1127         assert_eq!(a.help.unwrap(), "some help{n}info");
1128         assert!(a.is_multiple_occurrences_set());
1129         assert!(!a.is_multiple_values_set());
1130         assert!(!a.is_required_set());
1131         assert!(a.val_names.is_empty());
1132     }
1133
1134     #[test]
1135     fn pos_help_newline_lit_sq() {
1136         let a = Arg::from_usage(
1137             "[pos]... 'some help\' stuff{n}\
1138              info'",
1139         );
1140         assert_eq!(a.name, "pos");
1141         assert_eq!(a.help.unwrap(), "some help' stuff{n}info");
1142         assert!(a.is_multiple_occurrences_set());
1143         assert!(!a.is_multiple_values_set());
1144         assert!(!a.is_required_set());
1145         assert!(a.val_names.is_empty());
1146     }
1147
1148     #[test]
1149     fn pos_req_mult_help() {
1150         let a = Arg::from_usage("<pos>... 'some help info'");
1151         assert_eq!(a.name, "pos");
1152         assert_eq!(a.help.unwrap(), "some help info");
1153         assert!(a.is_multiple_occurrences_set());
1154         assert!(!a.is_multiple_values_set());
1155         assert!(a.is_required_set());
1156         assert!(a.val_names.is_empty());
1157     }
1158
1159     #[test]
1160     fn pos_req() {
1161         let a = Arg::from_usage("<pos>");
1162         assert_eq!(a.name, "pos");
1163         assert!(!a.is_multiple_occurrences_set());
1164         assert!(!a.is_multiple_values_set());
1165         assert!(a.is_required_set());
1166         assert!(a.val_names.is_empty());
1167     }
1168
1169     #[test]
1170     fn pos_mult() {
1171         let a = Arg::from_usage("[pos]...");
1172         assert_eq!(a.name, "pos");
1173         assert!(a.is_multiple_occurrences_set());
1174         assert!(!a.is_multiple_values_set());
1175         assert!(!a.is_required_set());
1176         assert!(a.val_names.is_empty());
1177     }
1178
1179     #[test]
1180     fn pos_req_mult_def_help() {
1181         let a = Arg::from_usage("<pos>... @a 'some help info'");
1182         assert_eq!(a.name, "pos");
1183         assert_eq!(a.help.unwrap(), "some help info");
1184         assert!(a.is_multiple_occurrences_set());
1185         assert!(!a.is_multiple_values_set());
1186         assert!(a.is_required_set());
1187         assert!(a.val_names.is_empty());
1188         assert_eq!(a.default_vals, vec![std::ffi::OsStr::new("a")]);
1189     }
1190
1191     #[test]
1192     fn create_option_with_vals1_def() {
1193         let a = Arg::from_usage("-o <file> <mode> @a 'some help info'");
1194         assert_eq!(a.name, "o");
1195         assert!(a.long.is_none());
1196         assert_eq!(a.short.unwrap(), 'o');
1197         assert_eq!(a.help.unwrap(), "some help info");
1198         assert!(!a.is_multiple_occurrences_set());
1199         assert!(!a.is_multiple_values_set());
1200         assert!(a.is_takes_value_set());
1201         assert!(a.is_required_set());
1202         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"file", &"mode"]);
1203         assert_eq!(a.default_vals, vec![std::ffi::OsStr::new("a")]);
1204     }
1205
1206     #[test]
1207     fn create_option_with_vals4_def() {
1208         let a = Arg::from_usage("[myopt] --opt <file> <mode> @a 'some help info'");
1209         assert_eq!(a.name, "myopt");
1210         assert!(a.short.is_none());
1211         assert_eq!(a.long.unwrap(), "opt");
1212         assert_eq!(a.help.unwrap(), "some help info");
1213         assert!(!a.is_multiple_occurrences_set());
1214         assert!(!a.is_multiple_values_set());
1215         assert!(a.is_takes_value_set());
1216         assert!(!a.is_required_set());
1217         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"file", &"mode"]);
1218         assert_eq!(a.default_vals, vec![std::ffi::OsStr::new("a")]);
1219     }
1220
1221     #[test]
1222     fn nonascii() {
1223         let a = Arg::from_usage("<ASCII> 'üñíčöĐ€'");
1224         assert_eq!(a.name, "ASCII");
1225         assert_eq!(a.help, Some("üñíčöĐ€"));
1226         let a = Arg::from_usage("<üñíčöĐ€> 'ASCII'");
1227         assert_eq!(a.name, "üñíčöĐ€");
1228         assert_eq!(a.help, Some("ASCII"));
1229         let a = Arg::from_usage("<üñíčöĐ€> 'üñíčöĐ€'");
1230         assert_eq!(a.name, "üñíčöĐ€");
1231         assert_eq!(a.help, Some("üñíčöĐ€"));
1232         let a = Arg::from_usage("-ø 'ø'");
1233         assert_eq!(a.name, "ø");
1234         assert_eq!(a.short, Some('ø'));
1235         assert_eq!(a.help, Some("ø"));
1236         let a = Arg::from_usage("--üñíčöĐ€ 'Nōṫ ASCII'");
1237         assert_eq!(a.name, "üñíčöĐ€");
1238         assert_eq!(a.long, Some("üñíčöĐ€"));
1239         assert_eq!(a.help, Some("Nōṫ ASCII"));
1240         let a = Arg::from_usage("[ñämê] --ôpt=[üñíčöĐ€] 'hælp'");
1241         assert_eq!(a.name, "ñämê");
1242         assert_eq!(a.long, Some("ôpt"));
1243         assert_eq!(a.val_names.iter().collect::<Vec<_>>(), [&"üñíčöĐ€"]);
1244         assert_eq!(a.help, Some("hælp"));
1245     }
1246
1247     #[test]
1248     fn value_names_building_num_vals_from_usage() {
1249         use crate::Command;
1250         let m = Command::new("test")
1251             .arg(Arg::from_usage("--pos <who> <what> <why>"))
1252             .try_get_matches_from(vec!["myprog", "--pos", "val1", "val2", "val3"]);
1253
1254         assert!(m.is_ok(), "{:?}", m.unwrap_err().kind());
1255         let m = m.unwrap();
1256
1257         assert_eq!(
1258             m.values_of("pos").unwrap().collect::<Vec<_>>(),
1259             ["val1", "val2", "val3"]
1260         );
1261     }
1262
1263     #[test]
1264     fn issue_665() {
1265         use crate::{error::ErrorKind, Command};
1266         // Verify fix for "arg_from_usage(): required values not being enforced when followed by another option"
1267         let res = Command::new("tester")
1268         .arg(Arg::from_usage("-v, --reroll-count=[N] 'Mark the patch series as PATCH vN'"))
1269         .arg(
1270             Arg::from_usage("--subject-prefix [Subject-Prefix] 'Use [Subject-Prefix] instead of the standard [PATCH] prefix'")
1271                 .setting(ArgSettings::ForbidEmptyValues)
1272         )
1273         .try_get_matches_from(vec!["test", "--subject-prefix", "-v", "2"]);
1274
1275         assert!(res.is_err());
1276         assert_eq!(res.unwrap_err().kind(), ErrorKind::EmptyValue);
1277     }
1278 }