Files
solidcraft/crates/engine/src/cmd/joints_tests.rs
T
b2f5da6ca7 joints: support custom names and joint type-dependent default names (#10340) (#10165)
* joints: support custom names in dialog and type-based default names

Allow users to specify a custom name in the Joint dialog and generate
type-prefixed default names (e.g. "Planar Joint1", "Revolute Joint1")
instead of generic "Joint{n}".

- Add `name` field to `JointForm` and display a text row in the Joint
  dialog with a dynamic placeholder matching the chosen type.
- Update `new_joint_name` in `cmd/joints.rs` to take `JointKind` and
  prefix auto-generated names with the joint kind label.
- Prioritize non-empty custom names and pass them through `joint.create`,
  `joint.as_built`, and `joint.edit`.
- Pre-populate the existing joint name in `edit_joint` to allow renaming
  directly from the Edit Joint dialog.

* joints: add tests for custom and type-based joint naming

Verify that the joint dialog and engine command layer correctly generate
type-prefixed default names and respect user-specified custom names.

- Add engine-layer test `new_joints_generate_type_prefixed_names_or_keep_custom_name`
  to verify `joint.create` and `joint.as_built` naming logic.
- Add UI-layer test `joint_dialog_applies_custom_name_or_falls_back_to_type_default`
  to ensure the `JointForm` captures and submits names correctly.

* Format dialogs_assembly_tests.rs (trailing blank line)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: bherbruck <brennen.herbruck@gmail.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 18:31:43 +00:00

2765 lines
152 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use solidcraft_geom::prelude::*;
use std::f64::consts::FRAC_PI_2;
use serde_json::{Value, json};
use solidcore_record::Vec3;
use crate::Session;
pub(super) fn run(s: &mut Session, id: &str, p: Value) -> Value {
match s.execute(id, &p) {
Ok(v) => v,
Err(e) => panic!("{id} {p}: {e}"),
}
}
pub(super) fn occ(s: &Session, component: &str) -> u64 {
let c = s.doc.find_component(component).unwrap_or(0);
s.doc.occurrence_of(c).map(|o| o.id).unwrap_or(0)
}
pub(super) fn place(s: &Session, component: &str, p: Vec3) -> Vec3 {
solidcraft_doc::apply_point(&solidcraft_doc::joints::occurrence_world(&s.doc, occ(s, component)), p)
}
fn near(a: Vec3, b: Vec3) -> bool {
a.dist(b) < 1e-6
}
#[test]
fn deleted_joint_ids_are_not_reused_after_reopening() {
for command in ["joint.create", "joint.as_built"] {
let mut s = Session::default();
run(&mut s, "component.create", json!({"name": "Part"}));
let params = if command == "joint.create" {
json!({"type": "revolute", "a": {"occurrence": 0, "point": [0, 0, 0]}, "b": {"occurrence": "Part", "point": [0, 0, 0]}})
} else {
json!({"type": "revolute", "a": 0, "b": "Part"})
};
let first = run(&mut s, command, params.clone())["joint"].as_u64().unwrap();
run(&mut s, "joint.delete", json!({"joint": first}));
let doc = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();
*s.doc_mut() = doc;
let second = run(&mut s, command, params)["joint"].as_u64().unwrap();
assert!(second > first, "{command}: deleted joint {first} was reused as {second}");
assert!(s.execute("joint.drive", &json!({"joint": first, "value": 45})).is_err());
}
}
/// A hinge leaf (oracle 63's knuckle geometry): a 40 x 30 x 3 plate and an r4 knuckle along X
/// at y = 33, z = 4.
fn leaf(s: &mut Session, name: &str) {
run(s, "component.activate", json!({"component": "root"}));
run(s, "component.create", json!({"name": name, "grounded": false}));
run(s, "solid.box", json!({"length": 40, "width": 30, "height": 3, "corner": [0, 0, 0]}));
run(s, "solid.cylinder", json!({"base": [0, 33, 4], "axis": [1, 0, 0], "radius": 4, "height": 40, "operation": "new"}));
}
#[test]
fn circle_given_by_its_centre_takes_that_round_end() {
// #393: `circle` at the centre of a round end, as the parameters document, was refused with
// "no cylindrical face there" (no face lies at a centre).
let mut s = Session::default();
run(&mut s, "component.create", json!({"name": "Plate"}));
run(&mut s, "solid.box", json!({"length": 30, "width": 20, "height": 6, "corner": [-15, -10, 0]}));
run(&mut s, "component.activate", json!({"component": "root"}));
run(&mut s, "component.create", json!({"name": "Knob"}));
run(&mut s, "solid.cylinder", json!({"base": [0, 0, 6], "axis": [0, 0, 1], "radius": 10, "height": 10, "operation": "new"}));
let r = run(
&mut s,
"joint.create",
json!({"type": "cylindrical", "a": {"occurrence": "Plate", "face": [0, 0, 6]}, "b": {"occurrence": "Knob", "circle": [0, 0, 6]}, "name": "J"}),
);
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
// The knob's bottom circle already sits on the plate's top: its axis stays put (it may turn
// about it, to line up the two frames' x).
for z in [6.0, 16.0] {
assert!(near(place(&s, "Knob", Vec3::new(0.0, 0.0, z)), Vec3::new(0.0, 0.0, z)), "{:?}", place(&s, "Knob", Vec3::new(0.0, 0.0, z)));
}
// The top end's centre: its axis points up, out of the knob. It is kept by the knob's wall
// and the face its end opens onto, so it follows them.
run(&mut s, "joint.origin", json!({"occurrence": "Knob", "circle": [0, 0, 16], "name": "Top"}));
let top = s.doc.assembly.origins.iter().find(|o| o.name == "Top").map(|o| o.origin.clone()).unwrap();
assert!(matches!(&top.snap, solidcraft_doc::joints::Snap::CircleCenter { face: Some(_), end: Some(_), .. }), "{top:?}");
let m = solidcraft_doc::joints::resolve_origin(&s.doc, &s.model.state(), &top).unwrap();
assert!(near(Vec3::new(m[3][0], m[3][1], m[3][2]), Vec3::new(0.0, 0.0, 16.0)) && near(Vec3::new(m[2][0], m[2][1], m[2][2]), Vec3::Z), "{m:?}");
// Off the axis is still refused; a coupling size given by a centre is that round face's
// radius (it follows the face).
assert!(s.execute("joint.origin", &json!({"occurrence": "Knob", "circle": [3, 0, 6]})).is_err());
run(&mut s, "joint.screw", json!({"joint": "J", "pitch": {"occurrence": "Knob", "circle": [0, 0, 6]}}));
}
#[test]
fn revolute_hinge_turns_about_the_knuckle() {
let mut s = Session::default();
leaf(&mut s, "LeafA");
leaf(&mut s, "LeafB");
let o = occ(&s, "LeafA");
run(&mut s, "occurrence.ground", json!({"occurrence": o, "grounded": true}));
let r = run(
&mut s,
"joint.create",
json!({
"type": "revolute", "a": {"occurrence": "LeafA", "circle": [1, 37, 4]}, "b": {"occurrence": "LeafB", "circle": [1, 37, 4]}, "flip": true, "name": "Hinge"}),
);
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
// Same frames: B stays put at angle 0.
assert!(near(place(&s, "LeafB", Vec3::new(20.0, 0.0, 0.0)), Vec3::new(20.0, 0.0, 0.0)));
let l = run(&mut s, "joint.list", json!({}));
let dof = l["dof"].as_array().unwrap().iter().find(|d| d["occurrence"] == occ(&s, "LeafB")).unwrap()["dof"].clone();
assert_eq!(dof, 1, "{l}");
// Drive 90°: B turns about the knuckle axis (through (0, 33, 4), along the frame's z = −X).
run(&mut s, "joint.drive", json!({"joint": "Hinge", "value": 90}));
let want = solidcraft_doc::rigid(Vec3::ZERO, Vec3::new(0.0, 33.0, 4.0), Vec3::new(-1.0, 0.0, 0.0), FRAC_PI_2);
let p = Vec3::new(20.0, 0.0, 0.0);
assert!(near(place(&s, "LeafB", p), solidcraft_doc::apply_point(&want, p)), "{:?}", place(&s, "LeafB", p));
assert!(near(place(&s, "LeafB", p), Vec3::new(20.0, 29.0, 37.0)));
// LeafA did not move; the knuckle axis is fixed.
assert!(near(place(&s, "LeafA", p), p));
assert!(near(place(&s, "LeafB", Vec3::new(10.0, 33.0, 4.0)), Vec3::new(10.0, 33.0, 4.0)));
// Expressions drive too, and undo puts it back.
run(&mut s, "joint.drive", json!({"joint": "Hinge", "value": "pi rad"}));
assert!(near(place(&s, "LeafB", p), Vec3::new(20.0, 66.0, 8.0)));
run(&mut s, "edit.undo", json!({}));
assert!(near(place(&s, "LeafB", p), Vec3::new(20.0, 29.0, 37.0)));
}
/// A joint value too large says so, rather than that it is not a number (#9625).
#[test]
fn a_joint_value_out_of_range_says_so() {
let mut s = Session::default();
leaf(&mut s, "LeafA");
leaf(&mut s, "LeafB");
let o = occ(&s, "LeafA");
run(&mut s, "occurrence.ground", json!({"occurrence": o, "grounded": true}));
let hinge = json!({"type": "revolute", "a": {"occurrence": "LeafA", "circle": [1, 37, 4]}, "b": {"occurrence": "LeafB", "circle": [1, 37, 4]}, "flip": true, "name": "Hinge"});
run(&mut s, "joint.create", hinge);
for value in [json!(1e9), json!(-5e15)] {
let e = s.execute("joint.drive", &json!({"joint": "Hinge", "value": value})).err().map(|e| e.to_string()).unwrap_or_default();
assert!(
e.contains("a joint value must be a number between -1e9 and 1e9") && !e.contains("a joint value must be a number or"),
"{value}: {e}"
);
}
let e = s.execute("joint.drive", &json!({"joint": "Hinge", "value": true})).err().map(|e| e.to_string()).unwrap_or_default();
assert!(e.contains("a joint value must be a number or an expression") && !e.contains("between"), "{e}");
}
/// Two 10 mm cubes in components A (grounded) and B.
fn two_cubes() -> Session {
let mut s = Session::default();
for (name, x) in [("A", 0), ("B", 20)] {
run(&mut s, "component.activate", json!({"component": "root"}));
run(&mut s, "component.create", json!({"name": name, "grounded": false}));
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [x, 0, 0]}));
}
let o = occ(&s, "A");
run(&mut s, "occurrence.ground", json!({"occurrence": o, "grounded": true}));
s
}
#[test]
fn slider_limits_clamp() {
let mut s = two_cubes();
// B's bottom face onto A's top face (faces meet), sliding along their common normal.
let r = run(
&mut s,
"joint.create",
json!({"type": "slider", "a": {"face": [5, 5, 10]}, "b": {"face": [25, 5, 0]}, "limits": [[0, 10]], "name": "Rail"}),
);
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
// B now sits on A.
assert!(near(place(&s, "B", Vec3::new(25.0, 5.0, 0.0)), Vec3::new(5.0, 5.0, 10.0)), "{:?}", place(&s, "B", Vec3::new(25.0, 5.0, 0.0)));
let r = run(&mut s, "joint.drive", json!({"joint": "Rail", "value": 25}));
assert_eq!((&r["values"][0]["value"], &r["values"][0]["unit"]), (&json!(10.0), &json!("mm")), "{r}");
assert!(near(place(&s, "B", Vec3::new(25.0, 5.0, 0.0)), Vec3::new(5.0, 5.0, 20.0)));
run(&mut s, "joint.drive", json!({"joint": "Rail", "value": -5}));
assert!(near(place(&s, "B", Vec3::new(25.0, 5.0, 0.0)), Vec3::new(5.0, 5.0, 10.0)));
// Changing the limits clamps the current value.
run(&mut s, "joint.drive", json!({"joint": "Rail", "value": 8}));
run(&mut s, "joint.limits", json!({"joint": "Rail", "min": 0, "max": 4}));
assert!(near(place(&s, "B", Vec3::new(25.0, 5.0, 0.0)), Vec3::new(5.0, 5.0, 14.0)));
// Joints follow edits: A gets taller, B rides on its new top.
let h = s
.doc
.features
.iter()
.find(|f| matches!(f.kind, solidcraft_doc::FeatureKind::Box { .. }))
.and_then(|f| f.param_names.get(2).cloned())
.unwrap_or_default();
run(&mut s, "parameters.change", json!({"name": h, "expression": "15"}));
assert!(near(place(&s, "B", Vec3::new(25.0, 5.0, 0.0)), Vec3::new(5.0, 5.0, 19.0)), "{:?}", place(&s, "B", Vec3::new(25.0, 5.0, 0.0)));
}
#[test]
fn rigid_cycles_solve_and_conflicts_report() {
let mut s = two_cubes();
run(&mut s, "component.activate", json!({"component": "root"}));
run(&mut s, "component.create", json!({"name": "C"}));
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [40, 0, 0]}));
run(&mut s, "component.activate", json!({"component": "root"}));
// A rigid group and a closing as-built joint: a consistent loop.
run(&mut s, "joint.rigid_group", json!({"occurrences": ["A", "B", "C"]}));
let r = run(&mut s, "joint.as_built", json!({"type": "rigid", "a": "B", "b": "C"}));
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
assert!(near(place(&s, "C", Vec3::new(40.0, 0.0, 0.0)), Vec3::new(40.0, 0.0, 0.0)));
let l = run(&mut s, "joint.list", json!({}));
assert!(l["dof"].as_array().unwrap().iter().all(|d| d["dof"] == 0), "{l}");
// A joint that wants C elsewhere conflicts and says so.
let r = run(
&mut s,
"joint.create",
json!({"type": "rigid", "a": {"occurrence": "A", "point": [0, 0, 0]}, "b": {"occurrence": "C", "point": [40, 0, 0]}, "name": "Wrong"}),
);
let c = r["conflicts"].as_array().cloned().unwrap_or_default();
assert_eq!(c.len(), 1, "{r}");
assert!(c[0]["why"].as_str().unwrap_or("").contains("off by"), "{r}");
// A rigid joint has nothing to drive: the refusal names the types that move (#6981).
let e = s.execute("joint.drive", &json!({"joint": "Wrong", "value": 1})).map(|_| ()).unwrap_err().to_string();
assert!(e.contains("does not move") && e.contains("joint.edit") && e.contains("revolute") && e.contains("cylindrical"), "{e}");
// Suppressing it clears the conflict.
let r = run(&mut s, "joint.edit", json!({"joint": "Wrong", "suppressed": true}));
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0));
assert!(
s.execute(
"joint.create",
&json!({"type": "rigid", "a": {"occurrence": "A", "point": [0, 0, 0]}, "b": {"occurrence": "A", "point": [1, 0, 0]}})
)
.is_err()
);
assert!(s.execute("joint.create", &json!({"type": "hinge"})).is_err());
}
/// A 30 x 30 x 3 plate with a through slot whose x = 20 wall carries one rib (0.3 tall, 0.8
/// wide), and a peg in the slot with 0.15 clearance all round.
fn ribbed_slot_and_peg(s: &mut Session, peg_x1: f64) {
run(s, "sketch.create", json!({"plane": "XY"}));
run(s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [30, 30]}));
run(s, "sketch.finish", json!({}));
run(s, "solid.extrude", json!({"distance": 3, "body_name": "Plate"}));
run(s, "sketch.create", json!({"plane": "XY", "offset": -1}));
let slot = json!([[10, 5], [20, 5], [20, 14.6], [19.7, 14.6], [19.7, 15.4], [20, 15.4], [20, 25], [10, 25]]);
run(s, "sketch.line", json!({"points": slot, "closed": true}));
run(s, "sketch.finish", json!({}));
run(s, "solid.extrude", json!({"distance": 5, "operation": "cut", "targets": ["Plate"]}));
run(s, "sketch.create", json!({"plane": "XY"}));
run(s, "sketch.rectangle.two_point", json!({"p0": [10.15, 5.15], "p1": [peg_x1, 24.85]}));
run(s, "sketch.finish", json!({}));
run(s, "solid.extrude", json!({"distance": 3, "operation": "new", "body_name": "Peg"}));
}
/// The peg overlaps only the rib: 0.15 x 0.8 x 3 = 0.36 mm³ (#442).
#[test]
fn interference_finds_a_peg_overlapping_a_small_rib() {
let mut s = Session::default();
ribbed_slot_and_peg(&mut s, 19.85);
let i = run(&mut s, "inspect.interference", json!({}));
assert_eq!(i["count"], 1, "{i}");
assert!((i["interferences"][0]["volume_mm3"].as_f64().unwrap_or(0.0) - 0.36).abs() < 1e-6, "{i}");
let (lo, hi) = (&i["interferences"][0]["bbox"]["min"], &i["interferences"][0]["bbox"]["max"]);
assert!((lo[0].as_f64().unwrap_or(0.0) - 19.7).abs() < 1e-6 && (hi[0].as_f64().unwrap_or(0.0) - 19.85).abs() < 1e-6, "{i}");
}
/// A pair interference can't check is listed as unchecked, with its reason, instead of passing
/// as clear. Truck could not intersect an arc revolved up to a post's wall; SMLib does, exactly,
/// so the pair that can't be checked is now an imported mesh beside a solid.
#[test]
fn interference_lists_a_pair_it_could_not_check() {
// A quarter ring revolved round z through the post, brought in as an imported mesh (an STL
// of it): a mesh body has no exact surfaces to intersect, so its pair with the post is listed
// as not checked, with the reason, rather than read as clear.
let dir = std::env::temp_dir().join(format!("solidcraft-unchecked-pair-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let stl = dir.join("arc.stl");
let mut source = Session::default();
run(&mut source, "sketch.create", json!({"name": "Profile", "plane": "XZ"}));
run(&mut source, "sketch.rectangle.two_point", json!({"p0": [10, 0], "p1": [15, 5]}));
run(&mut source, "sketch.finish", json!({}));
run(
&mut source,
"solid.revolve",
json!({"sketch": "Profile", "axis": {"origin": [0, 0, 0], "dir": [0, 0, 1]}, "angle": "90 deg", "body_name": "Arc"}),
);
run(&mut source, "file.export", json!({"path": stl.to_string_lossy()}));
let mut s = Session::default();
run(&mut s, "solid.cylinder", json!({"base": [0, 14, -5], "radius": 4, "height": 15, "body_name": "Post"}));
run(&mut s, "file.insert_mesh", json!({"path": stl.to_string_lossy()}));
let _ = std::fs::remove_dir_all(&dir);
let mesh: Vec<String> = s.world_state().unwrap().bodies.iter().filter(|b| b.body.is_mesh()).map(|b| b.name.clone()).collect();
assert_eq!(mesh.len(), 1, "{mesh:?}");
let i = run(&mut s, "inspect.interference", json!({}));
assert_eq!(i["count"], 0, "{i}");
let unchecked = i["unchecked"].as_array().cloned().unwrap_or_default();
assert_eq!(unchecked.len(), 1, "{i}");
assert_eq!(unchecked[0]["a"].as_str(), mesh.first().map(String::as_str), "{i}");
assert_eq!(unchecked[0]["reason"], "mesh body: not checked", "{i}");
// Bodies that are clear of each other, or overlap plainly, leave the list empty.
let mut s = two_cubes();
let i = run(&mut s, "inspect.interference", json!({}));
assert_eq!(i["unchecked"].as_array().map(Vec::len), Some(0), "{i}");
}
#[test]
fn motion_links_and_interference() {
let mut s = two_cubes();
run(&mut s, "joint.create", json!({"type": "cylindrical", "a": {"face": [5, 5, 10]}, "b": {"face": [25, 5, 0]}, "name": "Screw"}));
run(&mut s, "joint.drive", json!({"joint": "Screw", "values": [0, 0]}));
// No overlap while B sits on A; then push B 4 mm into A.
let i = run(&mut s, "inspect.interference", json!({}));
assert_eq!(i["count"], 0, "{i}");
run(&mut s, "joint.drive", json!({"joint": "Screw", "values": [0, -4]}));
let i = run(&mut s, "inspect.interference", json!({}));
assert_eq!(i["count"], 1, "{i}");
assert!((i["interferences"][0]["volume_mm3"].as_f64().unwrap_or(0.0) - 400.0).abs() < 1e-3, "{i}");
// A motion link: a second joint's value follows.
run(&mut s, "component.activate", json!({"component": "root"}));
run(&mut s, "component.create", json!({"name": "D"}));
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [60, 0, 0]}));
run(
&mut s,
"joint.create",
json!({"type": "slider", "a": {"occurrence": "A", "face": [5, 5, 10]}, "b": {"occurrence": "D", "face": [65, 5, 0]}, "name": "Follower"}),
);
run(&mut s, "joint.motion_link", json!({"a": "Screw", "ia": 1, "b": "Follower", "ratio": 2}));
run(&mut s, "joint.drive", json!({"joint": "Screw", "values": [0, 3]}));
assert!(near(place(&s, "D", Vec3::new(65.0, 5.0, 0.0)), Vec3::new(5.0, 5.0, 16.0)), "{:?}", place(&s, "D", Vec3::new(65.0, 5.0, 0.0)));
// Saved and reopened, joints come back.
let back = solidcraft_doc::Document::from_json(&s.doc.to_json()).unwrap();
assert_eq!(back.assembly, s.doc.assembly);
let mut t = Session::new(back);
let l = run(&mut t, "joint.list", json!({}));
assert_eq!(l["joints"].as_array().map(Vec::len), Some(2));
}
/// Two faces joined mate: B's bottom face lands on A's top face, B on top of A (not inside
/// it); Flip turns B over instead.
#[test]
fn faces_mate_by_default() {
let mut s = two_cubes();
run(&mut s, "joint.create", json!({"type": "rigid", "a": {"face": [5, 5, 10]}, "b": {"face": [25, 5, 0]}, "name": "Stack"}));
// B's bottom centre (25, 5, 0) at A's top centre, B above it.
assert!(near(place(&s, "B", Vec3::new(25.0, 5.0, 0.0)), Vec3::new(5.0, 5.0, 10.0)));
assert!(near(place(&s, "B", Vec3::new(25.0, 5.0, 10.0)), Vec3::new(5.0, 5.0, 20.0)), "{:?}", place(&s, "B", Vec3::new(25.0, 5.0, 10.0)));
run(&mut s, "joint.edit", json!({"joint": "Stack", "flip": true}));
assert!(near(place(&s, "B", Vec3::new(25.0, 5.0, 10.0)), Vec3::new(5.0, 5.0, 0.0)), "{:?}", place(&s, "B", Vec3::new(25.0, 5.0, 10.0)));
}
/// Edit Joint takes new sides as joint.create does: the joint moves its attachment to them, and
/// keeps its limits, its drive and the expression its offset follows.
#[test]
fn edit_moves_a_side_and_keeps_limits_and_expressions() {
let mut s = two_cubes();
run(&mut s, "parameters.add", json!({"name": "gap", "expression": "2 mm"}));
run(
&mut s,
"joint.create",
json!({"type": "slider", "name": "Rail", "offset": "gap", "limits": [[0, 10]], "a": {"face": [5, 5, 10]}, "b": {"face": [25, 5, 0]}}),
);
run(&mut s, "joint.drive", json!({"joint": "Rail", "value": 4}));
// B's bottom centre rides 2 mm (the gap) plus 4 mm (the drive) above A's top centre.
assert!(near(place(&s, "B", Vec3::new(25.0, 5.0, 0.0)), Vec3::new(5.0, 5.0, 16.0)), "{:?}", place(&s, "B", Vec3::new(25.0, 5.0, 0.0)));
// B's top centre, where B is placed now, is the new side (`face` is a world point).
let top = place(&s, "B", Vec3::new(25.0, 5.0, 10.0));
let r = run(&mut s, "joint.edit", json!({"joint": "Rail", "b": {"occurrence": "B", "face": [top.x, top.y, top.z]}}));
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
assert!(near(place(&s, "B", Vec3::new(25.0, 5.0, 10.0)), Vec3::new(5.0, 5.0, 16.0)), "{:?}", place(&s, "B", Vec3::new(25.0, 5.0, 10.0)));
let j = s.doc.assembly.joints.first().cloned().unwrap_or_else(|| panic!("no joint"));
assert_eq!(j.limits, vec![Some((0.0, 10.0))]);
assert_eq!(j.exprs.offset.as_deref(), Some("gap"));
assert_eq!(j.values, vec![4.0]);
assert_eq!(j.name, "Rail");
}
/// Sides left out of joint.edit stay as they are; the other parameters still change.
#[test]
fn omitted_sides_stay() {
let mut s = two_cubes();
run(&mut s, "joint.create", json!({"type": "rigid", "name": "Stack", "a": {"face": [5, 5, 10]}, "b": {"face": [25, 5, 0]}}));
let before = s.doc.assembly.joints[0].clone();
run(&mut s, "joint.edit", json!({"joint": "Stack", "flip": true, "name": "Flipped"}));
let after = &s.doc.assembly.joints[0];
assert_eq!((&after.a, &after.b), (&before.a, &before.b));
assert!(after.flip && after.name == "Flipped");
}
/// One undo step puts the sides back, and the parts with them.
#[test]
fn one_undo_restores_the_old_sides() {
let mut s = two_cubes();
run(&mut s, "joint.create", json!({"type": "rigid", "name": "Stack", "a": {"face": [5, 5, 10]}, "b": {"face": [25, 5, 0]}}));
let before = s.doc.assembly.joints[0].clone();
let top = place(&s, "B", Vec3::new(25.0, 5.0, 10.0));
run(&mut s, "joint.edit", json!({"joint": "Stack", "b": {"occurrence": "B", "face": [top.x, top.y, top.z]}}));
assert!(near(place(&s, "B", Vec3::new(25.0, 5.0, 10.0)), Vec3::new(5.0, 5.0, 10.0)), "{:?}", place(&s, "B", Vec3::new(25.0, 5.0, 10.0)));
run(&mut s, "edit.undo", json!({}));
assert_eq!(s.doc.assembly.joints[0], before);
assert!(near(place(&s, "B", Vec3::new(25.0, 5.0, 0.0)), Vec3::new(5.0, 5.0, 10.0)));
}
/// Moving a side re-solves the joint as joint.create would at the same pose: the turn B keeps
/// about the joint's axis follows its new origin, so B does not turn by a half turn (or any turn
/// a fresh create would not give). Both designs start from the same pose; one moves the side,
/// the other deletes the joint and creates it with the new sides.
#[test]
fn moving_a_side_places_the_part_as_create_would() {
let a_faces = [[5, 5, 10], [5, 0, 5], [5, 10, 5], [10, 5, 5], [0, 5, 5]];
let b_faces = [[25, 5, 0], [25, 5, 10], [25, 0, 5], [25, 10, 5], [20, 5, 5], [30, 5, 5]];
// A point of B off the axes of every face above.
let probe = |s: &Session| place(s, "B", Vec3::new(22.0, 3.0, 7.0));
let mut differ = Vec::new();
for a in a_faces {
for b in b_faces {
let mut edited = two_cubes();
run(&mut edited, "joint.create", json!({"type": "rigid", "name": "J", "a": {"face": [5, 5, 10]}, "b": {"face": [25, 5, 0]}}));
let mut created = Session::new(solidcraft_doc::Document::from_json(&edited.doc.to_json()).unwrap());
// The new sides in world coordinates, where B is before the move.
let (aw, bw) = (Vec3::new(a[0] as f64, a[1] as f64, a[2] as f64), place(&edited, "B", Vec3::new(b[0] as f64, b[1] as f64, b[2] as f64)));
let side = |occurrence: &str, p: Vec3| json!({"occurrence": occurrence, "face": [p.x, p.y, p.z]});
run(&mut edited, "joint.edit", json!({"joint": "J", "a": side("A", aw), "b": side("B", bw)}));
run(&mut created, "joint.delete", json!({"joint": "J"}));
run(&mut created, "joint.create", json!({"type": "rigid", "name": "J", "a": side("A", aw), "b": side("B", bw)}));
if !near(probe(&edited), probe(&created)) {
differ.push((a, b, probe(&edited), probe(&created)));
}
}
}
assert!(differ.is_empty(), "moved sides place B differently from create: {differ:?}");
}
/// A side that makes no joint is refused, and the joint is left as it was: a side on the other
/// side's component, a side that is not a joint origin, an unknown occurrence.
#[test]
fn an_invalid_side_is_refused_and_the_joint_is_kept() {
let mut s = two_cubes();
run(&mut s, "joint.create", json!({"type": "rigid", "name": "Stack", "a": {"face": [5, 5, 10]}, "b": {"face": [25, 5, 0]}}));
let before = s.doc.assembly.joints[0].clone();
// A is a's occurrence and B is b's: each side is tried on the other's occurrence, and with
// the faults every side can have.
let cases = [
("a", json!({"occurrence": "B", "face": [25, 5, 10]})),
("a", json!({"occurrence": "Nope", "face": [5, 5, 10]})),
("a", json!({"occurrence": "A"})),
("a", json!(5)),
("b", json!({"occurrence": "A", "face": [5, 5, 0]})),
("b", json!({"occurrence": "Nope", "face": [25, 5, 0]})),
("b", json!({"occurrence": "B"})),
("b", json!("NoSuchOrigin")),
];
for (key, side) in cases {
let r = s.execute("joint.edit", &json!({"joint": "Stack", key: side.clone()}));
assert!(r.is_err(), "{key}: {side} should be refused");
assert_eq!(s.doc.assembly.joints[0], before, "{key}: {side} changed the joint");
}
}
/// A move of a jointed part that the joint takes back: the model is evaluated for the
/// placements the solve leaves, so a mirror of the part's body, made from the root, is where a
/// fresh evaluation of the design puts it. The model was the one evaluated for the move before
/// the solve took it back, and its mirror didn't match the part.
#[test]
fn a_feature_reading_a_jointed_parts_placement_follows_the_solve() {
let mut s = Session::default();
for (cmd, p) in [
("component.create", json!({"grounded": true, "name": "Base"})),
("solid.box", json!({"corner": [-11, -25, 0], "height": 9, "length": 11, "width": 14})),
("component.create", json!({"grounded": false, "name": "Slide"})),
("solid.cylinder", json!({"base": [-2, -10, 7], "height": 7, "radius": 2})),
("component.activate", json!({"component": "root"})),
("joint.as_built", json!({"a": "Base:1", "b": "Slide:1", "name": "Rail", "type": "slider"})),
("solid.mirror", json!({"bodies": ["Body2"], "plane": "XY"})),
("occurrence.move", json!({"occurrence": "Slide:1", "translate": [-10, -18, 2]})),
] {
s.execute(cmd, &p).unwrap_or_else(|e| panic!("{cmd}: {e}"));
}
let boxes = |st: &solidcraft_doc::ModelState| {
st.bodies
.iter()
.map(|b| (b.name.clone(), b.body.outline_bounds()))
.map(|(n, bb)| format!("{n} {:.6?} {:.6?}", bb.min, bb.max))
.collect::<Vec<_>>()
};
let mut fresh = solidcraft_doc::Model::new();
fresh.no_cache = true;
fresh.evaluate(&s.doc);
assert_eq!(boxes(&s.model.state()), boxes(&fresh.state()));
}
/// #1239: two parts as bodies of one component (a multi-body STEP import). The refusal names the
/// way out, and after Create Components from Bodies the same origins make the joint.
#[test]
fn bodies_of_one_component_get_components_first() {
let mut s = Session::default();
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10}));
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 10, "corner": [20, 0, 0]}));
let p = json!({"type": "rigid", "a": {"face": [5, 5, 10]}, "b": {"face": [25, 5, 0]}});
let e = s.execute("joint.create", &p).map(|_| ()).unwrap_err().to_string();
assert!(e.contains("two different occurrences") && e.contains("component.from_bodies"), "{e}");
run(&mut s, "component.from_bodies", json!({"bodies": ["Body1", "Body2"]}));
run(&mut s, "joint.create", p);
// The first joint's A side stays; B lands on top of it.
assert!(near(place(&s, "Body2", Vec3::new(25.0, 5.0, 0.0)), Vec3::new(5.0, 5.0, 10.0)));
}
/// #527: an assembly with its fasteners passes 200 bodies quickly; the clash check must still
/// cover the whole design. 201 separate 1 mm cubes 2 mm apart, plus one cube pushed half-way
/// into the first: exactly that pair overlaps, by 0.5 mm³.
#[test]
fn interference_checks_designs_with_more_than_200_bodies() {
let mut s = Session::default();
for i in 0..201 {
run(&mut s, "solid.box", json!({"length": 1, "width": 1, "height": 1, "corner": [2 * i, 0, 0], "operation": "new"}));
}
run(&mut s, "solid.box", json!({"length": 1, "width": 1, "height": 1, "corner": [0.5, 0, 0], "operation": "new", "body_name": "Clash"}));
assert_eq!(s.model.state().bodies.len(), 202);
let i = run(&mut s, "inspect.interference", json!({}));
assert_eq!(i["checked"], 202, "{i}");
assert_eq!(i["count"], 1, "{i}");
let hit = &i["interferences"][0];
let mut pair = [hit["a"].as_str().unwrap_or(""), hit["b"].as_str().unwrap_or("")];
pair.sort_unstable();
assert_eq!(pair, ["Body1", "Clash"], "{i}");
assert!((hit["volume_mm3"].as_f64().unwrap_or(0.0) - 0.5).abs() < 1e-6, "{i}");
}
/// The bounding-box sweep behind `inspect.interference` finds exactly the pairs a check of every
/// pair finds (touching boxes count), and reports how many it left out past its limit.
#[test]
fn interference_box_sweep_matches_every_pair_check() {
use solidcraft_geom::Aabb3;
let cube = |x: f64, y: f64, z: f64, e: f64| Aabb3 { min: Vec3::new(x, y, z), max: Vec3::new(x + e, y + e, z + e) };
// A deterministic scatter: overlapping, touching, and apart in only one axis.
let boxes: Vec<Aabb3> = (0..60)
.map(f64::from)
.map(|i| cube((i * 7.3) % 20.0, (i * 3.1) % 9.0, (i * 5.7) % 4.0, 1.0 + (i % 3.0)))
.chain([cube(30.0, 0.0, 0.0, 1.0), cube(31.0, 0.0, 0.0, 1.0)])
.collect();
let mut every = Vec::new();
for (i, a) in boxes.iter().enumerate() {
for (j, b) in boxes.iter().enumerate().skip(i + 1) {
let apart = a.max.x < b.min.x || b.max.x < a.min.x || a.max.y < b.min.y || b.max.y < a.min.y || a.max.z < b.min.z || b.max.z < a.min.z;
if !apart {
every.push((i, j));
}
}
}
assert!(every.contains(&(60, 61)), "touching boxes are a candidate pair");
let (pairs, skipped) = super::overlapping_pairs(&boxes, usize::MAX);
assert_eq!((pairs, skipped), (every.clone(), 0));
let (pairs, skipped) = super::overlapping_pairs(&boxes, 10);
assert_eq!((pairs.len(), skipped), (10, every.len() - 10));
}
/// A small block in a new component: a part of a linkage, where only its joints matter.
pub(super) fn part(s: &mut Session, name: &str, corner: [f64; 3]) {
run(s, "component.activate", json!({"component": "root"}));
run(s, "component.create", json!({"name": name, "grounded": false}));
run(s, "solid.box", json!({"length": 2, "width": 2, "height": 2, "corner": corner}));
}
/// A joint between two parts as they are, at a world point with its z along `z`.
pub(super) fn pin(s: &mut Session, kind: &str, name: &str, a: &str, b: &str, p: Vec3, z: Vec3) {
let at = |o: &str| json!({"occurrence": o, "point": [p.x, p.y, p.z], "z": [z.x, z.y, z.z]});
let r = run(s, "joint.create", json!({"type": kind, "a": at(a), "b": at(b), "flip": true, "name": name}));
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
}
/// Where circles about `p` (radius `r`) and `q` (radius `s`) in the XY plane meet.
pub(super) fn meet(p: Vec3, r: f64, q: Vec3, s: f64) -> [Vec3; 2] {
let d = q - p;
let l = d.len();
let a = (r * r - s * s + l * l) / (2.0 * l);
let m = p + d * (a / l);
let n = Vec3::new(-d.y, d.x, 0.0) * ((r * r - a * a).max(0.0).sqrt() / l);
[m + n, m - n]
}
/// A crank-rocker four-bar about +Z: ground pivots O2 = (0, 0) and O4 = (45, 0), crank 20,
/// coupler 50, rocker 40, assembled with the crank at 90°. Returns the crank pin P0 and the
/// rocker pin Q0 (the upper, open assembly).
pub(super) fn four_bar() -> (Session, Vec3, Vec3) {
let mut s = Session::default();
let (o2, o4, p0) = (Vec3::ZERO, Vec3::new(45.0, 0.0, 0.0), Vec3::new(0.0, 20.0, 0.0));
let [q0, _] = meet(p0, 50.0, o4, 40.0);
for (name, c) in [("Ground", o2), ("Crank", p0), ("Coupler", (p0 + q0) * 0.5), ("Rocker", q0)] {
part(&mut s, name, [c.x, c.y, -5.0]);
}
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
pin(&mut s, "revolute", "Crank", "Ground", "Crank", o2, Vec3::Z);
pin(&mut s, "revolute", "Crank pin", "Crank", "Coupler", p0, Vec3::Z);
pin(&mut s, "revolute", "Rocker pin", "Coupler", "Rocker", q0, Vec3::Z);
pin(&mut s, "revolute", "Rocker", "Ground", "Rocker", o4, Vec3::Z);
(s, p0, q0)
}
/// The four-bar's rocker pin with the crank driven to `to`°, followed a degree at a time from
/// `from`° (where it is at `q`), so it stays on its branch.
fn rocker_pin(from: f64, to: f64, mut q: Vec3) -> Vec3 {
let n = ((to - from).abs().ceil() as usize).max(1);
for k in 1..=n {
let th = (90.0 + from + (to - from) * k as f64 / n as f64).to_radians();
let [m1, m2] = meet(Vec3::new(20.0 * th.cos(), 20.0 * th.sin(), 0.0), 50.0, Vec3::new(45.0, 0.0, 0.0), 40.0);
q = if m1.dist(q) <= m2.dist(q) { m1 } else { m2 };
}
q
}
#[test]
fn four_bar_follows_its_crank() {
let (mut s, p0, q0) = four_bar();
let mut q = q0;
let mut at_330 = q0;
for k in 1..=12 {
let v = 30.0 * f64::from(k);
let r = run(&mut s, "joint.drive", json!({"joint": "Crank", "value": v}));
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{v}°: {r}");
assert!(r["stopped_by_loop"].is_null(), "{v}°: {r}");
// The driven joint keeps exactly the value asked for, answered in degrees as asked.
assert!((r["values"][0]["value"].as_f64().unwrap_or(f64::NAN) - v).abs() < 1e-9 && r["values"][0]["unit"] == "deg", "{r}");
q = rocker_pin(v - 30.0, v, q);
let th = (90.0 + v).to_radians();
let p = Vec3::new(20.0 * th.cos(), 20.0 * th.sin(), 0.0);
for (part, local, want) in [("Crank", p0, p), ("Coupler", p0, p), ("Coupler", q0, q), ("Rocker", q0, q)] {
assert!(near(place(&s, part, local), want), "{v}°: {part} {:?} wants {want:?}", place(&s, part, local));
}
if k == 11 {
at_330 = q;
}
}
// Back where it started after a full turn, and undo steps back.
assert!(near(q, q0));
run(&mut s, "edit.undo", json!({}));
assert!(near(place(&s, "Rocker", q0), at_330), "{:?}", place(&s, "Rocker", q0));
// One 180° drive lands on the same (open) branch as the stepped path.
let (mut s, _, q0) = four_bar();
let r = run(&mut s, "joint.drive", json!({"joint": "Crank", "value": 180}));
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
assert!(near(place(&s, "Rocker", q0), rocker_pin(0.0, 180.0, q0)), "{:?}", place(&s, "Rocker", q0));
// A motion study playing the crank places the rocker the same way.
run(&mut s, "motion.study", json!({"name": "Turn", "steps": 10, "keys": [{"joint": "Crank", "points": [[0, 0], [10, 120]]}]}));
let r = run(&mut s, "motion.play", json!({"study": "Turn", "step": 5}));
assert!(r["stopped_by_loop"].is_null(), "{r}");
assert!(near(place(&s, "Rocker", q0), rocker_pin(180.0, 60.0, rocker_pin(0.0, 180.0, q0))), "{:?}", place(&s, "Rocker", q0));
}
/// The rocker swings between its toggle positions, where crank and coupler line up (|Q| = 70
/// and |Q| = 30, about 69.3° and 139.2° from the ground line); driving it further stops where
/// the loop still closes.
#[test]
fn four_bar_rocker_stops_where_the_loop_cannot_close() {
let (mut s, _, q0) = four_bar();
let start = q0.y.atan2(q0.x - 45.0).to_degrees();
let r = run(&mut s, "joint.drive", json!({"joint": "Rocker", "value": 100}));
assert!(r["stopped_by_loop"].is_object(), "{r}");
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
let reached = r["values"][0]["value"].as_f64().unwrap_or(f64::NAN);
// |Q|² = 45² + 40² + 2·45·40·cos φ = 30².
let limit = ((900.0f64 - 3625.0) / 3600.0).acos().to_degrees() - start;
assert!(reached > limit - 5.0 && reached <= limit, "stopped at {reached}°, the limit is {limit}°");
// Inside its swing it moves freely, and the crank follows.
let r = run(&mut s, "joint.drive", json!({"joint": "Rocker", "value": -10}));
assert!(r["stopped_by_loop"].is_null() && r["conflicts"].as_array().map(Vec::len) == Some(0), "{r}");
let q = place(&s, "Rocker", q0);
assert!((q.y.atan2(q.x - 45.0).to_degrees() - (start - 10.0)).abs() < 1e-6, "{q:?}");
assert!(place(&s, "Coupler", q0).dist(q) < 1e-6);
// A full turn would end where it started, but the rocker can't get there.
let (mut s, _, _) = four_bar();
let r = run(&mut s, "joint.drive", json!({"joint": "Rocker", "value": 360}));
assert!(r["stopped_by_loop"].is_object(), "{r}");
assert!(r["values"][0]["value"].as_f64().unwrap_or(f64::NAN) <= limit, "{r}");
}
/// A loop value a motion link sets follows through the start of its link chain: a dial outside
/// the loop turns a gear, which sets the rocker's angle, so turning the crank turns the dial.
#[test]
fn four_bar_turns_the_source_of_a_linked_loop_value() {
let linked = || {
let (mut s, _, q0) = four_bar();
for (name, x) in [("Dial", 80.0), ("Gear", 100.0)] {
part(&mut s, name, [x, 0.0, -5.0]);
pin(&mut s, "revolute", name, "Ground", name, Vec3::new(x, 0.0, 0.0), Vec3::Z);
}
run(&mut s, "joint.motion_link", json!({"a": "Dial", "b": "Gear", "ratio": 1}));
run(&mut s, "joint.motion_link", json!({"a": "Gear", "b": "Rocker", "ratio": 0.5}));
(s, q0)
};
let (mut s, q0) = linked();
let r = run(&mut s, "joint.drive", json!({"joint": "Crank", "value": 60}));
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
let q = rocker_pin(0.0, 60.0, q0);
assert!(near(place(&s, "Rocker", q0), q), "{:?} wants {q:?}", place(&s, "Rocker", q0));
let turn = q.y.atan2(q.x - 45.0) - q0.y.atan2(q0.x - 45.0);
let dial = s.doc.assembly.joints.iter().find(|j| j.name == "Dial").and_then(|j| j.values.first().copied()).unwrap_or(f64::NAN);
assert!((dial - 2.0 * turn).abs() < 1e-9, "dial {dial}, rocker turned {turn}");
// Driving the dial drives the rocker through the chain: two turns of the dial would turn
// the rocker a full turn, which it can't make.
let (mut s, _) = linked();
let r = run(&mut s, "joint.drive", json!({"joint": "Dial", "value": 720}));
assert!(r["stopped_by_loop"].is_object(), "{r}");
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
}
/// Values left out of a drive are free to follow in a loop: a plate on a planar joint whose
/// travel a diagonal slider limits. Driving only the planar joint's x moves its y along.
#[test]
fn values_left_out_of_a_drive_follow_the_loop() {
let mut s = Session::default();
part(&mut s, "Ground", [-1.0, -1.0, -5.0]);
part(&mut s, "Plate", [-1.0, -1.0, 0.0]);
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
let frame = |o: &str, z: [f64; 3], x: [f64; 3]| json!({"occurrence": o, "frame": {"origin": [0, 0, 0], "z": z, "x": x}});
let flat = |o: &str| frame(o, [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]);
let r = run(&mut s, "joint.create", json!({"type": "planar", "a": flat("Ground"), "b": flat("Plate"), "flip": true, "name": "Table"}));
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
let diagonal = |o: &str| frame(o, [1.0, 1.0, 0.0], [0.0, 0.0, 1.0]);
let r = run(&mut s, "joint.create", json!({"type": "slider", "a": diagonal("Ground"), "b": diagonal("Plate"), "flip": true, "name": "Rail"}));
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
let r = run(&mut s, "joint.drive", json!({"joint": "Table", "values": [10]}));
assert!(r["stopped_by_loop"].is_null() && r["conflicts"].as_array().map(Vec::len) == Some(0), "{r}");
assert!(near(place(&s, "Plate", Vec3::ZERO), Vec3::new(10.0, 10.0, 0.0)), "{:?}", place(&s, "Plate", Vec3::ZERO));
}
/// Two boards 400 x 100 x 20 for #10331: yellow at the origin, grounded, and red 300 mm along Y.
fn boards() -> Session {
let mut s = Session::default();
for (name, corner) in [("Yellow", [0.0, 0.0, 0.0]), ("Red", [0.0, 300.0, 0.0])] {
run(&mut s, "component.activate", json!({"component": "root"}));
run(&mut s, "component.create", json!({"name": name, "grounded": false}));
run(&mut s, "solid.box", json!({"length": 400, "width": 100, "height": 20, "corner": corner}));
}
let y = occ(&s, "Yellow");
run(&mut s, "occurrence.ground", json!({"occurrence": y, "grounded": true}));
s
}
/// #10331: a board on a planar joint, mated by a second planar joint at a face that points the
/// same way as the face it meets. It meets it turned a half turn on the first joint, the way the
/// first joint moves its part into place, in either pick order, and still slides along the
/// line the two planes share. Faces that can never meet stay a conflict, and nothing moves.
#[test]
fn a_second_planar_joint_turns_its_part_a_half_turn_to_meet() {
// Each case: the yellow face, the red face (world points once red lies on yellow, at
// x 0..400, y 0..100, z 20..40), and where red's origin ends up.
let cases = [
("fronts", [200.0, 0.0, 10.0], [200.0, 0.0, 30.0], Some(Vec3::new(400.0, 300.0, 20.0))),
("ends", [0.0, 50.0, 10.0], [0.0, 50.0, 30.0], Some(Vec3::new(0.0, 400.0, 20.0))),
("top against front", [200.0, 0.0, 10.0], [200.0, 50.0, 40.0], None),
];
for red_first in [false, true] {
for (case, yellow_face, red_face, expected) in cases {
let mut s = boards();
let planar = |s: &mut Session, name: &str, yellow: [f64; 3], red: [f64; 3]| {
let (yellow, red) = (json!({"occurrence": "Yellow", "face": yellow}), json!({"occurrence": "Red", "face": red}));
let (a, b) = if red_first { (red, yellow) } else { (yellow, red) };
run(s, "joint.create", json!({"type": "planar", "a": a, "b": b, "name": name}))
};
let r = planar(&mut s, "Top", [200.0, 50.0, 20.0], [200.0, 350.0, 0.0]);
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{case}: {r}");
let on_top = place(&s, "Red", Vec3::ZERO);
let r = planar(&mut s, "Side", yellow_face, red_face);
let label = format!("{case}, red picked first: {red_first}");
let Some(expected) = expected else {
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(1), "{label}: {r}");
assert!(near(place(&s, "Red", Vec3::ZERO), on_top), "{label}: {:?}", place(&s, "Red", Vec3::ZERO));
continue;
};
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{label}: {r}");
assert!(place(&s, "Red", Vec3::ZERO).dist(expected) < 1e-6, "{label}: {:?}", place(&s, "Red", Vec3::ZERO));
assert_eq!(dof_of(&mut s, "Red"), 1, "{label}");
let axes = solidcraft_doc::joints::motion_axes(&s.doc, &s.model.state(), occ(&s, "Red"));
assert!(axes.len() == 1 && !axes.iter().any(|a| a.angular), "{label}: {axes:?}");
}
}
}
/// #10331, with the board turned on the table first (the report's board was turned 40 degrees):
/// a second planar joint between any side of the yellow board and any side of the red one meets,
/// whichever turn the red board needs on the first joint to get there.
#[test]
fn any_two_sides_of_turned_boards_meet_on_a_second_planar_joint() {
// The sides' centres, the red ones where the red board was made.
let reds = [
("red front", Vec3::new(200.0, 300.0, 10.0)),
("red back", Vec3::new(200.0, 400.0, 10.0)),
("red left end", Vec3::new(0.0, 350.0, 10.0)),
("red right end", Vec3::new(400.0, 350.0, 10.0)),
];
let yellows = [
("yellow front", [200.0, 0.0, 10.0]),
("yellow back", [200.0, 100.0, 10.0]),
("yellow left end", [0.0, 50.0, 10.0]),
("yellow right end", [400.0, 50.0, 10.0]),
];
for turn in [40.0f64, 0.0, 137.0] {
for (yn, yp) in yellows {
for (rn, rl) in reds {
let mut s = boards();
run(
&mut s,
"occurrence.move",
json!({"occurrence": "Red:1", "space": "world", "axis": [0, 0, 1], "angle": format!("{turn} deg"), "origin": [200, 350, 0]}),
);
let top = place(&s, "Red", Vec3::new(200.0, 350.0, 0.0));
run(
&mut s,
"joint.create",
json!({"type": "planar", "a": {"occurrence": "Yellow", "face": [200, 50, 20]}, "b": {"occurrence": "Red", "face": [top.x, top.y, top.z]}, "name": "Top"}),
);
let rp = place(&s, "Red", rl);
let r = run(
&mut s,
"joint.create",
json!({"type": "planar", "a": {"occurrence": "Yellow", "face": yp}, "b": {"occurrence": "Red", "face": [rp.x, rp.y, rp.z]}, "name": "Side"}),
);
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "turned {turn} degrees, {yn} against {rn}: {r}");
}
}
}
}
/// #9687: a second planar joint left as a conflict, as a design saved before joint.create turned
/// its part a half turn keeps it, meets when Edit Joint's OK places it again, and one unsuppressed
/// after its part was turned away on the first joint meets too. A rename alone moves nothing.
#[test]
fn editing_or_unsuppressing_a_conflicting_second_planar_joint_turns_its_part_to_meet() {
let conflicts = |r: &Value| r["conflicts"].as_array().map(Vec::len);
let values = |s: &Session, name: &str| s.doc.assembly.joints.iter().find(|j| j.name == name).map(|j| j.values.clone()).unwrap_or_default();
let pose = |s: &Session| [Vec3::ZERO, Vec3::X, Vec3::Y, Vec3::Z].map(|p| place(s, "Red", p));
let mut s = boards();
let planar = |s: &mut Session, name: &str, yellow: [f64; 3], red: [f64; 3]| {
run(
s,
"joint.create",
json!({"type": "planar", "a": {"occurrence": "Yellow", "face": yellow}, "b": {"occurrence": "Red", "face": red}, "name": name}),
)
};
planar(&mut s, "Top", [200.0, 50.0, 20.0], [200.0, 350.0, 0.0]);
let on_top = values(&s, "Top");
// The fronts point the same way: Side meets with Red turned a half turn on Top.
let r = planar(&mut s, "Side", [200.0, 0.0, 10.0], [200.0, 0.0, 30.0]);
assert_eq!(conflicts(&r), Some(0), "{r}");
let met = pose(&s);
// Red as it met, slid along the line the two planes share (X) at most.
let meets = |s: &Session| {
let now = pose(s);
let dx = Vec3::new(now[0].x - met[0].x, 0.0, 0.0);
now.iter().zip(&met).all(|(p, q)| near(*p, *q + dx))
};
// As a design saved before joint.create turned Red: Top's values from before Side.
if let Some(j) = s.doc_mut().assembly.joints.iter_mut().find(|j| j.name == "Top") {
j.values = on_top;
}
let r = run(&mut s, "joint.solve", json!({}));
assert_eq!(conflicts(&r), Some(1), "{r}");
let saved = pose(&s);
assert!(!meets(&s), "{saved:?}");
let r = run(&mut s, "joint.edit", json!({"joint": "Side", "name": "Front"}));
assert_eq!(conflicts(&r), Some(1), "a rename: {r}");
assert!(pose(&s).iter().zip(&saved).all(|(p, q)| near(*p, *q)), "a rename moved Red: {:?}", pose(&s));
// Edit Joint's OK sends the type, flip and offset.
let r = run(&mut s, "joint.edit", json!({"joint": "Front", "type": "planar", "flip": false, "offset": 0}));
assert_eq!(conflicts(&r), Some(0), "Edit Joint's OK: {r}");
assert!(meets(&s), "Edit Joint's OK: {:?}", pose(&s));
assert_eq!(dof_of(&mut s, "Red"), 1);
// Suppressed, Red turned a half turn away on Top, then unsuppressed.
run(&mut s, "joint.edit", json!({"joint": "Front", "suppressed": true}));
let angle = values(&s, "Top").get(2).copied().unwrap_or(f64::NAN).to_degrees();
run(&mut s, "joint.drive", json!({"joint": "Top", "index": 2, "value": angle + 180.0}));
assert!(!meets(&s), "turned away: {:?}", pose(&s));
let r = run(&mut s, "joint.edit", json!({"joint": "Front", "suppressed": false}));
assert_eq!(conflicts(&r), Some(0), "unsuppressed: {r}");
assert!(meets(&s), "unsuppressed: {:?}", pose(&s));
}
/// #9687: a frame held by many planar joints ties its loops into one group with more values than
/// the loop solver moves at once, which was then only checked: a new joint closing a loop in it
/// stayed a conflict, and a drive in it moved nothing. A table on the ground, parts each on the
/// table and on the ground (11 parts: 70 values with the peg), and a peg 10 mm from where P0's
/// pin point sits: P0 slides onto it as it does with one part, and turns about it when driven.
#[test]
fn a_loop_in_a_group_over_the_solvers_values_still_closes_and_drives() {
let conflicts = |r: &Value| r["conflicts"].as_array().map(Vec::len);
for parts in [1usize, 11] {
let mut s = Session::default();
part(&mut s, "Ground", [-1.0, -1.0, -2.0]);
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
part(&mut s, "Table", [-1.0, -1.0, 0.0]);
pin(&mut s, "planar", "Base", "Ground", "Table", Vec3::ZERO, Vec3::Z);
for k in 0..parts {
let (name, c) = (format!("P{k}"), Vec3::new(10.0 * k as f64, 20.0, 0.0));
part(&mut s, &name, [c.x - 1.0, c.y - 1.0, 0.0]);
pin(&mut s, "planar", &format!("{name} on table"), "Table", &name, c, Vec3::Z);
pin(&mut s, "planar", &format!("{name} on ground"), "Ground", &name, c, Vec3::Z);
}
let at = |o: &str, p: [f64; 3]| json!({"occurrence": o, "point": p, "z": [0, 0, 1]});
let peg = json!({"type": "revolute", "name": "Peg", "a": at("Ground", [10.0, 20.0, 0.0]), "b": at("P0", [0.0, 20.0, 0.0]), "flip": true});
let r = run(&mut s, "joint.create", peg);
assert_eq!(conflicts(&r), Some(0), "{parts} parts: {r}");
let pin_point = Vec3::new(10.0, 20.0, 0.0);
assert!(near(place(&s, "P0", Vec3::new(0.0, 20.0, 0.0)), pin_point), "{parts} parts: {:?}", place(&s, "P0", Vec3::new(0.0, 20.0, 0.0)));
// P0's point 1 mm along X from its pin point (closing the loop may have turned P0 a little
// about the peg), then 30 degrees further round.
let (p, q0) = (Vec3::new(1.0, 20.0, 0.0), place(&s, "P0", Vec3::new(1.0, 20.0, 0.0)));
let turn = s.doc.assembly.joints.iter().find(|j| j.name == "Peg").and_then(|j| j.values.first().copied()).unwrap_or(f64::NAN);
let r = run(&mut s, "joint.drive", json!({"joint": "Peg", "value": turn.to_degrees() + 30.0}));
assert!(r["stopped_by_loop"].is_null() && conflicts(&r) == Some(0), "{parts} parts: {r}");
let (a, b) = (q0 - pin_point, place(&s, "P0", p) - pin_point);
let sin = a.x * b.y - a.y * b.x;
assert!((b.len() - 1.0).abs() < 1e-6 && (sin.abs() - 0.5).abs() < 1e-6 && b.z.abs() < 1e-6, "{parts} parts: {a:?} to {b:?}");
}
}
/// A slider-crank: crank 15 about the origin, rod 40, a piston sliding along X. Returns the crank
/// pin and the wrist pin.
fn slider_crank() -> (Session, Vec3, Vec3) {
let mut s = Session::default();
let (o, p0) = (Vec3::ZERO, Vec3::new(0.0, 15.0, 0.0));
let s0 = Vec3::new((40.0f64 * 40.0 - 15.0 * 15.0).sqrt(), 0.0, 0.0);
for (name, c) in [("Ground", o), ("Crank", p0), ("Rod", s0 * 0.5), ("Piston", s0)] {
part(&mut s, name, [c.x, c.y, -5.0]);
}
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
pin(&mut s, "revolute", "Crank", "Ground", "Crank", o, Vec3::Z);
pin(&mut s, "revolute", "Crank pin", "Crank", "Rod", p0, Vec3::Z);
pin(&mut s, "revolute", "Wrist pin", "Rod", "Piston", s0, Vec3::Z);
pin(&mut s, "slider", "Bore", "Ground", "Piston", s0, Vec3::X);
(s, p0, s0)
}
/// The piston sits at a·cos θ + √(b² − (a·sin θ)²).
#[test]
fn slider_crank_moves_the_piston() {
let (mut s, p0, s0) = slider_crank();
for v in [40.0, 135.0, 270.0] {
let r = run(&mut s, "joint.drive", json!({"joint": "Crank", "value": v}));
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{v}°: {r}");
let th = (90.0f64 + v).to_radians();
let x = 15.0 * th.cos() + (40.0f64.powi(2) - (15.0 * th.sin()).powi(2)).sqrt();
assert!(near(place(&s, "Piston", s0), Vec3::new(x, 0.0, 0.0)), "{v}°: {:?} wants x = {x}", place(&s, "Piston", s0));
assert!(near(place(&s, "Rod", p0), Vec3::new(15.0 * th.cos(), 15.0 * th.sin(), 0.0)));
}
}
/// A slotted-arm drive: a clamp turns about the origin (Yaw) and carries a pin 26 from it; an arm
/// turns about a shaft 52 out on a motor fixed to the ground, and the pin slides in the arm's slot
/// (Slot: its frame at the shaft, x along the slot towards the pin). Every joint of the loop
/// moves when it does, the slot's included. The pin's face sits `gap` mm off the arm's along
/// the axes: a gap no value of the loop takes out, within the conflict check.
fn slotted_arm(yaw_first: bool, gap: f64) -> Session {
let mut s = Session::default();
for (name, x) in [("Ground", 0.0), ("Clamp", 26.0), ("Motor", 52.0), ("Arm", 40.0)] {
part(&mut s, name, [x - 1.0, -1.0, -5.0]);
}
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
// The joint order sets the tree: with the yaw first, the arm hangs from the clamp through the
// slot and the arm's shaft closes the loop; with the motor first, the slot closes it.
if yaw_first {
pin(&mut s, "revolute", "Yaw", "Ground", "Clamp", Vec3::ZERO, Vec3::Z);
}
pin(&mut s, "rigid", "Mount", "Ground", "Motor", Vec3::new(52.0, 0.0, 0.0), Vec3::Z);
if !yaw_first {
pin(&mut s, "revolute", "Yaw", "Ground", "Clamp", Vec3::ZERO, Vec3::Z);
}
pin(&mut s, "revolute", "Shaft", "Arm", "Motor", Vec3::new(52.0, 0.0, 0.0), Vec3::Z);
let r = run(
&mut s,
"joint.create",
json!({"type": "pin_slot", "a": framed("Arm", [52.0, 0.0, 0.0], [0.0, 0.0, 1.0], [-1.0, 0.0, 0.0]),
"b": framed("Clamp", [26.0, 0.0, gap], [0.0, 0.0, 1.0], [-1.0, 0.0, 0.0]), "flip": true, "values": [0, 26], "name": "Slot"}),
);
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
s
}
/// A joint's stored values.
fn values_of(s: &Session, joint: &str) -> Vec<f64> {
s.doc.assembly.joints.iter().find(|j| j.name == joint).map(|j| j.values.clone()).unwrap_or_default()
}
/// Driving either end of the slotted arm moves the other: the arm turns atan(26 sin θ / (52 −
/// 26 cos θ)) for a yaw θ, and the pin slides out from 26 to √(26² + 52² − 2·26·52 cos θ).
#[test]
fn slotted_arm_drives_both_ways() {
for (yaw_first, gap) in [(false, 0.0), (true, 0.0), (false, 3e-8), (true, 3e-8)] {
slotted_arm_drives(yaw_first, gap);
}
}
fn slotted_arm_drives(yaw_first: bool, gap: f64) {
let mut s = slotted_arm(yaw_first, gap);
let (shaft, pin_at) = (Vec3::new(52.0, 0.0, 0.0), Vec3::new(26.0, 0.0, 0.0));
let check = |s: &Session, what: &str| {
let th = values_of(s, "Yaw").first().copied().unwrap_or(f64::NAN);
let p = Vec3::new(26.0 * th.cos(), 26.0 * th.sin(), 0.0);
assert!(near(place(s, "Clamp", pin_at), p), "{what}: pin {:?} wants {p:?}", place(s, "Clamp", pin_at));
let arm = values_of(s, "Shaft").first().copied().unwrap_or(f64::NAN);
let want = (26.0 * th.sin()).atan2(52.0 - 26.0 * th.cos());
assert!((arm.abs() - want.abs()).abs() < 1e-6, "{what}: arm {arm} wants ±{want}");
// The arm's slot points at the pin, which sits as far out as the slot says.
let tip = place(s, "Arm", Vec3::new(40.0, 0.0, 0.0));
let along = (p - shaft) * (1.0 / (p - shaft).len());
assert!(near(tip, shaft + along * 12.0), "{what}: arm tip {tip:?}");
let slide = values_of(s, "Slot").get(1).copied().unwrap_or(f64::NAN);
assert!((slide.abs() - (p - shaft).len()).abs() < 1e-6, "{what}: slide {slide} wants {}", (p - shaft).len());
};
check(&s, &format!("yaw first {yaw_first}, gap {gap}, at rest"));
for v in [10.0, 40.0, -40.0, 0.0] {
let r = run(&mut s, "joint.drive", json!({"joint": "Yaw", "value": v}));
assert!(
r["stopped_by_loop"].is_null() && r["conflicts"].as_array().map(Vec::len) == Some(0),
"yaw first {yaw_first}, gap {gap}, yaw {v}°: {r}"
);
assert!((values_of(&s, "Yaw").first().copied().unwrap_or(f64::NAN) - f64::to_radians(v)).abs() < 1e-9);
check(&s, &format!("yaw first {yaw_first}, gap {gap}, yaw {v}°"));
}
let slide = values_of(&s, "Slot").get(1).copied().unwrap_or(f64::NAN).abs();
assert!((slide - 26.0).abs() < 1e-6, "{slide}");
for v in [15.0, -27.0, 27.0] {
let r = run(&mut s, "joint.drive", json!({"joint": "Shaft", "value": v}));
assert!(
r["stopped_by_loop"].is_null() && r["conflicts"].as_array().map(Vec::len) == Some(0),
"yaw first {yaw_first}, gap {gap}, arm {v}°: {r}"
);
assert!((values_of(&s, "Shaft").first().copied().unwrap_or(f64::NAN) - f64::to_radians(v)).abs() < 1e-9);
check(&s, &format!("yaw first {yaw_first}, gap {gap}, arm {v}°"));
}
// The clamp's pin reaches a point on its circle, the arm following.
let (th, at) = (20f64.to_radians(), place(&s, "Clamp", pin_at));
let r = run(&mut s, "joint.reach", json!({"occurrence": "Clamp", "at": [at.x, at.y, at.z], "point": [26.0 * th.cos(), 26.0 * th.sin(), 0.0]}));
assert!(r["reached"] == json!(true) && r["stopped_by_loop"].is_null(), "yaw first {yaw_first}, gap {gap}, reach: {r}");
check(&s, &format!("yaw first {yaw_first}, gap {gap}, reach"));
// A limit on the arm stops the yaw where the arm meets it.
run(&mut s, "joint.limits", json!({"joint": "Shaft", "min": -20, "max": 20}));
let r = run(&mut s, "joint.drive", json!({"joint": "Yaw", "value": 40}));
assert!(r["stopped_by_loop"].is_object() && r["conflicts"].as_array().map(Vec::len) == Some(0), "yaw first {yaw_first}, gap {gap}, limit: {r}");
check(&s, &format!("yaw first {yaw_first}, gap {gap}, limit"));
let arm = values_of(&s, "Shaft").first().copied().unwrap_or(f64::NAN).abs().to_degrees();
assert!(arm > 19.9 && arm <= 20.0 + 1e-9, "yaw first {yaw_first}, gap {gap}: the arm stopped at {arm}°");
}
/// The four-bar with its rocker a rod on an axle (a cylindrical joint), and the rocker pin
/// joining the coupler to the rod 4 mm up the axle from where the rod sits, its axis turned
/// `tilt` rad from the others about Y. Returns the closing joint's answer and the rocker pin.
fn rod_on_an_axle(tilt: f64) -> (Session, Value, Vec3) {
let mut s = Session::default();
let (o2, o4, p0) = (Vec3::ZERO, Vec3::new(45.0, 0.0, 0.0), Vec3::new(0.0, 20.0, 0.0));
let [q0, _] = meet(p0, 50.0, o4, 40.0);
for (name, c) in [("Ground", o2), ("Crank", p0), ("Coupler", (p0 + q0) * 0.5), ("Rod", q0)] {
part(&mut s, name, [c.x, c.y, -5.0]);
}
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
pin(&mut s, "revolute", "Crank", "Ground", "Crank", o2, Vec3::Z);
pin(&mut s, "revolute", "Crank pin", "Crank", "Coupler", p0, Vec3::Z);
pin(&mut s, "cylindrical", "Axle", "Ground", "Rod", o4, Vec3::Z);
let z = [tilt.sin(), 0.0, tilt.cos()];
let r = run(
&mut s,
"joint.create",
json!({"type": "revolute", "a": {"occurrence": "Coupler", "point": [q0.x, q0.y, 0.0], "z": z},
"b": {"occurrence": "Rod", "point": [q0.x, q0.y, 4.0], "z": z}, "flip": true, "name": "Rocker pin"}),
);
(s, r, q0)
}
/// Axes of holes picked on parts are seldom exactly parallel (#6211: a few hundredths of a
/// microradian apart on a lever). A closed loop through them leaves a gap of nanometres no value
/// takes out; it still closes, the rod sliding down its axle, and follows its crank. A tilt that
/// shows still locks it.
#[test]
fn a_loop_whose_axes_are_a_hair_out_of_parallel_still_moves() {
let (mut s, r, q0) = rod_on_an_axle(1e-7);
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
let up = Vec3::new(0.0, 0.0, 4.0);
let close = |a: Vec3, b: Vec3| a.dist(b) < 1e-4;
assert!(close(place(&s, "Rod", q0 + up), q0), "{:?}", place(&s, "Rod", q0 + up));
for part in ["Crank", "Coupler", "Rod"] {
assert_eq!(dof_of(&mut s, part), 1, "{part}");
}
for v in [30.0, 60.0, -45.0] {
let r = run(&mut s, "joint.drive", json!({"joint": "Crank", "value": v}));
assert!(r["stopped_by_loop"].is_null() && r["conflicts"].as_array().map(Vec::len) == Some(0), "{v}°: {r}");
let q = rocker_pin(0.0, v, q0);
assert!(close(place(&s, "Rod", q0 + up), q), "{v}°: {:?} wants {q:?}", place(&s, "Rod", q0 + up));
}
// Dragged by its crank pin (the viewport's drag of a part joints hold), the rod follows too.
let (at, th) = (place(&s, "Crank", Vec3::new(0.0, 20.0, 0.0)), 110f64.to_radians());
let r = run(&mut s, "joint.reach", json!({"occurrence": "Crank", "at": [at.x, at.y, at.z], "point": [20.0 * th.cos(), 20.0 * th.sin(), 0.0]}));
assert!(r["reached"] == json!(true) && r["stopped_by_loop"].is_null(), "{r}");
let q = rocker_pin(0.0, 20.0, q0);
assert!(close(place(&s, "Rod", q0 + up), q), "reach: {:?} wants {q:?}", place(&s, "Rod", q0 + up));
// Tilted a milliradian, the loop is locked: no longer planar, it can't turn.
let (mut s, r, _) = rod_on_an_axle(1e-3);
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
assert_eq!(dof_of(&mut s, "Rod"), 0);
let r = run(&mut s, "joint.drive", json!({"joint": "Crank", "value": 30}));
assert!(r["stopped_by_loop"].is_object() && r["values"][0]["value"].as_f64().is_some_and(|v| v.abs() < 0.1), "{r}");
}
/// A joint frame on an occurrence, by origin and axes.
fn framed(o: &str, origin: [f64; 3], z: [f64; 3], x: [f64; 3]) -> Value {
json!({"occurrence": o, "frame": {"origin": origin, "z": z, "x": x}})
}
/// A loop open from the start closes from where it is: an arm on a revolute joint, and a rigid
/// joint that wants it turned 90°.
#[test]
fn an_open_loop_closes_from_where_it_is() {
let mut s = Session::default();
part(&mut s, "Ground", [-1.0, -1.0, -5.0]);
part(&mut s, "Arm", [0.0, -1.0, 0.0]);
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
pin(&mut s, "revolute", "Pivot", "Ground", "Arm", Vec3::ZERO, Vec3::Z);
let r = run(
&mut s,
"joint.create",
json!({"type": "rigid", "a": framed("Ground", [0.0; 3], [0.0, 0.0, 1.0], [0.0, 1.0, 0.0]),
"b": framed("Arm", [0.0; 3], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]), "flip": true, "name": "Lock"}),
);
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
assert!(near(place(&s, "Arm", Vec3::new(10.0, 0.0, 0.0)), Vec3::new(0.0, 10.0, 0.0)), "{:?}", place(&s, "Arm", Vec3::new(10.0, 0.0, 0.0)));
}
/// A loop that can't close does not hold up another one: the four-bar still drives beside a
/// block whose rigid joint wants it where its pivot can't take it.
#[test]
fn a_broken_loop_does_not_stop_another() {
let (mut s, _, q0) = four_bar();
part(&mut s, "Block", [200.0, -1.0, -5.0]);
pin(&mut s, "revolute", "Block pivot", "Ground", "Block", Vec3::new(200.0, 0.0, 0.0), Vec3::Z);
run(
&mut s,
"joint.create",
json!({"type": "rigid", "a": {"occurrence": "Ground", "point": [200, 0, 0]}, "b": {"occurrence": "Block", "point": [210, 0, 0]}, "flip": true, "name": "Wrong"}),
);
let r = run(&mut s, "joint.drive", json!({"joint": "Crank", "value": 60}));
let names: Vec<&str> = r["conflicts"].as_array().into_iter().flatten().filter_map(|c| c["name"].as_str()).collect();
assert_eq!(names, ["Wrong"], "{r}");
assert!(r["stopped_by_loop"].is_null(), "{r}");
assert!(near(place(&s, "Rocker", q0), rocker_pin(0.0, 60.0, q0)), "{:?}", place(&s, "Rocker", q0));
}
/// A loop locked rigid can't move at all: driving its crank stops at once.
#[test]
fn a_locked_loop_does_not_move() {
let (mut s, _, _) = four_bar();
run(&mut s, "joint.as_built", json!({"type": "rigid", "a": "Ground", "b": "Rocker", "name": "Lock"}));
let r = run(&mut s, "joint.drive", json!({"joint": "Crank", "value": 360}));
assert!(r["stopped_by_loop"].is_object(), "{r}");
assert!(r["values"][0]["value"].as_f64().unwrap_or(f64::NAN).to_radians().abs() < 1e-3, "{r}");
}
/// A link that turns the rocker 100 times as far as its dial: a small turn of the dial is a full
/// turn of the rocker, which it can't make.
#[test]
fn a_geared_down_loop_value_is_followed_all_the_way() {
let (mut s, _, _) = four_bar();
part(&mut s, "Dial", [80.0, 0.0, -5.0]);
pin(&mut s, "revolute", "Dial", "Ground", "Dial", Vec3::new(80.0, 0.0, 0.0), Vec3::Z);
run(&mut s, "joint.motion_link", json!({"a": "Dial", "b": "Rocker", "ratio": 100}));
let r = run(&mut s, "joint.drive", json!({"joint": "Dial", "value": 3.6}));
assert!(r["stopped_by_loop"].is_object(), "{r}");
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
}
/// A suppressed dial still turns the rocker through its motion link, and a rocker whose value
/// the file leaves out starts from 0: both are followed all the way, so a full turn stops.
#[test]
fn a_full_turn_stops_from_a_suppressed_dial_or_a_missing_value() {
let (mut s, _, _) = four_bar();
part(&mut s, "Dial", [80.0, 0.0, -5.0]);
pin(&mut s, "revolute", "Dial", "Ground", "Dial", Vec3::new(80.0, 0.0, 0.0), Vec3::Z);
run(&mut s, "joint.motion_link", json!({"a": "Dial", "b": "Rocker", "ratio": 0.5}));
run(&mut s, "joint.edit", json!({"joint": "Dial", "suppressed": true}));
let r = run(&mut s, "joint.drive", json!({"joint": "Dial", "value": 720}));
assert!(r["stopped_by_loop"].is_object() && r["moved"] == true && r.get("reason").is_none(), "{r}");
// Undriven, the suppressed dial still follows the rocker when the crank turns.
run(&mut s, "joint.drive", json!({"joint": "Dial", "value": 0}));
let r = run(&mut s, "joint.drive", json!({"joint": "Crank", "value": 60}));
assert!(r["stopped_by_loop"].is_null() && r["conflicts"].as_array().map(Vec::len) == Some(0), "{r}");
let (mut s, _, _) = four_bar();
if let Some(j) = s.doc_mut().assembly.joints.iter_mut().find(|j| j.name == "Rocker") {
j.values.clear();
}
let r = run(&mut s, "joint.drive", json!({"joint": "Rocker", "value": 360}));
assert!(r["stopped_by_loop"].is_object(), "{r}");
}
/// Loops that only share a rigid joint are independent: an arm whose lock can't close does not
/// stop another arm, beside it on the same rigidly mounted base, from closing its own loop.
#[test]
fn loops_sharing_only_a_rigid_joint_are_solved_apart() {
let mut s = Session::default();
for (name, x) in [("Ground", -1.0), ("Base", -1.0), ("Arm", 0.0), ("Other", 100.0)] {
part(&mut s, name, [x, -1.0, 0.0]);
}
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
run(&mut s, "joint.as_built", json!({"type": "rigid", "a": "Ground", "b": "Base", "name": "Mount"}));
pin(&mut s, "revolute", "Pivot", "Base", "Arm", Vec3::ZERO, Vec3::Z);
pin(&mut s, "revolute", "Other pivot", "Base", "Other", Vec3::new(100.0, 0.0, 0.0), Vec3::Z);
run(
&mut s,
"joint.create",
json!({"type": "rigid", "a": {"occurrence": "Ground", "point": [100, 0, 0]}, "b": {"occurrence": "Other", "point": [110, 0, 0]}, "flip": true, "name": "Wrong"}),
);
let r = run(
&mut s,
"joint.create",
json!({"type": "rigid", "a": framed("Ground", [0.0; 3], [0.0, 0.0, 1.0], [0.0, 1.0, 0.0]),
"b": framed("Arm", [0.0; 3], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]), "flip": true, "name": "Lock"}),
);
// The broken loop is reported (on whichever of its joints closes it), the arm's is not.
let names: Vec<&str> = r["conflicts"].as_array().into_iter().flatten().filter_map(|c| c["name"].as_str()).collect();
assert!(names.len() == 1 && ["Wrong", "Other pivot"].contains(&names[0]), "{r}");
assert!(near(place(&s, "Arm", Vec3::new(10.0, 0.0, 0.0)), Vec3::new(0.0, 10.0, 0.0)), "{:?}", place(&s, "Arm", Vec3::new(10.0, 0.0, 0.0)));
}
/// Two links writing one value: whichever carries a driven dial's turn into the loop, the turn
/// is followed (here dial A turns gear B, which turns the rocker, before dial D rewrites B).
#[test]
fn a_turn_carried_in_by_any_link_is_followed() {
let (mut s, _, _) = four_bar();
for (name, x) in [("A", 80.0), ("B", 100.0), ("D", 120.0)] {
part(&mut s, name, [x, 0.0, -5.0]);
pin(&mut s, "revolute", name, "Ground", name, Vec3::new(x, 0.0, 0.0), Vec3::Z);
}
run(&mut s, "joint.motion_link", json!({"a": "A", "b": "B", "ratio": 1}));
run(&mut s, "joint.motion_link", json!({"a": "B", "b": "Rocker", "ratio": 0.5}));
run(&mut s, "joint.motion_link", json!({"a": "D", "b": "B", "ratio": 1}));
let r = run(&mut s, "joint.drive", json!({"joint": "A", "value": 720}));
assert!(r["stopped_by_loop"].is_object(), "{r}");
}
/// Several links writing one value: every value a link chain starts from can move to close the
/// loop, whichever of them the link order lets through (here dial A's, before dial B rewrites
/// the gear).
#[test]
fn a_loop_value_moves_through_whichever_link_carries_it() {
let (mut s, _, q0) = four_bar();
for (name, x) in [("A", 80.0), ("G", 100.0), ("B", 120.0)] {
part(&mut s, name, [x, 0.0, -5.0]);
pin(&mut s, "revolute", name, "Ground", name, Vec3::new(x, 0.0, 0.0), Vec3::Z);
}
run(&mut s, "joint.motion_link", json!({"a": "A", "b": "G", "ratio": 1}));
run(&mut s, "joint.motion_link", json!({"a": "G", "b": "Rocker", "ratio": 1}));
run(&mut s, "joint.motion_link", json!({"a": "B", "b": "G", "ratio": 1}));
let r = run(&mut s, "joint.drive", json!({"joint": "Crank", "value": 60}));
assert!(r["stopped_by_loop"].is_null() && r["conflicts"].as_array().map(Vec::len) == Some(0), "{r}");
assert!(near(place(&s, "Rocker", q0), rocker_pin(0.0, 60.0, q0)), "{:?}", place(&s, "Rocker", q0));
}
/// Two values of one joint can feed two independent loops: a puck's x drives a pair of parallel
/// slides, its y a slide whose rigid lock can't close. Driving x moves the healthy pair.
#[test]
fn values_of_one_joint_feed_independent_loops() {
let mut s = Session::default();
for (name, y) in [("Ground", -10.0), ("Puck", -20.0), ("Car", 50.0), ("Other", 100.0)] {
part(&mut s, name, [-1.0, y, 0.0]);
}
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
let flat = |o: &str| framed(o, [0.0, -20.0, 0.0], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]);
run(&mut s, "joint.create", json!({"type": "planar", "a": flat("Ground"), "b": flat("Puck"), "flip": true, "name": "Table"}));
pin(&mut s, "slider", "Rail", "Ground", "Car", Vec3::new(0.0, 50.0, 0.0), Vec3::X);
pin(&mut s, "slider", "Guide", "Ground", "Car", Vec3::new(10.0, 50.0, 0.0), Vec3::X);
pin(&mut s, "slider", "Lift", "Ground", "Other", Vec3::new(0.0, 100.0, 0.0), Vec3::Y);
run(
&mut s,
"joint.create",
json!({"type": "rigid", "a": {"occurrence": "Ground", "point": [0, 100, 0]}, "b": {"occurrence": "Other", "point": [10, 100, 0]}, "flip": true, "name": "Wrong"}),
);
run(&mut s, "joint.motion_link", json!({"a": "Table", "ia": 0, "b": "Rail", "ratio": 1}));
run(&mut s, "joint.motion_link", json!({"a": "Table", "ia": 1, "b": "Lift", "ratio": 1}));
let r = run(&mut s, "joint.drive", json!({"joint": "Table", "values": [10]}));
assert!(r["stopped_by_loop"].is_null(), "{r}");
let names: Vec<&str> = r["conflicts"].as_array().into_iter().flatten().filter_map(|c| c["name"].as_str()).collect();
assert_eq!(names, ["Wrong"], "{r}");
assert!(near(place(&s, "Car", Vec3::new(0.0, 50.0, 0.0)), Vec3::new(10.0, 50.0, 0.0)), "{:?}", place(&s, "Car", Vec3::new(0.0, 50.0, 0.0)));
}
/// Two loops can move different values of one joint: each keeps what it moved. A table's x
/// feeds one pair of parallel slides and its y another; a study drives both pairs.
#[test]
fn loops_moving_different_values_of_one_joint_keep_both() {
let mut s = Session::default();
for (name, y) in [("Ground", -10.0), ("Puck", -20.0), ("CarA", 50.0), ("CarB", 100.0)] {
part(&mut s, name, [-1.0, y, 0.0]);
}
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
let flat = |o: &str| framed(o, [0.0, -20.0, 0.0], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]);
run(&mut s, "joint.create", json!({"type": "planar", "a": flat("Ground"), "b": flat("Puck"), "flip": true, "name": "Table"}));
for (car, y) in [("CarA", 50.0), ("CarB", 100.0)] {
pin(&mut s, "slider", &format!("{car} rail"), "Ground", car, Vec3::new(0.0, y, 0.0), Vec3::X);
pin(&mut s, "slider", &format!("{car} guide"), "Ground", car, Vec3::new(10.0, y, 0.0), Vec3::X);
}
run(&mut s, "joint.motion_link", json!({"a": "Table", "ia": 0, "b": "CarA rail", "ratio": 1}));
run(&mut s, "joint.motion_link", json!({"a": "Table", "ia": 1, "b": "CarB rail", "ratio": 1}));
let keys = json!([{"joint": "CarA guide", "points": [[0, 0], [10, 10]]}, {"joint": "CarB guide", "points": [[0, 0], [10, 20]]}]);
run(&mut s, "motion.study", json!({"name": "Both", "steps": 10, "keys": keys}));
let r = run(&mut s, "motion.play", json!({"study": "Both", "step": 10}));
assert!(r["stopped_by_loop"].is_null(), "{r}");
let table = s.doc.assembly.joints.iter().find(|j| j.name == "Table").map(|j| j.values.clone()).unwrap_or_default();
assert!(table.len() == 3 && (table[0] - 10.0).abs() < 1e-6 && (table[1] - 20.0).abs() < 1e-6, "{table:?}");
// A solve with nothing driven leaves them where they are.
run(&mut s, "joint.solve", json!({}));
assert!(near(place(&s, "CarA", Vec3::new(0.0, 50.0, 0.0)), Vec3::new(10.0, 50.0, 0.0)), "{:?}", place(&s, "CarA", Vec3::new(0.0, 50.0, 0.0)));
assert!(near(place(&s, "CarB", Vec3::new(0.0, 100.0, 0.0)), Vec3::new(20.0, 100.0, 0.0)), "{:?}", place(&s, "CarB", Vec3::new(0.0, 100.0, 0.0)));
}
/// A clamped link can jump: a 100:1 link to a rocker limited to a full turn reaches its limit
/// after the dial's first few degrees, back where it started. Each step is checked, so the drive
/// still stops where the rocker can't go.
#[test]
fn a_clamped_link_is_followed_step_by_step() {
let (mut s, _, _) = four_bar();
part(&mut s, "Dial", [80.0, 0.0, -5.0]);
pin(&mut s, "revolute", "Dial", "Ground", "Dial", Vec3::new(80.0, 0.0, 0.0), Vec3::Z);
run(&mut s, "joint.limits", json!({"joint": "Rocker", "min": 0, "max": 360}));
run(&mut s, "joint.motion_link", json!({"a": "Dial", "b": "Rocker", "ratio": 100}));
let r = run(&mut s, "joint.drive", json!({"joint": "Dial", "value": 360}));
assert!(r["stopped_by_loop"].is_object(), "{r}");
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{r}");
}
/// Each occurrence's degrees of freedom as `joint.list` reports them.
fn dof_of(s: &mut Session, component: &str) -> u64 {
let o = occ(s, component);
let l = run(s, "joint.list", json!({}));
l["dof"].as_array().into_iter().flatten().find(|d| d["occurrence"] == o).and_then(|d| d["dof"].as_u64()).unwrap_or(99)
}
/// Loops take degrees of freedom away: a four-bar's moving parts have one between them (its
/// mobility), a part hinged to the coupler one more, a slider-crank one, a parallelogram one, and a
/// four-bar locked rigid none.
#[test]
fn loops_report_their_mobility() {
let (mut s, p0, q0) = four_bar();
for (part, want) in [("Ground", 0), ("Crank", 1), ("Coupler", 1), ("Rocker", 1)] {
assert_eq!(dof_of(&mut s, part), want, "four-bar {part}");
}
// Still one after a drive moved it.
run(&mut s, "joint.drive", json!({"joint": "Crank", "value": 70}));
assert_eq!(dof_of(&mut s, "Coupler"), 1);
// A flag hinged to the coupler half-way along: one more.
let mid = (p0 + q0) * 0.5;
part(&mut s, "Flag", [mid.x, mid.y, 5.0]);
run(&mut s, "joint.as_built", json!({"type": "revolute", "a": "Coupler", "b": "Flag", "name": "Flag hinge"}));
assert_eq!(dof_of(&mut s, "Flag"), 2);
// Still two when a rotor elsewhere turns the flag's hinge through a motion link.
part(&mut s, "Rotor", [100.0, 0.0, -5.0]);
pin(&mut s, "revolute", "Rotor", "Ground", "Rotor", Vec3::new(100.0, 0.0, 0.0), Vec3::Z);
run(&mut s, "joint.motion_link", json!({"a": "Rotor", "b": "Flag hinge", "ratio": 1}));
assert_eq!(dof_of(&mut s, "Flag"), 2);
// A rotor locked by a loop of its own leaves the flag only the mechanism's one.
run(&mut s, "joint.as_built", json!({"type": "rigid", "a": "Ground", "b": "Rotor", "name": "Rotor lock"}));
assert_eq!(dof_of(&mut s, "Flag"), 1);
// Locked: nothing moves.
let (mut s, _, _) = four_bar();
run(&mut s, "joint.as_built", json!({"type": "rigid", "a": "Ground", "b": "Rocker", "name": "Lock"}));
for part in ["Crank", "Coupler", "Rocker"] {
assert_eq!(dof_of(&mut s, part), 0, "locked {part}");
}
// A rotor whose turn a motion link carries into the locked crank can't turn either.
part(&mut s, "Rotor", [100.0, 0.0, -5.0]);
pin(&mut s, "revolute", "Rotor", "Ground", "Rotor", Vec3::new(100.0, 0.0, 0.0), Vec3::Z);
run(&mut s, "joint.motion_link", json!({"a": "Rotor", "b": "Crank", "ratio": 1}));
assert_eq!(dof_of(&mut s, "Rotor"), 0);
let (mut s, _, _) = slider_crank();
for part in ["Crank", "Rod", "Piston"] {
assert_eq!(dof_of(&mut s, part), 1, "slider-crank {part}");
}
// A parallelogram (crank and rocker 20, ground and coupler 45), away from its folded poses.
let mut s = Session::default();
let (o2, o4) = (Vec3::ZERO, Vec3::new(45.0, 0.0, 0.0));
let (p, q) = (Vec3::new(12.0, 16.0, 0.0), Vec3::new(57.0, 16.0, 0.0));
for (name, c) in [("Ground", o2), ("Crank", p), ("Coupler", (p + q) * 0.5), ("Rocker", q)] {
part(&mut s, name, [c.x, c.y, -5.0]);
}
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
pin(&mut s, "revolute", "Crank", "Ground", "Crank", o2, Vec3::Z);
pin(&mut s, "revolute", "Crank pin", "Crank", "Coupler", p, Vec3::Z);
pin(&mut s, "revolute", "Rocker pin", "Coupler", "Rocker", q, Vec3::Z);
pin(&mut s, "revolute", "Rocker", "Ground", "Rocker", o4, Vec3::Z);
for part in ["Crank", "Coupler", "Rocker"] {
assert_eq!(dof_of(&mut s, part), 1, "parallelogram {part}");
}
}
/// An actuator in line with the path of its tip pin, as modelled: a panel hinged at the origin,
/// its tip pin at (30, 0) moving along Y, and a barrel and rod along Y from a root pin at
/// (30, -40). There the rod only extends and the barrel's turn is zero to first order, but the
/// barrel turns as soon as the panel does: it has one degree of freedom, at that pose too.
#[test]
fn a_part_at_a_dead_point_of_its_loop_keeps_its_mobility() {
let mut s = Session::default();
let (tip, root) = (Vec3::new(30.0, 0.0, 0.0), Vec3::new(30.0, -40.0, 0.0));
for (name, c) in [("Ground", Vec3::new(0.0, -40.0, 0.0)), ("Panel", tip), ("Barrel", root), ("Rod", (tip + root) * 0.5)] {
part(&mut s, name, [c.x, c.y, -5.0]);
}
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
pin(&mut s, "revolute", "Hinge", "Ground", "Panel", Vec3::ZERO, Vec3::Z);
pin(&mut s, "revolute", "Root pin", "Ground", "Barrel", root, Vec3::Z);
pin(&mut s, "slider", "Stroke", "Barrel", "Rod", root, Vec3::Y);
pin(&mut s, "revolute", "Tip pin", "Rod", "Panel", tip, Vec3::Z);
super::solve_counts::take();
s.refresh();
assert_eq!(super::solve_counts::take().1, 0, "refresh must not repeat the singular-pose analysis");
for part in ["Panel", "Barrel", "Rod"] {
assert_eq!(dof_of(&mut s, part), 1, "dead point: {part}");
}
run(&mut s, "joint.drive", json!({"joint": "Hinge", "value": 5}));
for part in ["Panel", "Barrel", "Rod"] {
assert_eq!(dof_of(&mut s, part), 1, "driven: {part}");
}
}
/// A design file path in a fresh temporary folder (removed by the caller).
fn temp_design(tag: &str, ext: &str) -> (std::path::PathBuf, String) {
let dir = std::env::temp_dir().join(format!("solidcraft-joint-visibility-{tag}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join(format!("design.{ext}")).to_string_lossy().to_string();
(dir, path)
}
/// Two hinge leaves joined by a revolute "Hinge" and a rigid "Glue" to a third part.
fn hinged() -> Session {
let mut s = Session::default();
leaf(&mut s, "LeafA");
leaf(&mut s, "LeafB");
part(&mut s, "Tag", [60.0, 0.0, 0.0]);
let o = occ(&s, "LeafA");
run(&mut s, "occurrence.ground", json!({"occurrence": o, "grounded": true}));
run(
&mut s,
"joint.create",
json!({"type": "revolute", "a": {"occurrence": "LeafA", "circle": [1, 37, 4]}, "b": {"occurrence": "LeafB", "circle": [1, 37, 4]}, "flip": true, "name": "Hinge"}),
);
pin(&mut s, "rigid", "Glue", "LeafA", "Tag", Vec3::new(61.0, 1.0, 0.0), Vec3::new(0.0, 0.0, 1.0));
s
}
fn joint(s: &Session, name: &str) -> u64 {
s.doc.assembly.joints.iter().find(|j| j.name == name).map(|j| j.id).unwrap()
}
/// #1160: hiding a joint hides only its glyph. It is saved with the design and is an undo step
/// of its own (#2219, like other visibility), the hinge still drives its leaf while hidden, and
/// the folder hides and shows every joint at once.
#[test]
fn hidden_joints_still_drive_and_are_saved_with_the_design() {
let (dir, path) = temp_design("saved", "json");
let mut s = hinged();
let (hinge, glue) = (joint(&s, "Hinge"), joint(&s, "Glue"));
run(&mut s, "file.save", json!({"path": path}));
let undo = s.undo.len();
let r = run(&mut s, "browser.visibility", json!({"joints": ["Hinge"], "visible": false}));
assert_eq!(r["changed"], 1, "{r}");
assert!(!s.joint_visible(hinge) && s.joint_visible(glue));
assert_eq!(s.undo.len(), undo + 1, "hiding is one undo step");
assert!(s.is_dirty(), "hiding leaves unsaved changes");
let l = run(&mut s, "joint.list", json!({}));
assert_eq!(l["joints"].as_array().unwrap().iter().map(|j| j["visible"].clone()).collect::<Vec<_>>(), [json!(false), json!(true)]);
// Hidden, the hinge still constrains and moves its leaf; undoing the drive keeps it hidden.
let p = Vec3::new(20.0, 0.0, 0.0);
run(&mut s, "joint.drive", json!({"joint": "Hinge", "value": 90}));
assert!(near(place(&s, "LeafB", p), Vec3::new(20.0, 29.0, 37.0)), "{:?}", place(&s, "LeafB", p));
run(&mut s, "edit.undo", json!({}));
assert!(near(place(&s, "LeafB", p), p));
assert!(!s.joint_visible(hinge), "undo keeps the hiding");
run(&mut s, "edit.redo", json!({}));
assert!(near(place(&s, "LeafB", p), Vec3::new(20.0, 29.0, 37.0)));
// Saved and opened again, the hinge stays hidden.
run(&mut s, "file.save", json!({}));
run(&mut s, "file.new", json!({}));
run(&mut s, "doc.open", json!({"path": path}));
let (hinge, glue) = (joint(&s, "Hinge"), joint(&s, "Glue"));
assert!(!s.joint_visible(hinge) && s.joint_visible(glue), "{:?}", s.visibility);
assert!(!s.is_dirty());
let saved: Value = serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap();
assert_eq!(saved["visibility"]["hidden_joints"], json!([hinge]));
// The folder: all hidden, then all shown (and saved without any hidden joints).
run(&mut s, "browser.visibility", json!({"folder": "joints", "visible": false}));
assert!(!s.joint_visible(hinge) && !s.joint_visible(glue));
run(&mut s, "browser.visibility", json!({"folder": "joints", "visible": true}));
assert!(s.joint_visible(hinge) && s.joint_visible(glue));
// By name among other items, too.
run(&mut s, "browser.visibility", json!({"items": ["Glue"], "visible": false}));
assert!(!s.joint_visible(glue));
run(&mut s, "browser.visibility", json!({"items": ["Glue"], "visible": true}));
run(&mut s, "file.save", json!({}));
let saved: Value = serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap();
assert!(saved.get("visibility").is_none_or(|v| v.get("hidden_joints").is_none()), "{saved}");
// Bad requests change nothing.
let before = s.visibility.clone();
for p in [
json!({"joints": ["Nope"], "visible": false}),
json!({"joints": [], "visible": false}),
json!({"joints": "Hinge", "visible": false}),
json!({"joints": ["Hinge"], "folder": "joints", "visible": false}),
json!({"joints": ["Hinge"], "items": ["Glue"], "visible": false}),
] {
assert!(s.execute("browser.visibility", &p).is_err(), "{p}");
}
assert_eq!(s.visibility, before);
let _ = std::fs::remove_dir_all(&dir);
}
/// #3892: a large nested STEP assembly hides thousands of joints, and the browser asks about
/// every joint of the design on every frame: the answer must not walk the hidden-joint list,
/// so the work must not grow with the number of hidden joints. The hidden joint stays hidden,
/// the shown one stays shown, and undo and redo keep the hiding right.
#[test]
fn hidden_joint_lookups_do_not_walk_the_hidden_joint_list() {
use crate::occurrences::visibility_work;
let mut s = hinged();
let (hinge, glue) = (joint(&s, "Hinge"), joint(&s, "Glue"));
// The hidden joints of an imported assembly: thousands of ids (#3892).
let hide_many = |s: &mut Session, n: u64| {
s.visibility.hidden_joints.clear();
for id in 0..n {
s.visibility.hidden_joints.push(id);
}
};
// The entries one lookup walked, for a joint that is not hidden.
let walked_by = |s: &Session, id: u64| {
visibility_work::take();
let visible = s.joint_visible(id);
let walked = visibility_work::take();
assert!(visible, "joint {id} is not hidden here");
walked
};
hide_many(&mut s, 10);
let few = walked_by(&s, 9_000_001);
hide_many(&mut s, 10_000);
let many = walked_by(&s, 9_000_001);
assert!(
many <= few + 4,
"a joint lookup walked {many} entries of a 10,000-entry hidden-joint list and {few} of a \
10-entry one: the work must not grow with the number of hidden joints"
);
// The behaviour is unchanged: the hidden joint is hidden, the shown one is shown, and undo
// and redo keep the hiding right.
s.visibility.hidden_joints.clear();
run(&mut s, "browser.visibility", json!({"joints": ["Hinge"], "visible": false}));
assert!(!s.joint_visible(hinge) && s.joint_visible(glue));
run(&mut s, "edit.undo", json!({}));
assert!(s.joint_visible(hinge), "undo shows the hinge again");
run(&mut s, "edit.redo", json!({}));
assert!(!s.joint_visible(hinge), "redo hides it again");
}
/// The cost of a frame's worth of joint questions, with few and with many hidden joints: the
/// manual measurement behind #3892. Run it with `--ignored --nocapture`.
#[test]
#[ignore = "manual scaling measurement"]
fn joint_visibility_lookup_cost_by_hidden_joint_count() {
use crate::occurrences::visibility_work;
let joints = 1_000u64;
for hidden in [0u64, 10, 100, 1_000, 10_000] {
let mut s = Session::default();
for id in 0..hidden {
s.visibility.hidden_joints.push(id);
}
let mut times = Vec::new();
for _ in 0..11 {
let start = std::time::Instant::now();
for id in 0..joints {
let _ = s.joint_visible(id + hidden + 1);
}
times.push(start.elapsed().as_secs_f64() * 1e3);
}
times.sort_by(f64::total_cmp);
// The index is built once per change of the view, apart from the answers themselves.
println!(
"hidden_joints={hidden:>6} questions={joints} median_ms={:.3} min_ms={:.3} max_ms={:.3} built_entries={}",
times[times.len() / 2],
times[0],
times[times.len() - 1],
visibility_work::built_take()
);
}
}
/// #1160: a design saved before joints could be hidden (format 19, no `hidden_joints`) opens
/// with every joint shown; and a new joint that takes a deleted hidden joint's id starts shown.
#[test]
fn older_designs_show_every_joint_and_new_joints_start_shown() {
let (dir, path) = temp_design("legacy", "json");
let mut s = hinged();
let mut legacy: Value = serde_json::from_slice(&solidcraft_io::write_design(&s.doc)).unwrap();
legacy["format"] = json!("solidcraft/19");
legacy["visibility"] =
json!({"hidden_bodies": [], "hidden_occurrences": [], "hidden_origin": ["XY"], "hidden_sketches": [], "shown_sketches": []});
std::fs::write(&path, serde_json::to_vec(&legacy).unwrap()).unwrap();
run(&mut s, "file.new", json!({}));
run(&mut s, "doc.open", json!({"path": path}));
assert_eq!(s.doc.assembly.joints.len(), 2);
assert!(s.doc.assembly.joints.iter().all(|j| s.joint_visible(j.id)));
assert_eq!(s.visibility.hidden_origin, ["XY"]);
let glue = joint(&s, "Glue");
run(&mut s, "browser.visibility", json!({"joints": [glue], "visible": false}));
run(&mut s, "joint.delete", json!({"joint": glue}));
pin(&mut s, "rigid", "Glue2", "LeafA", "Tag", Vec3::new(61.0, 1.0, 0.0), Vec3::new(0.0, 0.0, 1.0));
let again = joint(&s, "Glue2");
assert!(s.joint_visible(again), "id {again} reused from {glue}");
let _ = std::fs::remove_dir_all(&dir);
}
/// Dials R0…R4 on revolute joints to ground, linked R0 → R1 → … → `last` (ratio 1), the links
/// stored from the end of the chain to its start.
fn reverse_link_chain(s: &mut Session, last: &str) {
for k in 0..5 {
let x = 100.0 + 10.0 * f64::from(k);
part(s, &format!("R{k}"), [x, 0.0, -5.0]);
pin(s, "revolute", &format!("R{k}"), "Ground", &format!("R{k}"), Vec3::new(x, 0.0, 0.0), Vec3::Z);
}
for k in (0..5).rev() {
let b = if k == 4 { last.to_string() } else { format!("R{}", k + 1) };
run(s, "joint.motion_link", json!({"a": format!("R{k}"), "b": b, "ratio": 1}));
}
}
/// A motion link chain carries a value through all its links, however they are stored: five
/// links stored from the end still turn the last joint with the first.
#[test]
fn a_link_chain_stored_backwards_carries_its_value_through() {
let (mut s, _, _) = four_bar();
part(&mut s, "Last", [200.0, 0.0, -5.0]);
pin(&mut s, "revolute", "Last", "Ground", "Last", Vec3::new(200.0, 0.0, 0.0), Vec3::Z);
reverse_link_chain(&mut s, "Last");
run(&mut s, "joint.drive", json!({"joint": "R0", "value": 10}));
let l = run(&mut s, "joint.list", json!({}));
let last = l["joints"].as_array().into_iter().flatten().find(|j| j["name"] == "Last").map(|j| j["values"][0]["value"].clone());
assert!((last.and_then(|v| v.as_f64()).unwrap_or(f64::NAN) - 10.0).abs() < 1e-9, "{l}");
}
/// Driving the start of such a chain into a four-bar's crank turns the mechanism, and never
/// reports its loop as opened.
#[test]
fn a_link_chain_stored_backwards_drives_a_loop() {
let (mut s, _, q0) = four_bar();
reverse_link_chain(&mut s, "Crank");
for v in [1.0, 30.0] {
let r = run(&mut s, "joint.drive", json!({"joint": "R0", "value": v}));
assert_eq!(r["conflicts"].as_array().map(Vec::len), Some(0), "{v}: {r}");
assert!(r["stopped_by_loop"].is_null(), "{v}: {r}");
assert!(near(place(&s, "Rocker", q0), rocker_pin(0.0, v, q0)), "{v}: {:?}", place(&s, "Rocker", q0));
}
}
/// A turret on a pedestal joined to nothing grounded (Rover v7's turret): the solver places
/// neither, so driving the turret moves nothing. The drive, a motion study and joint.list say
/// so, naming the pedestal, instead of answering as if it worked.
#[test]
fn a_turret_on_a_floating_pedestal_says_it_moves_nothing() {
let mut s = Session::default();
for (name, corner) in [("Chassis", [0.0, 0.0, 0.0]), ("Arm", [10.0, 0.0, 0.0]), ("Pedestal", [50.0, 0.0, 0.0]), ("Turret", [50.0, 0.0, 2.0])] {
part(&mut s, name, corner);
}
let g = occ(&s, "Chassis");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
pin(&mut s, "revolute", "Shoulder", "Chassis", "Arm", Vec3::new(10.0, 1.0, 1.0), Vec3::Y);
pin(&mut s, "revolute", "Azimuth", "Pedestal", "Turret", Vec3::new(51.0, 1.0, 2.0), Vec3::Z);
let corner = Vec3::new(52.0, 0.0, 2.0);
let start = place(&s, "Turret", corner);
let r = run(&mut s, "joint.drive", json!({"joint": "Azimuth", "value": 30, "quiet": true}));
assert_eq!((&r["moved"], &r["unconnected"]), (&json!(false), &json!("Pedestal:1")), "{r}");
assert!(r["reason"].as_str().is_some_and(|w| w.starts_with("Pedestal:1 is not connected to anything grounded")), "{r}");
assert!(r.get("dof").is_none() && r.get("fixed").is_none(), "quiet: {r}");
// The value is set and answered in degrees, as asked; the turret stays where it was.
assert!((r["values"][0]["value"].as_f64().unwrap_or(f64::NAN) - 30.0).abs() < 1e-9 && r["values"][0]["unit"] == "deg", "{r}");
assert!(near(place(&s, "Turret", corner), start));
let l = run(&mut s, "joint.list", json!({}));
assert_eq!(l["floating"], json!([{"occurrences": ["Pedestal:1", "Turret:1"], "joints": ["Azimuth"]}]), "{l}");
// A study keying both joints moves the arm and says the turret can't move.
let keys = json!([{"joint": "Azimuth", "points": [[0, 0], [10, 90]]}, {"joint": "Shoulder", "points": [[0, 0], [10, 45]]}]);
run(&mut s, "motion.study", json!({"name": "Scan", "steps": 10, "keys": keys}));
let r = run(&mut s, "motion.play", json!({"study": "Scan", "step": 10, "quiet": true}));
assert_eq!(r["moved"], true, "{r}");
let unmoved = r["unmoved"].as_array().cloned().unwrap_or_default();
assert!(unmoved.len() == 1 && unmoved[0]["name"] == "Azimuth" && unmoved[0]["reason"].as_str().is_some_and(|w| w.contains("Pedestal:1")), "{r}");
// Quiet: only the arm, which moved, has its pose in the answer.
assert_eq!(r["positions"].as_array().map(|p| p.iter().map(|x| x["occurrence"].clone()).collect::<Vec<_>>()), Some(vec![json!("Arm:1")]), "{r}");
// Fixed to the chassis, the pedestal is placed and the turret turns.
run(&mut s, "joint.as_built", json!({"type": "rigid", "a": "Chassis", "b": "Pedestal", "name": "Mount"}));
let r = run(&mut s, "joint.drive", json!({"joint": "Azimuth", "value": 60}));
assert!(r["moved"] == true && r.get("reason").is_none() && r.get("unconnected").is_none() && r["dof"].is_array(), "{r}");
assert!(!near(place(&s, "Turret", corner), start));
assert_eq!(run(&mut s, "joint.list", json!({}))["floating"], json!([]));
}
/// `quiet: true` leaves the per-occurrence lists out of joint answers, and `moved` says whether
/// a drive moved anything: driving a joint to where it is moves nothing, with no reason given.
#[test]
fn quiet_joint_answers_and_a_drive_to_where_it_is() {
let mut s = two_cubes();
let r =
run(&mut s, "joint.create", json!({"type": "slider", "a": {"face": [5, 5, 10]}, "b": {"face": [25, 5, 0]}, "name": "Rail", "quiet": true}));
assert!(r.get("dof").is_none() && r.get("fixed").is_none() && r["conflicts"].is_array(), "{r}");
let r = run(&mut s, "joint.drive", json!({"joint": "Rail", "value": 5, "quiet": true}));
assert!(r.get("dof").is_none() && r["moved"] == true, "{r}");
let r = run(&mut s, "joint.drive", json!({"joint": "Rail", "value": 5}));
assert!(r["dof"].is_array() && r["moved"] == false && r.get("reason").is_none(), "{r}");
// A suppressed joint with no motion link moves nothing, and says why.
run(&mut s, "joint.edit", json!({"joint": "Rail", "suppressed": true}));
let (doc, undo) = (s.doc.clone(), s.undo.len());
let r = run(&mut s, "joint.drive", json!({"joint": "Rail", "value": 8}));
assert!(r["moved"] == false && r["reason"] == "Rail is suppressed" && r.get("unconnected").is_none(), "{r}");
// Nor does it store the value, as it did with an undo step: unsuppressed, the part jumped to
// it (#9742). The reply keeps what was asked apart from what the joint holds.
assert!(std::sync::Arc::ptr_eq(&doc, &s.doc) && s.undo.len() == undo, "a drive of a suppressed joint changed the design");
assert_eq!((&r["requested"][0]["value"], &r["values"][0]["value"]), (&json!(8.0), &json!(5.0)), "{r}");
assert!(r.get("held").is_none(), "{r}");
}
/// A screw's travel follows its turn, so a distance asked of it is not reached: the reply says
/// what was asked and why the joint holds another value, and a drive of the distance alone,
/// which moves nothing, says why. A limit is named the same way (#9742).
#[test]
fn a_drive_says_which_values_a_motion_link_or_a_limit_held() {
let mut s = two_cubes();
run(&mut s, "joint.create", json!({"type": "cylindrical", "a": {"face": [5, 5, 10]}, "b": {"face": [25, 5, 0]}, "name": "Cy"}));
run(&mut s, "joint.screw", json!({"joint": "Cy", "pitch": 2}));
let follows = json!("distance follows its angle through a motion link (screw)");
let r = run(&mut s, "joint.drive", json!({"joint": "Cy", "values": [90, 5]}));
assert!(r["moved"] == true && r.get("reason").is_none(), "{r}");
assert_eq!((&r["requested"][0]["value"], &r["requested"][1]["value"]), (&json!(90.0), &json!(5.0)), "{r}");
let held = r["held"].as_array().cloned().unwrap_or_default();
assert_eq!(held.len(), 1, "only the distance is held: {r}");
assert_eq!(
(&held[0]["name"], &held[0]["requested"], &held[0]["unit"], &held[0]["why"]),
(&json!("distance"), &json!(5.0), &json!("mm"), &follows),
"{r}"
);
assert!((held[0]["value"].as_f64().unwrap_or(f64::NAN) - 0.5).abs() < 1e-9, "a quarter turn at pitch 2 travels 0.5 mm: {r}");
// The distance alone: nothing moves, and the reply says why.
let r = run(&mut s, "joint.drive", json!({"joint": "Cy", "index": 1, "value": 4}));
assert_eq!((&r["moved"], &r["reason"], &r["held"][0]["requested"]), (&json!(false), &follows, &json!(4.0)), "{r}");
let mut s = two_cubes();
run(&mut s, "joint.as_built", json!({"type": "slider", "a": "A", "b": "B", "name": "Rail", "limits": [[0, 5]]}));
let r = run(&mut s, "joint.drive", json!({"joint": "Rail", "value": 20}));
assert!(r["moved"] == true && r.get("reason").is_none(), "{r}");
assert_eq!(
r["held"],
json!([{"name": "distance", "requested": 20.0, "value": 5.0, "unit": "mm", "why": "distance is held to its limits, 0 to 5 mm"}]),
"{r}"
);
// Within the limits, nothing is held.
let r = run(&mut s, "joint.drive", json!({"joint": "Rail", "value": 3}));
assert!(r.get("held").is_none() && r["requested"][0]["value"] == 3.0, "{r}");
}
/// An as-built joint takes a name and limits like any other joint.
#[test]
fn as_built_takes_a_name_and_limits() {
let mut s = two_cubes();
let r = run(&mut s, "joint.as_built", json!({"type": "slider", "a": "A", "b": "B", "name": "Rail", "limits": [[0, 5]]}));
assert_eq!(r["name"], "Rail", "{r}");
let r = run(&mut s, "joint.drive", json!({"joint": "Rail", "value": 20}));
assert_eq!((&r["values"][0]["value"], &r["values"][0]["limits"]), (&json!(5.0), &json!([0.0, 5.0])), "{r}");
assert!(near(place(&s, "B", Vec3::new(20.0, 0.0, 0.0)), Vec3::new(20.0, 0.0, 5.0)), "{:?}", place(&s, "B", Vec3::new(20.0, 0.0, 0.0)));
}
/// `value` drives a joint's first value only: the others keep theirs, as with a shorter `values`.
#[test]
fn a_single_value_keeps_the_joints_other_values() {
let mut s = two_cubes();
run(&mut s, "joint.as_built", json!({"type": "cylindrical", "a": "A", "b": "B", "name": "Spindle"}));
run(&mut s, "joint.drive", json!({"joint": "Spindle", "values": [30, 5]}));
let at = |r: &Value| [0, 1].map(|i| r["values"][i]["value"].as_f64().unwrap_or(f64::NAN));
let r = run(&mut s, "joint.drive", json!({"joint": "Spindle", "value": 45}));
assert!((at(&r)[0] - 45.0).abs() < 1e-9 && (at(&r)[1] - 5.0).abs() < 1e-9, "{r}");
let r = run(&mut s, "joint.drive", json!({"joint": "Spindle", "values": [60]}));
assert!((at(&r)[0] - 60.0).abs() < 1e-9 && (at(&r)[1] - 5.0).abs() < 1e-9, "{r}");
}
/// A motion link's offset is in the linked value's units, like joint values and limits: degrees
/// for an angle, mm for a distance, or an expression. `joint.list` answers it the same way, it is
/// stored in radians as before, and a saved link opens with the offset it had.
#[test]
fn a_link_offset_is_in_the_linked_values_units() {
let mut s = Session::default();
for (name, x) in [("Ground", 0.0), ("Dial", 80.0), ("Gear", 100.0), ("Car", 120.0), ("Cart", 140.0)] {
part(&mut s, name, [x, 0.0, -5.0]);
}
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
for (kind, name, x) in [("revolute", "Dial", 80.0), ("revolute", "Gear", 100.0), ("slider", "Car", 120.0), ("slider", "Cart", 140.0)] {
pin(&mut s, kind, name, "Ground", name, Vec3::new(x, 0.0, 0.0), Vec3::Z);
}
run(&mut s, "joint.motion_link", json!({"a": "Dial", "b": "Gear", "ratio": 1, "offset": 10}));
run(&mut s, "joint.motion_link", json!({"a": "Car", "b": "Cart", "ratio": 1, "offset": "5 mm"}));
run(&mut s, "joint.drive", json!({"joint": "Dial", "value": 20}));
run(&mut s, "joint.drive", json!({"joint": "Car", "value": 3}));
let value = |l: &Value, name: &str| {
l["joints"].as_array().into_iter().flatten().find(|j| j["name"] == name).and_then(|j| j["values"][0]["value"].as_f64()).unwrap_or(f64::NAN)
};
let l = run(&mut s, "joint.list", json!({}));
assert!((value(&l, "Gear") - 30.0).abs() < 1e-9 && (value(&l, "Cart") - 8.0).abs() < 1e-9, "{l}");
let links: Vec<(f64, &str)> =
l["links"].as_array().into_iter().flatten().map(|k| (k["offset"].as_f64().unwrap_or(f64::NAN), k["unit"].as_str().unwrap_or(""))).collect();
assert!(
links.len() == 2 && (links[0].0 - 10.0).abs() < 1e-9 && links[0].1 == "deg" && (links[1].0 - 5.0).abs() < 1e-9 && links[1].1 == "mm",
"{l}"
);
assert!((s.doc.assembly.links[0].offset - 10f64.to_radians()).abs() < 1e-12);
// A design saved before offsets took degrees stored 0.1 rad, and opens turning Gear 5.73° past Dial.
s.doc_mut().assembly.links[0].offset = 0.1;
let (dir, path) = temp_design("link-offset", "solidcraft");
run(&mut s, "file.save", json!({"path": path}));
run(&mut s, "file.new", json!({}));
run(&mut s, "doc.open", json!({"path": path}));
let l = run(&mut s, "joint.list", json!({}));
assert!((value(&l, "Gear") - value(&l, "Dial") - 0.1f64.to_degrees()).abs() < 1e-9, "{l}");
let _ = std::fs::remove_dir_all(&dir);
}
/// A link between an angle and a distance takes its ratio in b's units per a's, like its offset:
/// a pinion moves its rack 0.5 mm per degree, and a car turns its dial 2 degrees per mm.
/// `joint.list` answers the ratios the same way; they are stored per radian, as before.
#[test]
fn a_link_ratio_between_an_angle_and_a_distance_is_per_degree() {
let mut s = Session::default();
for (name, x) in [("Ground", 0.0), ("Pinion", 80.0), ("Rack", 100.0), ("Car", 120.0), ("Dial", 140.0)] {
part(&mut s, name, [x, 0.0, -5.0]);
}
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
for (kind, name, x) in [("revolute", "Pinion", 80.0), ("slider", "Rack", 100.0), ("slider", "Car", 120.0), ("revolute", "Dial", 140.0)] {
pin(&mut s, kind, name, "Ground", name, Vec3::new(x, 0.0, 0.0), Vec3::Z);
}
run(&mut s, "joint.motion_link", json!({"a": "Pinion", "b": "Rack", "ratio": 0.5}));
run(&mut s, "joint.motion_link", json!({"a": "Car", "b": "Dial", "ratio": 2}));
run(&mut s, "joint.drive", json!({"joint": "Pinion", "value": 20}));
run(&mut s, "joint.drive", json!({"joint": "Car", "value": 3}));
let l = run(&mut s, "joint.list", json!({}));
let value = |name: &str| {
l["joints"].as_array().into_iter().flatten().find(|j| j["name"] == name).and_then(|j| j["values"][0]["value"].as_f64()).unwrap_or(f64::NAN)
};
assert!((value("Rack") - 10.0).abs() < 1e-9 && (value("Dial") - 6.0).abs() < 1e-9, "{l}");
let ratios: Vec<f64> = l["links"].as_array().into_iter().flatten().map(|k| k["ratio"].as_f64().unwrap_or(f64::NAN)).collect();
assert!(ratios.len() == 2 && (ratios[0] - 0.5).abs() < 1e-9 && (ratios[1] - 2.0).abs() < 1e-9, "{l}");
let stored: Vec<f64> = s.doc.assembly.links.iter().map(|k| k.ratio).collect();
assert!((stored[0] - 0.5f64 / 1f64.to_radians()).abs() < 1e-9 && (stored[1] - 2f64.to_radians()).abs() < 1e-12, "{stored:?}");
}
/// A new joint starts at its values inside its limits. Limits that leave out 0 (or the values
/// given) start it at the nearer limit, which it keeps, and the answer says the part moved there.
#[test]
fn a_new_joint_starts_inside_its_limits_and_says_so() {
let mut s = two_cubes();
let r = run(&mut s, "joint.as_built", json!({"type": "slider", "a": "A", "b": "B", "name": "Rail", "limits": [[2, 5]]}));
let w = r["warnings"].as_array().cloned().unwrap_or_default();
assert!(
w.len() == 1 && w[0].as_str().is_some_and(|w| w.starts_with("Rail distance starts at 2 mm, inside its limits [2, 5], not at 0 mm")),
"{r}"
);
assert!(near(place(&s, "B", Vec3::new(20.0, 0.0, 0.0)), Vec3::new(20.0, 0.0, 2.0)), "{:?}", place(&s, "B", Vec3::new(20.0, 0.0, 0.0)));
assert_eq!(s.doc.assembly.joints[0].values, [2.0]);
// Values given outside the limits start at the nearer one too; angles are answered in degrees.
let mut s = two_cubes();
let r = run(
&mut s,
"joint.create",
json!({"type": "revolute", "a": {"face": [5, 5, 10]}, "b": {"face": [25, 5, 0]}, "values": [90], "limits": [[0, 60]], "name": "Hinge"}),
);
let w = r["warnings"].as_array().cloned().unwrap_or_default();
assert!(w.len() == 1 && w[0].as_str().is_some_and(|w| w.contains("starts at 60 deg") && w.contains("not at 90 deg")), "{r}");
// Inside the limits, nothing to say.
let mut s = two_cubes();
let r = run(&mut s, "joint.as_built", json!({"type": "cylindrical", "a": "A", "b": "B", "name": "Spindle", "limits": [[-30, 30], [0, 5]]}));
assert!(r.get("warnings").is_none(), "{r}");
}
/// The trace's points as world points.
fn traced(r: &Value) -> Vec<Vec3> {
r["points"].as_array().into_iter().flatten().filter_map(crate::params::vec3).collect()
}
/// A point rigidly carried from segment (a0, b0) to segment (a, b) in the XY plane.
fn carried(p0: Vec3, a0: Vec3, b0: Vec3, a: Vec3, b: Vec3) -> Vec3 {
let turn = (b.y - a.y).atan2(b.x - a.x) - (b0.y - a0.y).atan2(b0.x - a0.x);
let d = p0 - a0;
a + Vec3::new(d.x * turn.cos() - d.y * turn.sin(), d.x * turn.sin() + d.y * turn.cos(), d.z)
}
/// A point on the four-bar's coupler, 10 mm off the line between its pins, traces the coupler
/// curve: the crank pin on its circle, the rocker pin where the coupler and rocker circles meet
/// (on the open branch), and the point carried with the pins. A motion study turning the crank
/// traces the same curve, and the design is left as it was.
#[test]
fn four_bar_coupler_point_traces_its_closed_form_curve() {
let (mut s, p0, q0) = four_bar();
let d = (q0 - p0) * (1.0 / q0.dist(p0));
let c0 = (p0 + q0) * 0.5 + Vec3::new(-d.y, d.x, 0.0) * 10.0;
let before = s.doc.clone();
let p = json!({"occurrence": "Coupler", "point": [c0.x, c0.y, c0.z], "joint": "Crank", "from": 0, "to": 360, "samples": 73});
let r = run(&mut s, "motion.trace", p);
assert_eq!(*s.doc, *before, "a trace leaves the design as it was");
assert!(r["stopped_at"].is_null() && r["samples"] == 73, "{r}");
let pts = traced(&r);
assert_eq!(pts.len(), 73);
let mut q = q0;
for (k, got) in pts.iter().enumerate() {
let v = 5.0 * k as f64;
if k > 0 {
q = rocker_pin(v - 5.0, v, q);
}
let th = (90.0 + v).to_radians();
let want = carried(c0, p0, q0, Vec3::new(20.0 * th.cos(), 20.0 * th.sin(), 0.0), q);
assert!(near(*got, want), "{v}°: {got:?} wants {want:?}");
}
assert!(pts.first().zip(pts.last()).is_some_and(|(a, b)| near(*a, *b)), "a full turn closes the curve");
run(&mut s, "motion.study", json!({"name": "Turn", "steps": 72, "keys": [{"joint": "Crank", "points": [[0, 0], [72, 360]]}]}));
let r = run(&mut s, "motion.trace", json!({"occurrence": "Coupler", "point": [c0.x, c0.y, c0.z], "study": "Turn"}));
let from_study = traced(&r);
assert_eq!(from_study.len(), 73, "{r}");
assert!(from_study.iter().zip(&pts).all(|(a, b)| near(*a, *b)), "{r}");
}
fn kept_trace_fit(s: &Session, id: u64) -> Vec<Vec3> {
s.doc.sketch(id).unwrap().wires.first().unwrap().fit.clone()
}
#[test]
fn chebyshev_demo_regenerates_its_analytic_trajectory_without_resampling_playback() {
let mut s = Session::default();
s.run_script(&serde_json::from_str(include_str!("../../../../examples/chebyshev-motion-trace.json")).unwrap()).unwrap();
let trace = s.doc.assembly.traces.first().unwrap().clone();
let original = kept_trace_fit(&s, trace.sketch);
assert_eq!(original.len(), 145);
assert_eq!(s.doc.assembly.joints.len(), 4);
assert!(s.model.results.iter().all(|r| r.error.is_none()), "{:?}", s.model.results);
// Independent circle-intersection construction: P is the crank end, Q the
// coupler/rocker pin, and the tracer extends the coupler by another PQ.
let mut q = Vec3::new(40.0, 50.0, 0.0);
for (i, got) in original.iter().enumerate() {
let theta = (90.0 + 2.5 * i as f64).to_radians();
let p = Vec3::new(20.0 * theta.cos(), 20.0 * theta.sin(), 0.0);
let [a, b] = meet(p, 50.0, Vec3::new(40.0, 0.0, 0.0), 50.0);
q = if a.dist(q) < b.dist(q) { a } else { b };
let want = q * 2.0 - p + Vec3::Z * 10.0;
assert!(near(*got, want), "sample {i}: {got:?} wants {want:?}");
}
let count = s.motion_traces.recomputations;
for angle in [30, 90, 180, 270, 0] {
let result = run(&mut s, "joint.drive", json!({"joint":"Crank drive","value":angle,"quiet":true}));
assert!(result["stopped_by_loop"].is_null(), "{result}");
}
assert_eq!(s.motion_traces.recomputations, count);
assert_eq!(kept_trace_fit(&s, trace.sketch), original);
run(&mut s, "parameters.change", json!({"name":"coupler_length","expression":"55 mm"}));
let updated = kept_trace_fit(&s, trace.sketch);
let [q, _] = meet(Vec3::new(0.0, 20.0, 0.0), 55.0, Vec3::new(40.0, 0.0, 0.0), 50.0);
assert!(near(updated[0], q * 2.0 - Vec3::new(0.0, 20.0, 0.0) + Vec3::Z * 10.0));
assert_ne!(updated, original);
assert_eq!(s.doc.assembly.traces[0].wire, trace.wire);
assert_eq!(s.motion_traces.recomputations, count + 1, "a dimension edit resamples once");
assert!(s.model.result(trace.sketch).unwrap().warning.is_none());
run(&mut s, "parameters.change", json!({"changes":{"coupler_length":"2.5 * unit_length","unit_length":"24 mm"}}));
let scaled = kept_trace_fit(&s, trace.sketch);
assert!(scaled.iter().zip(&original).all(|(a, b)| near(*a, Vec3::new(b.x * 1.2, b.y * 1.2, 10.0))));
run(&mut s, "parameters.change", json!({"name":"trace_sweep","expression":"180 deg"}));
let half = kept_trace_fit(&s, trace.sketch);
assert!(near(half[0], scaled[0]) && near(*half.last().unwrap(), scaled[72]));
assert!(s.model.results.iter().all(|r| r.error.is_none()), "{:?}", s.model.results);
}
#[test]
fn associative_trace_reuses_pose_and_unrelated_edits_but_follows_drive_expressions() {
let (mut s, p0, q0) = four_bar();
let mid = (p0 + q0) * 0.5;
run(&mut s, "parameters.add", json!({"name":"swing","expression":"90 deg"}));
let r = run(
&mut s,
"motion.trace.keep",
json!({"occurrence":"Coupler","point":[mid.x,mid.y,mid.z],
"joint":"Crank","from":0,"to":"swing","samples":19}),
);
let id = r["sketch"].as_u64().unwrap();
let original = kept_trace_fit(&s, id);
let count = s.motion_traces.recomputations;
for angle in [20, 45, 75, 10] {
run(&mut s, "joint.drive", json!({"joint":"Crank","value":angle,"quiet":true}));
assert_eq!(kept_trace_fit(&s, id), original);
}
run(&mut s, "parameters.add", json!({"name":"unrelated","expression":"123 mm"}));
run(&mut s, "parameters.change", json!({"name":"unrelated","expression":"456 mm"}));
assert_eq!(s.motion_traces.recomputations, count, "pose and unrelated edits must not resample");
let mut preview = s.scratch();
run(&mut preview, "joint.drive", json!({"joint":"Crank","value":80,"quiet":true}));
assert_eq!(preview.motion_traces.recomputations, count, "scratch previews reuse the same valid inputs");
run(&mut s, "parameters.change", json!({"name":"swing","expression":"180 deg"}));
let updated = kept_trace_fit(&s, id);
assert_ne!(updated, original);
assert_eq!(s.motion_traces.recomputations, count + 1, "a parameter command may refresh twice; sample once");
run(&mut s, "edit.undo", json!({}));
assert_eq!(kept_trace_fit(&s, id), original);
run(&mut s, "edit.redo", json!({}));
assert_eq!(kept_trace_fit(&s, id), updated);
assert_eq!(s.motion_traces.recomputations, count + 1, "undo and redo reuse the retained input results");
run(&mut s, "parameters.rename", json!({"name":"swing","new_name":"travel"}));
assert_eq!(s.motion_traces.recomputations, count + 1, "renaming a parameter leaves resolved inputs unchanged");
let count = s.motion_traces.recomputations;
let before = s.doc.clone();
for invalid in [
json!({"sketch":id,"samples":501}),
json!({"sketch":id,"index":99}),
json!({"sketch":id,"from":"missing_parameter"}),
json!({"sketch":id,"joint":"Missing","from":0,"to":90}),
] {
assert!(s.execute("motion.trace.edit", &invalid).is_err());
assert_eq!(*s.doc, *before, "invalid trace edits must be atomic");
}
run(&mut s, "motion.trace.edit", json!({"sketch":id,"samples":19}));
assert_eq!(s.motion_traces.recomputations, count, "an identical definition is reusable");
assert!(std::sync::Arc::ptr_eq(&before, &s.doc), "an identical edit must not refresh the model or add an undo step");
run(&mut s, "motion.trace.edit", json!({"sketch":id,"auto_update":false}));
run(&mut s, "parameters.change", json!({"name":"travel","expression":"270 deg"}));
assert_eq!(kept_trace_fit(&s, id), updated, "detaching preserves the curve");
}
#[test]
fn associative_trace_follows_a_study_and_survives_serialization() {
let (mut s, p0, q0) = four_bar();
let mid = (p0 + q0) * 0.5;
let study = run(
&mut s,
"motion.study",
json!({"name":"Turn","steps":18,
"keys":[{"joint":"Crank","points":[[0,0],[18,90]]}]}),
);
let r = run(&mut s, "motion.trace.keep", json!({"occurrence":"Coupler","point":[mid.x,mid.y,mid.z],"study":"Turn"}));
let id = r["sketch"].as_u64().unwrap();
let original = kept_trace_fit(&s, id);
run(
&mut s,
"motion.study",
json!({"study":study["study"],"name":"Turn","steps":36,
"keys":[{"joint":"Crank","points":[[0,0],[36,180]]}]}),
);
assert_eq!(kept_trace_fit(&s, id).len(), 37);
assert_ne!(kept_trace_fit(&s, id), original);
let doc: solidcraft_doc::Document = serde_json::from_value(serde_json::to_value(&*s.doc).unwrap()).unwrap();
let mut opened = Session::new(doc);
run(&mut opened, "motion.trace.edit", json!({"sketch":id,"samples":25}));
assert_eq!(kept_trace_fit(&opened, id).len(), 25);
run(&mut opened, "motion.delete", json!({"study":"Turn"}));
assert!(run(&mut opened, "motion.list", json!({}))["traces"][0]["error"].is_string());
assert!(opened.model.result(id).unwrap().warning.as_ref().unwrap().contains("last successful"));
let count = opened.motion_traces.recomputations;
opened.refresh();
assert_eq!(opened.motion_traces.recomputations, count, "a missing dependency must not retry on every refresh");
run(&mut opened, "edit.undo", json!({}));
assert!(run(&mut opened, "motion.list", json!({}))["traces"][0]["error"].is_null());
assert!(opened.model.result(id).unwrap().warning.is_none());
}
#[test]
fn associative_trace_follows_a_resized_picked_face_and_keeps_downstream_paths_current() {
let mut s = two_cubes();
pin(&mut s, "revolute", "Pivot", "A", "B", Vec3::new(20.0, 0.0, 0.0), Vec3::Z);
let r = run(
&mut s,
"motion.trace.keep",
json!({"occurrence":"B","point":[25,5,10],
"point_ref":{"occurrence":"B","face":[25,5,10]},"joint":"Pivot","from":0,"to":90,"samples":2}),
);
let id = r["sketch"].as_u64().unwrap();
let original = kept_trace_fit(&s, id);
run(&mut s, "component.activate", json!({"component":"root"}));
run(&mut s, "solid.pipe", json!({"path_sketch":id,"path":r["curves"],"diameter":1,"operation":"new","body_name":"TracePipe"}));
let pipe_before = s.model.state().body("TracePipe").unwrap().outline_bounds();
let comp = s.doc.find_component("B").unwrap();
let height =
s.doc.features.iter().find(|f| f.component == comp && matches!(f.kind, solidcraft_doc::FeatureKind::Box { .. })).unwrap().param_names[2]
.clone();
let count = s.motion_traces.recomputations;
run(&mut s, "parameters.change", json!({"name":height,"expression":"15 mm"}));
let updated = kept_trace_fit(&s, id);
assert!(updated.iter().all(|p| (p.z - 15.0).abs() < 1e-6));
assert_ne!(original, updated);
assert_eq!(s.motion_traces.recomputations, count + 1);
let model = s.model.state();
assert_eq!(model.sketch(id).unwrap().sketch.wires.first().unwrap().fit, updated);
let pipe_after = model.body("TracePipe").unwrap().outline_bounds();
assert!((pipe_after.min.z - pipe_before.min.z - 5.0).abs() < 1e-6);
}
#[test]
fn associative_trace_ignores_another_mechanism_on_the_same_ground() {
let (mut s, p0, q0) = four_bar();
part(&mut s, "Other", [100.0, 0.0, -5.0]);
pin(&mut s, "revolute", "Other pivot", "Ground", "Other", Vec3::new(100.0, 0.0, 0.0), Vec3::Z);
let mid = (p0 + q0) * 0.5;
run(
&mut s,
"motion.trace.keep",
json!({"occurrence":"Coupler","point":[mid.x,mid.y,mid.z],
"joint":"Crank","from":0,"to":180,"samples":19}),
);
let count = s.motion_traces.recomputations;
run(&mut s, "joint.limits", json!({"joint":"Other pivot","min":-20,"max":30}));
assert_eq!(s.motion_traces.recomputations, count);
}
/// The middle of a slider-crank's rod: halfway between the crank pin on its circle and the wrist
/// pin at a·cos θ + √(b² − (a·sin θ)²).
#[test]
fn slider_crank_rod_traces_its_closed_form_curve() {
let (mut s, p0, s0) = slider_crank();
let m0 = (p0 + s0) * 0.5;
let r =
run(&mut s, "motion.trace", json!({"occurrence": "Rod", "point": [m0.x, m0.y, m0.z], "joint": "Crank", "from": 0, "to": 360, "samples": 37}));
let pts = traced(&r);
assert_eq!(pts.len(), 37, "{r}");
for (k, got) in pts.iter().enumerate() {
let th = (90.0 + 10.0 * k as f64).to_radians();
let x = 15.0 * th.cos() + (40.0f64.powi(2) - (15.0 * th.sin()).powi(2)).sqrt();
let want = (Vec3::new(15.0 * th.cos(), 15.0 * th.sin(), 0.0) + Vec3::new(x, 0.0, 0.0)) * 0.5;
assert!(near(*got, want), "{}°: {got:?} wants {want:?}", 10 * k);
}
}
/// Driving the rocker past its swing stops where the loop can't close: the trace ends there.
#[test]
fn a_trace_ends_where_the_loop_stops_the_motion() {
let (mut s, _, q0) = four_bar();
let start = q0.y.atan2(q0.x - 45.0).to_degrees();
let r = run(
&mut s,
"motion.trace",
json!({"occurrence": "Rocker", "point": [q0.x, q0.y, q0.z], "joint": "Rocker", "from": 0, "to": 100, "samples": 21}),
);
assert!(r["stopped_by_loop"].is_object(), "{r}");
let k = r["stopped_at"].as_u64().unwrap_or(u64::MAX) as usize;
let pts = traced(&r);
assert!(k > 0 && k < 20 && pts.len() == k + 1 && r["samples"] == k + 1, "{r}");
let angle = |p: &Vec3| p.y.atan2(p.x - 45.0).to_degrees();
for (i, p) in pts.iter().take(k).enumerate() {
assert!((angle(p) - (start + 5.0 * i as f64)).abs() < 1e-6, "sample {i}: {}", angle(p));
}
let limit = ((900.0f64 - 3625.0) / 3600.0).acos().to_degrees();
let last = pts.last().map(angle).unwrap_or(f64::NAN);
assert!(last > limit - 5.0 && last <= limit + 1e-9, "stopped at {last}°, the limit is {limit}°");
}
/// Keep makes a 3D sketch spline through the trace, in one undo step.
#[test]
fn a_kept_trace_is_a_3d_sketch_spline() {
let (mut s, p0, q0) = four_bar();
let c0 = (p0 + q0) * 0.5;
let p = json!({"occurrence": "Coupler", "point": [c0.x, c0.y, c0.z], "joint": "Crank", "from": 0, "to": 180, "samples": 19});
let pts = traced(&run(&mut s, "motion.trace", p.clone()));
let features = s.doc.features.len();
let r = run(&mut s, "motion.trace.keep", p);
assert_eq!((r["name"].as_str(), r["points"].as_u64()), (Some("Motion Trace1"), Some(19)), "{r}");
assert!(s.active_sketch.is_none(), "the sketch is left");
let id = r["sketch"].as_u64().unwrap_or(0);
let sk = s.doc.sketch(id).cloned().unwrap_or_default();
assert!(sk.view.three_d && sk.wires.len() == 1, "{r}");
let fit = sk.wires.first().map(|w| w.fit.clone()).unwrap_or_default();
assert!(fit.len() == pts.len() && fit.iter().zip(&pts).all(|(a, b)| a.dist(*b) < 1e-9), "{fit:?}");
let again = json!({"occurrence": "Coupler", "point": [0, 0, 0], "joint": "Crank", "from": 0, "to": 90});
assert_eq!(run(&mut s, "motion.trace.keep", again)["name"], "Motion Trace2");
run(&mut s, "edit.undo", json!({}));
run(&mut s, "edit.undo", json!({}));
assert_eq!(s.doc.features.len(), features);
// A point on the ground does not move: there is nothing to keep.
let e = s.execute("motion.trace.keep", &json!({"occurrence": "Ground", "point": [0, 0, 0], "joint": "Crank", "from": 0, "to": 90})).unwrap_err();
assert!(e.to_string().contains("does not move"), "{e}");
}
/// A full turn kept closes exactly on its start, also when the sample before the end lies a hair
/// from it (a study keyed to 359.99999° one step before 360°).
#[test]
fn a_kept_full_turn_closes_on_its_start() {
let mut s = Session::default();
part(&mut s, "Ground", [-1.0, -1.0, -5.0]);
part(&mut s, "Arm", [0.0, -1.0, 0.0]);
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
pin(&mut s, "revolute", "Pivot", "Ground", "Arm", Vec3::ZERO, Vec3::Z);
run(&mut s, "motion.study", json!({"name": "Turn", "steps": 5, "keys": [{"joint": "Pivot", "points": [[0, 0], [4, 359.99999], [5, 360]]}]}));
let r = run(&mut s, "motion.trace.keep", json!({"occurrence": "Arm", "point": [1, 0, 0], "study": "Turn"}));
let id = r["sketch"].as_u64().unwrap_or(0);
let fit = s.doc.sketch(id).ok().and_then(|sk| sk.wires.first().map(|w| w.fit.clone())).unwrap_or_default();
assert_eq!(fit.len(), 5, "{fit:?}");
assert_eq!(fit.first(), fit.last(), "{fit:?}");
}
/// Kept while a component is active and shown moved (a move not captured yet): the spline goes
/// in the root, where no joint moves it, through the traced points; the component stays active.
#[test]
fn a_trace_kept_in_a_moved_component_stays_on_the_path() {
let (mut s, p0, q0) = four_bar();
let crank = occ(&s, "Crank");
let c0 = (p0 + q0) * 0.5;
let p = json!({"occurrence": "Coupler", "point": [c0.x, c0.y, c0.z], "joint": "Crank", "from": 0, "to": 90, "samples": 4});
let pts = traced(&run(&mut s, "motion.trace", p.clone()));
run(&mut s, "component.activate", json!({"component": "Crank", "occurrence": crank, "path": [crank]}));
run(&mut s, "occurrence.move", json!({"occurrence": crank, "translate": [0, 0, 100], "capture": false}));
let active = (s.active_component, s.active_occurrence_path.clone());
let r = run(&mut s, "motion.trace.keep", p);
assert_eq!((s.active_component, s.active_occurrence_path.clone()), active);
let id = r["sketch"].as_u64().unwrap_or(0);
assert_eq!(s.doc.feature(id).map(|f| f.component), Some(0), "{r}");
let fit = s.doc.sketch(id).ok().and_then(|sk| sk.wires.first().map(|w| w.fit.clone())).unwrap_or_default();
assert!(fit.len() == pts.len() && fit.iter().zip(&pts).all(|(a, b)| near(*a, *b)), "{fit:?} wants {pts:?}");
}
/// A part inside a sub-assembly placed twice: the occurrence path picks the instance traced. The
/// second Arm turns about its pivot and its Tip goes round; the first Arm, and so the Tip at its
/// first placement, stays put.
#[test]
fn a_trace_follows_the_instance_its_path_names() {
let mut s = Session::default();
part(&mut s, "Ground", [-1.0, -1.0, -5.0]);
let g = occ(&s, "Ground");
run(&mut s, "occurrence.ground", json!({"occurrence": g, "grounded": true}));
run(&mut s, "component.activate", json!({"component": "root"}));
let arm = run(&mut s, "component.create", json!({"name": "Arm"}));
run(&mut s, "component.create", json!({"name": "Tip"}));
run(&mut s, "solid.box", json!({"length": 2, "width": 2, "height": 2, "corner": [10, 0, 0]}));
run(&mut s, "component.activate", json!({"component": "root"}));
let second = run(&mut s, "occurrence.copy", json!({"component": arm["component"], "translate": [0, 50, 0]}))["occurrence"].as_u64().unwrap_or(0);
let at = |o: Value| json!({"occurrence": o, "point": [0, 50, 0], "z": [0, 0, 1]});
run(&mut s, "joint.create", json!({"type": "revolute", "a": at(json!(g)), "b": at(json!(second)), "flip": true, "name": "Pivot"}));
let tip = occ(&s, "Tip");
let trace = |s: &mut Session, o: Value| {
traced(&run(s, "motion.trace", json!({"occurrence": o, "point": [11, 51, 1], "joint": "Pivot", "from": 0, "to": 90, "samples": 3})))
};
let turned = trace(&mut s, json!([second, tip]));
let pivot = Vec3::new(0.0, 50.0, 1.0);
assert!(turned.iter().all(|p| (p.dist(pivot) - 122f64.sqrt()).abs() < 1e-6), "{turned:?}");
assert!(turned.first().zip(turned.last()).is_some_and(|(a, b)| (a.dist(*b) - 244f64.sqrt()).abs() < 1e-6), "a quarter turn: {turned:?}");
let first = trace(&mut s, json!(tip));
assert!(first.iter().all(|p| p.dist(Vec3::new(11.0, 51.0, 1.0)) < 1e-9), "{first:?}");
assert!(s.execute("motion.trace", &json!({"occurrence": [tip, second], "point": [0, 0, 0], "joint": "Pivot", "from": 0, "to": 90})).is_err());
assert!(s.execute("motion.trace", &json!({"occurrence": vec![second; 65], "point": [0, 0, 0], "joint": "Pivot", "from": 0, "to": 90})).is_err());
}
/// Trace params come from scripts and the control channel: bad ones are refused, never a panic.
#[test]
fn hostile_trace_params_are_refused() {
let (mut s, _, _) = four_bar();
run(&mut s, "motion.study", json!({"name": "Turn", "steps": 4, "keys": [{"joint": "Crank", "points": [[0, 0], [4, 90]]}]}));
let base = json!({"occurrence": "Coupler", "point": [0, 0, 0], "joint": "Crank", "from": 0, "to": 90});
let with = |k: &str, v: Value| {
let mut p = base.clone();
p[k] = v;
p
};
let without = |k: &str| {
let mut p = base.clone();
p.as_object_mut().map(|o| o.remove(k));
p
};
for p in [
with("samples", json!(0)),
with("samples", json!(1)),
with("samples", json!(501)),
with("samples", json!(1e300)),
with("samples", json!(-3)),
with("samples", json!("many")),
with("point", json!([f64::MAX, 0, 0])),
with("point", json!([0, 0])),
with("point", json!("here")),
without("point"),
with("occurrence", json!("Nowhere")),
without("occurrence"),
with("joint", json!("Nowhere")),
with("index", json!(1)),
with("index", json!(-1)),
with("from", json!("nonsense +")),
with("to", json!(1e300)),
without("from"),
without("to"),
with("study", json!("Turn")),
with("study", json!(null)),
without("joint"),
] {
for cmd in ["motion.trace", "motion.trace.keep"] {
assert!(s.execute(cmd, &p).is_err(), "{cmd} {p}");
}
}
run(&mut s, "joint.as_built", json!({"type": "rigid", "a": "Ground", "b": "Crank", "name": "Lock"}));
assert!(s.execute("motion.trace", &with("joint", json!("Lock"))).is_err(), "a rigid joint does not move");
}
#[path = "joints_coupling_tests.rs"]
mod coupling;
#[path = "joints_cam_tests.rs"]
mod cam;
// Plots and interference of motion studies, on the four-bar and slider-crank above.
#[path = "motion_analysis_tests.rs"]
mod motion_analysis;
// Joints swept until parts touch: a door, the four-bar above and a Watt six-bar.
#[path = "motion_sweep_tests.rs"]
mod motion_sweep;
/// A pin through a hole of its own radius whose axis is a hair off the hole's (parts placed from
/// rounded coordinates): the walls are all but tangent along two lines. Each offset gets a
/// checked answer: clear on the axis and within the kernel's same-surface tolerance, and
/// otherwise the crescent the pin shares with the plate, against the textbook lens of two circles. The pin is chamfered, so it is not a plain prism.
#[test]
fn interference_of_a_pin_a_hair_off_its_hole() {
let crescent = |r: f64, e: f64| std::f64::consts::PI * r * r - (2.0 * r * r * (e / (2.0 * r)).acos() - e / 2.0 * (4.0 * r * r - e * e).sqrt());
for offset in [0.0, 1e-6, 5.9e-4, 1e-2] {
let mut s = Session::default();
run(&mut s, "solid.box", json!({"length": 20, "width": 20, "height": 5, "corner": [-10, -10, 0], "body_name": "Plate"}));
run(&mut s, "solid.cylinder", json!({"radius": 3, "height": 9, "base": [0, 0, -2], "operation": "cut", "targets": ["Plate"]}));
run(&mut s, "solid.cylinder", json!({"radius": 3, "height": 9, "base": [offset, 0, -2], "operation": "new", "body_name": "Pin"}));
run(&mut s, "solid.chamfer", json!({"edges": [[offset + 3.0, 0, 7]], "distance": 0.5, "body": "Pin"}));
let i = run(&mut s, "inspect.interference", json!({"bodies": ["Plate", "Pin"]}));
assert_eq!(i["unchecked"].as_array().map(Vec::len), Some(0), "{offset}: {i}");
if offset < 1e-5 {
assert_eq!(i["count"], 0, "{offset}: {i}");
continue;
}
assert_eq!(i["count"], 1, "{offset}: {i}");
let want = 5.0 * crescent(3.0, offset);
let got = i["interferences"][0]["volume_mm3"].as_f64().unwrap_or(0.0);
assert!((got - want).abs() < 1e-6 * want, "{offset}: {got} against {want}: {i}");
}
}
/// The pin's head has the radius of the bush the pin sits in, on nearly its axis but beside it:
/// two walls of one radius that never meet along the axis don't stop the crescent from counting.
#[test]
fn interference_of_a_headed_pin_a_hair_off_a_bush_of_its_heads_radius() {
let crescent = |r: f64, e: f64| std::f64::consts::PI * r * r - (2.0 * r * r * (e / (2.0 * r)).acos() - e / 2.0 * (4.0 * r * r - e * e).sqrt());
let offset = 5.9e-4;
let mut s = Session::default();
run(&mut s, "solid.cylinder", json!({"radius": 5.25, "height": 10, "base": [0, 0, 0], "operation": "new", "body_name": "Bush"}));
run(&mut s, "solid.cylinder", json!({"radius": 3, "height": 14, "base": [0, 0, -2], "operation": "cut", "targets": ["Bush"]}));
run(&mut s, "solid.cylinder", json!({"radius": 3, "height": 8, "base": [offset, 0, -3], "operation": "new", "body_name": "Pin"}));
run(&mut s, "solid.cylinder", json!({"radius": 5.25, "height": 2, "base": [offset, 0, -5], "operation": "join", "targets": ["Pin"]}));
let i = run(&mut s, "inspect.interference", json!({"bodies": ["Bush", "Pin"]}));
assert_eq!(i["unchecked"].as_array().map(Vec::len), Some(0), "{i}");
assert_eq!(i["count"], 1, "{i}");
let want = 5.0 * crescent(3.0, offset);
let got = i["interferences"][0]["volume_mm3"].as_f64().unwrap_or(0.0);
assert!((got - want).abs() < 1e-6 * want, "{got} against {want}: {i}");
}
/// A headed pin made before the plate it sits in, a hair off the plate's hole: the crescent
/// whichever body comes first.
#[test]
fn interference_of_a_headed_pin_made_before_its_plate() {
let crescent = |r: f64, e: f64| std::f64::consts::PI * r * r - (2.0 * r * r * (e / (2.0 * r)).acos() - e / 2.0 * (4.0 * r * r - e * e).sqrt());
let offset = 5.6e-4;
let mut s = Session::default();
run(&mut s, "solid.cylinder", json!({"radius": 3, "height": 12, "base": [offset, 0, -2.35], "operation": "new", "body_name": "Pin"}));
run(&mut s, "solid.cylinder", json!({"radius": 5.25, "height": 3, "base": [offset, 0, -5.35], "operation": "join", "targets": ["Pin"]}));
run(&mut s, "solid.box", json!({"length": 60, "width": 60, "height": 2, "corner": [-30, -30, -2.35], "body_name": "Plate"}));
run(&mut s, "solid.cylinder", json!({"radius": 3, "height": 9, "base": [0, 0, -6], "operation": "cut", "targets": ["Plate"]}));
let i = run(&mut s, "inspect.interference", json!({"bodies": ["Pin", "Plate"]}));
assert_eq!(i["unchecked"].as_array().map(Vec::len), Some(0), "{i}");
assert_eq!(i["count"], 1, "{i}");
let want = 2.0 * crescent(3.0, offset);
let got = i["interferences"][0]["volume_mm3"].as_f64().unwrap_or(0.0);
assert!((got - want).abs() < 1e-6 * want, "{got} against {want}: {i}");
}
/// A grounded Base (a 40 x 40 x 10 box), a Pin extruded 20 mm from the sketch circle `c1` of
/// `PinSketch` (r5 at x = 100) and a Cap box; a revolute Hinge from the Base's top to the Pin's
/// top rim, its offset the parameter `gap`, and a rigid Fix between two points of Base and Cap.
fn hinge_and_fix() -> Session {
let mut s = Session::default();
run(&mut s, "parameters.add", json!({"name": "gap", "expression": "2 mm"}));
run(&mut s, "component.create", json!({"name": "Base"}));
run(&mut s, "solid.box", json!({"length": 40, "width": 40, "height": 10, "corner": [0, 0, 0]}));
let base = occ(&s, "Base");
run(&mut s, "occurrence.ground", json!({"occurrence": base, "grounded": true}));
run(&mut s, "component.activate", json!({"component": "root"}));
run(&mut s, "component.create", json!({"name": "Pin"}));
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "PinSketch"}));
run(&mut s, "sketch.circle.center", json!({"center": [100, 0], "radius": 5, "id": "c1"}));
run(&mut s, "sketch.finish", json!({}));
run(&mut s, "solid.extrude", json!({"distance": 20}));
run(&mut s, "component.activate", json!({"component": "root"}));
run(&mut s, "component.create", json!({"name": "Cap"}));
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 5, "corner": [200, 0, 0]}));
let r = run(
&mut s,
"joint.create",
json!({"type": "revolute", "name": "Hinge", "offset": "gap", "limits": [[-90, 90]],
"a": {"occurrence": "Base", "face": [20, 20, 10]}, "b": {"occurrence": "Pin", "circle": [105, 0, 20]}}),
);
assert_eq!(r["errors"].as_array().map(Vec::len), Some(0), "{r}");
run(
&mut s,
"joint.create",
json!({"type": "rigid", "name": "Fix", "a": {"occurrence": "Base", "point": [0, 0, 0]}, "b": {"occurrence": "Cap", "point": [200, 0, 0]}}),
);
s
}
/// The reference of `role` on side `side` of an inspected joint.
fn reference<'a>(j: &'a Value, side: &str, role: &str) -> &'a Value {
j[side]["references"].as_array().and_then(|r| r.iter().find(|r| r["role"] == role)).unwrap_or(&Value::Null)
}
/// `joint.inspect` gives each joint's definition: its kind, offset (and the expression it
/// follows), limits and values, and for each side the occurrence and component, the snap as
/// saved, and what its face names refer to: a circle's wall back to the extrude and the sketch
/// curve it was swept from.
#[test]
fn joint_inspect_gives_what_each_joint_is_attached_to() {
let mut s = hinge_and_fix();
let all = run(&mut s, "joint.inspect", json!({}));
let joints = all["joints"].as_array().cloned().unwrap_or_default();
assert_eq!(joints.iter().map(|j| j["name"].clone()).collect::<Vec<_>>(), [json!("Hinge"), json!("Fix")], "{all}");
let hinge = run(&mut s, "joint.inspect", json!({"joint": "Hinge"}))["joints"][0].clone();
assert_eq!((&hinge["type"], &hinge["offset"], &hinge["expressions"]["offset"]), (&json!("revolute"), &json!(2.0), &json!("gap")), "{hinge}");
assert_eq!(hinge["values"][0]["limits"], json!([-90.0, 90.0]), "{hinge}");
assert_eq!(hinge["dofs"], json!(["angle"]));
assert_eq!((&hinge["a"]["occurrence_name"], &hinge["a"]["component_name"]), (&json!("Base:1"), &json!("Base")), "{hinge}");
assert_eq!(hinge["a"]["path"], hinge["a"]["occurrence_name"]);
assert_eq!((&hinge["a"]["snap"]["type"], &hinge["b"]["snap"]["type"]), (&json!("face_center"), &json!("circle_center")), "{hinge}");
assert_eq!((&hinge["a"]["resolves"], &hinge["b"]["resolves"]), (&json!(true), &json!(true)), "{hinge}");
assert_eq!(hinge["b"]["component_name"], "Pin");
// The Pin's wall: the extrude's side swept from PinSketch's c1.
let wall = reference(&hinge, "b", "face");
assert_eq!(wall["feature"]["type"], "ExtrudeFeature", "{hinge}");
assert_eq!(
(&wall["sketch"]["name"], &wall["sketch"]["curve"], &wall["sketch"]["curve_type"]),
(&json!("PinSketch"), &json!("c1"), &json!("circle")),
"{hinge}"
);
assert_eq!(wall["name"].as_str().map(|n| n.contains(":side:c1")), Some(true), "{hinge}");
// The rim's end face is the extrude's top.
assert_eq!(reference(&hinge, "b", "end")["feature"], wall["feature"], "{hinge}");
// The Base's top: a face of its box, no sketch.
assert!(reference(&hinge, "a", "face")["feature"]["id"].is_u64() && reference(&hinge, "a", "face")["sketch"].is_null(), "{hinge}");
let fix = &joints[1];
assert_eq!((&fix["type"], &fix["values"], &fix["dofs"]), (&json!("rigid"), &json!([]), &json!([])), "{fix}");
assert_eq!((&fix["b"]["snap"]["type"], &fix["b"]["snap"]["point"]), (&json!("point"), &json!([200.0, 0.0, 0.0])), "{fix}");
assert_eq!(fix["b"]["references"], json!([]));
assert!(fix.get("expressions").is_none(), "{fix}");
// A joint that isn't there is an error.
assert!(s.execute("joint.inspect", &json!({"joint": "Nope"})).is_err());
}
/// A joint whose sketch circle is replaced: its origin's face is gone, so it no longer
/// resolves; the inspection says why and that its curve is no longer in the sketch.
#[test]
fn joint_inspect_reports_a_lost_origin() {
let mut s = hinge_and_fix();
run(&mut s, "sketch.edit", json!({"sketch": "PinSketch"}));
run(&mut s, "sketch.delete", json!({"entities": ["c1"]}));
run(&mut s, "sketch.circle.center", json!({"center": [100, 0], "radius": 5, "id": "c2"}));
run(&mut s, "sketch.finish", json!({}));
let hinge = run(&mut s, "joint.inspect", json!({"joint": "Hinge"}))["joints"][0].clone();
assert_eq!(hinge["b"]["resolves"], false, "{hinge}");
let wall = reference(&hinge, "b", "face");
let name = wall["name"].as_str().unwrap_or_default();
assert!(hinge["b"]["error"].as_str().is_some_and(|e| e.contains(name)), "{hinge}");
assert_eq!(wall["sketch"]["curve"], "c1", "{hinge}");
assert!(wall["sketch"]["error"].is_string(), "{hinge}");
assert!(!hinge["errors"].as_array().is_none_or(Vec::is_empty), "the solve says so too: {hinge}");
// The Base side is still found.
assert_eq!(hinge["a"]["resolves"], true);
}
/// An edge whose first face is a fillet's: the fillet face's name holds the edge it rounds
/// (`F2:blend:<face>|<face>`), so the edge's two faces are the whole blend name and the slot's
/// wall, not the blend name cut at its own `|`.
#[test]
fn joint_inspect_splits_an_edge_of_a_blend_face_into_its_two_faces() {
let mut s = Session::default();
run(&mut s, "component.create", json!({"name": "Base"}));
run(&mut s, "solid.box", json!({"length": 40, "width": 40, "height": 10, "corner": [0, 0, 0]}));
run(&mut s, "solid.fillet", json!({"edges": [[40, 20, 10]], "radius": 3}));
run(&mut s, "solid.box", json!({"length": 10, "width": 4, "height": 20, "corner": [32, 18, -5], "operation": "cut"}));
run(&mut s, "component.activate", json!({"component": "root"}));
run(&mut s, "component.create", json!({"name": "Cap"}));
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 5, "corner": [200, 0, 0]}));
// On the slot's wall y = 18, halfway round the fillet (axis x = 37, z = 7, r = 3).
let h = 3.0 * std::f64::consts::FRAC_1_SQRT_2;
run(
&mut s,
"joint.create",
json!({"type": "rigid", "name": "OnBlend", "a": {"occurrence": "Base", "edge": [37.0 + h, 18, 7.0 + h]},
"b": {"occurrence": "Cap", "face": [205, 5, 5]}}),
);
let j = run(&mut s, "joint.inspect", json!({"joint": "OnBlend"}))["joints"][0].clone();
let edge = reference(&j, "a", "edge");
let name = edge["name"].as_str().unwrap_or_default().to_string();
let faces: Vec<String> = edge["faces"].as_array().into_iter().flatten().filter_map(|f| f["name"].as_str().map(str::to_string)).collect();
// `F4:blend:F3:+x|F3:+z#[F3:-y,F5:-y]|F5:-y`: the blend piece beside the slot, and the slot's wall.
assert!(name.split_once(':').is_some_and(|(_, r)| r.starts_with("blend:")), "the blend face comes first: {name}");
assert_eq!(faces.len(), 2, "{edge}");
assert_eq!(format!("{}|{}", faces[0], faces[1]), name, "{edge}");
assert!(faces[0].contains(":blend:") && faces[0].contains('|'), "{edge}");
assert!(!faces[1].contains('|'), "{edge}");
}
/// A joint on a pattern's copy of a pin: the copy's wall (`F3:side:c1@F4.1`) still names the
/// sketch curve it was swept from, `c1`.
#[test]
fn joint_inspect_finds_the_sketch_curve_of_a_copied_side() {
let mut s = Session::default();
run(&mut s, "component.create", json!({"name": "Pins"}));
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "PinSketch"}));
run(&mut s, "sketch.circle.center", json!({"center": [0, 0], "radius": 5, "id": "c1"}));
run(&mut s, "sketch.finish", json!({}));
run(&mut s, "solid.extrude", json!({"distance": 20, "name": "Pin"}));
run(&mut s, "solid.pattern.rectangular", json!({"features": ["Pin"], "dir1": [1, 0, 0], "count1": 2, "spacing1": 30}));
run(&mut s, "component.activate", json!({"component": "root"}));
run(&mut s, "component.create", json!({"name": "Cap"}));
run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 5, "corner": [200, 0, 0]}));
run(
&mut s,
"joint.create",
json!({"type": "revolute", "name": "OnCopy", "a": {"occurrence": "Pins", "circle": [35, 0, 20]}, "b": {"occurrence": "Cap", "face": [205, 5, 5]}}),
);
let j = run(&mut s, "joint.inspect", json!({"joint": "OnCopy"}))["joints"][0].clone();
let wall = reference(&j, "a", "face");
assert!(wall["name"].as_str().is_some_and(|n| n.contains(":side:c1@F")), "a copy's wall: {j}");
assert_eq!((&wall["sketch"]["curve"], &wall["sketch"]["name"]), (&json!("c1"), &json!("PinSketch")), "{j}");
assert!(wall["sketch"]["error"].is_null(), "{j}");
}
/// `joint.inspect` reads only: no undo step, the design unchanged, and the id agents' gates
/// treat as reading (`*.inspect`).
#[test]
fn joint_inspect_reads_only() {
let mut s = hinge_and_fix();
let spec = crate::cmd::command_specs().into_iter().find(|c| c.id == "joint.inspect");
assert!(spec.is_some_and(|c| !c.undoable && c.tab.is_empty()));
let undo = run(&mut s, "document.inspect", json!({}))["undo"].clone();
let before = serde_json::to_value(&s.doc).unwrap_or_default();
run(&mut s, "joint.inspect", json!({}));
run(&mut s, "joint.inspect", json!({"joint": "Fix"}));
assert_eq!(run(&mut s, "document.inspect", json!({}))["undo"], undo);
assert_eq!(serde_json::to_value(&s.doc).unwrap_or_default(), before);
}
/// Trial placements use exactly the same constraints as a full solve. Only the expensive DOF
/// report is optional: loop stops, errors and the resulting pose must not depend on it.
#[test]
fn placement_analysis_preserves_held_loop_constraints_and_diagnostics() {
use solidcraft_doc::joints::{self, Analysis};
use std::collections::BTreeMap;
let (s, _, _) = four_bar();
let rocker = s.doc.assembly.joints.iter().find(|j| j.name == "Rocker").unwrap().id;
let held = BTreeMap::from([((rocker, 0), 0.0)]);
for angle in [-10.0_f64, 40.0, 100.0] {
let mut doc = (*s.doc).clone();
doc.assembly.joints.iter_mut().find(|j| j.id == rocker).unwrap().values[0] = angle.to_radians();
let full = joints::solve_holding(&doc, &s.model.state(), &held);
let placement = joints::solve_holding_with_analysis(&doc, &s.model.state(), &held, Analysis::Placement);
assert!(placement.dof.is_empty(), "trial placement must not compute DOF");
assert_eq!(placement.world, full.world);
assert_eq!(placement.values, full.values);
assert_eq!(placement.fixed, full.fixed);
assert_eq!(placement.conflicts, full.conflicts);
assert_eq!(placement.errors, full.errors);
let mut placed = doc.clone();
placed.apply_joint_solution(&placement);
let mut reference = doc;
reference.apply_joint_solution(&full);
assert_eq!(placed, reference);
assert_eq!(joints::solve(&placed, &s.model.state()).dof, joints::solve(&reference, &s.model.state()).dof);
}
// A degenerate origin remains an error even in a placement-only trial.
let mut broken = (*s.doc).clone();
broken.assembly.joints[0].b.snap = solidcraft_doc::joints::Snap::Point { point: Vec3::ZERO, z: Some(Vec3::ZERO), x: None };
let full = joints::solve(&broken, &s.model.state());
let placement = joints::solve_holding_with_analysis(&broken, &s.model.state(), &BTreeMap::new(), Analysis::Placement);
assert!(!full.errors.is_empty());
assert_eq!(placement.errors, full.errors);
assert_eq!(placement.conflicts, full.conflicts);
}
/// Ordinary commands publish one complete report; refresh only updates constraint placements.
/// Counts are deterministic work assertions, not timing thresholds tied to a test machine.
#[test]
fn joint_drive_and_refresh_do_not_repeat_dof_analysis() {
let (mut s, _, _) = four_bar();
for (angle, quiet) in [(17, false), (58, true), (105, false)] {
super::solve_counts::take();
let r = run(&mut s, "joint.drive", json!({"joint":"Crank", "value":angle, "quiet":quiet}));
let (all, full) = super::solve_counts::take();
assert!(all > full, "placement trials must still run");
assert_eq!(full, usize::from(!quiet), "only a published DOF report needs full analysis");
let expected = super::sol_json(&solidcraft_doc::joints::solve(&s.doc, &s.model.state()), &json!({"quiet":quiet}));
for key in ["dof", "fixed", "errors", "conflicts"] {
assert_eq!(r.get(key), expected.get(key), "{key}: {r}");
}
let before = s.doc.clone();
s.refresh();
assert_eq!(super::solve_counts::take().1, 0, "refresh discards the DOF report");
assert_eq!(*s.doc, *before);
}
}
/// A parameter change solves the joints once: the refresh that follows the command finds the
/// design and the model as the command's own solve left them (the sketch the parameter drives
/// has its new solution stored after that solve). A move the joints undo is still solved.
#[test]
fn a_parameter_change_solves_the_joints_once() {
let mut s = Session::default();
run(&mut s, "parameters.change", json!({"name": "W", "expression": "300 mm"}));
run(&mut s, "component.create", json!({"name": "Plate"}));
run(&mut s, "solid.box", json!({"length": "W", "width": 100, "height": 1, "corner": [0, 0, 0]}));
run(&mut s, "solid.hole", json!({"position": ["W / 2", 50, 1], "diameter": 6}));
run(&mut s, "sketch.create", json!({"plane": "XY", "name": "S"}));
let r = run(&mut s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [40, 30]}));
let bottom = r["curves"][0].as_str().unwrap_or_default().to_string();
run(&mut s, "sketch.dimension", json!({"entities": [bottom], "value": "W / 10"}));
run(&mut s, "sketch.finish", json!({}));
let plate = occ(&s, "Plate");
run(&mut s, "occurrence.ground", json!({"occurrence": plate, "grounded": true}));
run(&mut s, "component.activate", json!({"component": "root"}));
run(&mut s, "component.create", json!({"name": "Bracket"}));
run(&mut s, "solid.box", json!({"length": 20, "width": 20, "height": 2, "corner": [100, 200, 0]}));
run(&mut s, "solid.hole", json!({"position": [110, 210, 2], "diameter": 6}));
let r = run(
&mut s,
"joint.create",
json!({"type": "rigid", "a": {"occurrence": "Plate", "circle": [153, 50, 0.8], "x": [1, 0, 0]},
"b": {"occurrence": "Bracket", "circle": [113, 210, 0.4], "x": [1, 0, 0]}}),
);
assert_eq!(r["errors"].as_array().map(Vec::len), Some(0), "{r}");
run(&mut s, "component.activate", json!({"component": "root"}));
for w in [400.0, 360.0] {
super::solve_counts::take();
run(&mut s, "parameters.change", json!({"name": "W", "expression": format!("{w} mm")}));
assert_eq!(super::solve_counts::take().0, 1, "W = {w}");
let at = place(&s, "Bracket", Vec3::new(110.0, 210.0, 0.0));
assert!(near(at, Vec3::new(w / 2.0, 50.0, 1.0)), "W = {w}: the bracket follows the hole, {at:?}");
}
// Moving the bracket changes no feature, so the model stays; the joint still takes it back.
let bracket = occ(&s, "Bracket");
super::solve_counts::take();
run(&mut s, "occurrence.move", json!({"occurrence": bracket, "translate": [5, 0, 0], "capture": true}));
assert!(super::solve_counts::take().0 > 0);
assert!(near(place(&s, "Bracket", Vec3::new(110.0, 210.0, 0.0)), Vec3::new(180.0, 50.0, 1.0)));
}
#[test]
fn driving_one_cylindrical_coordinate_preserves_the_other_expression_and_reports_continuous() {
let mut s = Session::default();
run(&mut s, "component.create", json!({"name":"Part","grounded":false}));
run(&mut s, "solid.box", json!({"length":10,"width":10,"height":10}));
run(&mut s, "component.activate", json!({"component":"root"}));
run(&mut s, "parameters.add", json!({"name":"turn","expression":"30 deg"}));
let joint = run(
&mut s,
"joint.create",
json!({"type":"cylindrical","a":{"occurrence":0,"point":[0,0,0]},"b":{"occurrence":"Part","point":[0,0,0]},"flip":true,"values":["turn",0]}),
)["joint"]
.as_u64()
.unwrap();
let before = s.doc.assembly.joints.iter().find(|j| j.id == joint).unwrap().exprs.value(0).map(str::to_string);
assert!(before.is_some());
let reply = run(&mut s, "joint.drive", json!({"joint":joint,"index":1,"value":12,"continuous":true,"quiet":true}));
assert_eq!(reply["continuous"], true);
let j = s.doc.assembly.joints.iter().find(|j| j.id == joint).unwrap();
assert_eq!(j.exprs.value(0).map(str::to_string), before);
assert!((j.values[0].to_degrees() - 30.).abs() < 1e-7);
assert!((j.values[1] - 12.).abs() < 1e-7);
run(&mut s, "parameters.change", json!({"name":"turn","expression":"40 deg"}));
let j = s.doc.assembly.joints.iter().find(|j| j.id == joint).unwrap();
assert!((j.values[0].to_degrees() - 40.).abs() < 1e-7, "the preserved expression still drives the angle");
assert!((j.values[1] - 12.).abs() < 1e-7);
for bad in [json!(-1), json!(2), json!(1000000), json!("0")] {
assert!(s.execute("joint.drive", &json!({"joint":joint,"index":bad,"value":0})).is_err());
}
}
/// #10747: driving a joint to 30 reports 30, not 29.999999999999996; the joint keeps
/// full precision.
#[test]
fn driving_an_angle_reports_the_number_a_person_would_read() {
let mut s = two_cubes();
run(
&mut s,
"joint.create",
json!({"type": "revolute", "a": {"occurrence": "A", "point": [5.0, 5.0, 10.0]}, "b": {"occurrence": "B", "point": [25.0, 5.0, 10.0]}, "name": "Turn"}),
);
let r = run(&mut s, "joint.drive", json!({"joint": "Turn", "value": 30}));
assert_eq!(r["values"][0]["value"], json!(30.0), "{r}");
assert_eq!(r["requested"][0]["value"], json!(30.0), "{r}");
// Only what is reported is rounded: the stored value keeps full precision.
let j = s.doc.assembly.joints.iter().find(|j| j.name == "Turn").unwrap();
assert_ne!(j.values[0].to_degrees(), 30.0, "the stored angle keeps its bits");
}
#[test]
fn new_joints_generate_type_prefixed_names_or_keep_custom_name() {
let mut s = two_cubes();
let (a, b) = (occ(&s, "A"), occ(&s, "B"));
// 1. Without name: revolute joint defaults to "Revolute Joint1"
let r1 = run(
&mut s,
"joint.create",
json!({
"type": "revolute",
"a": {"occurrence": a, "face": [5, 5, 10]},
"b": {"occurrence": b, "face": [25, 5, 0]}
}),
);
assert_eq!(r1["name"], "Revolute Joint1");
// 2. Without name: slider joint defaults to "Slider Joint1"
let r2 = run(
&mut s,
"joint.as_built",
json!({
"type": "slider",
"a": "A",
"b": "B"
}),
);
assert_eq!(r2["name"], "Slider Joint1");
// 3. With custom name: preserves custom name exactly
let r3 = run(
&mut s,
"joint.create",
json!({
"type": "rigid",
"name": "CustomRigid",
"a": {"occurrence": a, "face": [5, 5, 10]},
"b": {"occurrence": b, "face": [25, 5, 0]}
}),
);
assert_eq!(r3["name"], "CustomRigid");
}