]>
Commit | Line | Data |
---|---|---|
416331ca XL |
1 | use super::*; |
2 | ||
e74abb32 XL |
3 | use crate::{ |
4 | bench::Bencher, | |
5 | console::OutputLocation, | |
6 | options::OutputFormat, | |
7 | time::{TimeThreshold, TestTimeOptions}, | |
8 | formatters::PrettyFormatter, | |
9 | test::{ | |
10 | filter_tests, parse_opts, run_test, DynTestFn, DynTestName, MetricMap, | |
11 | RunIgnored, RunStrategy, ShouldPanic, StaticTestName, TestDesc, | |
12 | TestDescAndFn, TestOpts, TrIgnored, TrOk, | |
13 | // FIXME (introduced by #65251) | |
14 | // ShouldPanic, StaticTestName, TestDesc, TestDescAndFn, TestOpts, TestTimeOptions, | |
15 | // TestType, TrFailedMsg, TrIgnored, TrOk, | |
16 | }, | |
dc9dc135 | 17 | }; |
60c5eb7d | 18 | use std::any::TypeId; |
dc9dc135 | 19 | use std::sync::mpsc::channel; |
e74abb32 | 20 | use std::time::Duration; |
dc9dc135 | 21 | |
416331ca XL |
22 | impl TestOpts { |
23 | fn new() -> TestOpts { | |
24 | TestOpts { | |
25 | list: false, | |
26 | filter: None, | |
27 | filter_exact: false, | |
60c5eb7d | 28 | force_run_in_process: false, |
416331ca XL |
29 | exclude_should_panic: false, |
30 | run_ignored: RunIgnored::No, | |
31 | run_tests: false, | |
32 | bench_benchmarks: false, | |
33 | logfile: None, | |
34 | nocapture: false, | |
35 | color: AutoColor, | |
36 | format: OutputFormat::Pretty, | |
37 | test_threads: None, | |
38 | skip: vec![], | |
e74abb32 | 39 | time_options: None, |
416331ca XL |
40 | options: Options::new(), |
41 | } | |
42 | } | |
43 | } | |
44 | ||
dc9dc135 XL |
45 | fn one_ignored_one_unignored_test() -> Vec<TestDescAndFn> { |
46 | vec![ | |
47 | TestDescAndFn { | |
48 | desc: TestDesc { | |
49 | name: StaticTestName("1"), | |
50 | ignore: true, | |
51 | should_panic: ShouldPanic::No, | |
52 | allow_fail: false, | |
e74abb32 | 53 | test_type: TestType::Unknown, |
dc9dc135 XL |
54 | }, |
55 | testfn: DynTestFn(Box::new(move || {})), | |
56 | }, | |
57 | TestDescAndFn { | |
58 | desc: TestDesc { | |
59 | name: StaticTestName("2"), | |
60 | ignore: false, | |
61 | should_panic: ShouldPanic::No, | |
62 | allow_fail: false, | |
e74abb32 | 63 | test_type: TestType::Unknown, |
dc9dc135 XL |
64 | }, |
65 | testfn: DynTestFn(Box::new(move || {})), | |
66 | }, | |
67 | ] | |
68 | } | |
69 | ||
70 | #[test] | |
71 | pub fn do_not_run_ignored_tests() { | |
72 | fn f() { | |
73 | panic!(); | |
74 | } | |
75 | let desc = TestDescAndFn { | |
76 | desc: TestDesc { | |
77 | name: StaticTestName("whatever"), | |
78 | ignore: true, | |
79 | should_panic: ShouldPanic::No, | |
80 | allow_fail: false, | |
e74abb32 | 81 | test_type: TestType::Unknown, |
dc9dc135 XL |
82 | }, |
83 | testfn: DynTestFn(Box::new(f)), | |
84 | }; | |
85 | let (tx, rx) = channel(); | |
e74abb32 XL |
86 | run_test(&TestOpts::new(), false, desc, RunStrategy::InProcess, tx, Concurrent::No); |
87 | let result = rx.recv().unwrap().result; | |
60c5eb7d | 88 | assert_ne!(result, TrOk); |
dc9dc135 XL |
89 | } |
90 | ||
91 | #[test] | |
92 | pub fn ignored_tests_result_in_ignored() { | |
93 | fn f() {} | |
94 | let desc = TestDescAndFn { | |
95 | desc: TestDesc { | |
96 | name: StaticTestName("whatever"), | |
97 | ignore: true, | |
98 | should_panic: ShouldPanic::No, | |
99 | allow_fail: false, | |
e74abb32 | 100 | test_type: TestType::Unknown, |
dc9dc135 XL |
101 | }, |
102 | testfn: DynTestFn(Box::new(f)), | |
103 | }; | |
104 | let (tx, rx) = channel(); | |
e74abb32 XL |
105 | run_test(&TestOpts::new(), false, desc, RunStrategy::InProcess, tx, Concurrent::No); |
106 | let result = rx.recv().unwrap().result; | |
60c5eb7d | 107 | assert_eq!(result, TrIgnored); |
dc9dc135 XL |
108 | } |
109 | ||
e74abb32 | 110 | // FIXME: Re-enable emscripten once it can catch panics again (introduced by #65251) |
dc9dc135 | 111 | #[test] |
e74abb32 | 112 | #[cfg(not(target_os = "emscripten"))] |
dc9dc135 XL |
113 | fn test_should_panic() { |
114 | fn f() { | |
115 | panic!(); | |
116 | } | |
117 | let desc = TestDescAndFn { | |
118 | desc: TestDesc { | |
119 | name: StaticTestName("whatever"), | |
120 | ignore: false, | |
121 | should_panic: ShouldPanic::Yes, | |
122 | allow_fail: false, | |
e74abb32 | 123 | test_type: TestType::Unknown, |
dc9dc135 XL |
124 | }, |
125 | testfn: DynTestFn(Box::new(f)), | |
126 | }; | |
127 | let (tx, rx) = channel(); | |
e74abb32 XL |
128 | run_test(&TestOpts::new(), false, desc, RunStrategy::InProcess, tx, Concurrent::No); |
129 | let result = rx.recv().unwrap().result; | |
60c5eb7d | 130 | assert_eq!(result, TrOk); |
dc9dc135 XL |
131 | } |
132 | ||
e74abb32 | 133 | // FIXME: Re-enable emscripten once it can catch panics again (introduced by #65251) |
dc9dc135 | 134 | #[test] |
e74abb32 | 135 | #[cfg(not(target_os = "emscripten"))] |
dc9dc135 XL |
136 | fn test_should_panic_good_message() { |
137 | fn f() { | |
138 | panic!("an error message"); | |
139 | } | |
140 | let desc = TestDescAndFn { | |
141 | desc: TestDesc { | |
142 | name: StaticTestName("whatever"), | |
143 | ignore: false, | |
144 | should_panic: ShouldPanic::YesWithMessage("error message"), | |
145 | allow_fail: false, | |
e74abb32 | 146 | test_type: TestType::Unknown, |
dc9dc135 XL |
147 | }, |
148 | testfn: DynTestFn(Box::new(f)), | |
149 | }; | |
150 | let (tx, rx) = channel(); | |
e74abb32 XL |
151 | run_test(&TestOpts::new(), false, desc, RunStrategy::InProcess, tx, Concurrent::No); |
152 | let result = rx.recv().unwrap().result; | |
60c5eb7d | 153 | assert_eq!(result, TrOk); |
dc9dc135 XL |
154 | } |
155 | ||
e74abb32 | 156 | // FIXME: Re-enable emscripten once it can catch panics again (introduced by #65251) |
dc9dc135 | 157 | #[test] |
e74abb32 | 158 | #[cfg(not(target_os = "emscripten"))] |
dc9dc135 | 159 | fn test_should_panic_bad_message() { |
e74abb32 | 160 | use crate::tests::TrFailedMsg; |
dc9dc135 XL |
161 | fn f() { |
162 | panic!("an error message"); | |
163 | } | |
164 | let expected = "foobar"; | |
60c5eb7d XL |
165 | let failed_msg = r#"panic did not contain expected string |
166 | panic message: `"an error message"`, | |
167 | expected substring: `"foobar"`"#; | |
dc9dc135 XL |
168 | let desc = TestDescAndFn { |
169 | desc: TestDesc { | |
170 | name: StaticTestName("whatever"), | |
171 | ignore: false, | |
172 | should_panic: ShouldPanic::YesWithMessage(expected), | |
173 | allow_fail: false, | |
e74abb32 | 174 | test_type: TestType::Unknown, |
dc9dc135 XL |
175 | }, |
176 | testfn: DynTestFn(Box::new(f)), | |
177 | }; | |
178 | let (tx, rx) = channel(); | |
e74abb32 XL |
179 | run_test(&TestOpts::new(), false, desc, RunStrategy::InProcess, tx, Concurrent::No); |
180 | let result = rx.recv().unwrap().result; | |
60c5eb7d XL |
181 | assert_eq!(result, TrFailedMsg(failed_msg.to_string())); |
182 | } | |
183 | ||
184 | // FIXME: Re-enable emscripten once it can catch panics again (introduced by #65251) | |
185 | #[test] | |
186 | #[cfg(not(target_os = "emscripten"))] | |
187 | fn test_should_panic_non_string_message_type() { | |
188 | use crate::tests::TrFailedMsg; | |
189 | fn f() { | |
190 | panic!(1i32); | |
191 | } | |
192 | let expected = "foobar"; | |
193 | let failed_msg = format!(r#"expected panic with string value, | |
194 | found non-string value: `{:?}` | |
195 | expected substring: `"foobar"`"#, TypeId::of::<i32>()); | |
196 | let desc = TestDescAndFn { | |
197 | desc: TestDesc { | |
198 | name: StaticTestName("whatever"), | |
199 | ignore: false, | |
200 | should_panic: ShouldPanic::YesWithMessage(expected), | |
201 | allow_fail: false, | |
202 | test_type: TestType::Unknown, | |
203 | }, | |
204 | testfn: DynTestFn(Box::new(f)), | |
205 | }; | |
206 | let (tx, rx) = channel(); | |
207 | run_test(&TestOpts::new(), false, desc, RunStrategy::InProcess, tx, Concurrent::No); | |
208 | let result = rx.recv().unwrap().result; | |
209 | assert_eq!(result, TrFailedMsg(failed_msg)); | |
dc9dc135 XL |
210 | } |
211 | ||
e74abb32 | 212 | // FIXME: Re-enable emscripten once it can catch panics again (introduced by #65251) |
dc9dc135 | 213 | #[test] |
e74abb32 | 214 | #[cfg(not(target_os = "emscripten"))] |
dc9dc135 XL |
215 | fn test_should_panic_but_succeeds() { |
216 | fn f() {} | |
217 | let desc = TestDescAndFn { | |
218 | desc: TestDesc { | |
219 | name: StaticTestName("whatever"), | |
220 | ignore: false, | |
221 | should_panic: ShouldPanic::Yes, | |
222 | allow_fail: false, | |
e74abb32 | 223 | test_type: TestType::Unknown, |
dc9dc135 XL |
224 | }, |
225 | testfn: DynTestFn(Box::new(f)), | |
226 | }; | |
227 | let (tx, rx) = channel(); | |
e74abb32 XL |
228 | run_test(&TestOpts::new(), false, desc, RunStrategy::InProcess, tx, Concurrent::No); |
229 | let result = rx.recv().unwrap().result; | |
60c5eb7d | 230 | assert_eq!(result, TrFailedMsg("test did not panic as expected".to_string())); |
e74abb32 XL |
231 | } |
232 | ||
233 | fn report_time_test_template(report_time: bool) -> Option<TestExecTime> { | |
234 | fn f() {} | |
235 | let desc = TestDescAndFn { | |
236 | desc: TestDesc { | |
237 | name: StaticTestName("whatever"), | |
238 | ignore: false, | |
239 | should_panic: ShouldPanic::No, | |
240 | allow_fail: false, | |
241 | test_type: TestType::Unknown, | |
242 | }, | |
243 | testfn: DynTestFn(Box::new(f)), | |
244 | }; | |
245 | let time_options = if report_time { | |
246 | Some(TestTimeOptions::default()) | |
247 | } else { | |
248 | None | |
249 | }; | |
250 | ||
251 | let test_opts = TestOpts { | |
252 | time_options, | |
253 | ..TestOpts::new() | |
254 | }; | |
255 | let (tx, rx) = channel(); | |
256 | run_test(&test_opts, false, desc, RunStrategy::InProcess, tx, Concurrent::No); | |
257 | let exec_time = rx.recv().unwrap().exec_time; | |
258 | exec_time | |
259 | } | |
260 | ||
261 | #[test] | |
262 | fn test_should_not_report_time() { | |
263 | let exec_time = report_time_test_template(false); | |
264 | assert!(exec_time.is_none()); | |
265 | } | |
266 | ||
267 | #[test] | |
268 | fn test_should_report_time() { | |
269 | let exec_time = report_time_test_template(true); | |
270 | assert!(exec_time.is_some()); | |
271 | } | |
272 | ||
273 | fn time_test_failure_template(test_type: TestType) -> TestResult { | |
274 | fn f() {} | |
275 | let desc = TestDescAndFn { | |
276 | desc: TestDesc { | |
277 | name: StaticTestName("whatever"), | |
278 | ignore: false, | |
279 | should_panic: ShouldPanic::No, | |
280 | allow_fail: false, | |
281 | test_type | |
282 | }, | |
283 | testfn: DynTestFn(Box::new(f)), | |
284 | }; | |
285 | // `Default` will initialize all the thresholds to 0 milliseconds. | |
286 | let mut time_options = TestTimeOptions::default(); | |
287 | time_options.error_on_excess = true; | |
288 | ||
289 | let test_opts = TestOpts { | |
290 | time_options: Some(time_options), | |
291 | ..TestOpts::new() | |
292 | }; | |
293 | let (tx, rx) = channel(); | |
294 | run_test(&test_opts, false, desc, RunStrategy::InProcess, tx, Concurrent::No); | |
295 | let result = rx.recv().unwrap().result; | |
296 | ||
297 | result | |
298 | } | |
299 | ||
300 | #[test] | |
301 | fn test_error_on_exceed() { | |
302 | let types = [TestType::UnitTest, TestType::IntegrationTest, TestType::DocTest]; | |
303 | ||
60c5eb7d | 304 | for test_type in types.iter() { |
e74abb32 XL |
305 | let result = time_test_failure_template(*test_type); |
306 | ||
307 | assert_eq!(result, TestResult::TrTimedFail); | |
308 | } | |
309 | ||
310 | // Check that for unknown tests thresholds aren't applied. | |
311 | let result = time_test_failure_template(TestType::Unknown); | |
312 | assert_eq!(result, TestResult::TrOk); | |
313 | } | |
314 | ||
315 | fn typed_test_desc(test_type: TestType) -> TestDesc { | |
316 | TestDesc { | |
317 | name: StaticTestName("whatever"), | |
318 | ignore: false, | |
319 | should_panic: ShouldPanic::No, | |
320 | allow_fail: false, | |
321 | test_type | |
322 | } | |
323 | } | |
324 | ||
325 | fn test_exec_time(millis: u64) -> TestExecTime { | |
326 | TestExecTime(Duration::from_millis(millis)) | |
327 | } | |
328 | ||
329 | #[test] | |
330 | fn test_time_options_threshold() { | |
331 | let unit = TimeThreshold::new(Duration::from_millis(50), Duration::from_millis(100)); | |
332 | let integration = TimeThreshold::new(Duration::from_millis(500), Duration::from_millis(1000)); | |
333 | let doc = TimeThreshold::new(Duration::from_millis(5000), Duration::from_millis(10000)); | |
334 | ||
335 | let options = TestTimeOptions { | |
336 | error_on_excess: false, | |
337 | colored: false, | |
338 | unit_threshold: unit.clone(), | |
339 | integration_threshold: integration.clone(), | |
340 | doctest_threshold: doc.clone(), | |
341 | }; | |
342 | ||
343 | let test_vector = [ | |
344 | (TestType::UnitTest, unit.warn.as_millis() - 1, false, false), | |
345 | (TestType::UnitTest, unit.warn.as_millis(), true, false), | |
346 | (TestType::UnitTest, unit.critical.as_millis(), true, true), | |
347 | (TestType::IntegrationTest, integration.warn.as_millis() - 1, false, false), | |
348 | (TestType::IntegrationTest, integration.warn.as_millis(), true, false), | |
349 | (TestType::IntegrationTest, integration.critical.as_millis(), true, true), | |
350 | (TestType::DocTest, doc.warn.as_millis() - 1, false, false), | |
351 | (TestType::DocTest, doc.warn.as_millis(), true, false), | |
352 | (TestType::DocTest, doc.critical.as_millis(), true, true), | |
353 | ]; | |
354 | ||
60c5eb7d | 355 | for (test_type, time, expected_warn, expected_critical) in test_vector.iter() { |
e74abb32 XL |
356 | let test_desc = typed_test_desc(*test_type); |
357 | let exec_time = test_exec_time(*time as u64); | |
358 | ||
359 | assert_eq!(options.is_warn(&test_desc, &exec_time), *expected_warn); | |
360 | assert_eq!(options.is_critical(&test_desc, &exec_time), *expected_critical); | |
361 | } | |
dc9dc135 XL |
362 | } |
363 | ||
364 | #[test] | |
365 | fn parse_ignored_flag() { | |
366 | let args = vec![ | |
367 | "progname".to_string(), | |
368 | "filter".to_string(), | |
369 | "--ignored".to_string(), | |
370 | ]; | |
371 | let opts = parse_opts(&args).unwrap().unwrap(); | |
372 | assert_eq!(opts.run_ignored, RunIgnored::Only); | |
373 | } | |
374 | ||
e1599b0c XL |
375 | #[test] |
376 | fn parse_show_output_flag() { | |
377 | let args = vec![ | |
378 | "progname".to_string(), | |
379 | "filter".to_string(), | |
380 | "--show-output".to_string(), | |
381 | ]; | |
382 | let opts = parse_opts(&args).unwrap().unwrap(); | |
383 | assert!(opts.options.display_output); | |
384 | } | |
385 | ||
dc9dc135 XL |
386 | #[test] |
387 | fn parse_include_ignored_flag() { | |
388 | let args = vec![ | |
389 | "progname".to_string(), | |
390 | "filter".to_string(), | |
391 | "-Zunstable-options".to_string(), | |
392 | "--include-ignored".to_string(), | |
393 | ]; | |
394 | let opts = parse_opts(&args).unwrap().unwrap(); | |
395 | assert_eq!(opts.run_ignored, RunIgnored::Yes); | |
396 | } | |
397 | ||
398 | #[test] | |
399 | pub fn filter_for_ignored_option() { | |
400 | // When we run ignored tests the test filter should filter out all the | |
401 | // unignored tests and flip the ignore flag on the rest to false | |
402 | ||
403 | let mut opts = TestOpts::new(); | |
404 | opts.run_tests = true; | |
405 | opts.run_ignored = RunIgnored::Only; | |
406 | ||
407 | let tests = one_ignored_one_unignored_test(); | |
408 | let filtered = filter_tests(&opts, tests); | |
409 | ||
410 | assert_eq!(filtered.len(), 1); | |
411 | assert_eq!(filtered[0].desc.name.to_string(), "1"); | |
412 | assert!(!filtered[0].desc.ignore); | |
413 | } | |
414 | ||
415 | #[test] | |
416 | pub fn run_include_ignored_option() { | |
417 | // When we "--include-ignored" tests, the ignore flag should be set to false on | |
418 | // all tests and no test filtered out | |
419 | ||
420 | let mut opts = TestOpts::new(); | |
421 | opts.run_tests = true; | |
422 | opts.run_ignored = RunIgnored::Yes; | |
423 | ||
424 | let tests = one_ignored_one_unignored_test(); | |
425 | let filtered = filter_tests(&opts, tests); | |
426 | ||
427 | assert_eq!(filtered.len(), 2); | |
428 | assert!(!filtered[0].desc.ignore); | |
429 | assert!(!filtered[1].desc.ignore); | |
430 | } | |
431 | ||
432 | #[test] | |
433 | pub fn exclude_should_panic_option() { | |
434 | let mut opts = TestOpts::new(); | |
435 | opts.run_tests = true; | |
436 | opts.exclude_should_panic = true; | |
437 | ||
438 | let mut tests = one_ignored_one_unignored_test(); | |
439 | tests.push(TestDescAndFn { | |
440 | desc: TestDesc { | |
441 | name: StaticTestName("3"), | |
442 | ignore: false, | |
443 | should_panic: ShouldPanic::Yes, | |
444 | allow_fail: false, | |
e74abb32 | 445 | test_type: TestType::Unknown, |
dc9dc135 XL |
446 | }, |
447 | testfn: DynTestFn(Box::new(move || {})), | |
448 | }); | |
449 | ||
450 | let filtered = filter_tests(&opts, tests); | |
451 | ||
452 | assert_eq!(filtered.len(), 2); | |
453 | assert!(filtered.iter().all(|test| test.desc.should_panic == ShouldPanic::No)); | |
454 | } | |
455 | ||
456 | #[test] | |
457 | pub fn exact_filter_match() { | |
458 | fn tests() -> Vec<TestDescAndFn> { | |
459 | vec!["base", "base::test", "base::test1", "base::test2"] | |
460 | .into_iter() | |
461 | .map(|name| TestDescAndFn { | |
462 | desc: TestDesc { | |
463 | name: StaticTestName(name), | |
464 | ignore: false, | |
465 | should_panic: ShouldPanic::No, | |
466 | allow_fail: false, | |
e74abb32 | 467 | test_type: TestType::Unknown, |
dc9dc135 XL |
468 | }, |
469 | testfn: DynTestFn(Box::new(move || {})), | |
470 | }) | |
471 | .collect() | |
472 | } | |
473 | ||
474 | let substr = filter_tests( | |
475 | &TestOpts { | |
476 | filter: Some("base".into()), | |
477 | ..TestOpts::new() | |
478 | }, | |
479 | tests(), | |
480 | ); | |
481 | assert_eq!(substr.len(), 4); | |
482 | ||
483 | let substr = filter_tests( | |
484 | &TestOpts { | |
485 | filter: Some("bas".into()), | |
486 | ..TestOpts::new() | |
487 | }, | |
488 | tests(), | |
489 | ); | |
490 | assert_eq!(substr.len(), 4); | |
491 | ||
492 | let substr = filter_tests( | |
493 | &TestOpts { | |
494 | filter: Some("::test".into()), | |
495 | ..TestOpts::new() | |
496 | }, | |
497 | tests(), | |
498 | ); | |
499 | assert_eq!(substr.len(), 3); | |
500 | ||
501 | let substr = filter_tests( | |
502 | &TestOpts { | |
503 | filter: Some("base::test".into()), | |
504 | ..TestOpts::new() | |
505 | }, | |
506 | tests(), | |
507 | ); | |
508 | assert_eq!(substr.len(), 3); | |
509 | ||
510 | let exact = filter_tests( | |
511 | &TestOpts { | |
512 | filter: Some("base".into()), | |
513 | filter_exact: true, | |
514 | ..TestOpts::new() | |
515 | }, | |
516 | tests(), | |
517 | ); | |
518 | assert_eq!(exact.len(), 1); | |
519 | ||
520 | let exact = filter_tests( | |
521 | &TestOpts { | |
522 | filter: Some("bas".into()), | |
523 | filter_exact: true, | |
524 | ..TestOpts::new() | |
525 | }, | |
526 | tests(), | |
527 | ); | |
528 | assert_eq!(exact.len(), 0); | |
529 | ||
530 | let exact = filter_tests( | |
531 | &TestOpts { | |
532 | filter: Some("::test".into()), | |
533 | filter_exact: true, | |
534 | ..TestOpts::new() | |
535 | }, | |
536 | tests(), | |
537 | ); | |
538 | assert_eq!(exact.len(), 0); | |
539 | ||
540 | let exact = filter_tests( | |
541 | &TestOpts { | |
542 | filter: Some("base::test".into()), | |
543 | filter_exact: true, | |
544 | ..TestOpts::new() | |
545 | }, | |
546 | tests(), | |
547 | ); | |
548 | assert_eq!(exact.len(), 1); | |
549 | } | |
550 | ||
551 | #[test] | |
552 | pub fn sort_tests() { | |
553 | let mut opts = TestOpts::new(); | |
554 | opts.run_tests = true; | |
555 | ||
556 | let names = vec![ | |
557 | "sha1::test".to_string(), | |
558 | "isize::test_to_str".to_string(), | |
559 | "isize::test_pow".to_string(), | |
560 | "test::do_not_run_ignored_tests".to_string(), | |
561 | "test::ignored_tests_result_in_ignored".to_string(), | |
562 | "test::first_free_arg_should_be_a_filter".to_string(), | |
563 | "test::parse_ignored_flag".to_string(), | |
564 | "test::parse_include_ignored_flag".to_string(), | |
565 | "test::filter_for_ignored_option".to_string(), | |
566 | "test::run_include_ignored_option".to_string(), | |
567 | "test::sort_tests".to_string(), | |
568 | ]; | |
569 | let tests = { | |
570 | fn testfn() {} | |
571 | let mut tests = Vec::new(); | |
572 | for name in &names { | |
573 | let test = TestDescAndFn { | |
574 | desc: TestDesc { | |
575 | name: DynTestName((*name).clone()), | |
576 | ignore: false, | |
577 | should_panic: ShouldPanic::No, | |
578 | allow_fail: false, | |
e74abb32 | 579 | test_type: TestType::Unknown, |
dc9dc135 XL |
580 | }, |
581 | testfn: DynTestFn(Box::new(testfn)), | |
582 | }; | |
583 | tests.push(test); | |
584 | } | |
585 | tests | |
586 | }; | |
587 | let filtered = filter_tests(&opts, tests); | |
588 | ||
589 | let expected = vec![ | |
590 | "isize::test_pow".to_string(), | |
591 | "isize::test_to_str".to_string(), | |
592 | "sha1::test".to_string(), | |
593 | "test::do_not_run_ignored_tests".to_string(), | |
594 | "test::filter_for_ignored_option".to_string(), | |
595 | "test::first_free_arg_should_be_a_filter".to_string(), | |
596 | "test::ignored_tests_result_in_ignored".to_string(), | |
597 | "test::parse_ignored_flag".to_string(), | |
598 | "test::parse_include_ignored_flag".to_string(), | |
599 | "test::run_include_ignored_option".to_string(), | |
600 | "test::sort_tests".to_string(), | |
601 | ]; | |
602 | ||
603 | for (a, b) in expected.iter().zip(filtered) { | |
60c5eb7d | 604 | assert_eq!(*a, b.desc.name.to_string()); |
dc9dc135 XL |
605 | } |
606 | } | |
607 | ||
608 | #[test] | |
609 | pub fn test_metricmap_compare() { | |
610 | let mut m1 = MetricMap::new(); | |
611 | let mut m2 = MetricMap::new(); | |
612 | m1.insert_metric("in-both-noise", 1000.0, 200.0); | |
613 | m2.insert_metric("in-both-noise", 1100.0, 200.0); | |
614 | ||
615 | m1.insert_metric("in-first-noise", 1000.0, 2.0); | |
616 | m2.insert_metric("in-second-noise", 1000.0, 2.0); | |
617 | ||
618 | m1.insert_metric("in-both-want-downwards-but-regressed", 1000.0, 10.0); | |
619 | m2.insert_metric("in-both-want-downwards-but-regressed", 2000.0, 10.0); | |
620 | ||
621 | m1.insert_metric("in-both-want-downwards-and-improved", 2000.0, 10.0); | |
622 | m2.insert_metric("in-both-want-downwards-and-improved", 1000.0, 10.0); | |
623 | ||
624 | m1.insert_metric("in-both-want-upwards-but-regressed", 2000.0, -10.0); | |
625 | m2.insert_metric("in-both-want-upwards-but-regressed", 1000.0, -10.0); | |
626 | ||
627 | m1.insert_metric("in-both-want-upwards-and-improved", 1000.0, -10.0); | |
628 | m2.insert_metric("in-both-want-upwards-and-improved", 2000.0, -10.0); | |
629 | } | |
630 | ||
631 | #[test] | |
632 | pub fn test_bench_once_no_iter() { | |
633 | fn f(_: &mut Bencher) {} | |
634 | bench::run_once(f); | |
635 | } | |
636 | ||
637 | #[test] | |
638 | pub fn test_bench_once_iter() { | |
639 | fn f(b: &mut Bencher) { | |
640 | b.iter(|| {}) | |
641 | } | |
642 | bench::run_once(f); | |
643 | } | |
644 | ||
645 | #[test] | |
646 | pub fn test_bench_no_iter() { | |
647 | fn f(_: &mut Bencher) {} | |
648 | ||
649 | let (tx, rx) = channel(); | |
650 | ||
651 | let desc = TestDesc { | |
652 | name: StaticTestName("f"), | |
653 | ignore: false, | |
654 | should_panic: ShouldPanic::No, | |
655 | allow_fail: false, | |
e74abb32 | 656 | test_type: TestType::Unknown, |
dc9dc135 XL |
657 | }; |
658 | ||
659 | crate::bench::benchmark(desc, tx, true, f); | |
660 | rx.recv().unwrap(); | |
661 | } | |
662 | ||
663 | #[test] | |
664 | pub fn test_bench_iter() { | |
665 | fn f(b: &mut Bencher) { | |
666 | b.iter(|| {}) | |
667 | } | |
668 | ||
669 | let (tx, rx) = channel(); | |
670 | ||
671 | let desc = TestDesc { | |
672 | name: StaticTestName("f"), | |
673 | ignore: false, | |
674 | should_panic: ShouldPanic::No, | |
675 | allow_fail: false, | |
e74abb32 | 676 | test_type: TestType::Unknown, |
dc9dc135 XL |
677 | }; |
678 | ||
679 | crate::bench::benchmark(desc, tx, true, f); | |
680 | rx.recv().unwrap(); | |
681 | } | |
416331ca XL |
682 | |
683 | #[test] | |
684 | fn should_sort_failures_before_printing_them() { | |
685 | let test_a = TestDesc { | |
686 | name: StaticTestName("a"), | |
687 | ignore: false, | |
688 | should_panic: ShouldPanic::No, | |
689 | allow_fail: false, | |
e74abb32 | 690 | test_type: TestType::Unknown, |
416331ca XL |
691 | }; |
692 | ||
693 | let test_b = TestDesc { | |
694 | name: StaticTestName("b"), | |
695 | ignore: false, | |
696 | should_panic: ShouldPanic::No, | |
697 | allow_fail: false, | |
e74abb32 | 698 | test_type: TestType::Unknown, |
416331ca XL |
699 | }; |
700 | ||
e74abb32 | 701 | let mut out = PrettyFormatter::new(OutputLocation::Raw(Vec::new()), false, 10, false, None); |
416331ca | 702 | |
e74abb32 | 703 | let st = console::ConsoleTestState { |
416331ca XL |
704 | log_out: None, |
705 | total: 0, | |
706 | passed: 0, | |
707 | failed: 0, | |
708 | ignored: 0, | |
709 | allowed_fail: 0, | |
710 | filtered_out: 0, | |
711 | measured: 0, | |
712 | metrics: MetricMap::new(), | |
713 | failures: vec![(test_b, Vec::new()), (test_a, Vec::new())], | |
714 | options: Options::new(), | |
715 | not_failures: Vec::new(), | |
e74abb32 | 716 | time_failures: Vec::new(), |
416331ca XL |
717 | }; |
718 | ||
719 | out.write_failures(&st).unwrap(); | |
720 | let s = match out.output_location() { | |
e74abb32 XL |
721 | &OutputLocation::Raw(ref m) => String::from_utf8_lossy(&m[..]), |
722 | &OutputLocation::Pretty(_) => unreachable!(), | |
416331ca XL |
723 | }; |
724 | ||
725 | let apos = s.find("a").unwrap(); | |
726 | let bpos = s.find("b").unwrap(); | |
727 | assert!(apos < bpos); | |
728 | } |