GitCorner

Code

ossartcrafteffectcraft🌐
665bfac0b339
use super::*;
use kurbo::{Circle, Rect, Shape};

fn len(p: &[BezPath]) -> f64 {
    p.iter().map(length).sum()
}

fn sq(x: f64, y: f64, s: f64) -> BezPath {
    Rect::new(x, y, x + s, y + s).to_path(0.1)
}

fn circle(x: f64, y: f64, r: f64) -> BezPath {
    Circle::new((x, y), r).to_path(1e-3)
}

fn close(a: f64, b: f64, tol: f64) -> bool {
    (a - b).abs() <= tol
}

fn on_curve(p: &BezPath) -> Vec<Point> {
    p.elements().iter().filter_map(|e| e.end_point()).collect()
}

// ---------------------------------------------------------------- trim

#[test]
fn trim_half_square() {
    let s = sq(0.0, 0.0, 100.0);
    let t = trim(std::slice::from_ref(&s), 0.0, 50.0, 0.0);
    assert!(close(len(&t), 200.0, 0.5), "{}", len(&t));
    let t2 = trim(&[s], 0.0, 50.0, 270.0);
    assert!(close(len(&t2), 200.0, 0.5));
}

#[test]
fn trim_empty_keeps_slot() {
    let t = trim(&[sq(0.0, 0.0, 10.0)], 30.0, 30.0, 0.0);
    assert_eq!(t.len(), 1);
    assert!(t[0].elements().is_empty());
}

#[test]
fn trim_across_start_point_is_one_piece() {
    // 75 %..125 % (via the offset) crosses the start of the closed path: one continuous subpath.
    let t = trim(&[sq(0.0, 0.0, 100.0)], 0.0, 50.0, 270.0);
    let moves = t[0].elements().iter().filter(|e| matches!(e, PathEl::MoveTo(_))).count();
    assert_eq!(moves, 1, "{:?}", t[0]);
}

#[test]
fn trim_simultaneously_trims_each_path() {
    let paths = [sq(0.0, 0.0, 100.0), sq(200.0, 0.0, 50.0)];
    let t = trim(&paths, 0.0, 50.0, 0.0);
    assert!(close(length(&t[0]), 200.0, 0.5));
    assert!(close(length(&t[1]), 100.0, 0.5));
}

#[test]
fn trim_individually_is_sequential() {
    let paths = [sq(0.0, 0.0, 100.0), sq(200.0, 0.0, 100.0)];
    let t = trim_individually(&paths, 0.0, 50.0, 0.0);
    assert!(close(length(&t[0]), 400.0, 0.5), "{}", length(&t[0]));
    assert!(length(&t[1]) < 1e-6);
    let t = trim_individually(&paths, 25.0, 75.0, 0.0);
    assert!(close(length(&t[0]), 200.0, 0.5));
    assert!(close(length(&t[1]), 200.0, 0.5));
    // Unequal lengths: the kept length is the fraction of the total.
    let paths = [sq(0.0, 0.0, 100.0), sq(200.0, 0.0, 25.0)];
    let t = trim_individually(&paths, 10.0, 90.0, 45.0);
    assert!(close(len(&t), 0.8 * 500.0, 0.5), "{}", len(&t));
}

#[test]
fn reverse_flips_orientation() {
    let s = sq(0.0, 0.0, 10.0);
    let r = reverse(std::slice::from_ref(&s));
    assert!(close(r[0].area(), -s.area(), 1e-9));
    assert_eq!(vertex_count(&r[0]), 4);
}

// ---------------------------------------------------------------- round corners

#[test]
fn round_corners_square() {
    let r = round_corners(&[sq(0.0, 0.0, 100.0)], 10.0);
    assert_eq!(vertex_count(&r[0]), 8);
    let expect = 10000.0 - (4.0 - PI) * 100.0;
    assert!(close(r[0].area().abs(), expect, 1.0), "{}", r[0].area());
    // Matches the rectangle's own roundness.
    let rr = crate::rect([100.0, 100.0], [50.0, 50.0], 10.0);
    assert!(close(rr.area().abs(), r[0].area().abs(), 1.0));
}

#[test]
fn round_corners_clamps_to_half_segment() {
    let r = round_corners(&[sq(0.0, 0.0, 20.0)], 100.0);
    assert!(close(r[0].area().abs(), PI * 100.0, 2.0), "{}", r[0].area());
}

#[test]
fn round_corners_keeps_smooth_and_open_ends() {
    let c = circle(0.0, 0.0, 50.0);
    let r = round_corners(std::slice::from_ref(&c), 10.0);
    assert_eq!(vertex_count(&r[0]), vertex_count(&c));
    let mut open = BezPath::new();
    open.move_to((0.0, 0.0));
    open.line_to((100.0, 0.0));
    open.line_to((100.0, 100.0));
    let r = round_corners(&[open], 20.0);
    assert_eq!(vertex_count(&r[0]), 4);
    let pts = on_curve(&r[0]);
    assert_eq!(pts[0], Point::new(0.0, 0.0));
    assert!(pts.last().unwrap().distance(Point::new(100.0, 100.0)) < 1e-9);
}

#[test]
fn round_corners_triangle_arc_is_tangent() {
    let mut t = BezPath::new();
    t.move_to((0.0, 0.0));
    t.line_to((100.0, 0.0));
    t.line_to((50.0, 80.0));
    t.close_path();
    let r = round_corners(std::slice::from_ref(&t), 15.0);
    assert_eq!(vertex_count(&r[0]), 6);
    assert!(r[0].area().abs() < t.area().abs());
    assert!(r[0].area().abs() > t.area().abs() - 3.0 * 15.0 * 15.0);
}

// ---------------------------------------------------------------- offset

#[test]
fn offset_grows_square_with_miter() {
    let o = offset(&[sq(0.0, 0.0, 100.0)], 10.0, Join::Miter, 4.0, 1.0, 0.0);
    assert!(close(area(&o), 120.0 * 120.0, 1.0), "{}", area(&o));
    let b = o[0].bounding_box();
    assert!(close(b.x0, -10.0, 1e-3) && close(b.x1, 110.0, 1e-3));
}

#[test]
fn offset_round_join_adds_perimeter_times_d() {
    let o = offset(&[sq(0.0, 0.0, 100.0)], 10.0, Join::Round, 4.0, 1.0, 0.0);
    let expect = 10000.0 + 400.0 * 10.0 + PI * 100.0;
    assert!(close(area(&o), expect, 2.0), "{} vs {expect}", area(&o));
    let o = offset(&[sq(0.0, 0.0, 100.0)], 10.0, Join::Bevel, 4.0, 1.0, 0.0);
    let expect = 10000.0 + 400.0 * 10.0 + 4.0 * 50.0;
    assert!(close(area(&o), expect, 2.0), "{} vs {expect}", area(&o));
}

#[test]
fn offset_negative_shrinks() {
    let o = offset(&[sq(0.0, 0.0, 100.0)], -10.0, Join::Miter, 4.0, 1.0, 0.0);
    assert!(close(area(&o), 80.0 * 80.0, 1.0), "{}", area(&o));
    let gone = offset(&[sq(0.0, 0.0, 100.0)], -60.0, Join::Miter, 4.0, 1.0, 0.0);
    assert!(area(&gone) < 1e-6);
}

#[test]
fn offset_circle_is_a_circle() {
    let o = offset(&[circle(0.0, 0.0, 50.0)], 10.0, Join::Round, 4.0, 1.0, 0.0);
    assert!(close(area(&o), PI * 3600.0, 3600.0 * PI * 1e-3), "{}", area(&o));
    let o = offset(&[circle(0.0, 0.0, 50.0)], -20.0, Join::Round, 4.0, 1.0, 0.0);
    assert!(close(area(&o), PI * 900.0, 900.0 * PI * 1e-3), "{}", area(&o));
    // Curves stay curves (no polygon flattening blow-up).
    assert!(vertex_count(&o[0]) < 40, "{}", vertex_count(&o[0]));
}

#[test]
fn offset_is_independent_of_orientation() {
    let s = sq(0.0, 0.0, 100.0);
    let a = offset(std::slice::from_ref(&s), 5.0, Join::Miter, 4.0, 1.0, 0.0);
    let b = offset(&reverse(&[s]), 5.0, Join::Miter, 4.0, 1.0, 0.0);
    assert!(close(area(&a), area(&b), 1e-3));
}

#[test]
fn offset_copies() {
    let o = offset(&[sq(0.0, 0.0, 100.0)], 10.0, Join::Miter, 4.0, 3.0, 0.0);
    let contours = o[0].elements().iter().filter(|e| matches!(e, PathEl::MoveTo(_))).count();
    assert_eq!(contours, 3);
    assert!(close(o[0].bounding_box().width(), 160.0, 1e-3));
    let o = offset(&[sq(0.0, 0.0, 100.0)], 10.0, Join::Miter, 4.0, 1.0, 1.0);
    assert!(close(o[0].bounding_box().width(), 140.0, 1e-3));
}

#[test]
fn offset_copies_are_budgeted_by_the_output_they_return() {
    // An open one-segment subpath comes back as a closed outline of several elements, so the copies
    // stop when the returned elements pass the budget, not when the input segments would.
    let line = || {
        let mut p = BezPath::new();
        p.move_to((0.0, 0.0));
        p.line_to((50.0, 0.0));
        p
    };
    let one = offset_within(&[line()], 5.0, Join::Round, 4.0, 1.0, 0.0, usize::MAX)[0].elements().len();
    assert!(one > 4, "{one}");
    let o = offset_within(&[line()], 5.0, Join::Round, 4.0, 50.0, 0.0, one * 3);
    let moves = o[0].elements().iter().filter(|e| matches!(e, PathEl::MoveTo(_))).count();
    assert!((1..50).contains(&moves) && o[0].elements().len() <= one * 4, "{moves} contours, {} elements", o[0].elements().len());
    // The first copy always comes back, however small the budget.
    assert!(!offset_within(&[line()], 5.0, Join::Round, 4.0, 5.0, 0.0, 0)[0].elements().is_empty());
}

#[test]
fn offset_open_path_outlines() {
    let mut l = BezPath::new();
    l.move_to((0.0, 0.0));
    l.line_to((100.0, 0.0));
    let o = offset(&[l], 5.0, Join::Miter, 4.0, 1.0, 0.0);
    assert!(close(area(&o), 1000.0, 1.0), "{}", area(&o));
}

// ---------------------------------------------------------------- pucker & bloat

#[test]
fn bloat_moves_vertices_inwards_and_bulges() {
    let s = sq(-50.0, -50.0, 100.0);
    let b = pucker_bloat(std::slice::from_ref(&s), 50.0);
    for p in on_curve(&b[0]) {
        assert!(close(p.x.abs(), 25.0, 1e-9) && close(p.y.abs(), 25.0, 1e-9), "{p:?}");
    }
    // Handles pushed outwards: the shape reaches beyond its vertices.
    let bb = b[0].bounding_box();
    assert!(bb.width() > 50.0 + 1.0, "{bb:?}");
}

#[test]
fn pucker_moves_vertices_outwards() {
    let s = sq(-50.0, -50.0, 100.0);
    let p = pucker_bloat(std::slice::from_ref(&s), -50.0);
    for q in on_curve(&p[0]) {
        assert!(close(q.x.abs(), 75.0, 1e-9) && close(q.y.abs(), 75.0, 1e-9));
    }
    assert!(area(&p) < area(&[s]) * 2.25, "segments pulled in");
    assert_eq!(pucker_bloat(&[sq(0.0, 0.0, 1.0)], 0.0)[0], sq(0.0, 0.0, 1.0));
}

// ---------------------------------------------------------------- twist

#[test]
fn twist_rotates_by_distance() {
    let mut l = BezPath::new();
    l.move_to((0.0, 0.0));
    l.line_to((100.0, 0.0));
    let t = twist(&[l], 90.0, [0.0, 0.0]);
    let pts = on_curve(&t[0]);
    assert!(pts[0].distance(Point::ZERO) < 1e-9, "centre is fixed");
    let end = *pts.last().unwrap();
    assert!(end.distance(Point::new(0.0, 100.0)) < 1e-9, "{end:?}");
    // Every on-curve point keeps its distance from the centre (it is a rotation per radius).
    for p in &pts {
        let r = p.distance(Point::ZERO);
        let ang = p.y.atan2(p.x);
        assert!(close(ang, PI / 2.0 * r / 100.0, 1e-9), "{p:?}");
    }
    assert!(pts.len() > 4, "subdivided");
}

#[test]
fn twist_of_centred_circle_keeps_it_round() {
    let c = circle(0.0, 0.0, 50.0);
    let t = twist(std::slice::from_ref(&c), 120.0, [0.0, 0.0]);
    assert!(close(area(&t), area(&[c]), 1.0));
    let id = twist(&[sq(0.0, 0.0, 5.0)], 0.0, [0.0, 0.0]);
    assert_eq!(id[0], sq(0.0, 0.0, 5.0));
}

#[test]
fn twist_keeps_requested_detail_when_the_whole_request_fits_the_budget() {
    // One long segment asks for 64 pieces; 20,000 tiny ones ask for one each. Together that is
    // far under the budget, so the long one is not cut to what a uniform 64 per segment would allow.
    let mut long = BezPath::new();
    long.move_to((0.0, 0.0));
    long.line_to((5000.0, 0.0));
    let mut tiny = BezPath::new();
    tiny.move_to((0.0, 1.0));
    for i in 1..=20_000 {
        tiny.line_to((i as f64 * 1e-3, 1.0));
    }
    let t = twist(&[long, tiny], 90.0, [0.0, 0.0]);
    assert_eq!(t[0].elements().len(), 1 + 64);
}

// ---------------------------------------------------------------- zig zag

#[test]
fn zigzag_vertex_counts() {
    let z = zigzag(&[sq(0.0, 0.0, 100.0)], 5.0, 5.0, false);
    assert_eq!(vertex_count(&z[0]), 24);
    let mut l = BezPath::new();
    l.move_to((0.0, 0.0));
    l.line_to((100.0, 0.0));
    let z = zigzag(&[l], 5.0, 3.0, false);
    assert_eq!(vertex_count(&z[0]), 5);
    let pts = on_curve(&z[0]);
    for (i, p) in pts.iter().enumerate() {
        assert!(close(p.x, 25.0 * i as f64, 1e-6));
        assert!(close(p.y.abs(), 5.0, 1e-9));
        if i > 0 {
            assert!(p.y * pts[i - 1].y < 0.0, "alternates");
        }
    }
}

#[test]
fn zigzag_smooth_uses_curves() {
    let z = zigzag(&[sq(0.0, 0.0, 100.0)], 5.0, 2.0, true);
    assert!(z[0].elements().iter().any(|e| matches!(e, PathEl::CurveTo(..))));
    assert_eq!(vertex_count(&z[0]), 12);
    let corner = zigzag(&[sq(0.0, 0.0, 100.0)], 5.0, 2.0, false);
    assert!(!corner[0].elements().iter().any(|e| matches!(e, PathEl::CurveTo(..))));
}

// ---------------------------------------------------------------- wiggle

#[test]
fn wiggle_is_deterministic_and_time_varying() {
    let s = [sq(0.0, 0.0, 100.0)];
    let w = WiggleParams::default();
    let a = wiggle(&s, &w, 0.5);
    assert_eq!(a, wiggle(&s, &w, 0.5));
    assert_ne!(a, wiggle(&s, &w, 0.75));
    assert_ne!(a, wiggle(&s, &WiggleParams { seed: 3.0, ..w }, 0.5));
    // Phase of 360° = one wiggle period at speed 1: same as advancing time by one second.
    let w1 = WiggleParams { speed: 1.0, ..w };
    assert_eq!(wiggle(&s, &WiggleParams { phase_deg: 360.0, ..w1 }, 0.25), wiggle(&s, &w1, 1.25));
    assert_eq!(vertex_count(&a[0]), 4 * 11);
}

#[test]
fn wiggle_survives_an_absurd_speed_or_time() {
    // `t` far past i64 saturates the lattice index at i64::MAX, and the neighbours' `+ 1`, `+ 2` used to overflow.
    let s = [sq(0.0, 0.0, 100.0)];
    for v in [f64::INFINITY, f64::NEG_INFINITY, f64::NAN, f64::MAX, f64::MIN, 1e300, 9.3e18] {
        let by_speed = wiggle(&s, &WiggleParams { speed: v, ..Default::default() }, 1.0);
        let by_time = wiggle(&s, &WiggleParams::default(), v);
        let by_phase = wiggle(&s, &WiggleParams { phase_deg: v, ..Default::default() }, 0.0);
        assert_eq!((by_speed.len(), by_time.len(), by_phase.len()), (1, 1, 1), "wiggle with {v}");
    }
}

#[test]
fn wiggle_displacement_is_bounded() {
    let mut l = BezPath::new();
    l.move_to((0.0, 0.0));
    l.line_to((1000.0, 0.0));
    let w = WiggleParams { size: 7.0, detail: 50.0, smooth: false, ..Default::default() };
    for t in [0.0, 0.3, 1.7, 9.1] {
        let r = wiggle(std::slice::from_ref(&l), &w, t);
        let pts = on_curve(&r[0]);
        assert_eq!(pts.len(), 52);
        assert!(pts.iter().all(|p| p.y.abs() <= 7.0 * 1.0001));
        assert!(pts.iter().any(|p| p.y.abs() > 0.1));
    }
}

#[test]
fn wiggle_full_correlation_translates() {
    let s = [sq(0.0, 0.0, 100.0)];
    let w = WiggleParams { correlation: 100.0, smooth: false, ..Default::default() };
    let r = wiggle(&s, &w, 0.4);
    assert!(close(area(&r), 10000.0, 1e-6));
    let zero = wiggle(&s, &WiggleParams { size: 0.0, ..w }, 1.0);
    assert_eq!(zero[0], s[0]);
}

/// Spatial Phase moves the pattern of displacements along the path: 360° is once around, and a
/// whole number of points' worth gives each point the displacement of the point that far ahead.
#[test]
fn wiggle_spatial_phase_moves_the_pattern_along_the_path() {
    let s = [sq(0.0, 0.0, 100.0)];
    let w = WiggleParams { detail: 3.0, correlation: 0.0, smooth: false, ..Default::default() };
    // Displacements are proportional to Size: twice the size less once the size.
    let disp = |w: WiggleParams| -> Vec<Vec2> {
        let a = on_curve(&wiggle(&s, &w, 0.4)[0]);
        let b = on_curve(&wiggle(&s, &WiggleParams { size: w.size * 2.0, ..w }, 0.4)[0]);
        a.iter().zip(&b).map(|(a, b)| *b - *a).take(16).collect()
    };
    let d0 = disp(w);
    let n = d0.len();
    assert_eq!(n, 16);
    for k in [1, 5] {
        let dk = disp(WiggleParams { spatial_phase_deg: 360.0 * k as f64 / n as f64, ..w });
        for j in 0..n {
            let e = d0[(j + k) % n];
            assert!(close(dk[j].x, e.x, 1e-9) && close(dk[j].y, e.y, 1e-9), "{k} ahead, point {j}: {:?} vs {e:?}", dk[j]);
        }
    }
    // Whole turns either way leave the path as it is.
    let base = wiggle(&s, &w, 0.4);
    assert_eq!(wiggle(&s, &WiggleParams { spatial_phase_deg: 360.0, ..w }, 0.4), base);
    assert_eq!(wiggle(&s, &WiggleParams { spatial_phase_deg: -720.0, ..w }, 0.4), base);
    // Half a point ahead, the displacements change and stay within Size.
    let half = disp(WiggleParams { spatial_phase_deg: 180.0 / n as f64, ..w });
    assert!(half.iter().zip(&d0).any(|(h, d)| (*h - *d).hypot() > 1e-3));
    assert!(half.iter().all(|h| h.x.abs() <= 10.0 + 1e-9 && h.y.abs() <= 10.0 + 1e-9));
}

// ---------------------------------------------------------------- merge / booleans

fn inclusion_exclusion(a: BezPath, b: BezPath) {
    let aa = area(std::slice::from_ref(&a));
    let ab = area(std::slice::from_ref(&b));
    let pair = [a, b];
    let u = area(&[merge(&pair, MergeMode::Add)]);
    let i = area(&[merge(&pair, MergeMode::Intersect)]);
    let s = area(&[merge(&pair, MergeMode::Subtract)]);
    let x = area(&[merge(&pair, MergeMode::Exclude)]);
    let tol = 1e-3 * (aa + ab);
    assert!(i > 1.0, "overlapping");
    assert!(close(u, aa + ab - i, tol), "union {u} vs {aa}+{ab}-{i}");
    assert!(close(s, aa - i, tol), "subtract {s}");
    assert!(close(x, u - i, tol), "exclude {x}");
}

#[test]
fn merge_rects_inclusion_exclusion() {
    inclusion_exclusion(sq(0.0, 0.0, 100.0), sq(50.0, 30.0, 100.0));
    let i = merge(&[sq(0.0, 0.0, 100.0), sq(50.0, 30.0, 100.0)], MergeMode::Intersect);
    assert!(close(area(&[i]), 50.0 * 70.0, 1e-6));
}

#[test]
fn merge_circles_inclusion_exclusion() {
    inclusion_exclusion(circle(0.0, 0.0, 50.0), circle(40.0, 10.0, 35.0));
    // Curves are preserved: the union of two circles has few vertices.
    let u = merge(&[circle(0.0, 0.0, 50.0), circle(40.0, 10.0, 35.0)], MergeMode::Add);
    assert!(vertex_count(&u) < 20, "{}", vertex_count(&u));
}

#[test]
fn merge_modes_edge_cases() {
    let a = sq(0.0, 0.0, 10.0);
    let b = sq(100.0, 0.0, 10.0);
    assert!(area(&[merge(&[a.clone(), b.clone()], MergeMode::Intersect)]) < 1e-9);
    assert!(close(area(&[merge(&[a.clone(), b.clone()], MergeMode::Add)]), 200.0, 1e-6));
    let m = merge(&[a.clone(), b.clone()], MergeMode::Merge);
    assert_eq!(m.elements().len(), a.elements().len() + b.elements().len());
    // Subtract with three operands: first minus the rest.
    let s = merge(&[sq(0.0, 0.0, 100.0), sq(0.0, 0.0, 50.0), sq(50.0, 50.0, 50.0)], MergeMode::Subtract);
    assert!(close(area(&[s]), 5000.0, 1e-6));
    assert!(merge(&[], MergeMode::Add).elements().is_empty());
}

#[test]
fn normalize_and_filled_area() {
    // Two same-direction overlapping squares in one path: non-zero fills the union.
    let mut p = sq(0.0, 0.0, 100.0);
    p.extend(sq(50.0, 0.0, 100.0).elements().iter().copied());
    assert!(close(crate::boolean::filled_area(&p, FillRule::NonZero), 15000.0, 1e-6));
    assert!(close(crate::boolean::filled_area(&p, FillRule::EvenOdd), 10000.0, 1e-6));
    let n = crate::boolean::normalize(&p, FillRule::EvenOdd);
    assert!(close(n.area().abs(), 10000.0, 1e-6));
}

// ---------------------------------------------------------------- operator budget

#[test]
fn stacked_expanding_operators_stay_within_the_segment_budget() {
    // Three Zig Zags at 1000 ridges would turn a square into 4 · 1001³ segments; each output
    // is held to the budget instead, and the last operators still pass the geometry through.
    let mut p = vec![sq(0.0, 0.0, 100.0)];
    for _ in 0..3 {
        p = zigzag(&p, 1.0, 1000.0, false);
        let n: usize = p.iter().map(|q| q.elements().len()).sum();
        assert!(n <= 2 * MAX_OPERATOR_SEGMENTS, "{n}");
    }
    let w = wiggle(&p, &WiggleParams { detail: 1000.0, ..Default::default() }, 0.0);
    let n: usize = w.iter().map(|q| q.elements().len()).sum();
    assert!(n <= 2 * MAX_OPERATOR_SEGMENTS, "{n}");
    let o = offset(&[sq(0.0, 0.0, 100.0)], 1.0, Join::Miter, 4.0, 1000.0, 0.0);
    assert!(!o[0].elements().is_empty());
    // Within the budget nothing changes: 4 segments × 11 pieces.
    assert_eq!(vertex_count(&zigzag(&[sq(0.0, 0.0, 100.0)], 1.0, 10.0, false)[0]), 44);
}

#[test]
fn many_short_open_paths_keep_their_requested_detail_within_the_budget() {
    // 1000 open lines at 1000 ridges: 1,001,000 segments fit the budget, so nothing is reduced.
    let lines: Vec<BezPath> = (0..1000)
        .map(|i| {
            let mut p = BezPath::new();
            p.move_to((0.0, i as f64));
            p.line_to((100.0, i as f64));
            p
        })
        .collect();
    let z = zigzag(&lines, 1.0, 1000.0, false);
    assert!(z.iter().all(|q| q.elements().len() == 1 + 1001));
}

#[test]
fn open_subpaths_reserve_one_element_of_overhead() {
    // 349,525 open lines: the move-to is the only extra element, so 2 copies fit the budget
    // (a closed subpath's extra close-path would leave room for 1).
    let line = BezPath::from_vec(vec![PathEl::MoveTo((0.0, 0.0).into()), PathEl::LineTo((1.0, 0.0).into())]);
    let lines = vec![line; 349_525];
    assert_eq!(pieces_within_budget(&lines, 3), 2);
}