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