Skip to content

armgit / klad

Public Imported from GitHub
0

A drawing app built for agent/human collaboration

Rust
91.7 KB
Raw Blame
use std::process::Command;

#[test]
fn the_binary_runs() {
    let out = Command::new(env!("CARGO_BIN_EXE_klad"))
        .arg("--version")
        .output()
        .unwrap();
    assert!(out.status.success());
    assert!(String::from_utf8_lossy(&out.stdout).starts_with("klad"));
}

#[test]
fn skill_prints_the_klad_skill_and_the_drawing_and_pixel_skills() {
    let skill = |args: &[&str]| {
        Command::new(env!("CARGO_BIN_EXE_klad"))
            .arg("skill")
            .args(args)
            .output()
            .unwrap()
    };
    let said = |args: &[&str]| String::from_utf8_lossy(&skill(args).stdout).to_string();
    assert!(said(&[]).starts_with("---\nname: klad\n"));
    assert_eq!(said(&["klad"]), said(&[]));
    let drawing = said(&["drawing"]);
    assert!(drawing.starts_with("---\nname: klad-drawing\n"));
    assert!(drawing.contains("## The order of work"));
    let pixel = said(&["pixel"]);
    assert!(pixel.starts_with("---\nname: klad-pixel\n"));
    assert!(pixel.contains("## Clusters") && pixel.contains("## Before you show it"));
    assert!(said(&[]).contains("klad skill pixel"), "the klad skill points to it");
    let reference = String::from_utf8_lossy(
        &Command::new(env!("CARGO_BIN_EXE_klad"))
            .arg("reference")
            .output()
            .unwrap()
            .stdout,
    )
    .to_string();
    let words = |text: &str, lead: &str| -> std::collections::BTreeSet<String> {
        text.match_indices(lead)
            .map(|(at, _)| {
                text[at + lead.len()..]
                    .chars()
                    .take_while(|c| c.is_ascii_lowercase() || *c == '-')
                    .collect::<String>()
            })
            .filter(|word| word.starts_with(|c: char| c.is_ascii_lowercase()))
            .map(|word| word.trim_end_matches('-').to_string())
            .collect()
    };
    let commands = words(&pixel, "`klad ");
    assert!(commands.len() >= 8, "{commands:?}");
    commands.iter().for_each(|command| {
        assert!(
            reference.contains(&format!("## klad {command}")) || reference.contains(&format!("klad {command} ")),
            "the pixel skill names klad {command}, which klad does not have"
        );
    });
    let flags = words(&pixel, "--");
    assert!(flags.len() >= 12, "{flags:?}");
    flags.iter().for_each(|flag| {
        assert!(
            reference.contains(&format!("--{flag}")),
            "the pixel skill names --{flag}, which no command has"
        );
    });
    let unknown = skill(&["painting"]);
    assert!(!unknown.status.success());
    assert!(String::from_utf8_lossy(&unknown.stderr).contains("no skill named painting"));
}

#[test]
fn a_drawing_moves_and_a_layer_duplicates_from_the_command_line() {
    let dir = std::env::temp_dir().join(format!("draw-binary-move-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    let bundle = dir.join("a.klad");
    let draw = |args: &[&str]| {
        let out = Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    let path = bundle.to_str().unwrap();
    draw(&["new", path, "--width", "200", "--height", "100", "--frames", "12"]);
    draw(&["stroke", path, "l1", "--path", "M10 10 L190 90", "--size", "4"]);
    draw(&["cel", path, "dup", "c2", "--frame", "8", "--hold", "2"]);
    draw(&["cel", path, "move", "c2", "--frame", "2"]);
    assert!(draw(&["duplicate", path, "paint 1"]).contains("added"));
    let doc: serde_json::Value = serde_json::from_slice(&std::fs::read(bundle.join("doc.json")).unwrap()).unwrap();
    let layers = doc["layers"].as_array().unwrap();
    assert_eq!(layers.len(), 2);
    assert_eq!(layers[1]["name"], "paint 1 copy");
    let starts = |l: &serde_json::Value| -> Vec<u64> {
        l["cels"]
            .as_array()
            .unwrap()
            .iter()
            .map(|c| c["frame"].as_u64().unwrap())
            .collect()
    };
    assert_eq!(starts(&layers[0]), [2, 10]);
    assert_eq!(starts(&layers[1]), [2, 10]);
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn an_error_is_one_line_and_the_backtrace_waits_for_klad_backtrace() {
    let missing = std::env::temp_dir().join(format!("draw-binary-missing-{}.klad", std::process::id()));
    let run = |backtrace: Option<&str>| {
        let mut command = Command::new(env!("CARGO_BIN_EXE_klad"));
        command
            .args(["ls", missing.to_str().unwrap()])
            .env("RUST_BACKTRACE", "1");
        match backtrace {
            Some(v) => command.env("KLAD_BACKTRACE", v),
            None => command.env_remove("KLAD_BACKTRACE"),
        };
        let out = command.output().unwrap();
        assert_eq!(out.status.code(), Some(1));
        String::from_utf8_lossy(&out.stderr).to_string()
    };
    let plain = run(None);
    assert_eq!(plain.lines().count(), 1, "{plain}");
    assert!(
        plain.starts_with("error: reading ") && plain.contains("doc.json: "),
        "{plain}"
    );
    assert_eq!(run(Some("0")), plain);
    let traced = run(Some("1"));
    assert!(traced.contains("Caused by") && traced.contains("backtrace"), "{traced}");
}

#[test]
fn the_client_makes_edits_reads_and_renders_a_drawing() {
    use klad_client::{Error, Klad, json};
    let dir = std::env::temp_dir().join(format!("draw-binary-client-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let klad = Klad::at(env!("CARGO_BIN_EXE_klad"));
    assert!(klad.version().unwrap().starts_with("klad"));
    let art = klad.drawing(dir.join("art.klad"));
    art.create(320, 200, Some("#e9e4da")).unwrap();
    let ids = art
        .apply([
            json!({"op": "add", "layer": {"kind": "vector", "name": "sky"}}),
            json!({"op": "stroke", "layer": "l1", "brush": "ink", "size": 6, "color": "#1b1b1b", "path": "M20 100 L300 100"}),
        ])
        .unwrap();
    assert!(!ids.is_empty());
    let layer = art.document().unwrap()["layers"]
        .as_array()
        .unwrap()
        .iter()
        .find(|l| l["name"] == "sky")
        .map(|l| l["id"].as_str().unwrap().to_string())
        .unwrap();
    art.apply([json!({"op": "add", "node": {"type": "rect", "x": 10, "y": 10, "w": 50, "h": 30, "fill": "#336699"}, "in": layer, "frame": 0})])
        .unwrap();
    assert!(art.ls(0).unwrap().to_string().contains("sky"));
    let strokes = art.strokes("l1", 0).unwrap();
    assert!(strokes.to_string().contains("ink"));
    let png = art.render(&dir.join("art.png"), 0, 0.5).unwrap();
    assert!(std::fs::metadata(png).unwrap().len() > 0);
    art.undo().unwrap();
    assert!(!art.document().unwrap().to_string().contains("#336699"));
    let missing = art.show("n999").unwrap_err();
    assert!(matches!(missing, Error::Failed { .. }), "{missing}");
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn updates_says_what_the_feed_holds() {
    let dir = std::env::temp_dir().join(format!("draw-binary-updates-{}", std::process::id()));
    std::fs::create_dir_all(&dir).unwrap();
    let feed = dir.join("latest.json");
    let run = |feed: &std::path::Path| {
        Command::new(env!("CARGO_BIN_EXE_klad"))
            .arg("updates")
            .env("KLAD_UPDATE_FEED", feed)
            .output()
            .unwrap()
    };
    std::fs::write(
        &feed,
        r#"{"tag_name":"v9.9.9","html_url":"https://github.com/klad-app/klad/releases","body":"- a test"}"#,
    )
    .unwrap();
    let out = run(&feed);
    assert!(out.status.success());
    assert_eq!(
        String::from_utf8_lossy(&out.stdout),
        "klad 9.9.9 is out: a test\nhttps://github.com/klad-app/klad/releases\n"
    );
    std::fs::write(&feed, r#"{"tag_name":"v0.0.1","html_url":"https://example.org"}"#).unwrap();
    assert!(String::from_utf8_lossy(&run(&feed).stdout).contains("is the newest version"));
    let missing = run(&dir.join("missing.json"));
    assert!(!missing.status.success());
    assert!(String::from_utf8_lossy(&missing.stderr).starts_with("error: could not check: reading"));
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn samples_are_listed_and_copied_to_draw_on() {
    let dir = std::env::temp_dir().join(format!("draw-binary-samples-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    let shipped = dir.join("shipped");
    let run = |args: &[&str]| {
        Command::new(env!("CARGO_BIN_EXE_klad"))
            .args(args)
            .env("KLAD_SAMPLES", &shipped)
            .current_dir(&dir)
            .output()
            .unwrap()
    };
    std::fs::create_dir_all(&shipped).unwrap();
    let rock = shipped.join("rock/rock.klad");
    let out = run(&["new", rock.to_str().unwrap(), "--width", "64", "--height", "64"]);
    assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
    std::fs::write(
        shipped.join("shipped.json"),
        r#"[{"name":"rock","bundle":"rock/rock.klad","about":"a rock on its own"}]"#,
    )
    .unwrap();
    let listed = String::from_utf8_lossy(&run(&["samples"]).stdout).to_string();
    assert!(listed.starts_with("rock       a rock on its own"), "{listed}");
    let copied = run(&["samples", "--copy", "rock"]);
    assert!(copied.status.success(), "{}", String::from_utf8_lossy(&copied.stderr));
    assert!(
        dir.join("rock.klad/doc.json").is_file(),
        "the copy goes in the current folder"
    );
    let into = dir.join("mine");
    let out = run(&["samples", "--copy", "rock", "--into", into.to_str().unwrap()]);
    assert_eq!(
        String::from_utf8_lossy(&out.stdout).trim(),
        format!("copied rock to {}", into.join("rock.klad").display())
    );
    let wrong = run(&["samples", "--copy", "stone"]);
    assert!(String::from_utf8_lossy(&wrong.stderr).contains("no sample stone; there are rock"));
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn a_report_holds_the_version_the_log_with_home_hidden_and_zips_the_drawing() {
    let dir = std::env::temp_dir().join(format!("draw-binary-report-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let home = dir.join("home");
    let log = dir.join("klad.log");
    std::fs::write(
        &log,
        format!("2026-11-06 17:00:00 editor: could not read {}/x.png\n", home.display()),
    )
    .unwrap();
    let bundle = dir.join("drawings/rock.klad");
    let run = |args: &[&str]| {
        Command::new(env!("CARGO_BIN_EXE_klad"))
            .args(args)
            .env("KLAD_LOG", &log)
            .env("HOME", &home)
            .output()
            .unwrap()
    };
    assert!(
        run(&["new", bundle.to_str().unwrap(), "--width", "64", "--height", "48"])
            .status
            .success()
    );
    let out = run(&["report", "--drawing", bundle.to_str().unwrap()]);
    assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
    let text = String::from_utf8_lossy(&out.stdout).to_string();
    assert!(
        text.starts_with("klad ") && text.contains("from the command line"),
        "{text}"
    );
    assert!(
        text.contains("could not read ~/x.png"),
        "the home folder reads as ~: {text}"
    );
    assert!(
        text.contains("The drawing (64 by 48 px, 1 layer, 1 frame) is attached as rock for a report.zip."),
        "{text}"
    );
    assert!(dir.join("drawings/rock for a report.zip").is_file());
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn solo_shows_one_layer_and_undo_brings_the_rest_back() {
    let dir = std::env::temp_dir().join(format!("draw-binary-solo-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    let bundle = dir.join("a.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| {
        let out = Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    run(&["new", path, "--width", "64", "--height", "64", "--layers", "3"]);
    let shown = || -> Vec<bool> {
        let doc: serde_json::Value = serde_json::from_slice(&std::fs::read(bundle.join("doc.json")).unwrap()).unwrap();
        doc["layers"]
            .as_array()
            .unwrap()
            .iter()
            .map(|l| l["visible"].as_bool().unwrap_or(true))
            .collect()
    };
    run(&["solo", path, "paint 2"]);
    assert_eq!(shown(), [false, true, false]);
    assert!(run(&["solo", path, "paint 2"]).contains("already shows alone"));
    run(&["undo", path]);
    assert_eq!(shown(), [true, true, true]);
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn a_chain_and_its_ik_are_set_up_and_posed_from_the_command_line() {
    let dir = std::env::temp_dir().join(format!("klad-binary-ik-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    let bundle = dir.join("a.klad");
    let klad = |args: &[&str]| {
        let out = Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    let path = bundle.to_str().unwrap();
    klad(&["new", path, "--width", "400", "--height", "400", "--frames", "6"]);
    klad(&[
        "stroke",
        path,
        "l1",
        "--path",
        "M100 100 L100 200 L100 300",
        "--size",
        "6",
    ]);
    klad(&["add", path, "layer", "bones", "name=bones"]);
    let made = klad(&[
        "bone",
        path,
        "bones",
        "--chain",
        "thigh,shin",
        "--through",
        "100,100 100,200 100,300",
    ]);
    assert!(made.contains("chain thigh, shin"), "{made}");
    let rigged = klad(&["attach", path, "l1", "--bend", "--skeleton", "bones"]);
    assert!(rigged.contains("bends with bones"), "{rigged}");
    let ik = klad(&["ik", path, "bones", "--add", "shin", "--softness", "4"]);
    assert!(ik.contains("a limb with thigh") && ik.contains("softness 4"), "{ik}");
    klad(&["ik", path, "bones", "--set", "shin", "--bend", "flip"]);
    klad(&[
        "pose",
        path,
        "bones",
        "--from",
        "0",
        "--to",
        "3",
        "--target",
        "shin=180,240",
        "--mix",
        "shin=0.5",
        "--root",
        "-10,0",
    ]);
    let listed = klad(&["bones", path]);
    assert!(
        listed.contains("ik shin: a limb with thigh, bending counterclockwise, softness 4 px"),
        "{listed}"
    );
    assert!(
        listed.contains("root -10,0 target shin=180,240 mix 0.5 solved shin="),
        "{listed}"
    );
    let nan = Command::new(env!("CARGO_BIN_EXE_klad"))
        .args([
            "pose",
            path,
            "bones",
            "--from",
            "0",
            "--to",
            "4",
            "--target",
            "shin=nan,240",
        ])
        .output()
        .unwrap();
    assert!(!nan.status.success(), "a target that is not a number is refused");
    klad(&["ls", path]);
    let json: serde_json::Value = serde_json::from_str(&klad(&["bones", path, "--json"])).unwrap();
    assert_eq!(json[0]["ik"][0]["bone"], "shin");
    assert!(json[0]["poses"][0]["solved"]["thigh"].is_number());
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn a_checkout_under_the_cache_renders_the_drawing_it_brings() {
    let dir = std::env::temp_dir().join(format!("draw-binary-checkout-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    let bundle = dir.join("a.klad");
    let path = bundle.to_str().unwrap();
    let draw = |args: &[&str]| {
        let out = Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    let render = || {
        let printed = draw(&["render", path]);
        std::fs::read(printed.lines().last().unwrap().trim()).unwrap()
    };
    let files = || ["doc.json", "strokes/l1/c2.strokes"].map(|f| std::fs::read(bundle.join(f)).ok());
    let put = |kept: &[Option<Vec<u8>>; 2]| {
        ["doc.json", "strokes/l1/c2.strokes"]
            .iter()
            .zip(kept)
            .for_each(|(f, bytes)| match bytes {
                Some(bytes) => std::fs::write(bundle.join(f), bytes).unwrap(),
                None => {
                    let _ = std::fs::remove_file(bundle.join(f));
                }
            });
    };
    draw(&["new", path, "--width", "200", "--height", "100"]);
    let base = files();
    draw(&["stroke", path, "l1", "--path", "M10 10 L190 90", "--size", "8"]);
    let one = files();
    let first = render();
    put(&base);
    draw(&["stroke", path, "l1", "--path", "M10 90 L190 10", "--size", "8"]);
    let other = render();
    assert_ne!(
        first, other,
        "the other branch, after as many edits, is not the first one's render"
    );
    put(&one);
    assert_eq!(
        render(),
        first,
        "checking the first branch out again renders it, not the cached other"
    );
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn a_merge_that_left_an_id_used_twice_is_repaired() {
    let dir = std::env::temp_dir().join(format!("draw-binary-repair-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    let bundle = dir.join("a.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let draw = |args: &[&str]| {
        let out = run(args);
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    draw(&["new", path, "--width", "200", "--height", "100", "--layers", "2"]);
    draw(&["stroke", path, "l1", "--path", "M10 10 L190 90"]);
    draw(&["stroke", path, "l3", "--path", "M10 90 L190 10"]);
    let doc = std::fs::read_to_string(bundle.join("doc.json")).unwrap();
    std::fs::write(bundle.join("doc.json"), doc.replace("\"l3\"", "\"l1\"")).unwrap();
    std::fs::rename(
        bundle.join("strokes/l3/c4.strokes"),
        bundle.join("strokes/l1/c4.strokes"),
    )
    .unwrap();
    let refused = run(&["info", path]);
    let said = String::from_utf8_lossy(&refused.stderr);
    assert!(
        !refused.status.success() && said.contains("id l1 is used twice") && said.contains("klad repair"),
        "{said}"
    );
    let repaired = draw(&["repair", path]);
    assert!(repaired.contains("layer \"paint 2\": l1 is now l5"), "{repaired}");
    assert!(
        repaired.contains("moved strokes/l1/c4.strokes to strokes/l5/c4.strokes"),
        "{repaired}"
    );
    let info = draw(&["info", path]);
    assert!(
        info.contains("l1      c2") && info.contains("l5      c4") && info.matches("1 strokes").count() == 2,
        "{info}"
    );
    assert!(draw(&["repair", path]).contains("nothing to repair"));
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn shapes_align_spread_and_centre_on_the_canvas_from_the_command_line() {
    let dir = std::env::temp_dir().join(format!("draw-binary-align-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    let bundle = dir.join("a.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let draw = |args: &[&str]| {
        let out = run(args);
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    draw(&["new", path, "--width", "400", "--height", "200", "--sketch"]);
    let add = |x: &str, y: &str, w: &str| {
        let made = draw(&[
            "add",
            path,
            "rect",
            "--in",
            "l3",
            &format!("x={x}"),
            &format!("y={y}"),
            &format!("w={w}"),
            "h=20",
        ]);
        made.lines()
            .find_map(|line| line.strip_prefix("added "))
            .unwrap_or_else(|| panic!("an id in: {made}"))
            .to_string()
    };
    let (a, b, c) = (add("10", "10", "20"), add("100", "40", "40"), add("50", "80", "10"));
    let boxes = || {
        [&a, &b, &c].map(|id| {
            let node: serde_json::Value = serde_json::from_str(&draw(&["show", path, id])).unwrap();
            [0, 1].map(|i| node["bounds"][i].as_f64().unwrap())
        })
    };
    draw(&["align", path, &a, &b, &c, "--y", "top", "--spread", "x"]);
    assert_eq!(boxes(), [[10.0, 10.0], [100.0, 10.0], [60.0, 10.0]]);
    draw(&["align", path, &b, "--x", "centre", "--y", "middle", "--to", "canvas"]);
    assert_eq!(boxes()[1], [180.0, 90.0]);
    draw(&["align", path, &b, &c, "--x", "left", "--to", &a]);
    assert_eq!(boxes().map(|at| at[0]), [10.0, 10.0, 10.0]);
    assert!(draw(&["align", path, &b, &c, "--x", "left", "--to", &a]).contains("nothing moved"));
    let log = draw(&["log", path]);
    assert_eq!(
        log.lines().filter(|line| line.contains("set n")).count(),
        3,
        "one history step each: {log}"
    );
    let refused = run(&["align", path, &a, "--x", "left"]);
    assert!(!refused.status.success());
    assert!(String::from_utf8_lossy(&refused.stderr).contains("nothing to line up with"));
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn a_pixel_drawing_is_made_drawn_listed_and_edited_from_the_command_line() {
    let dir = std::env::temp_dir().join(format!("draw-binary-pixel-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let bundle = dir.join("sprite.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let draw = |args: &[&str]| {
        let out = run(args);
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    let json = |args: &[&str]| -> serde_json::Value { serde_json::from_str(&draw(args)).unwrap() };
    draw(&["new", path, "--pixel", "16x12"]);
    let tree = json(&["ls", path, "--json"]);
    assert_eq!(
        (tree["canvas"]["width"].as_u64(), tree["canvas"]["height"].as_u64()),
        (Some(16), Some(12))
    );
    let layer = tree["layers"][0]["id"].as_str().unwrap().to_string();
    assert_eq!(tree["layers"][0]["kind"], "pixel");
    draw(&["palette", path, "--add", "#f0c8a0", "--name", "skin"]);
    let made = draw(&[
        "pixel",
        path,
        &layer,
        "--color",
        "#2b2d42",
        "--cells",
        "3-12,2 3,3-8 12,3-8 3-12,9",
    ]);
    assert!(
        made.contains("pixel marks") && made.contains("changed palette"),
        "{made}"
    );
    draw(&["pixel", path, &layer, "--color", "skin", "--cells", "4-11,3-8"]);
    draw(&["pixel", path, &layer, "--erase", "--cells", "7,5 8,5"]);
    let listed = json(&["strokes", path, &layer, "--json"]);
    let marks = listed["fills"].as_array().unwrap();
    assert_eq!(marks.len(), 2, "the eraser leaves no mark of its own");
    assert_eq!(marks[0]["cells"].as_array().unwrap().len(), 32);
    assert_eq!(
        marks[1]["cells"].as_array().unwrap().len(),
        46,
        "it takes its two pixels out of the mark under it"
    );
    let palette = json(&["palette", path, "--json"]);
    assert_eq!(palette.as_array().unwrap().len(), 2);
    assert_eq!(
        marks[1]["entry"], palette[0]["id"],
        "the mark is bound to the skin entry"
    );
    assert_eq!(marks[0]["entry"], palette[1]["id"]);
    let text = draw(&["strokes", path, &layer]);
    assert!(
        text.contains("2 pixel marks, 78 cells") && text.contains("skin") && !text.contains("erases"),
        "{text}"
    );
    let first = marks[0]["address"].as_str().unwrap().to_string();
    draw(&["set", path, &first, "color=skin"]);
    draw(&["transform", path, &first, "--move", "1,0"]);
    let after = json(&["strokes", path, &layer, "--json"]);
    assert_eq!(after["fills"][0]["entry"], palette[0]["id"]);
    assert_eq!(after["fills"][0]["bounds"][0].as_f64(), Some(4.0));
    assert!(draw(&["ls", path]).contains("2 pixel marks"));
    let refused = run(&["stroke", path, &layer, "--path", "M1 1 L9 9"]);
    assert!(!refused.status.success());
    assert!(String::from_utf8_lossy(&refused.stderr).contains("pixel layer"));
    let bad = run(&["pixel", path, &layer, "--color", "skin", "--cells", "3;4"]);
    assert!(String::from_utf8_lossy(&bad.stderr).contains("is not x,y"));
    let added = draw(&["add", path, "layer", "pixel", "name=lines"]);
    let lines_id = added
        .lines()
        .find_map(|line| line.strip_prefix("added "))
        .unwrap_or_else(|| panic!("an id in: {added}"))
        .to_string();
    draw(&[
        "pixel",
        path,
        "lines",
        "--color",
        "skin",
        "--path",
        "M0.5 11.5 C 4 2 11 2 15.5 11.5",
    ]);
    draw(&[
        "pixel",
        path,
        &lines_id,
        "--color",
        "skin",
        "--path",
        "M1.5 1.5 L5.5 1.5 L5.5 4.5",
    ]);
    let lines = json(&["strokes", path, &lines_id, "--json"]);
    let cells = |at: usize| -> Vec<(i64, i64)> {
        lines["fills"][at]["cells"]
            .as_array()
            .unwrap()
            .iter()
            .map(|c| (c[0].as_i64().unwrap(), c[1].as_i64().unwrap()))
            .collect()
    };
    let curve = cells(0);
    assert!(curve.contains(&(0, 11)) && curve.contains(&(15, 11)), "{curve:?}");
    let doubled = curve.iter().any(|&(x, y)| {
        let has = |dx: i64, dy: i64| curve.contains(&(x + dx, y + dy));
        (has(1, 0) || has(-1, 0))
            && (has(0, 1) || has(0, -1))
            && !(has(1, 0) && has(-1, 0))
            && !(has(0, 1) && has(0, -1))
    });
    assert!(!doubled, "a curve is one pixel thin with no corner doubled: {curve:?}");
    assert_eq!(cells(1).len(), 8, "a path's own corner is kept");
    draw(&["pixel", path, &lines_id, "--erase", "--size", "3", "--cells", "5,1"]);
    let erased = json(&["strokes", path, &lines_id, "--json"]);
    assert_eq!(
        (
            erased["fills"].as_array().unwrap().len(),
            erased["fills"][1]["cells"].as_array().unwrap().len()
        ),
        (2, 5),
        "a size is a square of whole pixels: the eraser takes three of the path's and leaves no mark"
    );
    draw(&["rm", path, &lines_id]);
    let wide = run(&[
        "pixel", path, &layer, "--color", "skin", "--cells", "1,1", "--size", "99",
    ]);
    assert!(String::from_utf8_lossy(&wide.stderr).contains("from 1 to 64"));
    let shown = run(&["render", path]);
    assert!(
        String::from_utf8_lossy(&shown.stderr).contains("512x384"),
        "a pixel drawing renders enlarged by a whole number: {}",
        String::from_utf8_lossy(&shown.stderr)
    );
    let hash = |out: &std::process::Output| {
        String::from_utf8_lossy(&out.stderr)
            .split_whitespace()
            .skip_while(|word| *word != "hash")
            .nth(1)
            .map(String::from)
    };
    let gridded = run(&["render", path, "--overlay", "grid"]);
    assert!(
        gridded.status.success() && hash(&gridded) != hash(&shown),
        "the grid overlay draws its lines"
    );
    let real = run(&["render", path, "--scale", "1"]);
    assert!(String::from_utf8_lossy(&real.stderr).contains("16x12"));
    draw(&["add", path, "layer", "pixel", "name=shade"]);
    assert_eq!(json(&["ls", path, "--json"])["layers"][0]["kind"], "pixel");
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn the_palette_recolours_its_pixels_loads_palettes_and_groups_ramps_from_the_command_line() {
    let dir = std::env::temp_dir().join(format!("draw-binary-palette-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let bundle = dir.join("sprite.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let draw = |args: &[&str]| {
        let out = run(args);
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    let json = |args: &[&str]| -> serde_json::Value { serde_json::from_str(&draw(args)).unwrap() };
    draw(&["new", path, "--pixel", "8"]);
    draw(&["palette", path, "--add", "#f0c8a0", "--name", "skin"]);
    draw(&["pixel", path, "l1", "--color", "skin", "--cells", "1-3,1-3"]);
    draw(&["palette", path, "--recolour", "skin", "--to", "#e8b796"]);
    let marks = json(&["strokes", path, "l1", "--json"]);
    assert_eq!(
        marks["fills"][0]["color"], "#e8b796ff",
        "the pixels follow their palette colour"
    );
    draw(&["palette", path, "--ramp", "skin", "--base", "#e8b796", "--steps", "3"]);
    let palette = json(&["palette", path, "--json"]);
    let ramp: Vec<(&str, &str)> = palette
        .as_array()
        .unwrap()
        .iter()
        .map(|s| (s["name"].as_str().unwrap_or(""), s["ramp"].as_str().unwrap_or("")))
        .collect();
    assert_eq!(
        ramp,
        [("skin-1", "skin"), ("skin", "skin"), ("skin-3", "skin")],
        "the colour the palette has takes its place in the middle of its ramp"
    );
    assert!(draw(&["palettes"]).contains("pico-8"));
    assert_eq!(json(&["palettes", "--json"])[2]["colors"].as_array().unwrap().len(), 16);
    draw(&["palette", path, "--load", "four-greens"]);
    let file = dir.join("mine.hex");
    std::fs::write(&file, "081820\nabcdef\n").unwrap();
    draw(&["palette", path, "--load", file.to_str().unwrap()]);
    assert_eq!(
        json(&["palette", path, "--json"]).as_array().unwrap().len(),
        8,
        "three of the ramp, the four greens, one new from the file"
    );
    draw(&["palette", path, "--ramp", "greens", "--of", "#081820,#346856,#88c070"]);
    assert!(draw(&["palette", path]).contains("ramp greens"));
    let refused = run(&["palette", path, "--load", "nope"]);
    assert!(String::from_utf8_lossy(&refused.stderr).contains("comes with klad"));
    let lonely = run(&["palette", path, "--ramp", "x"]);
    assert!(String::from_utf8_lossy(&lonely.stderr).contains("--base"));
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn a_sprite_is_written_as_a_grid_of_characters_and_read_back_the_same() {
    use std::io::Write;
    use std::process::Stdio;
    let dir = std::env::temp_dir().join(format!("draw-binary-grid-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let bundle = dir.join("sprite.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let draw = |args: &[&str]| {
        let out = run(args);
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    draw(&["new", path, "--pixel", "8x6"]);
    draw(&["palette", path, "--add", "#22223b", "--name", "ink"]);
    let text = "i = ink\nb = #f2c14e\n\n..iiii..\n.ibbbbi.\n.ibbbbi.\n..iiii..\n";
    let mut child = Command::new(env!("CARGO_BIN_EXE_klad"))
        .args(["pixel", path, "l1", "--grid", "-", "--at", "0,1"])
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .unwrap();
    child.stdin.take().unwrap().write_all(text.as_bytes()).unwrap();
    let made = child.wait_with_output().unwrap();
    assert!(made.status.success(), "{}", String::from_utf8_lossy(&made.stderr));
    assert!(String::from_utf8_lossy(&made.stdout).contains("pixel marks"));
    let marks: serde_json::Value = serde_json::from_str(&draw(&["strokes", path, "l1", "--json"])).unwrap();
    assert_eq!(
        marks["fills"].as_array().unwrap().len(),
        2,
        "one mark for each colour of the grid"
    );
    let plain = draw(&["pixels", path, "l1", "--plain"]);
    assert_eq!(
        plain.trim_end(),
        ". = empty\ni = ink\na = #f2c14e\n\n........\n..iiii..\n.iaaaai.\n.iaaaai.\n..iiii..\n........"
    );
    let ruled = draw(&["pixels", path, "l1"]);
    assert!(ruled.contains("8x6") && ruled.contains(" 1  ..iiii.."), "{ruled}");
    let read: serde_json::Value = serde_json::from_str(&draw(&["pixels", path, "l1", "--json"])).unwrap();
    assert_eq!(read["rows"][2], ".iaaaai.");
    assert_eq!(read["legend"]["i"]["name"], "ink");
    assert_eq!((read["width"].as_u64(), read["height"].as_u64()), (Some(8), Some(6)));
    let copy = dir.join("copy.klad");
    let copy_path = copy.to_str().unwrap();
    draw(&["new", copy_path, "--pixel", "8x6"]);
    draw(&["palette", copy_path, "--add", "#22223b", "--name", "ink"]);
    let saved = dir.join("sprite.txt");
    std::fs::write(&saved, &plain).unwrap();
    draw(&["pixel", copy_path, "l1", "--grid", saved.to_str().unwrap()]);
    assert_eq!(
        draw(&["hash", copy_path]),
        draw(&["hash", path]),
        "what klad pixels prints draws the same picture again"
    );
    std::fs::write(&saved, "i = ink\n\n..q..\n").unwrap();
    let unknown = run(&["pixel", path, "l1", "--grid", saved.to_str().unwrap()]);
    assert!(String::from_utf8_lossy(&unknown.stderr).contains("the legend does not name"));
    draw(&["add", path, "layer", "paint", "name=paint"]);
    let wrong = run(&["pixels", path, "paint"]);
    assert!(String::from_utf8_lossy(&wrong.stderr).contains("reads pixel layers"));
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn lines_rectangles_ellipses_and_fills_go_on_the_grid_from_the_command_line() {
    let dir = std::env::temp_dir().join(format!("draw-binary-shapes-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let bundle = dir.join("sprite.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let draw = |args: &[&str]| {
        let out = run(args);
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    draw(&["new", path, "--pixel", "16x12"]);
    draw(&["palette", path, "--add", "#22223b", "--name", "ink"]);
    draw(&["palette", path, "--add", "#f2c14e", "--name", "body"]);
    draw(&["pixel", path, "l1", "--color", "ink", "--ellipse", "1,1,9,7"]);
    draw(&["pixel", path, "l1", "--color", "body", "--fill", "5,4"]);
    draw(&["pixel", path, "l1", "--color", "ink", "--rect", "11,1,4,4"]);
    draw(&["pixel", path, "l1", "--color", "body", "--rect", "11,6,4,3", "--filled"]);
    draw(&["pixel", path, "l1", "--color", "ink", "--line", "0,11,15,9"]);
    let rows: Vec<String> = draw(&["pixels", path, "l1", "--plain"])
        .lines()
        .skip_while(|line| !line.is_empty())
        .skip(1)
        .map(String::from)
        .collect();
    assert_eq!(
        rows,
        [
            "................",
            "...iiiii...iiii.",
            "..ibbbbbi..i..i.",
            ".ibbbbbbbi.i..i.",
            ".ibbbbbbbi.iiii.",
            ".ibbbbbbbi......",
            "..ibbbbbi..bbbb.",
            "...iiiii...bbbb.",
            "...........bbbb.",
            "............iiii",
            "....iiiiiiii....",
            "iiii............",
        ]
    );
    draw(&["add", path, "layer", "pixel", "name=under", "--below", "l1"]);
    draw(&[
        "pixel", path, "under", "--color", "#8ecae6", "--fill", "12,2", "--ref", "l1",
    ]);
    let under: serde_json::Value = serde_json::from_str(&draw(&["pixels", path, "under", "--json"])).unwrap();
    assert_eq!(
        under["rows"][2], "............aa..",
        "a fill on another layer stops at the lines it reads"
    );
    assert_eq!(under["rows"][5], "................");
    let both = run(&[
        "pixel", path, "l1", "--color", "ink", "--rect", "0,0,2,2", "--line", "0,0,3,3",
    ]);
    assert!(!both.status.success());
    let flat = run(&["pixel", path, "l1", "--color", "ink", "--rect", "0,0,0,2"]);
    assert!(String::from_utf8_lossy(&flat.stderr).contains("at least 1 pixel"));
    let off = run(&["pixel", path, "l1", "--color", "ink", "--fill", "40,40"]);
    assert!(String::from_utf8_lossy(&off.stderr).contains("off the 16x12 canvas"));
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn pixel_marks_are_listed_by_colour_cut_by_a_box_and_recoloured_exactly() {
    let dir = std::env::temp_dir().join(format!("draw-binary-pixel-edit-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let bundle = dir.join("sprite.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let draw = |args: &[&str]| {
        let out = run(args);
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    let rows = |layer: &str| -> Vec<String> {
        draw(&["pixels", path, layer, "--plain"])
            .lines()
            .skip_while(|line| !line.is_empty())
            .skip(1)
            .map(String::from)
            .collect()
    };
    draw(&["new", path, "--pixel", "12x6"]);
    draw(&["palette", path, "--add", "#22223b", "--name", "ink"]);
    draw(&["palette", path, "--add", "#f2c14e", "--name", "body"]);
    draw(&["pixel", path, "l1", "--color", "ink", "--rect", "0,0,6,4"]);
    draw(&["pixel", path, "l1", "--color", "body", "--rect", "1,1,4,2", "--filled"]);
    draw(&["pixel", path, "l1", "--color", "ink", "--cells", "0,5"]);
    let ink: serde_json::Value =
        serde_json::from_str(&draw(&["strokes", path, "l1", "--entry", "ink", "--json"])).unwrap();
    assert_eq!(
        ink["fills"].as_array().unwrap().len(),
        2,
        "the two ink marks, not the body"
    );
    assert!(draw(&["strokes", path, "l1", "--entry", "body"]).contains("1 pixel marks, 8 cells"));
    let moved = draw(&["lasso", path, "pixel 1", "--box", "3,0,3,4", "--cut", "--move", "5,1"]);
    assert!(moved.contains("moved"), "{moved}");
    assert_eq!(
        rows("l1"),
        [
            "iii.........",
            "ibb.....iii.",
            "ibb.....bbi.",
            "iii.....bbi.",
            "........iii.",
            "i..........."
        ],
        "the right half of the box moved 5 across and 1 down, between whole pixels"
    );
    let marks: serde_json::Value = serde_json::from_str(&draw(&["strokes", path, "l1", "--json"])).unwrap();
    let pieces = marks["fills"].as_array().unwrap();
    assert_eq!(pieces.len(), 5, "the two marks the box crossed are four now");
    assert!(
        pieces.iter().all(|m| m.get("cuts").is_none()),
        "with no cut left on them"
    );
    let body_moved = pieces
        .iter()
        .find(|m| m["color"] == "#f2c14eff" && m["bounds"][0].as_f64() == Some(8.0))
        .map(|m| m["address"].as_str().unwrap().to_string())
        .expect("the moved half of the body");
    draw(&["recolour", path, &body_moved, "--to", "ink"]);
    assert_eq!(
        rows("l1")[2],
        "ibb.....iii.",
        "a recoloured pixel mark takes exactly the palette colour"
    );
    assert_eq!(
        serde_json::from_str::<serde_json::Value>(&draw(&["palette", path, "--json"]))
            .unwrap()
            .as_array()
            .unwrap()
            .len(),
        2,
        "and no shade is added to the palette"
    );
    draw(&["lasso", path, "l1", "--box", "8,1,3,4", "--flip", "h"]);
    assert_eq!(rows("l1")[2], "ibb.....iii.");
    draw(&["lasso", path, "l1", "--box", "0,0,3,4", "--rotate", "90"]);
    let turned = rows("l1");
    let count = |sign: char| turned.iter().flat_map(|r| r.chars()).filter(|c| *c == sign).count();
    assert_eq!(
        (count('i'), count('b')),
        (8 + 12 + 1, 4),
        "a quarter turn keeps every pixel: {turned:?}"
    );
    assert_eq!(&turned[1][..4], "iiii", "and the 3 by 4 piece now lies 4 by 3");
    let missing = run(&["strokes", path, "l1", "--entry", "teal"]);
    assert!(String::from_utf8_lossy(&missing.stderr).contains("the palette has no"));
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn pixels_are_shaded_dithered_outlined_and_replaced_from_the_command_line() {
    let dir = std::env::temp_dir().join(format!("draw-binary-shade-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let bundle = dir.join("sprite.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let draw = |args: &[&str]| {
        let out = run(args);
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    let rows = || -> Vec<String> {
        draw(&["pixels", path, "l1", "--plain"])
            .lines()
            .skip_while(|line| !line.is_empty())
            .skip(1)
            .map(String::from)
            .collect()
    };
    draw(&["new", path, "--pixel", "12x8"]);
    draw(&["palette", path, "--ramp", "green", "--base", "#4c9a54", "--steps", "3"]);
    draw(&["palette", path, "--add", "#22223b", "--name", "ink"]);
    draw(&[
        "pixel", path, "l1", "--color", "green-2", "--rect", "4,3,3,2", "--filled",
    ]);
    draw(&["pixel", path, "l1", "--color", "ink", "--outline"]);
    assert_eq!(
        rows()[2..6],
        ["....iii.....", "...iGGGi....", "...iGGGi....", "....iii....."],
        "a one-pixel outline around the block"
    );
    draw(&["pixel", path, "l1", "--shade", "-1", "--rect", "4,4,3,1"]);
    draw(&["pixel", path, "l1", "--shade", "1", "--cells", "4,3"]);
    assert_eq!(
        rows()[3..5],
        ["...iaGGi....", "...igggi...."],
        "a highlight and a darker foot"
    );
    let first = serde_json::from_str::<serde_json::Value>(&draw(&["strokes", path, "l1", "--json"])).unwrap()["fills"]
        [0]["address"]
        .as_str()
        .unwrap()
        .to_string();
    draw(&["recolour", path, &first, "--step", "1"]);
    assert_eq!(
        rows()[3],
        "...iaaai....",
        "the block itself stepped lighter along its ramp"
    );
    draw(&["recolour", path, "--from", "ink", "--to", "green-1"]);
    assert_eq!(rows()[2], "....ggg.....", "every ink mark is the dark green now");
    draw(&[
        "pixel", path, "l1", "--color", "ink", "--second", "green-3", "--dither", "50", "--rect", "8,0,4,2", "--filled",
    ]);
    assert_eq!(
        rows()[..2],
        ["........iaia", "........aiai"],
        "a checkerboard of two colours"
    );
    let none = run(&["recolour", path, &first, "--step", "5"]);
    assert!(String::from_utf8_lossy(&none.stderr).contains("already at its end"));
    let both = run(&["pixel", path, "l1", "--shade", "1", "--color", "ink", "--cells", "1,1"]);
    assert!(!both.status.success());
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn a_tile_wraps_at_its_edges_mirrors_and_renders_repeated_from_the_command_line() {
    let dir = std::env::temp_dir().join(format!("draw-binary-tile-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let bundle = dir.join("tile.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let draw = |args: &[&str]| {
        let out = run(args);
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    let rows = || -> Vec<String> {
        draw(&["pixels", path, "l1", "--plain"])
            .lines()
            .skip_while(|line| !line.is_empty())
            .skip(1)
            .map(String::from)
            .collect()
    };
    draw(&["new", path, "--pixel", "8x4", "--wrap"]);
    assert!(draw(&["canvas", path]).contains("wraps at its edges"));
    draw(&["palette", path, "--add", "#22223b", "--name", "ink"]);
    draw(&["pixel", path, "l1", "--color", "ink", "--rect", "6,3,4,2", "--filled"]);
    assert_eq!(
        rows(),
        ["ii....ii", "........", "........", "ii....ii"],
        "a block over the corner shows in all four corners"
    );
    draw(&[
        "pixel",
        path,
        "l1",
        "--color",
        "ink",
        "--cells",
        "1,1",
        "--mirror-x",
        "4",
        "--mirror-y",
        "2",
    ]);
    assert_eq!(rows()[1..3], [".i....i.", ".i....i."]);
    let shown = run(&["render", path, "--repeat", "3", "--scale", "4"]);
    assert!(
        String::from_utf8_lossy(&shown.stderr).contains("96x48"),
        "three tiles across and down at 4x: {}",
        String::from_utf8_lossy(&shown.stderr)
    );
    draw(&["canvas", path, "--wrap", "off"]);
    assert!(draw(&["canvas", path]).contains("stops at its edges"));
    let json: serde_json::Value = serde_json::from_str(&draw(&["canvas", path, "--json"])).unwrap();
    assert_eq!((json["width"].as_u64(), json.get("wrap")), (Some(8), None));
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn a_pixel_layer_animates_frame_by_frame_moves_by_whole_pixels_and_refuses_in_betweens_and_bones() {
    let dir = std::env::temp_dir().join(format!("draw-binary-pixel-anim-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let bundle = dir.join("hop.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let draw = |args: &[&str]| {
        let out = run(args);
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    let refused = |args: &[&str]| {
        let out = run(args);
        assert!(!out.status.success(), "{args:?} went through");
        String::from_utf8_lossy(&out.stderr).to_string()
    };
    draw(&["new", path, "--pixel", "12x6", "--frames", "4", "--fps", "8"]);
    draw(&["palette", path, "--add", "#22223b", "--name", "ink"]);
    draw(&["pixel", path, "l1", "--color", "ink", "--rect", "1,3,2,2", "--filled"]);
    draw(&["add", path, "cel", "--in", "l1", "frame=2"]);
    draw(&[
        "pixel", path, "l1", "--frame", "2", "--color", "ink", "--rect", "1,1,2,2", "--filled",
    ]);
    let row = |frame: &str, at: usize| -> String {
        draw(&["pixels", path, "l1", "--frame", frame, "--plain"])
            .lines()
            .skip_while(|line| !line.is_empty())
            .skip(1)
            .nth(at)
            .unwrap()
            .to_string()
    };
    assert_eq!(
        (row("0", 3), row("1", 3), row("2", 3), row("2", 1)),
        (
            ".ii.........".to_string(),
            ".ii.........".to_string(),
            "............".to_string(),
            ".ii.........".to_string()
        ),
        "each drawing holds until the next: frames 0 and 1 show the first, 2 and 3 the second"
    );
    draw(&["clip", path, "--add", "hop", "--from", "0", "--to", "3", "--loop"]);
    assert!(draw(&["frames", path]).contains("hop"));
    draw(&["key", path, "l1", "--frame", "0", "x=0"]);
    draw(&["key", path, "l1", "--frame", "3", "x=4"]);
    let hashes = draw(&["hash", path, "--all"]);
    assert_eq!(hashes.lines().count(), 4);
    let shown = |frame: &str| {
        let out = dir.join(format!("f{frame}.png"));
        draw(&["export", path, "--frame", frame, "-o", out.to_str().unwrap()]);
        std::fs::read(&out).unwrap()
    };
    assert_ne!(shown("0"), shown("1"), "the key moves the drawing between frames");
    let onion = run(&["render", path, "--frame", "2", "--overlay", "onion"]);
    assert!(onion.status.success(), "{}", String::from_utf8_lossy(&onion.stderr));
    let between = refused(&["inbetween", path, "--layers", "l1", "--from", "0", "--to", "2"]);
    assert!(
        between.contains("pixel layer") && between.contains("Draw the frames"),
        "{between}"
    );
    draw(&["add", path, "layer", "bones", "name=bones"]);
    let attached = refused(&["attach", path, "l1", "--bend", "--skeleton", "bones"]);
    assert!(
        attached.contains("pixel layer") && attached.contains("off the grid"),
        "{attached}"
    );
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn klad_check_lists_what_stands_out_and_counts_the_details() {
    let dir = std::env::temp_dir().join(format!("draw-binary-check-quiet-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let bundle = dir.join("stud.klad");
    let path = bundle.to_str().unwrap();
    let draw = |args: &[&str]| {
        let out = Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
        assert!(
            out.status.success(),
            "{args:?}: {}",
            String::from_utf8_lossy(&out.stderr)
        );
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    draw(&["new", path, "--pixel", "8x6"]);
    let grid = dir.join("stud.txt");
    std::fs::write(
        &grid,
        "a = #20222e\nb = #6a7088\nc = #c8cedc\ns = #ffcc33\n\naabbb...\naasbb...\nccccc...\n........\n........\n.......s\n",
    )
    .unwrap();
    draw(&["pixel", path, "l1", "--grid", grid.to_str().unwrap()]);
    let listed = draw(&["check", path]);
    assert!(
        listed.contains("frame 0: 1 to look at, 1 small one left out"),
        "{listed}"
    );
    assert!(
        listed.contains("7,5") && listed.contains("alone, outside the shape"),
        "{listed}"
    );
    assert!(
        listed.contains("1 left out: single pixels among other colours") && !listed.contains("2,1 "),
        "{listed}"
    );
    let found: serde_json::Value = serde_json::from_str(&draw(&["check", path, "--json"])).unwrap();
    let small: Vec<&serde_json::Value> = found["findings"]
        .as_array()
        .unwrap()
        .iter()
        .filter(|f| f["minor"] == true)
        .collect();
    assert_eq!(small.len(), 1, "{found}");
    assert_eq!(small[0]["at"], serde_json::json!([2, 1]));
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn a_pixel_drawing_exports_sharp_at_whole_number_scales_as_png_gif_sheet_and_godot_scene() {
    let dir = std::env::temp_dir().join(format!("draw-binary-pixel-export-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let bundle = dir.join("hop.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let draw = |args: &[&str]| {
        let out = run(args);
        assert!(
            out.status.success(),
            "{args:?}: {}",
            String::from_utf8_lossy(&out.stderr)
        );
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    let refused = |args: &[&str]| {
        let out = run(args);
        assert!(!out.status.success(), "{args:?} went through");
        String::from_utf8_lossy(&out.stderr).to_string()
    };
    draw(&["new", path, "--pixel", "16x12", "--frames", "4", "--fps", "8"]);
    draw(&["palette", path, "--add", "#22223b", "--name", "ink"]);
    draw(&["palette", path, "--add", "#ef233c", "--name", "red"]);
    draw(&["pixel", path, "l1", "--color", "ink", "--rect", "2,6,4,4", "--filled"]);
    draw(&["pixel", path, "l1", "--color", "red", "--cells", "3,7 4,7"]);
    draw(&["add", path, "cel", "--in", "l1", "frame=2"]);
    draw(&[
        "pixel", path, "l1", "--frame", "2", "--color", "ink", "--rect", "2,2,4,4", "--filled",
    ]);
    draw(&["clip", path, "--add", "hop", "--from", "0", "--to", "3", "--loop"]);

    let between = refused(&["export", path, "--scale", "2.5"]);
    assert!(
        between.contains("whole-number scales") && between.contains("not 2.5"),
        "{between}"
    );
    assert!(refused(&["export", path, "--scale", "0.5"]).contains("whole-number scales"));
    assert!(refused(&["export", path, "--scale", "65"]).contains("past 64"));
    assert!(refused(&["export", path, "--gif", "--scale", "1.5"]).contains("whole-number scales"));
    let size = |file: &std::path::Path| {
        let png = std::fs::read(file).unwrap();
        (
            u32::from_be_bytes(png[16..20].try_into().unwrap()),
            u32::from_be_bytes(png[20..24].try_into().unwrap()),
        )
    };
    let big = dir.join("big.png");
    draw(&["export", path, "--scale", "32", "-o", big.to_str().unwrap()]);
    assert_eq!(size(&big), (512, 384), "past the old limit of 8");

    let named = draw(&["export", path, "--gif", "--scale", "8"]);
    let gif_path = std::path::PathBuf::from(named.trim());
    assert_eq!(
        gif_path.file_name().unwrap(),
        "[email protected]",
        "one GIF per clip, named for it"
    );
    let gif = std::fs::read(&gif_path).unwrap();
    assert_eq!(&gif[..6], b"GIF89a");
    assert_eq!(
        (
            u16::from_le_bytes([gif[6], gif[7]]),
            u16::from_le_bytes([gif[8], gif[9]])
        ),
        (128, 96)
    );
    assert_eq!(
        &gif[13..19],
        [0x22, 0x22, 0x3b, 0xef, 0x23, 0x3c],
        "the drawing's two colours, exactly"
    );
    let delays: Vec<u16> = gif
        .windows(8)
        .filter(|w| w[0] == 0x21 && w[1] == 0xf9 && w[2] == 4 && w[7] == 0)
        .map(|w| u16::from_le_bytes([w[4], w[5]]))
        .collect();
    assert_eq!(delays, [25, 25], "two drawings, each held two frames at 8 a second");
    assert!(
        gif.windows(11).any(|w| w == b"NETSCAPE2.0"),
        "the clip loops, so the GIF does"
    );
    let mixed = dir.join("mixed.gif");
    draw(&[
        "export",
        path,
        "--gif",
        "hop",
        "--scale",
        "8",
        "--dither",
        "-o",
        mixed.to_str().unwrap(),
    ]);
    assert_eq!(
        std::fs::read(&mixed).unwrap(),
        gif,
        "a drawing of a few colours is exact, so dithering changes nothing"
    );
    assert!(refused(&["export", path, "--dither"]).contains("--gif"));
    let range = dir.join("first.gif");
    draw(&["export", path, "--gif", "0-1", "-o", range.to_str().unwrap()]);
    assert_eq!(u16::from_le_bytes([std::fs::read(&range).unwrap()[6], 0]), 16);

    let sheet = dir.join("sheet.png");
    draw(&[
        "export",
        path,
        "--sheet",
        "all",
        "--scale",
        "3",
        "-o",
        sheet.to_str().unwrap(),
    ]);
    let json: serde_json::Value =
        serde_json::from_str(&std::fs::read_to_string(dir.join("sheet.json")).unwrap()).unwrap();
    let first = &json["frames"][0];
    assert_eq!(
        (
            first["sourceSize"]["w"].as_u64(),
            first["frame"]["w"].as_u64(),
            first["frame"]["h"].as_u64()
        ),
        (Some(48), Some(12), Some(12)),
        "the sheet's cells are the drawing three times over: {first}"
    );

    let game = dir.join("game");
    draw(&["export", path, "--godot", game.to_str().unwrap(), "--scale", "2"]);
    let scene = std::fs::read_to_string(game.join("hop.tscn")).unwrap();
    assert!(
        scene.contains("type=\"AnimatedSprite2D\"") && scene.contains("texture_filter = 1\n"),
        "{scene}"
    );

    let folder = dir.join("into");
    std::fs::create_dir_all(&folder).unwrap();
    let into = folder.to_str().unwrap();
    draw(&["export", path, "--sheet", "all", "-o", into]);
    draw(&["export", path, "--gif", "hop", "--scale", "2", "-o", into]);
    draw(&["export", path, "--frame", "2", "--scale", "2", "-o", into]);
    draw(&["export", path, "--aseprite", "-o", into]);
    let mut inside: Vec<String> = std::fs::read_dir(&folder)
        .unwrap()
        .map(|e| e.unwrap().file_name().to_string_lossy().to_string())
        .collect();
    inside.sort();
    assert_eq!(
        inside,
        [
            "[email protected]",
            "[email protected]",
            "hop-sheet.json",
            "hop-sheet.png",
            "hop.aseprite"
        ],
        "a folder that exists takes every kind of export under its usual name"
    );
    assert!(
        !dir.join("into.png").exists() && !dir.join("into.json").exists(),
        "nothing lands next to the folder"
    );
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn palette_variants_are_made_shown_and_exported_one_by_one() {
    let dir = std::env::temp_dir().join(format!("draw-binary-variants-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let bundle = dir.join("team.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let draw = |args: &[&str]| {
        let out = run(args);
        assert!(
            out.status.success(),
            "{args:?}: {}",
            String::from_utf8_lossy(&out.stderr)
        );
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    let refused = |args: &[&str]| {
        let out = run(args);
        assert!(!out.status.success(), "{args:?} went through");
        String::from_utf8_lossy(&out.stderr).to_string()
    };
    draw(&["new", path, "--pixel", "8x8", "--frames", "2", "--fps", "8"]);
    draw(&["palette", path, "--add", "#22223b", "--name", "ink"]);
    draw(&["palette", path, "--add", "#c0392b", "--name", "team"]);
    draw(&["pixel", path, "l1", "--color", "ink", "--rect", "1,1,6,6"]);
    draw(&["pixel", path, "l1", "--color", "team", "--rect", "2,2,4,4", "--filled"]);
    let row = |at: usize| -> String {
        draw(&["pixels", path, "l1", "--plain"])
            .lines()
            .skip_while(|line| !line.is_empty())
            .skip(1)
            .nth(at)
            .unwrap()
            .to_string()
    };
    let before = row(3);

    draw(&["palette", path, "--new-variant", "blue"]);
    draw(&["palette", path, "--recolour", "team", "--to", "#2a6fdb"]);
    let listed = draw(&["palette", path]);
    assert!(listed.starts_with("showing blue\n"), "{listed}");
    assert!(
        listed.contains("#2a6fdb") && listed.contains("variant blue: team #2a6fdb"),
        "{listed}"
    );
    assert_eq!(row(3), before, "the pixels are the same pixels, in another colour");
    draw(&["palette", path, "--variant", "base"]);
    let listed = draw(&["palette", path]);
    assert!(
        listed.starts_with("showing base\n") && listed.contains("#c0392b"),
        "{listed}"
    );
    assert!(refused(&["palette", path, "--variant", "pink"]).contains("base, blue"));
    assert!(refused(&["palette", path, "--to", "navy"]).contains("--rename-variant"));

    let pixel = |file: &std::path::Path| -> Vec<u8> { std::fs::read(file).unwrap() };
    let named: Vec<String> = draw(&["export", path, "--variants"])
        .lines()
        .map(String::from)
        .collect();
    let names: Vec<String> = named
        .iter()
        .map(|p| {
            std::path::Path::new(p)
                .file_name()
                .unwrap()
                .to_string_lossy()
                .to_string()
        })
        .collect();
    assert_eq!(names, ["team-f0.png", "team-blue-f0.png"]);
    assert_ne!(
        pixel(std::path::Path::new(&named[0])),
        pixel(std::path::Path::new(&named[1]))
    );
    let alone = dir.join("alone.png");
    draw(&["export", path, "--variant", "blue", "-o", alone.to_str().unwrap()]);
    assert_eq!(
        pixel(&alone),
        pixel(std::path::Path::new(&named[1])),
        "one variant by name, while the base is shown"
    );
    draw(&["palette", path, "--variant", "blue"]);
    let shown = dir.join("shown.png");
    draw(&["export", path, "-o", shown.to_str().unwrap()]);
    assert_eq!(
        pixel(&shown),
        pixel(&alone),
        "the same picture as showing the variant and exporting"
    );
    let base = dir.join("base.png");
    draw(&["export", path, "--variant", "base", "-o", base.to_str().unwrap()]);
    assert_eq!(
        pixel(&base),
        pixel(std::path::Path::new(&named[0])),
        "and the base while blue is shown"
    );

    let sheet = dir.join("out").join("sheet.png");
    std::fs::create_dir_all(sheet.parent().unwrap()).unwrap();
    let sheets = draw(&[
        "export",
        path,
        "--sheet",
        "all",
        "--variants",
        "-o",
        sheet.to_str().unwrap(),
    ]);
    assert!(
        sheets.contains("sheet.png") && sheets.contains("sheet-blue.png"),
        "{sheets}"
    );
    assert!(dir.join("out").join("sheet-blue.json").exists());
    let gifs = draw(&["export", path, "--gif", "--variants", "--scale", "2"]);
    assert!(
        gifs.contains("[email protected]") && gifs.contains("[email protected]"),
        "{gifs}"
    );
    let table = |file: &str| std::fs::read(file.trim()).unwrap()[13..19].to_vec();
    let both: Vec<Vec<u8>> = gifs.lines().map(table).collect();
    assert_eq!(both[0], [0x22, 0x22, 0x3b, 0xc0, 0x39, 0x2b]);
    assert_eq!(both[1], [0x22, 0x22, 0x3b, 0x2a, 0x6f, 0xdb]);
    let game = dir.join("game");
    let godot = draw(&["export", path, "--godot", game.to_str().unwrap(), "--variants"]);
    assert!(
        godot.contains("team.tscn") && godot.contains("team-blue.tscn") && godot.contains("team-blue.png"),
        "{godot}"
    );

    draw(&["palette", path, "--rename-variant", "blue", "--to", "navy"]);
    assert!(draw(&["palette", path]).contains("variant navy: team #2a6fdb"));
    draw(&["palette", path, "--rm-variant", "navy"]);
    let listed = draw(&["palette", path]);
    assert!(!listed.contains("showing") && listed.contains("#c0392b"), "{listed}");
    assert!(refused(&["export", path, "--variant", "navy"]).contains("no palette variant"));
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn a_pixel_drawing_goes_out_to_an_aseprite_file_and_comes_back_the_same() {
    let dir = std::env::temp_dir().join(format!("draw-binary-aseprite-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let bundle = dir.join("hero.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let both = |args: &[&str]| {
        let out = run(args);
        assert!(
            out.status.success(),
            "{args:?}: {}",
            String::from_utf8_lossy(&out.stderr)
        );
        (
            String::from_utf8_lossy(&out.stdout).to_string(),
            String::from_utf8_lossy(&out.stderr).to_string(),
        )
    };
    let draw = |args: &[&str]| both(args).0;
    let refused = |args: &[&str]| {
        let out = run(args);
        assert!(!out.status.success(), "{args:?} went through");
        String::from_utf8_lossy(&out.stderr).to_string()
    };
    draw(&["new", path, "--pixel", "12x8", "--frames", "6", "--fps", "10"]);
    draw(&["palette", path, "--add", "#22223b", "--name", "ink"]);
    draw(&["palette", path, "--add", "#ef233c", "--name", "red"]);
    draw(&["palette", path, "--add", "#f0c8a080", "--name", "glow"]);
    draw(&["set", path, "l1", "name=body"]);
    draw(&["pixel", path, "body", "--color", "ink", "--rect", "1,4,3,3", "--filled"]);
    draw(&["add", path, "cel", "--in", "l1", "frame=2"]);
    draw(&[
        "pixel", path, "body", "--frame", "2", "--color", "ink", "--rect", "1,1,3,3", "--filled",
    ]);
    draw(&[
        "pixel", path, "body", "--frame", "2", "--color", "red", "--cells", "2,2",
    ]);
    draw(&["add", path, "cel", "--in", "l1", "frame=5", "link=c2"]);
    let ops = dir.join("fx.jsonl");
    std::fs::write(
        &ops,
        r##"{"op":"add","layer":{"kind":"group","name":"fx","opacity":0.5,"children":[{"kind":"pixel","name":"spark","blend":"screen","visible":false,"cels":[{"frame":1,"hold":2}]}]}}"##,
    )
    .unwrap();
    draw(&["apply", path, "--file", ops.to_str().unwrap()]);
    draw(&[
        "pixel",
        path,
        "spark",
        "--frame",
        "1",
        "--color",
        "glow",
        "--cells",
        "8,1 9,1 9,2",
    ]);
    draw(&["add", path, "layer", "paint", "name=notes"]);
    draw(&["clip", path, "--add", "hop", "--from", "0", "--to", "4", "--loop"]);
    draw(&["clip", path, "--add", "land", "--from", "5", "--to", "5"]);

    let (named, said) = both(&["export", path, "--aseprite"]);
    let file = std::path::PathBuf::from(named.trim());
    assert_eq!(file.file_name().unwrap(), "hero.aseprite");
    assert!(said.contains("left out") && said.contains("notes"), "{said}");
    assert!(said.contains("3 layers") && said.contains("2 tags"), "{said}");
    let bytes = std::fs::read(&file).unwrap();
    assert_eq!(u16::from_le_bytes([bytes[4], bytes[5]]), 0xA5E0);
    assert_eq!(
        u16::from_le_bytes([bytes[6], bytes[7]]),
        5,
        "frames 0-1, 1 (the spark), 2, 3-4 and 5: a frame for each change, not for each klad frame"
    );

    let back = dir.join("back.klad");
    let (_, told) = both(&["import", file.to_str().unwrap(), "-o", back.to_str().unwrap()]);
    assert!(told.contains("6 frames at 10 fps"), "{told}");
    let again = back.to_str().unwrap();
    let grid = |drawing: &str, layer: &str, frame: u32| -> Vec<String> {
        draw(&["pixels", drawing, layer, "--frame", &frame.to_string(), "--plain"])
            .lines()
            .skip_while(|line| !line.is_empty())
            .skip(1)
            .map(String::from)
            .collect()
    };
    (0..6).for_each(|frame| {
        assert_eq!(
            grid(again, "body", frame),
            grid(path, "body", frame),
            "body, frame {frame}"
        );
        assert_eq!(
            grid(again, "spark", frame),
            grid(path, "spark", frame),
            "spark, frame {frame}"
        );
    });
    let listed = draw(&["ls", again]);
    assert!(
        listed.contains("group") && listed.contains("fx") && listed.contains("hidden"),
        "{listed}"
    );
    assert!(!listed.contains("notes"));
    let doc: serde_json::Value =
        serde_json::from_str(&std::fs::read_to_string(back.join("doc.json")).unwrap()).unwrap();
    let fx = doc["layers"]
        .as_array()
        .unwrap()
        .iter()
        .find(|l| l["name"] == "fx")
        .unwrap();
    assert!(
        (fx["opacity"].as_f64().unwrap() - 0.5).abs() < 0.003,
        "the group keeps its opacity, to the nearest of 255 steps: {fx}"
    );
    assert_eq!(
        fx["children"][0]["blend"], "screen",
        "and the layer its blend mode: {fx}"
    );
    let colours = draw(&["palette", again]);
    assert!(
        colours.contains("#f0c8a080") && colours.contains("glow") && colours.contains("ink"),
        "{colours}"
    );
    let timeline = draw(&["frames", again]);
    assert!(
        timeline.contains("clip hop  frames 0 to 4") && timeline.contains("loops"),
        "{timeline}"
    );
    assert!(timeline.contains("clip land  frames 5 to 5"), "{timeline}");
    assert!(timeline.contains("->"), "the linked drawing stays a link: {timeline}");
    assert_eq!(
        draw(&["hash", again, "--all"])
            .lines()
            .map(|l| l.split_whitespace().last().unwrap().to_string())
            .collect::<Vec<_>>(),
        draw(&["hash", path, "--all"])
            .lines()
            .map(|l| l.split_whitespace().last().unwrap().to_string())
            .collect::<Vec<_>>(),
        "every frame renders the same"
    );

    assert!(refused(&["import", file.to_str().unwrap(), "-o", again]).contains("is there already"));
    assert!(refused(&["import", path]).contains("Aseprite files"));
    let fake = dir.join("fake.ase");
    std::fs::write(&fake, b"not a sprite at all").unwrap();
    assert!(refused(&["import", fake.to_str().unwrap()]).contains("not an Aseprite file"));
    assert!(!dir.join("fake.klad").exists());
    let painting = dir.join("painting.klad");
    draw(&["new", painting.to_str().unwrap(), "--width", "64", "--height", "64"]);
    assert!(refused(&["export", painting.to_str().unwrap(), "--aseprite"]).contains("no pixel layers"));
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn pictures_and_painted_layers_become_pixels_on_the_palette() {
    let dir = std::env::temp_dir().join(format!("draw-binary-pixelize-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let bundle = dir.join("hop.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let both = |args: &[&str]| {
        let out = run(args);
        assert!(
            out.status.success(),
            "{args:?}: {}",
            String::from_utf8_lossy(&out.stderr)
        );
        (
            String::from_utf8_lossy(&out.stdout).to_string(),
            String::from_utf8_lossy(&out.stderr).to_string(),
        )
    };
    let draw = |args: &[&str]| both(args).0;
    let refused = |args: &[&str]| {
        let out = run(args);
        assert!(!out.status.success(), "{args:?} went through");
        String::from_utf8_lossy(&out.stderr).to_string()
    };
    let rows = |drawing: &str, layer: &str| -> Vec<String> {
        draw(&["pixels", drawing, layer, "--plain"])
            .lines()
            .skip_while(|line| !line.is_empty())
            .skip(1)
            .map(String::from)
            .collect()
    };
    draw(&["new", path, "--pixel", "16x12"]);
    draw(&["palette", path, "--add", "#22223b", "--name", "ink"]);
    draw(&["palette", path, "--add", "#ef233c", "--name", "red"]);
    draw(&["pixel", path, "l1", "--color", "ink", "--rect", "2,6,4,4", "--filled"]);
    draw(&["pixel", path, "l1", "--color", "red", "--cells", "3,7 4,7"]);
    let png = dir.join("[email protected]");
    draw(&["export", path, "--scale", "8", "-o", png.to_str().unwrap()]);

    let back = dir.join("back.klad");
    let (named, told) = both(&[
        "import",
        png.to_str().unwrap(),
        "--size",
        "16",
        "-o",
        back.to_str().unwrap(),
    ]);
    assert_eq!(named.trim(), back.to_str().unwrap());
    assert!(told.contains("16x12, 2 palette colours"), "{told}");
    let again = back.to_str().unwrap();
    let swapped =
        |rows: Vec<String>| -> Vec<String> { rows.iter().map(|r| r.replace('a', "i").replace('b', "r")).collect() };
    assert_eq!(
        swapped(rows(again, "l1")),
        rows(path, "l1"),
        "a picture enlarged eight times comes back exact"
    );
    let own = draw(&["import", png.to_str().unwrap()]);
    assert!(own.trim().ends_with("[email protected]"));
    assert!(
        draw(&["info", own.trim()]).contains("128x96"),
        "without --size a small picture keeps its size"
    );
    assert!(refused(&["import", png.to_str().unwrap(), "-o", again]).contains("is there already"));
    assert!(
        refused(&[
            "import",
            png.to_str().unwrap(),
            "--size",
            "900",
            "-o",
            dir.join("x.klad").to_str().unwrap()
        ])
        .contains("past 512")
    );
    assert!(refused(&["import", dir.join("notes.txt").to_str().unwrap()]).contains("Aseprite files"));

    let (_, told) = both(&[
        "pixelize",
        path,
        "--image",
        png.to_str().unwrap(),
        "--to",
        "l1",
        "--size",
        "8",
        "--at",
        "8,0",
    ]);
    assert!(
        told.contains("8x6 pixels in 1 colour on") && told.contains("nearest of the palette's 2 colours"),
        "at half the size the two red pixels are a quarter of their blocks, so the blocks are ink: {told}"
    );
    let placed = rows(path, "l1");
    assert_eq!(
        (placed[3].as_str(), placed[4].as_str(), placed[6].as_str()),
        (".........ii.....", ".........ii.....", "..iiii.........."),
        "the small copy sits beside the first, in the same palette colour"
    );
    assert_eq!(
        draw(&["palette", path]).lines().count(),
        2,
        "nothing was added to the palette"
    );
    let (_, told) = both(&[
        "pixelize",
        path,
        "--image",
        png.to_str().unwrap(),
        "--to",
        "l1",
        "--size",
        "8",
        "--colors",
        "2",
        "--at",
        "0,0",
    ]);
    assert!(
        told.contains("8x6 pixels in 2 colours"),
        "with colours made from the picture, the blocks that held a red pixel keep their own mix: {told}"
    );
    assert_eq!(
        draw(&["palette", path]).lines().count(),
        3,
        "the mixed colour joined the palette; ink was there already"
    );
    let quarter = refused(&[
        "pixelize",
        path,
        "--image",
        png.to_str().unwrap(),
        "--to",
        "l1",
        "--size",
        "4",
    ]);
    assert!(
        quarter.contains("no solid pixels"),
        "at a quarter of the size no block is half covered: {quarter}"
    );
    assert!(
        refused(&[
            "pixelize",
            path,
            "--image",
            png.to_str().unwrap(),
            "--to",
            "l1",
            "--at",
            "40,40"
        ])
        .contains("no solid pixels")
    );
    assert!(
        refused(&[
            "pixelize",
            path,
            "--image",
            png.to_str().unwrap(),
            "--to",
            "l1",
            "--colors",
            "1"
        ])
        .contains("2 to 256")
    );

    let painting = dir.join("sign.klad");
    let sign = painting.to_str().unwrap();
    draw(&[
        "new", sign, "--width", "320", "--height", "160", "--frames", "3", "--fps", "6",
    ]);
    draw(&["add", sign, "layer", "vector", "name=board"]);
    let board = draw(&["ls", sign])
        .lines()
        .find(|l| l.contains("board"))
        .unwrap()
        .split_whitespace()
        .next()
        .unwrap()
        .to_string();
    draw(&[
        "add",
        sign,
        "rect",
        "--in",
        &board,
        "x=40",
        "y=40",
        "w=240",
        "h=80",
        "fill=#8b5a2b",
    ]);
    draw(&[
        "add",
        sign,
        "ellipse",
        "--in",
        &board,
        "cx=160",
        "cy=80",
        "rx=30",
        "ry=30",
        "fill=#f0c8a0",
    ]);
    draw(&["clip", sign, "--add", "sway", "--from", "0", "--to", "2", "--loop"]);
    assert!(refused(&["pixelize", sign]).contains("give --size"));
    let (named, told) = both(&["pixelize", sign, "--layer", "board", "--size", "32"]);
    let made = named.trim().to_string();
    assert!(made.ends_with("sign-board-pixel.klad"), "{made}");
    assert!(told.contains("32x16, 3 frames (1 drawing)"), "{told}");
    let pixels = rows(&made, "board");
    assert_eq!(pixels.len(), 16);
    assert_eq!(
        pixels[4],
        format!("....{}....", pixels[4][4..5].repeat(24)),
        "the board is one colour across, from 40 to 280 of 320"
    );
    assert_ne!(
        pixels[8].chars().nth(16),
        pixels[8].chars().nth(5),
        "with the disc in another colour"
    );
    assert!(
        pixels[0].chars().all(|c| c == '.'),
        "and nothing where the layer is clear"
    );
    let timeline = draw(&["frames", &made]);
    assert!(
        timeline.contains("3 frames at 6 fps") && timeline.contains("clip sway"),
        "{timeline}"
    );
    assert!(
        draw(&["ls", sign]).contains("board"),
        "the painting itself is unchanged"
    );
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn a_drawing_cut_into_tiles_is_read_drawn_and_exported_tile_by_tile() {
    let dir = std::env::temp_dir().join(format!("draw-binary-tiles-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(dir.join("game")).unwrap();
    let bundle = dir.join("ground.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let both = |args: &[&str]| {
        let out = run(args);
        assert!(
            out.status.success(),
            "{args:?}: {}",
            String::from_utf8_lossy(&out.stderr)
        );
        (
            String::from_utf8_lossy(&out.stdout).to_string(),
            String::from_utf8_lossy(&out.stderr).to_string(),
        )
    };
    let draw = |args: &[&str]| both(args).0;
    let refused = |args: &[&str]| {
        let out = run(args);
        assert!(!out.status.success(), "{args:?} went through");
        String::from_utf8_lossy(&out.stderr).to_string()
    };
    let odd = dir.join("odd.klad");
    assert!(
        refused(&["new", odd.to_str().unwrap(), "--pixel", "50x32", "--tile", "16"])
            .contains("does not cut into tiles")
    );
    assert!(!odd.exists(), "a drawing that cannot be cut is not left behind");
    draw(&["new", path, "--pixel", "48x32", "--tile", "16"]);
    assert!(draw(&["canvas", path]).contains("tiles of 16x16, 3 across and 2 down"));
    draw(&["palette", path, "--add", "#3a5a40", "--name", "grass"]);
    draw(&["palette", path, "--add", "#8b5a2b", "--name", "dirt"]);
    draw(&[
        "pixel",
        path,
        "l1",
        "--color",
        "grass",
        "--rect",
        "0,0,16,16",
        "--filled",
    ]);
    let grid = dir.join("tile.txt");
    std::fs::write(&grid, "d = dirt\n\ndddd\nd..d\ndddd\n").unwrap();
    draw(&["pixel", path, "l1", "--grid", grid.to_str().unwrap(), "--tile", "2,1"]);
    let whole = draw(&["pixels", path, "l1", "--plain"]);
    let rows: Vec<&str> = whole.lines().skip_while(|l| !l.is_empty()).skip(1).collect();
    assert_eq!(
        &rows[16][32..36],
        "dddd",
        "the grid went to the tile's own corner, canvas pixel 32,16"
    );
    assert_eq!(&rows[17][32..36], "d..d");
    let tile = draw(&["pixels", path, "l1", "--tile", "2,1", "--plain"]);
    let cut: Vec<&str> = tile.lines().skip_while(|l| !l.is_empty()).skip(1).collect();
    assert_eq!(cut.len(), 16, "one tile is 16 rows");
    assert_eq!(
        (cut[0], cut[1], cut[3]),
        ("dddd............", "d..d............", "................")
    );
    assert!(draw(&["pixels", path, "l1", "--tile", "2,1"]).contains("tile 2,1 (its top left is canvas pixel 32,16)"));
    assert!(refused(&["pixels", path, "l1", "--tile", "3,0"]).contains("3 by 2 tiles"));

    let art = dir.join("game").join("art");
    let (named, told) = both(&["export", path, "--tileset", art.to_str().unwrap()]);
    assert!(
        named.contains("ground-tiles.png") && named.contains("ground-tiles.tres"),
        "{named}"
    );
    assert!(
        told.contains("2 tiles of 16x16 (3 across, 2 down, 4 empty left out)"),
        "{told}"
    );
    assert!(told.contains("texture filter to Nearest"), "{told}");
    let tres = std::fs::read_to_string(art.join("ground-tiles.tres")).unwrap();
    assert!(
        tres.contains("tile_size = Vector2i(16, 16)") && tres.contains("0:0/0 = 0") && tres.contains("2:1/0 = 0"),
        "{tres}"
    );
    let png = std::fs::read(art.join("ground-tiles.png")).unwrap();
    assert_eq!(u32::from_be_bytes(png[16..20].try_into().unwrap()), 48);
    draw(&["export", path, "--tileset"]);

    draw(&["canvas", path, "--tile", "off"]);
    assert!(!draw(&["canvas", path]).contains("tiles of"));
    assert!(refused(&["export", path, "--tileset"]).contains("not cut into tiles"));
    assert!(refused(&["pixels", path, "l1", "--tile", "0,0"]).contains("not cut into tiles"));
    draw(&["canvas", path, "--tile", "24x16", "--wrap", "on"]);
    assert!(draw(&["canvas", path]).contains("wraps at its edges  tiles of 24x16, 2 across and 2 down"));
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn klad_check_lists_the_slips_of_pixel_art_with_their_places() {
    let dir = std::env::temp_dir().join(format!("draw-binary-check-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let bundle = dir.join("slips.klad");
    let path = bundle.to_str().unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let draw = |args: &[&str]| {
        let out = run(args);
        assert!(
            out.status.success(),
            "{args:?}: {}",
            String::from_utf8_lossy(&out.stderr)
        );
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    let refused = |args: &[&str]| {
        let out = run(args);
        assert!(!out.status.success(), "{args:?} went through");
        String::from_utf8_lossy(&out.stderr).to_string()
    };
    draw(&["new", path, "--pixel", "24x16", "--frames", "3"]);
    draw(&["palette", path, "--add", "#1b1b2f", "--name", "dark"]);
    draw(&["palette", path, "--add", "#5a6e9a", "--name", "mid"]);
    draw(&["palette", path, "--add", "#cfd8ea", "--name", "light"]);
    draw(&["palette", path, "--add", "#22223b", "--name", "ink"]);
    draw(&["set", path, "l1", "name=body"]);
    assert!(draw(&["check", path]).contains("body (l1), frame 0: nothing to look at"));
    let grid = dir.join("slips.txt");
    std::fs::write(
        &grid,
        "d = dark\nm = mid\nl = light\ni = ink\n\n\
         dddddd..........i.......\n\
         mmmmmm..................\n\
         llllll..................\n\
         ........................\n\
         iiii....................\n\
         ....i...................\n\
         .....iiii...............\n\
         ........................\n\
         i.......................\n\
         .ii.....................\n\
         ..i.....................\n\
         ...i....................\n",
    )
    .unwrap();
    draw(&["pixel", path, "body", "--grid", grid.to_str().unwrap()]);
    draw(&["pixel", path, "body", "--color", "#ff00ff", "--cells", "20,12 21,12"]);
    draw(&["palette", path, "--rm", "#ff00ff"]);
    let listed = draw(&["check", path]);
    assert!(listed.contains("body (l1), frame 0:"), "{listed}");
    let line = |kind: &str| {
        listed
            .lines()
            .find(|l| l.trim_start().starts_with(kind))
            .unwrap_or_else(|| panic!("no {kind} in:\n{listed}"))
            .to_string()
    };
    assert!(
        line("stray pixel").contains("16,0") && line("stray pixel").contains("ink"),
        "{listed}"
    );
    assert!(line("doubled corner").contains("2,9"), "{listed}");
    assert!(
        line("jagged line").contains("4,5") && line("jagged line").contains("a run of 1 between runs of 4 and 4"),
        "{listed}"
    );
    assert!(
        line("banding").contains("0,1 to 5,1")
            && line("banding").contains("mid")
            && line("banding").contains("between dark and light"),
        "{listed}"
    );
    assert!(
        line("off the palette").contains("20,12")
            && line("off the palette").contains("#ff00ff")
            && line("off the palette").contains("2 pixels"),
        "{listed}"
    );
    assert!(listed.contains("not errors"), "{listed}");
    let found: serde_json::Value = serde_json::from_str(&draw(&["check", path, "body", "--json"])).unwrap();
    let kinds: std::collections::BTreeSet<&str> = found["findings"]
        .as_array()
        .unwrap()
        .iter()
        .map(|f| f["kind"].as_str().unwrap())
        .collect();
    assert_eq!(
        kinds.into_iter().collect::<Vec<_>>(),
        ["banding", "corner", "jagged", "off-palette", "stray"]
    );
    assert_eq!(found["checked"][0]["name"], "body");
    draw(&["add", path, "cel", "--in", "l1", "frame=2"]);
    let every = draw(&["check", path, "--all"]);
    assert!(
        every.contains("frame 0:") && every.contains("body (l1), frame 2: nothing to look at"),
        "{every}"
    );
    assert_eq!(
        every.matches("body (l1), frame").count(),
        2,
        "each drawing once, not each frame: {every}"
    );
    assert!(refused(&["check", path, "--frame", "9"]).contains("past the last frame"));
    let painting = dir.join("painting.klad");
    draw(&["new", painting.to_str().unwrap(), "--width", "64", "--height", "64"]);
    assert!(refused(&["check", painting.to_str().unwrap()]).contains("no pixel layers"));
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn recolour_moves_strokes_together_and_keeps_their_shades() {
    let dir = std::env::temp_dir().join(format!("draw-binary-recolour-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    let bundle = dir.join("a.klad");
    let path = bundle.to_str().unwrap();
    let draw = |args: &[&str]| {
        let out = Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    draw(&["new", path, "--width", "200", "--height", "100"]);
    draw(&["stroke", path, "l1", "--path", "M10 10 L190 10", "--color", "#2f5a30"]);
    draw(&["stroke", path, "l1", "--path", "M10 50 L190 50", "--color", "#a8dc84"]);
    draw(&["recolour", path, "c2:s1", "c2:s2", "--to", "#e3962f"]);
    let listed: serde_json::Value = serde_json::from_str(&draw(&["strokes", path, "l1", "--json"])).unwrap();
    let colours: Vec<String> = listed["strokes"]
        .as_array()
        .unwrap()
        .iter()
        .map(|s| s["color"].as_str().unwrap().to_string())
        .collect();
    let lab = |hex: &str| klad_core::color::to_oklab(klad_core::color::parse_hex(hex).unwrap());
    assert!(lab(&colours[0])[0] < lab(&colours[1])[0], "{colours:?}");
    assert!(colours.iter().all(|c| lab(c)[2] > 0.05), "both warm now: {colours:?}");
    let log = draw(&["log", path]);
    assert_eq!(log.matches("cli").count(), 3, "one history step: {log}");
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn an_eraser_stroke_attaches_to_the_lines_it_crosses_and_says_so() {
    let dir = std::env::temp_dir().join(format!("draw-binary-attach-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    let bundle = dir.join("a.klad");
    let path = bundle.to_str().unwrap();
    let draw = |args: &[&str]| {
        let out = Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    draw(&["new", path, "--width", "200", "--height", "100"]);
    draw(&["stroke", path, "l1", "--path", "M10 20 L190 20"]);
    draw(&["stroke", path, "l1", "--path", "M10 80 L190 80"]);
    draw(&[
        "stroke",
        path,
        "l1",
        "--brush",
        "eraser",
        "--size",
        "12",
        "--path",
        "M100 5 L100 35",
    ]);
    let listed: serde_json::Value = serde_json::from_str(&draw(&["strokes", path, "l1", "--json"])).unwrap();
    let strokes = listed["strokes"].as_array().unwrap();
    assert_eq!(strokes[2]["on"], serde_json::json!(["c2:s1"]));
    assert_eq!(strokes[0]["attached"], serde_json::json!(["c2:s3"]));
    assert!(strokes[1].get("attached").is_none());
    assert!(draw(&["strokes", path, "l1"]).contains("on s1"));
    assert!(strokes.iter().all(|s| s.get("hidden").is_none()), "cut, not wiped");
    draw(&["stroke", path, "l1", "--path", "M150 50 L160 50"]);
    draw(&[
        "stroke",
        path,
        "l1",
        "--brush",
        "eraser",
        "--size",
        "40",
        "--path",
        "M140 50 L170 50",
    ]);
    let wiped: serde_json::Value = serde_json::from_str(&draw(&["strokes", path, "l1", "--json"])).unwrap();
    assert_eq!(wiped["strokes"][3]["hidden"], serde_json::json!(true));
    draw(&["detach", path, "c2:s1"]);
    let listed: serde_json::Value = serde_json::from_str(&draw(&["strokes", path, "l1", "--json"])).unwrap();
    assert!(listed["strokes"][2].get("on").is_none(), "detached from its line");
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn modifiers_move_go_and_copy_with_their_marks_and_attach_again_when_moved_alone() {
    let dir = std::env::temp_dir().join(format!("draw-binary-follow-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    let bundle = dir.join("a.klad");
    let path = bundle.to_str().unwrap();
    let draw = |args: &[&str]| {
        let out = Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    let listed = |frame: &str| -> Vec<serde_json::Value> {
        let text = draw(&["strokes", path, "l1", "--frame", frame, "--json"]);
        let value: serde_json::Value = serde_json::from_str(&text).unwrap();
        value["strokes"].as_array().unwrap().clone()
    };
    draw(&["new", path, "--width", "400", "--height", "200"]);
    draw(&["stroke", path, "l1", "--path", "M10 40 L390 40"]);
    draw(&["stroke", path, "l1", "--path", "M10 140 L390 140"]);
    draw(&[
        "stroke",
        path,
        "l1",
        "--brush",
        "eraser",
        "--size",
        "12",
        "--path",
        "M100 25 L100 55",
    ]);
    draw(&["transform", path, "c2:s1", "--move", "0,20"]);
    let eraser = listed("0")[2].clone();
    assert_eq!(eraser["on"], serde_json::json!(["c2:s1"]));
    assert_eq!(
        eraser["bounds"][1],
        serde_json::json!(45.0),
        "the eraser came along with its line"
    );
    draw(&["transform", path, "c2:s3", "--move", "0,80"]);
    assert_eq!(
        listed("0")[2]["on"],
        serde_json::json!(["c2:s2"]),
        "moved on its own, it attaches to what it lands on"
    );
    draw(&["rm", path, "c2:s2"]);
    assert_eq!(listed("0").len(), 1, "the eraser went with the only line it was on");
    draw(&[
        "stroke",
        path,
        "l1",
        "--brush",
        "eraser",
        "--size",
        "12",
        "--path",
        "M200 45 L200 75",
    ]);
    let map = draw(&["copy", path, "c2:s1", "--frame", "4"]);
    assert_eq!(map.matches("->").count(), 2, "the line and its eraser: {map}");
    let copies = listed("4");
    assert_eq!(copies.len(), 2);
    assert_eq!(copies[1]["on"], serde_json::json!([copies[0]["address"]]));
    std::fs::remove_dir_all(&dir).unwrap();
}

#[test]
fn a_brush_with_a_feathered_or_fringed_edge_goes_in_from_the_command_line() {
    let dir = std::env::temp_dir().join(format!("draw-binary-feather-{}", std::process::id()));
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).unwrap();
    let run = |args: &[&str]| Command::new(env!("CARGO_BIN_EXE_klad")).args(args).output().unwrap();
    let draw = |args: &[&str]| {
        let out = run(args);
        assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
        String::from_utf8_lossy(&out.stdout).to_string()
    };
    let eraser = |feather: &str, fringe: &str| {
        format!(
            r#"{{"format":"klad-brush/1","name":"Eraser","tip":{{"round":{{"hardness":0.85}}}},"spacing":0.06,"blend":"erase","feather":{feather},"fringe":{fringe}}}"#
        )
    };
    let hash = |name: &str, brush: Option<String>| {
        let path = dir.join(format!("{name}.klad"));
        let path = path.to_str().unwrap();
        draw(&["new", path, "--width", "200", "--height", "100"]);
        draw(&[
            "fill",
            path,
            "l1",
            "--polygon",
            "0,0 200,0 200,100 0,100",
            "--color",
            "#204060",
        ]);
        let id = match brush {
            Some(def) => {
                let file = dir.join(format!("{name}.json"));
                std::fs::write(&file, def).unwrap();
                assert!(draw(&["brushes", path, "--set", "soft-eraser", file.to_str().unwrap()]).contains("added"));
                "soft-eraser"
            }
            None => "eraser",
        };
        draw(&[
            "stroke",
            path,
            "l1",
            "--brush",
            id,
            "--size",
            "40",
            "--path",
            "M20 50 L180 50",
        ]);
        let out = run(&["render", path, "-o", dir.join(format!("{name}.png")).to_str().unwrap()]);
        let said = String::from_utf8_lossy(&out.stderr).to_string() + &String::from_utf8_lossy(&out.stdout);
        (
            draw(&["brushes", path]),
            said.split("hash ").nth(1).unwrap()[..16].to_string(),
        )
    };
    let (_, plain) = hash("plain", None);
    let (listed, feathered) = hash("feathered", Some(eraser("0.8", "0")));
    assert!(listed.contains("round 0.85 +feather"), "{listed}");
    assert_ne!(plain, feathered, "the feather softens the edge");
    let (listed, fringed) = hash("fringed", Some(eraser("0", "1")));
    assert!(listed.contains("round 0.85 +fringe"), "{listed}");
    assert_ne!(plain, fringed, "the fringe frays it");
    let file = dir.join("bad.json");
    std::fs::write(&file, eraser("2", "0")).unwrap();
    let path = dir.join("plain.klad");
    let out = run(&[
        "brushes",
        path.to_str().unwrap(),
        "--set",
        "bad",
        file.to_str().unwrap(),
    ]);
    assert!(!out.status.success());
    assert!(String::from_utf8_lossy(&out.stderr).contains("feather"));
    let _ = std::fs::remove_dir_all(&dir);
}