mirror of
https://github.com/storytold/materialcraft.git
synced 2026-11-21 15:00:51 +01:00
main's per-axis wrapping, stored sampling and integer-sampling flag now come from craft-texture (storytold/craft-libs#1709). Every craft-libs dependency is pinned to that pull request's head, 92fb3fa8.
390 lines
21 KiB
Rust
390 lines
21 KiB
Rust
use super::*;
|
|
use materialcraft_core::Graph;
|
|
|
|
#[path = "../tests/support/node_library.rs"]
|
|
mod fixture;
|
|
|
|
#[test]
|
|
fn loaded_packages_share_equal_resource_buffers_without_merging_resources() {
|
|
let files = ["sbs://rt_ao.sbs".to_string(), "sbs://rt_ao_v2.sbs".to_string()];
|
|
|
|
let library = NodeLibrary::load(&files);
|
|
let resources: Vec<_> =
|
|
files.iter().map(|file| library.packages[file].resources.iter().find(|resource| resource.source.ends_with("bluenoise_256.png")).unwrap()).collect();
|
|
|
|
assert!(!resources[0].bytes.is_empty());
|
|
assert_eq!(resources[0].bytes, resources[1].bytes);
|
|
assert!(resources[0].bytes.ptr_eq(&resources[1].bytes), "equal resource bytes should use one immutable buffer");
|
|
assert!(library.packages[&files[0]].graph_by_name("rt_ao").is_some());
|
|
assert!(library.packages[&files[1]].graph_by_name("rt_ao").is_some());
|
|
}
|
|
|
|
/// Installing a library must not compile and clone graphs that no open document references.
|
|
#[test]
|
|
fn unused_library_packages_remain_shared_without_interface_refresh() {
|
|
let mut package = Package::new("Unused library");
|
|
package.graphs.push(Graph::new("Source"));
|
|
let mut caller = Graph::new("Caller");
|
|
let id = caller.add_node("graph_instance", [0.0; 2]);
|
|
caller.nodes.iter_mut().find(|node| node.id == id).unwrap().params.insert("graph".into(), materialcraft_core::Value::Text("Source".into()));
|
|
package.graphs.push(caller);
|
|
let source = Arc::new(package);
|
|
let mut library = NodeLibrary::default();
|
|
library.packages.insert("sbs://unused.sbs".into(), source.clone());
|
|
let session = crate::Session::with_library(Package::new("Empty"), Arc::new(library));
|
|
|
|
assert!(Arc::ptr_eq(&source, &session.pkg.dependencies["sbs://unused.sbs"]));
|
|
}
|
|
|
|
/// Category aliases and frame kinds resolve only to recognized categories.
|
|
#[test]
|
|
fn frame_titles_map_to_library_categories() {
|
|
assert_eq!(frame_category("Texture Generators - Noises", false, false).as_deref(), Some("Texture generators/Noises"));
|
|
assert_eq!(frame_category("Spline & Path tools - Path tools", false, false).as_deref(), Some("Spline & Path tools/Path tools"));
|
|
assert_eq!(frame_category("Material Filters - 1 click", false, false).as_deref(), Some("Material filters/1-click"));
|
|
assert_eq!(frame_category("Mesh-based generators - Weathering", false, false).as_deref(), Some("Mesh-based generators/Weathering"));
|
|
assert_eq!(frame_category("PBR Materials", false, false).as_deref(), Some("PBR materials"));
|
|
assert_eq!(frame_category("Atomic Nodes", false, false).as_deref(), Some("Atomic nodes"));
|
|
|
|
// The category MaterialCraft renamed still reads from older layouts
|
|
assert_eq!(frame_category("SDF functions - Primitives", false, false).as_deref(), Some("MCF functions/Primitives"));
|
|
assert_eq!(frame_category("Functions Inside", false, false), None);
|
|
assert_eq!(frame_category("Filters - Nowhere", false, false), None);
|
|
assert_eq!(frame_category("Comparison", true, true).as_deref(), Some("Function nodes/Comparison"));
|
|
assert_eq!(frame_category("Comparison", true, false).as_deref(), Some("Functions/Comparison"));
|
|
assert_eq!(frame_category("Unknown", true, true), None);
|
|
}
|
|
|
|
/// A graph with these attributes, for category tests
|
|
fn attributed(name: &str, category: &str, tags: &str) -> Graph {
|
|
let mut graph = Graph::new(name);
|
|
graph.attributes.category = category.into();
|
|
graph.attributes.tags = tags.into();
|
|
graph
|
|
}
|
|
|
|
/// Package categories and tags resolve to the tree's categories and sub-categories.
|
|
#[test]
|
|
fn package_attributes_map_to_library_categories() {
|
|
for (category, tags, expected) in [
|
|
("Generator", "Noise, Perlin", "Texture generators/Noises"),
|
|
("Generator", "Pattern", "Texture generators/Patterns"),
|
|
("Filter", "Blur", "Filters/Blurs"),
|
|
("Filter", "Effect, light, bloom", "Filters/Effects"),
|
|
("Filter", "Normal Map", "Filters/Normal map"),
|
|
("Filter", "Transformation, Crop", "Filters/Transforms"),
|
|
("Filter", "", "Filters"),
|
|
("Material Filter", "1-Click", "Material filters/1-click"),
|
|
("Material Filter", "Scan Processing", "Material filters/Scan processing"),
|
|
("Material Filters", "Mesh Adaptive", "Mesh-based generators/Utilities"),
|
|
("Scan", "", "Material filters/Scan processing"),
|
|
("Mesh Adaptive", "Mask Generators", "Mesh-based generators/Mask generators"),
|
|
("Splines & Paths", "Splines, Paths", "Spline & Path tools/Spline tools"),
|
|
("Splines & Paths", "Paths", "Spline & Path tools/Path tools"),
|
|
("3D View", "HDRI Tools", "3D view/HDRI tools"),
|
|
("Values", "Constant", "Values/Constant"),
|
|
("PBR Materials/Paper ", "", "PBR materials/Paper"),
|
|
("SDF function", "Primitive", "MCF functions/Primitives"),
|
|
("3D Functions", "Material", "MCF functions"),
|
|
] {
|
|
assert_eq!(library_category(&attributed("graph", category, tags)).as_deref(), Some(expected), "{category} / {tags}");
|
|
}
|
|
|
|
assert_eq!(library_category(&attributed("gravel", "Material", "")).as_deref(), Some("PBR materials/Ground"), "a material's name picks its sub-category");
|
|
assert_eq!(
|
|
library_category(&attributed("spot_emboss", "", "Effect")).as_deref(),
|
|
Some("Filters/Effects"),
|
|
"a graph without a category uses its listed one"
|
|
);
|
|
assert_eq!(library_category(&attributed("graph", "", "Effect")), None);
|
|
assert_eq!(library_category(&attributed("graph", "Template", "")), None);
|
|
}
|
|
|
|
/// Hidden graphs and helper functions stay out; categorized functions are listed.
|
|
#[test]
|
|
fn hidden_graphs_and_helper_functions_are_not_listed() {
|
|
let function = |name: &str, category: &str, tags: &str| {
|
|
let mut graph = attributed(name, category, tags);
|
|
graph.function = Some(materialcraft_core::FunctionGraph::default());
|
|
graph
|
|
};
|
|
|
|
let mut package = Package::new("Tools");
|
|
let mut shown = attributed("shown", "Filter", "Blur");
|
|
shown.add_node("output", [0.0; 2]);
|
|
let mut hidden = shown.clone();
|
|
hidden.name = "hidden".into();
|
|
hidden.attributes.hide_in_library = true;
|
|
package.graphs.extend([shown, hidden, function("helper", "", ""), function("cube", "SDF function", "Primitive"), function("hash", "", "Random")]);
|
|
let mut functions = Package::new("Functions only");
|
|
functions.graphs.push(function("loose", "", ""));
|
|
let packages = BTreeMap::from([("sbs://tools.sbs".to_string(), Arc::new(package)), ("sbs://user.sbs".to_string(), Arc::new(functions))]);
|
|
|
|
let entries = NodeLibrary::default().entries(&packages);
|
|
|
|
let listed: BTreeMap<_, _> =
|
|
entries.iter().filter(|entry| entry.id.starts_with("sbs://")).map(|entry| (entry.id.as_str(), entry.category.as_str())).collect();
|
|
let expected = [
|
|
("sbs://tools.sbs#cube", "MCF functions/Primitives"),
|
|
("sbs://tools.sbs#hash", "Functions/Random"),
|
|
("sbs://tools.sbs#shown", "Filters/Blurs"),
|
|
("sbs://user.sbs#loose", "Functions"),
|
|
];
|
|
|
|
assert_eq!(listed, BTreeMap::from(expected), "a package of functions alone lists its loose ones");
|
|
}
|
|
|
|
/// Every graph the bundled packages list sits in a category of the tree.
|
|
#[test]
|
|
fn the_whole_bundled_library_is_categorized() {
|
|
let library = NodeLibrary::load(&library::files());
|
|
let entries = library.entries(&library.packages);
|
|
let packaged: Vec<_> = entries.iter().filter(|entry| entry.id.starts_with("sbs://")).collect();
|
|
let known = |category: &str| {
|
|
let mut parts = category.split('/');
|
|
let top = parts.next().unwrap_or_default();
|
|
CATEGORIES.iter().any(|(name, subs)| *name == top && parts.next().is_none_or(|sub| subs.contains(&sub)))
|
|
};
|
|
|
|
let unknown: Vec<_> = packaged.iter().filter(|entry| !known(&entry.category)).map(|entry| (&entry.id, &entry.category)).collect();
|
|
|
|
assert!(unknown.is_empty(), "{unknown:?}");
|
|
|
|
let category = |id: &str| packaged.iter().find(|entry| entry.id == id).map(|entry| entry.category.as_str());
|
|
for (id, expected) in [
|
|
("sbs://noise_perlin_noise_v2.sbs#perlin_noise", "Texture generators/Noises"),
|
|
("sbs://pattern_tile_sampler.sbs#tile_sampler", "Texture generators/Patterns"),
|
|
("sbs://blur_hq.sbs#blur_hq", "Filters/Blurs"),
|
|
("sbs://mg_mask_builder.sbs#mg_mask_builder_2", "Mesh-based generators/Mask generators"),
|
|
("sbs://materials/pbr/gravel.sbs#gravel", "PBR materials/Ground"),
|
|
("sbs://functions.sbs#Functions/Math/Pi", "Functions/Constant"),
|
|
] {
|
|
assert_eq!(category(id), Some(expected), "{id}");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn bundled_material_functions_have_compatible_inputs() {
|
|
let library = NodeLibrary::load(&library::files());
|
|
|
|
for (package_name, graph_names) in [
|
|
("sbs://3d_functions.sbs", &["3d_sdf_primitives/3d_sdf_plane"][..]),
|
|
(
|
|
"sbs://pbr_render2.sbs",
|
|
&["ibl_specular_contrib_anisotropic/IBLSpecularContribution", "ibl_specular_contrib_anisotropic/IBLSpecularContribution_iteration"],
|
|
),
|
|
] {
|
|
let package = &library.packages[package_name];
|
|
for graph_name in graph_names {
|
|
let (_, graph) = package.graph_by_name(graph_name).unwrap();
|
|
let mut function = graph.function.as_ref().unwrap().clone();
|
|
|
|
materialcraft_nodes::function::resolve_instances(&mut function, package, &library.packages);
|
|
|
|
if let Err(error) = materialcraft_nodes::function::compile(&function, 0) {
|
|
panic!("{package_name}#{graph_name}: {error}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Identifier labels preserve recognized acronyms and omit empty words.
|
|
#[test]
|
|
fn identifiers_read_as_labels() {
|
|
assert_eq!(humanize("3D_perlin_noise"), "3D Perlin Noise");
|
|
assert_eq!(humanize("bnw_spots_1"), "BnW Spots 1");
|
|
assert_eq!(humanize("rgb-a_merge"), "RGB-A Merge");
|
|
assert_eq!(humanize("Functions/Math/acescg_to_srgb"), "ACEScg To sRGB");
|
|
assert_eq!(humanize("__"), "");
|
|
}
|
|
|
|
/// Function categories use exact path segments and known name overrides.
|
|
#[test]
|
|
fn functions_sort_into_sub_categories_by_folder_and_name() {
|
|
assert_eq!(function_category("Functions/Math/Pi"), "Functions/Constant");
|
|
assert_eq!(function_category("Functions/Math/Equality_Float2"), "Functions/Comparison");
|
|
assert_eq!(function_category("Functions/Math/Parity/EvenCount"), "Functions/Parity");
|
|
assert_eq!(function_category("Functions/Math/Trigo/acos"), "Functions/Maths");
|
|
assert_eq!(function_category("Functions/Math/Trigo/deg_to_rad"), "Functions/Conversion");
|
|
assert_eq!(function_category("Functions/easings/sine/ease_in_sine"), "Functions/Easings");
|
|
assert_eq!(function_category("Functions/switch/Float2/switch_float2_4_inputs"), "Functions/Various");
|
|
assert_eq!(function_category("Functions/Tonemappers/tonemap_ACES"), "Functions/Color");
|
|
assert_eq!(function_category("Functions/Mathematics/x"), "Functions", "a folder name must match whole");
|
|
assert_eq!(function_category("Loose"), "Functions");
|
|
}
|
|
|
|
/// The isolated bundled catalog has unique entries in recognized categories.
|
|
#[test]
|
|
fn the_bundled_library_fills_the_tree_with_what_materialcraft_has() {
|
|
let library = fixture::library();
|
|
assert!(library.layouts.is_empty());
|
|
assert!(library.packages.contains_key("sbs://functions.sbs"));
|
|
|
|
let entries = library.entries(&library.packages);
|
|
let ids: BTreeSet<_> = entries.iter().map(|entry| entry.id.as_str()).collect();
|
|
assert_eq!(ids.len(), entries.len(), "ids are unique");
|
|
assert!(entries.iter().all(|entry| entry.missing.is_none()), "everything listed can be added");
|
|
let known = |category: &str| {
|
|
let mut parts = category.split('/');
|
|
let top = parts.next().unwrap_or("");
|
|
CATEGORIES.iter().any(|(name, subs)| *name == top && parts.next().is_none_or(|sub| subs.contains(&sub)))
|
|
};
|
|
for entry in &entries {
|
|
assert!(known(&entry.category), "{} sits in unknown category {}", entry.id, entry.category);
|
|
}
|
|
let count = |category: &str| entries.iter().filter(|entry| entry.category == category).count();
|
|
let find = |id: &str| entries.iter().find(|entry| entry.id == id).unwrap_or_else(|| panic!("no entry {id}"));
|
|
|
|
for top in ["Function nodes", "Functions"] {
|
|
let (_, subs) = CATEGORIES.iter().find(|(name, _)| *name == top).unwrap();
|
|
for sub in *subs {
|
|
assert!(count(&format!("{top}/{sub}")) > 0, "{top}/{sub} is empty");
|
|
}
|
|
}
|
|
|
|
// Every bundled function has a sub-category
|
|
let functions = library.packages["sbs://functions.sbs"].graphs.iter().filter(|graph| graph.function.is_some()).count();
|
|
assert_eq!(entries.iter().filter(|entry| entry.category.starts_with("Functions/")).count(), functions);
|
|
assert_eq!(count("Functions"), 0);
|
|
assert_eq!(find("sbs://functions.sbs#Functions/Tonemappers/tonemap_ACES").category, "Functions/Color");
|
|
assert_eq!(
|
|
entries.iter().filter(|entry| entry.category == "Graph items").map(|entry| entry.label.as_str()).collect::<Vec<_>>(),
|
|
["Comment", "Frame", "Pin", "Dot node"]
|
|
);
|
|
for id in ["node:blur", "node:bitmap", "node:output", "node:input_color", "node:input_value"] {
|
|
assert_eq!(find(id).category, "Atomic nodes", "{id}");
|
|
}
|
|
assert_eq!(find("function:add").category, "Function nodes/Operator");
|
|
assert_eq!(find("pattern:paramset").category, "FxMap nodes");
|
|
let pi = find("sbs://functions.sbs#Functions/Math/Pi");
|
|
assert_eq!((pi.label.as_str(), pi.category.as_str()), ("Pi", "Functions/Constant"));
|
|
assert_eq!(find("sbs://functions.sbs#Functions/Math/Equality_Float2").category, "Functions/Comparison");
|
|
}
|
|
|
|
/// A layout that places a library node MaterialCraft doesn't have yet, a function and a sub-category
|
|
/// the PBR keywords decide
|
|
const LAYOUT: &str = r#"<package><dependencies>
|
|
<dependency><filename v="sbs://3d_perlin_noise.sbs"/><uid v="2"/></dependency>
|
|
<dependency><filename v="sbs://materials/bricks_001.sbs"/><uid v="3"/></dependency></dependencies>
|
|
<content><graph><identifier v="Layout"/><compNodes>
|
|
<compNode><uid v="10"/><GUILayout><gpos v="20 40 0"/></GUILayout><compImplementation><compInstance><path v="pkg:///3D_perlin_noise?dependency=2"/></compInstance></compImplementation></compNode>
|
|
<compNode><uid v="11"/><GUILayout><gpos v="220 40 0"/></GUILayout><compImplementation><compInstance><path v="pkg:///bricks_001?dependency=3"/></compInstance></compImplementation></compNode>
|
|
</compNodes><GUIObjects>
|
|
<GUIObject><type v="COMMENT"/><GUILayout><gpos v="0 0 0"/><size v="160 200"/></GUILayout><title v="Texture Generators - Noises"/></GUIObject>
|
|
<GUIObject><type v="COMMENT"/><GUILayout><gpos v="200 0 0"/><size v="160 200"/></GUILayout><title v="PBR Materials"/></GUIObject>
|
|
</GUIObjects></graph></content></package>"#;
|
|
|
|
/// A missing layout entry becomes available when its package is supplied.
|
|
#[test]
|
|
fn a_layout_lists_what_it_places_and_a_library_package_makes_it_available() {
|
|
let frames = materialcraft_formats::sbs::read_layout(LAYOUT.as_bytes(), "sbs://layout.sbs").unwrap();
|
|
let library = NodeLibrary { placements: placements(&frames), ..Default::default() };
|
|
let entries = library.entries(&BTreeMap::new());
|
|
let perlin = entries.iter().find(|entry| entry.id == "sbs://3d_perlin_noise.sbs#3D_perlin_noise").unwrap();
|
|
assert_eq!((perlin.label.as_str(), perlin.category.as_str()), ("3D Perlin Noise", "Texture generators/Noises"));
|
|
assert!(perlin.missing.is_some(), "a placed node whose package is absent is listed but not addable");
|
|
let bricks = entries.iter().find(|entry| entry.id == "sbs://materials/bricks_001.sbs#bricks_001").unwrap();
|
|
assert_eq!(bricks.category, "PBR materials/Bricks");
|
|
|
|
let mut graph = Graph::new("3D_perlin_noise");
|
|
graph.add_node("uniform", [0.0; 2]);
|
|
graph.add_node("output", [200.0, 0.0]);
|
|
let mut package = Package::new("3d_perlin_noise");
|
|
package.graphs.push(graph.clone());
|
|
graph.name = "Loose".into();
|
|
graph.attributes.category = "Filters/Blurs".into();
|
|
package.graphs.push(graph);
|
|
let dependencies = BTreeMap::from([("sbs://3d_perlin_noise.sbs".to_string(), Arc::new(package))]);
|
|
|
|
let entries = library.entries(&dependencies);
|
|
let perlin = entries.iter().find(|entry| entry.id == "sbs://3d_perlin_noise.sbs#3D_perlin_noise").unwrap();
|
|
assert!(perlin.missing.is_none());
|
|
assert_eq!(perlin.category, "Texture generators/Noises");
|
|
let loose = entries.iter().find(|entry| entry.id == "sbs://3d_perlin_noise.sbs#Loose").unwrap();
|
|
assert_eq!((loose.category.as_str(), loose.canvas), ("Filters/Blurs", LibraryCanvas::Material));
|
|
}
|
|
|
|
/// Invalid library files produce warnings while native entries remain usable.
|
|
#[test]
|
|
fn unreadable_library_files_warn_instead_of_failing() {
|
|
let library = NodeLibrary::load(&["sbs://does_not_exist.sbs".into(), "sbs://../escape.sbs".into()]);
|
|
assert!(library.packages.is_empty() && library.layouts.is_empty());
|
|
assert_eq!(library.warnings.len(), 2);
|
|
let entries = library.entries(&BTreeMap::new());
|
|
assert!(entries.iter().any(|entry| entry.id == "node:blur" && entry.category == "Atomic nodes"));
|
|
assert!(entries.iter().any(|entry| entry.id == "function:add" && entry.category == "Function nodes/Operator"));
|
|
}
|
|
|
|
/// Classification tags take precedence over package folders and support multiple placements.
|
|
#[test]
|
|
fn function_tags_choose_library_filters_before_path_fallbacks() {
|
|
let mut package = Package::new("Functions");
|
|
for (name, category, tags) in [("Pi", "Function", "Maths"), ("Tagged", "", "Comparison; Easing"), ("Fallback", "", "Unknown")] {
|
|
let mut graph = Graph::new(name);
|
|
graph.folder = "Functions/Math".into();
|
|
graph.function = Some(Default::default());
|
|
graph.attributes.category = category.into();
|
|
graph.attributes.tags = tags.into();
|
|
package.graphs.push(graph);
|
|
}
|
|
let dependencies = BTreeMap::from([("sbs://classification.sbs".to_string(), Arc::new(package))]);
|
|
|
|
let entries = NodeLibrary::default().entries(&dependencies);
|
|
let categories = |name: &str| entries.iter().filter(|entry| entry.label == name).map(|entry| entry.category.as_str()).collect::<Vec<_>>();
|
|
|
|
assert_eq!(categories("Pi"), ["Functions/Maths"]);
|
|
assert_eq!(categories("Tagged"), ["Functions/Comparison", "Functions/Easings"]);
|
|
assert_eq!(categories("Fallback"), ["Functions/Maths"]);
|
|
}
|
|
|
|
/// Library graphs render a preview from sample inputs; graphs that make no image give none.
|
|
#[test]
|
|
fn library_graphs_cook_previews_from_sample_inputs() {
|
|
let library = Arc::new(NodeLibrary::load(&library::files()));
|
|
let preview = |package: &str, graph: &str| NodeLibrary::preview(&library, package, graph, 32);
|
|
|
|
let filter = preview("sbs://blur_hq.sbs", "blur_hq").unwrap();
|
|
|
|
assert_eq!((filter.width(), filter.height()), (32, 32));
|
|
assert!(preview("sbs://materials/pbr/bricks_001.sbs", "bricks_001").is_some());
|
|
assert!(preview("sbs://noise_bnw_spots_1.sbs", "bnw_spots_1").is_some(), "an FX-Map noise reads the variables its size function sets");
|
|
assert!(preview("sbs://blur_hq.sbs", "no_such_graph").is_none());
|
|
assert!(preview("sbs://functions.sbs", "Functions/Math/Pi").is_none(), "a function has no image");
|
|
}
|
|
|
|
#[test]
|
|
#[ignore = "repeated bundled preview cooks; run explicitly for memory profiling"]
|
|
fn repeated_library_previews_release_images_and_source_references() {
|
|
let library = Arc::new(NodeLibrary::load(&library::files()));
|
|
let references: Vec<_> = library.packages.values().map(Arc::strong_count).collect();
|
|
for cycle in 0..12 {
|
|
for (package, graph) in
|
|
[("sbs://blur_hq.sbs", "blur_hq"), ("sbs://noise_clouds_3_v2.sbs", "clouds_3"), ("sbs://materials/pbr/bricks_001.sbs", "bricks_001")]
|
|
{
|
|
let image = NodeLibrary::preview(&library, package, graph, 72).unwrap_or_else(|| panic!("missing preview {package}#{graph}"));
|
|
let buffer = Arc::downgrade(image.shared_data());
|
|
drop(image);
|
|
|
|
assert!(buffer.upgrade().is_none(), "a completed thumbnail must release its image after upload");
|
|
assert_eq!(Arc::strong_count(&library), 1);
|
|
assert_eq!(library.packages.values().map(Arc::strong_count).collect::<Vec<_>>(), references);
|
|
}
|
|
|
|
println!("completed preview cycle {cycle}");
|
|
#[cfg(target_os = "linux")]
|
|
if let Ok(status) = std::fs::read_to_string("/proc/self/status") {
|
|
let memory: Vec<_> = status.lines().filter(|line| line.starts_with("VmRSS:") || line.starts_with("VmHWM:")).collect();
|
|
println!("{}", memory.join(", "));
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn cancelled_library_previews_stop_before_preparing_the_package() {
|
|
let library = Arc::new(NodeLibrary::default());
|
|
let cancelled = std::sync::atomic::AtomicBool::new(true);
|
|
|
|
assert!(NodeLibrary::preview_cancellable(&library, "unused", "unused", 72, &cancelled).is_none());
|
|
assert_eq!(Arc::strong_count(&library), 1);
|
|
}
|