1 extern crate assert_cmd;
2 extern crate escargot;
3 extern crate predicates;
4 
5 use assert_cmd::prelude::*;
6 use escargot::CargoBuild;
7 
8 #[test]
test_verbose_1()9 fn test_verbose_1() {
10     let example = CargoBuild::new().example("verbose").run().unwrap();
11     let mut cmd = example.command();
12     let output = cmd.unwrap();
13     output.clone().assert().success();
14     output.assert().stdout("ERROR\n");
15 }
16 
17 #[test]
test_verbose_2()18 fn test_verbose_2() {
19     let example = CargoBuild::new().example("verbose").run().unwrap();
20     let mut cmd = example.command();
21     let output = cmd.args(&["-v"]).unwrap();
22     output.clone().assert().success();
23     output.assert().stdout("WARN\n");
24 }
25 
26 #[test]
test_verbose_3()27 fn test_verbose_3() {
28     let example = CargoBuild::new().example("verbose").run().unwrap();
29     let mut cmd = example.command();
30     let output = cmd.args(&["-vvvvvv"]).unwrap();
31     output.clone().assert().success();
32     output.assert().stdout("TRACE\n");
33 }
34 
35 #[test]
test_verbose_4()36 fn test_verbose_4() {
37     let example = CargoBuild::new().example("verbose").run().unwrap();
38     let mut cmd = example.command();
39     cmd.args(&["-q"]).assert().failure();
40 }
41 
42 #[cfg(feature = "simplelog")]
43 #[test]
test_verbose_simplelog_1()44 fn test_verbose_simplelog_1() {
45     let example = CargoBuild::new()
46         .example("verbose_simplelog")
47         .features("simplelog")
48         .run()
49         .unwrap();
50     let mut cmd = example.command();
51     let output = cmd.unwrap();
52     output.clone().assert().success();
53     output.assert().stdout("");
54 }
55 
56 #[cfg(feature = "simplelog")]
57 #[test]
test_verbose_simplelog_2()58 fn test_verbose_simplelog_2() {
59     let example = CargoBuild::new()
60         .example("verbose_simplelog")
61         .features("simplelog")
62         .run()
63         .unwrap();
64     let mut cmd = example.command();
65     let output = cmd.args(&["-v"]).unwrap();
66     output.clone().assert().success();
67     output.assert().stdout("");
68 }
69 
70 #[cfg(feature = "simplelog")]
71 #[test]
test_verbose_simplelog_3()72 fn test_verbose_simplelog_3() {
73     let example = CargoBuild::new()
74         .example("verbose_simplelog")
75         .features("simplelog")
76         .run()
77         .unwrap();
78     let mut cmd = example.command();
79     let output = cmd.args(&["-vvvvvv"]).unwrap();
80     output.clone().assert().success();
81     output.assert().stdout(predicates::str::ends_with(
82         "verbose_simplelog: [examples/verbose_simplelog.rs:25] TRACE\n",
83     ));
84 }
85 
86 #[cfg(feature = "simplelog")]
87 #[test]
test_verbose_simplelog_4()88 fn test_verbose_simplelog_4() {
89     let example = CargoBuild::new()
90         .example("verbose_simplelog")
91         .features("simplelog")
92         .run()
93         .unwrap();
94     let mut cmd = example.command();
95     cmd.args(&["-q"]).assert().failure();
96 }
97 
98 #[test]
test_verbosenodef_1()99 fn test_verbosenodef_1() {
100     let example = CargoBuild::new()
101         .example("verbose_no_default")
102         .run()
103         .unwrap();
104     let mut cmd = example.command();
105     let output = cmd.unwrap();
106     output.clone().assert().success();
107     output.assert().stdout("OFF\n");
108 }
109 
110 #[test]
test_verbosenodef_2()111 fn test_verbosenodef_2() {
112     let example = CargoBuild::new()
113         .example("verbose_no_default")
114         .run()
115         .unwrap();
116     let mut cmd = example.command();
117     let output = cmd.args(&["-v"]).unwrap();
118     output.clone().assert().success();
119     output.assert().stdout("ERROR\n");
120 }
121 
122 #[test]
test_verbosenodef_3()123 fn test_verbosenodef_3() {
124     let example = CargoBuild::new()
125         .example("verbose_no_default")
126         .run()
127         .unwrap();
128     let mut cmd = example.command();
129     let output = cmd.args(&["-vvvvvvvvv"]).unwrap();
130     output.clone().assert().success();
131     output.assert().stdout("TRACE\n");
132 }
133 
134 #[test]
test_verbosenodef_4()135 fn test_verbosenodef_4() {
136     let example = CargoBuild::new()
137         .example("verbose_no_default")
138         .run()
139         .unwrap();
140     let mut cmd = example.command();
141     cmd.args(&["-q"]).assert().failure();
142 }
143 
144 #[cfg(feature = "simplelog")]
145 #[test]
test_verbosenodef_simplelog_1()146 fn test_verbosenodef_simplelog_1() {
147     let example = CargoBuild::new()
148         .example("verbose_no_default_simplelog")
149         .features("simplelog")
150         .run()
151         .unwrap();
152     let mut cmd = example.command();
153     let output = cmd.unwrap();
154     output.clone().assert().success();
155     output.assert().stdout("");
156 }
157 
158 #[cfg(feature = "simplelog")]
159 #[test]
test_verbosenodef_simplelog_2()160 fn test_verbosenodef_simplelog_2() {
161     let example = CargoBuild::new()
162         .example("verbose_no_default_simplelog")
163         .features("simplelog")
164         .run()
165         .unwrap();
166     let mut cmd = example.command();
167     let output = cmd.args(&["-vvvvvvvvv"]).unwrap();
168     output.clone().assert().success();
169     output.assert().stdout(predicates::str::ends_with(
170         "verbose_no_default_simplelog: [examples/verbose_no_default_simplelog.rs:30] TRACE\n",
171     ));
172 }
173 
174 #[cfg(feature = "simplelog")]
175 #[test]
test_verbosenodef_simplelog_3()176 fn test_verbosenodef_simplelog_3() {
177     let example = CargoBuild::new()
178         .example("verbose_no_default_simplelog")
179         .features("simplelog")
180         .run()
181         .unwrap();
182     let mut cmd = example.command();
183     cmd.args(&["-q"]).assert().failure();
184 }
185 
186 #[test]
test_quietverbose_1()187 fn test_quietverbose_1() {
188     let example = CargoBuild::new().example("quiet_verbose").run().unwrap();
189     let mut cmd = example.command();
190     let output = cmd.unwrap();
191     output.clone().assert().success();
192     output.assert().stdout("WARN\n");
193 }
194 
195 #[test]
test_quietverbose_2()196 fn test_quietverbose_2() {
197     let example = CargoBuild::new().example("quiet_verbose").run().unwrap();
198     let mut cmd = example.command();
199     let output = cmd.args(&["-vv"]).unwrap();
200     output.clone().assert().success();
201     output.assert().stdout("DEBUG\n");
202 }
203 
204 #[test]
test_quietverbose_3()205 fn test_quietverbose_3() {
206     let example = CargoBuild::new().example("quiet_verbose").run().unwrap();
207     let mut cmd = example.command();
208     let output = cmd.args(&["-qq"]).unwrap();
209     output.clone().assert().success();
210     output.assert().stdout("OFF\n");
211 }
212 
213 #[test]
test_quietverbose_4()214 fn test_quietverbose_4() {
215     let example = CargoBuild::new().example("quiet_verbose").run().unwrap();
216     let mut cmd = example.command();
217     cmd.args(&["-q", "-v"]).assert().failure();
218 }
219 
220 #[cfg(feature = "simplelog")]
221 #[test]
test_quietverbose_simplelog_1()222 fn test_quietverbose_simplelog_1() {
223     let example = CargoBuild::new()
224         .example("quiet_verbose_simplelog")
225         .features("simplelog")
226         .run()
227         .unwrap();
228     let mut cmd = example.command();
229     let output = cmd.unwrap();
230     output.clone().assert().success();
231     output.assert().stdout("");
232 }
233 
234 #[cfg(feature = "simplelog")]
235 #[test]
test_quietverbose_simplelog_2()236 fn test_quietverbose_simplelog_2() {
237     let example = CargoBuild::new()
238         .example("quiet_verbose_simplelog")
239         .features("simplelog")
240         .run()
241         .unwrap();
242     let mut cmd = example.command();
243     let output = cmd.args(&["-vv"]).unwrap();
244     output.clone().assert().success();
245     output.assert().stdout(predicates::str::ends_with(
246         "quiet_verbose_simplelog: DEBUG\n",
247     ));
248 }
249 
250 #[cfg(feature = "simplelog")]
251 #[test]
test_quietverbose_simplelog_3()252 fn test_quietverbose_simplelog_3() {
253     let example = CargoBuild::new()
254         .example("quiet_verbose_simplelog")
255         .features("simplelog")
256         .run()
257         .unwrap();
258     let mut cmd = example.command();
259     let output = cmd.args(&["-qq"]).unwrap();
260     output.clone().assert().success();
261     output.assert().stdout("");
262 }
263 
264 #[cfg(feature = "simplelog")]
265 #[test]
test_quietverbose_simplelog_4()266 fn test_quietverbose_simplelog_4() {
267     let example = CargoBuild::new()
268         .example("quiet_verbose_simplelog")
269         .features("simplelog")
270         .run()
271         .unwrap();
272     let mut cmd = example.command();
273     cmd.args(&["-q", "-v"]).assert().failure();
274 }
275 
276 #[test]
test_simpleverbose_1()277 fn test_simpleverbose_1() {
278     let example = CargoBuild::new().example("simple_verbose").run().unwrap();
279     let mut cmd = example.command();
280     let output = cmd.unwrap();
281     output.clone().assert().success();
282     output.assert().stdout("False\n");
283 }
284 
285 #[test]
test_simpleverbose_2()286 fn test_simpleverbose_2() {
287     let example = CargoBuild::new().example("simple_verbose").run().unwrap();
288     let mut cmd = example.command();
289     let output = cmd.args(&["-v"]).unwrap();
290     output.clone().assert().success();
291     output.assert().stdout("True\n");
292 }
293 
294 #[test]
test_simpleverbose_3()295 fn test_simpleverbose_3() {
296     let example = CargoBuild::new().example("simple_verbose").run().unwrap();
297     let mut cmd = example.command();
298     cmd.args(&["-vv"]).assert().failure();
299 }
300