init

hcie-filter/tests/filters.rs

@@ -0,0 +1,131 @@
+#![allow(dead_code, unused_imports, unused_variables, unused_macros, unreachable_patterns)]
+use hcie_filter::Layer;
+
+fn make_test_layer() -> Layer {
+    let mut layer = Layer::new_transparent("test", 10, 10);
+    for y in 0..10 {
+        for x in 0..10 {
+            let v = ((x + y) * 25 % 256) as u8;
+            layer.set_pixel(x, y, [v, v, v, 255]);
+        }
+    }
+    layer
+}
+
+fn assert_pixels_match(a: &Layer, b: &Layer) {
+    assert_eq!(a.width, b.width);
+    assert_eq!(a.height, b.height);
+    assert_eq!(a.pixels, b.pixels);
+}
+
+#[test]
+fn test_blur_does_not_panic() {
+    let mut layer = make_test_layer();
+    hcie_filter::apply_filter(&mut layer, "box_blur", &serde_json::json!({"radius": 2}));
+    assert_eq!(layer.width, 10);
+    assert_eq!(layer.height, 10);
+}
+
+#[test]
+fn test_gaussian_blur_does_not_panic() {
+    let mut layer = make_test_layer();
+    hcie_filter::apply_filter(&mut layer, "gaussian_blur", &serde_json::json!({"radius": 2}));
+    assert_eq!(layer.width, 10);
+    assert_eq!(layer.height, 10);
+}
+
+#[test]
+fn test_motion_blur_does_not_panic() {
+    let mut layer = make_test_layer();
+    hcie_filter::apply_filter(&mut layer, "motion_blur", &serde_json::json!({"distance": 5, "angle": 45.0}));
+    assert_eq!(layer.width, 10);
+    assert_eq!(layer.height, 10);
+}
+
+#[test]
+fn test_invert_filter() {
+    let mut layer = make_test_layer();
+    let original_pixels = layer.pixels.clone();
+    hcie_filter::apply_filter(&mut layer, "invert", &serde_json::json!({}));
+    let any_changed = layer.pixels.iter().zip(&original_pixels).any(|(a, b)| a != b);
+    assert!(any_changed, "invert should change pixel values");
+}
+
+#[test]
+fn test_grayscale_filter() {
+    let mut layer = make_test_layer();
+    hcie_filter::apply_filter(&mut layer, "grayscale", &serde_json::json!({}));
+    for y in 0..10 {
+        for x in 0..10 {
+            let p = layer.get_pixel(x, y);
+            let diff_rg = (p[0] as i16 - p[1] as i16).abs();
+            let diff_rb = (p[0] as i16 - p[2] as i16).abs();
+            assert!(diff_rg <= 3 && diff_rb <= 3, "grayscale: r={}, g={}, b={}", p[0], p[1], p[2]);
+        }
+    }
+}
+
+#[test]
+fn test_filter_ids() {
+    let ids = hcie_filter::filter_ids();
+    assert!(!ids.is_empty(), "should have at least one filter");
+    let names: Vec<&str> = ids.iter().map(|(id, _)| *id).collect();
+    assert!(names.contains(&"invert"), "invert should be registered");
+    assert!(names.contains(&"box_blur"), "box_blur should be registered");
+}
+
+#[test]
+fn test_sharpen_does_not_panic() {
+    let mut layer = make_test_layer();
+    hcie_filter::apply_filter(&mut layer, "sharpen", &serde_json::json!({}));
+    assert_eq!(layer.width, 10);
+    assert_eq!(layer.height, 10);
+}
+
+#[test]
+fn test_unknown_filter_is_noop() {
+    let mut layer = make_test_layer();
+    let before = layer.pixels.clone();
+    hcie_filter::apply_filter(&mut layer, "nonexistent_filter", &serde_json::json!({}));
+    assert_eq!(layer.pixels, before, "unknown filter should be noop");
+}
+
+#[test]
+fn test_unsharp_mask_does_not_panic() {
+    let mut layer = make_test_layer();
+    hcie_filter::apply_filter(&mut layer, "unsharp_mask", &serde_json::json!({"radius": 2, "amount": 0.5}));
+    assert_eq!(layer.width, 10);
+    assert_eq!(layer.height, 10);
+}
+
+#[test]
+fn test_brightness_contrast() {
+    let mut layer = make_test_layer();
+    hcie_filter::apply_filter(&mut layer, "brightness_contrast", &serde_json::json!({"brightness": 0.2, "contrast": 0.5}));
+    let any_different = layer.pixels.iter().any(|&v| v != 0);
+    assert!(any_different, "brightness/contrast should produce valid output");
+}
+
+#[test]
+fn test_hue_saturation_does_not_panic() {
+    let mut layer = make_test_layer();
+    hcie_filter::apply_filter(&mut layer, "hue_saturation", &serde_json::json!({"hue_shift": 0.5, "saturation": 1.5, "lightness": 0.0}));
+    assert_eq!(layer.width, 10);
+    assert_eq!(layer.height, 10);
+}
+
+#[test]
+fn test_emboss_does_not_panic() {
+    let mut layer = make_test_layer();
+    hcie_filter::apply_filter(&mut layer, "emboss", &serde_json::json!({}));
+    assert_eq!(layer.width, 10);
+    assert_eq!(layer.height, 10);
+}
+
+#[test]
+fn test_find_edges_does_not_panic() {
+    let mut layer = make_test_layer();
+    hcie_filter::apply_filter(&mut layer, "find_edges", &serde_json::json!({}));
+    assert_eq!(layer.width, 10);
+    assert_eq!(layer.height, 10);
+}