547 lines
21 KiB
Python
547 lines
21 KiB
Python
"""Native verification distinguishes unsafe poses and sustained actuator limits."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import math
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
pytest.importorskip("mujoco")
|
|
|
|
from mjrl.onboarding import verify as verify_module
|
|
|
|
SLIDER = """
|
|
<mujoco>
|
|
<option timestep="0.002" gravity="0 0 0" integrator="implicitfast"/>
|
|
<worldbody>
|
|
<body name="base">
|
|
<geom type="box" size="0.02 0.02 0.02"/>
|
|
<body name="carriage" pos="0 0 0.15">
|
|
<joint name="slide" type="slide" axis="1 0 0" range="-1 1"
|
|
damping="4" stiffness="{stiffness}"/>
|
|
<geom name="carriage_shell" type="sphere" size="0.025" mass="0.1"/>
|
|
</body>
|
|
{other_body}
|
|
</body>
|
|
</worldbody>
|
|
<actuator>
|
|
<position name="servo" joint="slide" kp="10" forcerange="-1 1" ctrlrange="-1 1"/>
|
|
</actuator>
|
|
</mujoco>
|
|
"""
|
|
|
|
|
|
def _model(tmp_path: Path, *, stiffness: float = 0.0, overlap: bool = False) -> Path:
|
|
other = (
|
|
"""
|
|
<body name="overlap" pos="0 0.01 0.15">
|
|
<joint name="spare" type="hinge"/>
|
|
<geom name="overlap_shell" type="sphere" size="0.025" mass="0.1"/>
|
|
</body>
|
|
"""
|
|
if overlap
|
|
else ""
|
|
)
|
|
path = tmp_path / f"slider_{stiffness}_{overlap}.xml"
|
|
path.write_text(SLIDER.format(stiffness=stiffness, other_body=other), encoding="utf-8")
|
|
return path
|
|
|
|
|
|
def _configuration(target: float = 0.15, expected: float = 0.15, **extra) -> dict:
|
|
return {
|
|
"steps": 1000,
|
|
"actuator_targets": {"servo": target},
|
|
"joint_positions": {"slide": expected},
|
|
**extra,
|
|
}
|
|
|
|
|
|
def _check(report, stage, name):
|
|
return next(item for item in report["stages"][stage]["checks"] if item["name"] == name)
|
|
|
|
|
|
def test_initial_joint_margin_rejects_near_stop_before_motion(tmp_path):
|
|
model = _model(tmp_path)
|
|
safe = verify_module.verify(model, _configuration())
|
|
assert safe["passed"], safe["stages"]
|
|
near = verify_module.verify(model, _configuration(pose={"slide": 0.99}))
|
|
gate = _check(near, "physics", "initial_joint_ranges")
|
|
assert not near["passed"] and not gate["passed"]
|
|
assert gate["margins"]["slide"] == pytest.approx(0.005)
|
|
assert gate["minimum_margin_fraction"] == 0.02
|
|
assert near["probes"] == []
|
|
|
|
allowed = verify_module.verify(
|
|
model,
|
|
_configuration(
|
|
pose={"slide": 0.99},
|
|
steps=4000,
|
|
thresholds={"minimum_initial_limit_margin": 0.004},
|
|
),
|
|
)
|
|
assert allowed["passed"], allowed["stages"]
|
|
|
|
|
|
def test_initial_self_penetration_lists_both_robot_geoms(tmp_path):
|
|
report = verify_module.verify(_model(tmp_path, overlap=True), _configuration())
|
|
gate = _check(report, "physics", "initial_self_penetration")
|
|
assert not report["passed"] and not gate["passed"]
|
|
assert len(gate["contacts"]) == 1
|
|
contact = gate["contacts"][0]
|
|
assert contact["geoms"] == ["carriage_shell", "overlap_shell"]
|
|
assert contact["depth_m"] == pytest.approx(0.04)
|
|
assert report["probes"] == []
|
|
|
|
|
|
def test_sustained_saturation_fails_even_when_position_response_matches(tmp_path):
|
|
# The force limit is 1 N. A 10 N/m return spring holds the saturated
|
|
# carriage at 0.1 m even though its controller requests 0.5 m.
|
|
result = verify_module.verify(_model(tmp_path, stiffness=10), _configuration(0.5, 0.1))
|
|
assert result["stages"]["physics"]["passed"]
|
|
assert _check(result, "control", "joint_positions")["passed"]
|
|
assert not result["passed"]
|
|
saturation = _check(result, "control", "effort_saturation")
|
|
assert not saturation["passed"]
|
|
assert saturation["peak_ratios"]["actuator:servo"] == pytest.approx(1.0)
|
|
assert saturation["saturated_fractions"]["actuator:servo"] == 1.0
|
|
assert saturation["window_steps"] == saturation["measured_window_steps"] == 250
|
|
|
|
|
|
def test_transient_saturation_during_acceleration_passes(tmp_path):
|
|
result = verify_module.verify(_model(tmp_path), _configuration())
|
|
saturation = _check(result, "control", "effort_saturation")
|
|
assert result["passed"], result["stages"]
|
|
assert saturation["peak_ratios"]["actuator:servo"] == pytest.approx(1.0)
|
|
assert saturation["saturated_fractions"]["actuator:servo"] == 0.0
|
|
|
|
|
|
def test_invalid_generated_control_stays_out_of_reference_samples(tmp_path, monkeypatch):
|
|
original = verify_module._probe_driver
|
|
|
|
def broken(*args, **kwargs):
|
|
update = original(*args, **kwargs)
|
|
data = args[1]
|
|
|
|
def step(index):
|
|
update(index)
|
|
if index == 2:
|
|
data.ctrl[0] = float("nan")
|
|
|
|
return step
|
|
|
|
monkeypatch.setattr(verify_module, "_probe_driver", broken)
|
|
result = verify_module.verify(_model(tmp_path), _configuration())
|
|
check = _check(result, "control", "finite_control")
|
|
assert not result["passed"] and not check["passed"]
|
|
assert check["first_invalid_step"] == 3
|
|
assert _check(result, "physics", "native_steps")["completed"] == 2
|
|
json.dumps(result, allow_nan=False)
|
|
|
|
|
|
def test_velocity_servo_accelerates_at_the_limit_and_then_settles(tmp_path):
|
|
model = tmp_path / "velocity.xml"
|
|
model.write_text(
|
|
"""
|
|
<mujoco>
|
|
<option timestep="0.002" gravity="0 0 0" integrator="implicitfast"/>
|
|
<worldbody>
|
|
<body name="base">
|
|
<geom type="box" size="0.02 0.02 0.02"/>
|
|
<body name="rotor" pos="0 0 0.3">
|
|
<joint name="rotation" axis="1 0 0" damping="0.05"/>
|
|
<geom type="cylinder" size="0.1 0.03" mass="1"/>
|
|
</body>
|
|
</body>
|
|
</worldbody>
|
|
<actuator>
|
|
<velocity name="spin" joint="rotation" kv="4" forcerange="-1 1"/>
|
|
</actuator>
|
|
</mujoco>
|
|
""",
|
|
encoding="utf-8",
|
|
)
|
|
result = verify_module.verify(
|
|
model,
|
|
{"steps": 500, "actuator_targets": {"spin": 3.0}, "joint_velocities": {"rotation": 3.0}},
|
|
)
|
|
assert result["passed"], result["stages"]
|
|
effort = _check(result, "control", "effort_saturation")
|
|
assert effort["peak_ratios"]["actuator:spin"] == pytest.approx(1.0)
|
|
assert effort["saturated_fractions"]["actuator:spin"] == 0.0
|
|
assert _check(result, "physics", "initial_joint_ranges")["margins"]["rotation"] is None
|
|
|
|
|
|
def test_disabling_collisions_cannot_bypass_physics_verification(tmp_path):
|
|
model = _model(tmp_path, overlap=True)
|
|
text = model.read_text()
|
|
model.write_text(
|
|
text.replace(
|
|
'integrator="implicitfast"/>',
|
|
'integrator="implicitfast"><flag contact="disable"/></option>',
|
|
)
|
|
)
|
|
report = verify_module.verify(model, _configuration())
|
|
assert not _check(report, "physics", "contact_dynamics_enabled")["passed"]
|
|
assert report["probes"] == []
|
|
|
|
|
|
def test_joint_effort_bound_is_checked_independently_of_actuator_force(tmp_path):
|
|
model = _model(tmp_path, stiffness=10)
|
|
text = model.read_text()
|
|
model.write_text(
|
|
text.replace(
|
|
'damping="4" stiffness="10"', 'damping="4" stiffness="10" actuatorfrcrange="-1 1"'
|
|
).replace('forcerange="-1 1" ctrlrange', 'forcerange="-10 10" ctrlrange')
|
|
)
|
|
result = verify_module.verify(model, _configuration(0.5, 0.1))
|
|
assert _check(result, "control", "joint_positions")["passed"]
|
|
effort = _check(result, "control", "effort_saturation")
|
|
assert not effort["passed"]
|
|
assert effort["saturated_fractions"]["actuator:servo"] == 0.0
|
|
assert effort["saturated_fractions"]["joint:slide"] == 1.0
|
|
|
|
|
|
_MEAN = "base_velocity_mean_m_s"
|
|
_MAE = "base_velocity_tracking_mae_m_s"
|
|
|
|
|
|
@pytest.fixture
|
|
def translating_robot(tmp_path: Path) -> Path:
|
|
source = tmp_path / "robot.xml"
|
|
source.write_text(
|
|
"""
|
|
<mujoco>
|
|
<option timestep=".002" gravity="0 0 0" integrator="implicitfast"/>
|
|
<worldbody>
|
|
<body name="base" euler="0 0 90">
|
|
<joint name="travel" type="slide" axis="1 0 0" damping=".2"/>
|
|
<geom type="sphere" size=".025" mass=".1"/>
|
|
</body>
|
|
</worldbody>
|
|
<actuator><velocity name="drive" joint="travel" kv="10" ctrlrange="-1 1"/></actuator>
|
|
</mujoco>
|
|
""",
|
|
encoding="utf-8",
|
|
)
|
|
return source
|
|
|
|
|
|
def _axis_expectation(target: float, tolerance: float) -> dict:
|
|
return {"target": [target, 0, 0], "tolerance": [tolerance, 0.001, None]}
|
|
|
|
|
|
def test_constant_body_velocity_passes_and_replays_from_app(translating_robot, tmp_path):
|
|
from mjrl.platform.bundle import build_bundle
|
|
from mjrl.platform.reference import check_reference
|
|
|
|
translating_robot.write_text(
|
|
translating_robot.read_text().replace(
|
|
'<velocity name="drive" joint="travel" kv="10" ctrlrange="-1 1"/>',
|
|
'<position name="drive" joint="travel" kp="100" kv="6.2" ctrlrange="-2 2"/>',
|
|
)
|
|
)
|
|
controller = tmp_path / "controller.json"
|
|
controller.write_text(
|
|
json.dumps(
|
|
{
|
|
"kind": "trajectory",
|
|
"control_hz": 500,
|
|
"joints": ["travel"],
|
|
"trajectory": {"joint_order": ["travel"], "time_s": [0, 3], "q": [[0], [1.5]]},
|
|
}
|
|
),
|
|
encoding="utf-8",
|
|
)
|
|
config = {
|
|
"controller": str(controller),
|
|
"steps": 1000,
|
|
"probes": [
|
|
{
|
|
"command": {"playback_rate": 1},
|
|
"evaluation_start_s": 0.4,
|
|
"expect": {
|
|
_MEAN: _axis_expectation(0.5, 1e-4),
|
|
_MAE: _axis_expectation(0.5, 1e-4),
|
|
"base_angular_velocity_mean_rad_s": _axis_expectation(0, 1e-6),
|
|
"base_angular_velocity_tracking_mae_rad_s": _axis_expectation(0, 1e-6),
|
|
},
|
|
}
|
|
],
|
|
}
|
|
report = verify_module.verify(translating_robot, config)
|
|
assert report["passed"], report["stages"]
|
|
probe = report["probes"][0]
|
|
evidence = probe["velocity_evaluation"]
|
|
assert evidence["physics_samples"] == 801
|
|
assert [item["physics_step"] for item in probe["samples"]] == [0, 1, 500, 1000]
|
|
assert evidence["metrics"][_MEAN]["observed"] == pytest.approx([0.5, 0, 0], abs=1e-4)
|
|
assert evidence["metrics"][_MAE]["actuation_disabled_observed"] == pytest.approx([0.5, 0, 0])
|
|
verification = tmp_path / "verification.json"
|
|
verification.write_text(json.dumps(report), encoding="utf-8")
|
|
options = {
|
|
"robot_id": "robot",
|
|
"modes": {"drive": {"controller": controller, "verification": verification}},
|
|
}
|
|
app = build_bundle(translating_robot, tmp_path / "robot", **options)
|
|
replay = check_reference(app)
|
|
assert replay["passed"]
|
|
assert replay["probes"][0]["velocity_evaluation"]["metrics"][_MEAN][
|
|
"observed"
|
|
] == pytest.approx([0.5, 0, 0], abs=1e-4)
|
|
|
|
# A reference can preserve all four sampled states and still lie about
|
|
# its inter-sample velocity. Building the app must catch that discrepancy.
|
|
evidence["metrics"][_MEAN]["observed"][0] = 0.55
|
|
_check(report, "control", _MEAN)["observed"][0] = 0.55
|
|
verification.write_text(json.dumps(report), encoding="utf-8")
|
|
with pytest.raises(ValueError, match="did not reproduce verification"):
|
|
build_bundle(translating_robot, tmp_path / "false_measurement", **options)
|
|
|
|
|
|
def test_bundle_requires_endpoint_gate_and_remeasures_it(tmp_path):
|
|
from mjrl.platform.bundle import build_bundle
|
|
from mjrl.platform.reference import check_reference
|
|
|
|
model = _model(tmp_path)
|
|
controller = tmp_path / "controller.json"
|
|
controller.write_text(json.dumps({"kind": "joint_sliders", "joints": ["slide"]}))
|
|
verification = tmp_path / "verification.json"
|
|
options = {
|
|
"robot_id": "robot",
|
|
"modes": {
|
|
"move": {
|
|
"controller": controller,
|
|
"verification": verification,
|
|
}
|
|
},
|
|
}
|
|
|
|
def report_for(target):
|
|
return verify_module.verify(
|
|
model,
|
|
{
|
|
"controller": str(controller),
|
|
"probes": [
|
|
{
|
|
"steps": 1000,
|
|
"command": {"slide": 0.15},
|
|
"joint_positions": {"slide": target},
|
|
}
|
|
],
|
|
},
|
|
)
|
|
|
|
failed = report_for(-0.15)
|
|
stage = failed["stages"]["control"]
|
|
gate = _check(failed, "control", "joint_positions")
|
|
assert not failed["passed"] and not gate["passed"]
|
|
failed["passed"] = stage["passed"] = True
|
|
stage["checks"].remove(gate)
|
|
verification.write_text(json.dumps(failed))
|
|
with pytest.raises(ValueError, match="requires explicit physical response expectations"):
|
|
build_bundle(model, tmp_path / "missing_response", **options)
|
|
|
|
stage["checks"].append(gate)
|
|
gate["passed"] = True
|
|
failed["probes"][0]["endpoint_response"]["metrics"]["joint_positions"]["passed"] = True
|
|
verification.write_text(json.dumps(failed))
|
|
with pytest.raises(ValueError, match="did not reproduce verification"):
|
|
build_bundle(model, tmp_path / "false_response", **options)
|
|
|
|
good = report_for(0.15)
|
|
assert good["passed"]
|
|
verification.write_text(json.dumps(good))
|
|
app = build_bundle(model, tmp_path / "accepted_response", **options)
|
|
reproduced = check_reference(app)
|
|
assert reproduced["passed"]
|
|
endpoint = reproduced["probes"][0]["endpoint_response"]["metrics"]["joint_positions"]
|
|
measured = _check(good, "control", "joint_positions")
|
|
assert endpoint["observed"] == pytest.approx(measured["observed"], abs=1e-8)
|
|
assert endpoint["error"] <= endpoint["tolerance"]
|
|
|
|
|
|
def test_near_zero_mean_oscillation_fails_tracking_mae(translating_robot, monkeypatch):
|
|
def oscillating_driver(model, data, *_args):
|
|
def update(index):
|
|
data.ctrl[0] = 0.51 * math.sin(2 * math.pi * index * model.opt.timestep * 2)
|
|
|
|
return update
|
|
|
|
monkeypatch.setattr(verify_module, "_probe_driver", oscillating_driver)
|
|
report = verify_module.verify(
|
|
translating_robot,
|
|
{
|
|
"steps": 2250,
|
|
"evaluation_start_s": 0.502,
|
|
"expect": {_MEAN: _axis_expectation(0, 0.01), _MAE: _axis_expectation(0, 0.1)},
|
|
},
|
|
)
|
|
assert report["stages"]["physics"]["passed"]
|
|
assert _check(report, "control", _MEAN)["passed"]
|
|
mae = _check(report, "control", _MAE)
|
|
assert not mae["passed"] and mae["observed"][0] > 0.25
|
|
assert mae["actuation_disabled_observed"] == [0, 0, 0]
|
|
|
|
|
|
def test_endpoint_motion_cannot_satisfy_window_contrast(tmp_path):
|
|
report = verify_module.verify(
|
|
_model(tmp_path), _configuration(expect={_MEAN: _axis_expectation(0, 0.01)})
|
|
)
|
|
assert _check(report, "control", "joint_positions")["passed"]
|
|
assert _check(report, "control", _MEAN)["passed"]
|
|
assert not _check(report, "control", "response_differs_with_actuators_disabled")["passed"]
|
|
|
|
|
|
@pytest.mark.parametrize("start", [-1, 2, 3, True, float("nan")])
|
|
def test_invalid_evaluation_warmup_fails_without_a_probe(translating_robot, start):
|
|
report = verify_module.verify(
|
|
translating_robot,
|
|
{
|
|
"steps": 1000,
|
|
"actuator_targets": {"drive": 0.51},
|
|
"evaluation_start_s": start,
|
|
"expect": {_MEAN: _axis_expectation(0.5, 0.01)},
|
|
},
|
|
)
|
|
assert not report["passed"] and not report["probes"]
|
|
assert "evaluation_start_s" in _check(report, "control", "control_probes")["detail"]
|
|
|
|
|
|
def test_wheels_spinning_on_fixed_chassis_cannot_be_verified_or_packaged(tmp_path):
|
|
from mjrl.controllers import setup_controller
|
|
from mjrl.platform.bundle import build_bundle
|
|
|
|
fixture = Path(__file__).resolve().parents[1] / "assets" / "differential_drive"
|
|
source = tmp_path / "fixed.xml"
|
|
source.write_text(
|
|
(fixture / "robot.xml").read_text().replace('<freejoint name="root"/>', "")
|
|
.replace('name="chassis" pos="0 0 0.12"', 'name="chassis" pos="0 0 0.4"'),
|
|
encoding="utf-8",
|
|
)
|
|
setup = setup_controller(source, fixture / "controller.json", tmp_path / "prepared")
|
|
report = verify_module.verify(
|
|
setup.model,
|
|
{
|
|
"root_body": "chassis",
|
|
"controller": str(setup.config),
|
|
"controls": str(setup.controls),
|
|
"steps": 750,
|
|
"probes": [
|
|
{
|
|
"command": {"lin_vel_x": 0.35},
|
|
"joint_velocities": {"left_wheel": 3.5, "right_wheel": 3.5},
|
|
"base_displacement_m": [0, 0, 0],
|
|
}
|
|
],
|
|
},
|
|
)
|
|
assert report["stages"]["physics"]["passed"]
|
|
assert _check(report, "control", "joint_velocities")["passed"]
|
|
assert _check(report, "control", "response_differs_with_actuators_disabled")["passed"]
|
|
coverage = _check(report, "control", "body_command_coverage")
|
|
assert not report["passed"]
|
|
assert coverage["missing_axes"] == ["ang_vel_z", "lin_vel_x"]
|
|
|
|
# An older or edited report can omit the failed coverage check. Packaging
|
|
# checks the evidence itself and must still refuse the fixed chassis.
|
|
stage = report["stages"]["control"]
|
|
report["passed"] = stage["passed"] = True
|
|
stage["checks"].remove(coverage)
|
|
verification = tmp_path / "verification.json"
|
|
verification.write_text(json.dumps(report), encoding="utf-8")
|
|
with pytest.raises(ValueError, match="differential requires measured nonzero body-motion"):
|
|
build_bundle(
|
|
setup.model,
|
|
tmp_path / "fixed",
|
|
robot_id="fixed",
|
|
modes={"main": {"controller": setup.config, "controls": setup.controls}},
|
|
verification=verification,
|
|
)
|
|
|
|
|
|
def test_complete_wheel_probe_exercises_body_translation_and_yaw(tmp_path):
|
|
from mjrl.controllers import setup_controller
|
|
from mjrl.platform.bundle import build_bundle
|
|
|
|
fixture = Path(__file__).resolve().parents[1] / "assets" / "differential_drive"
|
|
setup = setup_controller(fixture / "robot.xml", fixture / "controller.json", tmp_path / "setup")
|
|
config = json.loads((fixture / "verify.json").read_text())
|
|
report = verify_module.verify(setup.model, config, base_dir=setup.config.parent)
|
|
assert report["passed"], report["stages"]["control"]
|
|
assert _check(report, "control", "body_command_coverage")["passed"]
|
|
verification = tmp_path / "verification.json"
|
|
verification.write_text(json.dumps(report), encoding="utf-8")
|
|
assert build_bundle(
|
|
setup.model,
|
|
tmp_path / "drive",
|
|
robot_id="drive",
|
|
modes={"main": {"controller": setup.config, "controls": setup.controls}},
|
|
verification=verification,
|
|
).is_file()
|
|
|
|
config["thresholds"]["base_displacement_atol_m"] = 0.08
|
|
config["probes"] = [{
|
|
"command": {"lin_vel_x": 0.25, "ang_vel_z": 0.4},
|
|
"base_displacement_m": [0.35, 0.1, 0],
|
|
"base_angular_velocity_rad_s": [0, 0, 0.4],
|
|
}]
|
|
combined = verify_module.verify(setup.model, config, base_dir=setup.config.parent)
|
|
assert _check(combined, "control", "base_displacement_m")["passed"]
|
|
assert _check(combined, "control", "base_angular_velocity_rad_s")["passed"]
|
|
assert _check(combined, "control", "body_command_coverage")["missing_axes"] == [
|
|
"ang_vel_z", "lin_vel_x",
|
|
]
|
|
|
|
|
|
def test_onnx_velocity_axes_need_matching_measured_commands():
|
|
from mjrl.platform.mobility import missing_mobility_axes
|
|
|
|
config = {"kind": "rl_onnx"}
|
|
layout = {
|
|
"observation": {"terms": [{"name": "commands"}]},
|
|
"command_ranges": {"twist": {"lin_vel_x": [-1, 1], "ang_vel_z": [-1, 1]}},
|
|
}
|
|
forward = {
|
|
"inputs": {"command": {"lin_vel_x": 0.4}},
|
|
"velocity_evaluation": {
|
|
"metrics": {
|
|
_MEAN: {
|
|
"expected": [0.4, 0, 0], "observed": [0.38, 0, 0],
|
|
"tolerance": [0.1, None, None], "passed": True,
|
|
"actuation_disabled_observed": [0, 0, 0],
|
|
}
|
|
}
|
|
},
|
|
}
|
|
yaw = {
|
|
"inputs": {"command": {"ang_vel_z": -0.5}},
|
|
"velocity_evaluation": {
|
|
"metrics": {
|
|
"base_angular_velocity_tracking_mae_rad_s": {
|
|
"expected": [0, 0, 0.5], "observed": [0, 0, 0.05],
|
|
"tolerance": [None, None, 0.1], "passed": True,
|
|
"actuation_disabled_observed": [0, 0, 0.5],
|
|
}
|
|
}
|
|
},
|
|
}
|
|
report = {"probes": [forward, yaw]}
|
|
assert missing_mobility_axes(None, config, report, layout) == ["ang_vel_z"]
|
|
metric = yaw["velocity_evaluation"]["metrics"]["base_angular_velocity_tracking_mae_rad_s"]
|
|
metric["expected"][2] = -0.5
|
|
assert missing_mobility_axes(None, config, report, layout) == []
|
|
combined = {
|
|
"inputs": {"command": {"lin_vel_x": 0.4, "ang_vel_z": -0.5}},
|
|
"velocity_evaluation": {"metrics": {
|
|
**forward["velocity_evaluation"]["metrics"],
|
|
**yaw["velocity_evaluation"]["metrics"],
|
|
}},
|
|
}
|
|
assert missing_mobility_axes(None, config, {"probes": [combined]}, layout) == [
|
|
"ang_vel_z", "lin_vel_x",
|
|
]
|
|
metric["actuation_disabled_observed"][2] = 0.06
|
|
assert missing_mobility_axes(None, config, report, layout) == ["ang_vel_z"]
|