testing

crates/cli/src/bin/wasm-bindgen-test-runner/headless.rs

@@ -4,14 +4,14 @@ use log::{debug, warn};
 use rouille::url::Url;
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Map, Value as Json};
-use std::env;
 use std::fs::File;
-use std::io::{BufRead, BufReader, Read};
+use std::io::{Cursor, Read, Write};
 use std::net::{SocketAddr, TcpListener, TcpStream};
 use std::path::{Path, PathBuf};
 use std::process::{Child, ChildStderr, ChildStdout, Command, Stdio};
 use std::thread;
 use std::time::{Duration, Instant};
+use std::{env, io};
 use ureq::Agent;
 
 /// Options that can use to customize and configure a WebDriver session.
@@ -627,12 +627,46 @@ fn tab(s: &str) -> String {
 
 struct BackgroundChild<'a> {
     child: Child,
-    stdout: BufReader<ChildStdout>,
-    stderr: BufReader<ChildStderr>,
+    stdout: ReadCache<ChildStdout>,
+    stderr: ReadCache<ChildStderr>,
     shell: &'a Shell,
     print_stdio_on_drop: bool,
 }
 
+struct ReadCache<T> {
+    source: T,
+    buffer: Cursor<Vec<u8>>,
+}
+
+impl<T: Read> ReadCache<T> {
+    fn new(source: T) -> Self {
+        Self {
+            source,
+            buffer: Cursor::new(Vec::new()),
+        }
+    }
+
+    fn has_data(&mut self) -> bool {
+        if self.buffer.position() != 0 {
+            return true;
+        }
+
+        let mut buffer = [0];
+
+        if self.source.read(&mut buffer).unwrap() == 1 {
+            self.buffer.write_all(&buffer).unwrap();
+            true
+        } else {
+            false
+        }
+    }
+
+    fn read_to_end(&mut self) -> &[u8] {
+        io::copy(&mut self.source, &mut self.buffer).unwrap();
+        self.buffer.get_ref()
+    }
+}
+
 impl<'a> BackgroundChild<'a> {
     fn spawn(
         path: &Path,
@@ -646,8 +680,8 @@ impl<'a> BackgroundChild<'a> {
         let mut child = cmd
             .spawn()
             .context(format!("failed to spawn {:?} binary", path))?;
-        let stdout = BufReader::new(child.stdout.take().unwrap());
-        let stderr = BufReader::new(child.stderr.take().unwrap());
+        let stdout = ReadCache::new(child.stdout.take().unwrap());
+        let stderr = ReadCache::new(child.stderr.take().unwrap());
         Ok(BackgroundChild {
             child,
             stdout,
@@ -660,11 +694,7 @@ impl<'a> BackgroundChild<'a> {
     fn has_failed(&mut self) -> bool {
         match self.child.try_wait() {
             Ok(Some(status)) => !status.success(),
-            Ok(None) => self
-                .stderr
-                .fill_buf()
-                .map(|b| !b.is_empty())
-                .unwrap_or(true),
+            Ok(None) => self.stderr.has_data(),
             Err(_) => true,
         }
     }
@@ -681,15 +711,13 @@ impl Drop for BackgroundChild<'_> {
         self.shell.clear();
         println!("driver status: {}", status);
 
-        let mut stdout = Vec::new();
-        self.stdout.read_to_end(&mut stdout).unwrap();
+        let stdout = self.stdout.read_to_end();
         if !stdout.is_empty() {
-            println!("driver stdout:\n{}", tab(&String::from_utf8_lossy(&stdout)));
+            println!("driver stdout:\n{}", tab(&String::from_utf8_lossy(stdout)));
         }
-        let mut stderr = Vec::new();
-        self.stderr.read_to_end(&mut stderr).unwrap();
+        let stderr = self.stderr.read_to_end();
         if !stderr.is_empty() {
-            println!("driver stderr:\n{}", tab(&String::from_utf8_lossy(&stderr)));
+            println!("driver stderr:\n{}", tab(&String::from_utf8_lossy(stderr)));
         }
     }
 }