clap/
usage_parser.rs

1// Internal
2use INTERNAL_ERROR_MSG;
3use args::Arg;
4use args::settings::ArgSettings;
5use map::VecMap;
6
7#[derive(PartialEq, Debug)]
8enum UsageToken {
9    Name,
10    ValName,
11    Short,
12    Long,
13    Help,
14    Multiple,
15    Unknown,
16}
17
18#[doc(hidden)]
19#[derive(Debug)]
20pub struct UsageParser<'a> {
21    usage: &'a str,
22    pos: usize,
23    start: usize,
24    prev: UsageToken,
25    explicit_name_set: bool,
26}
27
28impl<'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,
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
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        }
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);
105                arg.v.val_names = Some(v);
106                arg.setb(ArgSettings::TakesValue);
107            }
108            self.prev = UsageToken::ValName;
109        }
110    }
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;
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]
209fn name_end(b: u8) -> bool { b != b']' && b != b'>' }
210
211#[inline]
212fn token(b: u8) -> bool { b != b'\'' && b != b'.' && b != b'<' && b != b'[' && b != b'-' }
213
214#[inline]
215fn long_end(b: u8) -> bool {
216    b != b'\'' && b != b'.' && b != b'<' && b != b'[' && b != b'=' && b != b' '
217}
218
219#[inline]
220fn help_start(b: u8) -> bool { b != b'\'' }
221
222#[cfg(test)]
223mod 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}