Consolidate overlapping isaaclab_newton tests

Merge the dynamics accessor shape and FK-refresh checks into one sim per
asset, fold paired sensor and schema checks that rebuilt the same scene,
remove permanently skipped tests, and skip the non-strict xfail contact
sensor cases that ran to completion without producing a verdict.

Author: StafaH

source/isaaclab_newton/changelog.d/test-optimize-isaaclab-newton-tests-2.skip

@@ -0,0 +1,4 @@
+Test-only change: consolidated overlapping isaaclab_newton tests (articulation dynamics
+accessor shapes and FK-refresh checks, sensor initialization/at-rest checks, schema
+author/unset pairs, frame-view guards), removed permanently skipped tests, and replaced
+non-strict xfail contact-sensor cases with skips. No user-visible behavior change.

source/isaaclab_newton/test/assets/test_articulation.py

@@ -32,7 +32,6 @@
 import isaaclab.sim as sim_utils
 from isaaclab.assets import RigidObjectCfg
 from isaaclab.sim import SimulationCfg, build_simulation_context
-from isaaclab.sim.spawners import materials
 from isaaclab.utils.assets import ISAAC_NUCLEUS_DIR, ISAACLAB_NUCLEUS_DIR
 from isaaclab.utils.math import (
     combine_frame_transforms,
@@ -155,76 +154,16 @@ def test_initialization(num_cubes, device):
 
 
 @pytest.mark.isaacsim_ci
-@pytest.mark.skip(reason="Newton does not support kinematic rigid bodies")
-@pytest.mark.parametrize("num_cubes", [1, 2])
-@pytest.mark.parametrize("device", test_devices())
-def test_initialization_with_kinematic_enabled(num_cubes, device):
-    """Test that initialization for prim with kinematic flag enabled."""
-    with _newton_sim_context(device, auto_add_lighting=True) as sim:
+@pytest.mark.parametrize("api", ["none", "articulation_root"])
+def test_initialization_rejects_non_rigid_body_prims(api):
+    """Initialization fails when the prim path has no rigid body API or carries an articulation root."""
+    with _newton_sim_context("cpu", auto_add_lighting=True) as sim:
         sim._app_control_on_stop_handle = None
-        # Generate cubes scene
-        cube_object, origins = generate_cubes_scene(num_cubes=num_cubes, kinematic_enabled=True, device=device)
+        cube_object, _ = generate_cubes_scene(num_cubes=1, api=api, device="cpu")
 
         # Check that the framework doesn't hold excessive strong references.
         assert sys.getrefcount(cube_object) < 10
 
-        # Play sim
-        sim.reset()
-
-        # Check if object is initialized
-        assert cube_object.is_initialized
-        assert len(cube_object.body_names) == 1
-
-        # Check buffers that exists and have correct shapes
-        assert cube_object.data.root_pos_w.torch.shape == (num_cubes, 3)
-        assert cube_object.data.root_quat_w.torch.shape == (num_cubes, 4)
-
-        # Simulate physics
-        for _ in range(2):
-            # perform rendering
-            sim.step()
-            # update object
-            cube_object.update(sim.cfg.dt)
-            # check that the object is kinematic
-            default_root_pose = cube_object.data.default_root_pose.torch.clone()
-            default_root_vel = cube_object.data.default_root_vel.torch.clone()
-            default_root_pose[:, :3] += origins
-            torch.testing.assert_close(cube_object.data.root_link_pose_w.torch, default_root_pose)
-            torch.testing.assert_close(cube_object.data.root_com_vel_w.torch, default_root_vel)
-
-
-@pytest.mark.isaacsim_ci
-@pytest.mark.parametrize("num_cubes", [1, 2])
-@pytest.mark.parametrize("device", test_devices())
-def test_initialization_with_no_rigid_body(num_cubes, device):
-    """Test that initialization fails when no rigid body is found at the provided prim path."""
-    with _newton_sim_context(device, auto_add_lighting=True) as sim:
-        sim._app_control_on_stop_handle = None
-        # Generate cubes scene
-        cube_object, _ = generate_cubes_scene(num_cubes=num_cubes, api="none", device=device)
-
-        # Check that the framework doesn't hold excessive strong references.
-        assert sys.getrefcount(cube_object) < 10
-
-        # Play sim
-        with pytest.raises(RuntimeError):
-            sim.reset()
-
-
-@pytest.mark.isaacsim_ci
-@pytest.mark.parametrize("num_cubes", [1, 2])
-@pytest.mark.parametrize("device", test_devices())
-def test_initialization_with_articulation_root(num_cubes, device):
-    """Test that initialization fails when an articulation root is found at the provided prim path."""
-    with _newton_sim_context(device, auto_add_lighting=True) as sim:
-        sim._app_control_on_stop_handle = None
-        # Generate cubes scene
-        cube_object, _ = generate_cubes_scene(num_cubes=num_cubes, api="articulation_root", device=device)
-
-        # Check that the framework doesn't hold excessive strong references.
-        assert sys.getrefcount(cube_object) < 10
-
-        # Play sim
         with pytest.raises(RuntimeError):
             sim.reset()
 
@@ -610,234 +549,6 @@ def test_rigid_body_set_material_properties(num_cubes, device):
         torch.testing.assert_close(restitution_check, restitution)
 
 
-def _set_newton_material_properties(cube_object, friction_val, restitution_val, device):
-    """Helper to set material properties via Newton view-level APIs."""
-    model = SimulationManager.get_model()
-    friction_binding = cube_object._root_view.get_attribute("shape_material_mu", model)[:, 0]
-    restitution_binding = cube_object._root_view.get_attribute("shape_material_restitution", model)[:, 0]
-    num_envs = friction_binding.shape[0]
-    num_shapes = friction_binding.shape[1]
-
-    friction_tensor = torch.full((num_envs, num_shapes), friction_val, device=device)
-    restitution_tensor = torch.full((num_envs, num_shapes), restitution_val, device=device)
-
-    wp.to_torch(friction_binding)[:] = friction_tensor
-    wp.to_torch(restitution_binding)[:] = restitution_tensor
-    SimulationManager.add_model_change(ModelFlags.SHAPE_PROPERTIES)
-
-
-@pytest.mark.isaacsim_ci
-@pytest.mark.skip(reason="MuJoCo contact at height=0 does not settle the same as PhysX — cube falls on z-axis")
-@pytest.mark.parametrize("num_cubes", [1, 2])
-@pytest.mark.parametrize("device", test_devices())
-def test_rigid_body_no_friction(num_cubes, device):
-    """Test that a rigid object with no friction will maintain it's velocity when sliding across a plane."""
-    with _newton_sim_context(device, auto_add_lighting=True) as sim:
-        sim._app_control_on_stop_handle = None
-        # Generate cubes scene
-        cube_object, _ = generate_cubes_scene(num_cubes=num_cubes, height=0.0, device=device)
-
-        # Create ground plane with near-zero friction
-        # Note: MuJoCo requires friction >= MJ_MINMU (1e-5), so we use 1e-4
-        cfg = sim_utils.GroundPlaneCfg(
-            physics_material=materials.RigidBodyMaterialCfg(
-                static_friction=1e-4,
-                dynamic_friction=1e-4,
-                restitution=0.0,
-            )
-        )
-        cfg.func("/World/GroundPlane", cfg)
-
-        # Play sim
-        sim.reset()
-
-        # Set material friction to near-zero via view-level API
-        _set_newton_material_properties(cube_object, friction_val=1e-4, restitution_val=0.0, device=device)
-
-        # Set initial velocity
-        # Initial velocity in X to get the block moving
-        initial_velocity = torch.zeros((num_cubes, 6), device=sim.cfg.device)
-        initial_velocity[:, 0] = 0.1
-
-        cube_object.write_root_velocity_to_sim_index(root_velocity=initial_velocity)
-
-        # Simulate physics
-        for _ in range(5):
-            # perform rendering
-            sim.step()
-            # update object
-            cube_object.update(sim.cfg.dt)
-
-            # Non-deterministic when on GPU, so we use different tolerances
-            if device.startswith("cuda"):
-                tolerance = 1e-2
-            else:
-                tolerance = 1e-5
-
-            torch.testing.assert_close(
-                cube_object.data.root_lin_vel_w.torch, initial_velocity[:, :3], rtol=1e-5, atol=tolerance
-            )
-
-
-@pytest.mark.isaacsim_ci
-@pytest.mark.skip(reason="MuJoCo uses Coulomb friction (single mu), no static/dynamic distinction")
-@pytest.mark.parametrize("num_cubes", [1, 2])
-@pytest.mark.parametrize("device", test_devices())
-def test_rigid_body_with_static_friction(num_cubes, device):
-    """Test that static friction applied to rigid object works as expected.
-
-    This test works by applying a force to the object and checking if the object moves or not based on the
-    mu (coefficient of static friction) value set for the object. We set the static friction to be non-zero and
-    apply a force to the object. When the force applied is below mu, the object should not move. When the force
-    applied is above mu, the object should move.
-    """
-    with _newton_sim_context(device, dt=0.01, add_ground_plane=False, auto_add_lighting=True) as sim:
-        sim._app_control_on_stop_handle = None
-        cube_object, _ = generate_cubes_scene(num_cubes=num_cubes, height=0.03125, device=device)
-
-        # Create ground plane
-        static_friction_coefficient = 0.5
-        cfg = sim_utils.GroundPlaneCfg(
-            physics_material=materials.RigidBodyMaterialCfg(
-                static_friction=static_friction_coefficient,
-                dynamic_friction=static_friction_coefficient,
-            )
-        )
-        cfg.func("/World/GroundPlane", cfg)
-
-        # Play sim
-        sim.reset()
-
-        # Set friction via view-level API
-        _set_newton_material_properties(
-            cube_object,
-            friction_val=static_friction_coefficient,
-            restitution_val=0.0,
-            device=device,
-        )
-
-        # let everything settle
-        for _ in range(100):
-            sim.step()
-            cube_object.update(sim.cfg.dt)
-        cube_object.write_root_velocity_to_sim_index(root_velocity=torch.zeros((num_cubes, 6), device=sim.device))
-        cube_mass = cube_object.data.body_mass.torch
-        gravity_magnitude = abs(sim.cfg.gravity[2])
-        # 2 cases: force applied is below and above mu
-        # below mu: block should not move as the force applied is <= mu
-        # above mu: block should move as the force applied is > mu
-        for force in "below_mu", "above_mu":
-            # set initial velocity to zero
-            cube_object.write_root_velocity_to_sim_index(root_velocity=torch.zeros((num_cubes, 6), device=sim.device))
-
-            external_wrench_b = torch.zeros((num_cubes, 1, 6), device=sim.device)
-            if force == "below_mu":
-                external_wrench_b[..., 0] = static_friction_coefficient * cube_mass * gravity_magnitude * 0.99
-            else:
-                external_wrench_b[..., 0] = static_friction_coefficient * cube_mass * gravity_magnitude * 1.01
-
-            cube_object.permanent_wrench_composer.set_forces_and_torques_index(
-                forces=external_wrench_b[..., :3],
-                torques=external_wrench_b[..., 3:],
-            )
-
-            # Get root state
-            initial_root_pos = cube_object.data.root_pos_w.torch.clone()
-            # Simulate physics
-            for _ in range(200):
-                # apply the wrench
-                cube_object.write_data_to_sim()
-                sim.step()
-                # update object
-                cube_object.update(sim.cfg.dt)
-                if force == "below_mu":
-                    # Assert that the block has not moved
-                    torch.testing.assert_close(
-                        cube_object.data.root_pos_w.torch, initial_root_pos, rtol=2e-3, atol=2e-3
-                    )
-            if force == "above_mu":
-                assert (cube_object.data.root_pos_w.torch[..., 0] - initial_root_pos[..., 0] > 0.02).all()
-
-
-@pytest.mark.isaacsim_ci
-@pytest.mark.skip(reason="MuJoCo restitution model differs from PhysX — inelastic collisions still bounce")
-@pytest.mark.parametrize("num_cubes", [1, 2])
-@pytest.mark.parametrize("device", test_devices())
-def test_rigid_body_with_restitution(num_cubes, device):
-    """Test that restitution when applied to rigid object works as expected.
-
-    This test works by dropping a block from a height and checking if the block bounces or not based on the
-    restitution value set for the object. We set the restitution to be non-zero and drop the block from a height.
-    When the restitution is 0, the block should not bounce. When the restitution is between 0 and 1, the block
-    should bounce with less energy.
-    """
-    for expected_collision_type in "partially_elastic", "inelastic":
-        with _newton_sim_context(device, add_ground_plane=False, auto_add_lighting=True) as sim:
-            sim._app_control_on_stop_handle = None
-            cube_object, _ = generate_cubes_scene(num_cubes=num_cubes, height=1.0, device=device)
-
-            # Set static friction to be non-zero
-            if expected_collision_type == "inelastic":
-                restitution_coefficient = 0.0
-            elif expected_collision_type == "partially_elastic":
-                restitution_coefficient = 0.5
-
-            # Create ground plane
-            cfg = sim_utils.GroundPlaneCfg(
-                physics_material=materials.RigidBodyMaterialCfg(
-                    restitution=restitution_coefficient,
-                )
-            )
-            cfg.func("/World/GroundPlane", cfg)
-
-            # Play sim
-            sim.reset()
-
-            root_pose = torch.zeros(num_cubes, 7, device=sim.device)
-            root_pose[:, 3] = 1.0  # To make orientation a quaternion
-            for i in range(num_cubes):
-                root_pose[i, 1] = 1.0 * i
-            root_pose[:, 2] = 1.0  # Set an initial drop height
-            root_vel = torch.zeros(num_cubes, 6, device=sim.device)
-            root_vel[:, 2] = -1.0  # Set an initial downward velocity
-
-            cube_object.write_root_pose_to_sim_index(root_pose=root_pose)
-            cube_object.write_root_velocity_to_sim_index(root_velocity=root_vel)
-
-            # Set restitution via view-level API
-            _set_newton_material_properties(
-                cube_object,
-                friction_val=0.0,
-                restitution_val=restitution_coefficient,
-                device=device,
-            )
-
-            curr_z_velocity = cube_object.data.root_lin_vel_w.torch[:, 2].clone()
-
-            for _ in range(100):
-                sim.step()
-
-                # update object
-                cube_object.update(sim.cfg.dt)
-                curr_z_velocity = cube_object.data.root_lin_vel_w.torch[:, 2].clone()
-
-                if expected_collision_type == "inelastic":
-                    # assert that the block has not bounced by checking that the z velocity is less than or equal to 0
-                    assert (curr_z_velocity <= 0.0).all()
-
-                if torch.all(curr_z_velocity <= 0.0):
-                    # Still in the air
-                    prev_z_velocity = curr_z_velocity
-                else:
-                    # collision has happened, exit the for loop
-                    break
-
-            if expected_collision_type == "partially_elastic":
-                # Assert that the block has lost some energy by checking that the z velocity is less
-                assert torch.all(torch.le(abs(curr_z_velocity), abs(prev_z_velocity)))
-                assert (curr_z_velocity > 0.0).all()
-
-
 @pytest.mark.isaacsim_ci
 @pytest.mark.parametrize("num_cubes", [2])
 @pytest.mark.parametrize("device", test_devices())

source/isaaclab_newton/test/assets/test_rigid_object.py

@@ -243,51 +243,11 @@ def test_set_body_inertial_properties_updates_inverses(device):
         torch.testing.assert_close(wp.to_torch(model_inv_mass), updated_inv_mass)
 
 
-@pytest.mark.skip(reason="Newton doesn't support kinematic rigid bodies yet")
-@pytest.mark.parametrize("num_envs", [1, 2])
-@pytest.mark.parametrize("num_cubes", [1, 3])
-@pytest.mark.parametrize("device", test_devices())
-def test_initialization_with_kinematic_enabled(num_envs, num_cubes, device):
-    """Test that initialization for prim with kinematic flag enabled."""
-    with _newton_sim_context(device, auto_add_lighting=True) as sim:
-        sim._app_control_on_stop_handle = None
-        object_collection, origins = generate_cubes_scene(
-            num_envs=num_envs, num_cubes=num_cubes, kinematic_enabled=True, device=device
-        )
-
-        # Check that the framework doesn't hold excessive strong references.
-        assert sys.getrefcount(object_collection) < 10
-
-        # Play sim
-        sim.reset()
-
-        # Check if object is initialized
-        assert object_collection.is_initialized
-        assert len(object_collection.body_names) == num_cubes
-
-        # Check buffers that exist and have correct shapes
-        assert object_collection.data.body_link_pos_w.torch.shape == (num_envs, num_cubes, 3)
-        assert object_collection.data.body_link_quat_w.torch.shape == (num_envs, num_cubes, 4)
-
-        # Simulate physics
-        for _ in range(2):
-            sim.step()
-            object_collection.update(sim.cfg.dt)
-            # check that the object is kinematic
-            default_body_pose = object_collection.data.default_body_pose.torch.clone()
-            default_body_vel = object_collection.data.default_body_vel.torch.clone()
-            default_body_pose[..., :3] += origins.unsqueeze(1)
-            torch.testing.assert_close(object_collection.data.body_link_pose_w.torch, default_body_pose)
-            torch.testing.assert_close(object_collection.data.body_link_vel_w.torch, default_body_vel)
-
-
-@pytest.mark.parametrize("num_cubes", [2])
-@pytest.mark.parametrize("device", test_devices())
-def test_initialization_with_no_rigid_body(num_cubes, device):
+def test_initialization_with_no_rigid_body():
     """Test that initialization fails when no rigid body is found at the provided prim path."""
-    with _newton_sim_context(device, auto_add_lighting=True) as sim:
+    with _newton_sim_context("cpu", auto_add_lighting=True) as sim:
         sim._app_control_on_stop_handle = None
-        object_collection, _ = generate_cubes_scene(num_cubes=num_cubes, has_api=False, device=device)
+        object_collection, _ = generate_cubes_scene(num_cubes=2, has_api=False, device="cpu")
 
         # Check that the framework doesn't hold excessive strong references.
         assert sys.getrefcount(object_collection) < 10