hcie-rust-v3.05/hcie-engine-api-orig/tests/engine_integration.rs

use hcie_engine_api::Engine;

#[test]
fn test_engine_new() {
    let engine = Engine::new(100, 200);
    assert_eq!(engine.canvas_width(), 100);
    assert_eq!(engine.canvas_height(), 200);
    assert_eq!(engine.get_layer_count(), 1);
    assert!(!engine.is_modified(), "new engine should not be modified");
}

#[test]
fn test_engine_add_layer() {
    let mut engine = Engine::new(10, 10);
    let id = engine.add_layer("Layer 1");
    assert_ne!(id, 0);
    assert_eq!(engine.get_layer_count(), 2);
}

#[test]
fn test_engine_delete_layer() {
    let mut engine = Engine::new(10, 10);
    let id = engine.active_layer_id();
    engine.delete_layer(id);
    assert!(!engine.layer_infos().is_empty(), "should keep at least background layer");
}

#[test]
fn test_engine_composite_pixels() {
    let mut engine = Engine::new(10, 10);
    engine.draw_filled_rect_rgba(0, 0, 10, 10, [255, 0, 0, 255]);
    let pixels = engine.get_composite_pixels();
    assert_eq!(pixels.len(), 10 * 10 * 4);
    assert_eq!(pixels[0], 255, "R channel");
    assert_eq!(pixels[1], 0, "G channel");
}

#[test]
fn test_engine_undo() {
    let mut engine = Engine::new(10, 10);
    engine.draw_filled_rect_rgba(0, 0, 10, 10, [255, 0, 0, 255]);
    assert!(engine.is_modified());
    assert!(engine.undo(), "undo should succeed after modification");
    assert!(!engine.undo(), "double undo should return false at boundary");
}

#[test]
fn test_engine_undo_returns_false_at_boundary() {
    let mut engine = Engine::new(10, 10);
    assert!(!engine.undo(), "no history should return false");
}

#[test]
fn test_engine_tab_label() {
    let engine = Engine::new(10, 10);
    let label = engine.tab_label();
    assert!(label.contains("Untitled"), "default name should show");
}

#[test]
fn test_engine_layer_info() {
    let engine = Engine::new(10, 10);
    let id = engine.active_layer_id();
    let info = engine.get_layer_info(id);
    assert!(info.is_some());
    let info = info.unwrap();
    assert_eq!(info.width, 10);
    assert_eq!(info.height, 10);
}

#[test]
fn test_engine_get_pixel() {
    let mut engine = Engine::new(10, 10);
    engine.draw_filled_rect_rgba(0, 0, 10, 10, [255, 128, 64, 255]);
    let px = engine.get_pixel(engine.active_layer_id(), 5, 5);
    assert!(px.is_some());
    let px = px.unwrap();
    assert_eq!(px[0], 255);
    assert_eq!(px[1], 128);
    assert_eq!(px[2], 64);
}

#[test]
fn test_engine_layer_count() {
    let mut engine = Engine::new(10, 10);
    assert_eq!(engine.get_layer_count(), 1);
    engine.add_layer("new");
    assert_eq!(engine.get_layer_count(), 2);
}

#[test]
fn test_engine_get_all_layer_ids() {
    let mut engine = Engine::new(10, 10);
    let id1 = engine.add_layer("A");
    let id2 = engine.add_layer("B");
    let ids = engine.get_all_layer_ids();
    assert!(ids.contains(&id1));
    assert!(ids.contains(&id2));
}

#[test]
fn test_engine_set_layer_visible() {
    let mut engine = Engine::new(10, 10);
    let id = engine.active_layer_id();
    engine.set_layer_visible(id, false);
    let info = engine.get_layer_info(id).unwrap();
    assert!(!info.visible);
}

#[test]
fn test_engine_set_layer_opacity() {
    let mut engine = Engine::new(10, 10);
    let id = engine.active_layer_id();
    engine.set_layer_opacity(id, 0.5);
    let info = engine.get_layer_info(id).unwrap();
    assert!((info.opacity - 0.5).abs() < 0.001);
}

#[test]
fn test_engine_rename_layer() {
    let mut engine = Engine::new(10, 10);
    let id = engine.active_layer_id();
    engine.rename_layer(id, "NewName");
    let info = engine.get_layer_info(id).unwrap();
    assert_eq!(info.name, "NewName");
}

#[test]
fn test_engine_apply_filter() {
    let mut engine = Engine::new(10, 10);
    engine.draw_filled_rect_rgba(0, 0, 10, 10, [100, 100, 100, 255]);
    engine.apply_filter("invert", serde_json::json!({}));
    let ctx = engine.get_composite_pixels();
    assert_ne!(ctx[0], 100, "invert should change pixel values");
}