add tests for low-pass-filter

Author: gregcusack

low-pass-filter/src/lib.rs

@@ -19,6 +19,7 @@ pub mod api {
     // 2 * pi * SCALE
     const TWO_PI_SCALED: u64 = 6_283_185;
 
+    #[derive(Clone)]
     pub struct FilterConfig {
         pub output_range: std::ops::Range<u64>,
         pub k: u64,
@@ -71,6 +72,8 @@ pub mod api {
 
     /// Approximates `base^alpha` rounded to nearest integer using
     /// integer-only linear interpolation between `base^1` and `base^2`.
+    ///
+    /// Note: This function is most accurate when `base` is small e.g. < ~25.
     #[inline]
     pub fn interpolate(base: u64, t: u64) -> u64 {
         let scale = SCALE.get();
@@ -84,4 +87,272 @@ pub mod api {
     }
 }
 
-//TODO: greg: add tests for this file
+#[cfg(test)]
+mod tests {
+    use super::api::*;
+
+    #[test]
+    fn test_compute_k_zero_tc() {
+        // When time constant is 0, K should be 0
+        assert_eq!(compute_k(100, 0), 0);
+        assert_eq!(compute_k(1000, 0), 0);
+        assert_eq!(compute_k(u64::MAX, 0), 0);
+    }
+
+    #[test]
+    fn test_compute_k_zero_fs() {
+        // When sample frequency is 0, K should be 0
+        assert_eq!(compute_k(0, 100), 0);
+        assert_eq!(compute_k(0, 1000), 0);
+        assert_eq!(compute_k(0, u64::MAX), 0);
+    }
+
+    #[test]
+    fn test_compute_k_large_values() {
+        // K should never exceed SCALE
+        let k = compute_k(u64::MAX, 1);
+        assert!(k <= SCALE.get());
+
+        let k = compute_k(1000000, 1);
+        assert!(k <= SCALE.get());
+
+        let k = compute_k(u64::MAX / 2, u64::MAX / 4);
+        assert!(k <= SCALE.get());
+
+        let k = compute_k(500000000, 1000000000);
+        assert!(k <= SCALE.get());
+    }
+
+    #[test]
+    fn test_compute_k_normal_cases() {
+        // Test some normal cases
+        let k1 = compute_k(100, 1000);
+        assert_eq!(k1, 385869);
+
+        let k2 = compute_k(1000, 100);
+        assert_eq!(k2, 984333);
+        assert!(k2 > k1);
+
+        let k3 = compute_k(1000, 1000);
+        assert_eq!(k3, 862697);
+    }
+
+    #[test]
+    fn test_filter_alpha_k_zero() {
+        // When K=0, output should equal previous value
+        let config = FilterConfig {
+            output_range: 0..1000000,
+            k: 0,
+        };
+
+        assert_eq!(filter_alpha(100, 500, config.clone()), 100);
+        assert_eq!(filter_alpha(0, 1000000, config.clone()), 0);
+        assert_eq!(filter_alpha(999999, 0, config), 999999);
+    }
+
+    #[test]
+    fn test_filter_alpha_k_max() {
+        // When K=SCALE, output should equal target value (clamped to range)
+        let config = FilterConfig {
+            output_range: 0..1000000,
+            k: SCALE.get(),
+        };
+
+        assert_eq!(filter_alpha(100, 500, config.clone()), 500);
+        assert_eq!(filter_alpha(0, 1000000, config), 1000000);
+
+        // Test clamping - target outside range
+        let config = FilterConfig {
+            output_range: 100..900,
+            k: SCALE.get(),
+        };
+        assert_eq!(filter_alpha(200, 50, config.clone()), 100);
+        assert_eq!(filter_alpha(200, 1000, config), 900);
+    }
+
+    #[test]
+    fn test_filter_alpha_clamping() {
+        // Test output range clamping
+        let config = FilterConfig {
+            output_range: 100..900,
+            k: SCALE.get() / 2,
+        };
+
+        // Result would be (500000 * 50 + 500000 * 950) / 1000000 = 500
+        // This should be within range
+        let result = filter_alpha(950, 50, config);
+        assert_eq!(result, 500);
+
+        // Test extreme clamping
+        let config_narrow = FilterConfig {
+            output_range: 500..501,
+            k: SCALE.get() / 4,
+        };
+        let result = filter_alpha(0, 1000000, config_narrow);
+        assert_eq!(result, 501);
+    }
+
+    #[test]
+    fn test_filter_alpha_overflow_protection() {
+        // Test with large values that might cause overflow
+        let config = FilterConfig {
+            output_range: 0..u64::MAX,
+            k: SCALE.get() / 2,
+        };
+
+        let result = filter_alpha(u64::MAX / 2, u64::MAX / 2, config.clone());
+        assert_eq!(result, 18446744073709);
+
+        let result2 = filter_alpha(u64::MAX - 1000, u64::MAX - 2000, config);
+        assert_eq!(result2, 18446744073709);
+    }
+
+    #[test]
+    fn test_filter_alpha_mathematical_correctness() {
+        // Test the formula: (k * target + (scale - k) * prev) / scale
+        let config = FilterConfig {
+            output_range: 0..u64::MAX,
+            k: SCALE.get() / 4, // 25%
+        };
+
+        let prev = 800;
+        let target = 400;
+        let result = filter_alpha(prev, target, config);
+
+        assert_eq!(result, 700);
+
+        // Test with k at 60%
+        let config = FilterConfig {
+            output_range: 0..u64::MAX,
+            k: SCALE.get() * 60 / 100, // 60%
+        };
+
+        let prev = 111111;
+        let target = 222222;
+        let result = filter_alpha(prev, target, config);
+
+        assert_eq!(result, 177777);
+    }
+
+    #[test]
+    fn test_interpolate_t_zero() {
+        // When t=0, should return base
+        assert_eq!(interpolate(100, 0), 100);
+        assert_eq!(interpolate(0, 0), 0);
+        assert_eq!(interpolate(1000000, 0), 1000000);
+    }
+
+    #[test]
+    fn test_interpolate_t_max() {
+        // When t=SCALE, should return base^2
+        let base = 100;
+        let result = interpolate(base, SCALE.get());
+        assert_eq!(result, base * base);
+
+        let base2 = 1000;
+        let result = interpolate(base2, SCALE.get());
+        assert_eq!(result, base2 * base2);
+    }
+
+    #[test]
+    fn test_interpolate_values() {
+        let t_10 = SCALE.get() / 10; // 10%
+        let t_50 = SCALE.get() / 2; // 50%
+        let t_75 = SCALE.get() * 3 / 4; // 75%
+
+        let base = 3;
+        let result = interpolate(base, t_10);
+        assert_eq!(result, 4);
+
+        let result = interpolate(base, t_50);
+        assert_eq!(result, 6);
+
+        let result = interpolate(base, t_75);
+        assert_eq!(result, 8);
+
+        let base = 15;
+        let result = interpolate(base, t_10);
+        assert_eq!(result, 36);
+
+        let result = interpolate(base, t_50);
+        assert_eq!(result, 120);
+
+        let result = interpolate(base, t_75);
+        assert_eq!(result, 173);
+
+        let base = 24;
+        let result = interpolate(base, t_10);
+        assert_eq!(result, 79);
+
+        let result = interpolate(base, t_50);
+        assert_eq!(result, 300);
+
+        let result = interpolate(base, t_75);
+        assert_eq!(result, 438);
+    }
+
+    #[test]
+    fn test_interpolate_large_base() {
+        let base = 1000000000000000000;
+        let result = interpolate(base, SCALE.get() / 2);
+        assert!(result >= base);
+        assert!(result < base * base);
+    }
+
+    #[test]
+    fn test_interpolate_edge_cases() {
+        // Test with base = 1
+        assert_eq!(interpolate(1, 0), 1);
+        assert_eq!(interpolate(1, SCALE.get()), 1);
+        assert_eq!(interpolate(1, SCALE.get() / 2), 1);
+
+        // Test with base = 0
+        assert_eq!(interpolate(0, 0), 0);
+        assert_eq!(interpolate(0, SCALE.get()), 0);
+        assert_eq!(interpolate(0, SCALE.get() / 2), 0);
+    }
+
+    #[test]
+    fn test_interpolate_rounding() {
+        // Test rounding behavior with values that result in fractional parts
+        let base = 3;
+        let t = SCALE.get() / 3;
+        let result = interpolate(base, t);
+
+        assert!(result >= 3);
+        assert!(result <= 9);
+    }
+
+    #[test]
+    fn test_scale_constant() {
+        assert_eq!(SCALE.get(), 1_000_000);
+        assert!(SCALE.get() > 0);
+    }
+
+    #[test]
+    fn test_integration_filter_and_interpolate() {
+        // Test using filtered alpha with interpolate
+        // Alpha range is [SCALE, 2*SCALE] as used in push_active_set
+        let alpha_min = SCALE.get();
+        let alpha_max = 2 * SCALE.get();
+
+        let config = FilterConfig {
+            output_range: alpha_min..alpha_max,
+            k: SCALE.get() / 10, // 10%
+        };
+
+        let prev_alpha = alpha_min + SCALE.get() / 4; // 1.25 * SCALE
+        let target_alpha = alpha_min + SCALE.get() / 2; // 1.5 * SCALE
+        let filtered_alpha = filter_alpha(prev_alpha, target_alpha, config);
+
+        let t = filtered_alpha.saturating_sub(alpha_min);
+        let base = 2;
+        let result = interpolate(base, t);
+
+        assert!(result >= base);
+        assert!(result <= base * base);
+
+        assert!(filtered_alpha >= alpha_min);
+        assert!(filtered_alpha <= alpha_max);
+    }
+}