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