phantom
b09795ccff
- Add `persistence.rs` for stable serialization of dock layouts without runtime identifiers. - Introduce `preview.rs` for geometry handling of dock drop previews. - Create `sizing.rs` to manage content-aware sizing policies and constraint solving for dock panels. - Implement `welcome.rs` to provide a welcome surface when no documents are open, featuring New and Open actions.
279 lines
8.8 KiB
Rust
279 lines
8.8 KiB
Rust
//! Golden Visual Regression Test Harness
|
|
//!
|
|
//! Purpose:
|
|
//! Port v3's deterministic golden hash concept to v4 through the public Engine API boundary.
|
|
//! These tests validate that Engine output remains deterministic and pixel-perfect across changes.
|
|
//!
|
|
//! Design:
|
|
//! - Uses only `hcie_engine_api::Engine` public API (no internal crate access)
|
|
//! - Creates deterministic canvases, layers, colors, vector shapes, brush strokes, filters
|
|
//! - Hashes `engine.get_composite_pixels()` with SHA-256
|
|
//! - Compares against inline golden hashes
|
|
//!
|
|
//! Regeneration:
|
|
//! Set `HCIE_REGEN_GOLDENS=1` to print computed hashes after test verification.
|
|
//!
|
|
//! Golden cases:
|
|
//! - white_canvas_empty_document: validates blank document/composite baseline
|
|
//! - green_rect_draw_and_composite: validates draw_filled_rect_rgba
|
|
//! - red_rect_over_green_rect: validates layer compositing order
|
|
//! - vector_rect_golden: validates vector rendering through Engine API
|
|
//! - brush_stroke_golden: validates brush engine + draw pipeline
|
|
//! - invert_filter_golden: validates filter pipeline and deterministic output
|
|
//! - undo_after_rect_golden: validates history snapshot and restoration
|
|
|
|
use hcie_engine_api::Engine;
|
|
use hcie_engine_api::{BrushStyle, BrushTip, VectorShape};
|
|
use sha2::{Digest, Sha256};
|
|
|
|
/// Compute SHA-256 hash of pixel buffer for golden comparison.
|
|
fn hash_pixels(pixels: &[u8]) -> String {
|
|
let mut hasher = Sha256::new();
|
|
hasher.update(pixels);
|
|
format!("{:x}", hasher.finalize())
|
|
}
|
|
|
|
/// Test: White canvas, empty document baseline.
|
|
/// Validates that a blank document produces deterministic all-white/transparent RGBA output.
|
|
#[test]
|
|
fn white_canvas_empty_document() {
|
|
let mut engine = Engine::new(8, 8);
|
|
let pixels = engine.get_composite_pixels();
|
|
|
|
// Engine::new creates a transparent document by default
|
|
assert_eq!(pixels.len(), 8 * 8 * 4, "Canvas size mismatch");
|
|
// Transparent pixels: alpha = 0
|
|
for i in (0..pixels.len()).step_by(4) {
|
|
assert_eq!(pixels[i + 3], 0, "Alpha channel should be 0 (transparent)");
|
|
}
|
|
assert_eq!(
|
|
hash_pixels(&pixels),
|
|
"5341e6b2646979a70e57653007a1f310169421ec9bdd9f1a5648f75ade005af1"
|
|
);
|
|
}
|
|
|
|
/// Test: Green rectangle draw and composite.
|
|
/// Validates `draw_filled_rect_rgba` produces deterministic output.
|
|
#[test]
|
|
fn green_rect_draw_and_composite() {
|
|
let mut engine = Engine::new(16, 16);
|
|
engine.draw_filled_rect_rgba(4, 4, 12, 12, [0, 255, 0, 255]);
|
|
let pixels = engine.get_composite_pixels();
|
|
|
|
assert_eq!(pixels.len(), 16 * 16 * 4);
|
|
// Check center pixel is green
|
|
let center_idx = (8 * 16 + 8) * 4;
|
|
assert_eq!(pixels[center_idx], 0);
|
|
assert_eq!(pixels[center_idx + 1], 255);
|
|
assert_eq!(pixels[center_idx + 2], 0);
|
|
assert_eq!(pixels[center_idx + 3], 255);
|
|
assert_eq!(
|
|
hash_pixels(&pixels),
|
|
"01b9681b08e6d9bafd568f110f0656613c7447c667fda4af9350d705dadc758a"
|
|
);
|
|
}
|
|
|
|
/// Test: Red rectangle over green rectangle.
|
|
/// Validates layer compositing order with two layers.
|
|
#[test]
|
|
fn red_rect_over_green_rect() {
|
|
let mut engine = Engine::new(16, 16);
|
|
|
|
// Bottom layer: green rect
|
|
let green_id = engine.add_layer("green");
|
|
engine.set_active_layer(green_id);
|
|
engine.draw_filled_rect_rgba(2, 2, 14, 14, [0, 255, 0, 255]);
|
|
|
|
// Top layer: red rect
|
|
let red_id = engine.add_layer("red");
|
|
engine.set_active_layer(red_id);
|
|
engine.draw_filled_rect_rgba(6, 6, 10, 10, [255, 0, 0, 255]);
|
|
|
|
let pixels = engine.get_composite_pixels();
|
|
assert_eq!(pixels.len(), 16 * 16 * 4);
|
|
|
|
// Center pixel should be red (top layer wins)
|
|
let center_idx = (8 * 16 + 8) * 4;
|
|
assert_eq!(pixels[center_idx], 255);
|
|
assert_eq!(pixels[center_idx + 1], 0);
|
|
assert_eq!(pixels[center_idx + 2], 0);
|
|
assert_eq!(
|
|
hash_pixels(&pixels),
|
|
"c893ae44fb82ff080e286a6625389fef843ac60e82cdb4d7dde8c7975bbae750"
|
|
);
|
|
}
|
|
|
|
/// Test: Vector shape rendering.
|
|
/// Validates vector shapes are rendered deterministically through Engine API.
|
|
#[test]
|
|
fn vector_rect_golden() {
|
|
let mut engine = Engine::new(16, 16);
|
|
let shape = VectorShape::Rect {
|
|
x1: 0.0,
|
|
y1: 0.0,
|
|
x2: 16.0,
|
|
y2: 16.0,
|
|
stroke: 1.0,
|
|
color: [255, 0, 0, 255],
|
|
fill_color: [255, 0, 0, 255],
|
|
fill: true,
|
|
radius: 0.0,
|
|
angle: 0.0,
|
|
opacity: 1.0,
|
|
hardness: 1.0,
|
|
};
|
|
engine.add_vector_shape(shape);
|
|
let pixels = engine.get_composite_pixels();
|
|
|
|
assert_eq!(pixels.len(), 16 * 16 * 4);
|
|
|
|
// Verify at least one red pixel (vector rect was drawn)
|
|
let has_red = pixels
|
|
.chunks(4)
|
|
.any(|p| p[0] == 255 && p[1] == 0 && p[2] == 0);
|
|
assert!(has_red, "Vector rect should contain red pixels");
|
|
assert_eq!(
|
|
hash_pixels(&pixels),
|
|
"71205eb7a329a3ead670c77eee185c0fbeb612f7a2b3d6aadbe2af4f9276b60d"
|
|
);
|
|
}
|
|
|
|
/// Test: Brush stroke rendering.
|
|
/// Validates brush engine + draw pipeline produces deterministic output.
|
|
#[test]
|
|
fn brush_stroke_golden() {
|
|
let mut engine = Engine::new(16, 16);
|
|
let brush = BrushTip {
|
|
style: BrushStyle::Round,
|
|
size: 4.0,
|
|
opacity: 1.0,
|
|
hardness: 1.0,
|
|
spacing: 0.1,
|
|
..Default::default()
|
|
};
|
|
engine.set_brush_tip(brush);
|
|
engine.begin_stroke(engine.active_layer_id(), 8.0, 8.0);
|
|
engine.stroke_to(engine.active_layer_id(), 12.0, 12.0, 1.0);
|
|
engine.end_stroke(engine.active_layer_id());
|
|
let pixels = engine.get_composite_pixels();
|
|
|
|
assert_eq!(pixels.len(), 16 * 16 * 4);
|
|
|
|
// Brush stroke should produce non-white pixels
|
|
let has_non_white = pixels.iter().any(|&p| p < 255);
|
|
assert!(
|
|
has_non_white,
|
|
"Brush stroke should produce non-white pixels"
|
|
);
|
|
assert_eq!(
|
|
hash_pixels(&pixels),
|
|
"e97f0dd89644a40cd4d16b7440576265761849c45180fd4dece66b4f709fa087"
|
|
);
|
|
}
|
|
|
|
/// Test: Invert filter.
|
|
/// Validates filter pipeline produces deterministic output.
|
|
#[test]
|
|
fn invert_filter_golden() {
|
|
let mut engine = Engine::new(8, 8);
|
|
engine.draw_filled_rect_rgba(0, 0, 8, 8, [100, 150, 200, 255]);
|
|
engine.apply_filter("invert", serde_json::json!({}));
|
|
|
|
let pixels = engine.get_composite_pixels();
|
|
assert_eq!(pixels.len(), 8 * 8 * 4);
|
|
|
|
// Center pixel should be inverted
|
|
let idx = (4 * 8 + 4) * 4;
|
|
assert_eq!(pixels[idx], 155); // 255 - 100
|
|
assert_eq!(pixels[idx + 1], 105); // 255 - 150
|
|
assert_eq!(pixels[idx + 2], 55); // 255 - 200
|
|
assert_eq!(
|
|
hash_pixels(&pixels),
|
|
"35490247d911e119aeae86afa584459b47b853262afde75f832521a738bb069f"
|
|
);
|
|
}
|
|
|
|
/// Test: Undo after rectangle.
|
|
/// Validates history snapshot and restoration works correctly.
|
|
#[test]
|
|
fn undo_after_rect_golden() {
|
|
let mut engine = Engine::new(8, 8);
|
|
|
|
// Initial state: transparent
|
|
let before = hash_pixels(&engine.get_composite_pixels());
|
|
|
|
// Draw green rect
|
|
engine.draw_filled_rect_rgba(2, 2, 6, 6, [0, 255, 0, 255]);
|
|
|
|
// Undo
|
|
engine.undo();
|
|
|
|
let after = hash_pixels(&engine.get_composite_pixels());
|
|
|
|
// After undo, should match initial state
|
|
assert_eq!(before, after, "Undo should restore original canvas state");
|
|
}
|
|
|
|
/// Test: Vector fill toggle and delete.
|
|
/// Validates that set_vector_shape_fill and delete_vector_shape work correctly.
|
|
#[test]
|
|
fn vector_fill_toggle_and_delete() {
|
|
let mut engine = Engine::new(16, 16);
|
|
|
|
// Create a rect with fill=false
|
|
let shape = VectorShape::Rect {
|
|
x1: 2.0,
|
|
y1: 2.0,
|
|
x2: 14.0,
|
|
y2: 14.0,
|
|
stroke: 1.0,
|
|
color: [255, 0, 0, 255],
|
|
fill_color: [0, 0, 255, 255],
|
|
fill: false,
|
|
radius: 0.0,
|
|
angle: 0.0,
|
|
opacity: 1.0,
|
|
hardness: 1.0,
|
|
};
|
|
engine.add_vector_shape(shape);
|
|
let layer_id = engine.active_layer_id();
|
|
|
|
// Verify fill is initially false
|
|
let shapes = engine.active_vector_shapes().unwrap();
|
|
assert_eq!(
|
|
shapes[0].fill(),
|
|
Some(false),
|
|
"fill should be false initially"
|
|
);
|
|
|
|
// Toggle fill ON
|
|
engine.set_vector_shape_fill(layer_id, 0, true);
|
|
let shapes = engine.active_vector_shapes().unwrap();
|
|
assert_eq!(
|
|
shapes[0].fill(),
|
|
Some(true),
|
|
"fill should be true after toggle"
|
|
);
|
|
|
|
// Verify composite pixels contain blue fill
|
|
let pixels = engine.get_composite_pixels();
|
|
let has_blue = pixels
|
|
.chunks(4)
|
|
.any(|p| p[2] == 255 && p[0] == 0 && p[1] == 0 && p[3] > 0);
|
|
assert!(has_blue, "should have blue fill pixels after enabling fill");
|
|
|
|
// Toggle fill OFF
|
|
engine.set_vector_shape_fill(layer_id, 0, false);
|
|
let shapes = engine.active_vector_shapes().unwrap();
|
|
assert_eq!(
|
|
shapes[0].fill(),
|
|
Some(false),
|
|
"fill should be false after toggling off"
|
|
);
|
|
|
|
// Delete the shape
|
|
engine.delete_vector_shape(layer_id, 0);
|
|
let shapes = engine.active_vector_shapes().unwrap();
|
|
assert!(shapes.is_empty(), "shapes should be empty after delete");
|
|
}
|