| #![feature(cfg_target_has_reliable_f16_f128)] | |
| #![cfg_attr(target_has_reliable_f16, feature(f16))] | |
| #![expect(internal_features)] // reliable_f16_f128 | |
| mod traits; | |
| mod ui; | |
| mod validate; | |
| 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 rand::distr::{Distribution, StandardUniform}; | |
| use rayon::prelude::*; | |
| use time::{Duration, Instant}; | |
| use traits::{Float, Generator, Int}; | |
| use validate::CheckError; | |
| /// Test generators. | |
| mod gen_ { | |
| pub mod exhaustive; | |
| pub mod exponents; | |
| pub mod fuzz; | |
| pub mod integers; | |
| pub mod long_fractions; | |
| pub mod many_digits; | |
| pub mod sparse; | |
| pub mod spot_checks; | |
| pub mod subnorm; | |
| } | |
| /// How many failures to exit after if unspecified. | |
| const DEFAULT_MAX_FAILURES: u64 = 20; | |
| /// Register exhaustive tests only for <= 32 bits. No more because it would take years. | |
| const MAX_BITS_FOR_EXHAUUSTIVE: u32 = 32; | |
| /// If there are more tests than this threshold, the test will be deferred until after all | |
| /// others run (so as to avoid thread pool starvation). They also can be excluded with | |
| /// `--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"; | |
| /// Global configuration. | |
| #[derive(Debug)] | |
| pub struct Config { | |
| pub timeout: Duration, | |
| /// Failures per test | |
| pub max_failures: u64, | |
| pub disable_max_failures: bool, | |
| /// If `None`, the default will be used | |
| pub fuzz_count: Option<u64>, | |
| pub skip_huge: bool, | |
| } | |
| impl Default for Config { | |
| fn default() -> Self { | |
| Self { | |
| timeout: Duration::from_secs(60 * 60 * 3), | |
| max_failures: DEFAULT_MAX_FAILURES, | |
| disable_max_failures: false, | |
| fuzz_count: None, | |
| skip_huge: false, | |
| } | |
| } | |
| } | |
| /// Collect, filter, and launch all tests. | |
| pub fn run(cfg: Config, include: &[String], exclude: &[String]) -> ExitCode { | |
| // With default parallelism, the CPU doesn't saturate. We don't need to be nice to | |
| // other processes, so do 1.5x to make sure we use all available resources. | |
| let threads = std::thread::available_parallelism().map(Into::into).unwrap_or(0) * 3 / 2; | |
| rayon::ThreadPoolBuilder::new().num_threads(threads).build_global().unwrap(); | |
| let mut tests = register_tests(&cfg); | |
| println!("registered"); | |
| let initial_tests: Vec<_> = tests.iter().map(|t| t.name.clone()).collect(); | |
| let unmatched: Vec<_> = include | |
| .iter() | |
| .chain(exclude.iter()) | |
| .filter(|filt| !tests.iter().any(|t| t.matches(filt))) | |
| .collect(); | |
| assert!( | |
| unmatched.is_empty(), | |
| "filters were provided that have no matching tests: {unmatched:#?}" | |
| ); | |
| tests.retain(|test| !exclude.iter().any(|exc| test.matches(exc))); | |
| if cfg.skip_huge { | |
| tests.retain(|test| !test.is_huge_test()); | |
| } | |
| if !include.is_empty() { | |
| tests.retain(|test| include.iter().any(|inc| test.matches(inc))); | |
| } | |
| for exc in initial_tests.iter().filter(|orig_name| !tests.iter().any(|t| t.name == **orig_name)) | |
| { | |
| println!("Skipping test '{exc}'"); | |
| } | |
| println!("Launching all"); | |
| let elapsed = launch_tests(&mut tests, &cfg); | |
| ui::finish_all(&tests, elapsed, &cfg) | |
| } | |
| /// Enumerate tests to run but don't actually run them. | |
| pub fn register_tests(cfg: &Config) -> Vec<TestInfo> { | |
| let mut tests = Vec::new(); | |
| // Register normal generators for all floats. | |
| #[cfg(target_has_reliable_f16)] | |
| register_float::<f16>(&mut tests, cfg); | |
| register_float::<f32>(&mut tests, cfg); | |
| register_float::<f64>(&mut tests, cfg); | |
| tests.sort_unstable_by_key(|t| (t.float_name, t.gen_name)); | |
| for i in 0..(tests.len() - 1) { | |
| if tests[i].gen_name == tests[i + 1].gen_name { | |
| panic!("duplicate test name {}", tests[i].gen_name); | |
| } | |
| } | |
| tests | |
| } | |
| /// Register all generators for a single float. | |
| fn register_float<F: Float>(tests: &mut Vec<TestInfo>, cfg: &Config) | |
| where | |
| RangeInclusive<F::Int>: Iterator<Item = F::Int>, | |
| <F::Int as TryFrom<u128>>::Error: std::fmt::Debug, | |
| StandardUniform: Distribution<<F as traits::Float>::Int>, | |
| { | |
| if F::BITS <= MAX_BITS_FOR_EXHAUUSTIVE { | |
| // Only run exhaustive tests if there is a chance of completion. | |
| TestInfo::register::<F, gen_::exhaustive::Exhaustive<F>>(tests); | |
| } | |
| gen_::fuzz::Fuzz::<F>::set_iterations(cfg.fuzz_count); | |
| TestInfo::register::<F, gen_::exponents::LargeExponents<F>>(tests); | |
| TestInfo::register::<F, gen_::exponents::SmallExponents<F>>(tests); | |
| TestInfo::register::<F, gen_::fuzz::Fuzz<F>>(tests); | |
| TestInfo::register::<F, gen_::integers::LargeInt<F>>(tests); | |
| TestInfo::register::<F, gen_::integers::SmallInt>(tests); | |
| TestInfo::register::<F, gen_::long_fractions::RepeatingDecimal>(tests); | |
| TestInfo::register::<F, gen_::many_digits::RandDigits<F>>(tests); | |
| TestInfo::register::<F, gen_::sparse::FewOnesFloat<F>>(tests); | |
| TestInfo::register::<F, gen_::sparse::FewOnesInt<F>>(tests); | |
| TestInfo::register::<F, gen_::spot_checks::RegressionCheck>(tests); | |
| TestInfo::register::<F, gen_::spot_checks::Special>(tests); | |
| TestInfo::register::<F, gen_::subnorm::SubnormComplete<F>>(tests); | |
| TestInfo::register::<F, gen_::subnorm::SubnormEdgeCases<F>>(tests); | |
| } | |
| /// Configuration for a single test. | |
| #[derive(Debug)] | |
| pub struct TestInfo { | |
| pub name: String, | |
| float_name: &'static str, | |
| float_bits: u32, | |
| gen_name: &'static str, | |
| /// Name for display in the progress bar. | |
| short_name: String, | |
| /// Pad the short name to a common width for progress bar use. | |
| short_name_padded: String, | |
| total_tests: u64, | |
| /// Function to launch this test. | |
| launch: fn(&TestInfo, &Config), | |
| /// Progress bar to be updated. | |
| progress: Option<ui::Progress>, | |
| /// Once completed, this will be set. | |
| completed: OnceLock<Completed>, | |
| } | |
| impl TestInfo { | |
| /// Check if either the name or short name is a match, for filtering. | |
| fn matches(&self, pat: &str) -> bool { | |
| self.short_name.contains(pat) || self.name.contains(pat) | |
| } | |
| /// Create a `TestInfo` for a given float and generator, then add it to a list. | |
| fn register<F: Float, G: Generator<F>>(v: &mut Vec<Self>) { | |
| let f_name = type_name::<F>(); | |
| let gen_name = G::NAME; | |
| let gen_short_name = G::SHORT_NAME; | |
| let name = format!("{f_name} {gen_name}"); | |
| let short_name = format!("{f_name} {gen_short_name}"); | |
| let short_name_padded = format!("{short_name:18}"); | |
| let info = TestInfo { | |
| float_name: f_name, | |
| float_bits: F::BITS, | |
| gen_name, | |
| progress: None, | |
| name, | |
| short_name_padded, | |
| short_name, | |
| launch: test_runner::<F, G>, | |
| total_tests: G::total_tests(), | |
| completed: OnceLock::new(), | |
| }; | |
| v.push(info); | |
| } | |
| /// True if this should be run after all others. | |
| fn is_huge_test(&self) -> bool { | |
| self.total_tests >= HUGE_TEST_CUTOFF | |
| } | |
| /// When the test is finished, update progress bar messages and finalize. | |
| fn complete(&self, c: Completed) { | |
| self.progress.as_ref().unwrap().complete(&c, 0); | |
| self.completed.set(c).unwrap(); | |
| } | |
| } | |
| /// Result of an input did not parsing successfully. | |
| #[derive(Clone, Debug)] | |
| enum CheckFailure { | |
| /// Above the zero cutoff but got rounded to zero. | |
| UnexpectedZero, | |
| /// Below the infinity cutoff but got rounded to infinity. | |
| UnexpectedInf, | |
| /// Above the negative infinity cutoff but got rounded to negative infinity. | |
| UnexpectedNegInf, | |
| /// Got a `NaN` when none was expected. | |
| UnexpectedNan, | |
| /// Expected `NaN`, got none. | |
| ExpectedNan, | |
| /// Expected infinity, got finite. | |
| ExpectedInf, | |
| /// Expected negative infinity, got finite. | |
| ExpectedNegInf, | |
| /// The value exceeded its error tolerance. | |
| InvalidReal { | |
| /// Error from the expected value, as a float. | |
| error_float: Option<f64>, | |
| /// Error as a rational string (since it can't always be represented as a float). | |
| error_str: Box<str>, | |
| /// True if the error was caused by not rounding to even at the midpoint between | |
| /// two representable values. | |
| incorrect_midpoint_rounding: bool, | |
| }, | |
| /// String did not parse successfully. | |
| ParsingFailed(Box<str>), | |
| /// A panic was caught. | |
| Panic(Box<str>), | |
| } | |
| impl fmt::Display for CheckFailure { | |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { | |
| match self { | |
| CheckFailure::UnexpectedZero => { | |
| write!(f, "incorrectly rounded to 0 (expected nonzero)") | |
| } | |
| CheckFailure::UnexpectedInf => { | |
| write!(f, "incorrectly rounded to +inf (expected finite)") | |
| } | |
| CheckFailure::UnexpectedNegInf => { | |
| write!(f, "incorrectly rounded to -inf (expected finite)") | |
| } | |
| CheckFailure::UnexpectedNan => write!(f, "got a NaN where none was expected"), | |
| CheckFailure::ExpectedNan => write!(f, "expected a NaN but did not get it"), | |
| CheckFailure::ExpectedInf => write!(f, "expected +inf but did not get it"), | |
| CheckFailure::ExpectedNegInf => write!(f, "expected -inf but did not get it"), | |
| CheckFailure::InvalidReal { error_float, error_str, incorrect_midpoint_rounding } => { | |
| if *incorrect_midpoint_rounding { | |
| write!( | |
| f, | |
| "midpoint between two representable values did not correctly \ | |
| round to even; error: {error_str}" | |
| )?; | |
| } else { | |
| write!(f, "real number did not parse correctly; error: {error_str}")?; | |
| } | |
| if let Some(float) = error_float { | |
| write!(f, " ({float})")?; | |
| } | |
| Ok(()) | |
| } | |
| CheckFailure::ParsingFailed(e) => write!(f, "parsing failed: {e}"), | |
| CheckFailure::Panic(e) => write!(f, "function panicked: {e}"), | |
| } | |
| } | |
| } | |
| /// Information about a completed test generator. | |
| #[derive(Clone, Debug)] | |
| struct Completed { | |
| /// Finished tests (both successful and failed). | |
| executed: u64, | |
| /// Failed tests. | |
| failures: u64, | |
| /// Extra exit information if unsuccessful. | |
| result: Result<FinishedAll, EarlyExit>, | |
| /// If there is something to warn about (e.g bad estimate), leave it here. | |
| warning: Option<Box<str>>, | |
| /// Total time to run the test. | |
| elapsed: Duration, | |
| } | |
| /// Marker for completing all tests (used in `Result` types). | |
| #[derive(Clone, Debug)] | |
| struct FinishedAll; | |
| /// Reasons for exiting early. | |
| #[derive(Clone, Debug)] | |
| enum EarlyExit { | |
| Timeout, | |
| MaxFailures, | |
| } | |
| /// Run all tests in `tests`. | |
| /// | |
| /// 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) -> Duration { | |
| // Run shorter tests and smaller float types first. | |
| tests.sort_unstable_by_key(|test| (test.total_tests, test.float_bits)); | |
| for test in tests.iter() { | |
| println!("Launching test '{}'", test.name); | |
| } | |
| let mut all_progress_bars = Vec::new(); | |
| let start = Instant::now(); | |
| for test in tests.iter_mut() { | |
| test.progress = Some(ui::Progress::new(test, &mut all_progress_bars)); | |
| ui::set_panic_hook(&all_progress_bars); | |
| (test.launch)(test, cfg); | |
| } | |
| start.elapsed() | |
| } | |
| /// Test runer for a single generator. | |
| /// | |
| /// This calls the generator's iterator multiple times (in parallel) and validates each output. | |
| fn test_runner<F: Float, G: Generator<F>>(test: &TestInfo, cfg: &Config) { | |
| let gen_ = G::new(); | |
| let executed = AtomicU64::new(0); | |
| let failures = AtomicU64::new(0); | |
| let checks_per_update = min(test.total_tests, 1000); | |
| let started = Instant::now(); | |
| // Function to execute for a single test iteration. | |
| let check_one = |buf: &mut String, ctx: G::WriteCtx| { | |
| let executed = executed.fetch_add(1, Ordering::Relaxed); | |
| buf.clear(); | |
| G::write_string(buf, ctx); | |
| match validate::validate::<F>(buf) { | |
| Ok(()) => (), | |
| Err(e) => { | |
| let CheckError { fail, input, float_res } = e; | |
| test.progress.as_ref().unwrap().println(&format!( | |
| "Failure in '{}': {fail}. parsing '{input}'. Parsed as: {float_res}", | |
| test.name | |
| )); | |
| let f = failures.fetch_add(1, Ordering::Relaxed); | |
| // End early if the limit is exceeded. | |
| if f >= cfg.max_failures { | |
| return Err(EarlyExit::MaxFailures); | |
| } | |
| } | |
| }; | |
| // Send periodic updates | |
| if executed % checks_per_update == 0 { | |
| let failures = failures.load(Ordering::Relaxed); | |
| test.progress.as_ref().unwrap().update(executed, failures); | |
| if started.elapsed() > cfg.timeout { | |
| return Err(EarlyExit::Timeout); | |
| } | |
| } | |
| Ok(()) | |
| }; | |
| // Run the test iterations in parallel. Each thread gets a string buffer to write | |
| // its check values to. | |
| let res = gen_.par_bridge().try_for_each_init(String::new, check_one); | |
| let elapsed = started.elapsed(); | |
| let executed = executed.into_inner(); | |
| let failures = failures.into_inner(); | |
| // Warn about bad estimates if relevant. | |
| let warning = if executed != test.total_tests && res.is_ok() { | |
| let msg = format!( | |
| "executed tests != estimated ({executed} != {}) for {}", | |
| test.total_tests, | |
| G::NAME | |
| ); | |
| Some(msg.into()) | |
| } else { | |
| None | |
| }; | |
| let result = res.map(|()| FinishedAll); | |
| test.complete(Completed { executed, failures, result, warning, elapsed }); | |
| } |