hcie-rust-v3.05/hcie-composite/tests/visibility.rs

use hcie_composite::composite_layers;
use hcie_protocol::{BlendMode, Layer};

fn count_opaque_pixels(pixels: &[u8]) -> usize {
    pixels.iter().skip(3).step_by(4).filter(|&&a| a > 0).count()
}

fn create_test_layer(name: &str, w: u32, h: u32, pixels: Vec<u8>) -> Layer {
    let mut l = Layer::from_rgba(name, w, h, pixels);
    l.blend_mode = BlendMode::Normal;
    l.visible = true;
    l.opacity = 1.0;
    l
}

#[test]
fn test_composite_visibility_toggle() {
    let w = 100u32;
    let h = 100u32;
    let px = (w * h * 4) as usize;

    // Layer 0: opaque white background
    let bg = create_test_layer("bg", w, h, vec![255u8; px]);

    // Layer 1: opaque black square
    let mut top_pixels = vec![0u8; px];
    for y in 20..80 {
        for x in 20..80 {
            let i = ((y * w + x) * 4) as usize;
            top_pixels[i] = 0;
            top_pixels[i + 1] = 0;
            top_pixels[i + 2] = 0;
            top_pixels[i + 3] = 255;
        }
    }
    let top = create_test_layer("top", w, h, top_pixels);

    let layers = vec![bg.clone(), top.clone()];

    // Test 1: both visible → 10000 opaque (white bg behind black square)
    let p = composite_layers(&layers, w, h);
    let opaque = count_opaque_pixels(&p);
    eprintln!("Test 1 (both visible): opaque={}/10000", opaque);
    assert_eq!(opaque, 10000, "all pixels should be opaque");

    // Test 2: hide background → only black square visible (3600 px)
    let mut bg_hidden = bg.clone();
    bg_hidden.visible = false;
    let layers = vec![bg_hidden, top.clone()];
    let p = composite_layers(&layers, w, h);
    let opaque = count_opaque_pixels(&p);
    eprintln!(
        "Test 2 (bg hidden): opaque={}/10000 (expected 3600)",
        opaque
    );
    assert_eq!(opaque, 3600, "only black square should be visible");

    // Test 3: hide top → only white background visible
    let mut top_hidden = top.clone();
    top_hidden.visible = false;
    let layers = vec![bg.clone(), top_hidden];
    let p = composite_layers(&layers, w, h);
    let opaque = count_opaque_pixels(&p);
    eprintln!(
        "Test 3 (top hidden): opaque={}/10000 (expected 10000)",
        opaque
    );
    assert_eq!(opaque, 10000, "white background should be visible");

    // Test 4: hide both → fully transparent
    let mut bg_h = bg.clone();
    bg_h.visible = false;
    let mut top_h = top.clone();
    top_h.visible = false;
    let layers = vec![bg_h, top_h];
    let p = composite_layers(&layers, w, h);
    let opaque = count_opaque_pixels(&p);
    eprintln!("Test 4 (both hidden): opaque={}/10000 (expected 0)", opaque);
    assert_eq!(opaque, 0, "should be fully transparent");
}