clars 0.3.0

Command line arguments resolver
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use super::*;

#[test]
fn _0001() {
  // Option terminator is not required and not provided in command line.
  let matches = Clar::new(APP).terminator(ClarTerminator::new("term")).resolve(EMPTY_INPUT).unwrap();
  assert_eq!(EMPTY_VALUES, matches.get_values("term"));
  assert_eq!(0, matches.get_count("term"));
  assert!(!matches.is_present("term"));
}

#[test]
fn _0002() {
  // Option terminator is not required and provided on command line without following arguments.
  let matches = Clar::new(APP).terminator(ClarTerminator::new("term")).resolve(["--"]).unwrap();
  assert_eq!(EMPTY_VALUES, matches.get_values("term"));
  assert_eq!(1, matches.get_count("term"));
  assert!(matches.is_present("term"));
}

#[test]
fn _0003() {
  // Option terminator is not required and provided on command line with one argument.
  assert_eq!(
    vec![some!("A")],
    Clar::new(APP)
      .terminator(ClarTerminator::new("term"))
      .resolve(["--", "A"])
      .unwrap()
      .get_values("term")
  );
}

#[test]
fn _0004() {
  // Option terminator is not required and provided on command line with multiple arguments.
  assert_eq!(
    vec![some!("A"), some!("B"), some!("C")],
    Clar::new(APP)
      .terminator(ClarTerminator::new("term"))
      .resolve(["--", "A", "B", "C"])
      .unwrap()
      .get_values("term")
  );
}

#[test]
fn _0005() {
  // Required option terminator is not provided.
  assert_eq!(
    "missing required option terminator '--'",
    Clar::new(APP)
      .terminator(ClarTerminator::new("term").required())
      .resolve(EMPTY_INPUT)
      .unwrap_err()
      .to_string()
  );
}

#[test]
fn _0006() {
  // Required option terminator is provided without arguments.
  assert_eq!(
    EMPTY_VALUES,
    Clar::new(APP)
      .terminator(ClarTerminator::new("term").required())
      .resolve(["--"])
      .unwrap()
      .get_values("term")
  );
}

#[test]
fn _0007() {
  // Required option terminator is provided with one argument.
  assert_eq!(
    vec![some!("A")],
    Clar::new(APP)
      .terminator(ClarTerminator::new("term").required())
      .resolve(["--", "A"])
      .unwrap()
      .get_values("term")
  );
}

#[test]
fn _0008() {
  // Required option terminator is provided with multiple arguments.
  assert_eq!(
    vec![some!("A"), some!("B")],
    Clar::new(APP)
      .terminator(ClarTerminator::new("term").required())
      .resolve(["--", "A", "B"])
      .unwrap()
      .get_values("term")
  );
}

#[test]
fn _0009() {
  // Given: A resolver that accepts only option terminator. Option terminator is optional.
  //  When: Instead of option terminator an option or argument appears on input.
  //  Then: Report an error.
  let terminator = ClarTerminator::new("term");
  assert_eq!(
    "unexpected option '-h' found",
    Clar::new(APP).terminator(terminator.clone()).resolve(["-h"]).unwrap_err().to_string()
  );
  assert_eq!(
    "unexpected option '--help' found",
    Clar::new(APP).terminator(terminator.clone()).resolve(["--help"]).unwrap_err().to_string()
  );
  assert_eq!(
    "unexpected argument 'help' found",
    Clar::new(APP).terminator(terminator).resolve(["help"]).unwrap_err().to_string()
  );
}

#[test]
fn _0010() {
  // Given: A resolver that accepts only option terminator.
  //        Option terminator is required and must appear on input.
  //  When: Instead of option terminator an option or argument appears on input.
  //  Then: Report an error.
  let terminator = ClarTerminator::new("term").required();
  assert_eq!(
    "unexpected option '-h' found",
    Clar::new(APP).terminator(terminator.clone()).resolve(["-h"]).unwrap_err().to_string()
  );
  assert_eq!(
    "unexpected option '--help' found",
    Clar::new(APP).terminator(terminator.clone()).resolve(["--help"]).unwrap_err().to_string()
  );
  assert_eq!(
    "unexpected argument 'help' found",
    Clar::new(APP).terminator(terminator).resolve(["help"]).unwrap_err().to_string()
  );
}