Skip to content

VectorCraft: An open-source, vector art tool written by scratch in pure Rust

refactor(tools): move draw2/curvature.rs tests to draw2/curvature/tests.rs

aiongg6dd257522b31
diff --git a/crates/tools/src/draw2/curvature.rs b/crates/tools/src/draw2/curvature.rs
index d81dc03e5..63d4d7e35 100644
--- a/crates/tools/src/draw2/curvature.rs
+++ b/crates/tools/src/draw2/curvature.rs
@@ -656,410 +656,4 @@ impl Tool for CurvatureTool {
}
#[cfg(test)]
-mod tests {
- use super::*;
- use crate::testutil::*;
- use vectorcraft_doc::{Appearance, Document, Node, Selection};
- use vectorcraft_geom::{ParamCurve, PathData};
-
- /// The Curvature tool has its own cursor, not the Pen's start-a-path one.
- #[test]
- fn curvature_tool_shows_its_cursor() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- assert_eq!(CurvatureTool::default().cursor(&cx, Point::new(10.0, 10.0), Mods::default()), Cursor::Curvature);
- }
-
- #[test]
- fn first_click_creates_then_notify_tracks_path() {
- let (d, id) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let mut t = CurvatureTool::default();
- let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 10.0, 10.0));
- assert!(matches!(&a[0], Action::Exec(c, v) if c == "path.curvature" && v.get("id").is_none() && v["points"].as_array().unwrap().len() == 1));
- assert_eq!(a[1], Action::Notify("created".into()));
- // Pretend the engine created `id` with one anchor: it is a rect (4 anchors) so it doesn't match.
- let mut s2 = Selection::default();
- s2.set([id]);
- let cx2 = crate::testutil::cx(&d, &s2, &p);
- t.notify(&cx2, "created");
- assert_eq!(t.id, Some(id));
- assert!(t.active(&cx2).is_none());
- // With four points it matches, so a click appends a fifth.
- t.pts = vec![(Point::new(100.0, 100.0), false); 4];
- let a = t.pointer(&cx2, &PointerEvent::new(PointerKind::Down, 400.0, 400.0));
- assert!(matches!(&a[0], Action::Exec(_, v) if v["id"] == id.0 && v["points"].as_array().unwrap().len() == 5));
- }
-
- /// Points snap to Smart Guides (#506): the first lands on another object's anchor and says so.
- #[test]
- fn points_snap_to_smart_guides() {
- let (d, _) = doc_with_rect();
- let s = Selection::default();
- let p = paint();
- let cx = cx(&d, &s, &p);
- let mut t = CurvatureTool::default();
- let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 202.0, 99.0));
- assert!(matches!(&a[0], Action::Exec(_, v) if v["points"][0]["x"] == 200.0 && v["points"][0]["y"] == 100.0), "{a:?}");
- assert!(t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Label { text, .. } if text == "anchor")));
- t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 202.0, 99.0));
- assert!(t.overlays(&cx).is_empty());
- }
-
- fn pt(x: f64, y: f64) -> Point {
- Point::new(x, y)
- }
-
- /// An open pen-style path: a corner start, two smooth anchors with uneven handles, a cusp and
- /// an end with only an incoming handle.
- fn wave() -> SubPath {
- SubPath::new(
- vec![
- Anchor::corner(pt(0.0, 100.0)),
- Anchor::with_handles(pt(100.0, 0.0), pt(60.0, 10.0), pt(160.0, -15.0)),
- Anchor::with_handles(pt(250.0, 80.0), pt(220.0, 30.0), pt(280.0, 130.0)),
- Anchor::with_handles(pt(350.0, 150.0), pt(320.0, 160.0), pt(380.0, 100.0)),
- Anchor::with_handles(pt(450.0, 60.0), pt(420.0, 90.0), pt(450.0, 60.0)),
- ],
- false,
- )
- }
-
- /// Every point of `a` lies on `b` (within 1e-6), sampled.
- fn lies_on(a: &SubPath, b: &SubPath) -> bool {
- let b = PathData::single(b.clone());
- (0..a.segment_count()).all(|i| (0..=20).all(|k| b.nearest(a.segment(i).eval(k as f64 / 20.0)).is_some_and(|n| n.4 < 1e-6)))
- }
-
- fn collinear(a: Vec2, b: Vec2) -> bool {
- a.cross(b).abs() < 1e-6 * a.hypot().max(1.0) * b.hypot().max(1.0)
- }
-
- #[test]
- fn moving_a_point_recurves_only_its_two_segments() {
- let before = wave();
- let mut sp = before.clone();
- assert_eq!(sp.anchors[2].kind, AnchorKind::Smooth);
- assert!(curvature_move(&mut sp, 2, pt(260.0, 140.0)));
- assert_eq!(sp.anchors[2].p, pt(260.0, 140.0));
- // The segments beyond its neighbours are bit-identical.
- assert_eq!(sp.segment(0), before.segment(0));
- assert_eq!(sp.segment(3), before.segment(3));
- // The neighbours keep their handle directions on its segments, and their other handles.
- assert!(collinear(sp.anchors[1].h_out - sp.anchors[1].p, before.anchors[1].h_out - before.anchors[1].p));
- assert!(collinear(sp.anchors[3].h_in - sp.anchors[3].p, before.anchors[3].h_in - before.anchors[3].p));
- assert_eq!((sp.anchors[1].h_in, sp.anchors[3].h_out), (before.anchors[1].h_in, before.anchors[3].h_out));
- // The moved smooth point takes the Curvature tool's handles, along the circle through it
- // and its neighbours, whatever the spacing: between a third and two thirds of its chord.
- let a = sp.anchors[2];
- let (prev, next) = (sp.anchors[1].p, sp.anchors[3].p);
- assert_eq!(a.kind, AnchorKind::Smooth);
- assert_eq!(Some((a.h_in, a.h_out)), smooth_handles(prev, a.p, next));
- assert!(collinear(a.h_in - a.p, a.h_out - a.p) && (a.h_in - a.p).dot(a.h_out - a.p) < 0.0);
- for (h, to) in [(a.h_in, prev), (a.h_out, next)] {
- let r = a.p.distance(h) / a.p.distance(to);
- assert!((1.0 / 3.0 - 1e-9..=2.0 / 3.0 + 1e-9).contains(&r), "{r}");
- }
- // A cusp keeps its handle directions; a moved end changes its one segment only.
- assert_eq!(sp.anchors[3].kind, AnchorKind::Corner);
- assert!(curvature_move(&mut sp, 3, pt(360.0, 170.0)));
- assert!(collinear(sp.anchors[3].h_out - sp.anchors[3].p, before.anchors[3].h_out - before.anchors[3].p));
- let mut end = before.clone();
- assert!(curvature_move(&mut end, 4, pt(470.0, 20.0)));
- assert_eq!(end.segment(2), before.segment(2));
- assert!(!curvature_move(&mut end, 5, pt(0.0, 0.0)));
- }
-
- /// A smooth end of an open path has one segment: its one handle into the curve, mirroring the
- /// neighbour's tangent in their chord, and nothing on the outer side.
- #[test]
- fn moving_a_smooth_end_gives_it_the_end_handle() {
- let mut sp = curvature_spline(&[(pt(0.0, 0.0), false), (pt(100.0, 60.0), false), (pt(200.0, 0.0), false), (pt(300.0, 50.0), false)], false);
- sp.anchors[0].kind = AnchorKind::Smooth;
- let before = sp.clone();
- assert!(curvature_move(&mut sp, 0, pt(-20.0, 30.0)));
- let (e, b) = (sp.anchors[0], sp.anchors[1]);
- assert!(!e.has_in() && e.has_out());
- assert_eq!(Some(e.h_out), end_handle(e.p, &b, true));
- assert_eq!(sp.segment(2), before.segment(2));
- assert_eq!(sp.anchors[2], before.anchors[2]);
- }
-
- #[test]
- fn moving_a_corner_without_handles_keeps_its_sides_straight() {
- let (d, id) = doc_with_rect();
- let mut sp = d.node(id).unwrap().path_data().unwrap().subpaths[0].clone();
- assert!(curvature_move(&mut sp, 0, pt(80.0, 70.0)));
- assert!((0..sp.segment_count()).all(|i| sp.segment_is_line(i)));
- assert_eq!(sp.anchors[0], Anchor::corner(pt(80.0, 70.0)));
- }
-
- #[test]
- fn going_on_from_an_end_keeps_the_old_segments() {
- let before = wave();
- let mut sp = before.clone();
- curvature_extend(&mut sp, false, pt(550.0, 120.0), EndCurve::Keep, false);
- assert_eq!(sp.anchors.len(), 6);
- assert!((0..4).all(|i| sp.segment(i) == before.segment(i)));
- // The old end turns smooth, going on along its incoming handle, a third of the chord out.
- let e = sp.anchors[4];
- assert_eq!(e.kind, AnchorKind::Smooth);
- assert!(collinear(e.h_out - e.p, e.p - e.h_in) && (e.h_out - e.p).dot(e.p - e.h_in) > 0.0);
- assert!((e.h_out.distance(e.p) - e.p.distance(pt(550.0, 120.0)) / 3.0).abs() < 1e-9);
- // The new end has no outer handle and one into the curve, mirroring the old end's tangent.
- let n = sp.anchors[5];
- assert_eq!((n.p, n.has_out(), n.kind), (pt(550.0, 120.0), false, AnchorKind::Corner));
- assert_eq!(Some(n.h_in), end_handle(n.p, &e, false));
- // The point placed then curves through its neighbours as a drawn path's points do.
- curvature_extend(&mut sp, false, pt(650.0, 60.0), EndCurve::Smooth, false);
- let drawn = curvature_spline(&[(pt(450.0, 60.0), false), (pt(550.0, 120.0), false), (pt(650.0, 60.0), false)], false);
- assert_eq!((sp.anchors[5].h_in, sp.anchors[5].h_out), (drawn.anchors[1].h_in, drawn.anchors[1].h_out));
- assert!((0..4).all(|i| sp.segment(i) == before.segment(i)));
- // A corner stays one.
- curvature_extend(&mut sp, false, pt(700.0, 100.0), EndCurve::Corner, false);
- assert!(!sp.anchors[6].has_in() && !sp.anchors[6].has_out());
- // From the start: the old segments come one later, and the new end is the first anchor.
- let mut sp = before.clone();
- curvature_extend(&mut sp, true, pt(-100.0, 50.0), EndCurve::Keep, false);
- assert!(sp.anchors[0].p == pt(-100.0, 50.0) && !sp.anchors[0].has_in() && sp.anchors[0].has_out());
- assert!((0..4).all(|i| sp.segment(i + 1) == before.segment(i)));
- // A corner end without handles goes on along its segment's tangent.
- let old = sp.anchors[1];
- assert!(old.has_in() && !old.has_out());
- assert!(collinear(old.h_in - old.p, old.p - before.anchors[1].h_in) && (old.h_in - old.p).dot(old.p - before.anchors[1].h_in) > 0.0);
- }
-
- #[test]
- fn closing_keeps_the_old_segments() {
- let before = wave();
- let mut sp = before.clone();
- curvature_close(&mut sp, false, EndCurve::Keep);
- assert!(sp.closed && sp.anchors.len() == 5);
- assert!((0..4).all(|i| sp.segment(i) == before.segment(i)));
- // The first anchor gains an incoming handle along its tangent: no kink there.
- let f = sp.anchors[0];
- assert!(f.has_in() && collinear(f.p - f.h_in, before.anchors[1].h_in - f.p));
- }
-
- #[test]
- fn inserting_a_point_keeps_the_shape() {
- let before = wave();
- let mut sp = before.clone();
- assert_eq!(curvature_insert(&mut sp, 1, 0.3), Some(2));
- assert_eq!(sp.anchors.len(), 6);
- assert_eq!(sp.anchors[2].kind, AnchorKind::Smooth);
- assert!(lies_on(&sp, &before) && lies_on(&before, &sp));
- // On a straight side the point is smooth too, its handles along the side.
- let (d, id) = doc_with_rect();
- let rect = d.node(id).unwrap().path_data().unwrap().subpaths[0].clone();
- let mut sp = rect.clone();
- let i = curvature_insert(&mut sp, 0, 0.5).unwrap();
- assert_eq!(sp.anchors[i].kind, AnchorKind::Smooth);
- assert!(sp.anchors[i].has_in() && sp.anchors[i].has_out());
- assert!(lies_on(&sp, &rect) && lies_on(&rect, &sp));
- assert_eq!(curvature_insert(&mut sp, 99, 0.5), None);
- }
-
- /// On a straight side the inserted point's handles lie along it, each a third of its own part
- /// of the side; a drag then moves it as a smooth Curvature point.
- #[test]
- fn a_point_inserted_on_a_line_takes_the_chord_rule_and_drags_smooth() {
- let (d, id) = doc_with_rect();
- let rect = d.node(id).unwrap().path_data().unwrap().subpaths[0].clone();
- let mut sp = rect.clone();
- let i = curvature_insert(&mut sp, 0, 0.25).unwrap();
- let (a, prev, next) = (sp.anchors[i], sp.anchors[i - 1].p, sp.anchors[i + 1].p);
- assert!((a.p.distance(a.h_in) - a.p.distance(prev) / 3.0).abs() < 1e-9);
- assert!((a.p.distance(a.h_out) - a.p.distance(next) / 3.0).abs() < 1e-9);
- assert!(collinear(a.h_out - a.p, next - prev) && (a.h_out - a.p).dot(next - prev) > 0.0);
- assert!(sp.segment_is_line(0) || lies_on(&sp, &rect));
- // A drag bends it as a smooth point; the sides beyond stay straight.
- let q = pt(a.p.x, a.p.y - 40.0);
- assert!(curvature_move(&mut sp, i, q));
- let m = sp.anchors[i];
- assert_eq!(Some((m.h_in, m.h_out)), smooth_handles(prev, q, next));
- assert!((2..sp.segment_count()).all(|s| sp.segment_is_line(s)));
- }
-
- #[test]
- fn curvature_smooth_uses_the_tool_rule() {
- let mut sp = curvature_spline(&[(pt(0.0, 0.0), true), (pt(100.0, 60.0), true), (pt(200.0, 0.0), false), (pt(300.0, 50.0), false)], false);
- // A corner in the middle takes the bisector handles.
- assert!(curvature_smooth(&mut sp, 1));
- let a = sp.anchors[1];
- assert_eq!((a.kind, Some((a.h_in, a.h_out))), (AnchorKind::Smooth, smooth_handles(pt(0.0, 0.0), a.p, pt(200.0, 0.0))));
- // An end curves into its segment, mirroring its neighbour's tangent.
- assert!(curvature_smooth(&mut sp, 0));
- let e = sp.anchors[0];
- assert!(!e.has_in() && Some(e.h_out) == end_handle(e.p, &sp.anchors[1], true));
- // No direction: a fold, or an end whose neighbour has no handle there, stays as it is.
- let mut fold = SubPath::new(vec![Anchor::corner(pt(0.0, 0.0)), Anchor::corner(pt(100.0, 0.0)), Anchor::corner(pt(0.0, 0.0))], false);
- let before = fold.clone();
- assert!(!curvature_smooth(&mut fold, 1) && !curvature_smooth(&mut fold, 0) && !curvature_smooth(&mut fold, 9));
- assert_eq!(fold, before);
- }
-
- /// A curved end counts as smooth for the toggle: Alt-click turns it into a corner.
- #[test]
- fn alt_click_on_a_curved_end_makes_it_a_corner() {
- let sp = curvature_spline(&[(pt(100.0, 300.0), false), (pt(200.0, 200.0), false), (pt(300.0, 300.0), false)], false);
- let (d, id) = doc_with(sp);
- let (s, p) = (selected(id, None), paint());
- let cx = quiet(&d, &s, &p);
- let a = press(&mut CurvatureTool::default(), &cx, 100.0, 300.0, true);
- assert!(a.iter().any(|a| matches!(a, Action::Exec(c, v) if c == "path.convertAnchor" && v["anchor"] == 0 && v["to"] == "corner")), "{a:?}");
- }
-
- /// A document with one path, `sp`.
- fn doc_with(sp: SubPath) -> (Document, NodeId) {
- let mut d = Document::new(800.0, 600.0);
- let l = d.layers[0].id;
- let id = d.alloc_id();
- d.insert(Some(l), 0, Node::path(id, PathData::single(sp), Appearance::default_art())).unwrap();
- (d, id)
- }
-
- /// Path `id` selected, anchor `current` of its first subpath direct-selected (or none).
- fn selected(id: NodeId, current: Option<usize>) -> Selection {
- let mut s = Selection::default();
- s.set([id]);
- if let Some(ai) = current {
- s.anchors.insert(id, [(0, ai)].into());
- }
- s
- }
-
- /// A context without snapping.
- fn quiet<'a>(d: &'a Document, s: &'a Selection, p: &'a crate::PaintDefaults) -> ToolContext<'a> {
- ToolContext { smart_guides: false, snap_to_point: false, ..cx(d, s, p) }
- }
-
- fn press(t: &mut CurvatureTool, cx: &ToolContext, x: f64, y: f64, alt: bool) -> Vec<Action> {
- let ev = PointerEvent::new(PointerKind::Down, x, y).with_mods(Mods { alt, ..Mods::default() });
- let mut a = t.pointer(cx, &ev);
- a.extend(t.pointer(cx, &PointerEvent::new(PointerKind::Up, x, y)));
- a
- }
-
- /// The op and params of a `path.curvatureEdit` action.
- fn edit_op(a: &Action) -> Option<(&str, &Value)> {
- match a {
- Action::Exec(c, v) | Action::Preview(c, v) if c == EDIT => Some((v["op"].as_str()?, v)),
- _ => None,
- }
- }
-
- #[test]
- fn a_press_on_a_point_selects_it_and_a_drag_moves_it() {
- let (d, id) = doc_with(wave());
- let (s, p) = (selected(id, None), paint());
- let cx = quiet(&d, &s, &p);
- let mut t = CurvatureTool::default();
- assert_eq!(t.cursor(&cx, pt(250.0, 81.0), Mods::default()), Cursor::Move);
- assert_eq!(t.cursor(&cx, pt(450.0, 61.0), Mods::default()), Cursor::PenContinue);
- let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 251.0, 81.0));
- assert_eq!(a, vec![Action::Exec("select.anchors".into(), json!({"id": id.0, "anchors": [[0, 2]], "mode": "set"}))]);
- let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 260.0, 140.0));
- assert_eq!(a[0], Action::Begin("Curvature".into()));
- let moved = edit_op(&a[1]).map(|(op, v)| (op, v["anchor"].clone(), v["x"].clone(), v["y"].clone()));
- assert_eq!(moved, Some(("move", json!(2), json!(260.0), json!(140.0))));
- assert!(t.busy());
- assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 260.0, 140.0)), vec![Action::Commit]);
- // A press without a drag only selects.
- assert_eq!(press(&mut t, &cx, 100.0, 0.0, false).len(), 1);
- }
-
- /// #2120: the dragged end of a slanted straight path keeps to its extension (Smart Guides).
- #[test]
- fn a_dragged_end_of_a_straight_path_keeps_to_its_extension() {
- let (d, id) = doc_with(SubPath::polyline(&[pt(300.0, 400.0), pt(380.0, 340.0)], false));
- let (s, p) = (selected(id, None), paint());
- let cx = cx(&d, &s, &p);
- let mut t = CurvatureTool::default();
- t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 380.0, 340.0));
- let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 421.5, 312.0));
- let moved = a.get(1).and_then(edit_op).map(|(op, v)| (op, v["x"].as_f64().unwrap(), v["y"].as_f64().unwrap()));
- assert!(matches!(moved, Some(("move", x, y)) if (x - 420.0).abs() < 1e-9 && (y - 310.0).abs() < 1e-9), "{a:?}");
- }
-
- #[test]
- fn alt_click_or_double_click_toggles_and_delete_removes() {
- let (d, id) = doc_with(wave());
- let p = paint();
- let s = selected(id, None);
- let cx = quiet(&d, &s, &p);
- let mut t = CurvatureTool::default();
- let to = |a: &[Action]| a.iter().find(|a| matches!(a, Action::Exec(c, _) if c == "path.convertAnchor")).cloned();
- let a = press(&mut t, &cx, 100.0, 0.0, true);
- assert!(matches!(to(&a), Some(Action::Exec(_, v)) if v["anchor"] == 1 && v["to"] == "corner"), "{a:?}");
- assert_eq!(t.cursor(&cx, pt(100.0, 0.0), Mods { alt: true, ..Mods::default() }), Cursor::PenConvert);
- let a = t.pointer(&cx, &PointerEvent::new(PointerKind::DoubleClick, 0.0, 100.0));
- assert!(matches!(to(&a), Some(Action::Exec(_, v)) if v["anchor"] == 0 && v["to"] == "smooth"), "{a:?}");
- // Delete is the tool's while a point is current, and removes it.
- assert!(!t.claims_key(&cx, ToolKey::Delete));
- let s = selected(id, Some(2));
- let cx = quiet(&d, &s, &p);
- assert!(t.claims_key(&cx, ToolKey::Backspace));
- assert_eq!(t.key(&cx, ToolKey::Delete, Mods::default()), vec![remove_anchor((id, 0, 2))]);
- // Esc lets go of the point.
- assert_eq!(t.key(&cx, ToolKey::Escape, Mods::default()), vec![Action::Exec("select.set".into(), json!({"ids": [id.0]}))]);
- }
-
- #[test]
- fn a_press_on_a_segment_adds_a_point_and_a_drag_moves_it_in_one_step() {
- let (d, id) = doc_with(wave());
- let (s, p) = (selected(id, None), paint());
- let cx = quiet(&d, &s, &p);
- let mut t = CurvatureTool::default();
- let on = wave().segment(1).eval(0.5);
- assert_eq!(t.cursor(&cx, on, Mods::default()), Cursor::PenAdd);
- let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, on.x, on.y));
- assert_eq!(a[0], Action::Begin("Curvature".into()));
- assert!(
- matches!(edit_op(&a[1]), Some(("insert", v)) if v["segment"] == 1 && (v["t"].as_f64().unwrap() - 0.5).abs() < 1e-3 && v.get("x").is_none())
- );
- let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, on.x + 1.0, on.y + 40.0));
- assert!(matches!(edit_op(&a[0]), Some(("insert", v)) if v["segment"] == 1 && v["y"] == on.y + 40.0), "{a:?}");
- assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, on.x, on.y + 40.0)), vec![Action::Commit]);
- }
-
- #[test]
- fn clicks_go_on_from_a_current_end_and_the_other_end_closes() {
- let p = paint();
- let mut sp = wave();
- let mut t = CurvatureTool::default();
- let (d, id) = doc_with(sp.clone());
- let s = selected(id, Some(4));
- let a = press(&mut t, &quiet(&d, &s, &p), 550.0, 120.0, false);
- assert!(matches!(edit_op(&a[0]), Some(("extend", v)) if v["end"] == "end" && v["from"] == "keep" && v["x"] == 550.0), "{a:?}");
- // As the engine does it: the new end is current, and the next click curves through it.
- curvature_extend(&mut sp, false, pt(550.0, 120.0), EndCurve::Keep, false);
- let (d, id) = doc_with(sp.clone());
- let s = selected(id, Some(5));
- let cx = quiet(&d, &s, &p);
- t.pointer(&cx, &PointerEvent::new(PointerKind::Move, 650.0, 60.0));
- let ovs = t.overlays(&cx);
- assert!(ovs.iter().any(|o| matches!(o, Overlay::Path { .. })), "the rubber band shows");
- let from = pt(550.0, 120.0);
- let to = pt(650.0, 60.0);
- assert!(ovs.iter().any(|o| matches!(o, Overlay::Measure { text, .. } if text == &cx.segment_measure_label(from, to))));
- let a = press(&mut t, &cx, 650.0, 60.0, true);
- assert!(matches!(edit_op(&a[0]), Some(("extend", v)) if v["from"] == "smooth"), "{a:?}");
- curvature_extend(&mut sp, false, pt(650.0, 60.0), EndCurve::Smooth, false);
- let (d, id) = doc_with(sp.clone());
- let s = selected(id, Some(6));
- let cx = quiet(&d, &s, &p);
- // The Alt-clicked point stays a corner; a click on the first point closes.
- assert_eq!(t.cursor(&cx, pt(0.0, 100.0), Mods::default()), Cursor::PenClose);
- let a = press(&mut t, &cx, 0.0, 100.0, false);
- assert!(matches!(edit_op(&a[0]), Some(("close", v)) if v["from"] == "corner" && v["end"] == "end"), "{a:?}");
- // Any other end keeps its curve; the start goes on from the start.
- let s = selected(id, Some(0));
- let a = press(&mut t, &quiet(&d, &s, &p), -50.0, 150.0, false);
- assert!(matches!(edit_op(&a[0]), Some(("extend", v)) if v["end"] == "start" && v["from"] == "keep"), "{a:?}");
- }
-}
+mod tests;
diff --git a/crates/tools/src/draw2/curvature/tests.rs b/crates/tools/src/draw2/curvature/tests.rs
new file mode 100644
index 000000000..10dc9d031
--- /dev/null
+++ b/crates/tools/src/draw2/curvature/tests.rs
@@ -0,0 +1,405 @@
+use super::*;
+use crate::testutil::*;
+use vectorcraft_doc::{Appearance, Document, Node, Selection};
+use vectorcraft_geom::{ParamCurve, PathData};
+
+/// The Curvature tool has its own cursor, not the Pen's start-a-path one.
+#[test]
+fn curvature_tool_shows_its_cursor() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ assert_eq!(CurvatureTool::default().cursor(&cx, Point::new(10.0, 10.0), Mods::default()), Cursor::Curvature);
+}
+
+#[test]
+fn first_click_creates_then_notify_tracks_path() {
+ let (d, id) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let mut t = CurvatureTool::default();
+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 10.0, 10.0));
+ assert!(matches!(&a[0], Action::Exec(c, v) if c == "path.curvature" && v.get("id").is_none() && v["points"].as_array().unwrap().len() == 1));
+ assert_eq!(a[1], Action::Notify("created".into()));
+ // Pretend the engine created `id` with one anchor: it is a rect (4 anchors) so it doesn't match.
+ let mut s2 = Selection::default();
+ s2.set([id]);
+ let cx2 = crate::testutil::cx(&d, &s2, &p);
+ t.notify(&cx2, "created");
+ assert_eq!(t.id, Some(id));
+ assert!(t.active(&cx2).is_none());
+ // With four points it matches, so a click appends a fifth.
+ t.pts = vec![(Point::new(100.0, 100.0), false); 4];
+ let a = t.pointer(&cx2, &PointerEvent::new(PointerKind::Down, 400.0, 400.0));
+ assert!(matches!(&a[0], Action::Exec(_, v) if v["id"] == id.0 && v["points"].as_array().unwrap().len() == 5));
+}
+
+/// Points snap to Smart Guides (#506): the first lands on another object's anchor and says so.
+#[test]
+fn points_snap_to_smart_guides() {
+ let (d, _) = doc_with_rect();
+ let s = Selection::default();
+ let p = paint();
+ let cx = cx(&d, &s, &p);
+ let mut t = CurvatureTool::default();
+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 202.0, 99.0));
+ assert!(matches!(&a[0], Action::Exec(_, v) if v["points"][0]["x"] == 200.0 && v["points"][0]["y"] == 100.0), "{a:?}");
+ assert!(t.overlays(&cx).iter().any(|o| matches!(o, Overlay::Label { text, .. } if text == "anchor")));
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 202.0, 99.0));
+ assert!(t.overlays(&cx).is_empty());
+}
+
+fn pt(x: f64, y: f64) -> Point {
+ Point::new(x, y)
+}
+
+/// An open pen-style path: a corner start, two smooth anchors with uneven handles, a cusp and
+/// an end with only an incoming handle.
+fn wave() -> SubPath {
+ SubPath::new(
+ vec![
+ Anchor::corner(pt(0.0, 100.0)),
+ Anchor::with_handles(pt(100.0, 0.0), pt(60.0, 10.0), pt(160.0, -15.0)),
+ Anchor::with_handles(pt(250.0, 80.0), pt(220.0, 30.0), pt(280.0, 130.0)),
+ Anchor::with_handles(pt(350.0, 150.0), pt(320.0, 160.0), pt(380.0, 100.0)),
+ Anchor::with_handles(pt(450.0, 60.0), pt(420.0, 90.0), pt(450.0, 60.0)),
+ ],
+ false,
+ )
+}
+
+/// Every point of `a` lies on `b` (within 1e-6), sampled.
+fn lies_on(a: &SubPath, b: &SubPath) -> bool {
+ let b = PathData::single(b.clone());
+ (0..a.segment_count()).all(|i| (0..=20).all(|k| b.nearest(a.segment(i).eval(k as f64 / 20.0)).is_some_and(|n| n.4 < 1e-6)))
+}
+
+fn collinear(a: Vec2, b: Vec2) -> bool {
+ a.cross(b).abs() < 1e-6 * a.hypot().max(1.0) * b.hypot().max(1.0)
+}
+
+#[test]
+fn moving_a_point_recurves_only_its_two_segments() {
+ let before = wave();
+ let mut sp = before.clone();
+ assert_eq!(sp.anchors[2].kind, AnchorKind::Smooth);
+ assert!(curvature_move(&mut sp, 2, pt(260.0, 140.0)));
+ assert_eq!(sp.anchors[2].p, pt(260.0, 140.0));
+ // The segments beyond its neighbours are bit-identical.
+ assert_eq!(sp.segment(0), before.segment(0));
+ assert_eq!(sp.segment(3), before.segment(3));
+ // The neighbours keep their handle directions on its segments, and their other handles.
+ assert!(collinear(sp.anchors[1].h_out - sp.anchors[1].p, before.anchors[1].h_out - before.anchors[1].p));
+ assert!(collinear(sp.anchors[3].h_in - sp.anchors[3].p, before.anchors[3].h_in - before.anchors[3].p));
+ assert_eq!((sp.anchors[1].h_in, sp.anchors[3].h_out), (before.anchors[1].h_in, before.anchors[3].h_out));
+ // The moved smooth point takes the Curvature tool's handles, along the circle through it
+ // and its neighbours, whatever the spacing: between a third and two thirds of its chord.
+ let a = sp.anchors[2];
+ let (prev, next) = (sp.anchors[1].p, sp.anchors[3].p);
+ assert_eq!(a.kind, AnchorKind::Smooth);
+ assert_eq!(Some((a.h_in, a.h_out)), smooth_handles(prev, a.p, next));
+ assert!(collinear(a.h_in - a.p, a.h_out - a.p) && (a.h_in - a.p).dot(a.h_out - a.p) < 0.0);
+ for (h, to) in [(a.h_in, prev), (a.h_out, next)] {
+ let r = a.p.distance(h) / a.p.distance(to);
+ assert!((1.0 / 3.0 - 1e-9..=2.0 / 3.0 + 1e-9).contains(&r), "{r}");
+ }
+ // A cusp keeps its handle directions; a moved end changes its one segment only.
+ assert_eq!(sp.anchors[3].kind, AnchorKind::Corner);
+ assert!(curvature_move(&mut sp, 3, pt(360.0, 170.0)));
+ assert!(collinear(sp.anchors[3].h_out - sp.anchors[3].p, before.anchors[3].h_out - before.anchors[3].p));
+ let mut end = before.clone();
+ assert!(curvature_move(&mut end, 4, pt(470.0, 20.0)));
+ assert_eq!(end.segment(2), before.segment(2));
+ assert!(!curvature_move(&mut end, 5, pt(0.0, 0.0)));
+}
+
+/// A smooth end of an open path has one segment: its one handle into the curve, mirroring the
+/// neighbour's tangent in their chord, and nothing on the outer side.
+#[test]
+fn moving_a_smooth_end_gives_it_the_end_handle() {
+ let mut sp = curvature_spline(&[(pt(0.0, 0.0), false), (pt(100.0, 60.0), false), (pt(200.0, 0.0), false), (pt(300.0, 50.0), false)], false);
+ sp.anchors[0].kind = AnchorKind::Smooth;
+ let before = sp.clone();
+ assert!(curvature_move(&mut sp, 0, pt(-20.0, 30.0)));
+ let (e, b) = (sp.anchors[0], sp.anchors[1]);
+ assert!(!e.has_in() && e.has_out());
+ assert_eq!(Some(e.h_out), end_handle(e.p, &b, true));
+ assert_eq!(sp.segment(2), before.segment(2));
+ assert_eq!(sp.anchors[2], before.anchors[2]);
+}
+
+#[test]
+fn moving_a_corner_without_handles_keeps_its_sides_straight() {
+ let (d, id) = doc_with_rect();
+ let mut sp = d.node(id).unwrap().path_data().unwrap().subpaths[0].clone();
+ assert!(curvature_move(&mut sp, 0, pt(80.0, 70.0)));
+ assert!((0..sp.segment_count()).all(|i| sp.segment_is_line(i)));
+ assert_eq!(sp.anchors[0], Anchor::corner(pt(80.0, 70.0)));
+}
+
+#[test]
+fn going_on_from_an_end_keeps_the_old_segments() {
+ let before = wave();
+ let mut sp = before.clone();
+ curvature_extend(&mut sp, false, pt(550.0, 120.0), EndCurve::Keep, false);
+ assert_eq!(sp.anchors.len(), 6);
+ assert!((0..4).all(|i| sp.segment(i) == before.segment(i)));
+ // The old end turns smooth, going on along its incoming handle, a third of the chord out.
+ let e = sp.anchors[4];
+ assert_eq!(e.kind, AnchorKind::Smooth);
+ assert!(collinear(e.h_out - e.p, e.p - e.h_in) && (e.h_out - e.p).dot(e.p - e.h_in) > 0.0);
+ assert!((e.h_out.distance(e.p) - e.p.distance(pt(550.0, 120.0)) / 3.0).abs() < 1e-9);
+ // The new end has no outer handle and one into the curve, mirroring the old end's tangent.
+ let n = sp.anchors[5];
+ assert_eq!((n.p, n.has_out(), n.kind), (pt(550.0, 120.0), false, AnchorKind::Corner));
+ assert_eq!(Some(n.h_in), end_handle(n.p, &e, false));
+ // The point placed then curves through its neighbours as a drawn path's points do.
+ curvature_extend(&mut sp, false, pt(650.0, 60.0), EndCurve::Smooth, false);
+ let drawn = curvature_spline(&[(pt(450.0, 60.0), false), (pt(550.0, 120.0), false), (pt(650.0, 60.0), false)], false);
+ assert_eq!((sp.anchors[5].h_in, sp.anchors[5].h_out), (drawn.anchors[1].h_in, drawn.anchors[1].h_out));
+ assert!((0..4).all(|i| sp.segment(i) == before.segment(i)));
+ // A corner stays one.
+ curvature_extend(&mut sp, false, pt(700.0, 100.0), EndCurve::Corner, false);
+ assert!(!sp.anchors[6].has_in() && !sp.anchors[6].has_out());
+ // From the start: the old segments come one later, and the new end is the first anchor.
+ let mut sp = before.clone();
+ curvature_extend(&mut sp, true, pt(-100.0, 50.0), EndCurve::Keep, false);
+ assert!(sp.anchors[0].p == pt(-100.0, 50.0) && !sp.anchors[0].has_in() && sp.anchors[0].has_out());
+ assert!((0..4).all(|i| sp.segment(i + 1) == before.segment(i)));
+ // A corner end without handles goes on along its segment's tangent.
+ let old = sp.anchors[1];
+ assert!(old.has_in() && !old.has_out());
+ assert!(collinear(old.h_in - old.p, old.p - before.anchors[1].h_in) && (old.h_in - old.p).dot(old.p - before.anchors[1].h_in) > 0.0);
+}
+
+#[test]
+fn closing_keeps_the_old_segments() {
+ let before = wave();
+ let mut sp = before.clone();
+ curvature_close(&mut sp, false, EndCurve::Keep);
+ assert!(sp.closed && sp.anchors.len() == 5);
+ assert!((0..4).all(|i| sp.segment(i) == before.segment(i)));
+ // The first anchor gains an incoming handle along its tangent: no kink there.
+ let f = sp.anchors[0];
+ assert!(f.has_in() && collinear(f.p - f.h_in, before.anchors[1].h_in - f.p));
+}
+
+#[test]
+fn inserting_a_point_keeps_the_shape() {
+ let before = wave();
+ let mut sp = before.clone();
+ assert_eq!(curvature_insert(&mut sp, 1, 0.3), Some(2));
+ assert_eq!(sp.anchors.len(), 6);
+ assert_eq!(sp.anchors[2].kind, AnchorKind::Smooth);
+ assert!(lies_on(&sp, &before) && lies_on(&before, &sp));
+ // On a straight side the point is smooth too, its handles along the side.
+ let (d, id) = doc_with_rect();
+ let rect = d.node(id).unwrap().path_data().unwrap().subpaths[0].clone();
+ let mut sp = rect.clone();
+ let i = curvature_insert(&mut sp, 0, 0.5).unwrap();
+ assert_eq!(sp.anchors[i].kind, AnchorKind::Smooth);
+ assert!(sp.anchors[i].has_in() && sp.anchors[i].has_out());
+ assert!(lies_on(&sp, &rect) && lies_on(&rect, &sp));
+ assert_eq!(curvature_insert(&mut sp, 99, 0.5), None);
+}
+
+/// On a straight side the inserted point's handles lie along it, each a third of its own part
+/// of the side; a drag then moves it as a smooth Curvature point.
+#[test]
+fn a_point_inserted_on_a_line_takes_the_chord_rule_and_drags_smooth() {
+ let (d, id) = doc_with_rect();
+ let rect = d.node(id).unwrap().path_data().unwrap().subpaths[0].clone();
+ let mut sp = rect.clone();
+ let i = curvature_insert(&mut sp, 0, 0.25).unwrap();
+ let (a, prev, next) = (sp.anchors[i], sp.anchors[i - 1].p, sp.anchors[i + 1].p);
+ assert!((a.p.distance(a.h_in) - a.p.distance(prev) / 3.0).abs() < 1e-9);
+ assert!((a.p.distance(a.h_out) - a.p.distance(next) / 3.0).abs() < 1e-9);
+ assert!(collinear(a.h_out - a.p, next - prev) && (a.h_out - a.p).dot(next - prev) > 0.0);
+ assert!(sp.segment_is_line(0) || lies_on(&sp, &rect));
+ // A drag bends it as a smooth point; the sides beyond stay straight.
+ let q = pt(a.p.x, a.p.y - 40.0);
+ assert!(curvature_move(&mut sp, i, q));
+ let m = sp.anchors[i];
+ assert_eq!(Some((m.h_in, m.h_out)), smooth_handles(prev, q, next));
+ assert!((2..sp.segment_count()).all(|s| sp.segment_is_line(s)));
+}
+
+#[test]
+fn curvature_smooth_uses_the_tool_rule() {
+ let mut sp = curvature_spline(&[(pt(0.0, 0.0), true), (pt(100.0, 60.0), true), (pt(200.0, 0.0), false), (pt(300.0, 50.0), false)], false);
+ // A corner in the middle takes the bisector handles.
+ assert!(curvature_smooth(&mut sp, 1));
+ let a = sp.anchors[1];
+ assert_eq!((a.kind, Some((a.h_in, a.h_out))), (AnchorKind::Smooth, smooth_handles(pt(0.0, 0.0), a.p, pt(200.0, 0.0))));
+ // An end curves into its segment, mirroring its neighbour's tangent.
+ assert!(curvature_smooth(&mut sp, 0));
+ let e = sp.anchors[0];
+ assert!(!e.has_in() && Some(e.h_out) == end_handle(e.p, &sp.anchors[1], true));
+ // No direction: a fold, or an end whose neighbour has no handle there, stays as it is.
+ let mut fold = SubPath::new(vec![Anchor::corner(pt(0.0, 0.0)), Anchor::corner(pt(100.0, 0.0)), Anchor::corner(pt(0.0, 0.0))], false);
+ let before = fold.clone();
+ assert!(!curvature_smooth(&mut fold, 1) && !curvature_smooth(&mut fold, 0) && !curvature_smooth(&mut fold, 9));
+ assert_eq!(fold, before);
+}
+
+/// A curved end counts as smooth for the toggle: Alt-click turns it into a corner.
+#[test]
+fn alt_click_on_a_curved_end_makes_it_a_corner() {
+ let sp = curvature_spline(&[(pt(100.0, 300.0), false), (pt(200.0, 200.0), false), (pt(300.0, 300.0), false)], false);
+ let (d, id) = doc_with(sp);
+ let (s, p) = (selected(id, None), paint());
+ let cx = quiet(&d, &s, &p);
+ let a = press(&mut CurvatureTool::default(), &cx, 100.0, 300.0, true);
+ assert!(a.iter().any(|a| matches!(a, Action::Exec(c, v) if c == "path.convertAnchor" && v["anchor"] == 0 && v["to"] == "corner")), "{a:?}");
+}
+
+/// A document with one path, `sp`.
+fn doc_with(sp: SubPath) -> (Document, NodeId) {
+ let mut d = Document::new(800.0, 600.0);
+ let l = d.layers[0].id;
+ let id = d.alloc_id();
+ d.insert(Some(l), 0, Node::path(id, PathData::single(sp), Appearance::default_art())).unwrap();
+ (d, id)
+}
+
+/// Path `id` selected, anchor `current` of its first subpath direct-selected (or none).
+fn selected(id: NodeId, current: Option<usize>) -> Selection {
+ let mut s = Selection::default();
+ s.set([id]);
+ if let Some(ai) = current {
+ s.anchors.insert(id, [(0, ai)].into());
+ }
+ s
+}
+
+/// A context without snapping.
+fn quiet<'a>(d: &'a Document, s: &'a Selection, p: &'a crate::PaintDefaults) -> ToolContext<'a> {
+ ToolContext { smart_guides: false, snap_to_point: false, ..cx(d, s, p) }
+}
+
+fn press(t: &mut CurvatureTool, cx: &ToolContext, x: f64, y: f64, alt: bool) -> Vec<Action> {
+ let ev = PointerEvent::new(PointerKind::Down, x, y).with_mods(Mods { alt, ..Mods::default() });
+ let mut a = t.pointer(cx, &ev);
+ a.extend(t.pointer(cx, &PointerEvent::new(PointerKind::Up, x, y)));
+ a
+}
+
+/// The op and params of a `path.curvatureEdit` action.
+fn edit_op(a: &Action) -> Option<(&str, &Value)> {
+ match a {
+ Action::Exec(c, v) | Action::Preview(c, v) if c == EDIT => Some((v["op"].as_str()?, v)),
+ _ => None,
+ }
+}
+
+#[test]
+fn a_press_on_a_point_selects_it_and_a_drag_moves_it() {
+ let (d, id) = doc_with(wave());
+ let (s, p) = (selected(id, None), paint());
+ let cx = quiet(&d, &s, &p);
+ let mut t = CurvatureTool::default();
+ assert_eq!(t.cursor(&cx, pt(250.0, 81.0), Mods::default()), Cursor::Move);
+ assert_eq!(t.cursor(&cx, pt(450.0, 61.0), Mods::default()), Cursor::PenContinue);
+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 251.0, 81.0));
+ assert_eq!(a, vec![Action::Exec("select.anchors".into(), json!({"id": id.0, "anchors": [[0, 2]], "mode": "set"}))]);
+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 260.0, 140.0));
+ assert_eq!(a[0], Action::Begin("Curvature".into()));
+ let moved = edit_op(&a[1]).map(|(op, v)| (op, v["anchor"].clone(), v["x"].clone(), v["y"].clone()));
+ assert_eq!(moved, Some(("move", json!(2), json!(260.0), json!(140.0))));
+ assert!(t.busy());
+ assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 260.0, 140.0)), vec![Action::Commit]);
+ // A press without a drag only selects.
+ assert_eq!(press(&mut t, &cx, 100.0, 0.0, false).len(), 1);
+}
+
+/// #2120: the dragged end of a slanted straight path keeps to its extension (Smart Guides).
+#[test]
+fn a_dragged_end_of_a_straight_path_keeps_to_its_extension() {
+ let (d, id) = doc_with(SubPath::polyline(&[pt(300.0, 400.0), pt(380.0, 340.0)], false));
+ let (s, p) = (selected(id, None), paint());
+ let cx = cx(&d, &s, &p);
+ let mut t = CurvatureTool::default();
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 380.0, 340.0));
+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 421.5, 312.0));
+ let moved = a.get(1).and_then(edit_op).map(|(op, v)| (op, v["x"].as_f64().unwrap(), v["y"].as_f64().unwrap()));
+ assert!(matches!(moved, Some(("move", x, y)) if (x - 420.0).abs() < 1e-9 && (y - 310.0).abs() < 1e-9), "{a:?}");
+}
+
+#[test]
+fn alt_click_or_double_click_toggles_and_delete_removes() {
+ let (d, id) = doc_with(wave());
+ let p = paint();
+ let s = selected(id, None);
+ let cx = quiet(&d, &s, &p);
+ let mut t = CurvatureTool::default();
+ let to = |a: &[Action]| a.iter().find(|a| matches!(a, Action::Exec(c, _) if c == "path.convertAnchor")).cloned();
+ let a = press(&mut t, &cx, 100.0, 0.0, true);
+ assert!(matches!(to(&a), Some(Action::Exec(_, v)) if v["anchor"] == 1 && v["to"] == "corner"), "{a:?}");
+ assert_eq!(t.cursor(&cx, pt(100.0, 0.0), Mods { alt: true, ..Mods::default() }), Cursor::PenConvert);
+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::DoubleClick, 0.0, 100.0));
+ assert!(matches!(to(&a), Some(Action::Exec(_, v)) if v["anchor"] == 0 && v["to"] == "smooth"), "{a:?}");
+ // Delete is the tool's while a point is current, and removes it.
+ assert!(!t.claims_key(&cx, ToolKey::Delete));
+ let s = selected(id, Some(2));
+ let cx = quiet(&d, &s, &p);
+ assert!(t.claims_key(&cx, ToolKey::Backspace));
+ assert_eq!(t.key(&cx, ToolKey::Delete, Mods::default()), vec![remove_anchor((id, 0, 2))]);
+ // Esc lets go of the point.
+ assert_eq!(t.key(&cx, ToolKey::Escape, Mods::default()), vec![Action::Exec("select.set".into(), json!({"ids": [id.0]}))]);
+}
+
+#[test]
+fn a_press_on_a_segment_adds_a_point_and_a_drag_moves_it_in_one_step() {
+ let (d, id) = doc_with(wave());
+ let (s, p) = (selected(id, None), paint());
+ let cx = quiet(&d, &s, &p);
+ let mut t = CurvatureTool::default();
+ let on = wave().segment(1).eval(0.5);
+ assert_eq!(t.cursor(&cx, on, Mods::default()), Cursor::PenAdd);
+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Down, on.x, on.y));
+ assert_eq!(a[0], Action::Begin("Curvature".into()));
+ assert!(
+ matches!(edit_op(&a[1]), Some(("insert", v)) if v["segment"] == 1 && (v["t"].as_f64().unwrap() - 0.5).abs() < 1e-3 && v.get("x").is_none())
+ );
+ let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, on.x + 1.0, on.y + 40.0));
+ assert!(matches!(edit_op(&a[0]), Some(("insert", v)) if v["segment"] == 1 && v["y"] == on.y + 40.0), "{a:?}");
+ assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, on.x, on.y + 40.0)), vec![Action::Commit]);
+}
+
+#[test]
+fn clicks_go_on_from_a_current_end_and_the_other_end_closes() {
+ let p = paint();
+ let mut sp = wave();
+ let mut t = CurvatureTool::default();
+ let (d, id) = doc_with(sp.clone());
+ let s = selected(id, Some(4));
+ let a = press(&mut t, &quiet(&d, &s, &p), 550.0, 120.0, false);
+ assert!(matches!(edit_op(&a[0]), Some(("extend", v)) if v["end"] == "end" && v["from"] == "keep" && v["x"] == 550.0), "{a:?}");
+ // As the engine does it: the new end is current, and the next click curves through it.
+ curvature_extend(&mut sp, false, pt(550.0, 120.0), EndCurve::Keep, false);
+ let (d, id) = doc_with(sp.clone());
+ let s = selected(id, Some(5));
+ let cx = quiet(&d, &s, &p);
+ t.pointer(&cx, &PointerEvent::new(PointerKind::Move, 650.0, 60.0));
+ let ovs = t.overlays(&cx);
+ assert!(ovs.iter().any(|o| matches!(o, Overlay::Path { .. })), "the rubber band shows");
+ let from = pt(550.0, 120.0);
+ let to = pt(650.0, 60.0);
+ assert!(ovs.iter().any(|o| matches!(o, Overlay::Measure { text, .. } if text == &cx.segment_measure_label(from, to))));
+ let a = press(&mut t, &cx, 650.0, 60.0, true);
+ assert!(matches!(edit_op(&a[0]), Some(("extend", v)) if v["from"] == "smooth"), "{a:?}");
+ curvature_extend(&mut sp, false, pt(650.0, 60.0), EndCurve::Smooth, false);
+ let (d, id) = doc_with(sp.clone());
+ let s = selected(id, Some(6));
+ let cx = quiet(&d, &s, &p);
+ // The Alt-clicked point stays a corner; a click on the first point closes.
+ assert_eq!(t.cursor(&cx, pt(0.0, 100.0), Mods::default()), Cursor::PenClose);
+ let a = press(&mut t, &cx, 0.0, 100.0, false);
+ assert!(matches!(edit_op(&a[0]), Some(("close", v)) if v["from"] == "corner" && v["end"] == "end"), "{a:?}");
+ // Any other end keeps its curve; the start goes on from the start.
+ let s = selected(id, Some(0));
+ let a = press(&mut t, &quiet(&d, &s, &p), -50.0, 150.0, false);
+ assert!(matches!(edit_op(&a[0]), Some(("extend", v)) if v["end"] == "start" && v["from"] == "keep"), "{a:?}");
+}