]>
Commit | Line | Data |
---|---|---|
8bb4bdeb | 1 | // Internal |
a2a8927a XL |
2 | use crate::{ |
3 | args::{settings::ArgSettings, Arg}, | |
4 | map::VecMap, | |
5 | INTERNAL_ERROR_MSG, | |
6 | }; | |
8bb4bdeb XL |
7 | |
8 | #[derive(PartialEq, Debug)] | |
9 | enum UsageToken { | |
10 | Name, | |
11 | ValName, | |
12 | Short, | |
13 | Long, | |
14 | Help, | |
15 | Multiple, | |
16 | Unknown, | |
17 | } | |
18 | ||
19 | #[doc(hidden)] | |
20 | #[derive(Debug)] | |
21 | pub struct UsageParser<'a> { | |
22 | usage: &'a str, | |
23 | pos: usize, | |
24 | start: usize, | |
25 | prev: UsageToken, | |
26 | explicit_name_set: bool, | |
27 | } | |
28 | ||
29 | impl<'a> UsageParser<'a> { | |
30 | fn new(usage: &'a str) -> Self { | |
041b39d2 | 31 | debugln!("UsageParser::new: usage={:?}", usage); |
8bb4bdeb | 32 | UsageParser { |
a2a8927a | 33 | usage, |
8bb4bdeb XL |
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 { | |
041b39d2 | 42 | debugln!("UsageParser::from_usage;"); |
8bb4bdeb XL |
43 | UsageParser::new(usage) |
44 | } | |
45 | ||
46 | pub fn parse(mut self) -> Arg<'a, 'a> { | |
041b39d2 | 47 | debugln!("UsageParser::parse;"); |
8bb4bdeb XL |
48 | let mut arg = Arg::default(); |
49 | loop { | |
041b39d2 | 50 | debugln!("UsageParser::parse:iter: pos={};", self.pos); |
8bb4bdeb XL |
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 | } | |
ff7c6d11 XL |
63 | debug_assert!( |
64 | !arg.b.name.is_empty(), | |
a2a8927a XL |
65 | "No name found for Arg when parsing usage string: {}", |
66 | self.usage | |
ff7c6d11 | 67 | ); |
041b39d2 | 68 | arg.v.num_vals = match arg.v.val_names { |
8bb4bdeb XL |
69 | Some(ref v) if v.len() >= 2 => Some(v.len() as u64), |
70 | _ => None, | |
71 | }; | |
041b39d2 | 72 | debugln!("UsageParser::parse: vals...{:?}", arg.v.val_names); |
8bb4bdeb XL |
73 | arg |
74 | } | |
75 | ||
76 | fn name(&mut self, arg: &mut Arg<'a, 'a>) { | |
041b39d2 | 77 | debugln!("UsageParser::name;"); |
3dfed10e XL |
78 | if *self |
79 | .usage | |
ff7c6d11 XL |
80 | .as_bytes() |
81 | .get(self.pos) | |
3dfed10e XL |
82 | .expect(INTERNAL_ERROR_MSG) |
83 | == b'<' | |
84 | && !self.explicit_name_set | |
ff7c6d11 | 85 | { |
8bb4bdeb XL |
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 { | |
041b39d2 XL |
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..."); | |
8bb4bdeb XL |
96 | self.explicit_name_set = true; |
97 | self.prev = UsageToken::Name; | |
98 | } | |
99 | } else { | |
041b39d2 XL |
100 | debugln!("UsageParser::name: setting val name...{}", name); |
101 | if let Some(ref mut v) = arg.v.val_names { | |
8bb4bdeb XL |
102 | let len = v.len(); |
103 | v.insert(len, name); | |
104 | } else { | |
105 | let mut v = VecMap::new(); | |
106 | v.insert(0, name); | |
041b39d2 | 107 | arg.v.val_names = Some(v); |
8bb4bdeb XL |
108 | arg.setb(ArgSettings::TakesValue); |
109 | } | |
110 | self.prev = UsageToken::ValName; | |
111 | } | |
112 | } | |
113 | ||
114 | fn stop_at<F>(&mut self, f: F) | |
ff7c6d11 XL |
115 | where |
116 | F: Fn(u8) -> bool, | |
8bb4bdeb | 117 | { |
041b39d2 | 118 | debugln!("UsageParser::stop_at;"); |
8bb4bdeb | 119 | self.start = self.pos; |
ff7c6d11 XL |
120 | self.pos += self.usage[self.start..] |
121 | .bytes() | |
122 | .take_while(|&b| f(b)) | |
123 | .count(); | |
8bb4bdeb XL |
124 | } |
125 | ||
126 | fn short_or_long(&mut self, arg: &mut Arg<'a, 'a>) { | |
041b39d2 | 127 | debugln!("UsageParser::short_or_long;"); |
8bb4bdeb | 128 | self.pos += 1; |
3dfed10e XL |
129 | if *self |
130 | .usage | |
ff7c6d11 XL |
131 | .as_bytes() |
132 | .get(self.pos) | |
3dfed10e XL |
133 | .expect(INTERNAL_ERROR_MSG) |
134 | == b'-' | |
ff7c6d11 | 135 | { |
8bb4bdeb XL |
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>) { | |
041b39d2 | 144 | debugln!("UsageParser::long;"); |
8bb4bdeb XL |
145 | self.stop_at(long_end); |
146 | let name = &self.usage[self.start..self.pos]; | |
147 | if !self.explicit_name_set { | |
041b39d2 XL |
148 | debugln!("UsageParser::long: setting name...{}", name); |
149 | arg.b.name = name; | |
8bb4bdeb | 150 | } |
041b39d2 XL |
151 | debugln!("UsageParser::long: setting long...{}", name); |
152 | arg.s.long = Some(name); | |
8bb4bdeb XL |
153 | self.prev = UsageToken::Long; |
154 | } | |
155 | ||
156 | fn short(&mut self, arg: &mut Arg<'a, 'a>) { | |
041b39d2 | 157 | debugln!("UsageParser::short;"); |
8bb4bdeb | 158 | let start = &self.usage[self.pos..]; |
a2a8927a | 159 | let short = start.chars().next().expect(INTERNAL_ERROR_MSG); |
041b39d2 XL |
160 | debugln!("UsageParser::short: setting short...{}", short); |
161 | arg.s.short = Some(short); | |
162 | if arg.b.name.is_empty() { | |
8bb4bdeb XL |
163 | // --long takes precedence but doesn't set self.explicit_name_set |
164 | let name = &start[..short.len_utf8()]; | |
041b39d2 XL |
165 | debugln!("UsageParser::short: setting name...{}", name); |
166 | arg.b.name = name; | |
8bb4bdeb XL |
167 | } |
168 | self.prev = UsageToken::Short; | |
169 | } | |
170 | ||
171 | // "something..." | |
172 | fn multiple(&mut self, arg: &mut Arg) { | |
041b39d2 | 173 | debugln!("UsageParser::multiple;"); |
8bb4bdeb XL |
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 { | |
041b39d2 | 181 | debugln!("UsageParser::multiple: setting multiple"); |
8bb4bdeb | 182 | arg.setb(ArgSettings::Multiple); |
041b39d2 | 183 | if arg.is_set(ArgSettings::TakesValue) { |
8bb4bdeb XL |
184 | arg.setb(ArgSettings::UseValueDelimiter); |
185 | arg.unsetb(ArgSettings::ValueDelimiterNotSet); | |
041b39d2 XL |
186 | if arg.v.val_delim.is_none() { |
187 | arg.v.val_delim = Some(','); | |
8bb4bdeb XL |
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>) { | |
041b39d2 | 198 | debugln!("UsageParser::help;"); |
8bb4bdeb XL |
199 | self.stop_at(help_start); |
200 | self.start = self.pos + 1; | |
201 | self.pos = self.usage.len() - 1; | |
ff7c6d11 XL |
202 | debugln!( |
203 | "UsageParser::help: setting help...{}", | |
204 | &self.usage[self.start..self.pos] | |
205 | ); | |
041b39d2 | 206 | arg.b.help = Some(&self.usage[self.start..self.pos]); |
ff7c6d11 | 207 | self.pos += 1; // Move to next byte to keep from thinking ending ' is a start |
8bb4bdeb XL |
208 | self.prev = UsageToken::Help; |
209 | } | |
210 | } | |
211 | ||
212 | #[inline] | |
3dfed10e XL |
213 | fn name_end(b: u8) -> bool { |
214 | b != b']' && b != b'>' | |
215 | } | |
8bb4bdeb XL |
216 | |
217 | #[inline] | |
3dfed10e XL |
218 | fn token(b: u8) -> bool { |
219 | b != b'\'' && b != b'.' && b != b'<' && b != b'[' && b != b'-' | |
220 | } | |
8bb4bdeb XL |
221 | |
222 | #[inline] | |
223 | fn long_end(b: u8) -> bool { | |
224 | b != b'\'' && b != b'.' && b != b'<' && b != b'[' && b != b'=' && b != b' ' | |
225 | } | |
226 | ||
227 | #[inline] | |
3dfed10e XL |
228 | fn help_start(b: u8) -> bool { |
229 | b != b'\'' | |
230 | } | |
8bb4bdeb XL |
231 | |
232 | #[cfg(test)] | |
233 | mod test { | |
a2a8927a | 234 | use crate::args::{Arg, ArgSettings}; |
8bb4bdeb XL |
235 | |
236 | #[test] | |
237 | fn create_flag_usage() { | |
238 | let a = Arg::from_usage("[flag] -f 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb | 243 | assert!(!a.is_set(ArgSettings::Multiple)); |
041b39d2 XL |
244 | assert!(a.v.val_names.is_none()); |
245 | assert!(a.v.num_vals.is_none()); | |
8bb4bdeb XL |
246 | |
247 | let b = Arg::from_usage("[flag] --flag 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb | 252 | assert!(!b.is_set(ArgSettings::Multiple)); |
041b39d2 XL |
253 | assert!(a.v.val_names.is_none()); |
254 | assert!(a.v.num_vals.is_none()); | |
8bb4bdeb XL |
255 | |
256 | let b = Arg::from_usage("--flag 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb | 261 | assert!(!b.is_set(ArgSettings::Multiple)); |
041b39d2 XL |
262 | assert!(b.v.val_names.is_none()); |
263 | assert!(b.v.num_vals.is_none()); | |
8bb4bdeb XL |
264 | |
265 | let c = Arg::from_usage("[flag] -f --flag 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb | 270 | assert!(!c.is_set(ArgSettings::Multiple)); |
041b39d2 XL |
271 | assert!(c.v.val_names.is_none()); |
272 | assert!(c.v.num_vals.is_none()); | |
8bb4bdeb XL |
273 | |
274 | let d = Arg::from_usage("[flag] -f... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb | 279 | assert!(d.is_set(ArgSettings::Multiple)); |
041b39d2 XL |
280 | assert!(d.v.val_names.is_none()); |
281 | assert!(d.v.num_vals.is_none()); | |
8bb4bdeb XL |
282 | |
283 | let e = Arg::from_usage("[flag] -f --flag... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb | 288 | assert!(e.is_set(ArgSettings::Multiple)); |
041b39d2 XL |
289 | assert!(e.v.val_names.is_none()); |
290 | assert!(e.v.num_vals.is_none()); | |
8bb4bdeb XL |
291 | |
292 | let e = Arg::from_usage("-f --flag... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb | 297 | assert!(e.is_set(ArgSettings::Multiple)); |
041b39d2 XL |
298 | assert!(e.v.val_names.is_none()); |
299 | assert!(e.v.num_vals.is_none()); | |
8bb4bdeb XL |
300 | |
301 | let e = Arg::from_usage("--flags"); | |
041b39d2 XL |
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()); | |
8bb4bdeb XL |
306 | |
307 | let e = Arg::from_usage("--flags..."); | |
041b39d2 XL |
308 | assert_eq!(e.b.name, "flags"); |
309 | assert_eq!(e.s.long.unwrap(), "flags"); | |
8bb4bdeb | 310 | assert!(e.is_set(ArgSettings::Multiple)); |
041b39d2 XL |
311 | assert!(e.v.val_names.is_none()); |
312 | assert!(e.v.num_vals.is_none()); | |
8bb4bdeb XL |
313 | |
314 | let e = Arg::from_usage("[flags] -f"); | |
041b39d2 XL |
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()); | |
8bb4bdeb XL |
319 | |
320 | let e = Arg::from_usage("[flags] -f..."); | |
041b39d2 XL |
321 | assert_eq!(e.b.name, "flags"); |
322 | assert_eq!(e.s.short.unwrap(), 'f'); | |
8bb4bdeb | 323 | assert!(e.is_set(ArgSettings::Multiple)); |
041b39d2 XL |
324 | assert!(e.v.val_names.is_none()); |
325 | assert!(e.v.num_vals.is_none()); | |
8bb4bdeb XL |
326 | |
327 | let a = Arg::from_usage("-f 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb | 332 | assert!(!a.is_set(ArgSettings::Multiple)); |
041b39d2 XL |
333 | assert!(a.v.val_names.is_none()); |
334 | assert!(a.v.num_vals.is_none()); | |
8bb4bdeb XL |
335 | |
336 | let e = Arg::from_usage("-f"); | |
041b39d2 XL |
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()); | |
8bb4bdeb XL |
341 | |
342 | let e = Arg::from_usage("-f..."); | |
041b39d2 XL |
343 | assert_eq!(e.b.name, "f"); |
344 | assert_eq!(e.s.short.unwrap(), 'f'); | |
8bb4bdeb | 345 | assert!(e.is_set(ArgSettings::Multiple)); |
041b39d2 XL |
346 | assert!(e.v.val_names.is_none()); |
347 | assert!(e.v.num_vals.is_none()); | |
8bb4bdeb XL |
348 | } |
349 | ||
350 | #[test] | |
351 | fn create_option_usage0() { | |
352 | // Short only | |
353 | let a = Arg::from_usage("[option] -o [opt] 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
358 | assert!(!a.is_set(ArgSettings::Multiple)); |
359 | assert!(a.is_set(ArgSettings::TakesValue)); | |
360 | assert!(!a.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
361 | assert_eq!( |
362 | a.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
363 | [&"opt"] | |
364 | ); | |
041b39d2 | 365 | assert!(a.v.num_vals.is_none()); |
8bb4bdeb XL |
366 | } |
367 | ||
368 | #[test] | |
369 | fn create_option_usage1() { | |
370 | let b = Arg::from_usage("-o [opt] 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
375 | assert!(!b.is_set(ArgSettings::Multiple)); |
376 | assert!(b.is_set(ArgSettings::TakesValue)); | |
377 | assert!(!b.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
378 | assert_eq!( |
379 | b.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
380 | [&"opt"] | |
381 | ); | |
041b39d2 | 382 | assert!(b.v.num_vals.is_none()); |
8bb4bdeb XL |
383 | } |
384 | ||
385 | #[test] | |
386 | fn create_option_usage2() { | |
387 | let c = Arg::from_usage("<option> -o <opt> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
392 | assert!(!c.is_set(ArgSettings::Multiple)); |
393 | assert!(c.is_set(ArgSettings::TakesValue)); | |
394 | assert!(c.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
395 | assert_eq!( |
396 | c.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
397 | [&"opt"] | |
398 | ); | |
041b39d2 | 399 | assert!(c.v.num_vals.is_none()); |
8bb4bdeb XL |
400 | } |
401 | ||
402 | #[test] | |
403 | fn create_option_usage3() { | |
404 | let d = Arg::from_usage("-o <opt> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
409 | assert!(!d.is_set(ArgSettings::Multiple)); |
410 | assert!(d.is_set(ArgSettings::TakesValue)); | |
411 | assert!(d.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
412 | assert_eq!( |
413 | d.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
414 | [&"opt"] | |
415 | ); | |
041b39d2 | 416 | assert!(d.v.num_vals.is_none()); |
8bb4bdeb XL |
417 | } |
418 | ||
419 | #[test] | |
420 | fn create_option_usage4() { | |
421 | let a = Arg::from_usage("[option] -o [opt]... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
426 | assert!(a.is_set(ArgSettings::Multiple)); |
427 | assert!(a.is_set(ArgSettings::TakesValue)); | |
428 | assert!(!a.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
429 | assert_eq!( |
430 | a.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
431 | [&"opt"] | |
432 | ); | |
041b39d2 | 433 | assert!(a.v.num_vals.is_none()); |
8bb4bdeb XL |
434 | } |
435 | ||
436 | #[test] | |
437 | fn create_option_usage5() { | |
438 | let a = Arg::from_usage("[option]... -o [opt] 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
443 | assert!(a.is_set(ArgSettings::Multiple)); |
444 | assert!(a.is_set(ArgSettings::TakesValue)); | |
445 | assert!(!a.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
446 | assert_eq!( |
447 | a.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
448 | [&"opt"] | |
449 | ); | |
041b39d2 | 450 | assert!(a.v.num_vals.is_none()); |
8bb4bdeb XL |
451 | } |
452 | ||
453 | #[test] | |
454 | fn create_option_usage6() { | |
455 | let b = Arg::from_usage("-o [opt]... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
460 | assert!(b.is_set(ArgSettings::Multiple)); |
461 | assert!(b.is_set(ArgSettings::TakesValue)); | |
462 | assert!(!b.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
463 | assert_eq!( |
464 | b.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
465 | [&"opt"] | |
466 | ); | |
041b39d2 | 467 | assert!(b.v.num_vals.is_none()); |
8bb4bdeb XL |
468 | } |
469 | ||
470 | #[test] | |
471 | fn create_option_usage7() { | |
472 | let c = Arg::from_usage("<option> -o <opt>... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
477 | assert!(c.is_set(ArgSettings::Multiple)); |
478 | assert!(c.is_set(ArgSettings::TakesValue)); | |
479 | assert!(c.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
480 | assert_eq!( |
481 | c.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
482 | [&"opt"] | |
483 | ); | |
041b39d2 | 484 | assert!(c.v.num_vals.is_none()); |
8bb4bdeb XL |
485 | } |
486 | ||
487 | #[test] | |
488 | fn create_option_usage8() { | |
489 | let c = Arg::from_usage("<option>... -o <opt> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
494 | assert!(c.is_set(ArgSettings::Multiple)); |
495 | assert!(c.is_set(ArgSettings::TakesValue)); | |
496 | assert!(c.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
497 | assert_eq!( |
498 | c.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
499 | [&"opt"] | |
500 | ); | |
041b39d2 | 501 | assert!(c.v.num_vals.is_none()); |
8bb4bdeb XL |
502 | } |
503 | ||
504 | #[test] | |
505 | fn create_option_usage9() { | |
506 | let d = Arg::from_usage("-o <opt>... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
511 | assert!(d.is_set(ArgSettings::Multiple)); |
512 | assert!(d.is_set(ArgSettings::TakesValue)); | |
513 | assert!(d.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
514 | assert_eq!( |
515 | d.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
516 | [&"opt"] | |
517 | ); | |
041b39d2 | 518 | assert!(d.v.num_vals.is_none()); |
8bb4bdeb XL |
519 | } |
520 | ||
521 | #[test] | |
522 | fn create_option_usage_long1() { | |
523 | let a = Arg::from_usage("[option] --opt [opt] 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
528 | assert!(!a.is_set(ArgSettings::Multiple)); |
529 | assert!(a.is_set(ArgSettings::TakesValue)); | |
530 | assert!(!a.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
531 | assert_eq!( |
532 | a.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
533 | [&"opt"] | |
534 | ); | |
041b39d2 | 535 | assert!(a.v.num_vals.is_none()); |
8bb4bdeb XL |
536 | } |
537 | ||
538 | #[test] | |
539 | fn create_option_usage_long2() { | |
540 | let b = Arg::from_usage("--opt [option] 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
545 | assert!(!b.is_set(ArgSettings::Multiple)); |
546 | assert!(b.is_set(ArgSettings::TakesValue)); | |
547 | assert!(!b.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
548 | assert_eq!( |
549 | b.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
550 | [&"option"] | |
551 | ); | |
041b39d2 | 552 | assert!(b.v.num_vals.is_none()); |
8bb4bdeb XL |
553 | } |
554 | ||
555 | #[test] | |
556 | fn create_option_usage_long3() { | |
557 | let c = Arg::from_usage("<option> --opt <opt> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
562 | assert!(!c.is_set(ArgSettings::Multiple)); |
563 | assert!(c.is_set(ArgSettings::TakesValue)); | |
564 | assert!(c.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
565 | assert_eq!( |
566 | c.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
567 | [&"opt"] | |
568 | ); | |
041b39d2 | 569 | assert!(c.v.num_vals.is_none()); |
8bb4bdeb XL |
570 | } |
571 | ||
572 | #[test] | |
573 | fn create_option_usage_long4() { | |
574 | let d = Arg::from_usage("--opt <option> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
579 | assert!(!d.is_set(ArgSettings::Multiple)); |
580 | assert!(d.is_set(ArgSettings::TakesValue)); | |
581 | assert!(d.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
582 | assert_eq!( |
583 | d.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
584 | [&"option"] | |
585 | ); | |
041b39d2 | 586 | assert!(d.v.num_vals.is_none()); |
8bb4bdeb XL |
587 | } |
588 | ||
589 | #[test] | |
590 | fn create_option_usage_long5() { | |
591 | let a = Arg::from_usage("[option] --opt [opt]... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
596 | assert!(a.is_set(ArgSettings::Multiple)); |
597 | assert!(a.is_set(ArgSettings::TakesValue)); | |
598 | assert!(!a.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
599 | assert_eq!( |
600 | a.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
601 | [&"opt"] | |
602 | ); | |
041b39d2 | 603 | assert!(a.v.num_vals.is_none()); |
8bb4bdeb XL |
604 | } |
605 | ||
606 | #[test] | |
607 | fn create_option_usage_long6() { | |
608 | let a = Arg::from_usage("[option]... --opt [opt] 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
613 | assert!(a.is_set(ArgSettings::Multiple)); |
614 | assert!(a.is_set(ArgSettings::TakesValue)); | |
615 | assert!(!a.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
616 | assert_eq!( |
617 | a.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
618 | [&"opt"] | |
619 | ); | |
041b39d2 | 620 | assert!(a.v.num_vals.is_none()); |
8bb4bdeb XL |
621 | } |
622 | ||
623 | #[test] | |
624 | fn create_option_usage_long7() { | |
625 | let b = Arg::from_usage("--opt [option]... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
630 | assert!(b.is_set(ArgSettings::Multiple)); |
631 | assert!(b.is_set(ArgSettings::TakesValue)); | |
632 | assert!(!b.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
633 | assert_eq!( |
634 | b.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
635 | [&"option"] | |
636 | ); | |
041b39d2 | 637 | assert!(b.v.num_vals.is_none()); |
8bb4bdeb XL |
638 | } |
639 | ||
640 | #[test] | |
641 | fn create_option_usage_long8() { | |
642 | let c = Arg::from_usage("<option> --opt <opt>... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
647 | assert!(c.is_set(ArgSettings::Multiple)); |
648 | assert!(c.is_set(ArgSettings::TakesValue)); | |
649 | assert!(c.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
650 | assert_eq!( |
651 | c.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
652 | [&"opt"] | |
653 | ); | |
041b39d2 | 654 | assert!(c.v.num_vals.is_none()); |
8bb4bdeb XL |
655 | } |
656 | ||
657 | #[test] | |
658 | fn create_option_usage_long9() { | |
659 | let c = Arg::from_usage("<option>... --opt <opt> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
664 | assert!(c.is_set(ArgSettings::Multiple)); |
665 | assert!(c.is_set(ArgSettings::TakesValue)); | |
666 | assert!(c.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
667 | assert_eq!( |
668 | c.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
669 | [&"opt"] | |
670 | ); | |
041b39d2 | 671 | assert!(c.v.num_vals.is_none()); |
8bb4bdeb XL |
672 | } |
673 | ||
674 | #[test] | |
675 | fn create_option_usage_long10() { | |
676 | let d = Arg::from_usage("--opt <option>... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
681 | assert!(d.is_set(ArgSettings::Multiple)); |
682 | assert!(d.is_set(ArgSettings::TakesValue)); | |
683 | assert!(d.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
684 | assert_eq!( |
685 | d.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
686 | [&"option"] | |
687 | ); | |
041b39d2 | 688 | assert!(d.v.num_vals.is_none()); |
8bb4bdeb XL |
689 | } |
690 | ||
691 | #[test] | |
692 | fn create_option_usage_long_equals1() { | |
693 | let a = Arg::from_usage("[option] --opt=[opt] 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
698 | assert!(!a.is_set(ArgSettings::Multiple)); |
699 | assert!(a.is_set(ArgSettings::TakesValue)); | |
700 | assert!(!a.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
701 | assert_eq!( |
702 | a.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
703 | [&"opt"] | |
704 | ); | |
041b39d2 | 705 | assert!(a.v.num_vals.is_none()); |
8bb4bdeb XL |
706 | } |
707 | ||
708 | #[test] | |
709 | fn create_option_usage_long_equals2() { | |
710 | let b = Arg::from_usage("--opt=[option] 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
715 | assert!(!b.is_set(ArgSettings::Multiple)); |
716 | assert!(b.is_set(ArgSettings::TakesValue)); | |
717 | assert!(!b.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
718 | assert_eq!( |
719 | b.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
720 | [&"option"] | |
721 | ); | |
041b39d2 | 722 | assert!(b.v.num_vals.is_none()); |
8bb4bdeb XL |
723 | } |
724 | ||
725 | #[test] | |
726 | fn create_option_usage_long_equals3() { | |
727 | let c = Arg::from_usage("<option> --opt=<opt> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
732 | assert!(!c.is_set(ArgSettings::Multiple)); |
733 | assert!(c.is_set(ArgSettings::TakesValue)); | |
734 | assert!(c.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
735 | assert_eq!( |
736 | c.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
737 | [&"opt"] | |
738 | ); | |
041b39d2 | 739 | assert!(c.v.num_vals.is_none()); |
8bb4bdeb XL |
740 | } |
741 | ||
742 | #[test] | |
743 | fn create_option_usage_long_equals4() { | |
744 | let d = Arg::from_usage("--opt=<option> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
749 | assert!(!d.is_set(ArgSettings::Multiple)); |
750 | assert!(d.is_set(ArgSettings::TakesValue)); | |
751 | assert!(d.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
752 | assert_eq!( |
753 | d.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
754 | [&"option"] | |
755 | ); | |
041b39d2 | 756 | assert!(d.v.num_vals.is_none()); |
8bb4bdeb XL |
757 | } |
758 | ||
759 | #[test] | |
760 | fn create_option_usage_long_equals5() { | |
761 | let a = Arg::from_usage("[option] --opt=[opt]... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
766 | assert!(a.is_set(ArgSettings::Multiple)); |
767 | assert!(a.is_set(ArgSettings::TakesValue)); | |
768 | assert!(!a.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
769 | assert_eq!( |
770 | a.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
771 | [&"opt"] | |
772 | ); | |
041b39d2 | 773 | assert!(a.v.num_vals.is_none()); |
8bb4bdeb XL |
774 | } |
775 | ||
776 | #[test] | |
777 | fn create_option_usage_long_equals6() { | |
778 | let a = Arg::from_usage("[option]... --opt=[opt] 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
783 | assert!(a.is_set(ArgSettings::Multiple)); |
784 | assert!(a.is_set(ArgSettings::TakesValue)); | |
785 | assert!(!a.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
786 | assert_eq!( |
787 | a.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
788 | [&"opt"] | |
789 | ); | |
041b39d2 | 790 | assert!(a.v.num_vals.is_none()); |
8bb4bdeb XL |
791 | } |
792 | ||
793 | #[test] | |
794 | fn create_option_usage_long_equals7() { | |
795 | let b = Arg::from_usage("--opt=[option]... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
800 | assert!(b.is_set(ArgSettings::Multiple)); |
801 | assert!(b.is_set(ArgSettings::TakesValue)); | |
802 | assert!(!b.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
803 | assert_eq!( |
804 | b.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
805 | [&"option"] | |
806 | ); | |
041b39d2 | 807 | assert!(b.v.num_vals.is_none()); |
8bb4bdeb XL |
808 | } |
809 | ||
810 | #[test] | |
811 | fn create_option_usage_long_equals8() { | |
812 | let c = Arg::from_usage("<option> --opt=<opt>... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
817 | assert!(c.is_set(ArgSettings::Multiple)); |
818 | assert!(c.is_set(ArgSettings::TakesValue)); | |
819 | assert!(c.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
820 | assert_eq!( |
821 | c.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
822 | [&"opt"] | |
823 | ); | |
041b39d2 | 824 | assert!(c.v.num_vals.is_none()); |
8bb4bdeb XL |
825 | } |
826 | ||
827 | #[test] | |
828 | fn create_option_usage_long_equals9() { | |
829 | let c = Arg::from_usage("<option>... --opt=<opt> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
834 | assert!(c.is_set(ArgSettings::Multiple)); |
835 | assert!(c.is_set(ArgSettings::TakesValue)); | |
836 | assert!(c.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
837 | assert_eq!( |
838 | c.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
839 | [&"opt"] | |
840 | ); | |
041b39d2 | 841 | assert!(c.v.num_vals.is_none()); |
8bb4bdeb XL |
842 | } |
843 | ||
844 | #[test] | |
845 | fn create_option_usage_long_equals10() { | |
846 | let d = Arg::from_usage("--opt=<option>... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
851 | assert!(d.is_set(ArgSettings::Multiple)); |
852 | assert!(d.is_set(ArgSettings::TakesValue)); | |
853 | assert!(d.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
854 | assert_eq!( |
855 | d.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
856 | [&"option"] | |
857 | ); | |
041b39d2 | 858 | assert!(d.v.num_vals.is_none()); |
8bb4bdeb XL |
859 | } |
860 | ||
861 | #[test] | |
862 | fn create_option_usage_both1() { | |
863 | let a = Arg::from_usage("[option] -o --opt [option] 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
868 | assert!(!a.is_set(ArgSettings::Multiple)); |
869 | assert!(a.is_set(ArgSettings::TakesValue)); | |
870 | assert!(!a.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
871 | assert_eq!( |
872 | a.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
873 | [&"option"] | |
874 | ); | |
041b39d2 | 875 | assert!(a.v.num_vals.is_none()); |
8bb4bdeb XL |
876 | } |
877 | ||
878 | #[test] | |
879 | fn create_option_usage_both2() { | |
880 | let b = Arg::from_usage("-o --opt [option] 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
885 | assert!(!b.is_set(ArgSettings::Multiple)); |
886 | assert!(b.is_set(ArgSettings::TakesValue)); | |
887 | assert!(!b.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
888 | assert_eq!( |
889 | b.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
890 | [&"option"] | |
891 | ); | |
041b39d2 | 892 | assert!(b.v.num_vals.is_none()); |
8bb4bdeb XL |
893 | } |
894 | ||
895 | #[test] | |
896 | fn create_option_usage_both3() { | |
897 | let c = Arg::from_usage("<option> -o --opt <opt> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
902 | assert!(!c.is_set(ArgSettings::Multiple)); |
903 | assert!(c.is_set(ArgSettings::TakesValue)); | |
904 | assert!(c.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
905 | assert_eq!( |
906 | c.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
907 | [&"opt"] | |
908 | ); | |
041b39d2 | 909 | assert!(c.v.num_vals.is_none()); |
8bb4bdeb XL |
910 | } |
911 | ||
912 | #[test] | |
913 | fn create_option_usage_both4() { | |
914 | let d = Arg::from_usage("-o --opt <option> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
919 | assert!(!d.is_set(ArgSettings::Multiple)); |
920 | assert!(d.is_set(ArgSettings::TakesValue)); | |
921 | assert!(d.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
922 | assert_eq!( |
923 | d.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
924 | [&"option"] | |
925 | ); | |
041b39d2 | 926 | assert!(d.v.num_vals.is_none()); |
8bb4bdeb XL |
927 | } |
928 | ||
929 | #[test] | |
930 | fn create_option_usage_both5() { | |
931 | let a = Arg::from_usage("[option]... -o --opt [option] 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
936 | assert!(a.is_set(ArgSettings::Multiple)); |
937 | assert!(a.is_set(ArgSettings::TakesValue)); | |
938 | assert!(!a.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
939 | assert_eq!( |
940 | a.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
941 | [&"option"] | |
942 | ); | |
041b39d2 | 943 | assert!(a.v.num_vals.is_none()); |
8bb4bdeb XL |
944 | } |
945 | ||
946 | #[test] | |
947 | fn create_option_usage_both6() { | |
948 | let b = Arg::from_usage("-o --opt [option]... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
953 | assert!(b.is_set(ArgSettings::Multiple)); |
954 | assert!(b.is_set(ArgSettings::TakesValue)); | |
955 | assert!(!b.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
956 | assert_eq!( |
957 | b.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
958 | [&"option"] | |
959 | ); | |
041b39d2 | 960 | assert!(b.v.num_vals.is_none()); |
8bb4bdeb XL |
961 | } |
962 | ||
963 | #[test] | |
964 | fn create_option_usage_both7() { | |
965 | let c = Arg::from_usage("<option>... -o --opt <opt> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
970 | assert!(c.is_set(ArgSettings::Multiple)); |
971 | assert!(c.is_set(ArgSettings::TakesValue)); | |
972 | assert!(c.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
973 | assert_eq!( |
974 | c.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
975 | [&"opt"] | |
976 | ); | |
041b39d2 | 977 | assert!(c.v.num_vals.is_none()); |
8bb4bdeb XL |
978 | } |
979 | ||
980 | #[test] | |
981 | fn create_option_usage_both8() { | |
982 | let d = Arg::from_usage("-o --opt <option>... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
987 | assert!(d.is_set(ArgSettings::Multiple)); |
988 | assert!(d.is_set(ArgSettings::TakesValue)); | |
989 | assert!(d.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
990 | assert_eq!( |
991 | d.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
992 | [&"option"] | |
993 | ); | |
041b39d2 | 994 | assert!(d.v.num_vals.is_none()); |
8bb4bdeb XL |
995 | } |
996 | ||
997 | #[test] | |
998 | fn create_option_usage_both_equals1() { | |
999 | let a = Arg::from_usage("[option] -o --opt=[option] 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
1004 | assert!(!a.is_set(ArgSettings::Multiple)); |
1005 | assert!(a.is_set(ArgSettings::TakesValue)); | |
1006 | assert!(!a.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
1007 | assert_eq!( |
1008 | a.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
1009 | [&"option"] | |
1010 | ); | |
041b39d2 | 1011 | assert!(a.v.num_vals.is_none()); |
8bb4bdeb XL |
1012 | } |
1013 | ||
1014 | #[test] | |
1015 | fn create_option_usage_both_equals2() { | |
1016 | let b = Arg::from_usage("-o --opt=[option] 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
1021 | assert!(!b.is_set(ArgSettings::Multiple)); |
1022 | assert!(b.is_set(ArgSettings::TakesValue)); | |
1023 | assert!(!b.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
1024 | assert_eq!( |
1025 | b.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
1026 | [&"option"] | |
1027 | ); | |
041b39d2 | 1028 | assert!(b.v.num_vals.is_none()); |
8bb4bdeb XL |
1029 | } |
1030 | ||
1031 | #[test] | |
1032 | fn create_option_usage_both_equals3() { | |
1033 | let c = Arg::from_usage("<option> -o --opt=<opt> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
1038 | assert!(!c.is_set(ArgSettings::Multiple)); |
1039 | assert!(c.is_set(ArgSettings::TakesValue)); | |
1040 | assert!(c.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
1041 | assert_eq!( |
1042 | c.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
1043 | [&"opt"] | |
1044 | ); | |
041b39d2 | 1045 | assert!(c.v.num_vals.is_none()); |
8bb4bdeb XL |
1046 | } |
1047 | ||
1048 | #[test] | |
1049 | fn create_option_usage_both_equals4() { | |
1050 | let d = Arg::from_usage("-o --opt=<option> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
1055 | assert!(!d.is_set(ArgSettings::Multiple)); |
1056 | assert!(d.is_set(ArgSettings::TakesValue)); | |
1057 | assert!(d.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
1058 | assert_eq!( |
1059 | d.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
1060 | [&"option"] | |
1061 | ); | |
041b39d2 | 1062 | assert!(d.v.num_vals.is_none()); |
8bb4bdeb XL |
1063 | } |
1064 | ||
1065 | #[test] | |
1066 | fn create_option_usage_both_equals5() { | |
1067 | let a = Arg::from_usage("[option]... -o --opt=[option] 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
1072 | assert!(a.is_set(ArgSettings::Multiple)); |
1073 | assert!(a.is_set(ArgSettings::TakesValue)); | |
1074 | assert!(!a.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
1075 | assert_eq!( |
1076 | a.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
1077 | [&"option"] | |
1078 | ); | |
041b39d2 | 1079 | assert!(a.v.num_vals.is_none()); |
8bb4bdeb XL |
1080 | } |
1081 | ||
1082 | #[test] | |
1083 | fn create_option_usage_both_equals6() { | |
1084 | let b = Arg::from_usage("-o --opt=[option]... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
1089 | assert!(b.is_set(ArgSettings::Multiple)); |
1090 | assert!(b.is_set(ArgSettings::TakesValue)); | |
1091 | assert!(!b.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
1092 | assert_eq!( |
1093 | b.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
1094 | [&"option"] | |
1095 | ); | |
041b39d2 | 1096 | assert!(b.v.num_vals.is_none()); |
8bb4bdeb XL |
1097 | } |
1098 | ||
1099 | #[test] | |
1100 | fn create_option_usage_both_equals7() { | |
1101 | let c = Arg::from_usage("<option>... -o --opt=<opt> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
1106 | assert!(c.is_set(ArgSettings::Multiple)); |
1107 | assert!(c.is_set(ArgSettings::TakesValue)); | |
1108 | assert!(c.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
1109 | assert_eq!( |
1110 | c.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
1111 | [&"opt"] | |
1112 | ); | |
041b39d2 | 1113 | assert!(c.v.num_vals.is_none()); |
8bb4bdeb XL |
1114 | } |
1115 | ||
1116 | #[test] | |
1117 | fn create_option_usage_both_equals8() { | |
1118 | let d = Arg::from_usage("-o --opt=<option>... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
1123 | assert!(d.is_set(ArgSettings::Multiple)); |
1124 | assert!(d.is_set(ArgSettings::TakesValue)); | |
1125 | assert!(d.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
1126 | assert_eq!( |
1127 | d.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
1128 | [&"option"] | |
1129 | ); | |
041b39d2 | 1130 | assert!(d.v.num_vals.is_none()); |
8bb4bdeb XL |
1131 | } |
1132 | ||
1133 | #[test] | |
1134 | fn create_option_with_vals1() { | |
1135 | let d = Arg::from_usage("-o <file> <mode> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
1140 | assert!(!d.is_set(ArgSettings::Multiple)); |
1141 | assert!(d.is_set(ArgSettings::TakesValue)); | |
1142 | assert!(d.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
1143 | assert_eq!( |
1144 | d.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
1145 | [&"file", &"mode"] | |
1146 | ); | |
041b39d2 | 1147 | assert_eq!(d.v.num_vals.unwrap(), 2); |
8bb4bdeb XL |
1148 | } |
1149 | ||
1150 | #[test] | |
1151 | fn create_option_with_vals2() { | |
1152 | let d = Arg::from_usage("-o <file> <mode>... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
1157 | assert!(d.is_set(ArgSettings::Multiple)); |
1158 | assert!(d.is_set(ArgSettings::TakesValue)); | |
1159 | assert!(d.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
1160 | assert_eq!( |
1161 | d.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
1162 | [&"file", &"mode"] | |
1163 | ); | |
041b39d2 | 1164 | assert_eq!(d.v.num_vals.unwrap(), 2); |
8bb4bdeb XL |
1165 | } |
1166 | ||
1167 | #[test] | |
1168 | fn create_option_with_vals3() { | |
1169 | let d = Arg::from_usage("--opt <file> <mode>... 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
1174 | assert!(d.is_set(ArgSettings::Multiple)); |
1175 | assert!(d.is_set(ArgSettings::TakesValue)); | |
1176 | assert!(d.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
1177 | assert_eq!( |
1178 | d.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
1179 | [&"file", &"mode"] | |
1180 | ); | |
041b39d2 | 1181 | assert_eq!(d.v.num_vals.unwrap(), 2); |
8bb4bdeb XL |
1182 | } |
1183 | ||
1184 | #[test] | |
1185 | fn create_option_with_vals4() { | |
1186 | let d = Arg::from_usage("[myopt] --opt <file> <mode> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
1191 | assert!(!d.is_set(ArgSettings::Multiple)); |
1192 | assert!(d.is_set(ArgSettings::TakesValue)); | |
1193 | assert!(!d.is_set(ArgSettings::Required)); | |
ff7c6d11 XL |
1194 | assert_eq!( |
1195 | d.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
1196 | [&"file", &"mode"] | |
1197 | ); | |
041b39d2 | 1198 | assert_eq!(d.v.num_vals.unwrap(), 2); |
8bb4bdeb XL |
1199 | } |
1200 | ||
1201 | #[test] | |
1202 | fn create_option_with_vals5() { | |
1203 | let d = Arg::from_usage("--opt <file> <mode> 'some help info'"); | |
041b39d2 XL |
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"); | |
8bb4bdeb XL |
1208 | assert!(!d.is_set(ArgSettings::Multiple)); |
1209 | assert!(d.is_set(ArgSettings::TakesValue)); | |
1210 | assert!(d.is_set(ArgSettings::Required)); | |
041b39d2 | 1211 | assert_eq!(d.v.num_vals.unwrap(), 2); |
8bb4bdeb XL |
1212 | } |
1213 | ||
1214 | #[test] | |
1215 | fn create_positional_usage() { | |
1216 | let a = Arg::from_usage("[pos] 'some help info'"); | |
041b39d2 XL |
1217 | assert_eq!(a.b.name, "pos"); |
1218 | assert_eq!(a.b.help.unwrap(), "some help info"); | |
8bb4bdeb XL |
1219 | assert!(!a.is_set(ArgSettings::Multiple)); |
1220 | assert!(!a.is_set(ArgSettings::Required)); | |
041b39d2 XL |
1221 | assert!(a.v.val_names.is_none()); |
1222 | assert!(a.v.num_vals.is_none()); | |
8bb4bdeb XL |
1223 | } |
1224 | ||
1225 | #[test] | |
1226 | fn create_positional_usage0() { | |
1227 | let b = Arg::from_usage("<pos> 'some help info'"); | |
041b39d2 XL |
1228 | assert_eq!(b.b.name, "pos"); |
1229 | assert_eq!(b.b.help.unwrap(), "some help info"); | |
8bb4bdeb XL |
1230 | assert!(!b.is_set(ArgSettings::Multiple)); |
1231 | assert!(b.is_set(ArgSettings::Required)); | |
041b39d2 XL |
1232 | assert!(b.v.val_names.is_none()); |
1233 | assert!(b.v.num_vals.is_none()); | |
8bb4bdeb XL |
1234 | } |
1235 | ||
1236 | #[test] | |
1237 | fn pos_mult_help() { | |
1238 | let c = Arg::from_usage("[pos]... 'some help info'"); | |
041b39d2 XL |
1239 | assert_eq!(c.b.name, "pos"); |
1240 | assert_eq!(c.b.help.unwrap(), "some help info"); | |
8bb4bdeb XL |
1241 | assert!(c.is_set(ArgSettings::Multiple)); |
1242 | assert!(!c.is_set(ArgSettings::Required)); | |
041b39d2 XL |
1243 | assert!(c.v.val_names.is_none()); |
1244 | assert!(c.v.num_vals.is_none()); | |
8bb4bdeb XL |
1245 | } |
1246 | ||
1247 | #[test] | |
1248 | fn pos_help_lit_single_quote() { | |
1249 | let c = Arg::from_usage("[pos]... 'some help\' info'"); | |
041b39d2 XL |
1250 | assert_eq!(c.b.name, "pos"); |
1251 | assert_eq!(c.b.help.unwrap(), "some help' info"); | |
8bb4bdeb XL |
1252 | assert!(c.is_set(ArgSettings::Multiple)); |
1253 | assert!(!c.is_set(ArgSettings::Required)); | |
041b39d2 XL |
1254 | assert!(c.v.val_names.is_none()); |
1255 | assert!(c.v.num_vals.is_none()); | |
8bb4bdeb XL |
1256 | } |
1257 | ||
1258 | #[test] | |
1259 | fn pos_help_double_lit_single_quote() { | |
1260 | let c = Arg::from_usage("[pos]... 'some \'help\' info'"); | |
041b39d2 XL |
1261 | assert_eq!(c.b.name, "pos"); |
1262 | assert_eq!(c.b.help.unwrap(), "some 'help' info"); | |
8bb4bdeb XL |
1263 | assert!(c.is_set(ArgSettings::Multiple)); |
1264 | assert!(!c.is_set(ArgSettings::Required)); | |
041b39d2 XL |
1265 | assert!(c.v.val_names.is_none()); |
1266 | assert!(c.v.num_vals.is_none()); | |
8bb4bdeb XL |
1267 | } |
1268 | ||
1269 | #[test] | |
1270 | fn pos_help_newline() { | |
ff7c6d11 XL |
1271 | let c = Arg::from_usage( |
1272 | "[pos]... 'some help{n}\ | |
1273 | info'", | |
1274 | ); | |
041b39d2 XL |
1275 | assert_eq!(c.b.name, "pos"); |
1276 | assert_eq!(c.b.help.unwrap(), "some help{n}info"); | |
8bb4bdeb XL |
1277 | assert!(c.is_set(ArgSettings::Multiple)); |
1278 | assert!(!c.is_set(ArgSettings::Required)); | |
041b39d2 XL |
1279 | assert!(c.v.val_names.is_none()); |
1280 | assert!(c.v.num_vals.is_none()); | |
8bb4bdeb XL |
1281 | } |
1282 | ||
1283 | #[test] | |
1284 | fn pos_help_newline_lit_sq() { | |
ff7c6d11 XL |
1285 | let c = Arg::from_usage( |
1286 | "[pos]... 'some help\' stuff{n}\ | |
1287 | info'", | |
1288 | ); | |
041b39d2 XL |
1289 | assert_eq!(c.b.name, "pos"); |
1290 | assert_eq!(c.b.help.unwrap(), "some help' stuff{n}info"); | |
8bb4bdeb XL |
1291 | assert!(c.is_set(ArgSettings::Multiple)); |
1292 | assert!(!c.is_set(ArgSettings::Required)); | |
041b39d2 XL |
1293 | assert!(c.v.val_names.is_none()); |
1294 | assert!(c.v.num_vals.is_none()); | |
8bb4bdeb XL |
1295 | } |
1296 | ||
1297 | #[test] | |
1298 | fn pos_req_mult_help() { | |
1299 | let d = Arg::from_usage("<pos>... 'some help info'"); | |
041b39d2 XL |
1300 | assert_eq!(d.b.name, "pos"); |
1301 | assert_eq!(d.b.help.unwrap(), "some help info"); | |
8bb4bdeb XL |
1302 | assert!(d.is_set(ArgSettings::Multiple)); |
1303 | assert!(d.is_set(ArgSettings::Required)); | |
041b39d2 XL |
1304 | assert!(d.v.val_names.is_none()); |
1305 | assert!(d.v.num_vals.is_none()); | |
8bb4bdeb XL |
1306 | } |
1307 | ||
1308 | #[test] | |
1309 | fn pos_req() { | |
1310 | let b = Arg::from_usage("<pos>"); | |
041b39d2 | 1311 | assert_eq!(b.b.name, "pos"); |
8bb4bdeb XL |
1312 | assert!(!b.is_set(ArgSettings::Multiple)); |
1313 | assert!(b.is_set(ArgSettings::Required)); | |
041b39d2 XL |
1314 | assert!(b.v.val_names.is_none()); |
1315 | assert!(b.v.num_vals.is_none()); | |
8bb4bdeb XL |
1316 | } |
1317 | ||
1318 | #[test] | |
1319 | fn pos_mult() { | |
1320 | let c = Arg::from_usage("[pos]..."); | |
041b39d2 | 1321 | assert_eq!(c.b.name, "pos"); |
8bb4bdeb XL |
1322 | assert!(c.is_set(ArgSettings::Multiple)); |
1323 | assert!(!c.is_set(ArgSettings::Required)); | |
041b39d2 XL |
1324 | assert!(c.v.val_names.is_none()); |
1325 | assert!(c.v.num_vals.is_none()); | |
8bb4bdeb XL |
1326 | } |
1327 | ||
1328 | #[test] | |
1329 | fn nonascii() { | |
1330 | let a = Arg::from_usage("<ASCII> 'üñíčöĐ€'"); | |
041b39d2 XL |
1331 | assert_eq!(a.b.name, "ASCII"); |
1332 | assert_eq!(a.b.help, Some("üñíčöĐ€")); | |
8bb4bdeb | 1333 | let a = Arg::from_usage("<üñíčöĐ€> 'ASCII'"); |
041b39d2 XL |
1334 | assert_eq!(a.b.name, "üñíčöĐ€"); |
1335 | assert_eq!(a.b.help, Some("ASCII")); | |
8bb4bdeb | 1336 | let a = Arg::from_usage("<üñíčöĐ€> 'üñíčöĐ€'"); |
041b39d2 XL |
1337 | assert_eq!(a.b.name, "üñíčöĐ€"); |
1338 | assert_eq!(a.b.help, Some("üñíčöĐ€")); | |
8bb4bdeb | 1339 | let a = Arg::from_usage("-ø 'ø'"); |
041b39d2 XL |
1340 | assert_eq!(a.b.name, "ø"); |
1341 | assert_eq!(a.s.short, Some('ø')); | |
1342 | assert_eq!(a.b.help, Some("ø")); | |
8bb4bdeb | 1343 | let a = Arg::from_usage("--üñíčöĐ€ 'Nōṫ ASCII'"); |
041b39d2 XL |
1344 | assert_eq!(a.b.name, "üñíčöĐ€"); |
1345 | assert_eq!(a.s.long, Some("üñíčöĐ€")); | |
1346 | assert_eq!(a.b.help, Some("Nōṫ ASCII")); | |
8bb4bdeb | 1347 | let a = Arg::from_usage("[ñämê] --ôpt=[üñíčöĐ€] 'hælp'"); |
041b39d2 XL |
1348 | assert_eq!(a.b.name, "ñämê"); |
1349 | assert_eq!(a.s.long, Some("ôpt")); | |
ff7c6d11 XL |
1350 | assert_eq!( |
1351 | a.v.val_names.unwrap().values().collect::<Vec<_>>(), | |
1352 | [&"üñíčöĐ€"] | |
1353 | ); | |
041b39d2 | 1354 | assert_eq!(a.b.help, Some("hælp")); |
8bb4bdeb XL |
1355 | } |
1356 | } |