library/test/src/lib.rs

   1 //! Support code for rustc's built in unit-test and micro-benchmarking
   2 //! framework.
   3 //!
   4 //! Almost all user code will only be interested in `Bencher` and
   5 //! `black_box`. All other interactions (such as writing tests and
   6 //! benchmarks themselves) should be done via the `#[test]` and
   7 //! `#[bench]` attributes.
   8 //!
   9 //! See the [Testing Chapter](../book/ch11-00-testing.html) of the book for more details.
  10
  11 // Currently, not much of this is meant for users. It is intended to
  12 // support the simplest interface possible for representing and
  13 // running tests while providing a base that other test frameworks may
  14 // build off of.
  15
  16 #![unstable(feature = "test", issue = "50297")]
  17 #![doc(test(attr(deny(warnings))))]
  18 #![feature(nll)]
  19 #![feature(bench_black_box)]
  20 #![feature(internal_output_capture)]
  21 #![feature(staged_api)]
  22 #![feature(termination_trait_lib)]
  23 #![feature(process_exitcode_placeholder)]
  24 #![feature(test)]
  25 #![feature(total_cmp)]
  26
  27 // Public reexports
  28 pub use self::bench::{black_box, Bencher};
  29 pub use self::console::run_tests_console;
  30 pub use self::options::{ColorConfig, Options, OutputFormat, RunIgnored, ShouldPanic};
  31 pub use self::types::TestName::*;
  32 pub use self::types::*;
  33 pub use self::ColorConfig::*;
  34 pub use cli::TestOpts;
  35
  36 // Module to be used by rustc to compile tests in libtest
  37 pub mod test {
  38     pub use crate::{
  39         assert_test_result,
  40         bench::Bencher,
  41         cli::{parse_opts, TestOpts},
  42         filter_tests,
  43         helpers::metrics::{Metric, MetricMap},
  44         options::{Concurrent, Options, RunIgnored, RunStrategy, ShouldPanic},
  45         run_test, test_main, test_main_static,
  46         test_result::{TestResult, TrFailed, TrFailedMsg, TrIgnored, TrOk},
  47         time::{TestExecTime, TestTimeOptions},
  48         types::{
  49             DynTestFn, DynTestName, StaticBenchFn, StaticTestFn, StaticTestName, TestDesc,
  50             TestDescAndFn, TestId, TestName, TestType,
  51         },
  52     };
  53 }
  54
  55 use std::{
  56     collections::VecDeque,
  57     env, io,
  58     io::prelude::Write,
  59     panic::{self, catch_unwind, AssertUnwindSafe, PanicInfo},
  60     process::{self, Command, Termination},
  61     sync::mpsc::{channel, Sender},
  62     sync::{Arc, Mutex},
  63     thread,
  64     time::{Duration, Instant},
  65 };
  66
  67 pub mod bench;
  68 mod cli;
  69 mod console;
  70 mod event;
  71 mod formatters;
  72 mod helpers;
  73 mod options;
  74 pub mod stats;
  75 mod term;
  76 mod test_result;
  77 mod time;
  78 mod types;
  79
  80 #[cfg(test)]
  81 mod tests;
  82
  83 use event::{CompletedTest, TestEvent};
  84 use helpers::concurrency::get_concurrency;
  85 use helpers::exit_code::get_exit_code;
  86 use helpers::shuffle::{get_shuffle_seed, shuffle_tests};
  87 use options::{Concurrent, RunStrategy};
  88 use test_result::*;
  89 use time::TestExecTime;
  90
  91 // Process exit code to be used to indicate test failures.
  92 const ERROR_EXIT_CODE: i32 = 101;
  93
  94 const SECONDARY_TEST_INVOKER_VAR: &str = "__RUST_TEST_INVOKE";
  95
  96 // The default console test runner. It accepts the command line
  97 // arguments and a vector of test_descs.
  98 pub fn test_main(args: &[String], tests: Vec<TestDescAndFn>, options: Option<Options>) {
  99     let mut opts = match cli::parse_opts(args) {
 100         Some(Ok(o)) => o,
 101         Some(Err(msg)) => {
 102             eprintln!("error: {}", msg);
 103             process::exit(ERROR_EXIT_CODE);
 104         }
 105         None => return,
 106     };
 107     if let Some(options) = options {
 108         opts.options = options;
 109     }
 110     if opts.list {
 111         if let Err(e) = console::list_tests_console(&opts, tests) {
 112             eprintln!("error: io error when listing tests: {:?}", e);
 113             process::exit(ERROR_EXIT_CODE);
 114         }
 115     } else {
 116         match console::run_tests_console(&opts, tests) {
 117             Ok(true) => {}
 118             Ok(false) => process::exit(ERROR_EXIT_CODE),
 119             Err(e) => {
 120                 eprintln!("error: io error when listing tests: {:?}", e);
 121                 process::exit(ERROR_EXIT_CODE);
 122             }
 123         }
 124     }
 125 }
 126
 127 /// A variant optimized for invocation with a static test vector.
 128 /// This will panic (intentionally) when fed any dynamic tests.
 129 ///
 130 /// This is the entry point for the main function generated by `rustc --test`
 131 /// when panic=unwind.
 132 pub fn test_main_static(tests: &[&TestDescAndFn]) {
 133     let args = env::args().collect::<Vec<_>>();
 134     let owned_tests: Vec<_> = tests.iter().map(make_owned_test).collect();
 135     test_main(&args, owned_tests, None)
 136 }
 137
 138 /// A variant optimized for invocation with a static test vector.
 139 /// This will panic (intentionally) when fed any dynamic tests.
 140 ///
 141 /// Runs tests in panic=abort mode, which involves spawning subprocesses for
 142 /// tests.
 143 ///
 144 /// This is the entry point for the main function generated by `rustc --test`
 145 /// when panic=abort.
 146 pub fn test_main_static_abort(tests: &[&TestDescAndFn]) {
 147     // If we're being run in SpawnedSecondary mode, run the test here. run_test
 148     // will then exit the process.
 149     if let Ok(name) = env::var(SECONDARY_TEST_INVOKER_VAR) {
 150         env::remove_var(SECONDARY_TEST_INVOKER_VAR);
 151         let test = tests
 152             .iter()
 153             .filter(|test| test.desc.name.as_slice() == name)
 154             .map(make_owned_test)
 155             .next()
 156             .unwrap_or_else(|| panic!("couldn't find a test with the provided name '{}'", name));
 157         let TestDescAndFn { desc, testfn } = test;
 158         let testfn = match testfn {
 159             StaticTestFn(f) => f,
 160             _ => panic!("only static tests are supported"),
 161         };
 162         run_test_in_spawned_subprocess(desc, Box::new(testfn));
 163     }
 164
 165     let args = env::args().collect::<Vec<_>>();
 166     let owned_tests: Vec<_> = tests.iter().map(make_owned_test).collect();
 167     test_main(&args, owned_tests, Some(Options::new().panic_abort(true)))
 168 }
 169
 170 /// Clones static values for putting into a dynamic vector, which test_main()
 171 /// needs to hand out ownership of tests to parallel test runners.
 172 ///
 173 /// This will panic when fed any dynamic tests, because they cannot be cloned.
 174 fn make_owned_test(test: &&TestDescAndFn) -> TestDescAndFn {
 175     match test.testfn {
 176         StaticTestFn(f) => TestDescAndFn { testfn: StaticTestFn(f), desc: test.desc.clone() },
 177         StaticBenchFn(f) => TestDescAndFn { testfn: StaticBenchFn(f), desc: test.desc.clone() },
 178         _ => panic!("non-static tests passed to test::test_main_static"),
 179     }
 180 }
 181
 182 /// Invoked when unit tests terminate. Should panic if the unit
 183 /// Tests is considered a failure. By default, invokes `report()`
 184 /// and checks for a `0` result.
 185 pub fn assert_test_result<T: Termination>(result: T) {
 186     let code = result.report().to_i32();
 187     assert_eq!(
 188         code, 0,
 189         "the test returned a termination value with a non-zero status code ({}) \
 190          which indicates a failure",
 191         code
 192     );
 193 }
 194
 195 pub fn run_tests<F>(
 196     opts: &TestOpts,
 197     tests: Vec<TestDescAndFn>,
 198     mut notify_about_test_event: F,
 199 ) -> io::Result<()>
 200 where
 201     F: FnMut(TestEvent) -> io::Result<()>,
 202 {
 203     use std::collections::{self, HashMap};
 204     use std::hash::BuildHasherDefault;
 205     use std::sync::mpsc::RecvTimeoutError;
 206
 207     struct RunningTest {
 208         join_handle: Option<thread::JoinHandle<()>>,
 209     }
 210
 211     // Use a deterministic hasher
 212     type TestMap =
 213         HashMap<TestId, RunningTest, BuildHasherDefault<collections::hash_map::DefaultHasher>>;
 214
 215     struct TimeoutEntry {
 216         id: TestId,
 217         desc: TestDesc,
 218         timeout: Instant,
 219     }
 220
 221     let tests_len = tests.len();
 222
 223     let mut filtered_tests = filter_tests(opts, tests);
 224     if !opts.bench_benchmarks {
 225         filtered_tests = convert_benchmarks_to_tests(filtered_tests);
 226     }
 227
 228     let filtered_tests = {
 229         let mut filtered_tests = filtered_tests;
 230         for test in filtered_tests.iter_mut() {
 231             test.desc.name = test.desc.name.with_padding(test.testfn.padding());
 232         }
 233
 234         filtered_tests
 235     };
 236
 237     let filtered_out = tests_len - filtered_tests.len();
 238     let event = TestEvent::TeFilteredOut(filtered_out);
 239     notify_about_test_event(event)?;
 240
 241     let filtered_descs = filtered_tests.iter().map(|t| t.desc.clone()).collect();
 242
 243     let shuffle_seed = get_shuffle_seed(opts);
 244
 245     let event = TestEvent::TeFiltered(filtered_descs, shuffle_seed);
 246     notify_about_test_event(event)?;
 247
 248     let (filtered_tests, filtered_benchs): (Vec<_>, _) = filtered_tests
 249         .into_iter()
 250         .enumerate()
 251         .map(|(i, e)| (TestId(i), e))
 252         .partition(|(_, e)| matches!(e.testfn, StaticTestFn(_) | DynTestFn(_)));
 253
 254     let concurrency = opts.test_threads.unwrap_or_else(get_concurrency);
 255
 256     let mut remaining = filtered_tests;
 257     if let Some(shuffle_seed) = shuffle_seed {
 258         shuffle_tests(shuffle_seed, &mut remaining);
 259     } else {
 260         remaining.reverse();
 261     }
 262     let mut pending = 0;
 263
 264     let (tx, rx) = channel::<CompletedTest>();
 265     let run_strategy = if opts.options.panic_abort && !opts.force_run_in_process {
 266         RunStrategy::SpawnPrimary
 267     } else {
 268         RunStrategy::InProcess
 269     };
 270
 271     let mut running_tests: TestMap = HashMap::default();
 272     let mut timeout_queue: VecDeque<TimeoutEntry> = VecDeque::new();
 273
 274     fn get_timed_out_tests(
 275         running_tests: &TestMap,
 276         timeout_queue: &mut VecDeque<TimeoutEntry>,
 277     ) -> Vec<TestDesc> {
 278         let now = Instant::now();
 279         let mut timed_out = Vec::new();
 280         while let Some(timeout_entry) = timeout_queue.front() {
 281             if now < timeout_entry.timeout {
 282                 break;
 283             }
 284             let timeout_entry = timeout_queue.pop_front().unwrap();
 285             if running_tests.contains_key(&timeout_entry.id) {
 286                 timed_out.push(timeout_entry.desc);
 287             }
 288         }
 289         timed_out
 290     }
 291
 292     fn calc_timeout(timeout_queue: &VecDeque<TimeoutEntry>) -> Option<Duration> {
 293         timeout_queue.front().map(|&TimeoutEntry { timeout: next_timeout, .. }| {
 294             let now = Instant::now();
 295             if next_timeout >= now { next_timeout - now } else { Duration::new(0, 0) }
 296         })
 297     }
 298
 299     if concurrency == 1 {
 300         while !remaining.is_empty() {
 301             let (id, test) = remaining.pop().unwrap();
 302             let event = TestEvent::TeWait(test.desc.clone());
 303             notify_about_test_event(event)?;
 304             let join_handle =
 305                 run_test(opts, !opts.run_tests, id, test, run_strategy, tx.clone(), Concurrent::No);
 306             assert!(join_handle.is_none());
 307             let completed_test = rx.recv().unwrap();
 308
 309             let event = TestEvent::TeResult(completed_test);
 310             notify_about_test_event(event)?;
 311         }
 312     } else {
 313         while pending > 0 || !remaining.is_empty() {
 314             while pending < concurrency && !remaining.is_empty() {
 315                 let (id, test) = remaining.pop().unwrap();
 316                 let timeout = time::get_default_test_timeout();
 317                 let desc = test.desc.clone();
 318
 319                 let event = TestEvent::TeWait(desc.clone());
 320                 notify_about_test_event(event)?; //here no pad
 321                 let join_handle = run_test(
 322                     opts,
 323                     !opts.run_tests,
 324                     id,
 325                     test,
 326                     run_strategy,
 327                     tx.clone(),
 328                     Concurrent::Yes,
 329                 );
 330                 running_tests.insert(id, RunningTest { join_handle });
 331                 timeout_queue.push_back(TimeoutEntry { id, desc, timeout });
 332                 pending += 1;
 333             }
 334
 335             let mut res;
 336             loop {
 337                 if let Some(timeout) = calc_timeout(&timeout_queue) {
 338                     res = rx.recv_timeout(timeout);
 339                     for test in get_timed_out_tests(&running_tests, &mut timeout_queue) {
 340                         let event = TestEvent::TeTimeout(test);
 341                         notify_about_test_event(event)?;
 342                     }
 343
 344                     match res {
 345                         Err(RecvTimeoutError::Timeout) => {
 346                             // Result is not yet ready, continue waiting.
 347                         }
 348                         _ => {
 349                             // We've got a result, stop the loop.
 350                             break;
 351                         }
 352                     }
 353                 } else {
 354                     res = rx.recv().map_err(|_| RecvTimeoutError::Disconnected);
 355                     break;
 356                 }
 357             }
 358
 359             let mut completed_test = res.unwrap();
 360             let running_test = running_tests.remove(&completed_test.id).unwrap();
 361             if let Some(join_handle) = running_test.join_handle {
 362                 if let Err(_) = join_handle.join() {
 363                     if let TrOk = completed_test.result {
 364                         completed_test.result =
 365                             TrFailedMsg("panicked after reporting success".to_string());
 366                     }
 367                 }
 368             }
 369
 370             let event = TestEvent::TeResult(completed_test);
 371             notify_about_test_event(event)?;
 372             pending -= 1;
 373         }
 374     }
 375
 376     if opts.bench_benchmarks {
 377         // All benchmarks run at the end, in serial.
 378         for (id, b) in filtered_benchs {
 379             let event = TestEvent::TeWait(b.desc.clone());
 380             notify_about_test_event(event)?;
 381             run_test(opts, false, id, b, run_strategy, tx.clone(), Concurrent::No);
 382             let completed_test = rx.recv().unwrap();
 383
 384             let event = TestEvent::TeResult(completed_test);
 385             notify_about_test_event(event)?;
 386         }
 387     }
 388     Ok(())
 389 }
 390
 391 pub fn filter_tests(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> Vec<TestDescAndFn> {
 392     let mut filtered = tests;
 393     let matches_filter = |test: &TestDescAndFn, filter: &str| {
 394         let test_name = test.desc.name.as_slice();
 395
 396         match opts.filter_exact {
 397             true => test_name == filter,
 398             false => test_name.contains(filter),
 399         }
 400     };
 401
 402     // Remove tests that don't match the test filter
 403     if !opts.filters.is_empty() {
 404         filtered.retain(|test| opts.filters.iter().any(|filter| matches_filter(test, filter)));
 405     }
 406
 407     // Skip tests that match any of the skip filters
 408     filtered.retain(|test| !opts.skip.iter().any(|sf| matches_filter(test, sf)));
 409
 410     // Excludes #[should_panic] tests
 411     if opts.exclude_should_panic {
 412         filtered.retain(|test| test.desc.should_panic == ShouldPanic::No);
 413     }
 414
 415     // maybe unignore tests
 416     match opts.run_ignored {
 417         RunIgnored::Yes => {
 418             filtered.iter_mut().for_each(|test| test.desc.ignore = false);
 419         }
 420         RunIgnored::Only => {
 421             filtered.retain(|test| test.desc.ignore);
 422             filtered.iter_mut().for_each(|test| test.desc.ignore = false);
 423         }
 424         RunIgnored::No => {}
 425     }
 426
 427     // Sort the tests alphabetically
 428     filtered.sort_by(|t1, t2| t1.desc.name.as_slice().cmp(t2.desc.name.as_slice()));
 429
 430     filtered
 431 }
 432
 433 pub fn convert_benchmarks_to_tests(tests: Vec<TestDescAndFn>) -> Vec<TestDescAndFn> {
 434     // convert benchmarks to tests, if we're not benchmarking them
 435     tests
 436         .into_iter()
 437         .map(|x| {
 438             let testfn = match x.testfn {
 439                 DynBenchFn(benchfn) => DynTestFn(Box::new(move || {
 440                     bench::run_once(|b| __rust_begin_short_backtrace(|| benchfn(b)))
 441                 })),
 442                 StaticBenchFn(benchfn) => DynTestFn(Box::new(move || {
 443                     bench::run_once(|b| __rust_begin_short_backtrace(|| benchfn(b)))
 444                 })),
 445                 f => f,
 446             };
 447             TestDescAndFn { desc: x.desc, testfn }
 448         })
 449         .collect()
 450 }
 451
 452 pub fn run_test(
 453     opts: &TestOpts,
 454     force_ignore: bool,
 455     id: TestId,
 456     test: TestDescAndFn,
 457     strategy: RunStrategy,
 458     monitor_ch: Sender<CompletedTest>,
 459     concurrency: Concurrent,
 460 ) -> Option<thread::JoinHandle<()>> {
 461     let TestDescAndFn { desc, testfn } = test;
 462
 463     // Emscripten can catch panics but other wasm targets cannot
 464     let ignore_because_no_process_support = desc.should_panic != ShouldPanic::No
 465         && cfg!(target_family = "wasm")
 466         && !cfg!(target_os = "emscripten");
 467
 468     if force_ignore || desc.ignore || ignore_because_no_process_support {
 469         let message = CompletedTest::new(id, desc, TrIgnored, None, Vec::new());
 470         monitor_ch.send(message).unwrap();
 471         return None;
 472     }
 473
 474     struct TestRunOpts {
 475         pub strategy: RunStrategy,
 476         pub nocapture: bool,
 477         pub concurrency: Concurrent,
 478         pub time: Option<time::TestTimeOptions>,
 479     }
 480
 481     fn run_test_inner(
 482         id: TestId,
 483         desc: TestDesc,
 484         monitor_ch: Sender<CompletedTest>,
 485         testfn: Box<dyn FnOnce() + Send>,
 486         opts: TestRunOpts,
 487     ) -> Option<thread::JoinHandle<()>> {
 488         let concurrency = opts.concurrency;
 489         let name = desc.name.clone();
 490
 491         let runtest = move || match opts.strategy {
 492             RunStrategy::InProcess => run_test_in_process(
 493                 id,
 494                 desc,
 495                 opts.nocapture,
 496                 opts.time.is_some(),
 497                 testfn,
 498                 monitor_ch,
 499                 opts.time,
 500             ),
 501             RunStrategy::SpawnPrimary => spawn_test_subprocess(
 502                 id,
 503                 desc,
 504                 opts.nocapture,
 505                 opts.time.is_some(),
 506                 monitor_ch,
 507                 opts.time,
 508             ),
 509         };
 510
 511         // If the platform is single-threaded we're just going to run
 512         // the test synchronously, regardless of the concurrency
 513         // level.
 514         let supports_threads = !cfg!(target_os = "emscripten") && !cfg!(target_family = "wasm");
 515         if concurrency == Concurrent::Yes && supports_threads {
 516             let cfg = thread::Builder::new().name(name.as_slice().to_owned());
 517             let mut runtest = Arc::new(Mutex::new(Some(runtest)));
 518             let runtest2 = runtest.clone();
 519             match cfg.spawn(move || runtest2.lock().unwrap().take().unwrap()()) {
 520                 Ok(handle) => Some(handle),
 521                 Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
 522                     // `ErrorKind::WouldBlock` means hitting the thread limit on some
 523                     // platforms, so run the test synchronously here instead.
 524                     Arc::get_mut(&mut runtest).unwrap().get_mut().unwrap().take().unwrap()();
 525                     None
 526                 }
 527                 Err(e) => panic!("failed to spawn thread to run test: {}", e),
 528             }
 529         } else {
 530             runtest();
 531             None
 532         }
 533     }
 534
 535     let test_run_opts =
 536         TestRunOpts { strategy, nocapture: opts.nocapture, concurrency, time: opts.time_options };
 537
 538     match testfn {
 539         DynBenchFn(benchfn) => {
 540             // Benchmarks aren't expected to panic, so we run them all in-process.
 541             crate::bench::benchmark(id, desc, monitor_ch, opts.nocapture, benchfn);
 542             None
 543         }
 544         StaticBenchFn(benchfn) => {
 545             // Benchmarks aren't expected to panic, so we run them all in-process.
 546             crate::bench::benchmark(id, desc, monitor_ch, opts.nocapture, benchfn);
 547             None
 548         }
 549         DynTestFn(f) => {
 550             match strategy {
 551                 RunStrategy::InProcess => (),
 552                 _ => panic!("Cannot run dynamic test fn out-of-process"),
 553             };
 554             run_test_inner(
 555                 id,
 556                 desc,
 557                 monitor_ch,
 558                 Box::new(move || __rust_begin_short_backtrace(f)),
 559                 test_run_opts,
 560             )
 561         }
 562         StaticTestFn(f) => run_test_inner(
 563             id,
 564             desc,
 565             monitor_ch,
 566             Box::new(move || __rust_begin_short_backtrace(f)),
 567             test_run_opts,
 568         ),
 569     }
 570 }
 571
 572 /// Fixed frame used to clean the backtrace with `RUST_BACKTRACE=1`.
 573 #[inline(never)]
 574 fn __rust_begin_short_backtrace<F: FnOnce()>(f: F) {
 575     f();
 576
 577     // prevent this frame from being tail-call optimised away
 578     black_box(());
 579 }
 580
 581 fn run_test_in_process(
 582     id: TestId,
 583     desc: TestDesc,
 584     nocapture: bool,
 585     report_time: bool,
 586     testfn: Box<dyn FnOnce() + Send>,
 587     monitor_ch: Sender<CompletedTest>,
 588     time_opts: Option<time::TestTimeOptions>,
 589 ) {
 590     // Buffer for capturing standard I/O
 591     let data = Arc::new(Mutex::new(Vec::new()));
 592
 593     if !nocapture {
 594         io::set_output_capture(Some(data.clone()));
 595     }
 596
 597     let start = report_time.then(Instant::now);
 598     let result = catch_unwind(AssertUnwindSafe(testfn));
 599     let exec_time = start.map(|start| {
 600         let duration = start.elapsed();
 601         TestExecTime(duration)
 602     });
 603
 604     io::set_output_capture(None);
 605
 606     let test_result = match result {
 607         Ok(()) => calc_result(&desc, Ok(()), &time_opts, &exec_time),
 608         Err(e) => calc_result(&desc, Err(e.as_ref()), &time_opts, &exec_time),
 609     };
 610     let stdout = data.lock().unwrap_or_else(|e| e.into_inner()).to_vec();
 611     let message = CompletedTest::new(id, desc, test_result, exec_time, stdout);
 612     monitor_ch.send(message).unwrap();
 613 }
 614
 615 fn spawn_test_subprocess(
 616     id: TestId,
 617     desc: TestDesc,
 618     nocapture: bool,
 619     report_time: bool,
 620     monitor_ch: Sender<CompletedTest>,
 621     time_opts: Option<time::TestTimeOptions>,
 622 ) {
 623     let (result, test_output, exec_time) = (|| {
 624         let args = env::args().collect::<Vec<_>>();
 625         let current_exe = &args[0];
 626
 627         let mut command = Command::new(current_exe);
 628         command.env(SECONDARY_TEST_INVOKER_VAR, desc.name.as_slice());
 629         if nocapture {
 630             command.stdout(process::Stdio::inherit());
 631             command.stderr(process::Stdio::inherit());
 632         }
 633
 634         let start = report_time.then(Instant::now);
 635         let output = match command.output() {
 636             Ok(out) => out,
 637             Err(e) => {
 638                 let err = format!("Failed to spawn {} as child for test: {:?}", args[0], e);
 639                 return (TrFailed, err.into_bytes(), None);
 640             }
 641         };
 642         let exec_time = start.map(|start| {
 643             let duration = start.elapsed();
 644             TestExecTime(duration)
 645         });
 646
 647         let std::process::Output { stdout, stderr, status } = output;
 648         let mut test_output = stdout;
 649         formatters::write_stderr_delimiter(&mut test_output, &desc.name);
 650         test_output.extend_from_slice(&stderr);
 651
 652         let result = match (|| -> Result<TestResult, String> {
 653             let exit_code = get_exit_code(status)?;
 654             Ok(get_result_from_exit_code(&desc, exit_code, &time_opts, &exec_time))
 655         })() {
 656             Ok(r) => r,
 657             Err(e) => {
 658                 write!(&mut test_output, "Unexpected error: {}", e).unwrap();
 659                 TrFailed
 660             }
 661         };
 662
 663         (result, test_output, exec_time)
 664     })();
 665
 666     let message = CompletedTest::new(id, desc, result, exec_time, test_output);
 667     monitor_ch.send(message).unwrap();
 668 }
 669
 670 fn run_test_in_spawned_subprocess(desc: TestDesc, testfn: Box<dyn FnOnce() + Send>) -> ! {
 671     let builtin_panic_hook = panic::take_hook();
 672     let record_result = Arc::new(move |panic_info: Option<&'_ PanicInfo<'_>>| {
 673         let test_result = match panic_info {
 674             Some(info) => calc_result(&desc, Err(info.payload()), &None, &None),
 675             None => calc_result(&desc, Ok(()), &None, &None),
 676         };
 677
 678         // We don't support serializing TrFailedMsg, so just
 679         // print the message out to stderr.
 680         if let TrFailedMsg(msg) = &test_result {
 681             eprintln!("{}", msg);
 682         }
 683
 684         if let Some(info) = panic_info {
 685             builtin_panic_hook(info);
 686         }
 687
 688         if let TrOk = test_result {
 689             process::exit(test_result::TR_OK);
 690         } else {
 691             process::exit(test_result::TR_FAILED);
 692         }
 693     });
 694     let record_result2 = record_result.clone();
 695     panic::set_hook(Box::new(move |info| record_result2(Some(&info))));
 696     testfn();
 697     record_result(None);
 698     unreachable!("panic=abort callback should have exited the process")
 699 }