use materialcraft_formats::sbs::{read_sbs, write_sbs}; const LIBRARY: &str = r#" "#; #[test] fn unresolved_polymorphic_output_preserves_the_declared_function_type() { let xml = LIBRARY.replace("", ""); let source = read_sbs(xml.as_bytes(), "source.sbs", &|_| None).unwrap().pkg; let saved = read_sbs(&write_sbs(&source).unwrap(), "saved.sbs", &|_| None).unwrap().pkg; assert_eq!(saved.graph_by_name("Caller").unwrap().1.function_type, 256); assert_eq!(saved.graph_by_name("Caller").unwrap().1.function.as_ref().unwrap().nodes[0].type_code, 118772); } #[test] fn nested_function_paths_and_library_aliases_survive_save() { let read = read_sbs(LIBRARY.as_bytes(), "test.sbs", &|_| None).unwrap(); assert!(read.warnings.is_empty(), "{:?}", read.warnings); let (_, pi) = read.pkg.graph_by_name("Functions/Math/Pi").expect("package path must remain addressable"); assert_eq!(pi.name, "Pi"); let call = read.pkg.graph_by_name("Caller").unwrap().1.function.as_ref().unwrap(); assert_eq!(call.nodes[0].instance.as_ref().unwrap().package, "sbs://functions.sbs"); let bytes = write_sbs(&read.pkg).unwrap(); let saved = read_sbs(&bytes, "saved.sbs", &|_| None).unwrap(); assert!(saved.warnings.is_empty(), "{:?}", saved.warnings); assert!(saved.pkg.graph_by_name("Functions/Math/Pi").is_some()); assert!(String::from_utf8(bytes).unwrap().contains(&format!("".into(); let bytes = write_sbs(&package).unwrap(); assert!(read_sbs(&bytes, "saved.sbs", &|_| None).is_ok()); package.graphs[index].function.as_mut().unwrap().nodes[0].missing_data = "".into(); assert!(write_sbs(&package).is_err()); } #[test] fn absent_dependency_records_do_not_erase_function_nodes() { let xml = LIBRARY.replace("dependency=9", "dependency=404"); let read = read_sbs(xml.as_bytes(), "missing.sbs", &|_| None).unwrap(); let function = read.pkg.graph_by_name("Caller").unwrap().1.function.as_ref().unwrap(); assert_eq!(function.nodes.len(), 1); assert_eq!(function.output, Some(2)); assert!(function.nodes[0].instance.is_some()); } #[test] fn missing_resource_links_survive_save_and_can_be_repaired() { let xml = r#""#; let read = read_sbs(xml.as_bytes(), "missing.sbs", &|_| None).unwrap(); let bytes = write_sbs(&read.pkg).unwrap(); let repaired = read_sbs(&bytes, "saved.sbs", &|path| (path == "sbs://missing.png").then(|| vec![1, 2, 3])).unwrap(); assert_eq!(repaired.pkg.resources.len(), 1); assert_eq!(repaired.pkg.resources[0].bytes.as_slice(), &[1, 2, 3]); } #[test] #[ignore = "local interoperability input; set MC_FUNCTIONS_SBS to an external package"] fn supplied_function_package_round_trip() { let path = std::env::var("MC_FUNCTIONS_SBS").unwrap(); let bytes = std::fs::read(&path).unwrap(); let read = read_sbs(&bytes, &path, &|_| None).unwrap(); assert!(read.warnings.is_empty(), "{:?}", read.warnings); assert!(read.pkg.graphs.iter().all(|graph| graph.function.as_ref().is_some_and(|function| !function.nodes.is_empty()))); let saved = read_sbs(&write_sbs(&read.pkg).unwrap(), "saved.sbs", &|_| None).unwrap(); let bundled = read_sbs(include_bytes!("../../../assets/sbs/functions.sbs"), "functions.sbs", &|_| None).unwrap(); assert!(saved.warnings.is_empty(), "{:?}", saved.warnings); assert!(bundled.warnings.is_empty(), "{:?}", bundled.warnings); assert_eq!(read.pkg.graphs.len(), 171); assert_eq!(read.pkg.graphs.len(), bundled.pkg.graphs.len()); assert_eq!(read.pkg.folder_paths(), bundled.pkg.folder_paths()); for graph in &read.pkg.graphs { let other = saved.pkg.graph_by_name(&graph.sbs_path()).unwrap().1; let replacement = bundled.pkg.graph_by_name(&graph.sbs_path()).unwrap().1; assert_eq!(graph.function_type, replacement.function_type, "{}", graph.sbs_path()); assert_eq!(graph.function_type, other.function_type, "{}", graph.sbs_path()); let mut expected_inputs = graph.exposed.clone(); for input in &mut expected_inputs { input.description.clear(); } assert_eq!(expected_inputs, replacement.exposed, "{}", graph.sbs_path()); assert_ne!(graph.attributes.description, replacement.attributes.description, "{}", graph.sbs_path()); assert!(replacement.attributes.author.is_empty()); assert_eq!(replacement.attributes.category, graph.attributes.category); assert_eq!(replacement.attributes.tags, graph.attributes.tags); assert!(replacement.frames.is_empty() && replacement.comments.is_empty() && replacement.pins.is_empty()); assert_same_body(graph, replacement); assert_eq!(graph.name, other.name); assert_eq!(graph.exposed, other.exposed); assert_eq!(graph.function.as_ref().unwrap().nodes.len(), other.function.as_ref().unwrap().nodes.len()); let before = graph.function.as_ref().unwrap(); let after = other.function.as_ref().unwrap(); let ids: std::collections::BTreeMap<_, _> = before.nodes.iter().zip(&after.nodes).map(|(left, right)| (left.id, right.id)).collect(); assert_eq!(before.output.map(|id| ids[&id]), after.output); for (left, right) in before.nodes.iter().zip(&after.nodes) { assert_eq!(left.op, right.op, "{}", graph.sbs_path()); assert_eq!(left.value, right.value, "{}", graph.sbs_path()); assert_eq!(left.type_code, right.type_code); assert_eq!(left.pos, right.pos); assert_eq!(left.instance, right.instance); assert_eq!(left.inputs.iter().map(|id| id.map(|id| ids[&id])).collect::>(), right.inputs); } } eprintln!("Round-tripped and compared all {} converted function bodies against the supplied package", read.pkg.graphs.len()); } fn assert_same_body(source: &materialcraft_core::Graph, converted: &materialcraft_core::Graph) { let before = source.function.as_ref().unwrap(); let after = converted.function.as_ref().unwrap(); assert_eq!(before.nodes.len(), after.nodes.len(), "{}", source.sbs_path()); let identifiers: std::collections::BTreeMap<_, _> = before.nodes.iter().zip(&after.nodes).map(|(left, right)| (left.id, right.id)).collect(); assert_eq!(before.output.map(|identifier| identifiers[&identifier]), after.output); for (left, right) in before.nodes.iter().zip(&after.nodes) { assert_eq!(left.op, right.op, "{}", source.sbs_path()); assert_eq!(left.value, right.value, "{}", source.sbs_path()); assert_eq!(left.type_code, right.type_code); assert_eq!(left.instance, right.instance); assert_eq!(left.inputs.iter().map(|identifier| identifier.map(|identifier| identifiers[&identifier])).collect::>(), right.inputs); assert_ne!(left.pos, right.pos, "layout was not replaced in {}", source.sbs_path()); } } #[test] fn bundled_library_has_complete_bodies_and_current_export_metadata() { let bytes = include_bytes!("../../../assets/sbs/functions.sbs"); let read = read_sbs(bytes, "functions.sbs", &|_| None).unwrap(); let xml = roxmltree::Document::parse(std::str::from_utf8(bytes).unwrap()).unwrap(); let version = xml.descendants().find(|element| element.has_tag_name("updaterVersion")).unwrap().attribute("v").unwrap(); assert_eq!(version, env!("CARGO_PKG_VERSION")); assert!(read.warnings.is_empty(), "{:?}", read.warnings); assert_eq!(read.pkg.graphs.len(), 171); assert_eq!(read.pkg.graphs.iter().flat_map(|graph| graph.functions()).map(|function| function.nodes.len()).sum::(), 2334); for graph in &read.pkg.graphs { let function = graph.function.as_ref().unwrap(); assert!(function.output.is_some(), "{}", graph.sbs_path()); assert!(function.nodes.iter().all(|node| node.missing.is_none()), "{}", graph.sbs_path()); assert!(!graph.attributes.description.is_empty()); assert!(graph.attributes.author.is_empty()); assert!(graph.frames.is_empty() && graph.comments.is_empty() && graph.pins.is_empty()); } let pi = &read.pkg.graph_by_name("Functions/Math/Pi").unwrap().1.attributes; assert!(pi.category.is_empty()); assert_eq!(pi.tags, "Constant"); let saved = write_sbs(&read.pkg).unwrap(); let reopened = read_sbs(&saved, "functions.sbs", &|_| None).unwrap(); for graph in &read.pkg.graphs { let reloaded = reopened.pkg.graph_by_name(&graph.sbs_path()).unwrap().1; assert_eq!(reloaded.attributes.category, graph.attributes.category); assert_eq!(reloaded.attributes.tags, graph.attributes.tags); } assert!(!xml.descendants().any(|element| element.has_tag_name("icon"))); } #[test] fn library_aliases_reject_paths_outside_the_asset_root() { use materialcraft_formats::sbs::library::relative_path; assert_eq!(relative_path("sbs://folder/file.sbs").unwrap(), "folder/file.sbs"); for invalid in ["sbs://../private", "sbs:///etc/passwd", "sbs://folder/../../private", "sbs://%2e%2e/private", "sbs://C:/private", "sbs://folder\\private"] { assert!(relative_path(invalid).is_err(), "{invalid}"); } } #[test] fn library_relative_resources_stay_with_the_owning_package() { use materialcraft_formats::sbs::library::resolve; assert_eq!(resolve("sbs://functions.sbs", "resources/tile.png").unwrap(), "sbs://resources/tile.png"); assert_eq!(resolve("sbs://nested/functions.sbs", "resources/tile.png").unwrap(), "sbs://nested/resources/tile.png"); assert_eq!(resolve("sbs://nested/functions.sbs", "../resources/tile.png").unwrap(), "sbs://resources/tile.png"); assert_eq!(resolve("sbs://functions.sbs", ".\\resources\\tile.png").unwrap(), "sbs://resources/tile.png"); assert_eq!(resolve("sbs://nested/functions.sbs", "sbs://resources/tile.png").unwrap(), "sbs://resources/tile.png"); for invalid in ["../private", "../../private", "/etc/passwd", "C:\\private", "https://example.com/image.png", "%2e%2e/private", ""] { assert!(resolve("sbs://functions.sbs", invalid).is_err(), "{invalid}"); } } #[test] fn duplicate_leaf_names_require_their_package_folder() { let mut package = materialcraft_core::Package::new("Folders"); for folder in ["A", "B"] { let mut graph = materialcraft_core::Graph::new("Same"); graph.folder = folder.into(); graph.function = Some(materialcraft_core::FunctionGraph::constant(materialcraft_core::Value::Float(1.0))); package.graphs.push(graph); } let read = read_sbs(&write_sbs(&package).unwrap(), "folders.sbs", &|_| None).unwrap(); assert!(read.pkg.graph_by_name("Same").is_none()); assert_eq!(read.pkg.graph_by_name("A/Same").unwrap().1.folder, "A"); assert_eq!(read.pkg.graph_by_name("B/Same").unwrap().1.folder, "B"); }