argparse 0.2.2

Powerful command-line argument parsing library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use parser::ArgumentParser;
use super::Store;
use super::{StoreTrue, StoreFalse};
use test_parser::{check_ok};

fn store_true(args: &[&str]) -> bool {
    let mut verbose = false;
    {
        let mut ap = ArgumentParser::new();
        ap.refer(&mut verbose)
          .add_option(&["-t", "--true"], StoreTrue,
            "Store true action");
        check_ok(&ap,  args);
    }
    return verbose;
}

#[test]
fn test_store_true() {
    assert!(!store_true(&["./argparse_test"]));
    assert!(store_true(&["./argparse_test", "--true"]));
}

fn store_false(args: &[&str]) -> bool {
    let mut verbose = true;
    {
        let mut ap = ArgumentParser::new();
        ap.refer(&mut verbose)
          .add_option(&["-f", "--false"], StoreFalse,
            "Store false action");
        check_ok(&ap,  args);
    }
    return verbose;
}
#[test]
fn test_store_false() {
    assert!(store_false(&["./argparse_test"]));
    assert!(!store_false(&["./argparse_test", "--false"]));
}

fn store_bool(args: &[&str]) -> bool {
    let mut verbose = false;
    {
        let mut ap = ArgumentParser::new();
        ap.refer(&mut verbose)
          .add_option(&["-f", "--false"], StoreFalse,
            "Store false action")
          .add_option(&["-t", "--true"], StoreTrue,
            "Store false action");
        check_ok(&ap,  args);
    }
    return verbose;
}

#[test]
fn test_bool() {
    assert!(!store_bool(&["./argparse_test"]));
    assert!(store_bool(&["./argparse_test", "-t"]));
    assert!(!store_bool(&["./argparse_test", "-f"]));
    assert!(store_bool(&["./argparse_test", "-fft"]));
    assert!(!store_bool(&["./argparse_test", "-fffft", "-f"]));
    assert!(store_bool(&["./argparse_test", "--false", "-fffft", "-f",
                   "--true"]));
}

fn set_bool(args: &[&str]) -> bool {
    let mut verbose = false;
    {
        let mut ap = ArgumentParser::new();
        ap.refer(&mut verbose)
          .add_option(&["-s", "--set"], Store,
            "Set boolean value");
        check_ok(&ap,  args);
    }
    return verbose;
}


#[test]
fn test_set_bool() {
    assert!(!set_bool(&["./argparse_test"]));
    assert!(set_bool(&["./argparse_test", "-strue"]));
    assert!(!set_bool(&["./argparse_test", "-sfalse"]));

    // Unfortunately other values do not work
}

#[test]
#[should_panic(expected="Bad value yes")]
fn test_bad_bools1() {
    assert!(!set_bool(&["./argparse_test", "-syes"]));
}

#[test]
#[should_panic(expected="Bad value no")]
fn test_bad_bools2() {
    assert!(!set_bool(&["./argparse_test", "-sno"]));
}