Pin analytic robustness and edge-contact scale regressions (#1950)

* test: pin analytic robustness and edge-contact scale regressions

* test: freeze patterned-bore reference after body grouping change
This commit is contained in:
cronos
2026-10-20 05:05:00 +09:00
committed by GitHub
parent 45d0b6053b
commit bd4eb42c2d
3 changed files with 140 additions and 15 deletions
+80
View File
@@ -440,3 +440,83 @@ pub fn minimise(run: &Run) -> Run {
}
Run { seed: run.seed, steps, outcome, unsupported: Vec::new(), rejected: 0, boolean_fallbacks, boolean_reports_truncated }
}
#[cfg(test)]
mod tests {
use std::collections::BTreeMap;
use super::*;
#[allow(clippy::expect_used)]
fn body_measures(s: &Session) -> Vec<solidcraft_kernel::BodyMeasure> {
s.model.state().bodies.iter().map(|b| solidcraft_kernel::measure(&b.body).expect("measure a valid body")).collect()
}
fn seed_measures(seed: u64) -> Vec<solidcraft_kernel::BodyMeasure> {
let (run, s) = run_session(seed, 8, &mut |_| {});
assert_eq!(run.outcome.kind, "ok", "seed {seed}: {:?}", run.outcome);
body_measures(&s)
}
/// Seed 34: a quarter cylinder R15 x 12.5, a spherical bite R2.5 centred
/// at (10, 12.5, 0), and an independent R2 x 5 blind drill with a 118° tip.
/// The circular-lens surface/volume integrals give these references
/// independently of the B-rep and its measurement tessellation (docs/robustness.md).
#[test]
fn a_spherical_bite_and_blind_drill_match_the_analytic_solid() {
let measured = seed_measures(34);
assert_eq!(measured.len(), 1);
let m = &measured[0];
for (name, got, want) in [("volume", m.volume, 2_134.404_133), ("area", m.area, 1_086.316_691)] {
// measure uses a chordal mesh with a 5e-5 relative chord tolerance.
assert!((got - want).abs() <= 5e-5 * want, "{name}: {got} versus analytic {want}");
}
assert_eq!(m.merged.face_types, BTreeMap::from([("cone".into(), 1), ("cylinder".into(), 2), ("plane".into(), 4), ("sphere".into(), 1)]));
}
/// The recorded seed-67 design: a notched extrusion with bores and a boss,
/// and a chamfered block with a patterned bore. Freeze the commands because
/// retaining disconnected shells in one body (#2247) changes later generator picks.
/// Redundant raw subdivisions must preserve the original analytic surface inventory.
#[test]
fn a_patterned_bore_preserves_the_analytic_surfaces() {
let commands = [
("sketch.create", json!({"plane":"XY"})),
("sketch.line", json!({"points":[[0,0],[30.0,0],[30.0,32.5],[17.5,32.5],[17.5,17.5],[10.0,17.5],[10.0,32.5],[0,32.5]]})),
("sketch.arc.three_point", json!({"end":[0,0],"start":[0,32.5],"through":[-15.0,16.25]})),
("sketch.finish", json!({})),
("solid.extrude", json!({"distance":20.0})),
("solid.cylinder", json!({"axis":[0.0,0.0,-1.0],"base":[-0.0,0.0,20.00000000000001],"height":2.5,"operation":"cut","radius":6.25})),
("solid.hole", json!({"diameter":6.0,"position":[13.749999999999998,17.5,10.00000000000001]})),
("solid.cylinder", json!({"axis":[0.0,0.0,1.0],"base":[-5.0,12.5,2.5],"height":30.0,"operation":"join","radius":3.75})),
(
"solid.box",
json!({"corner":[-14.999881984669182,22.5,32.500000000000014],"height":20.0,"length":12.5,"operation":"join","width":12.5}),
),
("solid.hole", json!({"depth":12.5,"diameter":4.0,"position":[-8.749881984669182,28.75,32.500000000000014]})),
(
"solid.chamfer",
json!({"distance":0.5,"edges":[[-2.499881984669182,28.75,32.500000000000014],[-9.900529629797113,27.11414854074047,32.500000000000014],[-8.749881984669182,35.0,32.500000000000014]]}),
),
("solid.pattern.rectangular", json!({"count1":2,"dir1":[1.0,0.0,0.0],"features":["Hole2"],"spacing1":7.5})),
];
let mut s = Session::default();
for (command, params) in commands {
let result = s.execute(command, &params);
assert!(result.is_ok(), "{command}: {result:?}");
for body in &s.model.state().bodies {
assert!(body.body.validity().is_empty(), "{command}: {:?}", body.body.validity());
}
}
let measured = body_measures(&s);
assert_eq!(measured.len(), 1);
assert_eq!(measured.iter().map(|m| m.shells).sum::<usize>(), 2);
let mut kinds = BTreeMap::new();
for m in &measured {
for (kind, count) in &m.merged.face_types {
*kinds.entry(kind.clone()).or_insert(0) += count;
}
}
assert_eq!(kinds, BTreeMap::from([("cone".into(), 1), ("cylinder".into(), 6), ("plane".into(), 22)]));
}
}
+33 -15
View File
@@ -118,6 +118,25 @@ fn identity(a: &Prim, b: &Prim) -> Result<(), TestCaseError> {
Ok(())
}
fn scale(a: &Prim, b: &Prim, k: f64) -> Result<(), TestCaseError> {
let sc = |p: &Prim| match p.clone() {
Prim::Box { at, size } => Prim::Box { at: at.map(|x| x * k), size: size.map(|x| x * k) },
Prim::Cyl { at, axis, r, h } => Prim::Cyl { at: at.map(|x| x * k), axis, r: r * k, h: h * k },
Prim::Sph { at, r } => Prim::Sph { at: at.map(|x| x * k), r: r * k },
};
let (ba, bb, ka, kb) = (a.body(), b.body(), sc(a).body(), sc(b).body());
let s = vol(&ba) + vol(&bb);
for op in [BoolOp::Union, BoolOp::Intersect, BoolOp::Cut] {
let (one, big) = (run(&ba, &bb, op), run(&ka, &kb, op));
if edge_contact_refusal(a, b, op, &one) && edge_contact_refusal(a, b, op, &big) {
continue;
}
let (one, big) = (one?, big? / (k * k * k));
prop_assert!(close(one, big, s), "{op:?} at scale 1 gives {one:.4}, at scale {k} gives {big:.4} (normalised)");
}
Ok(())
}
fn cfg(default: u32) -> ProptestConfig {
// The env var overrides the default; proptest reads PROPTEST_CASES itself only when the
// config does not set `cases`, so read it here.
@@ -186,21 +205,7 @@ proptest! {
/// (40x) expose tolerances that do not scale.
#[test]
fn scale_invariant(a in grid_prim(), b in grid_prim(), k in prop::sample::select(vec![0.05, 1.0, 40.0])) {
let sc = |p: &Prim| match p.clone() {
Prim::Box { at, size } => Prim::Box { at: at.map(|x| x * k), size: size.map(|x| x * k) },
Prim::Cyl { at, axis, r, h } => Prim::Cyl { at: at.map(|x| x * k), axis, r: r * k, h: h * k },
Prim::Sph { at, r } => Prim::Sph { at: at.map(|x| x * k), r: r * k },
};
let (ba, bb, ka, kb) = (a.body(), b.body(), sc(&a).body(), sc(&b).body());
let s = vol(&ba) + vol(&bb);
for op in [BoolOp::Union, BoolOp::Intersect, BoolOp::Cut] {
let (one, big) = (run(&ba, &bb, op), run(&ka, &kb, op));
if edge_contact_refusal(&a, &b, op, &one) && edge_contact_refusal(&a, &b, op, &big) {
continue;
}
let (one, big) = (one?, big? / (k * k * k));
prop_assert!(close(one, big, s), "{op:?} at scale 1 gives {one:.4}, at scale {k} gives {big:.4} (normalised)");
}
scale(&a, &b, k)?;
}
/// A∪A = A, A∩A = A, A−A = nothing.
@@ -279,6 +284,19 @@ fn edge_only_box_join_is_refused_in_both_orders() {
}
}
/// The saved scale-invariance failure: these boxes meet at y=30, z=20 along an
/// edge, so a join is refused at every scale. Intersection and cut still scale.
#[test]
fn edge_only_box_contact_is_scale_invariant() {
let a = Prim::Box { at: [0.0, 15.0, 7.5], size: [7.5, 15.0, 12.5] };
let b = Prim::Box { at: [0.0, 30.0, 20.0], size: [5.0, 5.0, 5.0] };
assert!(edge_only_boxes(&a, &b));
for k in [0.05, 1.0, 40.0] {
check(scale(&a, &b, k));
check(scale(&b, &a, k));
}
}
fn check(r: Result<(), TestCaseError>) {
if let Err(e) = r {
panic!("{e}");
+27
View File
@@ -63,6 +63,33 @@ ROBUSTNESS_GOLDENS_BLESS="why it changed" cargo test --profile ci -p solidcraft-
The changed seeds and the reason are added to the file's `notes`; say why in the pull request too.
The generator feeds the current geometry's bounds and face/edge picks back into later
commands. The same RNG seed can therefore generate different command coordinates or picks
on different math libraries. The original inputs are retained, including near-contact cases.
Platform snapshots track repeatability; they do not certify cross-platform geometric
equivalence or resolve the numerical differences tracked in #924.
### Independent measurement checks
The seeded snapshots also have checks against geometric references. Seed 34 starts with a
quarter cylinder of radius 15 and height 12.5 (`x,y >= 0`, `-12.5 <= z <= 0`), cuts it with a
radius-2.5 sphere centred at (10, 12.5, 0), then drills an independent radius-2, depth-5 blind
hole from (0, 7.5, -6.25) along +X, with a 118-degree tip.
Subtracting the sphere/cylinder intersection and the drill gives **2134.404133 mm³** and
**1086.316691 mm²**. The drill has tip height `2 / tan(59 degrees)`; the spherical bite is
integrated over the intersection of the radius-15 disk and the sphere's projected radius-2.5
disk. Integrating the lower spherical hemisphere and the removed cylinder-wall patch gives
the surface reference. The test compares the chordal measurement with these independent
references at 5e-5 relative error.
A fixed command replay recorded from seed 67 checks two disconnected shells kept in one
body after a cut (#2247), with a combined analytic surface inventory of 22 planar, six
cylindrical and one conical face after merging redundant subdivisions. The commands are
fixed because the generator chooses later operations from the current body and edge layout;
changes to body grouping can therefore change the generated design. This preserves the
original geometric reference independently of those choices. These checks supplement the
snapshots' stricter repeatability comparisons of raw topology and tessellated measurements.
## Successful Boolean retries
When an accepted Boolean result needs a retry that can make it differ from the