b45255bb6fe2
tail_tests.rs
//! The import's tail: editable vector networks, the closest layers for kinds the editor doesn't
//! have (sticky notes, shapes with text, connectors, tables) and variable prototype actions, on
//! fixtures built in code with the parent module's helpers.
use figcraft_doc::proto::Action;
use figcraft_doc::{HandleMirroring, StrokeCap, StrokeJoin, WindingRule};
use super::super::network::{self, Network, Region, Segment, Vertex};
use super::*;
fn seg(a: usize, b: usize, ta: (f64, f64), tb: (f64, f64)) -> Segment {
Segment { style: 0, a, ta, b, tb }
}
fn vtx(style: u32, x: f64, y: f64) -> Vertex {
Vertex { style, x, y }
}
/// A square with one curved side and a rounded, mirrored corner, filled even-odd.
fn square_blob() -> Vec<u8> {
network::encode(&Network {
vertices: vec![vtx(0, 0.0, 0.0), vtx(1, 50.0, 0.0), vtx(2, 50.0, 50.0), vtx(3, 0.0, 50.0)],
segments: vec![
seg(0, 1, (10.0, 0.0), (-10.0, 0.0)),
seg(1, 2, (0.0, 0.0), (0.0, 0.0)),
seg(2, 3, (0.0, 0.0), (0.0, 0.0)),
seg(3, 0, (0.0, 0.0), (0.0, 0.0)),
],
regions: vec![Region { style: 0, non_zero: false, loops: vec![vec![0, 1, 2, 3]] }],
})
}
/// An open line whose end point has its own (arrow) cap.
fn arrow_blob() -> Vec<u8> {
network::encode(&Network {
vertices: vec![vtx(0, 0.0, 0.0), vtx(2, 100.0, 0.0)],
segments: vec![seg(0, 1, (0.0, 0.0), (0.0, 0.0))],
regions: vec![],
})
}
/// An open path with one missing style ID and one unsupported point join.
fn join_fallback_blob() -> Vec<u8> {
network::encode(&Network {
vertices: vec![vtx(4, 0.0, 0.0), vtx(5, 50.0, 0.0), vtx(0, 100.0, 0.0)],
segments: vec![seg(0, 1, (0.0, 0.0), (0.0, 0.0)), seg(1, 2, (0.0, 0.0), (0.0, 0.0))],
regions: vec![],
})
}
fn vector_data(blob: u64, nx: f64, ny: f64, styles: Vec<Kv<'static>>) -> Kv<'static> {
o(vec![("vectorNetworkBlob", u(blob)), ("normalizedSize", xy(nx, ny)), ("styleOverrideTable", arr(styles))])
}
fn outline(blob: u64) -> Kv<'static> {
arr(vec![o(vec![("windingRule", e("NONZERO")), ("commandsBlob", u(blob))])])
}
fn text_data(t: &str) -> Kv<'static> {
o(vec![("characters", s(t))])
}
fn data(ty: &'static str, value: Kv<'static>) -> Kv<'static> {
o(vec![("value", value), ("dataType", e(ty))])
}
fn action(ty: &'static str, mut more: Vec<(&'static str, Kv<'static>)>) -> Kv<'static> {
more.push(("connectionType", e(ty)));
o(more)
}
/// Blobs: 0 a triangle outline, 1 the square network, 2 the arrow network, 3 a truncated network.
fn tail_message() -> Kv<'static> {
let modes = arr(vec![
o(vec![("id", g(92)), ("name", s("Off")), ("sortPosition", s("!"))]),
o(vec![("id", g(93)), ("name", s("On")), ("sortPosition", s("\""))]),
]);
let bool_value = |b| data("BOOLEAN", o(vec![("boolValue", Kv::Bool(b))]));
let values = o(vec![(
"entries",
arr(vec![o(vec![("modeID", g(92)), ("variableData", bool_value(false))]), o(vec![("modeID", g(93)), ("variableData", bool_value(true))])]),
)]);
let is_on = data(
"EXPRESSION",
o(vec![(
"expressionValue",
o(vec![("expressionFunction", e("EQUALS")), ("expressionArguments", arr(vec![alias_data(41), bool_value(true)]))]),
)]),
);
let click = o(vec![
("event", o(vec![("interactionType", e("ON_CLICK"))])),
(
"actions",
arr(vec![
action("SET_VARIABLE", vec![("targetVariable", o(vec![("id", o(vec![("guid", g(41))]))])), ("targetVariableData", bool_value(true))]),
action(
"CONDITIONAL",
vec![(
"conditionalActions",
arr(vec![
o(vec![("actions", arr(vec![action("BACK", vec![])])), ("condition", is_on)]),
o(vec![("actions", arr(vec![action("CLOSE", vec![])]))]),
]),
)],
),
action("SET_VARIABLE_MODE", vec![("targetVariableSetID", o(vec![("guid", g(40))])), ("targetVariableModeID", g(93))]),
]),
),
]);
let stroke = || ("strokePaints", arr(vec![solid(0.0, 0.0, 0.0)]));
let nodes = vec![
node(0, None, "DOCUMENT", "Document", vec![]),
node(1, Some((0, "!")), "CANVAS", "Board", vec![]),
node(2, Some((0, "~")), "CANVAS", "Internal", vec![("internalOnly", Kv::Bool(true))]),
node(40, Some((2, "!")), "VARIABLE_SET", "Flags", vec![("variableSetModes", modes)]),
node(
41,
Some((2, "\"")),
"VARIABLE",
"on",
vec![("variableSetID", o(vec![("guid", g(40))])), ("variableResolvedType", e("BOOLEAN")), ("variableDataValues", values)],
),
node(
30,
Some((1, "!")),
"VECTOR",
"Wave",
vec![
("size", xy(200.0, 100.0)),
("transform", at(700.0, 0.0)),
("fillPaints", arr(vec![solid(1.0, 0.0, 0.0)])),
("fillGeometry", outline(0)),
("strokeJoin", e("MITER")),
("dashPattern", arr(vec![f(4.0), f(2.0)])),
(
"vectorData",
vector_data(
1,
100.0,
50.0,
vec![
o(vec![
("styleID", u(1)),
("cornerRadius", f(4.0)),
("handleMirroring", e("ANGLE_AND_LENGTH")),
("strokeJoin", e("BEVEL")),
]),
o(vec![("styleID", u(2)), ("strokeJoin", e("MITER"))]),
o(vec![("styleID", u(3)), ("strokeJoin", e("ROUND"))]),
],
),
),
],
),
node(
31,
Some((1, "\"")),
"VECTOR",
"Arrow",
vec![
("size", xy(300.0, 0.0)),
("transform", at(0.0, 230.0)),
stroke(),
("strokeWeight", f(2.0)),
("strokeCap", e("NONE")),
("vectorData", vector_data(2, 100.0, 0.0, vec![o(vec![("styleID", u(2)), ("strokeCap", e("ARROW_LINES"))])])),
],
),
node(
42,
Some((1, "#")),
"VECTOR",
"Join Fallbacks",
vec![
("size", xy(100.0, 10.0)),
("transform", at(0.0, 330.0)),
stroke(),
("strokeJoin", e("MITER")),
("vectorData", vector_data(4, 100.0, 10.0, vec![o(vec![("styleID", u(5)), ("strokeJoin", u(999))])])),
],
),
node(
32,
Some((1, "#")),
"VECTOR",
"Broken",
vec![
("size", xy(10.0, 8.0)),
("transform", at(700.0, 200.0)),
("fillPaints", arr(vec![solid(0.0, 0.0, 1.0)])),
("fillGeometry", outline(0)),
("vectorData", vector_data(3, 10.0, 8.0, vec![])),
],
),
node(
33,
Some((1, "$")),
"STICKY",
"Idea",
vec![
("size", xy(200.0, 200.0)),
("fillPaints", arr(vec![solid(1.0, 0.9, 0.4)])),
("fontSize", f(24.0)),
("textData", text_data("Ship it")),
],
),
node(
34,
Some((1, "%")),
"SHAPE_WITH_TEXT",
"Bubble",
vec![
("size", xy(100.0, 60.0)),
("transform", at(0.0, 400.0)),
("fillPaints", arr(vec![solid(0.2, 0.6, 1.0)])),
("shapeWithTextType", e("ELLIPSE")),
("fillGeometry", outline(0)),
("textData", text_data("Hi")),
],
),
node(
35,
Some((1, "&")),
"RECTANGLE",
"Box",
vec![("size", xy(100.0, 100.0)), ("transform", at(400.0, 0.0)), ("fillPaints", arr(vec![solid(0.8, 0.8, 0.8)]))],
),
node(
36,
Some((1, "'")),
"CONNECTOR",
"Link",
vec![
stroke(),
("strokeWeight", f(2.0)),
("connectorStart", o(vec![("position", xy(0.0, 300.0))])),
("connectorEnd", o(vec![("endpointNodeID", g(35))])),
("connectorEndCap", e("ARROW_EQUILATERAL")),
("connectorLineStyle", e("ELBOWED")),
],
),
node(
37,
Some((1, "(")),
"TABLE",
"Grid",
vec![("size", xy(100.0, 50.0)), ("transform", at(300.0, 400.0)), ("strokePaints", arr(vec![solid(0.0, 0.0, 0.0)]))],
),
node(
39,
Some((1, ")")),
"FRAME",
"Proto",
vec![("size", xy(50.0, 50.0)), ("transform", at(500.0, 400.0)), ("prototypeInteractions", arr(vec![click]))],
),
];
let mut broken = square_blob();
broken.truncate(30);
let blobs = [triangle_blob(), square_blob(), arrow_blob(), broken, join_fallback_blob()];
o(vec![("nodeChanges", arr(nodes)), ("blobs", arr(blobs.into_iter().map(|b| o(vec![("bytes", Kv::Bytes(b))])).collect()))])
}
fn tail_canvas() -> Vec<u8> {
canvas(&schema(), &tail_message())
}
fn region_canvas(fill_paints: Option<Vec<Kv<'static>>>, style_id: u32) -> Vec<u8> {
let mut message = tail_message();
let Kv::Array(nodes) = field_mut(&mut message, "nodeChanges").unwrap() else { panic!() };
let wave = nodes.iter_mut().find(|node| node.get("name").and_then(Kv::str) == Some("Wave")).unwrap();
let vector_data = field_mut(wave, "vectorData").unwrap();
let Kv::Array(styles) = field_mut(vector_data, "styleOverrideTable").unwrap() else { panic!() };
let Kv::Object(fields) = styles.first_mut().unwrap() else { panic!() };
if let Some(fill_paints) = fill_paints {
fields.push(("fillPaints", arr(fill_paints)));
}
let mut network = network::decode(&square_blob()).unwrap();
network.regions[0].style = style_id;
let Kv::Array(blobs) = field_mut(&mut message, "blobs").unwrap() else { panic!() };
let bytes = field_mut(blobs.get_mut(1).unwrap(), "bytes").unwrap();
*bytes = Kv::Bytes(network::encode(&network));
canvas(&schema(), &message)
}
fn region_canvas_with_link(own: Option<Kv<'static>>, link_target: Option<u64>, linked_fill: Kv<'static>) -> Vec<u8> {
region_canvas_with_typed_link(own, link_target, "FILL", linked_fill)
}
fn region_canvas_with_typed_link(own: Option<Kv<'static>>, link_target: Option<u64>, style_type: &'static str, linked_fill: Kv<'static>) -> Vec<u8> {
let mut message = tail_message();
let Kv::Array(nodes) = field_mut(&mut message, "nodeChanges").unwrap() else { panic!() };
let wave = nodes.iter_mut().find(|node| node.get("name").and_then(Kv::str) == Some("Wave")).unwrap();
let vector_data = field_mut(wave, "vectorData").unwrap();
let Kv::Array(styles) = field_mut(vector_data, "styleOverrideTable").unwrap() else { panic!() };
let Kv::Object(fields) = styles.first_mut().unwrap() else { panic!() };
if let Some(own) = own {
fields.push(("fillPaints", arr(vec![own])));
}
if let Some(target) = link_target {
fields.push(("styleIdForFill", o(vec![("guid", g(target))])));
}
nodes.push(node(50, None, "RECTANGLE", "Linked Fill", vec![("styleType", e(style_type)), ("fillPaints", arr(vec![linked_fill]))]));
let mut network = network::decode(&square_blob()).unwrap();
network.regions[0].style = 1;
let Kv::Array(blobs) = field_mut(&mut message, "blobs").unwrap() else { panic!() };
*field_mut(blobs.get_mut(1).unwrap(), "bytes").unwrap() = Kv::Bytes(network::encode(&network));
canvas(&schema(), &message)
}
fn field_mut<'a, 's>(value: &'a mut Kv<'s>, name: &str) -> Option<&'a mut Kv<'s>> {
if let Kv::Object(fields) = value {
return fields.iter_mut().find(|(key, _)| *key == name).map(|(_, field)| field);
}
None
}
#[test]
fn vector_region_fills_import_from_style_table() {
let solid = o(vec![
("type", e("SOLID")),
("color", o(vec![("r", f(0.2)), ("g", f(0.4)), ("b", f(0.8)), ("a", f(0.5))])),
("opacity", f(0.5)),
("visible", Kv::Bool(false)),
]);
let gradient = o(vec![
("type", e("GRADIENT_LINEAR")),
(
"stops",
arr(vec![
o(vec![("position", f(0.0)), ("color", o(vec![("r", f(1.0)), ("g", f(0.0)), ("b", f(0.0)), ("a", f(1.0))]))]),
o(vec![("position", f(1.0)), ("color", o(vec![("r", f(0.0)), ("g", f(0.0)), ("b", f(1.0)), ("a", f(0.25))]))]),
]),
),
]);
let image_hash = vec![0x12, 0x34, 0x56];
let image = o(vec![("type", e("IMAGE")), ("image", o(vec![("hash", Kv::Bytes(image_hash.clone()))])), ("imageScaleMode", e("FILL"))]);
let wire = region_canvas(Some(vec![solid, gradient, image]), 1);
let (doc, warnings) = import(&wire, "Region fills").unwrap();
let fills = network_of(&doc, "Wave").regions[0].fills.as_ref().unwrap();
let figcraft_doc::color::PaintKind::Solid { color } = &fills[0].kind else { panic!("{fills:?}") };
assert_eq!((color.r, color.g, color.b, fills[0].opacity, fills[0].visible), (0.2, 0.4, 0.8, 0.25, false));
assert!(matches!(&fills[1].kind, figcraft_doc::color::PaintKind::Gradient(g) if g.stops.len() == 2 && g.stops[1].color.a == 0.25));
let figcraft_doc::color::PaintKind::Image(imported_image) = &fills[2].kind else { panic!("{fills:?}") };
let image_key = imported_image.image.clone();
assert!(doc.images.contains_key(&image_key), "image reference must retain its image placeholder");
assert!(!warnings.iter().any(|warning| warning.contains("their own fill use the layer's fill")), "{warnings:?}");
let saved = crate::save_bytes(&doc, None).unwrap();
let (reopened, _) = crate::load_bytes(&saved).unwrap();
assert_eq!(network_of(&reopened, "Wave").regions[0].fills, Some(fills.clone()));
assert!(reopened.images.contains_key(&image_key), "image reference must survive native save/reopen");
}
#[test]
fn vector_region_missing_and_empty_paints_remain_distinct() {
let (inherited, _) = import(®ion_canvas(None, 1), "Inherited region").unwrap();
assert_eq!(network_of(&inherited, "Wave").regions[0].fills, None);
let (empty, _) = import(®ion_canvas(Some(Vec::new()), 1), "Empty region").unwrap();
assert_eq!(network_of(&empty, "Wave").regions[0].fills, Some(Vec::new()));
}
#[test]
fn vector_region_fills_survive_a_fig_export() {
let solid = o(vec![("type", e("SOLID")), ("color", o(vec![("r", f(0.2)), ("g", f(0.4)), ("b", f(0.8)), ("a", f(1.0))])), ("opacity", f(0.5))]);
let gradient = o(vec![
("type", e("GRADIENT_LINEAR")),
(
"stops",
arr(vec![
o(vec![("position", f(0.0)), ("color", o(vec![("r", f(1.0)), ("g", f(0.0)), ("b", f(0.0)), ("a", f(1.0))]))]),
o(vec![("position", f(1.0)), ("color", o(vec![("r", f(0.0)), ("g", f(0.0)), ("b", f(1.0)), ("a", f(1.0))]))]),
]),
),
]);
let (doc, _) = import(®ion_canvas(Some(vec![solid, gradient]), 1), "Region fills").unwrap();
let first = network_of(&doc, "Wave").regions[0].fills.clone();
assert!(first.as_ref().is_some_and(|fills| fills.len() == 2), "{first:?}");
let (bytes, warnings) = crate::fig::export::export(&doc, None).unwrap();
assert!(!warnings.iter().any(|warning| warning.contains("region")), "{warnings:?}");
let (back, _) = import(&bytes, "Again").unwrap();
assert_eq!(network_of(&back, "Wave").regions[0].fills, first);
}
#[test]
fn vector_region_linked_fill_uses_style_paints_without_recording_definition() {
let linked = solid(0.9, 0.1, 0.2);
let own = solid(0.1, 0.2, 0.9);
let wire = region_canvas_with_link(Some(own), Some(50), linked);
let (doc, _) = import(&wire, "Linked region style").unwrap();
let fills = network_of(&doc, "Wave").regions[0].fills.as_ref().unwrap();
let figcraft_doc::color::PaintKind::Solid { color } = &fills[0].kind else { panic!("{fills:?}") };
assert_eq!((color.r, color.g, color.b), (0.9, 0.1, 0.2));
assert!(doc.nodes().all(|node| node.name != "Linked Fill"), "style lookup must not add a style as a layer");
let archive = Archive::open(&wire).unwrap();
let (schema, message) = decode_canvas(&archive.canvas).unwrap();
let message = schema.decode_message(schema.find("Message").unwrap(), &message).unwrap();
let (rest, _, _) = map::to_rest(&message, "Linked region style", crate::rest::MAX_NODES);
assert!(rest.get("styles").is_none(), "regional link must not populate the layer styles map");
}
#[test]
fn vector_region_variable_bound_own_fill_wins_over_linked_style() {
let own =
o(vec![("type", e("SOLID")), ("color", o(vec![("r", f(0.1)), ("g", f(0.2)), ("b", f(0.9)), ("a", f(1.0))])), ("colorVar", alias_data(41))]);
let (doc, _) = import(®ion_canvas_with_link(Some(own), Some(50), solid(0.9, 0.1, 0.2)), "Bound region style").unwrap();
let fills = network_of(&doc, "Wave").regions[0].fills.as_ref().unwrap();
let figcraft_doc::color::PaintKind::Solid { color } = &fills[0].kind else { panic!("{fills:?}") };
assert_eq!((color.r, color.g, color.b), (0.1, 0.2, 0.9));
}
#[test]
fn vector_region_missing_fills_inherit_and_unresolved_link_keeps_own_fill() {
let (inherited, _) = import(®ion_canvas_with_link(None, Some(50), solid(0.9, 0.1, 0.2)), "Inherited linked region").unwrap();
assert_eq!(network_of(&inherited, "Wave").regions[0].fills, None);
let own = solid(0.1, 0.2, 0.9);
let (fallback, _) = import(®ion_canvas_with_link(Some(own), Some(999), solid(0.9, 0.1, 0.2)), "Unresolved linked region").unwrap();
let fills = network_of(&fallback, "Wave").regions[0].fills.as_ref().unwrap();
let figcraft_doc::color::PaintKind::Solid { color } = &fills[0].kind else { panic!("{fills:?}") };
assert_eq!((color.r, color.g, color.b), (0.1, 0.2, 0.9));
}
#[test]
fn vector_region_link_to_non_fill_style_keeps_own_fill() {
let own = solid(0.1, 0.2, 0.9);
let (doc, _) = import(®ion_canvas_with_typed_link(Some(own), Some(50), "TEXT", solid(0.9, 0.1, 0.2)), "Text-linked region").unwrap();
let fills = network_of(&doc, "Wave").regions[0].fills.as_ref().unwrap();
let figcraft_doc::color::PaintKind::Solid { color } = &fills[0].kind else { panic!("{fills:?}") };
assert_eq!((color.r, color.g, color.b), (0.1, 0.2, 0.9));
}
#[test]
fn vector_region_paint_budget_covers_the_whole_file() {
// 190 gradients of 255 stops: 48,640 elements per layer, so four layers fit and a fifth doesn't.
let stop = o(vec![("position", f(0.0)), ("color", o(vec![("r", f(1.0)), ("g", f(0.0)), ("b", f(0.0)), ("a", f(1.0))]))]);
let gradient = o(vec![("type", e("GRADIENT_LINEAR")), ("stops", arr(vec![stop; 255]))]);
let mut message = tail_message();
let Kv::Array(nodes) = field_mut(&mut message, "nodeChanges").unwrap() else { panic!() };
let wave = nodes.iter_mut().find(|node| node.get("name").and_then(Kv::str) == Some("Wave")).unwrap();
let vector_data = field_mut(wave, "vectorData").unwrap();
let Kv::Array(styles) = field_mut(vector_data, "styleOverrideTable").unwrap() else { panic!() };
let Kv::Object(style_fields) = styles.first_mut().unwrap() else { panic!() };
style_fields.push(("fillPaints", arr(vec![gradient; 190])));
let wave = wave.clone();
for (index, position) in ["w", "x", "y", "z"].into_iter().enumerate() {
let mut copy = wave.clone();
let Kv::Object(fields) = &mut copy else { panic!() };
for (key, value) in fields.iter_mut() {
match *key {
"guid" => *value = g(60 + index as u64),
"name" => *value = Kv::Str(format!("Wave {index}")),
"parentIndex" => *value = o(vec![("guid", g(1)), ("position", s(position))]),
_ => {}
}
}
nodes.push(copy);
}
let mut network = network::decode(&square_blob()).unwrap();
network.regions[0].style = 1;
let Kv::Array(blobs) = field_mut(&mut message, "blobs").unwrap() else { panic!() };
*field_mut(blobs.get_mut(1).unwrap(), "bytes").unwrap() = Kv::Bytes(network::encode(&network));
let (doc, warnings) = import(&canvas(&schema(), &message), "Region paint budget").unwrap();
let painted = ["Wave", "Wave 0", "Wave 1", "Wave 2", "Wave 3"].iter().filter(|name| network_of(&doc, name).regions[0].fills.is_some()).count();
assert_eq!(painted, 4);
assert!(warnings.iter().any(|warning| warning.contains("region paint data exceeded import limits")), "{warnings:?}");
}
#[test]
fn vector_regions_keep_distinct_solid_paints() {
let mut message = tail_message();
let Kv::Array(nodes) = field_mut(&mut message, "nodeChanges").unwrap() else { panic!() };
let wave = nodes.iter_mut().find(|node| node.get("name").and_then(Kv::str) == Some("Wave")).unwrap();
let vector_data = field_mut(wave, "vectorData").unwrap();
let Kv::Array(styles) = field_mut(vector_data, "styleOverrideTable").unwrap() else { panic!() };
let Kv::Object(first_style) = styles.first_mut().unwrap() else { panic!() };
first_style.push(("fillPaints", arr(vec![solid(0.1, 0.2, 0.9)])));
let Kv::Object(second_style) = o(vec![("styleID", u(2)), ("fillPaints", arr(vec![solid(0.9, 0.1, 0.2)]))]) else { panic!() };
styles.push(Kv::Object(second_style));
let mut network = network::decode(&square_blob()).unwrap();
network.regions[0].style = 1;
network.regions.push(network::Region { style: 2, non_zero: network.regions[0].non_zero, loops: network.regions[0].loops.clone() });
let Kv::Array(blobs) = field_mut(&mut message, "blobs").unwrap() else { panic!() };
let bytes = field_mut(blobs.get_mut(1).unwrap(), "bytes").unwrap();
*bytes = Kv::Bytes(network::encode(&network));
let (doc, _) = import(&canvas(&schema(), &message), "Two region fills").unwrap();
let regions = &network_of(&doc, "Wave").regions;
assert_eq!(regions.len(), 2);
let color = |index: usize| match ®ions[index].fills.as_ref().unwrap()[0].kind {
figcraft_doc::color::PaintKind::Solid { color } => (color.r, color.g, color.b),
paint => panic!("{paint:?}"),
};
assert_eq!(color(0), (0.1, 0.2, 0.9));
assert_eq!(color(1), (0.9, 0.1, 0.2));
}
#[test]
fn vector_region_gradient_limit_warns_instead_of_silently_truncating() {
for count in [256, 257] {
let stops = (0..count)
.map(|i| {
let value = if i + 1 == count { 1.0 } else { 0.0 };
o(vec![
("position", f(i as f64 / (count - 1) as f64)),
("color", o(vec![("r", f(value)), ("g", f(value)), ("b", f(value)), ("a", f(1.0))])),
])
})
.collect();
let gradient = o(vec![("type", e("GRADIENT_LINEAR")), ("stops", arr(stops))]);
let (doc, warnings) = import(®ion_canvas(Some(vec![gradient]), 1), "Bounded region gradient").unwrap();
let fills = &network_of(&doc, "Wave").regions[0].fills;
if count == 256 {
let figcraft_doc::color::PaintKind::Gradient(g) = &fills.as_ref().unwrap()[0].kind else { panic!() };
assert_eq!(g.stops.len(), 256);
assert_eq!(g.stops.last().unwrap().color.r, 1.0);
assert!(!warnings.iter().any(|w| w.contains("vector region paint data exceeded")));
} else {
assert!(fills.is_none());
assert!(warnings.iter().any(|w| w.contains("vector region paint data exceeded import limits")), "{warnings:?}");
}
}
}
#[test]
fn vector_region_invalid_paints_and_style_refs_warn() {
let malformed = o(vec![("opacity", f(0.5))]);
let unsupported = o(vec![("type", e("EMOJI"))]);
let (doc, warnings) = import(®ion_canvas(Some(vec![malformed, unsupported]), 1), "Invalid region paints").unwrap();
assert_eq!(network_of(&doc, "Wave").regions[0].fills, Some(Vec::new()));
assert!(warnings.iter().any(|warning| warning.contains("invalid vector region paints were skipped")), "{warnings:?}");
assert!(warnings.iter().any(|warning| warning.contains("EMOJI paints are not supported")), "{warnings:?}");
let (doc, warnings) = import(®ion_canvas(None, 9), "Missing region style").unwrap();
assert_eq!(network_of(&doc, "Wave").regions[0].fills, None);
assert!(warnings.iter().any(|warning| warning.contains("vector region references a missing fill style")), "{warnings:?}");
}
fn network_of<'d>(doc: &'d figcraft_doc::Document, name: &str) -> &'d figcraft_doc::VectorNetwork {
match &named(doc, name).kind {
NodeKind::Vector { network } => network,
k => panic!("{name} is {k:?}"),
}
}
#[test]
fn vector_points_without_a_radius_of_their_own_take_the_layers() {
// A vector rounded from the layer's corner radius: the editor rounds every point whose
// style doesn't set a radius (no style, or one without `cornerRadius`) with the layer's,
// while a point's own radius, zero included, wins.
let mut message = tail_message();
let Kv::Array(nodes) = field_mut(&mut message, "nodeChanges").unwrap() else { panic!() };
let wave = nodes.iter_mut().find(|node| node.get("name").and_then(Kv::str) == Some("Wave")).unwrap();
let Kv::Object(fields) = wave else { panic!() };
fields.push(("cornerRadius", f(6.0)));
let vector_data = field_mut(wave, "vectorData").unwrap();
let Kv::Array(styles) = field_mut(vector_data, "styleOverrideTable").unwrap() else { panic!() };
let Kv::Object(sharp) = styles.get_mut(2).unwrap() else { panic!() };
sharp.push(("cornerRadius", f(0.0)));
let (doc, _) = import(&canvas(&schema(), &message), "Rounded").unwrap();
let radii: Vec<f64> = network_of(&doc, "Wave").vertices.iter().map(|v| v.radius).collect();
assert_eq!(radii, [6.0, 4.0, 6.0, 0.0], "no style, own radius, style without one, own zero");
// Without a layer radius, the points without one of their own stay sharp.
let (doc, _) = import(&tail_canvas(), "Tail").unwrap();
let radii: Vec<f64> = network_of(&doc, "Wave").vertices.iter().map(|v| v.radius).collect();
assert_eq!(radii, [0.0, 4.0, 0.0, 0.0]);
}
#[test]
fn an_instance_that_rounds_a_vector_keeps_its_own_points() {
// An instance's copy shares its main's vector data; overriding the layer's radius must not
// reuse the main's network, nor hand the instance's to the main.
let mut message = tail_message();
let Kv::Array(nodes) = field_mut(&mut message, "nodeChanges").unwrap() else { panic!() };
let wave = nodes.iter_mut().find(|node| node.get("name").and_then(Kv::str) == Some("Wave")).unwrap();
*field_mut(wave, "parentIndex").unwrap() = o(vec![("guid", g(50)), ("position", s("!"))]);
*field_mut(wave, "transform").unwrap() = at(0.0, 0.0);
let rounded = o(vec![("guidPath", o(vec![("guids", arr(vec![g(30)]))])), ("cornerRadius", f(6.0))]);
nodes.push(node(50, Some((1, "~")), "SYMBOL", "Mark", vec![("size", xy(200.0, 100.0)), ("transform", at(700.0, 0.0))]));
nodes.push(node(
51,
Some((1, "~!")),
"INSTANCE",
"Rounded mark",
vec![
("size", xy(200.0, 100.0)),
("transform", at(700.0, 400.0)),
("symbolData", o(vec![("symbolID", g(50)), ("symbolOverrides", arr(vec![rounded]))])),
],
));
let (doc, _) = import(&canvas(&schema(), &message), "Instance").unwrap();
let radii_under = |parent: &str| -> Vec<f64> {
let p = named(&doc, parent);
let wave = p.children.iter().map(|c| doc.node(*c).unwrap()).find(|n| n.name == "Wave").unwrap();
let NodeKind::Vector { network } = &wave.kind else { panic!() };
network.vertices.iter().map(|v| v.radius).collect()
};
assert_eq!(radii_under("Mark"), [0.0, 4.0, 0.0, 0.0]);
assert_eq!(radii_under("Rounded mark"), [6.0, 4.0, 6.0, 6.0]);
}
#[test]
fn a_scaled_instance_scales_its_vectors_point_radii() {
// Point radii are lengths: an instance scaled with the Scale tool draws its main's, from a
// point's own style or from the layer, times the factor (#2091).
let mut message = tail_message();
let Kv::Array(nodes) = field_mut(&mut message, "nodeChanges").unwrap() else { panic!() };
let wave = nodes.iter_mut().find(|node| node.get("name").and_then(Kv::str) == Some("Wave")).unwrap();
*field_mut(wave, "parentIndex").unwrap() = o(vec![("guid", g(50)), ("position", s("!"))]);
*field_mut(wave, "transform").unwrap() = at(0.0, 0.0);
let Kv::Object(fields) = wave else { panic!() };
fields.push(("cornerRadius", f(3.0)));
nodes.push(node(50, Some((1, "~")), "SYMBOL", "Mark", vec![("size", xy(200.0, 100.0)), ("transform", at(700.0, 0.0))]));
nodes.push(node(
51,
Some((1, "~!")),
"INSTANCE",
"Big mark",
vec![
("size", xy(400.0, 200.0)),
("transform", at(700.0, 400.0)),
("symbolData", o(vec![("symbolID", g(50)), ("uniformScaleFactor", f(2.0))])),
],
));
let (doc, _) = import(&canvas(&schema(), &message), "Scaled").unwrap();
let radii_under = |parent: &str| -> Vec<f64> {
let p = named(&doc, parent);
let wave = p.children.iter().map(|c| doc.node(*c).unwrap()).find(|n| n.name == "Wave").unwrap();
let NodeKind::Vector { network } = &wave.kind else { panic!() };
network.vertices.iter().map(|v| v.radius).collect()
};
assert_eq!(radii_under("Mark"), [3.0, 4.0, 3.0, 3.0]);
assert_eq!(radii_under("Big mark"), [6.0, 8.0, 6.0, 6.0]);
}
#[test]
fn vectors_import_as_editable_networks() {
let (doc, warnings) = import(&tail_canvas(), "Tail").unwrap();
// Scaled from the normalized size (100 × 50) to the layer's (200 × 100), corner and handles kept.
let wave = network_of(&doc, "Wave");
let pts: Vec<(f64, f64)> = wave.vertices.iter().map(|v| (v.x, v.y)).collect();
assert_eq!(pts, [(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)]);
assert_eq!((wave.vertices[1].radius, wave.vertices[1].mirror), (4.0, Some(HandleMirroring::AngleAndLength)));
assert_eq!(wave.vertices[0].mirror, None);
assert_eq!(
wave.vertices.iter().map(|v| v.join).collect::<Vec<_>>(),
[None, Some(StrokeJoin::Bevel), Some(StrokeJoin::Miter), Some(StrokeJoin::Round)]
);
assert_eq!(named(&doc, "Wave").stroke.join, StrokeJoin::Miter);
assert_eq!((wave.segments[0].ta, wave.segments[0].tb), ((20.0, 0.0), (-20.0, 0.0)));
assert_eq!(wave.regions.len(), 1);
assert_eq!((wave.regions[0].loops.clone(), wave.regions[0].winding), (vec![vec![0, 1, 2, 3]], WindingRule::EvenOdd));
assert_eq!(named(&doc, "Wave").fills.len(), 1);
// An open line stays a stroke; its end point's own cap is the end cap.
let arrow = named(&doc, "Arrow");
assert_eq!(network_of(&doc, "Arrow").vertices.iter().map(|v| v.x).collect::<Vec<_>>(), [0.0, 300.0]);
assert!(network_of(&doc, "Arrow").regions.is_empty());
assert_eq!((arrow.stroke.cap_start, arrow.stroke.cap_end), (StrokeCap::None, StrokeCap::LineArrow));
assert_eq!((arrow.strokes.len(), arrow.fills.len()), (1, 0));
// A damaged network falls back to the outline.
assert_eq!(network_of(&doc, "Broken").regions.len(), 1);
assert!(warnings.iter().any(|w| w.contains("damaged vector networks import as outlines")), "{warnings:?}");
let fallback = network_of(&doc, "Join Fallbacks");
assert!(fallback.vertices.iter().all(|v| v.join.is_none()));
assert_eq!(named(&doc, "Join Fallbacks").stroke.join, StrokeJoin::Miter);
assert!(
warnings
.iter()
.any(|w| w.contains("vector points refer to point settings missing from the file; they use the layer's joins and plain corners")),
"{warnings:?}"
);
assert!(warnings.iter().any(|w| w.contains("unknown stroke joins use the layer join")), "{warnings:?}");
assert!(warnings.iter().any(|w| w.contains("dashed or variable-width strokes render with the layer join")), "{warnings:?}");
}
#[test]
fn per_segment_stroke_styles_are_reported() {
let styled_import = |segment_style: u32| {
let mut blob = square_blob();
// The first segment's style id follows the counts and the vertices (12 bytes each).
blob[12 + 4 * 12..12 + 4 * 12 + 4].copy_from_slice(&segment_style.to_le_bytes());
let net = network::decode(&blob).unwrap();
assert_eq!((net.segments.len(), net.segments[0].style), (4, segment_style));
let mut message = tail_message();
let Kv::Object(fields) = &mut message else { panic!() };
let Kv::Array(blobs) = &mut fields.iter_mut().find(|(key, _)| *key == "blobs").unwrap().1 else { panic!() };
blobs[1] = o(vec![("bytes", Kv::Bytes(blob))]);
let (doc, warnings) = import(&canvas(&schema(), &message), "Tail").unwrap();
assert_eq!(network_of(&doc, "Wave").segments.len(), 4);
warnings
};
assert!(network::decode(&square_blob()).unwrap().segments.iter().all(|s| s.style == 0));
let plain = import(&tail_canvas(), "Tail").unwrap().1;
assert!(!plain.iter().any(|w| w.contains("vector segments")), "{plain:?}");
let uninterpreted = |w: &String| w.contains("style settings of some vector segments aren't supported; those segments use the layer's stroke");
let missing = |w: &String| w.contains("some vector segments refer to style settings missing from the file; they use the layer's stroke");
// Style 1 has a row in the layer's override table; its contents are not applied.
let known = styled_import(1);
assert_eq!(known.iter().filter(|w| uninterpreted(w)).count(), 1, "{known:?}");
assert!(!known.iter().any(missing), "{known:?}");
// Style 7 names no row at all.
let unknown = styled_import(7);
assert_eq!(unknown.iter().filter(|w| missing(w)).count(), 1, "{unknown:?}");
assert!(!unknown.iter().any(uninterpreted), "{unknown:?}");
}
#[test]
fn other_layer_kinds_import_as_the_closest_layers() {
let (doc, warnings) = import(&tail_canvas(), "Tail").unwrap();
let text_of = |id| match &doc.node(id).unwrap().kind {
NodeKind::Text(t) => t.characters.clone(),
k => panic!("{k:?}"),
};
// A sticky note: a frame with its paint, holding its text.
let idea = named(&doc, "Idea");
assert!(matches!(idea.kind, NodeKind::Frame));
assert_eq!(idea.fills.len(), 1);
assert_eq!(idea.children.len(), 1);
assert_eq!(text_of(idea.children[0]), "Ship it");
let NodeKind::Text(t) = &doc.node(idea.children[0]).unwrap().kind else { panic!() };
assert_eq!(t.style.font_size, 24.0);
// A shape with text: its outline as a vector (with the paint), then the text.
let bubble = named(&doc, "Bubble");
assert!(bubble.fills.is_empty());
let kids: Vec<&figcraft_doc::Node> = bubble.children.iter().map(|c| doc.node(*c).unwrap()).collect();
assert!(matches!(kids[0].kind, NodeKind::Vector { .. }) && kids[0].fills.len() == 1);
assert_eq!(text_of(bubble.children[1]), "Hi");
// An elbowed connector from a free point to a sibling: in right angles, into the side of the
// box facing the point, with its end cap.
let link = named(&doc, "Link");
let world = doc.world_transform(link.id);
let ends: Vec<(f64, f64)> =
network_of(&doc, "Link").vertices.iter().map(|v| world * figcraft_doc::geom::Point::new(v.x, v.y)).map(|p| (p.x, p.y)).collect();
assert_eq!(ends, [(0.0, 300.0), (198.0, 300.0), (198.0, 50.0), (396.0, 50.0)]);
assert_eq!(link.stroke.cap_end, StrokeCap::TriangleArrow);
// A table: a frame.
assert!(matches!(named(&doc, "Grid").kind, NodeKind::Frame));
for w in ["sticky layers import as frames", "shape with text layers", "connector layers import as vectors", "table layers", "elbowed"] {
assert!(warnings.iter().any(|x| x.contains(w)), "{w}: {warnings:?}");
}
}
/// Connectors saved without their path: straight to the point on the layer, elbowed and curved
/// from the side the end's point lies on, as a board connector would run.
#[test]
fn connectors_without_a_saved_path_follow_their_line_style() {
let mut message = tail_message();
let Kv::Array(nodes) = field_mut(&mut message, "nodeChanges").unwrap() else { panic!() };
let box_at = |id, name: &str, x| node(id, Some((1, "*")), "RECTANGLE", name, vec![("size", xy(100.0, 100.0)), ("transform", at(x, 600.0))]);
let joined = |id, name: &str, style: &'static str| {
let side = |node, x| o(vec![("endpointNodeID", g(node)), ("relativePosition", xy(x, 0.5))]);
node(
id,
Some((1, "+")),
"CONNECTOR",
name,
vec![
("strokePaints", arr(vec![solid(0.0, 0.0, 0.0)])),
("connectorStart", side(60, 1.0)),
("connectorEnd", side(61, 0.0)),
("connectorLineStyle", e(style)),
],
)
};
nodes.extend([box_at(60, "A", 0.0), box_at(61, "B", 300.0), joined(62, "Curve", "CURVED"), joined(63, "Line", "STRAIGHT")]);
let (doc, warnings) = import(&canvas(&schema(), &message), "Routes").unwrap();
let world = |name: &str| doc.world_transform(named(&doc, name).id);
// Curved: one curve from A's right side to B's left, leaving and arriving level.
let curve = network_of(&doc, "Curve");
let ends: Vec<_> = curve.vertices.iter().map(|v| world("Curve") * figcraft_doc::geom::Point::new(v.x, v.y)).collect();
assert_eq!(ends.iter().map(|p| (p.x, p.y)).collect::<Vec<_>>(), [(104.0, 650.0), (296.0, 650.0)], "END_GAP outside the sides");
assert_eq!(curve.segments.len(), 1);
assert_eq!((curve.segments[0].ta, curve.segments[0].tb), ((96.0, 0.0), (-96.0, 0.0)), "the curve leaves and arrives along the sides");
// Straight: unchanged, to the points the file gives on the layers.
let line: Vec<_> =
network_of(&doc, "Line").vertices.iter().map(|v| world("Line") * figcraft_doc::geom::Point::new(v.x, v.y)).map(|p| (p.x, p.y)).collect();
assert_eq!(line, [(100.0, 650.0), (300.0, 650.0)]);
assert!(warnings.iter().any(|w| w.contains("are routed afresh")), "{warnings:?}");
}
/// #1909: a connector end whose magnet is `AUTO` (FigJam picks the side when it draws) or `CENTER`
/// (the end aims at the layer's middle) leaves the side facing the other end, as a board connector
/// drawn here does, whatever `relativePosition` the file kept for it; a named magnet still wins.
#[test]
fn connectors_with_an_automatic_side_leave_the_side_facing_the_target() {
let mut message = tail_message();
let Kv::Array(nodes) = field_mut(&mut message, "nodeChanges").unwrap() else { panic!() };
let box_at = |id, name: &str, x| node(id, Some((1, "*")), "RECTANGLE", name, vec![("size", xy(100.0, 100.0)), ("transform", at(x, 600.0))]);
// The ends keep a stale point on the left of A and the right of B, as the reporter's file did.
let end = |node, magnet: &'static str, x| o(vec![("endpointNodeID", g(node)), ("magnet", e(magnet)), ("relativePosition", xy(x, 0.5))]);
let joined = |id, name: &str, style: &'static str, start: &'static str, finish: &'static str| {
node(
id,
Some((1, "+")),
"CONNECTOR",
name,
vec![
("strokePaints", arr(vec![solid(0.0, 0.0, 0.0)])),
("connectorStart", end(60, start, 0.0)),
("connectorEnd", end(61, finish, 1.0)),
("connectorLineStyle", e(style)),
],
)
};
nodes.extend([
box_at(60, "A", 0.0),
box_at(61, "B", 300.0),
joined(62, "Elbow", "ELBOWED", "AUTO", "AUTO"),
joined(63, "Line", "STRAIGHT", "CENTER", "CENTER"),
joined(64, "Curve", "CURVED", "AUTO", "AUTO"),
joined(65, "Named", "ELBOWED", "BOTTOM", "AUTO"),
]);
let (doc, _) = import(&canvas(&schema(), &message), "Sides").unwrap();
let ends = |name: &str| -> ((f64, f64), (f64, f64)) {
let world = doc.world_transform(named(&doc, name).id);
let pts: Vec<(f64, f64)> =
network_of(&doc, name).vertices.iter().map(|v| world * figcraft_doc::geom::Point::new(v.x, v.y)).map(|p| (p.x, p.y)).collect();
(pts[0], pts[pts.len() - 1])
};
// From A's right side (facing B) to B's left side (facing A), not from the stale left point; each
// end starts `END_GAP` (4) outside its side.
for name in ["Elbow", "Line", "Curve"] {
assert_eq!(ends(name), ((104.0, 650.0), (296.0, 650.0)), "{name}");
}
// A named magnet keeps its side: the bottom of A; the automatic end still faces A.
assert_eq!(ends("Named"), ((50.0, 704.0), (296.0, 650.0)));
}
/// A connector with a label but no saved snapshot: a frame holding its line and its label,
/// centred on the line's middle, in black when the connector gives no paint.
#[test]
fn a_labelled_connector_without_a_snapshot_keeps_its_label() {
let mut message = tail_message();
let Kv::Array(nodes) = field_mut(&mut message, "nodeChanges").unwrap() else { panic!() };
let box_at = |id, name: &str, x| node(id, Some((1, "*")), "RECTANGLE", name, vec![("size", xy(100.0, 100.0)), ("transform", at(x, 600.0))]);
let side = |node, x| o(vec![("endpointNodeID", g(node)), ("relativePosition", xy(x, 0.5))]);
let labelled = node(
62,
Some((1, "+")),
"CONNECTOR",
"Says",
vec![
("strokePaints", arr(vec![solid(0.0, 0.0, 0.0)])),
("connectorStart", side(60, 1.0)),
("connectorEnd", side(61, 0.0)),
("connectorLineStyle", e("STRAIGHT")),
("textData", text_data("yes")),
("fontSize", f(20.0)),
],
);
nodes.extend([box_at(60, "A", 0.0), box_at(61, "B", 300.0), labelled]);
let (doc, warnings) = import(&canvas(&schema(), &message), "Labels").unwrap();
let says = named(&doc, "Says");
assert!(matches!(says.kind, NodeKind::Frame), "{:?}", says.kind);
assert!(says.fills.is_empty() && says.strokes.is_empty(), "the frame only holds the line and the label");
let kids: Vec<&figcraft_doc::Node> = says.children.iter().map(|c| doc.node(*c).unwrap()).collect();
assert_eq!(kids.len(), 2);
assert!(matches!(kids[0].kind, NodeKind::Vector { .. }) && kids[0].strokes.len() == 1, "the line keeps its stroke");
assert!(matches!(&kids[1].kind, NodeKind::Text(t) if t.characters == "yes"), "{:?}", kids[1].kind);
assert_eq!(kids[1].fills.len(), 1, "black when the connector gives no paint");
// Centred on the line's middle, (200, 650) on the page.
let label = doc.world_transform(kids[1].id) * figcraft_doc::geom::Point::new(kids[1].width / 2.0, kids[1].height / 2.0);
assert!((label.x - 200.0).abs() < 1e-6 && (label.y - 650.0).abs() < 1e-6, "{label:?}");
assert!(warnings.iter().any(|w| w.contains("centred on the line")), "{warnings:?}");
assert!(!warnings.iter().any(|w| w.contains("connector labels were skipped")), "{warnings:?}");
}
#[test]
fn variable_prototype_actions_import() {
let (doc, warnings) = import(&tail_canvas(), "Tail").unwrap();
let actions = &named(&doc, "Proto").interactions[0].actions;
assert_eq!(actions.len(), 3, "{actions:?} {warnings:?}");
assert!(matches!(&actions[0], Action::SetVariable { variable, value, .. } if variable == "1:41" && *value == Value::Bool(true)));
let Action::Conditional { blocks } = &actions[1] else { panic!("{:?}", actions[1]) };
assert_eq!(blocks.len(), 2);
assert!(blocks[0].condition.is_some() && matches!(blocks[0].actions[..], [Action::Back]));
assert!(blocks[1].condition.is_none() && matches!(blocks[1].actions[..], [Action::CloseOverlay]));
assert!(matches!(&actions[2], Action::SetVariableMode { collection, mode } if collection == "1:40" && mode == "1:93"));
assert!(!warnings.iter().any(|w| w.contains("prototype")), "{warnings:?}");
}
#[test]
fn unreadable_conditions_skip_the_conditional() {
// A condition of a kind that can't be read must not become an "else".
let bad = data("MAP", o(vec![]));
let a =
action("CONDITIONAL", vec![("conditionalActions", arr(vec![o(vec![("actions", arr(vec![action("BACK", vec![])])), ("condition", bad)])]))]);
let it = o(vec![("event", o(vec![("interactionType", e("ON_CLICK"))])), ("actions", arr(vec![a]))]);
let nodes = vec![
node(0, None, "DOCUMENT", "D", vec![]),
node(1, Some((0, "!")), "CANVAS", "P", vec![]),
node(2, Some((1, "!")), "FRAME", "F", vec![("size", xy(10.0, 10.0)), ("prototypeInteractions", arr(vec![it]))]),
];
let mut sc = schema();
// `MAP` isn't in the fixture's enum: add it.
let dt = sc.defs.iter_mut().find(|d| d.name == "DataType").unwrap();
let value = dt.fields.len() as u32;
dt.fields.push(Field { name: "MAP".into(), ty: None, array: false, value });
let (doc, warnings) = import(&canvas(&sc, &o(vec![("nodeChanges", arr(nodes))])), "x").unwrap();
assert!(named(&doc, "F").interactions.is_empty());
assert!(warnings.iter().any(|w| w.contains("conditions that can't be evaluated")), "{warnings:?}");
}
#[test]
fn damaged_network_blobs_never_panic() {
let good = square_blob();
assert!(network::decode(&good).is_some());
for cut in 0..good.len() {
assert!(network::decode(&good[..cut]).is_none(), "{cut}");
}
let mut r = Lcg(5);
for _ in 0..5000 {
let mut m = good.clone();
for _ in 0..1 + r.next() % 4 {
let i = (r.next() as usize) % m.len();
m[i] ^= 1 << (r.next() % 8);
}
if let Some(net) = network::decode(&m) {
assert!(net.segments.iter().all(|s| s.a < net.vertices.len() && s.b < net.vertices.len()));
assert!(net.regions.iter().flat_map(|r| &r.loops).flatten().all(|i| *i < net.segments.len()));
assert!(net.vertices.iter().all(|v| v.x.is_finite() && v.y.is_finite()));
}
}
// Counts larger than the blob, and indices out of range.
let mut huge = vec![0xff; 12];
huge.extend_from_slice(&[0; 64]);
assert!(network::decode(&huge).is_none());
let mut bad = arrow_blob();
bad[12 + 24 + 4..12 + 24 + 8].copy_from_slice(&7u32.to_le_bytes());
assert!(network::decode(&bad).is_none());
for _ in 0..2000 {
let junk: Vec<u8> = (0..(r.next() % 120)).map(|_| r.next() as u8).collect();
let _ = network::decode(&junk);
}
}
#[test]
fn segment_styles_round_trip_without_changing_geometry() {
let original = Network {
vertices: vec![vtx(0, 2.0, 3.0), vtx(0, 10.0, 20.0), vtx(0, 40.0, 50.0), vtx(0, 60.0, 70.0)],
segments: vec![
seg(0, 1, (1.0, 2.0), (3.0, 4.0)),
Segment { style: 17, a: 1, ta: (5.0, 6.0), b: 2, tb: (7.0, 8.0) },
Segment { style: 27, a: 2, ta: (9.0, 10.0), b: 3, tb: (11.0, 12.0) },
],
regions: vec![],
};
let bytes = network::encode(&original);
let decoded = network::decode(&bytes).unwrap();
assert_eq!(decoded.segments.len(), 3);
for (got, want) in decoded.segments.iter().zip(&original.segments) {
assert_eq!(got.style, want.style);
assert_eq!((got.a, got.ta, got.b, got.tb), (want.a, want.ta, want.b, want.tb));
}
for cut in 0..bytes.len() {
assert!(network::decode(&bytes[..cut]).is_none(), "truncated at {cut}");
}
}
#[test]
fn mangled_tail_files_never_panic() {
let c = tail_canvas();
let mut r = Lcg(13);
for cut in (0..c.len()).step_by(29) {
let _ = import(&c[..cut], "x");
}
for _ in 0..300 {
let mut m = c.clone();
for _ in 0..1 + r.next() % 8 {
let i = (r.next() as usize) % m.len();
m[i] ^= 1 << (r.next() % 8);
}
let _ = import(&m, "x");
}
// Mangled messages decode and map without panicking.
let sc = schema();
let root = sc.find("Message").unwrap();
let msg = encode::message(&sc, root, &tail_message()).unwrap();
for _ in 0..2000 {
let mut m = msg.clone();
for _ in 0..1 + r.next() % 4 {
let i = (r.next() as usize) % m.len();
m[i] = r.next() as u8;
}
if let Ok(kv) = sc.decode_message(root, &m) {
let (json, _, networks) = map::to_rest(&kv, "x", crate::rest::MAX_NODES);
let _ = crate::rest::import_with_networks(&json, &crate::rest::no_images, networks, crate::rest::MAX_NODES);
}
}
}
#[test]
fn junk_vector_networks_in_json_fall_back() {
let vector = |net: Value| {
serde_json::json!({"document": {"id": "0:0", "type": "DOCUMENT", "children": [{"id": "0:1", "type": "CANVAS", "children": [{
"id": "1:1", "type": "VECTOR", "name": "V", "size": {"x": 10, "y": 10}, "relativeTransform": [[1, 0, 0], [0, 1, 0]],
"fills": [], "strokes": [], "fillGeometry": [{"path": "M0 0L10 0L10 10Z"}], "vectorNetwork": net}]}]}})
};
let cases = [
serde_json::json!({"vertices": [{"x": 0, "y": 0}], "segments": [{"a": 0, "b": 5}]}),
serde_json::json!({"vertices": [{"x": 1e300, "y": 0}, {"x": 0, "y": 0}], "segments": [{"a": 0, "b": 1}]}),
serde_json::json!({"vertices": "no"}),
serde_json::json!({"vertices": [{"x": 0, "y": 0}, {"x": 1, "y": 1}], "segments": [{"a": 0, "b": 1}], "regions": [{"loops": [[9]]}]}),
];
for (i, net) in cases.into_iter().enumerate() {
let (doc, w) = crate::rest::import(&vector(net), &crate::rest::no_images).unwrap();
let NodeKind::Vector { network } = &named(&doc, "V").kind else { panic!() };
assert!(!network.segments.is_empty(), "{i}");
if i == 3 {
// Usable apart from a loop that refers to nothing: kept, the loop dropped.
assert!(network.regions.iter().all(|r| r.loops.is_empty()));
} else {
assert!(w.iter().any(|w| w.contains("vector networks import as outlines")), "{i}: {w:?}");
}
}
}
/// Local only: writes this module's fixture as a `.fig` file to the path `FIG_FIXTURE_OUT` names
/// (for opening it in the app).
#[test]
fn write_fixture() {
if let Ok(out) = std::env::var("FIG_FIXTURE_OUT") {
std::fs::write(out, zip_file(&tail_canvas())).unwrap();
}
}
/// An elbow connector saved with its path (#1910): FigJam's control points, one per run between
/// the first and the last, each on its run with the run's axis, give the path the connector keeps;
/// the first run leaves the start's side and the last arrives at the end's.
#[test]
fn an_elbow_connector_saved_with_its_path_keeps_it() {
let mut message = tail_message();
let Kv::Array(nodes) = field_mut(&mut message, "nodeChanges").unwrap() else { panic!() };
let box_at = |id, name: &str, x, y| node(id, Some((1, "*")), "RECTANGLE", name, vec![("size", xy(100.0, 100.0)), ("transform", at(x, y))]);
let point = |x, y, ax, ay| o(vec![("position", xy(x, y)), ("axis", xy(ax, ay))]);
// From A's bottom, across at y 740, down at x 200, into B's left: four runs.
let saved = node(
66,
Some((1, "+")),
"CONNECTOR",
"Saved",
vec![
("strokePaints", arr(vec![solid(0.0, 0.0, 0.0)])),
("connectorStart", o(vec![("endpointNodeID", g(64)), ("relativePosition", xy(0.5, 1.0))])),
("connectorEnd", o(vec![("endpointNodeID", g(65)), ("relativePosition", xy(0.0, 0.5))])),
("connectorLineStyle", e("ELBOWED")),
("connectorControlPoints", arr(vec![point(150.0, 740.0, 1.0, 0.0), point(200.0, 800.0, 0.0, 1.0)])),
],
);
nodes.extend([box_at(64, "A", 0.0, 600.0), box_at(65, "B", 300.0, 800.0), saved]);
let (doc, warnings) = import(&canvas(&schema(), &message), "Saved path").unwrap();
let world = doc.world_transform(named(&doc, "Saved").id);
let line: Vec<_> =
network_of(&doc, "Saved").vertices.iter().map(|v| world * figcraft_doc::geom::Point::new(v.x, v.y)).map(|p| (p.x, p.y)).collect();
// Each end starts `END_GAP` (4) outside its side's border.
assert_eq!(line, [(50.0, 704.0), (50.0, 740.0), (200.0, 740.0), (200.0, 850.0), (296.0, 850.0)]);
// The fixture's own Link, saved without a path, is routed here: the note counts it alone.
let routed: Vec<_> = warnings.iter().filter(|w| w.contains("are routed afresh")).collect();
assert_eq!(routed.len(), 1, "{warnings:?}");
assert!(!routed[0].contains('×'), "a connector with its path isn't counted among those routed here: {routed:?}");
}
/// Saved control points that don't make a path from the connector's sides (#1910): a first run
/// that would leave the bottom sideways, a point off both axes, or two runs in a row the same way
/// leave the connector to FigCraft's routing, as one saved without a path is.
#[test]
fn an_elbow_whose_saved_path_doesnt_fit_its_sides_is_routed_here() {
let mut message = tail_message();
let Kv::Array(nodes) = field_mut(&mut message, "nodeChanges").unwrap() else { panic!() };
let box_at = |id, name: &str, x, y| node(id, Some((1, "*")), "RECTANGLE", name, vec![("size", xy(100.0, 100.0)), ("transform", at(x, y))]);
let point = |x, y, ax, ay| o(vec![("position", xy(x, y)), ("axis", xy(ax, ay))]);
let elbow = |id, name: &str, points: Vec<Kv<'static>>| {
let mut fields = vec![
("strokePaints", arr(vec![solid(0.0, 0.0, 0.0)])),
("connectorStart", o(vec![("endpointNodeID", g(64)), ("relativePosition", xy(0.5, 1.0))])),
("connectorEnd", o(vec![("endpointNodeID", g(65)), ("relativePosition", xy(0.0, 0.5))])),
("connectorLineStyle", e("ELBOWED")),
];
if !points.is_empty() {
fields.push(("connectorControlPoints", arr(points)));
}
node(id, Some((1, "+")), "CONNECTOR", name, fields)
};
nodes.extend([
box_at(64, "A", 0.0, 600.0),
box_at(65, "B", 300.0, 800.0),
elbow(66, "Plain", vec![]),
elbow(67, "Sideways", vec![point(100.0, 650.0, 0.0, 1.0)]),
elbow(68, "Askew", vec![point(150.0, 740.0, 1.0, 1.0)]),
elbow(69, "Repeated", vec![point(150.0, 740.0, 1.0, 0.0), point(150.0, 760.0, 1.0, 0.0)]),
// The first run would go up from A's bottom, through A; the last would arrive at B's left
// from inside B. Each run is at right angles to its side, so only the way it goes is wrong.
elbow(70, "Backwards", vec![point(100.0, 650.0, 1.0, 0.0), point(200.0, 740.0, 0.0, 1.0)]),
elbow(71, "Inside", vec![point(150.0, 740.0, 1.0, 0.0), point(350.0, 800.0, 0.0, 1.0)]),
]);
let (doc, warnings) = import(&canvas(&schema(), &message), "Unfit paths").unwrap();
let line = |name: &str| -> Vec<(f64, f64)> {
let world = doc.world_transform(named(&doc, name).id);
network_of(&doc, name).vertices.iter().map(|v| world * figcraft_doc::geom::Point::new(v.x, v.y)).map(|p| (p.x, p.y)).collect()
};
let plain = line("Plain");
assert!(plain.len() >= 3, "routed in right angles: {plain:?}");
for name in ["Sideways", "Askew", "Repeated", "Backwards", "Inside"] {
assert_eq!(line(name), plain, "{name} is routed as one without a path");
}
assert!(warnings.iter().any(|w| w.contains("are routed afresh")), "{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.