diff options
Diffstat (limited to 'src/libtest/tests.rs')
| -rw-r--r-- | src/libtest/tests.rs | 688 |
1 files changed, 0 insertions, 688 deletions
diff --git a/src/libtest/tests.rs b/src/libtest/tests.rs deleted file mode 100644 index 85a0705f69c..00000000000 --- a/src/libtest/tests.rs +++ /dev/null @@ -1,688 +0,0 @@ -use super::*; - -use crate::{ - bench::Bencher, - console::OutputLocation, - formatters::PrettyFormatter, - options::OutputFormat, - test::{ - filter_tests, - parse_opts, - run_test, - DynTestFn, - DynTestName, - MetricMap, - RunIgnored, - RunStrategy, - ShouldPanic, - StaticTestName, - TestDesc, - TestDescAndFn, - TestOpts, - TrIgnored, - TrOk, - // FIXME (introduced by #65251) - // ShouldPanic, StaticTestName, TestDesc, TestDescAndFn, TestOpts, TestTimeOptions, - // TestType, TrFailedMsg, TrIgnored, TrOk, - }, - time::{TestTimeOptions, TimeThreshold}, -}; -use std::any::TypeId; -use std::sync::mpsc::channel; -use std::time::Duration; - -impl TestOpts { - fn new() -> TestOpts { - TestOpts { - list: false, - filter: None, - filter_exact: false, - force_run_in_process: false, - exclude_should_panic: false, - run_ignored: RunIgnored::No, - run_tests: false, - bench_benchmarks: false, - logfile: None, - nocapture: false, - color: AutoColor, - format: OutputFormat::Pretty, - test_threads: None, - skip: vec![], - time_options: None, - options: Options::new(), - } - } -} - -fn one_ignored_one_unignored_test() -> Vec<TestDescAndFn> { - vec![ - TestDescAndFn { - desc: TestDesc { - name: StaticTestName("1"), - ignore: true, - should_panic: ShouldPanic::No, - allow_fail: false, - test_type: TestType::Unknown, - }, - testfn: DynTestFn(Box::new(move || {})), - }, - TestDescAndFn { - desc: TestDesc { - name: StaticTestName("2"), - ignore: false, - should_panic: ShouldPanic::No, - allow_fail: false, - test_type: TestType::Unknown, - }, - testfn: DynTestFn(Box::new(move || {})), - }, - ] -} - -#[test] -pub fn do_not_run_ignored_tests() { - fn f() { - panic!(); - } - let desc = TestDescAndFn { - desc: TestDesc { - name: StaticTestName("whatever"), - ignore: true, - should_panic: ShouldPanic::No, - allow_fail: false, - test_type: TestType::Unknown, - }, - testfn: DynTestFn(Box::new(f)), - }; - let (tx, rx) = channel(); - run_test(&TestOpts::new(), false, desc, RunStrategy::InProcess, tx, Concurrent::No); - let result = rx.recv().unwrap().result; - assert_ne!(result, TrOk); -} - -#[test] -pub fn ignored_tests_result_in_ignored() { - fn f() {} - let desc = TestDescAndFn { - desc: TestDesc { - name: StaticTestName("whatever"), - ignore: true, - should_panic: ShouldPanic::No, - allow_fail: false, - test_type: TestType::Unknown, - }, - testfn: DynTestFn(Box::new(f)), - }; - let (tx, rx) = channel(); - run_test(&TestOpts::new(), false, desc, RunStrategy::InProcess, tx, Concurrent::No); - let result = rx.recv().unwrap().result; - assert_eq!(result, TrIgnored); -} - -// FIXME: Re-enable emscripten once it can catch panics again (introduced by #65251) -#[test] -#[cfg(not(target_os = "emscripten"))] -fn test_should_panic() { - fn f() { - panic!(); - } - let desc = TestDescAndFn { - desc: TestDesc { - name: StaticTestName("whatever"), - ignore: false, - should_panic: ShouldPanic::Yes, - allow_fail: false, - test_type: TestType::Unknown, - }, - testfn: DynTestFn(Box::new(f)), - }; - let (tx, rx) = channel(); - run_test(&TestOpts::new(), false, desc, RunStrategy::InProcess, tx, Concurrent::No); - let result = rx.recv().unwrap().result; - assert_eq!(result, TrOk); -} - -// FIXME: Re-enable emscripten once it can catch panics again (introduced by #65251) -#[test] -#[cfg(not(target_os = "emscripten"))] -fn test_should_panic_good_message() { - fn f() { - panic!("an error message"); - } - let desc = TestDescAndFn { - desc: TestDesc { - name: StaticTestName("whatever"), - ignore: false, - should_panic: ShouldPanic::YesWithMessage("error message"), - allow_fail: false, - test_type: TestType::Unknown, - }, - testfn: DynTestFn(Box::new(f)), - }; - let (tx, rx) = channel(); - run_test(&TestOpts::new(), false, desc, RunStrategy::InProcess, tx, Concurrent::No); - let result = rx.recv().unwrap().result; - assert_eq!(result, TrOk); -} - -// FIXME: Re-enable emscripten once it can catch panics again (introduced by #65251) -#[test] -#[cfg(not(target_os = "emscripten"))] -fn test_should_panic_bad_message() { - use crate::tests::TrFailedMsg; - fn f() { - panic!("an error message"); - } - let expected = "foobar"; - let failed_msg = r#"panic did not contain expected string - panic message: `"an error message"`, - expected substring: `"foobar"`"#; - let desc = TestDescAndFn { - desc: TestDesc { - name: StaticTestName("whatever"), - ignore: false, - should_panic: ShouldPanic::YesWithMessage(expected), - allow_fail: false, - test_type: TestType::Unknown, - }, - testfn: DynTestFn(Box::new(f)), - }; - let (tx, rx) = channel(); - run_test(&TestOpts::new(), false, desc, RunStrategy::InProcess, tx, Concurrent::No); - let result = rx.recv().unwrap().result; - assert_eq!(result, TrFailedMsg(failed_msg.to_string())); -} - -// FIXME: Re-enable emscripten once it can catch panics again (introduced by #65251) -#[test] -#[cfg(not(target_os = "emscripten"))] -fn test_should_panic_non_string_message_type() { - use crate::tests::TrFailedMsg; - fn f() { - panic!(1i32); - } - let expected = "foobar"; - let failed_msg = format!( - r#"expected panic with string value, - found non-string value: `{:?}` - expected substring: `"foobar"`"#, - TypeId::of::<i32>() - ); - let desc = TestDescAndFn { - desc: TestDesc { - name: StaticTestName("whatever"), - ignore: false, - should_panic: ShouldPanic::YesWithMessage(expected), - allow_fail: false, - test_type: TestType::Unknown, - }, - testfn: DynTestFn(Box::new(f)), - }; - let (tx, rx) = channel(); - run_test(&TestOpts::new(), false, desc, RunStrategy::InProcess, tx, Concurrent::No); - let result = rx.recv().unwrap().result; - assert_eq!(result, TrFailedMsg(failed_msg)); -} - -// FIXME: Re-enable emscripten once it can catch panics again (introduced by #65251) -#[test] -#[cfg(not(target_os = "emscripten"))] -fn test_should_panic_but_succeeds() { - fn f() {} - let desc = TestDescAndFn { - desc: TestDesc { - name: StaticTestName("whatever"), - ignore: false, - should_panic: ShouldPanic::Yes, - allow_fail: false, - test_type: TestType::Unknown, - }, - testfn: DynTestFn(Box::new(f)), - }; - let (tx, rx) = channel(); - run_test(&TestOpts::new(), false, desc, RunStrategy::InProcess, tx, Concurrent::No); - let result = rx.recv().unwrap().result; - assert_eq!(result, TrFailedMsg("test did not panic as expected".to_string())); -} - -fn report_time_test_template(report_time: bool) -> Option<TestExecTime> { - fn f() {} - let desc = TestDescAndFn { - desc: TestDesc { - name: StaticTestName("whatever"), - ignore: false, - should_panic: ShouldPanic::No, - allow_fail: false, - test_type: TestType::Unknown, - }, - testfn: DynTestFn(Box::new(f)), - }; - let time_options = if report_time { Some(TestTimeOptions::default()) } else { None }; - - let test_opts = TestOpts { time_options, ..TestOpts::new() }; - let (tx, rx) = channel(); - run_test(&test_opts, false, desc, RunStrategy::InProcess, tx, Concurrent::No); - let exec_time = rx.recv().unwrap().exec_time; - exec_time -} - -#[test] -fn test_should_not_report_time() { - let exec_time = report_time_test_template(false); - assert!(exec_time.is_none()); -} - -#[test] -fn test_should_report_time() { - let exec_time = report_time_test_template(true); - assert!(exec_time.is_some()); -} - -fn time_test_failure_template(test_type: TestType) -> TestResult { - fn f() {} - let desc = TestDescAndFn { - desc: TestDesc { - name: StaticTestName("whatever"), - ignore: false, - should_panic: ShouldPanic::No, - allow_fail: false, - test_type, - }, - testfn: DynTestFn(Box::new(f)), - }; - // `Default` will initialize all the thresholds to 0 milliseconds. - let mut time_options = TestTimeOptions::default(); - time_options.error_on_excess = true; - - let test_opts = TestOpts { time_options: Some(time_options), ..TestOpts::new() }; - let (tx, rx) = channel(); - run_test(&test_opts, false, desc, RunStrategy::InProcess, tx, Concurrent::No); - let result = rx.recv().unwrap().result; - - result -} - -#[test] -fn test_error_on_exceed() { - let types = [TestType::UnitTest, TestType::IntegrationTest, TestType::DocTest]; - - for test_type in types.iter() { - let result = time_test_failure_template(*test_type); - - assert_eq!(result, TestResult::TrTimedFail); - } - - // Check that for unknown tests thresholds aren't applied. - let result = time_test_failure_template(TestType::Unknown); - assert_eq!(result, TestResult::TrOk); -} - -fn typed_test_desc(test_type: TestType) -> TestDesc { - TestDesc { - name: StaticTestName("whatever"), - ignore: false, - should_panic: ShouldPanic::No, - allow_fail: false, - test_type, - } -} - -fn test_exec_time(millis: u64) -> TestExecTime { - TestExecTime(Duration::from_millis(millis)) -} - -#[test] -fn test_time_options_threshold() { - let unit = TimeThreshold::new(Duration::from_millis(50), Duration::from_millis(100)); - let integration = TimeThreshold::new(Duration::from_millis(500), Duration::from_millis(1000)); - let doc = TimeThreshold::new(Duration::from_millis(5000), Duration::from_millis(10000)); - - let options = TestTimeOptions { - error_on_excess: false, - colored: false, - unit_threshold: unit.clone(), - integration_threshold: integration.clone(), - doctest_threshold: doc.clone(), - }; - - let test_vector = [ - (TestType::UnitTest, unit.warn.as_millis() - 1, false, false), - (TestType::UnitTest, unit.warn.as_millis(), true, false), - (TestType::UnitTest, unit.critical.as_millis(), true, true), - (TestType::IntegrationTest, integration.warn.as_millis() - 1, false, false), - (TestType::IntegrationTest, integration.warn.as_millis(), true, false), - (TestType::IntegrationTest, integration.critical.as_millis(), true, true), - (TestType::DocTest, doc.warn.as_millis() - 1, false, false), - (TestType::DocTest, doc.warn.as_millis(), true, false), - (TestType::DocTest, doc.critical.as_millis(), true, true), - ]; - - for (test_type, time, expected_warn, expected_critical) in test_vector.iter() { - let test_desc = typed_test_desc(*test_type); - let exec_time = test_exec_time(*time as u64); - - assert_eq!(options.is_warn(&test_desc, &exec_time), *expected_warn); - assert_eq!(options.is_critical(&test_desc, &exec_time), *expected_critical); - } -} - -#[test] -fn parse_ignored_flag() { - let args = vec!["progname".to_string(), "filter".to_string(), "--ignored".to_string()]; - let opts = parse_opts(&args).unwrap().unwrap(); - assert_eq!(opts.run_ignored, RunIgnored::Only); -} - -#[test] -fn parse_show_output_flag() { - let args = vec!["progname".to_string(), "filter".to_string(), "--show-output".to_string()]; - let opts = parse_opts(&args).unwrap().unwrap(); - assert!(opts.options.display_output); -} - -#[test] -fn parse_include_ignored_flag() { - let args = vec![ - "progname".to_string(), - "filter".to_string(), - "-Zunstable-options".to_string(), - "--include-ignored".to_string(), - ]; - let opts = parse_opts(&args).unwrap().unwrap(); - assert_eq!(opts.run_ignored, RunIgnored::Yes); -} - -#[test] -pub fn filter_for_ignored_option() { - // When we run ignored tests the test filter should filter out all the - // unignored tests and flip the ignore flag on the rest to false - - let mut opts = TestOpts::new(); - opts.run_tests = true; - opts.run_ignored = RunIgnored::Only; - - let tests = one_ignored_one_unignored_test(); - let filtered = filter_tests(&opts, tests); - - assert_eq!(filtered.len(), 1); - assert_eq!(filtered[0].desc.name.to_string(), "1"); - assert!(!filtered[0].desc.ignore); -} - -#[test] -pub fn run_include_ignored_option() { - // When we "--include-ignored" tests, the ignore flag should be set to false on - // all tests and no test filtered out - - let mut opts = TestOpts::new(); - opts.run_tests = true; - opts.run_ignored = RunIgnored::Yes; - - let tests = one_ignored_one_unignored_test(); - let filtered = filter_tests(&opts, tests); - - assert_eq!(filtered.len(), 2); - assert!(!filtered[0].desc.ignore); - assert!(!filtered[1].desc.ignore); -} - -#[test] -pub fn exclude_should_panic_option() { - let mut opts = TestOpts::new(); - opts.run_tests = true; - opts.exclude_should_panic = true; - - let mut tests = one_ignored_one_unignored_test(); - tests.push(TestDescAndFn { - desc: TestDesc { - name: StaticTestName("3"), - ignore: false, - should_panic: ShouldPanic::Yes, - allow_fail: false, - test_type: TestType::Unknown, - }, - testfn: DynTestFn(Box::new(move || {})), - }); - - let filtered = filter_tests(&opts, tests); - - assert_eq!(filtered.len(), 2); - assert!(filtered.iter().all(|test| test.desc.should_panic == ShouldPanic::No)); -} - -#[test] -pub fn exact_filter_match() { - fn tests() -> Vec<TestDescAndFn> { - vec!["base", "base::test", "base::test1", "base::test2"] - .into_iter() - .map(|name| TestDescAndFn { - desc: TestDesc { - name: StaticTestName(name), - ignore: false, - should_panic: ShouldPanic::No, - allow_fail: false, - test_type: TestType::Unknown, - }, - testfn: DynTestFn(Box::new(move || {})), - }) - .collect() - } - - let substr = - filter_tests(&TestOpts { filter: Some("base".into()), ..TestOpts::new() }, tests()); - assert_eq!(substr.len(), 4); - - let substr = filter_tests(&TestOpts { filter: Some("bas".into()), ..TestOpts::new() }, tests()); - assert_eq!(substr.len(), 4); - - let substr = - filter_tests(&TestOpts { filter: Some("::test".into()), ..TestOpts::new() }, tests()); - assert_eq!(substr.len(), 3); - - let substr = - filter_tests(&TestOpts { filter: Some("base::test".into()), ..TestOpts::new() }, tests()); - assert_eq!(substr.len(), 3); - - let exact = filter_tests( - &TestOpts { filter: Some("base".into()), filter_exact: true, ..TestOpts::new() }, - tests(), - ); - assert_eq!(exact.len(), 1); - - let exact = filter_tests( - &TestOpts { filter: Some("bas".into()), filter_exact: true, ..TestOpts::new() }, - tests(), - ); - assert_eq!(exact.len(), 0); - - let exact = filter_tests( - &TestOpts { filter: Some("::test".into()), filter_exact: true, ..TestOpts::new() }, - tests(), - ); - assert_eq!(exact.len(), 0); - - let exact = filter_tests( - &TestOpts { filter: Some("base::test".into()), filter_exact: true, ..TestOpts::new() }, - tests(), - ); - assert_eq!(exact.len(), 1); -} - -#[test] -pub fn sort_tests() { - let mut opts = TestOpts::new(); - opts.run_tests = true; - - let names = vec![ - "sha1::test".to_string(), - "isize::test_to_str".to_string(), - "isize::test_pow".to_string(), - "test::do_not_run_ignored_tests".to_string(), - "test::ignored_tests_result_in_ignored".to_string(), - "test::first_free_arg_should_be_a_filter".to_string(), - "test::parse_ignored_flag".to_string(), - "test::parse_include_ignored_flag".to_string(), - "test::filter_for_ignored_option".to_string(), - "test::run_include_ignored_option".to_string(), - "test::sort_tests".to_string(), - ]; - let tests = { - fn testfn() {} - let mut tests = Vec::new(); - for name in &names { - let test = TestDescAndFn { - desc: TestDesc { - name: DynTestName((*name).clone()), - ignore: false, - should_panic: ShouldPanic::No, - allow_fail: false, - test_type: TestType::Unknown, - }, - testfn: DynTestFn(Box::new(testfn)), - }; - tests.push(test); - } - tests - }; - let filtered = filter_tests(&opts, tests); - - let expected = vec![ - "isize::test_pow".to_string(), - "isize::test_to_str".to_string(), - "sha1::test".to_string(), - "test::do_not_run_ignored_tests".to_string(), - "test::filter_for_ignored_option".to_string(), - "test::first_free_arg_should_be_a_filter".to_string(), - "test::ignored_tests_result_in_ignored".to_string(), - "test::parse_ignored_flag".to_string(), - "test::parse_include_ignored_flag".to_string(), - "test::run_include_ignored_option".to_string(), - "test::sort_tests".to_string(), - ]; - - for (a, b) in expected.iter().zip(filtered) { - assert_eq!(*a, b.desc.name.to_string()); - } -} - -#[test] -pub fn test_metricmap_compare() { - let mut m1 = MetricMap::new(); - let mut m2 = MetricMap::new(); - m1.insert_metric("in-both-noise", 1000.0, 200.0); - m2.insert_metric("in-both-noise", 1100.0, 200.0); - - m1.insert_metric("in-first-noise", 1000.0, 2.0); - m2.insert_metric("in-second-noise", 1000.0, 2.0); - - m1.insert_metric("in-both-want-downwards-but-regressed", 1000.0, 10.0); - m2.insert_metric("in-both-want-downwards-but-regressed", 2000.0, 10.0); - - m1.insert_metric("in-both-want-downwards-and-improved", 2000.0, 10.0); - m2.insert_metric("in-both-want-downwards-and-improved", 1000.0, 10.0); - - m1.insert_metric("in-both-want-upwards-but-regressed", 2000.0, -10.0); - m2.insert_metric("in-both-want-upwards-but-regressed", 1000.0, -10.0); - - m1.insert_metric("in-both-want-upwards-and-improved", 1000.0, -10.0); - m2.insert_metric("in-both-want-upwards-and-improved", 2000.0, -10.0); -} - -#[test] -pub fn test_bench_once_no_iter() { - fn f(_: &mut Bencher) {} - bench::run_once(f); -} - -#[test] -pub fn test_bench_once_iter() { - fn f(b: &mut Bencher) { - b.iter(|| {}) - } - bench::run_once(f); -} - -#[test] -pub fn test_bench_no_iter() { - fn f(_: &mut Bencher) {} - - let (tx, rx) = channel(); - - let desc = TestDesc { - name: StaticTestName("f"), - ignore: false, - should_panic: ShouldPanic::No, - allow_fail: false, - test_type: TestType::Unknown, - }; - - crate::bench::benchmark(desc, tx, true, f); - rx.recv().unwrap(); -} - -#[test] -pub fn test_bench_iter() { - fn f(b: &mut Bencher) { - b.iter(|| {}) - } - - let (tx, rx) = channel(); - - let desc = TestDesc { - name: StaticTestName("f"), - ignore: false, - should_panic: ShouldPanic::No, - allow_fail: false, - test_type: TestType::Unknown, - }; - - crate::bench::benchmark(desc, tx, true, f); - rx.recv().unwrap(); -} - -#[test] -fn should_sort_failures_before_printing_them() { - let test_a = TestDesc { - name: StaticTestName("a"), - ignore: false, - should_panic: ShouldPanic::No, - allow_fail: false, - test_type: TestType::Unknown, - }; - - let test_b = TestDesc { - name: StaticTestName("b"), - ignore: false, - should_panic: ShouldPanic::No, - allow_fail: false, - test_type: TestType::Unknown, - }; - - let mut out = PrettyFormatter::new(OutputLocation::Raw(Vec::new()), false, 10, false, None); - - let st = console::ConsoleTestState { - log_out: None, - total: 0, - passed: 0, - failed: 0, - ignored: 0, - allowed_fail: 0, - filtered_out: 0, - measured: 0, - metrics: MetricMap::new(), - failures: vec![(test_b, Vec::new()), (test_a, Vec::new())], - options: Options::new(), - not_failures: Vec::new(), - time_failures: Vec::new(), - }; - - out.write_failures(&st).unwrap(); - let s = match out.output_location() { - &OutputLocation::Raw(ref m) => String::from_utf8_lossy(&m[..]), - &OutputLocation::Pretty(_) => unreachable!(), - }; - - let apos = s.find("a").unwrap(); - let bpos = s.find("b").unwrap(); - assert!(apos < bpos); -} |