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