Files
chasse20 4b5c27188c Auto: Fix HDR mipmaps and reuse image processing buffers
Prevent overflow in nearest-filter mipmaps and retain regression coverage. Reuse pattern, precision, channel and blur buffers. Wait for asynchronous parameter cooks in snapshot tests. Complete scoped cleanup and remove confirmed unused dependencies. Validated affected release suites, Clippy, layering, wasm, hostile-input checks and all 43 offscreen snapshots.
2026-11-17 03:28:21 +00:00

519 lines
25 KiB
Rust

use materialcraft_engine::{Session, command_specs, execute, sample_session};
use serde_json::{Value, json};
fn run(s: &mut Session, id: &str, p: Value) -> Value {
execute(s, id, &p).unwrap_or_else(|e| panic!("{id}: {e}"))
}
#[test]
fn every_template_cooks_cleanly() {
let mut s = sample_session();
s.preview_size = Some(128);
for (id, _) in materialcraft_engine::samples::TEMPLATES {
run(&mut s, "file.new", json!({"template": id, "size": 256}));
let c = s.cook().clone();
let g = s.graph().unwrap();
for (nid, r) in &c.nodes {
assert!(r.error.is_none(), "{id}: node {} ({}) failed: {:?}", nid.0, g.node(*nid).unwrap().def, r.error);
}
if *id != "empty" {
assert!(!s.material_maps().is_empty(), "{id} has no outputs");
}
}
}
#[test]
fn build_a_graph_by_commands() {
let mut s = sample_session();
run(&mut s, "file.new", json!({"template": "empty", "name": "Mine"}));
let noise = run(&mut s, "graph.node.add", json!({"def": "blur", "at": [0, 0], "params": {"intensity": 6}}))["id"].as_u64().unwrap();
let lv = run(&mut s, "graph.node.add", json!({"def": "levels", "connectFrom": {"node": noise}}))["id"].as_u64().unwrap();
let out = run(&mut s, "graph.node.add", json!({"def": "output", "at": [400, 0], "params": {"usage": 4}}))["id"].as_u64().unwrap();
run(&mut s, "graph.connect", json!({"from": lv, "to": out}));
run(&mut s, "graph.node.param", json!({"id": lv, "param": "in_low", "value": 0.3}));
run(&mut s, "graph.node.param", json!({"id": lv, "param": "in_low", "value": 0.4}));
// A slider drag is one undo step
assert_eq!(s.history().iter().filter(|h| *h == "Set parameter").count(), 1);
s.cook();
let i = run(&mut s, "session.inspect", json!({}));
let nodes = i["graph"]["nodes"].as_array().unwrap();
assert_eq!(nodes.len(), 3);
assert!(nodes.iter().all(|n| n["cooked"]["error"].is_null()));
assert_eq!(i["graph"]["connections"].as_array().unwrap().len(), 2);
// Bad input is an error, not a panic, and leaves the graph unchanged
assert!(execute(&mut s, "graph.connect", &json!({"from": out, "to": noise})).is_err());
assert!(execute(&mut s, "graph.node.param", &json!({"id": lv, "param": "nope", "value": 1})).is_err());
assert!(execute(&mut s, "graph.node.add", &json!({"def": "nope"})).is_err());
// Undo and redo
run(&mut s, "edit.undo", json!({}));
run(&mut s, "edit.redo", json!({}));
// Copy/paste and duplicate
run(&mut s, "graph.select", json!({"ids": [noise, lv]}));
run(&mut s, "edit.copy", json!({}));
run(&mut s, "edit.paste", json!({"at": [0, 300]}));
assert_eq!(s.graph().unwrap().nodes.len(), 5);
assert_eq!(s.graph().unwrap().connections.len(), 3);
run(&mut s, "edit.duplicate", json!({}));
assert_eq!(s.graph().unwrap().nodes.len(), 7);
// Create a graph from a selection: the nodes move into a sub-graph instance
run(&mut s, "graph.select", json!({"ids": [lv]}));
let r = run(&mut s, "graph.createFromSelection", json!({"name": "Leveler"}));
assert_eq!(r["graph"], "Leveler");
s.cook();
assert!(s.cooked.nodes.values().all(|r| r.error.is_none()));
// Exposed inputs drive bound parameters
run(&mut s, "graph.open", json!({"graph": "Mine"}));
run(&mut s, "graph.exposed.add", json!({"id": "detail", "bind": {"node": noise, "param": "intensity"}}));
run(&mut s, "graph.exposed.set", json!({"id": "detail", "value": 12}));
s.cook();
assert!(s.cooked.nodes.values().all(|r| r.error.is_none()));
}
#[test]
fn package_save_and_open_round_trip() {
let mut s = Session::new(materialcraft_engine::atomic_sample().unwrap());
let dir = std::env::temp_dir().join(format!("mc-test-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("atomics.sbs");
run(&mut s, "file.save", json!({"path": path.to_str().unwrap()}));
let before = s.pkg.clone();
run(&mut s, "file.newPackage", json!({}));
run(&mut s, "file.open", json!({"path": path.to_str().unwrap()}));
assert_eq!(s.pkg.graphs[0].nodes.len(), before.graphs[0].nodes.len());
let out = dir.join("tex");
let r = run(&mut s, "file.export", json!({"dir": out.to_str().unwrap(), "format": "png", "depth": 8}));
assert_eq!(r["files"].as_array().unwrap().len(), 1);
let small = dir.join("small");
run(&mut s, "file.export", json!({"dir": small.to_str().unwrap(), "format": "png", "depth": 8, "size": 64}));
let file = std::fs::read_dir(&small).unwrap().next().unwrap().unwrap().path();
let img = materialcraft_formats::decode(&std::fs::read(file).unwrap(), false).unwrap();
assert_eq!((img.width(), img.height()), (64, 64));
let _ = std::fs::remove_dir_all(&dir);
}
/// `file.export` `size` is the larger side in pixels or [width, height]; 0 means the graph's size and the proportions are kept
#[test]
fn export_size_keeps_proportions_and_clamps() {
use materialcraft_engine::{ExportRequest, ExportSize};
let mut s = sample_session();
s.pkg.graphs[0].size = [7, 6];
let dims = |s: &Session, size: Value| {
let request = ExportRequest::from_params(s, &json!({"size": size})).unwrap();
let files = materialcraft_engine::file_cmds::export_outputs(s, &request).unwrap();
files.iter().map(|f| materialcraft_formats::decode(&f.bytes, false).unwrap()).map(|i| (i.width(), i.height())).collect::<Vec<_>>()
};
let parsed = |s: &Session, size: Value| ExportRequest::from_params(s, &json!({"size": size})).map(|request| request.size);
for size in [json!(0), json!(null)] {
assert!(dims(&s, size).iter().all(|d| *d == (128, 64)));
}
assert!(dims(&s, json!(32)).iter().all(|d| *d == (32, 16)));
assert!(dims(&s, json!([16, 100])).iter().all(|d| *d == (16, 64)), "each side rounds down to a power of two");
assert_eq!(parsed(&s, json!(0)).unwrap(), None);
assert_eq!(parsed(&s, json!(u64::MAX)).unwrap(), Some(ExportSize::LargerSide(u32::MAX)));
assert_eq!(parsed(&s, json!([1, u64::MAX])).unwrap(), Some(ExportSize::Exact([1, u32::MAX])));
for invalid in [json!("large"), json!([64]), json!([64, "wide"]), json!([64, 64, 64])] {
assert!(parsed(&s, invalid.clone()).is_err(), "{invalid}");
}
s.pkg.graphs[0].size = [u32::MAX, u32::MAX];
assert!(dims(&s, json!(32)).iter().all(|d| *d == (32, 32)));
assert!(dims(&s, json!([1, u64::MAX])).iter().all(|d| *d == (16, 8192)), "sides clamp to 16..8192");
}
/// A scratch folder for one test, removed when dropped
struct TempDir(std::path::PathBuf);
impl TempDir {
fn new(name: &str) -> TempDir {
let dir = std::env::temp_dir().join(format!("mc-{name}-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
TempDir(dir)
}
fn file(&self, name: &str) -> String {
self.0.join(name).to_str().unwrap().to_string()
}
}
impl Drop for TempDir {
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
#[test]
fn native_sbs_is_the_default_save_format() {
let directory = TempDir::new("sbs-default");
let mut session = Session::new(materialcraft_engine::atomic_sample().unwrap());
let saved = run(&mut session, "file.save", json!({"path": directory.file("atomics")}))["path"].as_str().unwrap().to_string();
assert!(saved.ends_with("atomics.sbs"));
assert!(std::fs::read(&saved).unwrap().starts_with(b"<?xml"));
run(&mut session, "file.newPackage", json!({}));
let opened = run(&mut session, "file.open", json!({"path": saved}));
assert_eq!(opened["warnings"], json!([]));
assert_eq!(run(&mut session, "file.save", json!({}))["path"], json!(saved));
}
/// Saving an SBS file another program wrote must not overwrite it: MaterialCraft can't write back what it couldn't read
#[test]
fn saving_an_sbs_file_from_another_program_needs_a_new_name() {
let dir = TempDir::new("sbs-theirs");
let theirs = dir.file("theirs.sbs");
let xml = r#"<?xml version="1.0"?><package><content><graph><identifier v="G"/><compNodes><compNode><uid v="1"/><compImplementation><compFilter><filter v="curve"/><parameters><parameter><name v="curveluminance"/><paramValue><constantValueString v="POINTS"/></paramValue></parameter></parameters></compFilter></compImplementation></compNode></compNodes></graph><function><identifier v="their_function"/></function></content></package>"#;
std::fs::write(&theirs, xml).unwrap();
let mut s = sample_session();
let opened = run(&mut s, "file.open", json!({"path": theirs}));
assert_eq!(opened["path"], json!(null));
assert!(execute(&mut s, "file.save", &json!({})).is_err());
assert_eq!(std::fs::read_to_string(&theirs).unwrap(), xml, "the original is untouched");
// Saved under a new name it becomes a MaterialCraft file, which saves in place from then on
let mine = run(&mut s, "file.save", json!({"path": dir.file("mine.sbs")}))["path"].as_str().unwrap().to_string();
run(&mut s, "file.open", json!({"path": mine}));
assert_eq!(run(&mut s, "file.save", json!({}))["path"], json!(mine));
}
#[test]
fn a_broken_sbs_file_reports_an_sbs_error() {
let dir = TempDir::new("sbs-broken");
let broken = dir.file("broken.sbs");
std::fs::write(&broken, b"\xff\xfe<\x00p\x00").unwrap();
let mut s = sample_session();
let error = execute(&mut s, "file.open", &json!({"path": broken})).unwrap_err().to_string();
assert!(error.contains("SBS"), "{error}");
}
#[test]
fn an_sbs_file_with_missing_nodes_opens_softly() {
let directory = TempDir::new("sbs-missing");
let path = directory.file("missing.sbs");
let xml = r#"<package><content><graph><identifier v="G"/><compNodes><compNode><uid v="1"/><compImplementation><compFilter><filter v="unknown_primitive"/></compFilter></compImplementation></compNode></compNodes></graph></content></package>"#;
std::fs::write(&path, xml).unwrap();
let mut s = sample_session();
s.preview_size = Some(32);
let opened = run(&mut s, "file.open", json!({"path": path}));
let warnings = opened["warnings"].as_array().unwrap();
assert!(warnings.iter().any(|warning| warning.as_str().unwrap().contains("missing node")));
let inspect = run(&mut s, "session.inspect", json!({}));
assert_eq!(inspect["package"]["warnings"].as_array().map(Vec::len), Some(warnings.len()));
s.cook();
let placeholder = s.graph().unwrap().nodes[0].id;
assert!(s.cooked.nodes[&placeholder].error.is_some());
let (_, placeholders) = s.cook_failures();
assert_eq!(placeholders, 1);
// Commands on a placeholder are errors or no-ops, never panics
s.selection = vec![placeholder];
for (id, params) in [
("graph.node.param", json!({"id": placeholder.0, "param": "intensity", "value": 2})),
("edit.copy", json!({})),
("edit.paste", json!({})),
("edit.duplicate", json!({})),
("graph.node.delete", json!({"ids": [placeholder.0]})),
("edit.undo", json!({})),
] {
let _ = execute(&mut s, id, &params);
}
for spec in command_specs().iter().filter(|spec| !spec.id.starts_with("file.")) {
let _ = execute(&mut s, spec.id, &json!({}));
}
s.cook();
run(&mut s, "file.newPackage", json!({}));
assert!(s.load_warnings.is_empty(), "a new package clears the warnings");
}
/// Every command, run with empty and hostile params, returns Ok or Err but never panics
#[test]
fn panic_hunt() {
let hostile = [
json!({}),
json!(null),
json!({"id": u64::MAX, "ids": [u64::MAX, 0], "node": -1, "value": "x", "param": "", "def": "", "graph": 999}),
json!({"width": 0, "height": u64::MAX, "size": -5, "seed": f64::MAX, "at": [f64::MAX, -1e30], "by": ["a"], "rect": [1, 2]}),
json!({"value": [1e38, -1e38, 0, 0], "param": "opacity", "def": "blend", "mode": "zzz", "format": "gif", "dir": "", "path": ""}),
json!({"from": 0, "to": 0, "fromPort": "", "toPort": "", "clip": {"nodes": "x"}, "template": "../../x", "scene": "\u{0}"}),
];
for spec in command_specs() {
// Skip file writes to the working directory and opening paths
if matches!(
spec.id,
"file.save" | "file.saveAs" | "file.export" | "file.open" | "file.importBitmap" | "file.exportMaterial" | "file.sendToTextureCraft"
) {
continue;
}
for p in &hostile {
let mut s = sample_session();
s.preview_size = Some(64);
let first = s.graph().unwrap().nodes[0].id;
s.selection = vec![first];
let _ = execute(&mut s, spec.id, p);
s.cook();
}
}
}
#[test]
fn dynamic_parameters_follow_graph_inputs() {
use materialcraft_engine::core::{FunctionGraph, NodeId, Value, ValueType};
let mut session = sample_session();
run(&mut session, "file.new", json!({"template": "empty"}));
let owner = NodeId(
run(&mut session, "graph.node.add", json!({"def": "uniform", "params": {"color_mode": false, "color": Value::Color([0.5, 0.5, 0.5, 1.0])}}))["id"]
.as_u64()
.unwrap(),
);
run(&mut session, "graph.exposed.add", json!({"id": "level", "default": Value::Float4([0.25; 4])}));
let function = FunctionGraph::input("level", ValueType::Float4);
run(&mut session, "graph.node.function", json!({"id": owner, "param": "color", "function": function}));
let mean = session.cook().image(owner, 0).unwrap().mean()[0];
assert!((mean - 0.25).abs() < 1e-4, "{mean}");
run(&mut session, "graph.exposed.set", json!({"id": "level", "value": Value::Float4([0.75; 4])}));
let mean = session.cook().image(owner, 0).unwrap().mean()[0];
assert!((mean - 0.75).abs() < 1e-4);
// Removing the function restores the plain value
assert!(execute(&mut session, "graph.node.function", &json!({"id": owner, "param": "nope"})).is_err());
run(&mut session, "graph.node.function", json!({"id": owner, "param": "color", "remove": true}));
let mean = session.cook().image(owner, 0).unwrap().mean()[0];
assert!((mean - 0.5).abs() < 0.05);
}
#[test]
fn exposed_input_change_recooks_only_readers() {
let mut s = sample_session();
run(&mut s, "file.new", json!({"template": "atomics", "size": 64}));
s.preview_size = None;
let u = run(&mut s, "graph.node.add", json!({"def": "uniform", "params": {"color_mode": false}}))["id"].as_u64().unwrap();
run(&mut s, "graph.exposed.add", json!({"id": "level", "default": {"t": "float", "v": 0.25}}));
let f = json!({"nodes": [{"id": 1, "op": "get_float1", "value": {"t": "text", "v": "level"}}], "output": 1});
run(&mut s, "graph.node.function", json!({"id": u, "param": "color", "function": f}));
s.cook();
run(&mut s, "graph.exposed.set", json!({"id": "level", "value": 0.75}));
s.cook();
let recooked: Vec<u64> = s.cooked.nodes.iter().filter(|(_, r)| !r.cached).map(|(id, _)| id.0).collect();
assert_eq!(recooked, [u], "only the node reading `level` re-cooks");
}
#[test]
fn presets_store_and_restore_inputs() {
let mut s = sample_session();
run(&mut s, "file.new", json!({"template": "empty"}));
run(&mut s, "graph.exposed.add", json!({"id": "a", "default": {"t": "float", "v": 0.1}}));
run(&mut s, "graph.preset.save", json!({"name": "Low"}));
run(&mut s, "graph.exposed.set", json!({"id": "a", "value": 0.9}));
run(&mut s, "graph.preset.apply", json!({"name": "Low"}));
assert_eq!(s.graph().unwrap().input_value("a"), Some(&materialcraft_engine::core::Value::Float(0.1)));
assert!(execute(&mut s, "graph.preset.apply", &json!({"name": "Nope"})).is_err());
run(&mut s, "graph.preset.delete", json!({"name": "Low"}));
assert!(s.graph().unwrap().presets.is_empty());
}
#[test]
fn view3d_target_is_validated_clamped_and_reset() {
let mut s = sample_session();
let limit = materialcraft_engine::CameraPrefs::default().pan_limit;
run(&mut s, "view.3d", json!({"target": [0.5, -0.25, 99.0]}));
assert_eq!(s.view3d.target, [0.5, -0.25, limit]);
// A malformed target is refused and changes nothing, not even the other fields
for bad in [json!([1.0, 2.0]), json!("up"), json!([0.0, "x", 0.0]), json!([0.0, 1e300, 0.0])] {
assert!(execute(&mut s, "view.3d", &json!({"target": bad, "yaw": 90.0})).is_err());
assert_eq!(s.view3d.target, [0.5, -0.25, limit]);
assert_eq!(s.view3d.yaw, 35.0);
}
run(&mut s, "view.3d.reset", json!({}));
assert_eq!(s.view3d.target, [0.0; 3]);
}
/// The height output rises out of the mesh by default; depth and level are clamped and reset with the scene.
#[test]
fn view3d_height_depth_and_level_are_clamped_and_reset() {
let mut s = sample_session();
assert_eq!(s.view3d.height_level, 0.0, "the relief rises out of the surface by default");
assert!(s.view3d.height_scale > 0.0);
let view = run(&mut s, "view.3d", json!({"heightScale": 0.1, "heightLevel": 0.5}));
assert_eq!((view["heightScale"].as_f64(), view["heightLevel"].as_f64()), (Some(0.1f32 as f64), Some(0.5)));
run(&mut s, "view.3d", json!({"heightScale": 9.0, "heightLevel": -3.0}));
assert_eq!((s.view3d.height_scale, s.view3d.height_level), (0.5, 0.0));
run(&mut s, "view.3d", json!({"heightLevel": 7.0}));
assert_eq!(s.view3d.height_level, 1.0);
run(&mut s, "view.3d.reset", json!({}));
assert_eq!(s.view3d.height_level, 0.0);
}
#[test]
fn camera_prefs_bound_the_pan_and_survive_hostile_values() {
use materialcraft_engine::CameraPrefs;
let mut s = sample_session();
run(&mut s, "view.3d", json!({"target": [3.0, -4.0, 0.5]}));
// Lowering the limit pulls the current target in, and later targets respect it
s.set_camera_prefs(CameraPrefs { pan_limit: 2.0, ..CameraPrefs::default() });
assert_eq!(s.view3d.target, [2.0, -2.0, 0.5]);
run(&mut s, "view.3d", json!({"target": [0.0, 9.0, -9.0]}));
assert_eq!(s.view3d.target, [0.0, 2.0, -2.0]);
assert_eq!(run(&mut s, "session.inspect", json!({}))["camera"]["panLimit"], 2.0);
// A zero limit pins the camera to the mesh center
s.set_camera_prefs(CameraPrefs { pan_limit: 0.0, ..CameraPrefs::default() });
assert_eq!(s.view3d.target, [0.0; 3]);
// Non-finite or negative values fall back to the defaults
s.set_camera_prefs(CameraPrefs { pan_limit: f32::NAN, pan_speed: -1.0 });
assert_eq!(s.camera, CameraPrefs::default());
assert_eq!(CameraPrefs { pan_limit: f32::INFINITY, pan_speed: 2.0 }.sanitized().pan_speed, 2.0);
}
#[test]
fn reimported_bitmap_shows_new_pixels() {
use craft_texture::{Image, Kind};
use materialcraft_formats::{Depth, encode};
let bmp = |v: f32| encode(&Image::filled(4, 4, Kind::Color, [v, v, v, 1.0]), "bmp", Depth::U8, true).unwrap();
let (dark, light) = (bmp(0.1), bmp(0.9));
assert_eq!(dark.len(), light.len(), "same-size files are the case under test");
let mut s = sample_session();
materialcraft_engine::file_cmds::add_resource(&mut s, "tex.bmp", dark, Some("tex")).unwrap();
let before = s.resource_decoder()("tex").unwrap().data()[0];
s.undo();
materialcraft_engine::file_cmds::add_resource(&mut s, "tex.bmp", light, Some("tex")).unwrap();
let after = s.resource_decoder()("tex").unwrap().data()[0];
assert!(after - before > 0.5, "{before} -> {after}");
}
#[test]
fn a_wire_splits_with_a_reroute_dot_and_deletes() {
let mut s = sample_session();
run(&mut s, "file.new", json!({"template": "empty"}));
let a = run(&mut s, "graph.node.add", json!({"def": "uniform", "at": [0, 0]}))["id"].as_u64().unwrap();
let b = run(&mut s, "graph.node.add", json!({"def": "levels", "at": [400, 0]}))["id"].as_u64().unwrap();
run(&mut s, "graph.connect", json!({"from": a, "to": b}));
let dot = run(&mut s, "graph.wire.insertDot", json!({"to": b, "toPort": "input", "at": [200, 80]}))["id"].as_u64().unwrap();
let g = s.graph().unwrap();
let d = materialcraft_engine::core::NodeId(dot);
assert_eq!(g.node(d).unwrap().def, "dot");
assert_eq!(g.node(d).unwrap().pos, [200.0, 80.0]);
assert_eq!(g.connections.len(), 2);
assert_eq!(g.input_of(d, "input").unwrap().from.0, a);
assert_eq!(g.input_of(materialcraft_engine::core::NodeId(b), "input").unwrap().from.0, dot);
assert_eq!(s.selection, vec![d]);
// The material still cooks through the dot
s.cook();
assert!(s.cooked.nodes.values().all(|r| r.error.is_none()));
// One undo step restores the straight wire
run(&mut s, "edit.undo", json!({}));
assert_eq!(s.graph().unwrap().nodes.len(), 2);
assert_eq!(s.graph().unwrap().input_of(materialcraft_engine::core::NodeId(b), "input").unwrap().from.0, a);
// No wire there: an error, nothing changes
assert!(execute(&mut s, "graph.wire.insertDot", &json!({"to": a, "toPort": "input"})).is_err());
// Deleting the wire
run(&mut s, "graph.disconnect", json!({"to": b, "toPort": "input"}));
assert!(s.graph().unwrap().connections.is_empty());
}
#[test]
fn every_template_is_opaque_in_the_3d_view() {
// Template base colors must stay opaque in the 3D view
let mut s = sample_session();
s.preview_size = Some(64);
for (id, _) in materialcraft_engine::samples::TEMPLATES {
run(&mut s, "file.new", json!({"template": id, "size": 64}));
s.cook();
for (usage, img) in s.material_maps() {
if usage == "baseColor" && !img.is_gray() {
let min = img.data().chunks(4).map(|p| p[3]).fold(f32::INFINITY, f32::min);
assert!(min >= 0.999, "{id}: base color alpha goes down to {min}");
}
}
}
}
#[test]
fn selected_wires_swap_their_sources_and_delete_together() {
use materialcraft_engine::core::NodeId;
let mut session = sample_session();
run(&mut session, "file.new", json!({"template": "empty"}));
let foreground = run(&mut session, "graph.node.add", json!({"def": "uniform", "at": [0, 0]}))["id"].as_u64().unwrap();
let background = run(&mut session, "graph.node.add", json!({"def": "uniform", "at": [0, 200]}))["id"].as_u64().unwrap();
let mask = run(&mut session, "graph.node.add", json!({"def": "uniform", "at": [0, 400]}))["id"].as_u64().unwrap();
let blend = run(&mut session, "graph.node.add", json!({"def": "blend", "at": [300, 100]}))["id"].as_u64().unwrap();
run(&mut session, "graph.connect", json!({"from": foreground, "to": blend, "toPort": "foreground"}));
run(&mut session, "graph.connect", json!({"from": background, "to": blend, "toPort": "background"}));
run(&mut session, "graph.connect", json!({"from": mask, "to": blend, "toPort": "mask"}));
let source = |session: &Session, port: &str| session.graph().unwrap().input_of(NodeId(blend), port).unwrap().from.0;
let pair = json!({"wires": [{"to": blend, "toPort": "background"}, {"to": blend, "toPort": "foreground"}]});
// Swapping the pair leaves the mask link intact
run(&mut session, "graph.wire.swap", pair.clone());
assert_eq!((source(&session, "foreground"), source(&session, "background"), source(&session, "mask")), (background, foreground, mask));
run(&mut session, "graph.wire.swap", pair.clone());
assert_eq!((source(&session, "foreground"), source(&session, "background")), (foreground, background));
run(&mut session, "edit.undo", json!({}));
assert_eq!((source(&session, "foreground"), source(&session, "background")), (background, foreground));
run(&mut session, "edit.redo", json!({}));
// Only a pair can swap, even when three inputs are connected
let all = json!({"wires": [{"to": blend, "toPort": "foreground"}, {"to": blend, "toPort": "background"}, {"to": blend, "toPort": "mask"}]});
let history = session.history();
assert!(execute(&mut session, "graph.wire.swap", &all).is_err());
assert_eq!(session.history(), history);
assert_eq!((source(&session, "foreground"), source(&session, "background"), source(&session, "mask")), (foreground, background, mask));
// Bad requests change nothing
for bad in [
json!({}),
json!({"wires": [{"to": blend, "toPort": "foreground"}]}),
json!({"wires": [{"to": blend, "toPort": "foreground"}, {"to": blend, "toPort": "foreground"}]}),
json!({"wires": [{"to": blend, "toPort": "foreground"}, {"to": foreground, "toPort": "input"}]}),
] {
assert!(execute(&mut session, "graph.wire.swap", &bad).is_err(), "{bad}");
}
assert_eq!(source(&session, "foreground"), foreground);
// Reject swaps that introduce a cycle without changing the graph
let levels = run(&mut session, "graph.node.add", json!({"def": "levels", "at": [600, 100]}))["id"].as_u64().unwrap();
run(&mut session, "graph.connect", json!({"from": blend, "to": levels}));
let cycle = json!({"wires": [{"to": blend, "toPort": "foreground"}, {"to": levels, "toPort": "input"}]});
assert!(execute(&mut session, "graph.wire.swap", &cycle).is_err());
assert_eq!(source(&session, "foreground"), foreground);
assert_eq!(session.graph().unwrap().connections.len(), 4);
// Deleting several wires is one step
run(&mut session, "graph.wire.delete", all);
assert_eq!(session.graph().unwrap().connections.len(), 1);
run(&mut session, "edit.undo", json!({}));
assert_eq!(session.graph().unwrap().connections.len(), 4);
}
#[test]
fn undo_to_unmodified_state_clears_modified_flag() {
let mut s = sample_session();
assert!(!s.modified);
run(&mut s, "graph.node.add", json!({"def": "uniform", "at": [0, 0]}));
assert!(s.modified);
run(&mut s, "edit.undo", json!({}));
assert!(!s.modified, "undoing to the unmodified state should clear the modified flag");
run(&mut s, "edit.redo", json!({}));
assert!(s.modified, "redoing to the modified state should set the modified flag");
}