tests(Usage Parser): adds and fixes tests for usage parser

Author: kbknapp

clap-tests/run_tests.py

@@ -22,13 +22,13 @@
     -V, --version    Prints version information
 
 OPTIONS:
+    -O, --Option <option3>           tests options with specific value sets [values: fast slow]
+        --long-option-2 <option2>    tests long options with exclusions
         --maxvals3 <maxvals>...      Tests 3 max vals
         --minvals2 <minvals>...      Tests 2 min vals
         --multvals <one> <two>       Tests mutliple values, not mult occs
-        --multvalsmo <one> <two>     Tests mutliple values, not mult occs
+        --multvalsmo <one> <two>     Tests mutliple values, and mult occs
     -o, --option <opt>...            tests options
-        --long-option-2 <option2>    tests long options with exclusions
-    -O, --Option <option3>           tests options with specific value sets [values: fast slow]
 
 ARGS:
     positional        tests positionals
@@ -51,7 +51,7 @@
 
 For more information try --help'''
 
-_arg_dym_usage = '''error: The argument '--optio' wasn't recognized, or isn't valid in this context
+_arg_dym_usage = '''error: Found argument '--optio' which wasn't expected, or isn't valid in this context
 \tDid you mean --option ?
 
 USAGE:

clap-tests/src/main.rs

@@ -5,7 +5,6 @@ use clap::{App, Arg, SubCommand};
 
 
 fn main() {
-    let m_val_names = ["one", "two"];
     let args = "-o --option=[opt]... 'tests options'
                 [positional] 'tests positionals'";
     let opt3_vals = ["fast", "slow"];
@@ -18,13 +17,13 @@ fn main() {
                         .arg(Arg::from_usage("-f --flag... 'tests flags'")
                             .global(true))
                         .args(&[
-                            Arg::from_usage("[flag2] -F 'tests flags with exclusions'").conflicts_with("flag").requires("option2"),
+                            Arg::from_usage("[flag2] -F 'tests flags with exclusions'").conflicts_with("flag").requires("long-option-2"),
                             Arg::from_usage("--long-option-2 [option2] 'tests long options with exclusions'").conflicts_with("option").requires("positional2"),
                             Arg::from_usage("[positional2] 'tests positionals with exclusions'"),
                             Arg::from_usage("-O --Option [option3] 'tests options with specific value sets'").possible_values(&opt3_vals),
                             Arg::from_usage("[positional3]... 'tests positionals with specific values'").possible_values(&pos3_vals),
-                            Arg::from_usage("--multvals [multvals] 'Tests mutliple values, not mult occs'").value_names(&m_val_names),
-                            Arg::from_usage("--multvalsmo [multvalsmo]... 'Tests mutliple values, not mult occs'").value_names(&m_val_names),
+                            Arg::from_usage("--multvals [one] [two] 'Tests mutliple values, not mult occs'"),
+                            Arg::from_usage("--multvalsmo... [one] [two] 'Tests mutliple values, and mult occs'"),
                             Arg::from_usage("--minvals2 [minvals]... 'Tests 2 min vals'").min_values(2),
                             Arg::from_usage("--maxvals3 [maxvals]... 'Tests 3 max vals'").max_values(3)
                         ])
@@ -42,11 +41,11 @@ fn main() {
         println!("flag NOT present");
     }
 
-    if matches.is_present("opt") {
-        if let Some(v) = matches.value_of("opt") {
-            println!("option present {} times with value: {}",matches.occurrences_of("opt"), v);
+    if matches.is_present("option") {
+        if let Some(v) = matches.value_of("option") {
+            println!("option present {} times with value: {}",matches.occurrences_of("option"), v);
         }
-        if let Some(ov) = matches.values_of("opt") {
+        if let Some(ov) = matches.values_of("option") {
             for o in ov {
                 println!("An option: {}", o);
             }
@@ -63,15 +62,15 @@ fn main() {
 
     if matches.is_present("flag2") {
         println!("flag2 present");
-        println!("option2 present with value of: {}", matches.value_of("option2").unwrap());
+        println!("option2 present with value of: {}", matches.value_of("long-option-2").unwrap());
         println!("positional2 present with value of: {}", matches.value_of("positional2").unwrap());
     } else {
         println!("flag2 NOT present");
-        println!("option2 maybe present with value of: {}", matches.value_of("option2").unwrap_or("Nothing"));
+        println!("option2 maybe present with value of: {}", matches.value_of("long-option-2").unwrap_or("Nothing"));
         println!("positional2 maybe present with value of: {}", matches.value_of("positional2").unwrap_or("Nothing"));
     }
 
-    match matches.value_of("option3").unwrap_or("") {
+    match matches.value_of("Option3").unwrap_or("") {
         "fast" => println!("option3 present quickly"),
         "slow" => println!("option3 present slowly"),
         _      => println!("option3 NOT present")
@@ -83,11 +82,11 @@ fn main() {
         _      => println!("positional3 NOT present")
     }
 
-    if matches.is_present("opt") {
-        if let Some(v) = matches.value_of("opt") {
-            println!("option present {} times with value: {}",matches.occurrences_of("opt"), v);
+    if matches.is_present("option") {
+        if let Some(v) = matches.value_of("option") {
+            println!("option present {} times with value: {}",matches.occurrences_of("option"), v);
         }
-        if let Some(ov) = matches.values_of("opt") {
+        if let Some(ov) = matches.values_of("option") {
             for o in ov {
                 println!("An option: {}", o);
             }
@@ -110,11 +109,11 @@ fn main() {
                 println!("flag NOT present");
             }
 
-            if matches.is_present("scoption") {
-                if let Some(v) = matches.value_of("scoption") {
+            if matches.is_present("option") {
+                if let Some(v) = matches.value_of("option") {
                     println!("scoption present with value: {}", v);
                 }
-                if let Some(ov) = matches.values_of("scoption") {
+                if let Some(ov) = matches.values_of("option") {
                     for o in ov {
                         println!("An scoption: {}", o);
                     }

tests/flags.rs

@@ -1,6 +1,6 @@
 extern crate clap;
 
-use clap::{App, Arg};
+use clap::{App, Arg, ArgSettings};
 
 #[test]
 fn flag_using_short() {
@@ -9,7 +9,7 @@ fn flag_using_short() {
             Arg::from_usage("-f, --flag 'some flag'"),
             Arg::from_usage("-c, --color 'some other flag'")
             ])
-        .get_matches_from(vec!["myprog", "-f", "-c"]);
+        .get_matches_from(vec!["", "-f", "-c"]);
     assert!(m.is_present("flag"));
     assert!(m.is_present("color"));
 }
@@ -21,7 +21,7 @@ fn flag_using_long() {
             Arg::from_usage("--flag 'some flag'"),
             Arg::from_usage("--color 'some other flag'")
             ])
-        .get_matches_from(vec!["myprog", "--flag", "--color"]);
+        .get_matches_from(vec!["", "--flag", "--color"]);
     assert!(m.is_present("flag"));
     assert!(m.is_present("color"));
 }
@@ -33,7 +33,7 @@ fn flag_using_mixed() {
             Arg::from_usage("-f, --flag 'some flag'"),
             Arg::from_usage("-c, --color 'some other flag'")
             ])
-        .get_matches_from(vec!["myprog", "-f", "--color"]);
+        .get_matches_from(vec!["", "-f", "--color"]);
     assert!(m.is_present("flag"));
     assert!(m.is_present("color"));
 
@@ -42,7 +42,7 @@ fn flag_using_mixed() {
             Arg::from_usage("-f, --flag 'some flag'"),
             Arg::from_usage("-c, --color 'some other flag'")
             ])
-        .get_matches_from(vec!["myprog", "--flag", "-c"]);
+        .get_matches_from(vec!["", "--flag", "-c"]);
     assert!(m.is_present("flag"));
     assert!(m.is_present("color"));
 }
@@ -55,22 +55,157 @@ fn multiple_flags_in_single() {
             Arg::from_usage("-c, --color 'some other flag'"),
             Arg::from_usage("-d, --debug 'another other flag'")
             ])
-        .get_matches_from(vec!["myprog", "-fcd"]);
+        .get_matches_from(vec!["", "-fcd"]);
     assert!(m.is_present("flag"));
     assert!(m.is_present("color"));
     assert!(m.is_present("debug"));
 }
 
 #[test]
-#[should_panic]
 fn short_flag_misspel() {
-    App::new("short_flag")
-        .arg(Arg::from_usage("-f1, --flag 'some flag'"));
+    let a = Arg::from_usage("-f1, --flag 'some flag'");
+    assert_eq!(a.name, "flag");
+    assert_eq!(a.short.unwrap(), 'f');
+    assert_eq!(a.long.unwrap(), "flag");
+    assert_eq!(a.help.unwrap(), "some flag");
+    assert!(!a.is_set(ArgSettings::Multiple));
+    assert!(a.val_names.is_none());
+    assert!(a.num_vals.is_none());
 }
 
 #[test]
-#[should_panic]
 fn short_flag_name_missing() {
-    App::new("short_flag")
-        .arg(Arg::from_usage("-f 'some flag'"));
+    let a = Arg::from_usage("-f 'some flag'");
+    assert_eq!(a.name, "f");
+    assert_eq!(a.short.unwrap(), 'f');
+    assert!(a.long.is_none());
+    assert_eq!(a.help.unwrap(), "some flag");
+    assert!(!a.is_set(ArgSettings::Multiple));
+    assert!(a.val_names.is_none());
+    assert!(a.num_vals.is_none());
+
+}
+
+#[test]
+fn create_flag() {
+    let _ = App::new("test")
+                .arg(Arg::with_name("test")
+                            .short("t")
+                            .long("test")
+                            .help("testing testing"))
+                .get_matches();
+}
+
+#[test]
+fn create_flag_usage() {
+    let a = Arg::from_usage("[flag] -f 'some help info'");
+    assert_eq!(a.name, "flag");
+    assert_eq!(a.short.unwrap(), 'f');
+    assert!(a.long.is_none());
+    assert_eq!(a.help.unwrap(), "some help info");
+    assert!(!a.is_set(ArgSettings::Multiple));
+    assert!(a.val_names.is_none());
+    assert!(a.num_vals.is_none());
+
+    let b = Arg::from_usage("[flag] --flag 'some help info'");
+    assert_eq!(b.name, "flag");
+    assert_eq!(b.long.unwrap(), "flag");
+    assert!(b.short.is_none());
+    assert_eq!(b.help.unwrap(), "some help info");
+    assert!(!b.is_set(ArgSettings::Multiple));
+    assert!(a.val_names.is_none());
+    assert!(a.num_vals.is_none());
+
+    let b = Arg::from_usage("--flag 'some help info'");
+    assert_eq!(b.name, "flag");
+    assert_eq!(b.long.unwrap(), "flag");
+    assert!(b.short.is_none());
+    assert_eq!(b.help.unwrap(), "some help info");
+    assert!(!b.is_set(ArgSettings::Multiple));
+    assert!(b.val_names.is_none());
+    assert!(b.num_vals.is_none());
+
+    let c = Arg::from_usage("[flag] -f --flag 'some help info'");
+    assert_eq!(c.name, "flag");
+    assert_eq!(c.short.unwrap(), 'f');
+    assert_eq!(c.long.unwrap(), "flag");
+    assert_eq!(c.help.unwrap(), "some help info");
+    assert!(!c.is_set(ArgSettings::Multiple));
+    assert!(c.val_names.is_none());
+    assert!(c.num_vals.is_none());
+
+    let d = Arg::from_usage("[flag] -f... 'some help info'");
+    assert_eq!(d.name, "flag");
+    assert_eq!(d.short.unwrap(), 'f');
+    assert!(d.long.is_none());
+    assert_eq!(d.help.unwrap(), "some help info");
+    assert!(d.is_set(ArgSettings::Multiple));
+    assert!(d.val_names.is_none());
+    assert!(d.num_vals.is_none());
+
+    let e = Arg::from_usage("[flag] -f --flag... 'some help info'");
+    assert_eq!(e.name, "flag");
+    assert_eq!(e.long.unwrap(), "flag");
+    assert_eq!(e.short.unwrap(), 'f');
+    assert_eq!(e.help.unwrap(), "some help info");
+    assert!(e.is_set(ArgSettings::Multiple));
+    assert!(e.val_names.is_none());
+    assert!(e.num_vals.is_none());
+
+    let e = Arg::from_usage("-f --flag... 'some help info'");
+    assert_eq!(e.name, "flag");
+    assert_eq!(e.long.unwrap(), "flag");
+    assert_eq!(e.short.unwrap(), 'f');
+    assert_eq!(e.help.unwrap(), "some help info");
+    assert!(e.is_set(ArgSettings::Multiple));
+    assert!(e.val_names.is_none());
+    assert!(e.num_vals.is_none());
+
+    let e = Arg::from_usage("--flags");
+    assert_eq!(e.name, "flags");
+    assert_eq!(e.long.unwrap(), "flags");
+    assert!(e.val_names.is_none());
+    assert!(e.num_vals.is_none());
+
+    let e = Arg::from_usage("--flags...");
+    assert_eq!(e.name, "flags");
+    assert_eq!(e.long.unwrap(), "flags");
+    assert!(e.is_set(ArgSettings::Multiple));
+    assert!(e.val_names.is_none());
+    assert!(e.num_vals.is_none());
+
+    let e = Arg::from_usage("[flags] -f");
+    assert_eq!(e.name, "flags");
+    assert_eq!(e.short.unwrap(), 'f');
+    assert!(e.val_names.is_none());
+    assert!(e.num_vals.is_none());
+
+    let e = Arg::from_usage("[flags] -f...");
+    assert_eq!(e.name, "flags");
+    assert_eq!(e.short.unwrap(), 'f');
+    assert!(e.is_set(ArgSettings::Multiple));
+    assert!(e.val_names.is_none());
+    assert!(e.num_vals.is_none());
+
+    let a = Arg::from_usage("-f 'some help info'");
+    assert_eq!(a.name, "f");
+    assert_eq!(a.short.unwrap(), 'f');
+    assert!(a.long.is_none());
+    assert_eq!(a.help.unwrap(), "some help info");
+    assert!(!a.is_set(ArgSettings::Multiple));
+    assert!(a.val_names.is_none());
+    assert!(a.num_vals.is_none());
+
+    let e = Arg::from_usage("-f");
+    assert_eq!(e.name, "f");
+    assert_eq!(e.short.unwrap(), 'f');
+    assert!(e.val_names.is_none());
+    assert!(e.num_vals.is_none());
+
+    let e = Arg::from_usage("-f...");
+    assert_eq!(e.name, "f");
+    assert_eq!(e.short.unwrap(), 'f');
+    assert!(e.is_set(ArgSettings::Multiple));
+    assert!(e.val_names.is_none());
+    assert!(e.num_vals.is_none());
 }