//! Equality tests for the render/General cleanup: output over a large grid of format codes x //! values (format_value and text_function in both date systems, then General at widths 1..=30 and a few larger ones) //! is compared with golden digests recorded from the implementation BEFORE the cleanup //! (`tests/golden/*.txt`, one FNV-1a digest per format code / per value, so the files stay //! small). A failure names the code or value that differs; set `NUMFMT_DUMP_DIR` to write the //! full text of the current output for diffing against a dump from the old code. To re-record //! after an intended behaviour change run with `NUMFMT_BLESS=1`. #![allow(clippy::approx_constant, clippy::excessive_precision)] // values are test data, not constants use std::fmt::Write as _; use gridcraft_core::{DateSystem, Value}; use gridcraft_numfmt::{NumberFormat, format_general_fit, format_value, text_function}; // Placeholders far beyond the 15 significant digits. const LONG_DECIMALS: &str = "0.0000000000000000000000000"; #[rustfmt::skip] const CODES: &[&str] = &[ LONG_DECIMALS, "#,###,###,###,###,###,###,###,##0.00", "0.0000000000000000000000000E+00", "# ?????/?????", // numbers "General", "0", "0.00", "#,##0", "#,##0.00", "#.##", "0.0##", "00000", "000.000", "#,###", "#,##0,", "#,##0,,", "0.0,,\"M\"", "?.??", "##0.0", "# ", "#", ".00", ",0", "0,0", "0.00,", "\"$\"#,##0.00", "\"$\"#,##0_);\\(\"$\"#,##0\\)", "#,##0.00;[Red](#,##0.00)", "#,##0 ;(#,##0)", "0;-0;;@", "0.00;;", ";;;", "0_);(0)", "0\" units\"", "\\A0", "(0)", "00-00", "000-00-0000", "[<=9999999]###-####;(###) ###-####", "[$€-407]#,##0.00", // currency/accounting with fill "_(* #,##0_);_(* \\(#,##0\\);_(* \"-\"_);_(@_)", "_(\"$\"* #,##0.00_);_(\"$\"* \\(#,##0.00\\);_(\"$\"* \"-\"??_);_(@_)", "*-0", "0*x", "*0 0.0", "@*_", // percent "0%", "0.00%", "#,##0%", "0.0%%", "%0", "0%;[Red]-0%", // scientific "0.00E+00", "##0.0E+0", "0E+0", "0.0e-0", "0.00E+000", "E+0", "0.00E+", "#.##E+00", "0.0E+00 \"x\"", // fractions "# ?/?", "# ??/??", "# ???/???", "?/?", "# ?/8", "# ??/16", "0/0", "# #/#", "#/#", "?/100", "# ?/?;-# ?/?", "0 0/0", // dates/times "m/d/yyyy", "d-mmm-yy", "d-mmm", "mmm-yy", "h:mm AM/PM", "h:mm:ss AM/PM", "h:mm", "h:mm:ss", "m/d/yyyy h:mm", "mm:ss", "[h]:mm:ss", "[h]:mm", "[m]:ss", "[s]", "mmss.0", "yyyy-mm-dd", "dddd, mmmm d, yyyy", "ddd mmm dd yy", "mmmmm", "yy", "h:mm:ss.000", "h:mm:ss.0000", "hh:mm:ss A/P", "[hh]:mm:ss", "d", "dd", "dddd", "m", "mm", "s.00", "yyyy-mm-dd hh:mm:ss.00", "h AM/PM", "[$-409]d-mmm-yy", "yyyy\"年\"m\"月\"", "[h]\" hrs\"", "mmmm yyyy;@", // text sections, conditions, colours "@", "\"x\"@", "0;\"neg\"0;\"zero\";\"txt: \"@", "General;General;General;@", "[Red]0.0;[Blue]-0.0", "[Green]0;[Magenta]0;[Cyan]0;[Yellow]@", "[Color3]0.00", "[>100]\"big\"0;[<-100]\"small\"0;0.0", "[=0]\"zero\";0.0", "[>=1000]#,##0,\"K\";0", "[<1]0.00%;0.0", "[Red][>5]0;0.00", "General\" kg\"", "\"v\"General", "[Red]General", "0.0;[Red]General", // invalid / odd "[", "0.0.0", "0\"", "\\", "[h", "[$", "yyyy-mm-dd;", ";", "0;0;0;0;0", "\"abc", "[>x]0", "ggg", "#?#0", "0E", "E0", "/", "0/", "/0", "*", "_", "_0", "[Red", "0.00.00%", "mm:ss.0.0", "[ABC]0", "[=1]0;[=2]0;0", "0 ??/??;0", ]; fn values() -> Vec { let mut v = vec![ 0.0, -0.0, 1.0, -1.0, 0.5, -0.5, 0.25, 1.005, 2.675, 999.9995, 0.9995, 9.995, 99.5, 0.05, 0.005, 0.0005, 1e-5, 1e-10, 1e-300, 5e-324, 123456789.0, 1234.5678, 12345678901.0, 1e11, 1e15, 123456789012345.0, 1234567890123455.0, 1e20, 1e100, 1.7976931348623157e308, -1234.5, -0.004, -1e-10, 1.0 / 3.0, 2.0 / 3.0, 0.1 + 0.2, 100.0, 1000.0, 59.0, 60.0, 61.0, 36526.0, 36526.75, 43831.5, 45000.123456, 2958465.0, 2958465.999999, 2958466.0, -5.0, 0.99999999, 0.000999, 41.99999999999, f64::NAN, f64::INFINITY, f64::NEG_INFINITY, 0.041666666666666664, 0.9999999999, 1.0000000001, 12.3456789, 3.14159265358979, 65535.0, 1e5, 123456.0, 4.5, 0.375, 1e300, 1.5e-8, 999999999999999.0, 99999999999999.99, 0.00001234, 123456789012345678.0, 1e22, 9.999999999999999e22, 0.1234567890123456, ]; v.push(61.2 / 86400.0); v } fn fmt_formatted(f: &gridcraft_numfmt::Formatted) -> String { format!("{:?}|{:?}|{:?}|{}", f.text, f.color, f.fill, f.numeric) } fn dump_codes() -> Vec<(String, String)> { assert!(CODES.len() >= 80 && values().len() >= 40); let mut rows = Vec::new(); let others = [Value::Text("abc".into()), Value::Text("12.5".into()), Value::Bool(true), Value::Empty]; for code in CODES { let mut out = String::new(); let nf = NumberFormat::parse(code); let systems: &[(DateSystem, &str)] = if nf.is_date() { &[(DateSystem::D1900, "1900"), (DateSystem::D1904, "1904")] } else { &[(DateSystem::D1900, "1900")] }; for (sys, name) in systems { for n in values() { let v = Value::Number(n); let _ = writeln!(out, "{code:?} {name} {n:e} => {} || {:?}", fmt_formatted(&format_value(&v, &nf, *sys)), text_function(&v, code, *sys)); } } for v in &others { let _ = writeln!( out, "{code:?} {v:?} => {} || {:?}", fmt_formatted(&format_value(v, &nf, DateSystem::D1900)), text_function(v, code, DateSystem::D1900) ); } rows.push((format!("{code:?}"), out)); } rows } fn dump_general() -> Vec<(String, String)> { let mut vals = values(); let mut x = 0.7f64; // Deterministic spread over many magnitudes and digit patterns (no RNG dependency). for i in 0..240 { x = (x * 997.0 + 0.123_456_789).fract() + 1e-3; let e = (i % 41) - 20; let m = x * 10f64.powi(e); vals.push(if i % 3 == 0 { -m } else { m }); vals.push((m * 1000.0).round() / 1000.0); } assert!(vals.len() >= 300); let mut rows = Vec::new(); for n in vals { let mut out = String::new(); let _ = write!(out, "{n:e} =>"); for w in (1..=30usize).chain([31, 40, 100, 399, 400, 401, 500, 1000]) { let _ = write!(out, " {:?}", format_general_fit(n, w)); } out.push('\n'); rows.push((format!("{n:e}"), out)); } rows } fn fnv1a(s: &str) -> u64 { s.bytes().fold(0xcbf2_9ce4_8422_2325, |h, b| (h ^ u64::from(b)).wrapping_mul(0x100_0000_01b3)) } fn check(name: &str, rows: &[(String, String)], golden: &str, path: &str) { if let Some(dir) = std::env::var_os("NUMFMT_DUMP_DIR") { let all: String = rows.iter().map(|(_, b)| b.as_str()).collect(); std::fs::write(std::path::Path::new(&dir).join(format!("{name}.txt")), all).expect("write dump"); } let actual: String = rows.iter().map(|(k, b)| format!("{:016x} {} {k}\n", fnv1a(b), b.lines().count())).collect(); if std::env::var_os("NUMFMT_BLESS").is_some() { std::fs::write(path, &actual).expect("write golden"); return; } let bad: Vec = rows .iter() .zip(actual.lines().zip(golden.lines())) .filter(|(_, (a, g))| a != g) .take(3) .map(|((_, body), (a, g))| { format!(" new: {a}\n old: {g}\n new output of that row (first 12 lines):\n{}", body.lines().take(12).collect::>().join("\n")) }) .collect(); assert!( actual.lines().count() == golden.lines().count() && bad.is_empty(), "{name}: output differs from the recorded golden ({} vs {} rows). If the change is intended, re-record with\n NUMFMT_BLESS=1 cargo test -p gridcraft-numfmt --test render_equality\n{}", actual.lines().count(), golden.lines().count(), bad.join("\n") ); } #[test] fn format_value_and_text_function_match_golden() { check("codes", &dump_codes(), include_str!("golden/codes.txt"), concat!(env!("CARGO_MANIFEST_DIR"), "/tests/golden/codes.txt")); } #[test] fn general_fit_matches_golden() { check("general", &dump_general(), include_str!("golden/general.txt"), concat!(env!("CARGO_MANIFEST_DIR"), "/tests/golden/general.txt")); }