1 // Internal
2 use INTERNAL_ERROR_MSG;
3 use args::Arg;
4 use args::settings::ArgSettings;
5 use map::VecMap;
6
7 #[derive(PartialEq, Debug)]
8 enum UsageToken {
9 Name,
10 ValName,
11 Short,
12 Long,
13 Help,
14 Multiple,
15 Unknown,
16 }
17
18 #[doc(hidden)]
19 #[derive(Debug)]
20 pub struct UsageParser<'a> {
21 usage: &'a str,
22 pos: usize,
23 start: usize,
24 prev: UsageToken,
25 explicit_name_set: bool,
26 }
27
28 impl<'a> UsageParser<'a> {
new(usage: &'a str) -> Self29 fn new(usage: &'a str) -> Self {
30 debugln!("UsageParser::new: usage={:?}", usage);
31 UsageParser {
32 usage: usage,
33 pos: 0,
34 start: 0,
35 prev: UsageToken::Unknown,
36 explicit_name_set: false,
37 }
38 }
39
from_usage(usage: &'a str) -> Self40 pub fn from_usage(usage: &'a str) -> Self {
41 debugln!("UsageParser::from_usage;");
42 UsageParser::new(usage)
43 }
44
parse(mut self) -> Arg<'a, 'a>45 pub fn parse(mut self) -> Arg<'a, 'a> {
46 debugln!("UsageParser::parse;");
47 let mut arg = Arg::default();
48 loop {
49 debugln!("UsageParser::parse:iter: pos={};", self.pos);
50 self.stop_at(token);
51 if let Some(&c) = self.usage.as_bytes().get(self.pos) {
52 match c {
53 b'-' => self.short_or_long(&mut arg),
54 b'.' => self.multiple(&mut arg),
55 b'\'' => self.help(&mut arg),
56 _ => self.name(&mut arg),
57 }
58 } else {
59 break;
60 }
61 }
62 debug_assert!(
63 !arg.b.name.is_empty(),
64 format!(
65 "No name found for Arg when parsing usage string: {}",
66 self.usage
67 )
68 );
69 arg.v.num_vals = match arg.v.val_names {
70 Some(ref v) if v.len() >= 2 => Some(v.len() as u64),
71 _ => None,
72 };
73 debugln!("UsageParser::parse: vals...{:?}", arg.v.val_names);
74 arg
75 }
76
name(&mut self, arg: &mut Arg<'a, 'a>)77 fn name(&mut self, arg: &mut Arg<'a, 'a>) {
78 debugln!("UsageParser::name;");
79 if *self.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
stop_at<F>(&mut self, f: F) where F: Fn(u8) -> bool,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
short_or_long(&mut self, arg: &mut Arg<'a, 'a>)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
long(&mut self, arg: &mut Arg<'a, 'a>)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
short(&mut self, arg: &mut Arg<'a, 'a>)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..."
multiple(&mut self, arg: &mut Arg)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
help(&mut self, arg: &mut Arg<'a, 'a>)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]
name_end(b: u8) -> bool209 fn name_end(b: u8) -> bool { b != b']' && b != b'>' }
210
211 #[inline]
token(b: u8) -> bool212 fn token(b: u8) -> bool { b != b'\'' && b != b'.' && b != b'<' && b != b'[' && b != b'-' }
213
214 #[inline]
long_end(b: u8) -> bool215 fn long_end(b: u8) -> bool {
216 b != b'\'' && b != b'.' && b != b'<' && b != b'[' && b != b'=' && b != b' '
217 }
218
219 #[inline]
help_start(b: u8) -> bool220 fn help_start(b: u8) -> bool { b != b'\'' }
221
222 #[cfg(test)]
223 mod test {
224 use args::Arg;
225 use args::ArgSettings;
226
227 #[test]
create_flag_usage()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]
create_option_usage0()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]
create_option_usage1()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]
create_option_usage2()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]
create_option_usage3()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]
create_option_usage4()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]
create_option_usage5()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]
create_option_usage6()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]
create_option_usage7()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]
create_option_usage8()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]
create_option_usage9()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]
create_option_usage_long1()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]
create_option_usage_long2()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]
create_option_usage_long3()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]
create_option_usage_long4()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]
create_option_usage_long5()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]
create_option_usage_long6()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]
create_option_usage_long7()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]
create_option_usage_long8()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]
create_option_usage_long9()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]
create_option_usage_long10()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]
create_option_usage_long_equals1()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]
create_option_usage_long_equals2()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]
create_option_usage_long_equals3()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]
create_option_usage_long_equals4()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]
create_option_usage_long_equals5()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]
create_option_usage_long_equals6()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]
create_option_usage_long_equals7()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]
create_option_usage_long_equals8()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]
create_option_usage_long_equals9()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]
create_option_usage_long_equals10()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]
create_option_usage_both1()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]
create_option_usage_both2()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]
create_option_usage_both3()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]
create_option_usage_both4()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]
create_option_usage_both5()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]
create_option_usage_both6()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]
create_option_usage_both7()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]
create_option_usage_both8()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]
create_option_usage_both_equals1()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]
create_option_usage_both_equals2()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]
create_option_usage_both_equals3()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]
create_option_usage_both_equals4()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]
create_option_usage_both_equals5()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]
create_option_usage_both_equals6()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]
create_option_usage_both_equals7()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]
create_option_usage_both_equals8()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]
create_option_with_vals1()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]
create_option_with_vals2()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]
create_option_with_vals3()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]
create_option_with_vals4()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]
create_option_with_vals5()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]
create_positional_usage()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]
create_positional_usage0()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]
pos_mult_help()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]
pos_help_lit_single_quote()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]
pos_help_double_lit_single_quote()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]
pos_help_newline()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]
pos_help_newline_lit_sq()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]
pos_req_mult_help()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]
pos_req()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]
pos_mult()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]
nonascii()1320 fn nonascii() {
1321 let a = Arg::from_usage("<ASCII> 'üñíčöĐ€'");
1322 assert_eq!(a.b.name, "ASCII");
1323 assert_eq!(a.b.help, Some("üñíčöĐ€"));
1324 let a = Arg::from_usage("<üñíčöĐ€> 'ASCII'");
1325 assert_eq!(a.b.name, "üñíčöĐ€");
1326 assert_eq!(a.b.help, Some("ASCII"));
1327 let a = Arg::from_usage("<üñíčöĐ€> 'üñíčöĐ€'");
1328 assert_eq!(a.b.name, "üñíčöĐ€");
1329 assert_eq!(a.b.help, Some("üñíčöĐ€"));
1330 let a = Arg::from_usage("-ø 'ø'");
1331 assert_eq!(a.b.name, "ø");
1332 assert_eq!(a.s.short, Some('ø'));
1333 assert_eq!(a.b.help, Some("ø"));
1334 let a = Arg::from_usage("--üñíčöĐ€ 'Nōṫ ASCII'");
1335 assert_eq!(a.b.name, "üñíčöĐ€");
1336 assert_eq!(a.s.long, Some("üñíčöĐ€"));
1337 assert_eq!(a.b.help, Some("Nōṫ ASCII"));
1338 let a = Arg::from_usage("[ñämê] --ôpt=[üñíčöĐ€] 'hælp'");
1339 assert_eq!(a.b.name, "ñämê");
1340 assert_eq!(a.s.long, Some("ôpt"));
1341 assert_eq!(
1342 a.v.val_names.unwrap().values().collect::<Vec<_>>(),
1343 [&"üñíčöĐ€"]
1344 );
1345 assert_eq!(a.b.help, Some("hælp"));
1346 }
1347 }
1348