use std::process;
use crate::env_keys;
#[derive(Debug, Clone, Copy)]
pub enum ToleranceMode {
Absolute,
Relative,
AbsOrRel,
UpperBound,
LowerBound,
}
impl std::fmt::Display for ToleranceMode {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Absolute => write!(f, "abs"),
Self::Relative => write!(f, "rel"),
Self::AbsOrRel => write!(f, "abs|rel"),
Self::UpperBound => write!(f, "<"),
Self::LowerBound => write!(f, ">"),
}
}
}
#[derive(Debug, Clone)]
pub struct Check {
pub label: String,
pub passed: bool,
pub observed: f64,
pub expected: f64,
pub tolerance: f64,
pub rel_tolerance: Option<f64>,
pub mode: ToleranceMode,
}
#[derive(Debug, Default)]
pub struct ValidationHarness {
pub name: String,
pub checks: Vec<Check>,
}
impl ValidationHarness {
#[must_use]
pub fn new(name: &str) -> Self {
Self {
name: name.to_string(),
checks: Vec::new(),
}
}
pub fn check_abs(&mut self, label: &str, observed: f64, expected: f64, tolerance: f64) {
let passed = (observed - expected).abs() < tolerance;
self.checks.push(Check {
label: label.to_string(),
passed,
observed,
expected,
tolerance,
rel_tolerance: None,
mode: ToleranceMode::Absolute,
});
}
pub fn check_rel(&mut self, label: &str, observed: f64, expected: f64, tolerance: f64) {
let passed = if expected.abs() > f64::EPSILON {
((observed - expected) / expected).abs() < tolerance
} else {
observed.abs() < tolerance
};
self.checks.push(Check {
label: label.to_string(),
passed,
observed,
expected,
tolerance,
rel_tolerance: None,
mode: ToleranceMode::Relative,
});
}
pub fn check_relative(&mut self, label: &str, computed: f64, expected: f64, rel_tol: f64) {
let abs_diff = (computed - expected).abs();
let rel_err = if expected.abs() > 1e-15 {
abs_diff / expected.abs()
} else {
abs_diff
};
let passed = rel_err <= rel_tol;
self.checks.push(Check {
label: label.to_string(),
passed,
observed: computed,
expected,
tolerance: rel_tol,
rel_tolerance: None,
mode: ToleranceMode::Relative,
});
}
pub fn check_abs_or_rel(
&mut self,
label: &str,
computed: f64,
expected: f64,
abs_tol: f64,
rel_tol: f64,
) {
let abs_diff = (computed - expected).abs();
let abs_ok = abs_diff <= abs_tol;
let rel_err = if expected.abs() > 1e-15 {
abs_diff / expected.abs()
} else {
abs_diff
};
let rel_ok = rel_err <= rel_tol;
let passed = abs_ok || rel_ok;
self.checks.push(Check {
label: label.to_string(),
passed,
observed: computed,
expected,
tolerance: abs_tol,
rel_tolerance: Some(rel_tol),
mode: ToleranceMode::AbsOrRel,
});
}
pub fn check_upper(&mut self, label: &str, observed: f64, threshold: f64) {
self.checks.push(Check {
label: label.to_string(),
passed: observed < threshold,
observed,
expected: threshold,
tolerance: threshold,
rel_tolerance: None,
mode: ToleranceMode::UpperBound,
});
}
pub fn check_lower(&mut self, label: &str, observed: f64, threshold: f64) {
self.checks.push(Check {
label: label.to_string(),
passed: observed > threshold,
observed,
expected: threshold,
tolerance: threshold,
rel_tolerance: None,
mode: ToleranceMode::LowerBound,
});
}
pub fn check_bool(&mut self, label: &str, passed: bool) {
self.checks.push(Check {
label: label.to_string(),
passed,
observed: f64::from(u8::from(passed)),
expected: 1.0,
tolerance: 0.0,
rel_tolerance: None,
mode: ToleranceMode::Absolute,
});
}
pub fn require<T, E: std::fmt::Display>(
&mut self,
label: &str,
result: Result<T, E>,
) -> Option<T> {
match result {
Ok(v) => Some(v),
Err(e) => {
self.check_bool(&format!("{label}: {e}"), false);
None
}
}
}
#[must_use]
pub fn passed_count(&self) -> usize {
self.checks.iter().filter(|c| c.passed).count()
}
#[must_use]
pub fn total_count(&self) -> usize {
self.checks.len()
}
#[must_use]
pub fn all_passed(&self) -> bool {
self.checks.iter().all(|c| c.passed)
}
pub fn finish(&self) -> ! {
tracing::info!("");
for check in &self.checks {
let icon = if check.passed { "PASS" } else { "FAIL" };
if let Some(rel_tol) = check.rel_tolerance {
tracing::info!(
"[{icon}] {}: observed={:.10e}, expected={:.10e}, abs_tol={:.2e}, rel_tol={:.2e} ({})",
check.label,
check.observed,
check.expected,
check.tolerance,
rel_tol,
check.mode
);
} else {
tracing::info!(
"[{icon}] {}: observed={:.10e}, expected={:.10e}, tol={:.2e} ({})",
check.label,
check.observed,
check.expected,
check.tolerance,
check.mode
);
}
}
tracing::info!("");
tracing::info!(
"=== {}: {}/{} PASS, {} FAIL ===",
self.name,
self.passed_count(),
self.total_count(),
self.total_count() - self.passed_count(),
);
if self.all_passed() {
process::exit(0);
} else {
let failed: Vec<&str> = self
.checks
.iter()
.filter(|c| !c.passed)
.map(|c| c.label.as_str())
.collect();
tracing::info!("FAILED: {}", failed.join(", "));
process::exit(1);
}
}
}
#[must_use]
fn parse_gpu_required(val: Option<&str>) -> bool {
val.is_some_and(|v| v == "1" || v.eq_ignore_ascii_case("true"))
}
#[must_use]
pub fn gpu_required() -> bool {
parse_gpu_required(
std::env::var(env_keys::BARRACUDA_REQUIRE_GPU)
.ok()
.as_deref(),
)
}
pub fn exit_no_gpu() -> ! {
if gpu_required() {
tracing::error!("FAIL: no GPU adapter (BARRACUDA_REQUIRE_GPU=1)");
process::exit(1);
}
tracing::info!("0/0 checks — skipping gracefully (no GPU adapter)");
process::exit(0);
}
#[macro_export]
macro_rules! require {
($harness:expr, $result:expr, $label:expr) => {
match $result {
Ok(v) => v,
Err(e) => {
$harness.check_bool(&format!("{}: {}", $label, e), false);
return;
}
}
};
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn harness_tracks_pass_fail() {
let mut h = ValidationHarness::new("test");
h.check_abs("good", 1.0, 1.0, 0.01);
h.check_abs("bad", 1.0, 2.0, 0.01);
assert_eq!(h.passed_count(), 1);
assert_eq!(h.total_count(), 2);
assert!(!h.all_passed());
}
#[test]
fn harness_all_pass() {
let mut h = ValidationHarness::new("test");
h.check_abs("a", 1.0, 1.0, 0.01);
h.check_rel("b", 100.0, 100.0, 0.01);
h.check_bool("c", true);
assert!(h.all_passed());
}
#[test]
fn harness_bounds() {
let mut h = ValidationHarness::new("test");
h.check_upper("upper ok", 0.5, 1.0);
h.check_upper("upper fail", 1.5, 1.0);
h.check_lower("lower ok", 1.5, 1.0);
h.check_lower("lower fail", 0.5, 1.0);
assert_eq!(h.passed_count(), 2);
}
#[test]
fn harness_require_success() {
let mut h = ValidationHarness::new("test");
let val: Result<i32, String> = Ok(42);
let result = h.require("op", val);
assert_eq!(result, Some(42));
assert!(h.all_passed());
}
#[test]
fn harness_require_failure() {
let mut h = ValidationHarness::new("test");
let val: Result<i32, String> = Err("boom".into());
let result = h.require("op", val);
assert_eq!(result, None);
assert!(!h.all_passed());
}
#[test]
fn gpu_required_default_false() {
assert!(!parse_gpu_required(None));
}
#[test]
fn test_tolerance_mode_display() {
assert_eq!(ToleranceMode::Absolute.to_string(), "abs");
assert_eq!(ToleranceMode::Relative.to_string(), "rel");
assert_eq!(ToleranceMode::AbsOrRel.to_string(), "abs|rel");
assert_eq!(ToleranceMode::UpperBound.to_string(), "<");
assert_eq!(ToleranceMode::LowerBound.to_string(), ">");
}
#[test]
fn check_relative_pass_and_fail() {
let mut h = ValidationHarness::new("test");
h.check_relative("close", 1.005, 1.0, 0.01);
h.check_relative("far", 1.5, 1.0, 0.01);
assert_eq!(h.passed_count(), 1);
assert_eq!(h.total_count(), 2);
assert!(h.checks[0].passed);
assert!(!h.checks[1].passed);
}
#[test]
fn check_relative_near_zero_expected() {
let mut h = ValidationHarness::new("test");
h.check_relative("near_zero", 1e-16, 0.0, 1e-10);
assert!(h.checks[0].passed);
}
#[test]
fn check_abs_or_rel_pass_via_absolute() {
let mut h = ValidationHarness::new("test");
h.check_abs_or_rel("abs_wins", 100.001, 100.0, 0.01, 1e-10);
assert!(h.checks[0].passed);
}
#[test]
fn check_abs_or_rel_pass_via_relative() {
let mut h = ValidationHarness::new("test");
h.check_abs_or_rel("rel_wins", 1000.5, 1000.0, 0.001, 0.001);
assert!(h.checks[0].passed);
}
#[test]
fn check_abs_or_rel_fail_both() {
let mut h = ValidationHarness::new("test");
h.check_abs_or_rel("both_fail", 2.0, 1.0, 0.01, 0.01);
assert!(!h.checks[0].passed);
}
#[test]
fn test_check_rel_with_zero_expected() {
let mut h = ValidationHarness::new("test");
h.check_rel("zero_expected_pass", 0.0001, 0.0, 0.01);
h.check_rel("zero_expected_fail", 1.0, 0.0, 0.01);
assert!(h.checks[0].passed);
assert!(!h.checks[1].passed);
}
#[test]
fn test_empty_harness() {
let h = ValidationHarness::new("empty");
assert!(h.all_passed());
assert_eq!(h.passed_count(), 0);
assert_eq!(h.total_count(), 0);
}
#[test]
fn test_check_bool_false() {
let mut h = ValidationHarness::new("test");
h.check_bool("x", false);
assert_eq!(h.passed_count(), 0);
assert_eq!(h.total_count(), 1);
assert!(!h.all_passed());
}
#[test]
fn test_gpu_required_when_set_to_1() {
assert!(parse_gpu_required(Some("1")));
}
#[test]
fn test_gpu_required_when_set_to_true() {
assert!(parse_gpu_required(Some("true")));
}
#[test]
fn test_gpu_required_case_insensitive() {
assert!(parse_gpu_required(Some("TRUE")));
}
#[test]
fn test_gpu_required_false_when_other_value() {
assert!(!parse_gpu_required(Some("0")));
}
}