Chrivers/unit test improvements

Cargo.toml

@@ -43,10 +43,14 @@ members = [
 ]
 
 [workspace.lints.rust]
+# NOTE: to use llvm-cov, comment out the "unstable_features" restriction:
 unstable_features = "forbid"
 unused_lifetimes = "warn"
 unused_qualifications = "warn"
 
+# Needed for llvm-cov
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(coverage,coverage_nightly)'] }
+
 [workspace.lints.clippy]
 all         = { level = "warn", priority = -1 }
 correctness = { level = "warn", priority = -1 }

crates/hue/Cargo.toml

@@ -29,6 +29,7 @@ thiserror = "2.0.11"
 uuid = { version = "1.13.1", features = ["serde", "v5"] }
 
 mac_address = { version = "1.1.8", features = ["serde"], optional = true }
+maplit = "1.0.2"
 
 [features]
 default = ["event", "mac", "rng"]

crates/hue/src/clamp.rs

@@ -7,12 +7,12 @@ pub trait Clamp {
 impl Clamp for f32 {
     #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
     fn unit_to_u8_clamped(self) -> u8 {
-        (self * 255.0).clamp(0.0, 255.0) as u8
+        (self * 255.0).round().clamp(0.0, 255.0) as u8
     }
 
     #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
     fn unit_to_u8_clamped_light(self) -> u8 {
-        self.mul_add(253.0, 1.0).clamp(1.0, 254.0) as u8
+        self.mul_add(253.0, 1.0).round().clamp(1.0, 254.0) as u8
     }
 
     fn unit_from_u8(value: u8) -> Self {
@@ -23,15 +23,75 @@ impl Clamp for f32 {
 impl Clamp for f64 {
     #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
     fn unit_to_u8_clamped(self) -> u8 {
-        (self * 255.0).clamp(0.0, 255.0) as u8
+        (self * 255.0).round().clamp(0.0, 255.0) as u8
     }
 
     #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
     fn unit_to_u8_clamped_light(self) -> u8 {
-        self.mul_add(253.0, 1.0).clamp(1.0, 254.0) as u8
+        self.mul_add(253.0, 1.0).round().clamp(1.0, 254.0) as u8
     }
 
     fn unit_from_u8(value: u8) -> Self {
         Self::from(value) / 255.0
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::clamp::Clamp;
+    use crate::{compare, compare_float};
+
+    #[test]
+    fn f32_unit_to_u8_clamped() {
+        assert_eq!((-1.0f32).unit_to_u8_clamped(), 0x00);
+        assert_eq!(0.0f32.unit_to_u8_clamped(), 0x00);
+        assert_eq!(0.5f32.unit_to_u8_clamped(), 0x80);
+        assert_eq!(1.0f32.unit_to_u8_clamped(), 0xFF);
+        assert_eq!(2.0f32.unit_to_u8_clamped(), 0xFF);
+    }
+
+    #[test]
+    fn f64_unit_to_u8_clamped() {
+        assert_eq!((-1.0f64).unit_to_u8_clamped(), 0x00);
+        assert_eq!(0.0f64.unit_to_u8_clamped(), 0x00);
+        assert_eq!(0.5f64.unit_to_u8_clamped(), 0x80);
+        assert_eq!(1.0f64.unit_to_u8_clamped(), 0xFF);
+        assert_eq!(2.0f64.unit_to_u8_clamped(), 0xFF);
+    }
+
+    #[test]
+    fn f32_unit_to_u8_clamped_light() {
+        assert_eq!((-1.0f32).unit_to_u8_clamped_light(), 0x01);
+        assert_eq!(0.0f32.unit_to_u8_clamped_light(), 0x01);
+        assert_eq!(0.5f32.unit_to_u8_clamped_light(), 0x80);
+        assert_eq!(1.0f32.unit_to_u8_clamped_light(), 0xFE);
+        assert_eq!(2.0f32.unit_to_u8_clamped_light(), 0xFE);
+    }
+
+    #[test]
+    fn f64_unit_to_u8_clamped_light() {
+        assert_eq!((-1.0f64).unit_to_u8_clamped_light(), 0x01);
+        assert_eq!(0.0f64.unit_to_u8_clamped_light(), 0x01);
+        assert_eq!(0.5f64.unit_to_u8_clamped_light(), 0x80);
+        assert_eq!(1.0f64.unit_to_u8_clamped_light(), 0xFE);
+        assert_eq!(2.0f64.unit_to_u8_clamped_light(), 0xFE);
+    }
+
+    #[test]
+    fn f32_unit_from_u8() {
+        compare!(f32::unit_from_u8(0x00), 0.0 / 255.0);
+        compare!(f32::unit_from_u8(0x01), 1.0 / 255.0);
+        compare!(f32::unit_from_u8(0x02), 2.0 / 255.0);
+        compare!(f32::unit_from_u8(0xFE), 254.0 / 255.0);
+        compare!(f32::unit_from_u8(0xFF), 255.0 / 255.0);
+    }
+
+    #[test]
+    fn f64_unit_from_u8() {
+        compare!(f64::unit_from_u8(0x00), 0.0 / 255.0);
+        compare!(f64::unit_from_u8(0x01), 1.0 / 255.0);
+        compare!(f64::unit_from_u8(0x02), 2.0 / 255.0);
+        compare!(f64::unit_from_u8(0xFE), 254.0 / 255.0);
+        compare!(f64::unit_from_u8(0xFF), 255.0 / 255.0);
+    }
+}

crates/hue/src/colorspace.rs

@@ -52,7 +52,7 @@ impl Matrix3 {
             }
 
             // Divide the row by the diagonal term
-            let inv = 1.0 / d;
+            let inv = d.recip();
             for c in 0..3 {
                 current[[i, c]] *= inv;
                 inverse[[i, c]] *= inv;
@@ -215,16 +215,8 @@ pub const ADOBE: ColorSpace = ColorSpace {
 mod tests {
     use std::iter::zip;
 
-    use crate::colorspace::{ADOBE, ColorSpace, SRGB, WIDE};
-
-    macro_rules! compare {
-        ($expr:expr, $value:expr) => {
-            let a = $expr;
-            let b = $value;
-            eprintln!("{a} vs {b:.4}");
-            assert!((a - b).abs() < 1e-4);
-        };
-    }
+    use crate::colorspace::{ADOBE, ColorSpace, Matrix3, SRGB, WIDE};
+    use crate::{compare, compare_float, compare_matrix};
 
     fn verify_matrix(cs: &ColorSpace) {
         let xyz = &cs.xyz;
@@ -233,13 +225,8 @@ mod tests {
         let xyzi = xyz.inverted().unwrap();
         let rgbi = rgb.inverted().unwrap();
 
-        zip(xyz.0, rgbi.0).for_each(|(a, b)| {
-            compare!(a, b);
-        });
-
-        zip(rgb.0, xyzi.0).for_each(|(a, b)| {
-            compare!(a, b);
-        });
+        compare_matrix!(xyz.0, rgbi.0);
+        compare_matrix!(rgb.0, xyzi.0);
     }
 
     #[test]
@@ -256,4 +243,17 @@ mod tests {
     fn iverse_adobe() {
         verify_matrix(&ADOBE);
     }
+
+    #[test]
+    fn invert_identity() {
+        let ident = Matrix3::identity();
+        let inv = ident.inverted().unwrap();
+        compare_matrix!(ident.0, inv.0);
+    }
+
+    #[test]
+    fn invert_zero() {
+        let zero = Matrix3([0.0; 9]);
+        assert!(zero.inverted().is_none());
+    }
 }

crates/hue/src/colortemp.rs

@@ -51,24 +51,7 @@ pub fn cct_to_xy(cct: f64) -> XY {
 mod tests {
     use crate::colortemp::cct_to_xy;
     use crate::xy::XY;
-
-    macro_rules! compare {
-        ($expr:expr, $value:expr) => {
-            let a = $expr;
-            let b = $value;
-            eprintln!("{a} vs {b:.4}");
-            assert!((a - b).abs() < 1e-4);
-        };
-    }
-
-    macro_rules! compare_xy {
-        ($expr:expr, $value:expr) => {
-            let a = $expr;
-            let b = $value;
-            compare!(a.x, b.x);
-            compare!(a.y, b.y);
-        };
-    }
+    use crate::{compare, compare_float, compare_xy};
 
     // Regression tests, sanity checked against kelvin-to-blackbody raditation color
     // data found here:

crates/hue/src/date_format.rs

@@ -158,37 +158,167 @@ pub mod legacy_utc_opt {
     date_deserializer_utc_opt!(DateTime<Utc>, super::FORMAT_LOCAL);
 }
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 #[cfg(test)]
 mod tests {
-    use chrono::{DateTime, TimeZone, Utc};
+    use std::fmt::Debug;
+
+    use chrono::{DateTime, Local, NaiveDate, NaiveDateTime, NaiveTime, TimeZone, Utc};
+    use serde_json::de::StrRead;
 
     use crate::error::HueResult;
 
-    fn date() -> (&'static str, DateTime<Utc>) {
+    fn de<T: Debug + Eq>(
+        ds: &'static str,
+        d1: &T,
+        desi: impl Fn(&mut serde_json::Deserializer<StrRead>) -> serde_json::Result<T>,
+    ) -> HueResult<()> {
+        let mut deser = serde_json::Deserializer::from_str(ds);
+        let d2 = desi(&mut deser)?;
+
+        assert_eq!(*d1, d2);
+        Ok(())
+    }
+
+    fn se(
+        s1: &'static str,
+        seri: impl Fn(&mut serde_json::Serializer<&mut Vec<u8>>) -> serde_json::Result<()>,
+    ) -> HueResult<()> {
+        let mut s2 = vec![];
+        let mut ser = serde_json::Serializer::new(&mut s2);
+        seri(&mut ser)?;
+
+        eprintln!("{} vs {}", s1, s2.escape_ascii());
+        assert_eq!(s1.as_bytes(), s2);
+        Ok(())
+    }
+
+    fn date_utc() -> (&'static str, DateTime<Utc>) {
         let dt = Utc.with_ymd_and_hms(2014, 7, 8, 9, 10, 11).unwrap();
         ("\"2014-07-08T09:10:11Z\"", dt)
     }
 
     #[test]
     fn utc_de() -> HueResult<()> {
-        let (ds, d1) = date();
+        let (ds, d1) = date_utc();
+        de(ds, &d1, |de| super::utc::deserialize(de))
+    }
 
-        let mut deser = serde_json::Deserializer::from_str(ds);
-        let d2 = super::utc::deserialize(&mut deser)?;
+    #[test]
+    fn utc_se() -> HueResult<()> {
+        let (s1, dt) = date_utc();
+        se(s1, |ser| super::utc::serialize(&dt, ser))
+    }
 
-        assert_eq!(d1, d2);
-        Ok(())
+    fn date_utc_ms() -> (&'static str, DateTime<Utc>) {
+        let dt = Utc.with_ymd_and_hms(2014, 7, 8, 9, 10, 11).unwrap();
+        let dt = Utc
+            .timestamp_millis_opt(dt.timestamp_millis() + 123)
+            .unwrap();
+        ("\"2014-07-08T09:10:11.123Z\"", dt)
     }
 
     #[test]
-    fn utc_se() -> HueResult<()> {
-        let (s1, dt) = date();
+    fn utc_ms_de() -> HueResult<()> {
+        let (ds, d1) = date_utc_ms();
+        de(ds, &d1, |de| super::utc_ms::deserialize(de))
+    }
 
-        let mut s2 = vec![];
-        let mut ser = serde_json::Serializer::new(&mut s2);
-        super::utc::serialize(&dt, &mut ser)?;
+    #[test]
+    fn utc_ms_se() -> HueResult<()> {
+        let (s1, dt) = date_utc_ms();
+        se(s1, |ser| super::utc_ms::serialize(&dt, ser))
+    }
 
-        assert_eq!(s1.as_bytes(), s2);
-        Ok(())
+    #[test]
+    fn utc_ms_opt_de_some() -> HueResult<()> {
+        let (ds, d1) = date_utc_ms();
+        de(ds, &Some(d1), |de| super::utc_ms_opt::deserialize(de))
+    }
+
+    #[test]
+    fn utc_ms_opt_de_none() -> HueResult<()> {
+        de("null", &None, |de| super::utc_ms_opt::deserialize(de))
+    }
+
+    #[test]
+    fn utc_ms_opt_se_some() -> HueResult<()> {
+        let (s1, dt) = date_utc_ms();
+        se(s1, |ser| super::utc_ms_opt::serialize(&Some(dt), ser))
+    }
+
+    #[test]
+    fn utc_ms_opt_se_none() -> HueResult<()> {
+        se("null", |ser| super::utc_ms_opt::serialize(&None, ser))
+    }
+
+    fn date_legacy_naive() -> (&'static str, NaiveDateTime) {
+        let dt = NaiveDateTime::new(
+            NaiveDate::from_ymd_opt(2014, 7, 8).unwrap(),
+            NaiveTime::from_hms_opt(9, 10, 11).unwrap(),
+        );
+        ("\"2014-07-08T09:10:11\"", dt)
+    }
+
+    #[test]
+    fn legacy_naive_de() -> HueResult<()> {
+        let (ds, d1) = date_legacy_naive();
+        de(ds, &d1, |de| super::legacy_naive::deserialize(de))
+    }
+
+    #[test]
+    fn legacy_naive_se() -> HueResult<()> {
+        let (s1, dt) = date_legacy_naive();
+        se(s1, |ser| super::legacy_naive::serialize(&dt, ser))
+    }
+
+    fn date_legacy_local_opt() -> (&'static str, DateTime<Local>) {
+        let dt = Local.with_ymd_and_hms(2014, 7, 8, 9, 10, 11).unwrap();
+        ("\"2014-07-08T09:10:11\"", dt)
+    }
+
+    #[test]
+    fn legacy_local_opt_de_some() -> HueResult<()> {
+        let (ds, d1) = date_legacy_local_opt();
+        de(ds, &Some(d1), |de| super::legacy_local_opt::deserialize(de))
+    }
+
+    #[test]
+    fn legacy_local_opt_se_some() -> HueResult<()> {
+        let (s1, dt) = date_legacy_local_opt();
+        se(s1, |ser| super::legacy_local_opt::serialize(&Some(dt), ser))
+    }
+
+    #[test]
+    fn legacy_local_opt_de_none() -> HueResult<()> {
+        de("null", &None, |de| super::legacy_local_opt::deserialize(de))
+    }
+
+    #[test]
+    fn legacy_local_opt_se_none() -> HueResult<()> {
+        se("null", |ser| super::legacy_local_opt::serialize(&None, ser))
+    }
+
+    #[test]
+    fn update_utc_de() -> HueResult<()> {
+        let (ds, d1) = date_utc();
+        de(ds, &d1, |de| super::update_utc::deserialize(de))
+    }
+
+    fn date_legacy_utc() -> (&'static str, DateTime<Utc>) {
+        let dt = Utc.with_ymd_and_hms(2014, 7, 8, 9, 10, 11).unwrap();
+        ("\"2014-07-08T09:10:11\"", dt)
+    }
+
+    #[test]
+    fn legacy_utc_de() -> HueResult<()> {
+        let (ds, d1) = date_legacy_utc();
+        de(ds, &d1, |de| super::legacy_utc::deserialize(de))
+    }
+
+    #[test]
+    fn legacy_utc_se() -> HueResult<()> {
+        let (s1, dt) = date_legacy_utc();
+        se(s1, |ser| super::legacy_utc::serialize(&dt, ser))
     }
 }