src/vendor/clap/src/usage_parser.rs

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