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