assert_almost_eq!

Cargo.toml

@@ -2,7 +2,7 @@
 debug = true
 
 [workspace]
-members = ["jxl", "jxl_cli", "jxl_macros"]
+members = ["jxl", "jxl_cli", "jxl_macros", "jxl_test_utils"]
 resolver = "2"
 
 [workspace.lints.clippy]

jxl/Cargo.toml

@@ -15,6 +15,7 @@ array-init = "2.0.0"
 half = "1.7.1"
 tracing = { version = "0.1.40", optional = true }
 jxl_macros = { path = "../jxl_macros" }
+jxl_test_utils = {path = "../jxl_test_utils" }
 
 [dev-dependencies]
 arbtest = "0.3.1"

jxl/src/render/stages/upsample.rs

@@ -86,8 +86,10 @@ impl RenderPipelineStage for Upsample2x {
 
 #[cfg(test)]
 mod test {
+    //use jxl_test_utils::assert_almost_equal;
     use super::*;
     use crate::{error::Result, image::Image, render::test::make_and_run_simple_pipeline};
+    use jxl_test_utils::assert_almost_eq;
     use test_log::test;
 
     #[test]
@@ -112,7 +114,7 @@ mod test {
             make_and_run_simple_pipeline(stage, &[input], image_size, 123)?.1;
         for x in 0..image_size.0 {
             for y in 0..image_size.1 {
-                assert!((output[0].as_rect().row(y)[x] - val).abs() <= 0.0000001);
+                assert_almost_eq!(output[0].as_rect().row(y)[x], val, 0.0000001);
             }
         }
         Ok(())

jxl_test_utils/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "jxl_test_utils"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+
+[lints]
+workspace = true

jxl_test_utils/src/lib.rs

@@ -0,0 +1,64 @@
+// Copyright (c) the JPEG XL Project Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#[macro_export]
+macro_rules! assert_almost_eq {
+    ($left:expr, $right:expr, $max_error:expr $(,)?) => {
+        match (&$left, &$right, &$max_error) {
+            (left_val, right_val, max_error) => {
+                let diff = if *left_val > *right_val {
+                    *left_val - *right_val
+                } else {
+                    *right_val - *left_val
+                };
+                match diff.partial_cmp(max_error) {
+                    Some(std::cmp::Ordering::Greater) | None => panic!(
+                        "assertion failed: `(left ≈ right)`\n  left: `{:?}`,\n right: `{:?}`,\n max_error: `{:?}`",
+                        left_val, right_val, max_error
+                    ),
+                    _ => {}
+                }
+            }
+        }
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_with_floats() {
+        assert_almost_eq!(1.0000001f64, 1.0000002, 0.000001);
+        assert_almost_eq!(1.0, 1.1, 0.2);
+    }
+
+    #[test]
+    fn test_with_integers() {
+        assert_almost_eq!(100, 101, 2);
+        assert_almost_eq!(777u32, 770, 7);
+        assert_almost_eq!(500i64, 498, 3);
+    }
+
+    #[test]
+    fn test_panic() {
+        use std::panic;
+        let result = panic::catch_unwind(|| {
+            assert_almost_eq!(1.0, 1.2, 0.1);
+        });
+        assert!(
+            result.is_err(),
+            "Expected assert_almost_eq! to panic, but it didn't"
+        );
+
+        let result = panic::catch_unwind(|| {
+            assert_almost_eq!(100, 105, 2);
+        });
+        assert!(
+            result.is_err(),
+            "Expected assert_almost_eq! to panic, but it didn't"
+        );
+    }
+}