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