test-float-parse: Use an overrideable random seed

Currently `test-float-parse` is mostly random tests which take a fixed
seed, meaning the same set of values get tested for each invocation.
This isn't ideal because we don't get the true benefit of randomness,
which is to have better coverage over time.

Improve this by using a randomly generated seed, which can also be set
via env. The seed is printed at the beginning of each run so it is easy
to reproduce failures using the same test set, if needed.

Typically it isn't great to have fuzzing randomness in tests that get
run in CI because it can lead to spurious failures. However, this is a
test for which failure should never happen becasue the algorithms are
reasonably well proven, so if one does occur it represents a very
unexpected bug that needs to be addressed. The error message is updated
to strongly recommend reporting before retrying and to include details
on how to reproduce.

Author: tgross35

src/tools/test-float-parse/src/gen_/fuzz.rs

@@ -62,7 +62,7 @@ where
     }
 
     fn new() -> Self {
-        let rng = ChaCha8Rng::from_seed(SEED);
+        let rng = ChaCha8Rng::from_seed(SEED.0);
 
         Self { iter: 0..Self::total_tests(), rng, marker: PhantomData }
     }

src/tools/test-float-parse/src/gen_/many_digits.rs

@@ -39,7 +39,7 @@ impl<F: Float> Generator<F> for RandDigits<F> {
     }
 
     fn new() -> Self {
-        let rng = ChaCha8Rng::from_seed(SEED);
+        let rng = ChaCha8Rng::from_seed(SEED.0);
         let range = Uniform::try_from(0..10).unwrap();
 
         Self { rng, iter: 0..ITERATIONS, uniform: range, marker: PhantomData }

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

@@ -10,11 +10,13 @@ use std::any::type_name;
 use std::cmp::min;
 use std::ops::RangeInclusive;
 use std::process::ExitCode;
-use std::sync::OnceLock;
 use std::sync::atomic::{AtomicU64, Ordering};
-use std::{fmt, time};
+use std::sync::{LazyLock, OnceLock};
+use std::{env, fmt, time};
 
+use rand::TryRng;
 use rand::distr::{Distribution, StandardUniform};
+use rand::rngs::SysRng;
 use rayon::prelude::*;
 use time::{Duration, Instant};
 use traits::{Float, Generator, Int};
@@ -44,8 +46,41 @@ const MAX_BITS_FOR_EXHAUUSTIVE: u32 = 32;
 /// `--skip-huge`.
 const HUGE_TEST_CUTOFF: u64 = 5_000_000;
 
-/// Seed for tests that use a deterministic RNG.
-const SEED: [u8; 32] = *b"3.141592653589793238462643383279";
+const SEED_ENV: &str = "TEST_FLOAT_PARSE_SEED";
+
+/// Seed for tests that use a deterministic RNG, and its b64 representation for printing. Taken
+/// from env if provided,
+static SEED: LazyLock<([u8; 32], Box<str>)> = LazyLock::new(|| {
+    let seed = match env::var(SEED_ENV) {
+        Ok(s) => {
+            seed_from_str(&s).unwrap_or_else(|| panic!("{SEED_ENV} must be 32 bytes, hex encoded"))
+        }
+        Err(_) => {
+            let mut seed = [0u8; 32];
+            SysRng.try_fill_bytes(&mut seed).unwrap();
+            seed
+        }
+    };
+
+    let lo = u128::from_le_bytes(seed[..16].try_into().unwrap());
+    let hi = u128::from_le_bytes(seed[16..].try_into().unwrap());
+    let encoded = format!("{hi:032x}{lo:032x}").into_boxed_str();
+
+    (seed, encoded)
+});
+
+fn seed_from_str(s: &str) -> Option<[u8; 32]> {
+    let hi = s.get(..32)?;
+    let hi = u128::from_str_radix(hi, 16).ok()?;
+    let lo = s.get(32..)?;
+    let lo = u128::from_str_radix(lo, 16).ok()?;
+
+    let mut out = [0u8; 32];
+    out[..16].copy_from_slice(&lo.to_le_bytes());
+    out[16..].copy_from_slice(&hi.to_le_bytes());
+
+    Some(out)
+}
 
 /// Global configuration.
 #[derive(Debug)]
@@ -78,8 +113,10 @@ pub fn run(cfg: Config, include: &[String], exclude: &[String]) -> ExitCode {
     let threads = std::thread::available_parallelism().map(Into::into).unwrap_or(0) * 3 / 2;
     rayon::ThreadPoolBuilder::new().num_threads(threads).build_global().unwrap();
 
+    println!("Starting test runner");
+    println!("Using {SEED_ENV}={}`", SEED.1);
     let mut tests = register_tests(&cfg);
-    println!("registered");
+    println!("Tests registered");
     let initial_tests: Vec<_> = tests.iter().map(|t| t.name.clone()).collect();
 
     let unmatched: Vec<_> = include

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

@@ -8,7 +8,7 @@ use std::time::Duration;
 
 use indicatif::{ProgressBar, ProgressStyle};
 
-use crate::{Completed, Config, EarlyExit, FinishedAll, TestInfo};
+use crate::{Completed, Config, EarlyExit, FinishedAll, SEED, SEED_ENV, TestInfo};
 
 /// Templates for progress bars.
 const PB_TEMPLATE: &str = "[{elapsed:3} {percent:3}%] {bar:20.cyan/blue} NAME \
@@ -135,6 +135,16 @@ pub fn finish_all(tests: &[TestInfo], total_elapsed: Duration, cfg: &Config) ->
     );
 
     if failed_generators > 0 || stopped_generators > 0 {
+        println!();
+        println!(
+            "ERROR: Some float parsing/printing tests failed.\n\
+            \n\
+            If you ever encounter this failure when not expected, PLEASE OPEN AN ISSUE!! The \
+            failure will likely go away on the next run, but may represent a real bug.\n\
+            \n\
+            To reproduce, rerun with the same seed: {}={}",
+            SEED_ENV, SEED.1
+        );
         ExitCode::FAILURE
     } else {
         ExitCode::SUCCESS