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