GitCorner

Code

ossartcraftvectorcraft🌐
2bc41aeb8602
use super::*;

#[test]
fn hidden_attributes_show_again() {
    let mut a = Appearance::default_art();
    assert!(!a.has_hidden() && !a.show_all());
    a.stroke_mut().unwrap().visible = false;
    a.items[0].effects_mut().push(Effect { id: "distort.roughen".into(), params: serde_json::Value::Null, visible: false });
    assert!(a.has_hidden());
    assert!(a.show_all());
    assert!(!a.has_hidden() && a.items.iter().all(AppearanceItem::visible) && a.items[0].effects()[0].visible);
}

#[test]
fn basic_appearance() {
    let a = Appearance::default_art();
    assert!(a.is_basic());
    assert_eq!(a.fill_paint(), Paint::solid(Color::WHITE));
    assert_eq!(a.stroke_width(), 1.0);
}

#[test]
fn rebase_moves_fills_by_the_box_and_strokes_by_their_inflated_box() {
    use vectorcraft_color::{Gradient, GradientGeom, GradientPaint};
    use vectorcraft_geom::{Point, Rect};
    let placed = |x: f64| {
        let mut g = GradientPaint::new(Gradient::default());
        g.geom = Some(GradientGeom { start: Point::new(x, 0.0), end: Point::new(x + 10.0, 0.0), aspect: 1.0, focal: None });
        Paint::Gradient(Box::new(g))
    };
    let mut a = Appearance::basic(placed(0.0), placed(-5.0), 10.0);
    a.rebase_gradients(Rect::new(0.0, 0.0, 100.0, 100.0), Rect::new(100.0, 0.0, 300.0, 100.0));
    let start = |p: Paint| match p {
        Paint::Gradient(g) => g.geom.unwrap().start,
        _ => panic!("a gradient"),
    };
    // The fill's start stays on the left edge; the stroke's on its inflated box's (−5 → 95).
    assert_eq!((start(a.fill_paint()), start(a.stroke_paint())), (Point::new(100.0, 0.0), Point::new(95.0, 0.0)));
}

#[test]
fn items_by_index() {
    let mut a = Appearance::default_art();
    a.items.push(AppearanceItem::Fill(FillLayer::new(Paint::None)));
    // [Fill white, Stroke black, Fill none]
    assert_eq!(a.fill_at(None).unwrap().paint, Paint::None);
    assert_eq!(a.fill_at(Some(0)).unwrap().paint, Paint::solid(Color::WHITE));
    assert!(a.fill_at(Some(1)).is_none() && a.stroke_at(Some(0)).is_none() && a.fill_at(Some(9)).is_none());
    assert_eq!(a.item_of_kind(Some(1), false), Some(1));
    assert_eq!(a.item_of_kind(Some(1), true), None);
    assert_eq!(a.fill_for(Some(1)).unwrap().paint, Paint::None);
    assert!(a.set_fill_at(Some(0), Paint::solid(Color::BLACK)));
    assert!(!a.set_stroke_at(Some(0), Paint::None));
    assert_eq!(a.fill_at(Some(0)).unwrap().paint, Paint::solid(Color::BLACK));
    a.effects_mut(Some(1)).unwrap().push(Effect { id: "distort.roughen".into(), params: serde_json::Value::Null, visible: true });
    assert_eq!(a.effects_at(Some(1)).unwrap().len(), 1);
    assert!(a.effects_at(None).unwrap().is_empty() && a.effects_mut(Some(3)).is_none());
    assert_eq!((a.items[1].kind_name(), a.items[2].kind_name()), ("stroke", "fill"));
}

#[test]
fn basic_means_one_plain_fill_and_stroke() {
    let stroke = || AppearanceItem::Stroke(StrokeLayer::new(Paint::solid(Color::BLACK), 1.0));
    let mut a = Appearance { items: vec![stroke(), stroke()], ..Appearance::default() };
    assert!(!a.is_basic(), "two strokes");
    a.items.pop();
    assert!(a.is_basic() && Appearance::default().is_basic());
    let mut b = Appearance::default_art();
    b.stroke_mut().unwrap().visible = false;
    assert!(!b.is_basic(), "a hidden stroke");
    let mut c = Appearance::default_art();
    c.fill_mut().unwrap().opacity = 0.5;
    assert!(!c.is_basic(), "fill opacity");
    let mut d = Appearance::default_art();
    d.items.push(AppearanceItem::Fill(FillLayer::new(Paint::None)));
    assert!(!d.is_basic(), "two fills");
    let mut e = Appearance::default_art();
    e.effects.push(Effect { id: "distort.roughen".into(), params: serde_json::Value::Null, visible: true });
    assert!(!e.is_basic(), "an effect");
}

#[test]
fn drawn_fills_and_strokes_count_every_row() {
    let fill = |p: Paint| AppearanceItem::Fill(FillLayer::new(p));
    let stroke = |p: Paint, w: f64| AppearanceItem::Stroke(StrokeLayer::new(p, w));
    let black = || Paint::solid(Color::BLACK);
    assert!(!Appearance::default().has_drawn_fill() && !Appearance::default().has_drawn_stroke());
    // A painted lower row draws under an unpainted top row.
    let a = Appearance { items: vec![fill(black()), stroke(black(), 2.0), fill(Paint::None), stroke(Paint::None, 1.0)], ..Appearance::default() };
    assert!(a.has_drawn_fill() && a.has_drawn_stroke());
    // A hidden painted row, a zero opacity or a zero weight draws nothing.
    let mut b = Appearance { items: vec![fill(black()), stroke(black(), 2.0)], ..Appearance::default() };
    b.fill_mut().unwrap().visible = false;
    b.stroke_mut().unwrap().visible = false;
    assert!(!b.has_drawn_fill() && !b.has_drawn_stroke());
    let mut c = Appearance::default_art();
    c.fill_mut().unwrap().opacity = 0.0;
    c.stroke_mut().unwrap().opacity = 0.0;
    assert!(!c.has_drawn_fill() && !c.has_drawn_stroke());
    let d = Appearance::basic(Paint::None, black(), 0.0);
    assert!(!d.has_drawn_fill() && !d.has_drawn_stroke());
}

#[test]
fn set_creates_missing() {
    let mut a = Appearance::default();
    a.set_fill(Paint::solid(Color::BLACK));
    a.set_stroke(Paint::solid(Color::WHITE));
    assert_eq!(a.items.len(), 2);
    assert!(matches!(a.items[0], AppearanceItem::Fill(_)));
}

/// #852: pen pressure is kept simplified along the stroke and read back by position.
#[test]
fn pressure_profile_samples_simplify_and_interpolate() {
    // A steady ramp keeps only its ends; a bump keeps its peak.
    let ramp = PressureProfile::from_samples((0..=100).map(|i| (i as f64 / 100.0, i as f64 / 100.0))).unwrap();
    assert_eq!(ramp.points, vec![(0.0, 0.0), (1.0, 1.0)]);
    assert!((ramp.at(0.25) - 0.25).abs() < 1e-9);
    let bump = PressureProfile::from_samples([(0.0, 0.2), (0.3, 0.2), (0.5, 0.9), (0.7, 0.2), (1.0, 0.2)]).unwrap();
    assert!(bump.points.contains(&(0.5, 0.9)) && (bump.at(0.4) - 0.55).abs() < 1e-9, "{bump:?}");
    // Junk is clamped or dropped; positions never go back; nothing at all is no profile.
    let junk = PressureProfile::from_samples([(f64::NAN, 0.5), (0.5, 7.0), (0.2, -1.0), (2.0, f64::INFINITY)]).unwrap();
    assert_eq!(junk.points, vec![(0.5, 1.0), (0.5, 0.0)]);
    assert!(PressureProfile::from_samples([(f64::NAN, 0.5)]).is_none());
    assert_eq!(PressureProfile::default().at(0.3), PressureProfile::MID);
    // A long noisy stroke stays bounded.
    let noisy = PressureProfile::from_samples((0..1_000_000).map(|i| (i as f64 / 1e6, (i % 2) as f64))).unwrap();
    assert!(noisy.points.len() <= PressureProfile::MAX_POINTS);
    // Out-of-order points (a hand-edited file) still read within 0..1.
    let odd = PressureProfile { points: vec![(1.0, 5.0), (0.0, -3.0)] };
    assert!((0.0..=1.0).contains(&odd.at(0.5)));
}

#[test]
fn pressure_profile_extends_and_reverses() {
    let old = PressureProfile { points: vec![(0.0, 0.0), (1.0, 1.0)] };
    let added = PressureProfile { points: vec![(0.0, 1.0), (1.0, 0.0)] };
    // A 30 pt path continued by 10 pt: its ramp fills the first three quarters.
    let joined = PressureProfile::extended(Some(&old), 30.0, Some(&added), 10.0).unwrap();
    assert!((joined.at(0.75) - 1.0).abs() < 1e-9 && (joined.at(0.375) - 0.5).abs() < 1e-9 && joined.at(1.0) == 0.0, "{joined:?}");
    // A side without pressure is half way.
    let half = PressureProfile::extended(None, 10.0, Some(&added), 10.0).unwrap();
    assert_eq!(half.at(0.25), PressureProfile::MID);
    assert!(PressureProfile::extended(None, 10.0, None, 10.0).is_none());
    assert_eq!(PressureProfile::extended(Some(&old), 0.0, None, f64::NAN), Some(old.clone()));
    assert_eq!(old.reversed().points, vec![(0.0, 1.0), (1.0, 0.0)]);
}

/// #764: a pen's bearing or barrel rotation is kept the shorter way round between samples, so
/// 170° then −170° turns through 180°, not through 0°.
#[test]
fn angle_profiles_join_samples_the_shorter_way_round() {
    let across = AngleProfile::from_samples([(0.0, 170.0), (1.0, -170.0)]).unwrap();
    assert_eq!(across.points, vec![(0.0, 170.0), (1.0, 190.0)]);
    assert_eq!(across.at(0.5), 180.0);
    assert!((across.at(0.75) + 175.0).abs() < 1e-9, "{}", across.at(0.75));
    // Turns past a whole turn keep counting, and read back within −180..180°.
    let spin = AngleProfile::from_samples((0..=40).map(|i| (f64::from(i) / 40.0, f64::from(i * 30) - 180.0))).unwrap();
    assert!((spin.points.last().unwrap().1 - 1380.0).abs() < 1e-9, "{spin:?}");
    assert!((spin.at(1.0) + 60.0).abs() < 1e-9 && spin.points.len() == 2, "{spin:?}");
    // Junk is dropped; nothing at all is no profile, and no profile reads 0°.
    let junk = AngleProfile::from_samples([(f64::NAN, 5.0), (0.5, f64::INFINITY), (0.2, 400.0)]).unwrap();
    assert_eq!(junk.points, vec![(0.2, 40.0)]);
    assert!(AngleProfile::from_samples([(0.5, f64::NAN)]).is_none());
    assert_eq!(AngleProfile::default().at(0.3), 0.0);
    let noisy = AngleProfile::from_samples((0..1_000_000).map(|i| (f64::from(i) / 1e6, f64::from(i % 2) * 90.0))).unwrap();
    assert!(noisy.points.len() <= PressureProfile::MAX_POINTS);
    // Continued: the old part, then the new one; a side without an angle is 0°. Reversed, the
    // angles stay what they were.
    let old = AngleProfile { points: vec![(0.0, 90.0), (1.0, 90.0)] };
    let joined = AngleProfile::extended(Some(&old), 30.0, None, 10.0).unwrap();
    assert!((joined.at(0.5) - 90.0).abs() < 1e-9 && joined.at(1.0) == 0.0, "{joined:?}");
    assert!(AngleProfile::extended(None, 10.0, None, 10.0).is_none());
    assert_eq!(AngleProfile::extended(Some(&old), 0.0, None, 0.0), Some(old.clone()));
    assert_eq!(across.reversed().points, vec![(0.0, 190.0), (1.0, 170.0)]);
    // A part that turned more than half a turn between two of its samples keeps that turn when
    // the path is continued, and so does the new part.
    let quarter_turns = AngleProfile::from_samples([(0.0, 0.0), (1.0 / 3.0, 90.0), (2.0 / 3.0, 180.0), (1.0, 270.0)]).unwrap();
    assert_eq!(quarter_turns.points, vec![(0.0, 0.0), (1.0, 270.0)]);
    let added = AngleProfile { points: vec![(0.0, -80.0), (1.0, 280.0)] };
    let joined = AngleProfile::extended(Some(&quarter_turns), 10.0, Some(&added), 10.0).unwrap();
    assert!((joined.at(0.25) - 135.0).abs() < 1e-9, "{joined:?}");
    assert!((joined.at(0.75) - 100.0).abs() < 1e-9, "{joined:?}");
}

/// Strokes saved before pen pressure load as they were, and are written without it.
#[test]
fn strokes_without_pressure_round_trip_unchanged() {
    let json = serde_json::to_value(StrokeLayer::new(Paint::None, 2.0)).unwrap();
    for key in ["pressure", "tilt", "bearing", "rotation", "wheel"] {
        assert!(json.get(key).is_none(), "{key}");
    }
    let st: StrokeLayer = serde_json::from_value(json).unwrap();
    assert_eq!(st.pressure, None);
    let pressed = StrokeLayer { pressure: Some(PressureProfile::sample()), ..st };
    let back: StrokeLayer = serde_json::from_value(serde_json::to_value(&pressed).unwrap()).unwrap();
    assert_eq!(back, pressed);
    let mut ap = Appearance::basic(Paint::None, Paint::None, 1.0);
    ap.stroke_mut().unwrap().pressure = Some(PressureProfile::sample());
    assert_eq!(ap.without_pressure().stroke().unwrap().pressure, None);
    // The pen's tilt, bearing, rotation and wheel load, save and stay behind the same way.
    let posed = StrokeLayer {
        tilt: Some(PressureProfile::sample()),
        bearing: Some(AngleProfile::sample()),
        rotation: Some(AngleProfile { points: vec![(0.0, -45.0)] }),
        wheel: Some(PressureProfile { points: vec![(0.0, 0.25), (1.0, 0.75)] }),
        ..back
    };
    assert_eq!(serde_json::to_value(&posed).unwrap()["wheel"], serde_json::json!({"points": [[0.0, 0.25], [1.0, 0.75]]}));
    let again: StrokeLayer = serde_json::from_value(serde_json::to_value(&posed).unwrap()).unwrap();
    assert_eq!(again, posed);
    let mut ap = Appearance::basic(Paint::None, Paint::None, 1.0);
    *ap.stroke_mut().unwrap() = posed;
    let st = ap.without_pressure().stroke().cloned().unwrap();
    assert_eq!((st.pressure, st.tilt, st.bearing, st.rotation, st.wheel), (None, None, None, None, None));
}

/// The Lens profile's widths at its middle, a quarter of the way along and past its end.
#[test]
fn profile_interp() {
    let p = WidthProfile::lens();
    assert_eq!(p.at(0.5), (1.0, 1.0));
    // The lens is a parabola between its ends, so a quarter of the way along is 0.75: above the
    // 0.5 a straight taper would give.
    assert_eq!(p.at(0.25), (0.75, 0.75));
    assert_eq!(p.at(2.0), (0.0, 0.0));
}

/// The width runs smoothly between points: it passes through them, has one slope either side
/// of one, and never overshoots the widths its points set.
#[test]
fn profile_is_smooth_between_points() {
    let p = [(0.0, 1.0, 2.0), (0.5, 0.2, 2.0), (1.0, 1.0, 2.0)];
    assert!((WidthProfile::at_points(&p, 0.5).0 - 0.2).abs() < 1e-12);
    let slope = |t: f64| (WidthProfile::at_points(&p, t + 1e-6).0 - WidthProfile::at_points(&p, t - 1e-6).0) / 2e-6;
    // A local minimum at the middle point is flat there, so the two sides agree.
    assert!(slope(0.5).abs() < 1e-3, "{}", slope(0.5));
    for k in 0..=100 {
        let w = WidthProfile::at_points(&p, k as f64 / 100.0).0;
        assert!((0.2..=1.0).contains(&w), "{w} at {k}");
    }
    // The side with no points of its own stays flat.
    for k in 0..=100 {
        assert!((WidthProfile::at_points(&p, k as f64 / 100.0).1 - 2.0).abs() < 1e-12);
    }
}

/// A run with only two points takes its secant as both end slopes, so it stays a straight
/// taper on each side instead of becoming a smoothstep.
#[test]
fn profile_two_point_runs_are_linear() {
    let p = [(0.0, 0.0, 1.0), (1.0, 1.0, 0.0)];
    for k in 0..=100 {
        let t = k as f64 / 100.0;
        let (l, r) = WidthProfile::at_points(&p, t);
        assert!((l - t).abs() < 1e-12, "left {l} at {t}");
        assert!((r - (1.0 - t)).abs() < 1e-12, "right {r} at {t}");
    }
}

/// The lens's one-sided end slopes make it a parabola: at a quarter of the way it is 0.75,
/// above the 0.5 a straight line between its points would give.
#[test]
fn profile_lens_is_convex() {
    let p = WidthProfile::lens();
    assert!((p.at(0.25).0 - 0.75).abs() < 1e-12);
    assert!((p.at(0.75).0 - 0.75).abs() < 1e-12);
    for k in 1..25 {
        let t = k as f64 / 100.0;
        assert!(p.at(t).0 > 2.0 * t, "{} at {t}", p.at(t).0);
        assert!(p.at(1.0 - t).0 > 2.0 * t, "{} at {}", p.at(1.0 - t).0, 1.0 - t);
    }
}

/// A step still steps, and the smooth runs either side meet it flat.
#[test]
fn profile_steps_stay_steps() {
    let p = [(0.0, 1.0, 1.0), (0.5, 1.0, 1.0), (0.5, 2.0, 2.0), (1.0, 2.0, 2.0)];
    assert_eq!(WidthProfile::at_points(&p, 0.5), (1.0, 1.0));
    assert_eq!(WidthProfile::at_points(&p, 0.5 + 1e-6), (2.0, 2.0));
    assert_eq!(WidthProfile::at_points(&p, 0.5 - 1e-6), (1.0, 1.0));
    assert_eq!(WidthProfile::at_points(&p, 0.25), (1.0, 1.0));
    assert_eq!(WidthProfile::at_points(&p, 0.75), (2.0, 2.0));
}

/// Moving a point only reshapes the segments beside it (local influence), not the whole path.
#[test]
fn profile_points_only_affect_the_curve_around_them() {
    // A monotone run, so no neighbouring slope is held flat by a local extremum.
    let a = [(0.0, 0.0, 0.0), (0.25, 0.3, 0.3), (0.5, 0.5, 0.5), (0.75, 0.7, 0.7), (1.0, 1.0, 1.0)];
    let mut b = a;
    b[3] = (0.75, 0.9, 0.9);
    // Moving p[3] changes the slopes at p[2] and p[3], so p[1] and p[4] also shape the
    // curve: nothing before p[1] may move.
    for k in 0..=24 {
        let t = k as f64 / 100.0;
        assert_eq!(WidthProfile::at_points(&a, t), WidthProfile::at_points(&b, t), "at {t}");
    }
    assert_ne!(WidthProfile::at_points(&a, 0.3), WidthProfile::at_points(&b, 0.3));
}

#[test]
fn profile_presets_round_trip_their_ids() {
    for p in WidthProfile::PRESETS {
        let prof = WidthProfile::preset(p.id).unwrap();
        assert_eq!(prof.preset_id(), Some(p.id));
        assert_eq!(WidthProfile::id_of(Some(&prof)), p.id);
    }
    assert_eq!(WidthProfile::id_of(None), "uniform");
    assert_eq!(WidthProfile::id_of(Some(&WidthProfile { points: vec![(0.0, 0.3, 0.3)] })), "custom");
    assert!(WidthProfile::preset("nope").is_none());
    assert_eq!(WidthProfile::lens().points, vec![(0.0, 0.0, 0.0), (0.5, 1.0, 1.0), (1.0, 0.0, 0.0)]);
}

#[test]
fn arrowhead_names_are_stable_and_every_one_is_listed_once() {
    // Saved files store these names: they may only ever be appended to.
    const SAVED: [&str; 41] = [
        "Triangle",
        "TriangleOpen",
        "Circle",
        "CircleOpen",
        "Square",
        "SquareOpen",
        "Bar",
        "Diamond",
        "Arrow",
        "ArrowOpen",
        "Barbed",
        "HalfArrowLeft",
        "HalfArrowRight",
        "Concave",
        "DoubleBar",
        "Feather",
        "DotOnBar",
        "Chevron",
        "DoubleArrow",
        "Target",
        "Star",
        "Cross",
        "Plus",
        "Hexagon",
        "HexagonOpen",
        "Tag",
        "TagOpen",
        "HalfCircle",
        "Drop",
        "Slash",
        "DoubleSlash",
        "DiamondOpen",
        "TriangleReverse",
        "Swallowtail",
        "Bracket",
        "Fork",
        "Leaf",
        "Kite",
        "TriangleBar",
        "Oval",
        "LineArrow",
    ];
    for name in SAVED {
        let a: Arrowhead = serde_json::from_value(serde_json::json!(name)).unwrap();
        assert_eq!(serde_json::to_value(&a).unwrap(), name);
        assert_eq!(Arrowhead::ALL.iter().filter(|x| **x == a).count(), 1, "{name} in the menu once");
    }
    let labels: std::collections::HashSet<&str> = Arrowhead::ALL.iter().map(|a| a.label()).collect();
    assert_eq!(labels.len(), Arrowhead::ALL.len(), "labels are distinct");
}

/// A custom head: a triangle from its tip back 3 units, 2 units right and 1 left of its line.
fn custom_head() -> Arrowhead {
    use vectorcraft_geom::{PathData, Point, SubPath};
    let path = PathData::single(SubPath::polyline(&[Point::new(0.0, 0.0), Point::new(3.0, 2.0), Point::new(3.0, -1.0)], true));
    Arrowhead::Custom(std::sync::Arc::new(CustomArrowhead::new("Wedge".into(), path)))
}

#[test]
fn custom_arrowheads_carry_their_art_and_measure_it() {
    let head = custom_head();
    assert_eq!((head.name(), head.label()), ("Wedge", "Custom"));
    assert_eq!(head.reach(), 3.0f64.hypot(2.0));
    assert_eq!(head.half_width(), 2.0);
    let Arrowhead::Custom(c) = &head else { panic!("custom") };
    assert_eq!(c.stop(), 1.5, "the line stops halfway along the head");
    // Saved with the stroke, art and all, beside the built-in heads' names.
    let mut st = StrokeLayer::new(Paint::solid(Color::BLACK), 2.0);
    (st.start_arrow, st.end_arrow) = (Some(Arrowhead::Triangle), Some(head.clone()));
    let json = serde_json::to_value(&st).unwrap();
    assert_eq!(json["start_arrow"], "Triangle");
    assert_eq!(json["end_arrow"]["Custom"]["name"], "Wedge");
    let back: StrokeLayer = serde_json::from_value(json).unwrap();
    assert_eq!(back, st);
    // Extended, the tip sits the stop past the end point; on it, only the reach counts.
    assert_eq!(head.length(), 1.5 + head.reach());
    assert_eq!(st.head_reach(true), head.length() * 2.0 + 1.0);
    st.arrow_align = ArrowAlign::Tip;
    assert_eq!(st.head_reach(true), head.reach() * 2.0 + 1.0);
}

#[test]
fn custom_arrowheads_out_of_bounds_draw_nothing() {
    let Arrowhead::Custom(c) = custom_head() else { panic!("custom") };
    let mut path = c.path.clone();
    path.subpaths[0].anchors[1] = vectorcraft_geom::Anchor::corner(vectorcraft_geom::Point::new(1e9, 0.0));
    // A file can hold what `new` drops: reading it drops it too.
    let json = serde_json::to_value(CustomArrowhead { name: "Wedge".into(), path }).unwrap();
    let far: CustomArrowhead = serde_json::from_value(json).unwrap();
    assert_eq!((far.name.as_str(), far.path.subpaths.len()), ("Wedge", 0));
    assert_eq!((far.reach(), far.half_width(), far.stop()), (0.0, 0.0, 0.0));
    let anchors = vec![vectorcraft_geom::Anchor::corner(vectorcraft_geom::Point::new(1.0, 0.0)); CustomArrowhead::MAX_ANCHORS + 1];
    let many = CustomArrowhead::new("Many".into(), vectorcraft_geom::PathData::single(vectorcraft_geom::SubPath::new(anchors, true)));
    assert!(many.path.subpaths.is_empty(), "too many anchors");
    // Empty subpaths add no anchors, and still count.
    let mut hollow = c.path.clone();
    hollow.subpaths.extend(std::iter::repeat_n(vectorcraft_geom::SubPath::new(vec![], false), CustomArrowhead::MAX_ANCHORS));
    assert!(!CustomArrowhead::fits(&hollow), "too many subpaths");
    let json = serde_json::to_value(CustomArrowhead { name: "Hollow".into(), path: hollow }).unwrap();
    let hollow: CustomArrowhead = serde_json::from_value(json).unwrap();
    assert!(hollow.path.subpaths.is_empty(), "too many subpaths, read back");
}

#[test]
fn arrow_align_defaults_to_extend_and_round_trips() {
    let mut st = StrokeLayer::new(Paint::solid(Color::BLACK), 2.0);
    assert_eq!(st.arrow_align, ArrowAlign::Extend);
    // The default is not written, so older readers see the same JSON as before.
    assert!(!serde_json::to_string(&st).unwrap().contains("arrow_align"));
    let old: StrokeLayer = serde_json::from_str(r#"{"paint":{"type":"none"},"width":2.0}"#).unwrap();
    assert_eq!(old.arrow_align, ArrowAlign::Extend);
    st.arrow_align = ArrowAlign::Tip;
    let back: StrokeLayer = serde_json::from_str(&serde_json::to_string(&st).unwrap()).unwrap();
    assert_eq!(back, st);
}

#[test]
fn outset_covers_arrowheads() {
    let mut a = Appearance::basic(Paint::None, Paint::solid(Color::BLACK), 4.0);
    a.stroke_mut().unwrap().join = LineJoin::Round;
    assert_eq!(a.outset(), 2.0);
    let st = a.stroke_mut().unwrap();
    st.end_arrow = Some(Arrowhead::Triangle);
    st.arrow_scale = (100.0, 200.0);
    assert_eq!(st.arrow_weight(false), 4.0);
    assert_eq!(st.arrow_weight(true), 8.0);
    let reach = Arrowhead::Triangle.reach();
    assert_eq!((st.head_reach(false), st.head_reach(true)), (0.0, reach * 8.0 + 2.0));
    // A 32 pt head whose tip sits up to its length (plus the cap) past the end point.
    assert_eq!(a.outset(), reach * 8.0 + 2.0);
    // The line arrow's arms spread twice as wide, so it reaches further from its tip.
    a.stroke_mut().unwrap().end_arrow = Some(Arrowhead::LineArrow);
    assert!(Arrowhead::LineArrow.reach() > reach);
    assert_eq!(a.outset(), Arrowhead::LineArrow.reach() * 8.0 + 2.0);
    a.stroke_mut().unwrap().end_arrow = Some(Arrowhead::Triangle);
    a.stroke_mut().unwrap().width = 0.01;
    assert_eq!(a.stroke().unwrap().arrow_weight(true), 0.25, "heads keep a minimum size");
}

#[test]
fn outset_depends_on_align() {
    let mut a = Appearance::basic(Paint::None, Paint::solid(Color::BLACK), 10.0);
    a.stroke_mut().unwrap().join = LineJoin::Round;
    assert_eq!(a.outset(), 5.0);
    a.stroke_mut().unwrap().align = StrokeAlign::Outside;
    assert_eq!(a.outset(), 10.0);
    // Open paths stroke inside-aligned strokes centred.
    a.stroke_mut().unwrap().align = StrokeAlign::Inside;
    assert_eq!(a.outset(), 5.0);
    assert_eq!((a.stroke().unwrap().side_reach(true), a.stroke().unwrap().body(true)), (0.0, (10.0, Some(true))));
}

#[test]
fn outset_covers_miter_spikes_projecting_caps_and_profile_maxima() {
    let mut a = Appearance::basic(Paint::None, Paint::solid(Color::BLACK), 2.0);
    // Miter joins can spike out to the limit × half the weight.
    assert_eq!(a.outset(), 10.0);
    let st = a.stroke_mut().unwrap();
    st.join = LineJoin::Bevel;
    st.cap = LineCap::Square;
    assert!((a.outset() - std::f64::consts::SQRT_2).abs() < 1e-12, "a projecting cap's corner");
    let st = a.stroke_mut().unwrap();
    st.cap = LineCap::Round;
    st.profile = Some(WidthProfile { points: vec![(0.0, 0.5, 2.5), (1.0, 1.0, 1.0)] });
    assert_eq!(st.profile_max(), 2.5);
    assert_eq!(a.outset(), 2.5);
    a.stroke_mut().unwrap().paint = Paint::None;
    assert_eq!(a.outset(), 0.0, "an unpainted stroke");
}

#[test]
fn contents_slot_follows_item_edits_and_round_trips() {
    let fill = || AppearanceItem::Fill(FillLayer::new(Paint::None));
    let mut a = Appearance { items: vec![fill(), fill(), fill()], ..Appearance::default() };
    assert_eq!((a.contents_at(), a.split_contents().1.len()), (0, 3), "all items above by default");
    a.set_contents_at(1);
    assert!(!a.is_basic());
    // [0 | 1 2]: removing below shifts the slot, removing above doesn't.
    a.remove_item(2);
    assert_eq!(a.contents_at(), 1);
    a.remove_item(0);
    assert_eq!((a.contents_at(), a.contents_index), (0, None));
    // Inserting next to the slot joins the item below it.
    a.items.push(fill());
    a.set_contents_at(1); // [0 | 1]
    a.insert_item(1, fill());
    assert_eq!(a.contents_at(), 2);
    a.insert_item(3, fill()); // [0 1 | 2 3]
    assert_eq!(a.contents_at(), 2);
    // Moves keep their side when landing next to the slot, cross it otherwise.
    assert_eq!(a.move_item(3, 2), Some(2));
    assert_eq!(a.contents_at(), 2, "stays above");
    a.move_item(3, 0);
    assert_eq!(a.contents_at(), 3, "crossed below");
    a.move_item(0, 3);
    assert_eq!(a.contents_at(), 2, "crossed above");
    assert_eq!(a.move_item(9, 0), None);
    // Saved only when set; older files load with every item above.
    let json = serde_json::to_string(&a).unwrap();
    assert!(json.contains("\"contents_index\":2"));
    assert_eq!(serde_json::from_str::<Appearance>(&json).unwrap(), a);
    let old: Appearance = serde_json::from_str(r#"{"items":[]}"#).unwrap();
    assert_eq!(old.contents_index, None);
    assert!(!serde_json::to_string(&Appearance::default_art()).unwrap().contains("contents_index"));
}

/// The issue's case (#4174): two circles with different fills, the same stroke and the same
/// effect share the stroke and the effect, not the fills; a shared stroke at another place in one
/// stack maps to its own index there; nothing shared shares nothing; equal stacks share all.
#[test]
fn mixed_appearances_share_their_equal_rows() {
    let stroke = AppearanceItem::Stroke(StrokeLayer::new(Paint::solid(Color::rgb(0.0, 0.0, 1.0)), 11.0));
    let fill = |c: Color| AppearanceItem::Fill(FillLayer::new(Paint::solid(c)));
    let feather = Effect { id: "stylize.feather".into(), params: serde_json::json!({"radius": 5}), visible: true };
    let a = Appearance { items: vec![fill(Color::rgb(1.0, 1.0, 0.0)), stroke.clone()], effects: vec![feather.clone()], ..Appearance::default() };
    let b = Appearance { items: vec![fill(Color::rgb(1.0, 0.0, 0.0)), stroke.clone()], effects: vec![feather.clone()], ..Appearance::default() };
    let shared = SharedStack::of(&[&a, &b]);
    assert_eq!(shared.items, vec![vec![1, 1]], "the stroke, not the fills");
    assert_eq!(shared.effects, vec![vec![0, 0]]);
    // The stroke under an extra fill in the second object.
    let c =
        Appearance { items: vec![fill(Color::BLACK), fill(Color::WHITE), stroke.clone()], effects: vec![feather.clone()], ..Appearance::default() };
    let shared = SharedStack::of(&[&a, &c]);
    assert_eq!(shared.items, vec![vec![1, 2]]);
    assert_eq!(shared.item_in(1, 1), Some(2));
    assert_eq!(shared.item_in(0, 1), None);
    // Nothing alike.
    let d = Appearance { items: vec![fill(Color::WHITE)], ..Appearance::default() };
    let none = SharedStack::of(&[&a, &d]);
    assert!(none.items.is_empty() && none.effects.is_empty());
    // Equal stacks share everything, each row where it is.
    assert_eq!(SharedStack::of(&[&a, &a.clone(), &a.clone()]).items, vec![vec![0, 0, 0], vec![1, 1, 1]]);
}

/// Matches keep their stacking order: two equal rows in the opposite order match once.
#[test]
fn aligned_rows_never_cross() {
    assert_eq!(align(&[1, 2], &[2, 1], |a, b| a == b).iter().filter(|m| m.is_some()).count(), 1);
    assert_eq!(align(&[1, 2, 3], &[9, 1, 3], |a, b| a == b), vec![Some(1), None, Some(2)]);
    assert_eq!(align::<i32>(&[], &[1], |a, b| a == b), Vec::<Option<usize>>::new());
}