b45255bb6fe2
symbols_tests.rs
//! Sketch symbols → components and instances with overrides.
use figcraft_doc::{Document, Node, NodeKind};
use serde_json::{Value, json};
use super::fixture::*;
use super::{import, import_within_nodes};
const BLACK: [f64; 4] = [0.0, 0.0, 0.0, 1.0];
/// A 1×1 PNG whose red channel is `n`: images the importer can decode, one per `n`.
fn png(n: u8) -> Vec<u8> {
let mut out = Vec::new();
image::RgbaImage::from_pixel(1, 1, image::Rgba([n, 0, 0, 255])).write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png).unwrap();
out
}
/// One page with `layers`, one "Symbols" page with `masters`, and `document` changes.
fn open_doc(doc_json: Value, layers: Vec<Value>, masters: Vec<Value>) -> (Document, Vec<String>) {
let z = sketch_zip("50.2", 103, doc_json, &[page("P", "Page", layers), page("S", "Symbols", masters)], &[]);
import(&z, "f").unwrap()
}
/// [`open`] for a file saved by another Sketch.
fn open_version(app: &str, version: u64, layers: Vec<Value>, masters: Vec<Value>) -> (Document, Vec<String>) {
let z = sketch_zip(app, version, document(&["P", "S"]), &[page("P", "Page", layers), page("S", "Symbols", masters)], &[]);
import(&z, "f").unwrap()
}
fn open(layers: Vec<Value>, masters: Vec<Value>) -> (Document, Vec<String>) {
let mut d = document(&["P", "S"]);
d["do_objectID"] = json!("DOC");
open_doc(d, layers, masters)
}
fn named<'d>(doc: &'d Document, name: &str) -> Vec<&'d Node> {
doc.nodes().filter(|n| n.name == name).collect()
}
fn inside<'d>(doc: &'d Document, root: &Node, name: &str) -> &'d Node {
doc.subtree(root.id).into_iter().filter_map(|id| doc.node(id)).find(|n| n.name == name).unwrap_or_else(|| panic!("no {name}"))
}
fn chars(n: &Node) -> &str {
match &n.kind {
NodeKind::Text(td) => &td.characters,
other => panic!("{other:?}"),
}
}
fn instance_of<'d>(doc: &'d Document, name: &str) -> (&'d Node, &'d Node) {
let inst = named(doc, name).into_iter().find(|n| matches!(n.kind, NodeKind::Instance { .. })).unwrap_or_else(|| panic!("no instance {name}"));
let NodeKind::Instance { component, .. } = inst.kind else { panic!("not an instance") };
(inst, doc.node(component).unwrap())
}
fn button() -> Value {
master("M1", "S1", "Button", 100.0, 40.0, vec![text("Label", 10.0, 10.0, 80.0, 20.0, "Go", &[(0, 2, "Helvetica", 14.0, BLACK)])])
}
#[test]
fn master_is_component_instance_links() {
let (doc, _) = open(vec![instance("I1", "S1", 0.0, 0.0, 100.0, 40.0, &[])], vec![button()]);
let (inst, main) = instance_of(&doc, "I1");
assert!(matches!(main.kind, NodeKind::Component { .. }));
assert_eq!(main.name, "Button");
assert_eq!(chars(inside(&doc, inst, "Label")), "Go");
}
#[test]
fn string_override() {
let (doc, _) = open(vec![instance("I1", "S1", 0.0, 0.0, 100.0, 40.0, &[("Label_stringValue", json!("OK"))])], vec![button()]);
let (inst, main) = instance_of(&doc, "I1");
assert_eq!(chars(inside(&doc, inst, "Label")), "OK");
assert_eq!(chars(inside(&doc, main, "Label")), "Go");
}
#[test]
fn nested_symbol_swap_and_hide() {
let icon_a = master("MA", "SA", "Icon A", 20.0, 20.0, vec![rect("Dot A", 0.0, 0.0, 20.0, 20.0)]);
let icon_b = master("MB", "SB", "Icon B", 20.0, 20.0, vec![rect("Dot B", 0.0, 0.0, 20.0, 20.0)]);
let card = master("MC", "SC", "Card", 100.0, 40.0, vec![instance("N", "SA", 0.0, 0.0, 20.0, 20.0, &[])]);
let swapped = instance("Swapped", "SC", 0.0, 0.0, 100.0, 40.0, &[("N_symbolID", json!("SB"))]);
let hidden = instance("Hidden", "SC", 0.0, 100.0, 100.0, 40.0, &[("N_symbolID", json!(""))]);
let (doc, _) = open(vec![swapped, hidden], vec![icon_a, icon_b, card]);
let (sw, _) = instance_of(&doc, "Swapped");
assert!(doc.subtree(sw.id).into_iter().filter_map(|i| doc.node(i)).any(|n| n.name == "Dot B"));
assert!(!doc.subtree(sw.id).into_iter().filter_map(|i| doc.node(i)).any(|n| n.name == "Dot A"));
let (hd, _) = instance_of(&doc, "Hidden");
let nested = doc.node(hd.children[0]).unwrap();
assert!(!nested.visible);
}
#[test]
fn nested_path_override() {
let inner = master("MB", "SB", "Badge", 50.0, 20.0, vec![text("Count", 0.0, 0.0, 50.0, 20.0, "1", &[(0, 1, "Helvetica", 12.0, BLACK)])]);
let outer = master("MA", "SA", "Row", 100.0, 20.0, vec![instance("N", "SB", 50.0, 0.0, 50.0, 20.0, &[])]);
let (doc, _) = open(vec![instance("I1", "SA", 0.0, 0.0, 100.0, 20.0, &[("N/Count_stringValue", json!("42"))])], vec![inner, outer]);
let (inst, _) = instance_of(&doc, "I1");
assert_eq!(chars(inside(&doc, inst, "Count")), "42");
}
#[test]
fn image_override() {
let mut bitmap = rect("Photo", 0.0, 0.0, 40.0, 40.0);
bitmap["_class"] = json!("bitmap");
bitmap["image"] = json!({"_class": "MSJSONFileReference", "_ref": "images/a.png"});
let m = master("M", "S", "Avatar", 40.0, 40.0, vec![bitmap]);
let png = {
let mut out = Vec::new();
image::RgbaImage::new(1, 1).write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png).unwrap();
out
};
let mut png2 = Vec::new();
image::RgbaImage::new(2, 1).write_to(&mut std::io::Cursor::new(&mut png2), image::ImageFormat::Png).unwrap();
let inst = instance("I1", "S", 0.0, 0.0, 40.0, 40.0, &[("Photo_image", json!({"_class": "MSJSONFileReference", "_ref": "images/b.png"}))]);
let z = sketch_zip(
"50.2",
103,
document(&["P", "S"]),
&[page("P", "Page", vec![inst]), page("S", "Symbols", vec![m])],
&[("images/a.png", &png), ("images/b.png", &png2)],
);
let (doc, _) = import(&z, "f").unwrap();
assert_eq!(doc.images.len(), 2);
}
#[test]
fn foreign_symbols_are_components() {
let mut d = document(&["P", "S"]);
d["foreignSymbols"] = json!([{"_class": "MSImmutableForeignSymbol", "sourceLibraryName": "Kit", "symbolMaster": button()}]);
let (doc, warnings) = open_doc(d, vec![instance("I1", "S1", 0.0, 0.0, 100.0, 40.0, &[])], vec![]);
let (_, main) = instance_of(&doc, "I1");
assert_eq!(main.name, "Button");
let page = doc.pages.iter().copied().find(|p| doc.is_ancestor(*p, main.id)).unwrap();
assert_eq!(doc.node(page).unwrap().name, "Library symbols");
assert!(warnings.iter().any(|w| w.contains("Kit")), "{warnings:?}");
}
#[test]
fn missing_master_warns() {
let (doc, warnings) = open(vec![instance("Lost", "NOPE", 0.0, 0.0, 30.0, 30.0, &[])], vec![]);
let n = named(&doc, "Lost")[0];
assert!(matches!(n.kind, NodeKind::Frame));
assert_eq!((n.width, n.height), (30.0, 30.0));
assert!(warnings.iter().any(|w| w.contains("symbol")), "{warnings:?}");
}
#[test]
fn self_containing_master_stops() {
let a = master("MA", "SA", "Loop A", 50.0, 50.0, vec![instance("Self", "SA", 0.0, 0.0, 10.0, 10.0, &[])]);
let b = master("MB", "SB", "Loop B", 50.0, 50.0, vec![instance("ToC", "SC", 0.0, 0.0, 10.0, 10.0, &[])]);
let c = master("MC", "SC", "Loop C", 50.0, 50.0, vec![instance("ToB", "SB", 0.0, 0.0, 10.0, 10.0, &[])]);
let (_, warnings) = open(vec![instance("I1", "SA", 0.0, 0.0, 50.0, 50.0, &[]), instance("I2", "SB", 100.0, 0.0, 50.0, 50.0, &[])], vec![a, b, c]);
assert!(warnings.iter().any(|w| w.contains("contains itself")), "{warnings:?}");
}
#[test]
fn instance_explosion_is_bounded() {
let big = master("M", "S", "Big", 100.0, 100.0, (0..1000).map(|i| rect(&format!("R{i}"), 0.0, 0.0, 1.0, 1.0)).collect());
let many: Vec<Value> = (0..1000).map(|i| instance(&format!("I{i}"), "S", 0.0, 0.0, 100.0, 100.0, &[])).collect();
let z = sketch_zip("50.2", 103, document(&["P", "S"]), &[page("P", "Page", many), page("S", "Symbols", vec![big])], &[]);
let (doc, warnings) = import_within_nodes(&z, "f", 20_000).unwrap();
assert!(doc.nodes().count() <= 20_100);
assert!(warnings.iter().any(|w| w.contains("more than")), "{warnings:?}");
}
#[test]
fn resized_instance_follows_constraints() {
// Pinned right with a fixed width (bits 1 and 2 cleared); a Sketch 64 file.
let pinned = with(rect("Tag", 80.0, 0.0, 20.0, 40.0), "resizingConstraint", json!(60));
let m = master("M", "S", "Bar", 100.0, 40.0, vec![pinned]);
let (doc, _) = open_version("64", 125, vec![instance("Wide", "S", 0.0, 0.0, 200.0, 40.0, &[])], vec![m]);
let (inst, _) = instance_of(&doc, "Wide");
let tag = inside(&doc, inst, "Tag");
let b = doc.world_bounds(tag.id).unwrap();
assert!((b.x0 - 180.0).abs() < 1e-6 && (b.width() - 20.0).abs() < 1e-6, "{b:?}");
}
/// Overrides pointing at junk (a shared style that isn't an object, text runs that aren't) never
/// panic.
#[test]
fn override_application_survives_junk() {
let mut d = document(&["P", "S"]);
d["layerStyles"]["objects"] = json!([{"_class": "sharedStyle", "do_objectID": "S1", "name": "Junk", "value": 5}]);
d["layerTextStyles"]["objects"] =
json!([{"_class": "sharedStyle", "do_objectID": "T1", "name": "Junk text", "value": {"textStyle": {"encodedAttributes": {}}}}]);
let mut t = text("Label", 0.0, 0.0, 50.0, 20.0, "x", &[(0, 1, "Helvetica", 9.0, BLACK)]);
t["attributedString"]["attributes"] = json!([5, "x", null]);
let m = master("M", "S", "Junk master", 50.0, 20.0, vec![rect("C", 0.0, 0.0, 10.0, 10.0), t]);
let inst = instance(
"I1",
"S",
0.0,
0.0,
50.0,
20.0,
&[("C_layerStyle", json!("S1")), ("Label_textStyle", json!("T1")), ("Label_stringValue", json!("y"))],
);
let z = sketch_zip("50.2", 103, d, &[page("P", "Page", vec![inst]), page("S", "Symbols", vec![m])], &[]);
assert!(import(&z, "f").is_ok());
}
/// A huge master expanded by many instances stops at the file's work budget.
#[test]
fn expansion_work_is_bounded() {
let long = "x".repeat(200_000);
let m = master("M", "S", "Heavy", 50.0, 20.0, vec![text("Long", 0.0, 0.0, 50.0, 20.0, &long, &[(0, 200_000, "Helvetica", 9.0, BLACK)])]);
let many: Vec<Value> = (0..3000).map(|i| instance(&format!("I{i}"), "S", 0.0, 0.0, 50.0, 20.0, &[])).collect();
let z = sketch_zip("50.2", 103, document(&["P", "S"]), &[page("P", "Page", many), page("S", "Symbols", vec![m])], &[]);
let (_, warnings) = import(&z, "f").unwrap();
assert!(warnings.iter().any(|w| w.contains("expand")), "{warnings:?}");
}
/// Outer overrides fanned out to many nested instances stop at the work budget.
#[test]
fn override_fan_out_is_bounded() {
let inner = master("MB", "SB", "Cell", 10.0, 10.0, vec![text("T", 0.0, 0.0, 10.0, 10.0, "1", &[(0, 1, "Helvetica", 9.0, BLACK)])]);
let cells: Vec<Value> = (0..3000).map(|_| instance("X", "SB", 0.0, 0.0, 10.0, 10.0, &[])).collect();
let grid = master("MA", "SA", "Grid", 100.0, 100.0, cells);
let overrides: Vec<(String, Value)> = (0..3000).map(|i| (format!("X/N{i}_stringValue"), json!("v"))).collect();
let refs: Vec<(&str, Value)> = overrides.iter().map(|(k, v)| (k.as_str(), v.clone())).collect();
let z = sketch_zip(
"50.2",
103,
document(&["P", "S"]),
&[page("P", "Page", vec![instance("I", "SA", 0.0, 0.0, 100.0, 100.0, &refs)]), page("S", "Symbols", vec![inner, grid])],
&[],
);
let (_, warnings) = import(&z, "f").unwrap();
assert!(warnings.iter().any(|w| w.contains("expand")), "{warnings:?}");
}
/// Sketch 50 stores "not scaled" as `scale: 0`.
#[test]
fn scale_zero_is_unscaled() {
let mut i = instance("I1", "S1", 0.0, 0.0, 100.0, 40.0, &[]);
i["scale"] = json!(0);
let (_, warnings) = open(vec![i], vec![button()]);
assert!(!warnings.iter().any(|w| w.contains("scaled")), "{warnings:?}");
}
/// A master's background shows in its instances only when the master includes it both in
/// instances and in exports (Sketch's own renders and canvas, on files built for it).
#[test]
fn master_background_in_instances_only_when_included() {
let bg = |id: &str, sid: &str, instances: bool, exports: bool| {
let mut m = master(id, sid, id, 20.0, 20.0, vec![]);
m["hasBackgroundColor"] = json!(true);
m["backgroundColor"] = json!({"_class": "color", "red": 0, "green": 0, "blue": 0, "alpha": 1});
m["includeBackgroundColorInInstance"] = json!(instances);
m["includeBackgroundColorInExport"] = json!(exports);
m
};
let (doc, _) = open(
vec![
instance("Hidden", "SH", 0.0, 0.0, 20.0, 20.0, &[]),
instance("InstancesOnly", "SI", 25.0, 0.0, 20.0, 20.0, &[]),
instance("ExportsOnly", "SE", 50.0, 0.0, 20.0, 20.0, &[]),
instance("Shown", "SS", 75.0, 0.0, 20.0, 20.0, &[]),
],
vec![bg("MH", "SH", false, false), bg("MI", "SI", true, false), bg("ME", "SE", false, true), bg("MS", "SS", true, true)],
);
let (hidden, main) = instance_of(&doc, "Hidden");
assert!(hidden.fills.is_empty(), "{:?}", hidden.fills);
assert_eq!(main.fills.len(), 1, "the master shows its background");
assert!(instance_of(&doc, "InstancesOnly").0.fills.is_empty());
assert!(instance_of(&doc, "ExportsOnly").0.fills.is_empty());
assert_eq!(instance_of(&doc, "Shown").0.fills.len(), 1);
}
/// Sketch 2025+: a symbol's (`groupBehavior` 0) or frame master's fills are its background, shown
/// in instances on the same terms.
#[test]
fn style_background_in_instances_only_when_included() {
let m = |id: &str, sid: &str, behaviour: i64, shown: bool| {
let mut m = master(id, sid, id, 20.0, 20.0, vec![]);
m["groupBehavior"] = json!(behaviour);
m["style"]["fills"] = json!([solid_fill(1.0, 1.0, 1.0, 1.0)]);
m["includeBackgroundColorInInstance"] = json!(shown);
m["includeBackgroundColorInExport"] = json!(shown);
m
};
let (doc, _) = open_version(
"2026.3.1",
196,
vec![
instance("Symbol", "S0", 0.0, 0.0, 20.0, 20.0, &[]),
instance("Frame", "S1", 25.0, 0.0, 20.0, 20.0, &[]),
instance("Shown", "S2", 50.0, 0.0, 20.0, 20.0, &[]),
],
vec![m("M0", "S0", 0, false), m("M1", "S1", 1, false), m("M2", "S2", 0, true)],
);
assert!(instance_of(&doc, "Symbol").0.fills.is_empty());
assert!(instance_of(&doc, "Frame").0.fills.is_empty());
assert_eq!(instance_of(&doc, "Shown").0.fills.len(), 1);
}
/// A symbol clips its layers only with `clippingBehavior` 1, whatever its `groupBehavior`.
#[test]
fn symbols_clip_only_when_asked() {
let m = |id: &str, sid: &str, behaviour: Option<i64>, clipping: Option<i64>| {
let mut m = master(id, sid, id, 20.0, 20.0, vec![rect(&format!("R{id}"), 0.0, 10.0, 20.0, 20.0)]);
if let Some(b) = behaviour {
m["groupBehavior"] = json!(b);
}
if let Some(c) = clipping {
m["clippingBehavior"] = json!(c);
}
m
};
let masters = vec![
m("M0", "S0", Some(0), Some(0)),
m("M1", "S1", Some(1), Some(0)),
m("M2", "S2", Some(2), Some(0)),
m("M3", "S3", Some(1), Some(1)),
m("M4", "S4", Some(1), Some(2)),
m("M5", "S5", None, None),
];
let layers = (0..6).map(|i| instance(&format!("I{i}"), &format!("S{i}"), 30.0 * f64::from(i), 0.0, 20.0, 20.0, &[])).collect();
let (doc, _) = open_version("2026.3.1", 196, layers, masters);
let clips: Vec<bool> = (0..6).map(|i| instance_of(&doc, &format!("I{i}")).0.clip).collect();
assert_eq!(clips, [false, false, false, true, false, false]);
}
/// An image override on a shape replaces its top image fill's image.
#[test]
fn image_overrides_on_shapes() {
let pattern = |r: &str| {
json!({"_class": "fill", "isEnabled": true, "fillType": 4, "patternFillType": 1, "patternTileScale": 1,
"image": {"_class": "MSJSONFileReference", "_ref_class": "MSImageData", "_ref": r}})
};
let avatar = styled(rect("Avatar", 0.0, 0.0, 20.0, 20.0), "fills", json!([pattern("images/a.png"), pattern("images/b.png")]));
let over = json!({"_class": "MSJSONFileReference", "_ref_class": "MSImageData", "_ref": "images/c.png"});
let (a, b, c) = (png(1), png(2), png(3));
let z = sketch_zip(
"2026.3.1",
196,
document(&["P", "S"]),
&[
page("P", "Page", vec![instance("I", "S", 0.0, 0.0, 20.0, 20.0, &[("Avatar_image", over)])]),
page("S", "Symbols", vec![master("M", "S", "Contact", 20.0, 20.0, vec![avatar])]),
],
&[("images/a.png", &a), ("images/b.png", &b), ("images/c.png", &c)],
);
let (doc, _) = import(&z, "f").unwrap();
let (inst, main) = instance_of(&doc, "I");
let images = |n: &Node| -> Vec<String> {
n.fills
.iter()
.filter_map(|p| match &p.kind {
figcraft_doc::color::PaintKind::Image(i) => Some(i.image.clone()),
_ => None,
})
.collect()
};
let (shown, master_images) = (images(inside(&doc, inst, "Avatar")), images(inside(&doc, main, "Avatar")));
assert_eq!(shown.len(), 2);
assert_ne!(master_images[0], master_images[1]);
assert_eq!(shown[0], master_images[0], "the lower fill keeps its image");
assert_ne!(shown[1], master_images[1], "the top fill takes the override");
}
/// An image override still shows when the same layer's style is overridden too (the style comes
/// first, then the image).
#[test]
fn image_overrides_survive_layer_style_overrides() {
let pattern = |r: &str| {
json!({"_class": "fill", "isEnabled": true, "fillType": 4, "patternFillType": 1, "patternTileScale": 1,
"image": {"_class": "MSJSONFileReference", "_ref_class": "MSImageData", "_ref": r}})
};
let mut d = document(&["P", "S"]);
d["layerStyles"]["objects"] = json!([{"_class": "sharedStyle", "do_objectID": "LS", "name": "Round",
"value": {"_class": "style", "fills": [pattern("images/a.png")], "borders": []}}]);
let avatar = styled(rect("Avatar", 0.0, 0.0, 20.0, 20.0), "fills", json!([pattern("images/a.png")]));
let over = json!({"_class": "MSJSONFileReference", "_ref_class": "MSImageData", "_ref": "images/c.png"});
let (a, c) = (png(1), png(3));
let z = sketch_zip(
"2026.3.1",
196,
d,
&[
page("P", "Page", vec![instance("I", "S", 0.0, 0.0, 20.0, 20.0, &[("Avatar_layerStyle", json!("LS")), ("Avatar_image", over)])]),
page("S", "Symbols", vec![master("M", "S", "Contact", 20.0, 20.0, vec![avatar])]),
],
&[("images/a.png", &a), ("images/c.png", &c)],
);
let (doc, _) = import(&z, "f").unwrap();
let (inst, main) = instance_of(&doc, "I");
let image = |n: &Node| {
n.fills.iter().find_map(|p| match &p.kind {
figcraft_doc::color::PaintKind::Image(i) => Some(i.image.clone()),
_ => None,
})
};
let (shown, original) = (image(inside(&doc, inst, "Avatar")), image(inside(&doc, main, "Avatar")));
assert!(shown.is_some() && shown != original, "{shown:?} {original:?}");
}
/// How Sketch lays out a resized instance's layers, measured on its renders: a master of 200×100
/// with a 100×40 rectangle at (20, 30), shown at 320×60.
#[test]
fn resized_instances_lay_out_like_sketch() {
let case = |mask: i64, version: u64| {
let r = with(rect("R", 20.0, 30.0, 100.0, 40.0), "resizingConstraint", json!(mask));
let m = master("M", "S", "Box", 200.0, 100.0, vec![r]);
let (doc, _) = open_version("64", version, vec![instance("I", "S", 0.0, 0.0, 320.0, 60.0, &[])], vec![m]);
let (inst, _) = instance_of(&doc, "I");
let b = doc.world_bounds(inside(&doc, inst, "R").id).unwrap();
(b.x0, b.y0, b.width(), b.height())
};
let near = |a: (f64, f64, f64, f64), b: (f64, f64, f64, f64)| {
(a.0 - b.0).abs() < 0.5 && (a.1 - b.1).abs() < 0.5 && (a.2 - b.2).abs() < 0.5 && (a.3 - b.3).abs() < 0.5
};
// Sketch 52 and newer (format 110+).
for (mask, want) in [
(63, (32.0, 18.0, 160.0, 24.0)),
(59, (20.0, 18.0, 166.67, 24.0)),
(62, (40.0, 18.0, 200.0, 24.0)),
(61, (62.0, 18.0, 100.0, 24.0)),
(58, (20.0, 18.0, 220.0, 24.0)),
(57, (20.0, 18.0, 100.0, 24.0)),
(60, (140.0, 18.0, 100.0, 24.0)),
(54, (40.0, 12.86, 200.0, 17.14)),
(0, (32.0, 18.0, 160.0, 24.0)),
(47, (32.0, 10.0, 160.0, 40.0)),
] {
let got = case(mask, 125);
assert!(near(got, want), "mask {mask}: {got:?} vs {want:?}");
}
// Older files: everything scales.
for mask in [59, 62, 61, 0] {
let got = case(mask, 103);
assert!(near(got, (32.0, 18.0, 160.0, 24.0)), "legacy mask {mask}: {got:?}");
}
}
/// A nested swap to a symbol the file doesn't have keeps the original, as Sketch shows it.
#[test]
fn swap_to_a_missing_symbol_keeps_the_original() {
let icon = master("MA", "SA", "Icon A", 20.0, 20.0, vec![rect("Dot A", 0.0, 0.0, 20.0, 20.0)]);
let card = master("MC", "SC", "Card", 100.0, 40.0, vec![instance("N", "SA", 0.0, 0.0, 20.0, 20.0, &[])]);
let (doc, warnings) = open(vec![instance("I", "SC", 0.0, 0.0, 100.0, 40.0, &[("N_symbolID", json!("GONE"))])], vec![icon, card]);
let (inst, _) = instance_of(&doc, "I");
assert!(doc.subtree(inst.id).into_iter().filter_map(|i| doc.node(i)).any(|n| n.name == "Dot A"));
assert!(!warnings.iter().any(|w| w.contains("empty frames")), "{warnings:?}");
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.