Auto merge of rust-lang#78227 - SergioBenitez:test-stdout-threading, …

…r=m-ou-se Capture output from threads spawned in tests This is revival of rust-lang#75172. Original text: > Fixes rust-lang#42474. > > r? `@dtolnay` since you expressed interest in this, but feel free to redirect if you aren't the right person anymore. --- Closes rust-lang#75172.
rust-lang-ci · Oct 27, 2020 · 56d288f · 56d288f
2 parents 20b1e05 7c4fe00
commit 56d288f
Show file tree

Hide file tree

Showing 14 changed files with 184 additions and 12 deletions.
diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
@@ -115,6 115,11 @@ impl Write for Sink {
  Ok(())
  }
 }
 impl io::LocalOutput for Sink {
  fn clone_box(&self) -> Box<dyn io::LocalOutput> {
  Box::new(Self(self.0.clone()))
  }
 }
 
 /// Like a `thread::Builder::spawn` followed by a `join()`, but avoids the need
 /// for `'static` bounds.

diff --git a/library/std/src/io/impls.rs b/library/std/src/io/impls.rs
@@ -213,13 213,13 @@ impl<B: BufRead ?Sized> BufRead for Box<B> {
 #[cfg(test)]
 /// This impl is only used by printing logic, so any error returned is always
 /// of kind `Other`, and should be ignored.
-impl Write for Box<dyn (::realstd::io::Write) Send> {
 impl Write for dyn ::realstd::io::LocalOutput {
  fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
- (**self).write(buf).map_err(|_| ErrorKind::Other.into())
  (*self).write(buf).map_err(|_| ErrorKind::Other.into())
  }
 
  fn flush(&mut self) -> io::Result<()> {
- (**self).flush().map_err(|_| ErrorKind::Other.into())
  (*self).flush().map_err(|_| ErrorKind::Other.into())
  }
 }
 

diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs
@@ -277,10 277,12 @@ pub use self::stdio::{StderrLock, StdinLock, StdoutLock};
 pub use self::stdio::{_eprint, _print};
 #[unstable(feature = "libstd_io_internals", issue = "42788")]
 #[doc(no_inline, hidden)]
-pub use self::stdio::{set_panic, set_print};
 pub use self::stdio::{set_panic, set_print, LocalOutput};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::util::{copy, empty, repeat, sink, Empty, Repeat, Sink};
 
 pub(crate) use self::stdio::clone_io;
 
 mod buffered;
 mod cursor;
 mod error;

diff --git a/library/std/src/io/stdio.rs b/library/std/src/io/stdio.rs
@@ -18,14 18,14 @@ use crate::thread::LocalKey;
 
 thread_local! {
  /// Used by the test crate to capture the output of the print! and println! macros.
- static LOCAL_STDOUT: RefCell<Option<Box<dyn Write Send>>> = {
  static LOCAL_STDOUT: RefCell<Option<Box<dyn LocalOutput>>> = {
  RefCell::new(None)
  }
 }
 
 thread_local! {
  /// Used by the test crate to capture the output of the eprint! and eprintln! macros, and panics.
- static LOCAL_STDERR: RefCell<Option<Box<dyn Write Send>>> = {
  static LOCAL_STDERR: RefCell<Option<Box<dyn LocalOutput>>> = {
  RefCell::new(None)
  }
 }
@@ -888,6 888,18 @@ impl fmt::Debug for StderrLock<'_> {
  }
 }
 
 /// A writer than can be cloned to new threads.
 #[unstable(
  feature = "set_stdio",
  reason = "this trait may disappear completely or be replaced \
  with a more general mechanism",
  issue = "none"
 )]
 #[doc(hidden)]
 pub trait LocalOutput: Write Send {
  fn clone_box(&self) -> Box<dyn LocalOutput>;
 }
 
 /// Resets the thread-local stderr handle to the specified writer
 ///
 /// This will replace the current thread's stderr handle, returning the old
@@ -903,7 915,7 @@ impl fmt::Debug for StderrLock<'_> {
  issue = "none"
 )]
 #[doc(hidden)]
-pub fn set_panic(sink: Option<Box<dyn Write Send>>) -> Option<Box<dyn Write Send>> {
 pub fn set_panic(sink: Option<Box<dyn LocalOutput>>) -> Option<Box<dyn LocalOutput>> {
  use crate::mem;
  if sink.is_none() && !LOCAL_STREAMS.load(Ordering::Relaxed) {
  // LOCAL_STDERR is definitely None since LOCAL_STREAMS is false.
@@ -934,7 946,7 @@ pub fn set_panic(sink: Option<Box<dyn Write Send>>) -> Option<Box<dyn Write
  issue = "none"
 )]
 #[doc(hidden)]
-pub fn set_print(sink: Option<Box<dyn Write Send>>) -> Option<Box<dyn Write Send>> {
 pub fn set_print(sink: Option<Box<dyn LocalOutput>>) -> Option<Box<dyn LocalOutput>> {
  use crate::mem;
  if sink.is_none() && !LOCAL_STREAMS.load(Ordering::Relaxed) {
  // LOCAL_STDOUT is definitely None since LOCAL_STREAMS is false.
@@ -950,6 962,22 @@ pub fn set_print(sink: Option<Box<dyn Write Send>>) -> Option<Box<dyn Write
  s
 }
 
 pub(crate) fn clone_io() -> (Option<Box<dyn LocalOutput>>, Option<Box<dyn LocalOutput>>) {
  // Don't waste time when LOCAL_{STDOUT,STDERR} are definitely None.
  if !LOCAL_STREAMS.load(Ordering::Relaxed) {
  return (None, None);
  }
 
  LOCAL_STDOUT.with(|stdout| {
  LOCAL_STDERR.with(|stderr| {
  (
  stdout.borrow().as_ref().map(|o| o.clone_box()),
  stderr.borrow().as_ref().map(|o| o.clone_box()),
  )
  })
  })
 }
 
 /// Write `args` to output stream `local_s` if possible, `global_s`
 /// otherwise. `label` identifies the stream in a panic message.
 ///
@@ -962,7 990,7 @@ pub fn set_print(sink: Option<Box<dyn Write Send>>) -> Option<Box<dyn Write
 /// However, if the actual I/O causes an error, this function does panic.
 fn print_to<T>(
  args: fmt::Arguments<'_>,
- local_s: &'static LocalKey<RefCell<Option<Box<dyn Write Send>>>>,
  local_s: &'static LocalKey<RefCell<Option<Box<dyn LocalOutput>>>>,
  global_s: fn() -> T,
  label: &str,
 ) where

diff --git a/library/std/src/panicking.rs b/library/std/src/panicking.rs
@@ -220,7 220,7 @@ fn default_hook(info: &PanicInfo<'_>) {
 
  if let Some(mut local) = set_panic(None) {
  // NB. In `cfg(test)` this uses the forwarding impl
- // for `Box<dyn (::realstd::io::Write) Send>`.
  // for `dyn ::realstd::io::LocalOutput`.
  write(&mut local);
  set_panic(Some(local));
  } else if let Some(mut out) = panic_output() {

diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs
@@ -457,11 457,16 @@ impl Builder {
  let my_packet: Arc<UnsafeCell<Option<Result<T>>>> = Arc::new(UnsafeCell::new(None));
  let their_packet = my_packet.clone();
 
  let (stdout, stderr) = crate::io::clone_io();
 
  let main = move || {
  if let Some(name) = their_thread.cname() {
  imp::Thread::set_name(name);
  }
 
  crate::io::set_print(stdout);
  crate::io::set_panic(stderr);
 
  // SAFETY: the stack guard passed is the one for the current thread.
  // This means the current thread's stack and the new thread's stack
  // are properly set and protected from each other.

diff --git a/library/test/src/helpers/sink.rs b/library/test/src/helpers/sink.rs
@@ -6,6 6,7 @@ use std::{
  sync::{Arc, Mutex},
 };
 
 #[derive(Clone)]
 pub struct Sink(Arc<Mutex<Vec<u8>>>);
 
 impl Sink {
@@ -14,6 15,12 @@ impl Sink {
  }
 }
 
 impl io::LocalOutput for Sink {
  fn clone_box(&self) -> Box<dyn io::LocalOutput> {
  Box::new(self.clone())
  }
 }
 
 impl Write for Sink {
  fn write(&mut self, data: &[u8]) -> io::Result<usize> {
  Write::write(&mut *self.0.lock().unwrap(), data)

diff --git a/src/test/ui/panic-while-printing.rs b/src/test/ui/panic-while-printing.rs
@@ -5,7 5,7 @@
 
 use std::fmt;
 use std::fmt::{Display, Formatter};
-use std::io::set_panic;
 use std::io::{self, set_panic, LocalOutput, Write};
 
 pub struct A;
 
@@ -15,8 15,23 @@ impl Display for A {
  }
 }
 
 struct Sink;
 impl Write for Sink {
  fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  Ok(buf.len())
  }
  fn flush(&mut self) -> io::Result<()> {
  Ok(())
  }
 }
 impl LocalOutput for Sink {
  fn clone_box(&self) -> Box<dyn LocalOutput> {
  Box::new(Sink)
  }
 }
 
 fn main() {
- set_panic(Some(Box::new(Vec::new())));
  set_panic(Some(Box::new(Sink)));
  assert!(std::panic::catch_unwind(|| {
  eprintln!("{}", A);
  })

diff --git a/src/test/ui/test-thread-capture.rs b/src/test/ui/test-thread-capture.rs
@@ -0,0 1,31 @@
 // compile-flags: --test
 // run-fail
 // run-flags: --test-threads=1
 // check-run-results
 // exec-env:RUST_BACKTRACE=0
 // ignore-emscripten no threads support
 
 #[test]
 fn thready_pass() {
  println!("fee");
  std::thread::spawn(|| {
  println!("fie");
  println!("foe");
  })
  .join()
  .unwrap();
  println!("fum");
 }
 
 #[test]
 fn thready_fail() {
  println!("fee");
  std::thread::spawn(|| {
  println!("fie");
  println!("foe");
  })
  .join()
  .unwrap();
  println!("fum");
  panic!();
 }
diff --git a/src/test/ui/test-thread-capture.run.stdout b/src/test/ui/test-thread-capture.run.stdout
@@ -0,0 1,21 @@
 
 running 2 tests
 test thready_fail ... FAILED
 test thready_pass ... ok
 
 failures:
 
 ---- thready_fail stdout ----
 fee
 fie
 foe
 fum
 thread 'main' panicked at 'explicit panic', $DIR/test-thread-capture.rs:30:5
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 
 
 failures:
  thready_fail
 
 test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out
 
diff --git a/src/test/ui/test-thread-nocapture.rs b/src/test/ui/test-thread-nocapture.rs
@@ -0,0 1,31 @@
 // compile-flags: --test
 // run-fail
 // run-flags: --test-threads=1 --nocapture
 // check-run-results
 // exec-env:RUST_BACKTRACE=0
 // ignore-emscripten no threads support
 
 #[test]
 fn thready_pass() {
  println!("fee");
  std::thread::spawn(|| {
  println!("fie");
  println!("foe");
  })
  .join()
  .unwrap();
  println!("fum");
 }
 
 #[test]
 fn thready_fail() {
  println!("fee");
  std::thread::spawn(|| {
  println!("fie");
  println!("foe");
  })
  .join()
  .unwrap();
  println!("fum");
  panic!();
 }
diff --git a/src/test/ui/test-thread-nocapture.run.stderr b/src/test/ui/test-thread-nocapture.run.stderr
@@ -0,0 1,2 @@
 thread 'main' panicked at 'explicit panic', $DIR/test-thread-nocapture.rs:30:5
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/src/test/ui/test-thread-nocapture.run.stdout b/src/test/ui/test-thread-nocapture.run.stdout
@@ -0,0 1,20 @@
 
 running 2 tests
 test thready_fail ... fee
 fie
 foe
 fum
 FAILED
 test thready_pass ... fee
 fie
 foe
 fum
 ok
 
 failures:
 
 failures:
  thready_fail
 
 test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out
 
diff --git a/src/test/ui/threads-sendsync/task-stderr.rs b/src/test/ui/threads-sendsync/task-stderr.rs
@@ -16,6 16,11 @@ impl Write for Sink {
  }
  fn flush(&mut self) -> io::Result<()> { Ok(()) }
 }
 impl io::LocalOutput for Sink {
  fn clone_box(&self) -> Box<dyn io::LocalOutput> {
  Box::new(Sink(self.0.clone()))
  }
 }
 
 fn main() {
  let data = Arc::new(Mutex::new(Vec::new()));