SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
//! Profile library tests. Expected values are worked out by hand: rectangles and circles, and
//! composite rectangles by the parallel-axis theorem; each fillet adds or removes a spandrel of
//! (1 − π/4) r².
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
use std::f64::consts::PI;
const SPANDREL: f64 = 1.0 - PI / 4.0;
fn close(got: f64, want: f64, what: &str) {
let tol = 1e-9 * (1.0 + want.abs());
assert!((got - want).abs() <= tol, "{what}: got {got}, want {want}");
}
fn profile(json: serde_json::Value) -> Profile {
serde_json::from_value(json).unwrap()
}
fn sec(p: &Profile) -> Section {
let r = p.region().unwrap();
assert!(r.outer.is_closed(1e-9), "{} outline is closed", p.kind());
assert!(r.outer.is_ccw(), "{} outline runs counter-clockwise", p.kind());
for h in &r.holes {
assert!(h.is_closed(1e-9) && !h.is_ccw(), "{} holes are closed and clockwise", p.kind());
}
// The exact boundary integral agrees with the region's own area.
let s = section(&r);
close(s.area, r.area(), "area against Region2::area");
s
}
/// Area, centroid (in the profile's centred frame) and centroidal Ixx, Iyy of rectangles
/// given as (x0, y0, x1, y1), combined.
fn rects(parts: &[(f64, f64, f64, f64)]) -> (f64, f64, f64, f64, f64) {
let a: f64 = parts.iter().map(|&(x0, y0, x1, y1)| (x1 - x0) * (y1 - y0)).sum();
let cx = parts.iter().map(|&(x0, y0, x1, y1)| (x1 - x0) * (y1 - y0) * (x0 + x1) / 2.0).sum::<f64>() / a;
let cy = parts.iter().map(|&(x0, y0, x1, y1)| (x1 - x0) * (y1 - y0) * (y0 + y1) / 2.0).sum::<f64>() / a;
let ixx = parts
.iter()
.map(|&(x0, y0, x1, y1)| {
let (b, h) = (x1 - x0, y1 - y0);
b * h * h * h / 12.0 + b * h * ((y0 + y1) / 2.0 - cy).powi(2)
})
.sum();
let iyy = parts
.iter()
.map(|&(x0, y0, x1, y1)| {
let (b, h) = (x1 - x0, y1 - y0);
h * b * b * b / 12.0 + b * h * ((x0 + x1) / 2.0 - cx).powi(2)
})
.sum();
(a, cx, cy, ixx, iyy)
}
fn check_rects(s: &Section, parts: &[(f64, f64, f64, f64)], what: &str) {
let (a, cx, cy, ixx, iyy) = rects(parts);
close(s.area, a, &format!("{what} area"));
close(s.centroid[0], cx, &format!("{what} centroid x"));
close(s.centroid[1], cy, &format!("{what} centroid y"));
close(s.ixx, ixx, &format!("{what} Ixx"));
close(s.iyy, iyy, &format!("{what} Iyy"));
}
#[test]
fn bar_is_a_rectangle() {
let s = sec(&profile(serde_json::json!({"kind": "bar", "width": 40, "height": 10})));
close(s.area, 400.0, "area");
close(s.ixx, 40.0 * 1000.0 / 12.0, "Ixx = b h³ / 12");
close(s.iyy, 10.0 * 64_000.0 / 12.0, "Iyy = h b³ / 12");
close(s.ixy, 0.0, "Ixy");
close(s.width, 40.0, "width");
close(s.height, 10.0, "height");
}
#[test]
fn rounded_bar_loses_four_spandrels() {
let s = sec(&profile(serde_json::json!({"kind": "bar", "width": 30, "height": 20, "corner_radius": 4})));
close(s.area, 600.0 - 4.0 * SPANDREL * 16.0, "area");
// Fully rounded: a 20 × 20 bar with radius 10 is a circle.
let s = sec(&profile(serde_json::json!({"kind": "bar", "width": 20, "height": 20, "corner_radius": 10})));
close(s.area, PI * 100.0, "fully rounded area");
close(s.ixx, PI * 10f64.powi(4) / 4.0, "fully rounded Ixx");
}
#[test]
fn round_bar_and_tube() {
let s = sec(&Profile::RoundBar { diameter: 20.0 });
close(s.area, PI * 100.0, "bar area");
close(s.ixx, PI * 20f64.powi(4) / 64.0, "bar Ixx = π d⁴ / 64");
close(s.iyy, s.ixx, "bar Iyy");
let s = sec(&Profile::RoundTube { diameter: 42.4, wall: 3.2 });
let d = 42.4 - 6.4;
close(s.area, PI / 4.0 * (42.4f64.powi(2) - d * d), "tube area");
close(s.ixx, PI / 64.0 * (42.4f64.powi(4) - d.powi(4)), "tube Ixx = π (D⁴ − d⁴) / 64");
}
#[test]
fn rect_tube_sharp_and_rounded() {
let s = sec(&profile(serde_json::json!({"kind": "rect_tube", "width": 60, "height": 40, "wall": 3, "outer_radius": 0})));
close(s.area, 60.0 * 40.0 - 54.0 * 34.0, "sharp area");
close(s.ixx, (60.0 * 40f64.powi(3) - 54.0 * 34f64.powi(3)) / 12.0, "sharp Ixx");
close(s.iyy, (40.0 * 60f64.powi(3) - 34.0 * 54f64.powi(3)) / 12.0, "sharp Iyy");
// Defaults: outer radius 2 t = 6, inner radius 3.
let p = profile(serde_json::json!({"kind": "rect_tube", "width": 40, "height": 40, "wall": 3}));
assert_eq!(p.filled(), Profile::RectTube { width: 40.0, height: 40.0, wall: 3.0, outer_radius: Some(6.0) });
let s = sec(&p);
let outer = 1600.0 - 4.0 * SPANDREL * 36.0;
let inner = 34.0 * 34.0 - 4.0 * SPANDREL * 9.0;
close(s.area, outer - inner, "rounded area");
close(s.centroid[0], 0.0, "centroid x");
close(s.ixy, 0.0, "Ixy");
}
#[test]
fn angle_sharp_matches_two_rectangles() {
let (a, b, t) = (60.0, 40.0, 5.0);
let s = sec(&profile(serde_json::json!({"kind": "angle", "width": a, "height": b, "thickness": t, "root_radius": 0, "toe_radius": 0})));
let (x0, y0) = (-a / 2.0, -b / 2.0);
check_rects(&s, &[(x0, y0, x0 + a, y0 + t), (x0, y0 + t, x0 + t, y0 + b)], "angle");
assert!(s.ixy.abs() > 1.0, "an unequal angle has a product of inertia");
}
#[test]
fn angle_root_adds_and_toes_remove_spandrels() {
let (a, b, t) = (50.0, 50.0, 5.0);
let p = profile(serde_json::json!({"kind": "angle", "width": a, "height": b, "thickness": t}));
let s = sec(&p);
// Defaults: root radius t, toe radius t / 2.
close(s.area, t * (a + b - t) + SPANDREL * t * t - 2.0 * SPANDREL * (t / 2.0).powi(2), "area");
// An equal angle is symmetric about its diagonal.
close(s.centroid[0], s.centroid[1], "centroid on the diagonal");
close(s.ixx, s.iyy, "Ixx = Iyy");
}
#[test]
fn channel_and_i_beam_sharp_match_rectangles() {
let (h, b, tw, tf) = (100.0, 50.0, 6.0, 8.0);
let s = sec(&profile(serde_json::json!({"kind": "channel", "height": h, "width": b, "web": tw, "flange": tf, "root_radius": 0})));
let (x0, y0) = (-b / 2.0, -h / 2.0);
let parts = [(x0, y0, x0 + b, y0 + tf), (x0, y0 + tf, x0 + tw, y0 + h - tf), (x0, y0 + h - tf, x0 + b, y0 + h)];
check_rects(&s, &parts, "channel");
close(s.ixy, 0.0, "channel Ixy");
let (h, b, tw, tf) = (100.0, 50.0, 4.5, 7.0);
let s = sec(&profile(serde_json::json!({"kind": "i_beam", "height": h, "width": b, "web": tw, "flange": tf, "root_radius": 0})));
close(s.area, 2.0 * b * tf + (h - 2.0 * tf) * tw, "I area");
close(s.ixx, (b * h.powi(3) - (b - tw) * (h - 2.0 * tf).powi(3)) / 12.0, "I Ixx");
close(s.iyy, (2.0 * tf * b.powi(3) + (h - 2.0 * tf) * tw.powi(3)) / 12.0, "I Iyy");
}
#[test]
fn i_beam_root_radii_add_four_spandrels() {
let (h, b, tw, tf, r) = (100.0, 50.0, 4.5, 7.0, 7.0);
let s = sec(&profile(serde_json::json!({"kind": "i_beam", "height": h, "width": b, "web": tw, "flange": tf, "root_radius": r})));
close(s.area, 2.0 * b * tf + (h - 2.0 * tf) * tw + 4.0 * SPANDREL * r * r, "area");
close(s.centroid[0], 0.0, "centroid x");
close(s.centroid[1], 0.0, "centroid y");
}
#[test]
fn every_kind_example_builds() {
for k in profile_kinds() {
assert_eq!(k.example.kind(), k.kind);
let s = sec(&k.example);
assert!(s.area > 0.0 && s.ixx > 0.0 && s.iyy > 0.0, "{}: {s:?}", k.kind);
let (w, h) = k.example.size();
close(s.width, w, &format!("{} width", k.kind));
close(s.height, h, &format!("{} height", k.kind));
}
}
#[test]
fn dimensions_that_do_not_fit_are_refused() {
let bad = [
serde_json::json!({"kind": "bar", "width": f64::MAX, "height": 1}),
serde_json::json!({"kind": "bar", "width": -1, "height": 1}),
serde_json::json!({"kind": "bar", "width": 0, "height": 1}),
serde_json::json!({"kind": "bar", "width": 10, "height": 10, "corner_radius": 6}),
serde_json::json!({"kind": "round_bar", "diameter": 1e300}),
serde_json::json!({"kind": "rect_tube", "width": 10, "height": 10, "wall": 5}),
serde_json::json!({"kind": "rect_tube", "width": 10, "height": 10, "wall": 1, "outer_radius": -1}),
serde_json::json!({"kind": "round_tube", "diameter": 10, "wall": 5}),
serde_json::json!({"kind": "angle", "width": 10, "height": 10, "thickness": 10}),
serde_json::json!({"kind": "angle", "width": 10, "height": 10, "thickness": 2, "root_radius": 9}),
serde_json::json!({"kind": "angle", "width": 10, "height": 10, "thickness": 2, "toe_radius": 3}),
serde_json::json!({"kind": "channel", "height": 10, "width": 10, "web": 2, "flange": 5}),
serde_json::json!({"kind": "channel", "height": 10, "width": 10, "web": 10, "flange": 2}),
serde_json::json!({"kind": "i_beam", "height": 100, "width": 50, "web": 5, "flange": 7, "root_radius": 30}),
];
for j in bad {
let p: Profile = serde_json::from_value(j.clone()).unwrap();
assert!(p.region().is_err(), "{j} is refused");
}
for j in [
serde_json::json!({"kind": "bar", "width": 1}),
serde_json::json!({"kind": "bar", "width": 1, "height": 1, "colour": 2}),
serde_json::json!({"kind": "hexagon"}),
] {
assert!(serde_json::from_value::<Profile>(j.clone()).is_err(), "{j} is not a profile");
}
}
#[test]
fn non_finite_dimensions_are_refused() {
for v in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
assert!(Profile::RoundBar { diameter: v }.region().is_err());
assert!(Profile::RectTube { width: 40.0, height: 40.0, wall: 3.0, outer_radius: Some(v) }.region().is_err());
}
}
#[test]
fn placing_moves_the_anchor_onto_the_point() {
let p = profile(serde_json::json!({"kind": "angle", "width": 60, "height": 40, "thickness": 5}));
let r = p.region().unwrap();
let s0 = section(&r);
let anchor = anchor_point(std::slice::from_ref(&r), Anchor::BottomLeft);
close(anchor.x, -30.0, "bottom left x");
close(anchor.y, -20.0, "bottom left y");
let at = Vec2::new(100.0, 50.0);
let moved = placed(&r, anchor, at, PI / 2.0);
let s1 = section(&moved);
close(s1.area, s0.area, "area is kept");
// Turned a quarter: the heel stays on `at`, the 60 mm leg now runs up and the 40 mm one left.
close(s1.width, 40.0, "turned width");
close(s1.height, 60.0, "turned height");
let c = at + Vec2::new(-(s0.centroid[1] + 20.0), s0.centroid[0] + 30.0);
close(s1.centroid[0], c.x, "centroid x");
close(s1.centroid[1], c.y, "centroid y");
close(s1.ixx, s0.iyy, "Ixx after a quarter turn");
let centre = anchor_point(std::slice::from_ref(&r), Anchor::Centroid);
let s2 = section(&placed(&r, centre, Vec2::ZERO, 0.0));
close(s2.centroid[0], 0.0, "centroid anchor x");
close(s2.centroid[1], 0.0, "centroid anchor y");
}
#[test]
fn member_axes_are_square_to_the_line_and_keep_up() {
for d in [Vec3::X, Vec3::new(0.0, -3.0, 0.0), Vec3::new(1.0, 2.0, 3.0), Vec3::Z, Vec3::new(0.0, 0.0, -2.0), Vec3::new(1e-12, 0.0, 1.0)] {
for angle in [0.0, 0.3, -PI / 2.0] {
let (x, y) = member_axes(d, angle).unwrap();
let n = d.normalized().unwrap();
close(x.len(), 1.0, "|x|");
close(y.len(), 1.0, "|y|");
close(x.dot(y), 0.0, "x ⟂ y");
close(x.cross(y).dist(n), 0.0, "x × y runs along the line");
}
}
// Unturned: a horizontal member's y is world up; a vertical one's x is world X.
let (_, y) = member_axes(Vec3::new(1.0, 1.0, 0.0), 0.0).unwrap();
close(y.dist(Vec3::Z), 0.0, "horizontal y");
let (x, _) = member_axes(Vec3::Z, 0.0).unwrap();
close(x.dist(Vec3::X), 0.0, "vertical x");
let (x, _) = member_axes(Vec3::new(0.0, 0.0, -1.0), 0.0).unwrap();
close(x.dist(Vec3::X), 0.0, "downward x");
// A quarter turn takes x to where y was.
let (_, y0) = member_axes(Vec3::X, 0.0).unwrap();
let (x1, _) = member_axes(Vec3::X, PI / 2.0).unwrap();
close(x1.dist(y0), 0.0, "quarter turn");
assert!(member_axes(Vec3::ZERO, 0.0).is_none());
}
#[test]
fn mirroring_keeps_the_section_and_flips_x() {
let p = profile(serde_json::json!({"kind": "angle", "width": 60, "height": 40, "thickness": 5}));
let r = p.region().unwrap();
let m = mirrored(&r);
assert!(m.outer.is_ccw() && m.outer.is_closed(1e-9), "the outline still runs counter-clockwise");
let (a, b) = (section(&r), section(&m));
close(b.area, a.area, "area");
close(b.centroid[0], -a.centroid[0], "centroid x");
close(b.centroid[1], a.centroid[1], "centroid y");
close(b.ixy, -a.ixy, "Ixy changes sign");
let tube = mirrored(&profile(serde_json::json!({"kind": "rect_tube", "width": 40, "height": 20, "wall": 2})).region().unwrap());
assert!(tube.holes.iter().all(|h| !h.is_ccw()), "holes still run clockwise");
}
#[test]
fn anchors_of_an_off_centre_region() {
// A sketch profile need not be centred: a 10 × 20 box from (5, 5).
let r = Region2 {
outer: Loop2::polygon(&[Vec2::new(5.0, 5.0), Vec2::new(15.0, 5.0), Vec2::new(15.0, 25.0), Vec2::new(5.0, 25.0)]),
holes: Vec::new(),
};
let at = |a| anchor_point(std::slice::from_ref(&r), a);
assert_eq!(at(Anchor::Origin), Vec2::ZERO);
assert_eq!(at(Anchor::Center), Vec2::new(10.0, 15.0));
assert_eq!(at(Anchor::BottomLeft), Vec2::new(5.0, 5.0));
assert_eq!(at(Anchor::TopRight), Vec2::new(15.0, 25.0));
assert_eq!(at(Anchor::Left), Vec2::new(5.0, 15.0));
let c = at(Anchor::Centroid);
close(c.x, 10.0, "centroid x");
close(c.y, 15.0, "centroid y");
}
#[test]
fn default_radii_shrink_to_fit_thick_sections() {
// Each of these failed with the defaults at their usual size (#4003 review).
for j in [
serde_json::json!({"kind": "angle", "width": 20, "height": 20, "thickness": 10}),
serde_json::json!({"kind": "channel", "height": 50, "width": 10, "web": 6, "flange": 2}),
serde_json::json!({"kind": "channel", "height": 20, "width": 40, "web": 5, "flange": 8}),
serde_json::json!({"kind": "i_beam", "height": 100, "width": 10, "web": 6, "flange": 5}),
] {
let p = profile(j.clone());
let s = sec(&p);
assert!(s.area > 0.0, "{j}");
}
// A 20 × 20 × 10 angle has 10 mm of leg inside: root and toe keep their 2 : 1 ratio.
let Profile::Angle { root_radius: Some(r1), toe_radius: Some(r2), .. } =
profile(serde_json::json!({"kind": "angle", "width": 20, "height": 20, "thickness": 10})).filled()
else {
panic!("an angle")
};
close(r1, 20.0 / 3.0, "root");
close(r2, 10.0 / 3.0, "toe");
// One given, the other default takes what is left.
let Profile::Angle { toe_radius: Some(r2), .. } =
profile(serde_json::json!({"kind": "angle", "width": 20, "height": 20, "thickness": 10, "root_radius": 8})).filled()
else {
panic!("an angle")
};
close(r2, 2.0, "toe after an 8 mm root");
// A channel 20 tall with 8 mm flanges has 4 mm of web inside: two roots of 2.
let Profile::Channel { root_radius: Some(r1), .. } =
profile(serde_json::json!({"kind": "channel", "height": 20, "width": 40, "web": 5, "flange": 8})).filled()
else {
panic!("a channel")
};
close(r1, 2.0, "channel root");
// Defaults that fit are left as they are.
assert_eq!(
profile(serde_json::json!({"kind": "angle", "width": 50, "height": 50, "thickness": 5})).filled(),
Profile::Angle { width: 50.0, height: 50.0, thickness: 5.0, root_radius: Some(5.0), toe_radius: Some(2.5) }
);
}
#[test]
fn radii_given_too_large_or_too_small_are_refused_by_name() {
for (j, name) in [
(serde_json::json!({"kind": "angle", "width": 20, "height": 20, "thickness": 10, "toe_radius": 11}), "toe_radius"),
(serde_json::json!({"kind": "angle", "width": 20, "height": 20, "thickness": 10, "root_radius": 9, "toe_radius": 2}), "root_radius"),
(serde_json::json!({"kind": "channel", "height": 20, "width": 40, "web": 5, "flange": 8, "root_radius": 3}), "root_radius"),
(serde_json::json!({"kind": "i_beam", "height": 100, "width": 10, "web": 6, "flange": 5, "root_radius": 3}), "root_radius"),
(serde_json::json!({"kind": "rect_tube", "width": 40, "height": 40, "wall": 3, "outer_radius": 1e-12}), "outer_radius"),
(serde_json::json!({"kind": "bar", "width": 40, "height": 10, "corner_radius": 0.001}), "corner_radius"),
] {
let err = profile(j.clone()).region().unwrap_err().to_string();
assert!(err.contains(name), "{j}: {err}");
}
// The value named is the one given, not twice it.
let err = profile(serde_json::json!({"kind": "rect_tube", "width": 10, "height": 10, "wall": 5})).region().unwrap_err().to_string();
assert!(err.contains("`wall` (5)") && err.contains("half the smaller side (5)"), "{err}");
let err = profile(serde_json::json!({"kind": "channel", "height": 10, "width": 10, "web": 2, "flange": 5})).region().unwrap_err().to_string();
assert!(err.contains("`flange` (5)"), "{err}");
}
#[test]
fn a_spec_holds_expressions_and_resolves_them() {
let spec: ProfileSpec = serde_json::from_value(serde_json::json!({"kind": "rect_tube", "width": 40, "height": "H", "wall": "2 * t"})).unwrap();
assert_eq!(spec.dims.get("width").map(|e| e.as_str()), Some("40"));
// Saved as one object of text.
assert_eq!(serde_json::to_value(&spec).unwrap(), serde_json::json!({"kind": "rect_tube", "width": "40", "height": "H", "wall": "2 * t"}));
let p = spec
.resolve(|_, e| match e.as_str() {
"40" => Ok(40.0),
"H" => Ok(60.0),
"2 * t" => Ok(3.0),
other => Err(crate::DocError::Invalid(other.into())),
})
.unwrap();
assert_eq!(p, Profile::RectTube { width: 40.0, height: 60.0, wall: 3.0, outer_radius: None });
// A value that is not a finite length is refused, naming the dimension.
let err = spec.resolve(|name, _| Ok(if name == "wall" { f64::NAN } else { 40.0 })).unwrap_err().to_string();
assert!(err.contains("wall"), "{err}");
let mut labels = Vec::new();
crate::walk::Walk::walk_exprs(&spec, &mut |(label, e, kind, _)| labels.push((label, e.as_str().to_string(), kind)));
assert_eq!(labels, [("Height", "H".into(), Kind::Length), ("Wall", "2 * t".into(), Kind::Length), ("Width", "40".into(), Kind::Length)]);
for (j, why) in [
(serde_json::json!({"width": 40}), "kind"),
(serde_json::json!({"kind": "hexagon", "width": 40}), "unknown profile kind"),
(serde_json::json!({"kind": "round_bar"}), "needs `diameter`"),
(serde_json::json!({"kind": "round_bar", "diameter": 10, "colour": 2}), "no dimension `colour`"),
(serde_json::json!({"kind": "round_bar", "diameter": true}), "number or an expression"),
(serde_json::json!({"kind": "round_bar", "diameter": " "}), "number or an expression"),
(serde_json::json!({"kind": "round_bar", "diameter": "x".repeat(5000)}), "number or an expression"),
] {
let err = serde_json::from_value::<ProfileSpec>(j.clone()).unwrap_err().to_string();
assert!(err.contains(why), "{j}: {err}");
}
}
#[test]
fn descriptions_round_to_a_tenth_of_a_micron() {
let p = Profile::RectTube { width: 25.4, height: 25.4, wall: 0.125 * 25.4, outer_radius: None };
assert_eq!(p.description(), "Rect Tube 25.4x25.4x3.175");
assert_eq!(Profile::RoundBar { diameter: 1.0 / 3.0 }.description(), "Round Bar 0.3333");
}
#[test]
fn a_line_a_hair_off_vertical_is_vertical() {
// Rounding noise must not turn a post a quarter turn (#4003 review).
let (x0, _) = member_axes(Vec3::Z, 0.0).unwrap();
for lean in [1e-8, -1e-8, 1e-12] {
let (x, _) = member_axes(Vec3::new(lean, 0.0, 1.0), 0.0).unwrap();
close(x.dist(x0), 0.0, "near-vertical x");
let (x, _) = member_axes(Vec3::new(0.0, lean, 1.0), 0.0).unwrap();
close(x.dist(x0), 0.0, "near-vertical x");
}
// A lean you can see is a lean: its y tips toward up.
let (_, y) = member_axes(Vec3::new(1e-3, 0.0, 1.0), 0.0).unwrap();
assert!(y.z > 0.0 && y.x < 0.0, "{y:?}");
}