Remove Tee, since it turned out to not be very useful

Author: tgross35

.gitignore

@@ -53,7 +53,6 @@ build/
 # Created by default with `src/ci/docker/run.sh`
 /obj/
 /rustc-ice*
-/parse-float*
 
 ## Temporary files
 *~

src/bootstrap/src/core/build_steps/test.rs

@@ -3534,7 +3534,6 @@ impl Step for TestFloatParse {
         cargo_run.arg("--");
         if builder.config.args().is_empty() {
             // By default, exclude tests that take longer than ~1m.
-            builder.info("only running a subset of tests by default");
             cargo_run.arg("--skip-huge");
         } else {
             cargo_run.args(builder.config.args());

src/etc/test-float-parse/README.md

@@ -43,3 +43,6 @@ parallel, and their tests get chunked and run in parallel.
 There is a simple command line that allows filtering which tests are run,
 setting the number of iterations for fuzzing tests, limiting failures, setting
 timeouts, etc. See `main.rs` or run with `--help` for options.
+
+Note that when running via `./x`, only tests that take less than a few minutes
+are run by default. Pass `-- --all` to actually run them all locally.

src/etc/test-float-parse/src/lib.rs

@@ -15,8 +15,6 @@ use rand::distributions::{Distribution, Standard};
 use rayon::prelude::*;
 use time::{Duration, Instant};
 use traits::{Float, Generator, Int};
-pub use ui::create_log_file;
-use ui::Tee;
 
 /// Test generators.
 mod gen {
@@ -86,20 +84,13 @@ pub fn run(cfg: Config, include: &[String], exclude: &[String]) -> ExitCode {
         tests.retain(|test| include.iter().any(|inc| test.matches(inc)));
     }
 
-    let (logfile, logfile_name) = create_log_file();
-    let mut out = Tee { f: &logfile };
-
     for exc in initial_tests.iter().filter(|orig_name| !tests.iter().any(|t| t.name == **orig_name))
     {
-        out.write_sout(format!("Skipping test '{exc}'"));
+        println!("Skipping test '{exc}'");
     }
 
-    let elapsed = launch_tests(&mut tests, &cfg, &mut out);
-    let ret = ui::finish(&tests, elapsed, &cfg, &mut out);
-
-    println!("wrote results to {logfile_name}");
-
-    ret
+    let elapsed = launch_tests(&mut tests, &cfg);
+    ui::finish(&tests, elapsed, &cfg)
 }
 
 /// Enumerate tests to run but don't actaully run them.
@@ -191,15 +182,20 @@ impl TestInfo {
         v.push(info);
     }
 
+    /// Pad the short name to a common width for progress bar use.
+    fn short_name_padded(&self) -> String {
+        format!("{:18}", self.short_name)
+    }
+
     /// Create a progress bar for this test within a multiprogress bar.
     fn register_pb(&mut self, mp: &MultiProgress, drop_bars: &mut Vec<ProgressBar>) {
-        self.pb = Some(ui::create_pb(mp, self.total_tests, &self.short_name, drop_bars));
+        self.pb = Some(ui::create_pb(mp, self.total_tests, &self.short_name_padded(), drop_bars));
     }
 
     /// When the test is finished, update progress bar messages and finalize.
     fn finalize_pb(&self, c: &Completed) {
         let pb = self.pb.as_ref().unwrap();
-        ui::finalize_pb(pb, &self.short_name, c);
+        ui::finalize_pb(pb, &self.short_name_padded(), c);
     }
 
     /// True if this should be run after all others.
@@ -228,20 +224,21 @@ impl Msg {
     }
 
     /// Update UI as needed for a single message received from the test runners.
-    fn handle(self, tests: &[TestInfo], out: &mut Tee<'_>, mp: &MultiProgress) {
+    fn handle(self, tests: &[TestInfo], mp: &MultiProgress) {
         let test = self.find_test(tests);
         let pb = test.pb.as_ref().unwrap();
 
         match self.update {
             Update::Started => {
-                out.write_mp(mp, format!("Testing '{}'", test.name));
+                mp.println(format!("Testing '{}'", test.name)).unwrap();
             }
             Update::Progress { executed, failures } => {
                 pb.set_message(format! {"{failures}"});
                 pb.set_position(executed);
             }
             Update::Failure { fail, input } => {
-                out.write_mp(mp, format!("Failure in '{}': {fail}. parsing '{input}'", test.name,));
+                mp.println(format!("Failure in '{}': {fail}. parsing '{input}'", test.name))
+                    .unwrap();
             }
             Update::Completed(c) => {
                 test.finalize_pb(&c);
@@ -252,13 +249,11 @@ impl Msg {
                     Err(EarlyExit::MaxFailures) => "Max failures reached for",
                 };
 
-                out.write_mp(
-                    mp,
-                    format!(
-                        "{prefix} generator '{}' in {:?}. {} tests run, {} failures",
-                        test.name, c.elapsed, c.executed, c.failures
-                    ),
-                );
+                mp.println(format!(
+                    "{prefix} generator '{}' in {:?}. {} tests run, {} failures",
+                    test.name, c.elapsed, c.executed, c.failures
+                ))
+                .unwrap();
                 test.completed.set(c).unwrap();
             }
         };
@@ -361,12 +356,12 @@ enum EarlyExit {
 ///
 /// This launches a main thread that receives messages and handlees UI updates, and uses the
 /// rest of the thread pool to execute the tests.
-fn launch_tests(tests: &mut [TestInfo], cfg: &Config, out: &mut Tee<'_>) -> Duration {
+fn launch_tests(tests: &mut [TestInfo], cfg: &Config) -> Duration {
     // Run shorter tests first
     tests.sort_unstable_by_key(|test| test.total_tests);
 
     for test in tests.iter() {
-        out.write_sout(format!("Launching test '{}'", test.name));
+        println!("Launching test '{}'", test.name);
     }
 
     // Configure progress bars
@@ -393,7 +388,7 @@ fn launch_tests(tests: &mut [TestInfo], cfg: &Config, out: &mut Tee<'_>) -> Dura
                 }
 
                 let msg = rx.recv().unwrap();
-                msg.handle(tests, out, &mp);
+                msg.handle(tests, &mp);
             }
 
             // All tests completed; finish things up

src/etc/test-float-parse/src/main.rs

@@ -25,6 +25,9 @@ Args:
                            if fuzz tests are enabled. Pass `--fuzz-count none`
                            to remove this limit.
   --skip-huge              Skip tests that run for a long time.
+  --all                    Reset previous `--exclude`, `--skip-huge`, and
+                           `INCLUDE` arguments (useful for running all tests
+                           via `./x`).
 "#;
 
 enum ArgMode {
@@ -87,6 +90,12 @@ fn parse_args(args: Vec<String>) -> (tfp::Config, Vec<String>, Vec<String>) {
                 cfg.skip_huge = true;
                 ArgMode::Any
             }
+            ArgMode::Any if arg == "--all" => {
+                cfg.skip_huge = false;
+                include.clear();
+                exclude.clear();
+                ArgMode::Any
+            }
             ArgMode::Any if arg.starts_with('-') => {
                 panic!("Unknown argument {arg}. Usage:\n{HELP}")
             }

src/etc/test-float-parse/src/ui.rs

@@ -1,9 +1,8 @@
 //! Progress bars and such.
 
-use std::fs;
 use std::io::{self, Write};
 use std::process::ExitCode;
-use std::time::{Duration, SystemTime};
+use std::time::Duration;
 
 use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
 
@@ -18,12 +17,11 @@ const PB_TEMPLATE_FINAL: &str =
 pub fn create_pb(
     mp: &MultiProgress,
     total_tests: u64,
-    short_name: &str,
+    short_name_padded: &str,
     all_bars: &mut Vec<ProgressBar>,
 ) -> ProgressBar {
     let pb = mp.add(ProgressBar::new(total_tests));
-    let short_name_padded = format!("{short_name:16}");
-    let pb_style = ProgressStyle::with_template(&PB_TEMPLATE.replace("NAME", &short_name_padded))
+    let pb_style = ProgressStyle::with_template(&PB_TEMPLATE.replace("NAME", short_name_padded))
         .unwrap()
         .progress_chars("##-");
 
@@ -34,8 +32,7 @@ pub fn create_pb(
 }
 
 /// Removes the status bar and replace it with a message.
-pub fn finalize_pb(pb: &ProgressBar, short_name: &str, c: &Completed) {
-    let short_name_padded = format!("{short_name:16}");
+pub fn finalize_pb(pb: &ProgressBar, short_name_padded: &str, c: &Completed) {
     let f = c.failures;
 
     // Use a tuple so we can use colors
@@ -64,13 +61,8 @@ pub fn finalize_pb(pb: &ProgressBar, short_name: &str, c: &Completed) {
 }
 
 /// Print final messages after all tests are complete.
-pub fn finish(
-    tests: &[TestInfo],
-    total_elapsed: Duration,
-    cfg: &Config,
-    out: &mut Tee<'_>,
-) -> ExitCode {
-    out.write_sout("\n\nResults:");
+pub fn finish(tests: &[TestInfo], total_elapsed: Duration, cfg: &Config) -> ExitCode {
+    println!("\n\nResults:");
 
     let mut failed_generators = 0;
     let mut stopped_generators = 0;
@@ -88,35 +80,34 @@ pub fn finish(
             "SUCCESS"
         };
 
-        out.write_sout(format!(
+        println!(
             "    {stat} for generator '{name}'. {passed}/{executed} passed in {elapsed:?}",
             name = t.name,
             passed = executed - failures,
-        ));
+        );
 
         if let Some(warning) = warning {
-            out.write_sout(format!("      warning: {warning}"));
+            println!("      warning: {warning}");
         }
 
         match result {
             Ok(FinishedAll) => (),
             Err(EarlyExit::Timeout) => {
-                out.write_sout(format!("      exited early; exceded {:?} timeout", cfg.timeout))
+                println!("      exited early; exceded {:?} timeout", cfg.timeout)
+            }
+            Err(EarlyExit::MaxFailures) => {
+                println!("      exited early; exceeded {:?} max failures", cfg.max_failures)
             }
-            Err(EarlyExit::MaxFailures) => out.write_sout(format!(
-                "      exited early; exceeded {:?} max failures",
-                cfg.max_failures
-            )),
         }
     }
 
-    out.write_sout(format!(
+    println!(
         "{passed}/{} tests succeeded in {total_elapsed:?} ({passed} passed, {} failed, {} stopped)",
         tests.len(),
         failed_generators,
         stopped_generators,
         passed = tests.len() - failed_generators - stopped_generators,
-    ));
+    );
 
     if failed_generators > 0 || stopped_generators > 0 {
         ExitCode::FAILURE
@@ -139,34 +130,3 @@ pub fn set_panic_hook(drop_bars: Vec<ProgressBar>) {
         hook(info);
     }));
 }
-
-/// Open a file with a reasonable name that we can dump data to.
-pub fn create_log_file() -> (fs::File, String) {
-    let now = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs();
-    let name = format!("parse-float-{now}.txt");
-    (fs::OpenOptions::new().write(true).create_new(true).open(&name).unwrap(), name)
-}
-
-/// Tee output to the file and either stdout or a progress bar.
-pub struct Tee<'a> {
-    pub f: &'a fs::File,
-}
-
-impl<'a> Tee<'a> {
-    /// Write to both the file and above the multiprogress bar. Includes newline.
-    pub fn write_mp(&mut self, mb: &MultiProgress, s: impl Into<String>) {
-        let mut s = s.into();
-        s.push('\n');
-        self.f.write_all(s.as_bytes()).unwrap();
-        s.pop();
-        mb.println(s).unwrap();
-    }
-
-    /// Write to both the file and stdout. Includes newline.
-    pub fn write_sout(&mut self, s: impl Into<String>) {
-        let mut s = s.into();
-        s.push('\n');
-        self.f.write_all(s.as_bytes()).unwrap();
-        io::stdout().write_all(s.as_bytes()).unwrap();
-    }
-}