//! The operations against analytic volumes and topology counts (built with SMLib only). `SMLIB_OPS_SHOTS=
` also
//! writes every result there as a native `.smb`, to render.
#![cfg(feature = "native")]
use super::*;
use crate::CheckLevel;
/// Relative accuracy of SMLib's volume integration in these tests.
const ACC: f64 = 1e-7;
fn cube(a: f64) -> Brep {
Brep::make_box([0.0; 3], [a; 3]).unwrap()
}
fn volume(b: &Brep) -> f64 {
b.volume(ACC).unwrap()
}
fn assert_close(got: f64, want: f64, rel: f64, what: &str) {
assert!((got - want).abs() <= rel * want.abs(), "{what}: {got} vs analytic {want} (rel {:.3e})", (got - want).abs() / want.abs());
}
/// SMLib's own check, every test, finds nothing wrong with `b`; then, when `SMLIB_OPS_SHOTS` is
/// set, `b` is written there as `.smb`.
fn shot(b: &Brep, name: &str) {
let report = b.check(CheckLevel::All).unwrap();
assert!(report.is_valid(), "{name}: {} failed validity tests:\n{}", report.failures, report.text);
if let Some(dir) = std::env::var_os("SMLIB_OPS_SHOTS") {
let dir = std::path::PathBuf::from(dir);
std::fs::create_dir_all(&dir).unwrap();
b.write(&dir.join(format!("{name}.smb")), false).unwrap();
}
}
/// The midpoints of the 12 edges of the cube [0, a]³.
fn cube_edge_midpoints(a: f64) -> Vec<[f64; 3]> {
let h = a / 2.0;
let mut v = Vec::new();
for (p, q) in [(0.0, 0.0), (a, 0.0), (0.0, a), (a, a)] {
v.push([h, p, q]);
v.push([p, h, q]);
v.push([p, q, h]);
}
v
}
/// The inputs of an operation are left as they were.
fn assert_untouched(b: &Brep, vol: f64, counts: [usize; 3]) {
assert_close(volume(b), vol, 1e-9, "input volume");
assert_eq!(b.counts().unwrap(), counts, "input counts");
}
#[test]
fn union_of_overlapping_boxes() {
let a = cube(20.0);
let b = Brep::make_box([10.0, 5.0, 5.0], [20.0, 10.0, 10.0]).unwrap();
let u = a.boolean(&b, BooleanOp::Union).unwrap().unwrap();
shot(&u, "union");
// 20³ + 20·10·10 − the 10·10·10 overlap.
assert_close(volume(&u), 9000.0, 1e-9, "union volume");
// A's 6 faces (+x now with a hole) and B's 5 outside it; A's 12 edges, B's 8 outside and the
// 4 where B passes through +x; A's 8 vertices and B's 8 outside.
assert_eq!(u.counts().unwrap(), [11, 24, 16]);
assert_eq!(u.solid_count().unwrap(), 1);
assert_untouched(&a, 8000.0, [6, 12, 8]);
assert_untouched(&b, 2000.0, [6, 12, 8]);
}
#[test]
fn subtract_cuts_a_slot() {
let a = cube(20.0);
// A 10 mm wide, 10 mm deep slot across the top, from y = −1 to 21.
let tool = Brep::make_box([5.0, -1.0, 10.0], [10.0, 22.0, 15.0]).unwrap();
let s = a.boolean(&tool, BooleanOp::Subtract).unwrap().unwrap();
shot(&s, "subtract_slot");
assert_close(volume(&s), 8000.0 - 10.0 * 20.0 * 10.0, 1e-9, "slot volume");
// A prism over a U of 8 corners: 8 sides + 2 ends, 24 edges, 16 vertices.
assert_eq!(s.counts().unwrap(), [10, 24, 16]);
assert_eq!(s.solid_count().unwrap(), 1);
assert_untouched(&a, 8000.0, [6, 12, 8]);
}
#[test]
fn intersect_keeps_the_overlap() {
let a = cube(20.0);
let b = Brep::make_box([10.0, 5.0, 5.0], [20.0, 10.0, 10.0]).unwrap();
let i = a.boolean(&b, BooleanOp::Intersect).unwrap().unwrap();
shot(&i, "intersect");
assert_close(volume(&i), 1000.0, 1e-9, "intersection volume");
assert_eq!(i.counts().unwrap(), [6, 12, 8]);
}
#[test]
fn empty_and_split_boolean_results() {
let a = cube(10.0);
let far = Brep::make_box([50.0, 0.0, 0.0], [10.0, 10.0, 10.0]).unwrap();
assert!(a.boolean(&far, BooleanOp::Intersect).unwrap().is_none(), "disjoint intersection");
let big = Brep::make_box([-5.0; 3], [20.0; 3]).unwrap();
assert!(a.boolean(&big, BooleanOp::Subtract).unwrap().is_none(), "subtracting an enclosing body");
let two = a.boolean(&far, BooleanOp::Union).unwrap().unwrap();
shot(&two, "union_disjoint");
assert_eq!(two.solid_count().unwrap(), 2, "a union of disjoint boxes is two solids in one body");
assert_close(volume(&two), 2000.0, 1e-9, "disjoint union volume");
// A body through a slot splits in two.
let bar = cube(20.0);
let cut = Brep::make_box([8.0, -1.0, -1.0], [4.0, 22.0, 22.0]).unwrap();
let halves = bar.boolean(&cut, BooleanOp::Subtract).unwrap().unwrap();
shot(&halves, "subtract_split");
assert_eq!(halves.solid_count().unwrap(), 2);
assert_close(volume(&halves), 8000.0 - 4.0 * 400.0, 1e-9, "split volume");
}
#[test]
fn fillet_every_edge_of_a_cube() {
let (a, r) = (20.0, 2.0);
let c = cube(a);
let f = c.fillet(&cube_edge_midpoints(a), 0.1, r).unwrap();
shot(&f, "fillet_all_edges");
// The rounded cube is the Minkowski sum of the inner cube b = a − 2r with a ball of radius r:
// b³ (core) + 6·b²·r (face slabs) + 12·(π r²/4)·b (quarter cylinders on the edges)
// + 8·(π r³/6) (sphere octants at the corners) = 7804.6961… for a = 20, r = 2.
let b = a - 2.0 * r;
let pi = std::f64::consts::PI;
let want = b.powi(3) + 6.0 * b * b * r + 3.0 * pi * r * r * b + 4.0 / 3.0 * pi * r.powi(3);
let got = volume(&f);
eprintln!("filleted cube: volume {got} (analytic {want}), counts {:?}", f.counts().unwrap());
assert_close(got, want, 1e-6, "rounded cube volume");
// 6 planar faces, 12 edge rounds, 8 corner patches.
assert_eq!(f.counts().unwrap()[0], 26);
assert_untouched(&c, 8000.0, [6, 12, 8]);
}
#[test]
fn chamfer_one_edge() {
let c = cube(20.0);
// The edge y = 20, z = 20, set back 3 mm along both faces: a prism of 3·3/2 × 20 goes.
let ch = c.chamfer(&[[10.0, 20.0, 20.0]], 0.1, 3.0).unwrap();
shot(&ch, "chamfer_one_edge");
assert_close(volume(&ch), 8000.0 - 4.5 * 20.0, 1e-9, "chamfered volume");
// One face more; the edge becomes two edges joined by two new ones; 2 vertices more.
assert_eq!(ch.counts().unwrap(), [7, 15, 10]);
assert_untouched(&c, 8000.0, [6, 12, 8]);
}
#[test]
fn shell_a_box_open_at_the_top() {
let c = cube(20.0);
let top = [[10.0, 10.0, 20.0]];
let inward = c.shell(&top, 0.1, -2.0).unwrap();
shot(&inward, "shell_inward");
// The cavity is 16 × 16 × 18 (the floor is 2 thick, the top open).
assert_close(volume(&inward), 8000.0 - 16.0 * 16.0 * 18.0, 1e-9, "inward shell volume");
// Outside 5, inside 5, the rim 1.
assert_eq!(inward.counts().unwrap()[0], 11);
let outward = c.shell(&top, 0.1, 2.0).unwrap();
shot(&outward, "shell_outward");
// The outside grows to [−2, 22]² × [−2, 20] around the original box, which becomes the cavity.
assert_close(volume(&outward), 24.0 * 24.0 * 22.0 - 8000.0, 1e-9, "outward shell volume");
let closed = c.shell(&[], 0.1, -2.0).unwrap();
shot(&closed, "shell_closed");
assert_close(volume(&closed), 8000.0 - 16.0f64.powi(3), 1e-9, "closed hollow volume");
assert_untouched(&c, 8000.0, [6, 12, 8]);
}
#[test]
fn fillet_takes_exactly_the_picked_edges() {
// Round the vertical edge x = y = 20 first (r = 5): the top rim is then line, arc, line,
// meeting tangentially.
let c = cube(20.0);
let round = c.fillet(&[[20.0, 20.0, 10.0]], 0.1, 5.0).unwrap();
shot(&round, "fillet_one_edge");
let pi = std::f64::consts::PI;
assert_close(volume(&round), 8000.0 - (1.0 - pi / 4.0) * 25.0 * 20.0, 1e-6, "one rounded edge");
// One point on the straight part of the rim rounds that edge only; the chain is rounded when
// all of its edges are picked.
let one = round.fillet(&[[7.5, 20.0, 20.0]], 0.1, 1.0).unwrap();
shot(&one, "fillet_one_of_a_chain");
let arc = [15.0 + 5.0 * (pi / 4.0).cos(), 15.0 + 5.0 * (pi / 4.0).sin(), 20.0];
let all = round.fillet(&[[7.5, 20.0, 20.0], arc, [20.0, 7.5, 20.0]], 0.1, 1.0).unwrap();
shot(&all, "fillet_chain_picked");
assert_eq!(one.counts().unwrap()[0], round.counts().unwrap()[0] + 1, "one round on the picked edge");
assert_eq!(all.counts().unwrap()[0], round.counts().unwrap()[0] + 3, "three rounds on the chain");
assert!(volume(&all) < volume(&one), "the chain takes more than its one edge");
}
#[test]
fn hostile_inputs_are_errors() {
let c = cube(20.0);
let mid = [[10.0, 20.0, 20.0]];
for r in [f64::NAN, f64::INFINITY, -1.0, 0.0, 1e7] {
assert_eq!(c.fillet(&mid, 0.1, r).unwrap_err(), Error::Argument, "radius {r}");
assert_eq!(c.chamfer(&mid, 0.1, r).unwrap_err(), Error::Argument, "distance {r}");
}
for t in [f64::NAN, 0.0, -1.0, f64::INFINITY] {
assert_eq!(c.fillet(&mid, t, 1.0).unwrap_err(), Error::Argument, "tolerance {t}");
}
assert_eq!(c.fillet(&[[f64::NAN, 0.0, 0.0]], 0.1, 1.0).unwrap_err(), Error::Argument);
assert_eq!(c.fillet(&[], 0.1, 1.0).unwrap_err(), Error::Argument);
assert_eq!(c.fillet(&vec![[10.0, 20.0, 20.0]; MAX_POINTS + 1], 0.1, 1.0).unwrap_err(), Error::Argument);
// A second point far from every edge.
assert_eq!(c.fillet(&[mid[0], [100.0, 100.0, 100.0]], 0.1, 1.0).unwrap_err(), Error::NoMatch { point: 1 });
assert_eq!(c.shell(&[[10.0, 10.0, 25.0]], 0.1, -1.0).unwrap_err(), Error::NoMatch { point: 0 });
// A corner is equally near three edges, an edge equally near two faces.
assert_eq!(c.fillet(&[[20.0, 20.0, 20.0]], 0.1, 1.0).unwrap_err(), Error::Ambiguous { point: 0 });
assert_eq!(c.shell(&mid, 0.1, -1.0).unwrap_err(), Error::Ambiguous { point: 0 });
for t in [0.0, f64::NAN, -1e7] {
assert_eq!(c.shell(&[[10.0, 10.0, 20.0]], 0.1, t).unwrap_err(), Error::Argument, "thickness {t}");
}
// Sizes SMLib cannot build fail as errors, whatever SMLib says.
match c.fillet(&mid, 0.1, 50.0) {
Ok(b) => panic!("radius larger than the cube: SMLib built a body of volume {:?}, counts {:?}", b.volume(ACC), b.counts()),
Err(e) => eprintln!("radius larger than the cube: {e:?}"),
}
// A chamfer past the faces runs over their far edges, cliffs: it is cut as if the faces went
// on (the plane y + z = 10 through the setbacks 30 back from the edge y = z = 20), leaving the
// triangle y + z <= 10 of the cube's section along x: 50 x 20.
let past = c.chamfer(&mid, 0.1, 30.0).unwrap();
assert!((volume(&past) - 1000.0).abs() < 1e-6 * 1000.0, "{}", volume(&past));
// A wall with no room inside it never reaches SMLib's offset.
assert_eq!(c.shell(&[[10.0, 10.0, 20.0]], 0.1, -15.0).unwrap_err(), Error::NoRoom);
assert_eq!(c.offset_faces(&[[10.0, 10.0, 20.0]], 0.1, -20.0).unwrap_err(), Error::NoRoom);
assert_eq!(c.thicken(1.0, false).unwrap_err(), Error::Argument, "a solid is no sheet");
assert_untouched(&c, 8000.0, [6, 12, 8]);
}
/// Rig case shell/4711: a 60 x 40 x 10 block with an r3 through hole at (22.5, 7), 4 from the
/// front face, and a 10 x 10 notch on that edge, shelled 2 inward open at the bottom: the hole's
/// offset (r5) is tangent to the front's (y = 2), so the walls meet along a line and the offset
/// bounds no solid there. Refused as such; 1.5 (the walls apart) and 2.5 (crossing, merged)
/// build.
#[test]
fn a_shell_whose_walls_would_meet_is_refused_as_such() {
let block = Brep::make_box([0.0; 3], [60.0, 40.0, 10.0]).unwrap();
let pin = Brep::make_cylinder([22.5, 7.0, -5.0], 3.0, 20.0).unwrap();
let notch = Brep::make_box([25.0, -5.0, -5.0], [10.0, 10.0, 20.0]).unwrap();
let part = block.boolean(&pin, BooleanOp::Subtract).unwrap().unwrap().boolean(¬ch, BooleanOp::Subtract).unwrap().unwrap();
let bottom = [[50.0, 30.0, 0.0]];
assert_eq!(part.shell(&bottom, 0.1, -2.0).unwrap_err(), Error::WallsTouch);
for t in [1.5, 2.5] {
shot(&part.shell(&bottom, 0.1, -t).unwrap(), &format!("shell-4711-{t}"));
}
}
#[test]
fn boolean_history_through_tagged_operands() {
// A slot across the top of the cube: the cube's 6 faces give 7 result faces (the top is cut
// in two), the tool gives the slot's 2 walls and floor; no face is new.
let a = cube(20.0).tagged(0).unwrap();
let tool = Brep::make_box([5.0, -1.0, 10.0], [10.0, 22.0, 15.0]).unwrap().tagged(1).unwrap();
let s = a.boolean(&tool, BooleanOp::Subtract).unwrap().unwrap();
shot(&s, "subtract_slot_tagged");
let h = s.history().unwrap();
assert_eq!(h.faces.len(), 10);
let mut from = [0usize; 2];
for f in &h.faces {
assert!(!f.origins.is_empty(), "{f:?}");
for &(operand, _) in &f.origins {
from[operand.min(1)] += 1;
}
}
assert_eq!(from, [7, 3], "{h:?}");
// The 8 edges where the slot's walls and floor meet the top, front and back are new.
assert_eq!(h.edges.iter().filter(|e| e.origins.is_empty()).count(), 8, "{h:?}");
}
/// `blend` gives each picked edge its own size: two parallel top edges of a 20 mm cube rounded at
/// 2 and 3 lose (1 - pi/4) r^2 L each, chamfered r^2 L / 2 each; a chord of 2 sqrt 2 on a right
/// angle is the round of radius 2.
#[test]
fn blends_take_a_size_per_edge() {
let c = cube(20.0);
let tops = [[10.0, 20.0, 20.0], [10.0, 0.0, 20.0]];
let q = 1.0 - std::f64::consts::FRAC_PI_4;
let r = c.blend(Blend::Round, &tops, &[2.0, 3.0], 0.1).unwrap();
shot(&r, "blend-round-2-3");
assert_close(volume(&r), 8000.0 - q * 13.0 * 20.0, 1e-6, "rounds 2 and 3");
let ch = c.blend(Blend::Chamfer, &tops, &[2.0, 3.0], 0.1).unwrap();
shot(&ch, "blend-chamfer-2-3");
assert_close(volume(&ch), 8000.0 - 0.5 * 13.0 * 20.0, 1e-6, "chamfers 2 and 3");
let chord = c.blend(Blend::Chord, &tops[..1], &[2.0 * 2f64.sqrt()], 0.1).unwrap();
assert_close(volume(&chord), 8000.0 - q * 4.0 * 20.0, 2e-6, "chord");
assert!(c.blend(Blend::Round, &tops, &[2.0], 0.1).is_err());
}
/// A radius running linearly from 3 to 1 along a cube edge: (1 - pi/4) L (r0² + r0 r1 + r1²) / 3
/// taken away, whichever end is the start.
#[test]
fn a_variable_round_follows_its_law() {
let c = cube(20.0);
let q = 1.0 - std::f64::consts::FRAC_PI_4;
let knots = [0.0, 0.0, 1.0, 1.0];
let r = c.fillet_variable([10.0, 20.0, 20.0], 0.1, [0.0, 20.0, 20.0], 1, &knots, &[3.0, 1.0]).unwrap();
shot(&r, "variable-3-1");
assert_close(volume(&r), 8000.0 - q * 20.0 * 13.0 / 3.0, 1e-5, "linear law");
let back = c.fillet_variable([10.0, 20.0, 20.0], 0.1, [20.0, 20.0, 20.0], 1, &knots, &[1.0, 3.0]).unwrap();
assert_close(volume(&back), volume(&r), 1e-7, "reversed");
assert!(c.fillet_variable([10.0, 20.0, 20.0], 0.1, [0.0, 20.0, 20.0], 1, &[0.0, 0.5, 1.0, 1.0], &[3.0, 1.0]).is_err());
assert!(matches!(c.fillet_variable([90.0, 90.0, 90.0], 0.1, [0.0; 3], 1, &knots, &[3.0, 1.0]), Err(Error::NoMatch { .. })));
// A quadratic law with control radii 4, 1, 4: r(t) = 4(1 − t)² + 2t(1 − t) + 4t².
let law = |t: f64| 4.0 * (1.0 - t).powi(2) + 2.0 * t * (1.0 - t) + 4.0 * t * t;
let n = 4000;
let r2 = (0..n).map(|i| law((i as f64 + 0.5) / n as f64).powi(2)).sum::() / n as f64;
let quad = c.fillet_variable([10.0, 20.0, 20.0], 0.1, [0.0, 20.0, 20.0], 2, &[0.0, 0.0, 0.0, 1.0, 1.0, 1.0], &[4.0, 1.0, 4.0]).unwrap();
shot(&quad, "variable-quadratic");
assert_close(volume(&quad), 8000.0 - q * 20.0 * r2, 1e-5, "quadratic law");
// Down to zero at the far end: the round closes to the edge's end point.
let zero = c.fillet_variable([10.0, 20.0, 20.0], 0.1, [0.0, 20.0, 20.0], 1, &knots, &[4.0, 0.0]).unwrap();
shot(&zero, "variable-to-zero");
assert_close(volume(&zero), 8000.0 - q * 20.0 * 16.0 / 3.0, 1e-5, "down to zero");
// A law with a corner (4 → 2 → 4, straight on both halves): the round turns at the corner,
// each half taking away (1 - pi/4) (L / 2) (16 + 8 + 4) / 3; the same points joined smoothly
// (C1 cubic pieces, as RadiusSpline::through makes them) are built too.
let corner = c.fillet_variable([10.0, 20.0, 20.0], 0.1, [0.0, 20.0, 20.0], 1, &[0.0, 0.0, 0.5, 1.0, 1.0], &[4.0, 2.0, 4.0]).unwrap();
shot(&corner, "variable-corner-4-2-4");
assert_close(volume(&corner), 8000.0 - q * 20.0 * 28.0 / 3.0, 1e-6, "corner law");
// A law down to zero inside the edge would pinch the round to a point: refused.
let pinch = c.fillet_variable([10.0, 20.0, 20.0], 0.1, [0.0, 20.0, 20.0], 1, &[0.0, 0.0, 0.5, 1.0, 1.0], &[4.0, 0.0, 4.0]);
assert!(pinch.is_err(), "a law pinching to zero inside the edge");
let smooth_knots = [0.0, 0.0, 0.0, 0.0, 0.5, 0.5, 0.5, 1.0, 1.0, 1.0, 1.0];
let smooth = c.fillet_variable([10.0, 20.0, 20.0], 0.1, [0.0, 20.0, 20.0], 3, &smooth_knots, &[4.0, 10.0 / 3.0, 2.0, 2.0, 2.0, 10.0 / 3.0, 4.0]);
shot(&smooth.unwrap(), "variable-smooth-4-2-4");
}
/// Unequal chamfers of a cube's top edge y = 20: 5 back along the face facing `first` most and 2
/// along the other take away a triangle 5 × 2 / 2 along the 20 mm edge, either way round; 5 at
/// 30° to the first face is 5 and 5 tan 30°.
#[test]
fn chamfers_with_two_setbacks() {
let c = cube(20.0);
let top = [[10.0, 20.0, 20.0]];
let up = c.chamfer_sides(&top, 0.1, 5.0, ChamferSecond::Distance(2.0), [0.0, 0.0, 1.0]).unwrap();
shot(&up, "chamfer-5-2");
assert_close(volume(&up), 8000.0 - 5.0 * 20.0, 1e-9, "5 and 2");
let flipped = c.chamfer_sides(&top, 0.1, 5.0, ChamferSecond::Distance(2.0), [0.0, 0.0, -1.0]).unwrap();
assert_close(volume(&flipped), volume(&up), 1e-9, "flipped");
// Which face took the 5: the removed prism's centroid lies a third of each setback in from
// the edge, so the result's centroid moves away from it.
let centroid = |b: &Brep| b.mass_properties(ACC).unwrap().centroid;
let left = |dy: f64, dz: f64| [10.0, (8000.0 * 10.0 - 100.0 * (20.0 - dy / 3.0)) / 7900.0, (8000.0 * 10.0 - 100.0 * (20.0 - dz / 3.0)) / 7900.0];
for (b, want, what) in [(&up, left(5.0, 2.0), "5 along the top"), (&flipped, left(2.0, 5.0), "5 down the side")] {
let got = centroid(b);
assert!((0..3).all(|i| (got[i] - want[i]).abs() < 1e-6), "{what}: centroid {got:?}, want {want:?}");
}
let angle = c.chamfer_sides(&top, 0.1, 5.0, ChamferSecond::Angle(30f64.to_radians()), [0.0, 0.0, 1.0]).unwrap();
shot(&angle, "chamfer-5-at-30");
assert_close(volume(&angle), 8000.0 - 5.0 * 5.0 * 30f64.to_radians().tan() / 2.0 * 20.0, 1e-9, "5 at 30 degrees");
assert_eq!(c.chamfer_sides(&top, 0.1, 5.0, ChamferSecond::Angle(4.0), [0.0, 0.0, 1.0]).unwrap_err(), Error::Argument);
assert_eq!(c.chamfer_sides(&top, 0.1, 5.0, ChamferSecond::Distance(2.0), [0.0; 3]).unwrap_err(), Error::Argument);
assert_eq!(c.chamfer_sides(&top, 0.1, 5.0, ChamferSecond::Distance(-2.0), [0.0, 0.0, 1.0]).unwrap_err(), Error::Argument);
}
#[test]
fn imprint_cuts_faces_where_a_tool_meets_them() {
// A box half sunk into the cube cuts the four side faces it crosses and the top it lies in.
let cube = cube(20.0);
let tool = Brep::make_box([5.0, -1.0, 10.0], [10.0, 22.0, 15.0]).unwrap();
let cut = cube.imprint(&tool).unwrap().unwrap();
assert!(cut.counts().unwrap()[0] > 6);
assert!((cut.volume(1e-7).unwrap() - 8000.0).abs() < 1e-6);
assert_eq!(cube.counts().unwrap()[0], 6);
// A tool that misses cuts nothing.
let far = Brep::make_box([50.0, 0.0, 0.0], [10.0, 10.0, 10.0]).unwrap();
assert!(cube.imprint(&far).unwrap().is_none());
}
#[test]
fn draft_tilts_a_side_about_its_line_on_the_neutral_plane() {
let c = cube(20.0);
let deg = std::f64::consts::PI / 180.0;
let wedge = 0.5 * 20.0 * 20.0 * (5.0 * deg).tan() * 20.0;
let side = [[20.0, 10.0, 10.0]];
let up = [0.0, 0.0, 1.0];
let leaned = c.draft(&side, 0.1, [0.0; 3], up, up, 5.0 * deg).unwrap();
assert!((leaned.volume(ACC).unwrap() - (8000.0 - wedge)).abs() < 1e-6);
let out = c.draft(&side, 0.1, [0.0; 3], up, up, -5.0 * deg).unwrap();
assert!((out.volume(ACC).unwrap() - (8000.0 + wedge)).abs() < 1e-6);
// The top isn't parallel to the pull.
assert_eq!(c.draft(&[[10.0, 10.0, 20.0]], 0.1, [0.0; 3], up, up, 5.0 * deg).unwrap_err(), Error::Unsupported);
assert_eq!(c.draft(&side, 0.1, [0.0; 3], up, up, 0.0).unwrap_err(), Error::Argument);
assert_eq!(c.draft(&[], 0.1, [0.0; 3], up, up, 5.0 * deg).unwrap_err(), Error::Argument);
assert_untouched(&c, 8000.0, [6, 12, 8]);
}