vendor/clap/src/builder/usage_parser.rs

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