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