warp-lang 1.6.2__py3-none-macosx_10_13_universal2.whl → 1.7.1__py3-none-macosx_10_13_universal2.whl

warp/tests/sim/test_xpbd.py

@@ -0,0 +1,399 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from warp.sim.model import PARTICLE_FLAG_ACTIVE
+from warp.tests.unittest_utils import *
+
+# fmt: off
+CLOTH_POINTS = [
+    (-50.0000000, 0.0000000, -50.0000000),
+    (-38.8888893, 11.1111107, -50.0000000),
+    (-27.7777786, 22.2222214, -50.0000000),
+    (-16.6666679, 33.3333321, -50.0000000),
+    (-5.5555558, 44.4444427, -50.0000000),
+    (5.5555558, 55.5555573, -50.0000000),
+    (16.6666679, 66.6666641, -50.0000000),
+    (27.7777786, 77.7777786, -50.0000000),
+    (38.8888893, 88.8888855, -50.0000000),
+    (50.0000000, 100.0000000, -50.0000000),
+    (-50.0000000, 0.0000000, -38.8888893),
+    (-38.8888893, 11.1111107, -38.8888893),
+    (-27.7777786, 22.2222214, -38.8888893),
+    (-16.6666679, 33.3333321, -38.8888893),
+    (-5.5555558, 44.4444427, -38.8888893),
+    (5.5555558, 55.5555573, -38.8888893),
+    (16.6666679, 66.6666641, -38.8888893),
+    (27.7777786, 77.7777786, -38.8888893),
+    (38.8888893, 88.8888855, -38.8888893),
+    (50.0000000, 100.0000000, -38.8888893),
+    (-50.0000000, 0.0000000, -27.7777786),
+    (-38.8888893, 11.1111107, -27.7777786),
+    (-27.7777786, 22.2222214, -27.7777786),
+    (-16.6666679, 33.3333321, -27.7777786),
+    (-5.5555558, 44.4444427, -27.7777786),
+    (5.5555558, 55.5555573, -27.7777786),
+    (16.6666679, 66.6666641, -27.7777786),
+    (27.7777786, 77.7777786, -27.7777786),
+    (38.8888893, 88.8888855, -27.7777786),
+    (50.0000000, 100.0000000, -27.7777786),
+    (-50.0000000, 0.0000000, -16.6666679),
+    (-38.8888893, 11.1111107, -16.6666679),
+    (-27.7777786, 22.2222214, -16.6666679),
+    (-16.6666679, 33.3333321, -16.6666679),
+    (-5.5555558, 44.4444427, -16.6666679),
+    (5.5555558, 55.5555573, -16.6666679),
+    (16.6666679, 66.6666641, -16.6666679),
+    (27.7777786, 77.7777786, -16.6666679),
+    (38.8888893, 88.8888855, -16.6666679),
+    (50.0000000, 100.0000000, -16.6666679),
+    (-50.0000000, 0.0000000, -5.5555558),
+    (-38.8888893, 11.1111107, -5.5555558),
+    (-27.7777786, 22.2222214, -5.5555558),
+    (-16.6666679, 33.3333321, -5.5555558),
+    (-5.5555558, 44.4444427, -5.5555558),
+    (5.5555558, 55.5555573, -5.5555558),
+    (16.6666679, 66.6666641, -5.5555558),
+    (27.7777786, 77.7777786, -5.5555558),
+    (38.8888893, 88.8888855, -5.5555558),
+    (50.0000000, 100.0000000, -5.5555558),
+    (-50.0000000, 0.0000000, 5.5555558),
+    (-38.8888893, 11.1111107, 5.5555558),
+    (-27.7777786, 22.2222214, 5.5555558),
+    (-16.6666679, 33.3333321, 5.5555558),
+    (-5.5555558, 44.4444427, 5.5555558),
+    (5.5555558, 55.5555573, 5.5555558),
+    (16.6666679, 66.6666641, 5.5555558),
+    (27.7777786, 77.7777786, 5.5555558),
+    (38.8888893, 88.8888855, 5.5555558),
+    (50.0000000, 100.0000000, 5.5555558),
+    (-50.0000000, 0.0000000, 16.6666679),
+    (-38.8888893, 11.1111107, 16.6666679),
+    (-27.7777786, 22.2222214, 16.6666679),
+    (-16.6666679, 33.3333321, 16.6666679),
+    (-5.5555558, 44.4444427, 16.6666679),
+    (5.5555558, 55.5555573, 16.6666679),
+    (16.6666679, 66.6666641, 16.6666679),
+    (27.7777786, 77.7777786, 16.6666679),
+    (38.8888893, 88.8888855, 16.6666679),
+    (50.0000000, 100.0000000, 16.6666679),
+    (-50.0000000, 0.0000000, 27.7777786),
+    (-38.8888893, 11.1111107, 27.7777786),
+    (-27.7777786, 22.2222214, 27.7777786),
+    (-16.6666679, 33.3333321, 27.7777786),
+    (-5.5555558, 44.4444427, 27.7777786),
+    (5.5555558, 55.5555573, 27.7777786),
+    (16.6666679, 66.6666641, 27.7777786),
+    (27.7777786, 77.7777786, 27.7777786),
+    (38.8888893, 88.8888855, 27.7777786),
+    (50.0000000, 100.0000000, 27.7777786),
+    (-50.0000000, 0.0000000, 38.8888893),
+    (-38.8888893, 11.1111107, 38.8888893),
+    (-27.7777786, 22.2222214, 38.8888893),
+    (-16.6666679, 33.3333321, 38.8888893),
+    (-5.5555558, 44.4444427, 38.8888893),
+    (5.5555558, 55.5555573, 38.8888893),
+    (16.6666679, 66.6666641, 38.8888893),
+    (27.7777786, 77.7777786, 38.8888893),
+    (38.8888893, 88.8888855, 38.8888893),
+    (50.0000000, 100.0000000, 38.8888893),
+    (-50.0000000, 0.0000000, 50.0000000),
+    (-38.8888893, 11.1111107, 50.0000000),
+    (-27.7777786, 22.2222214, 50.0000000),
+    (-16.6666679, 33.3333321, 50.0000000),
+    (-5.5555558, 44.4444427, 50.0000000),
+    (5.5555558, 55.5555573, 50.0000000),
+    (16.6666679, 66.6666641, 50.0000000),
+    (27.7777786, 77.7777786, 50.0000000),
+    (38.8888893, 88.8888855, 50.0000000),
+    (50.0000000, 100.0000000, 50.0000000),
+]
+
+CLOTH_FACES = [
+    1, 12, 2,
+    1, 11, 12,
+    2, 12, 3,
+    12, 13, 3,
+    3, 14, 4,
+    3, 13, 14,
+    4, 14, 5,
+    14, 15, 5,
+    5, 16, 6,
+    5, 15, 16,
+    6, 16, 7,
+    16, 17, 7,
+    7, 18, 8,
+    7, 17, 18,
+    8, 18, 9,
+    18, 19, 9,
+    9, 20, 10,
+    9, 19, 20,
+    11, 21, 12,
+    21, 22, 12,
+    12, 23, 13,
+    12, 22, 23,
+    13, 23, 14,
+    23, 24, 14,
+    14, 25, 15,
+    14, 24, 25,
+    15, 25, 16,
+    25, 26, 16,
+    16, 27, 17,
+    16, 26, 27,
+    17, 27, 18,
+    27, 28, 18,
+    18, 29, 19,
+    18, 28, 29,
+    19, 29, 20,
+    29, 30, 20,
+    21, 32, 22,
+    21, 31, 32,
+    22, 32, 23,
+    32, 33, 23,
+    23, 34, 24,
+    23, 33, 34,
+    24, 34, 25,
+    34, 35, 25,
+    25, 36, 26,
+    25, 35, 36,
+    26, 36, 27,
+    36, 37, 27,
+    27, 38, 28,
+    27, 37, 38,
+    28, 38, 29,
+    38, 39, 29,
+    29, 40, 30,
+    29, 39, 40,
+    31, 41, 32,
+    41, 42, 32,
+    32, 43, 33,
+    32, 42, 43,
+    33, 43, 34,
+    43, 44, 34,
+    34, 45, 35,
+    34, 44, 45,
+    35, 45, 36,
+    45, 46, 36,
+    36, 47, 37,
+    36, 46, 47,
+    37, 47, 38,
+    47, 48, 38,
+    38, 49, 39,
+    38, 48, 49,
+    39, 49, 40,
+    49, 50, 40,
+    41, 52, 42,
+    41, 51, 52,
+    42, 52, 43,
+    52, 53, 43,
+    43, 54, 44,
+    43, 53, 54,
+    44, 54, 45,
+    54, 55, 45,
+    45, 56, 46,
+    45, 55, 56,
+    46, 56, 47,
+    56, 57, 47,
+    47, 58, 48,
+    47, 57, 58,
+    48, 58, 49,
+    58, 59, 49,
+    49, 60, 50,
+    49, 59, 60,
+    51, 61, 52,
+    61, 62, 52,
+    52, 63, 53,
+    52, 62, 63,
+    53, 63, 54,
+    63, 64, 54,
+    54, 65, 55,
+    54, 64, 65,
+    55, 65, 56,
+    65, 66, 56,
+    56, 67, 57,
+    56, 66, 67,
+    57, 67, 58,
+    67, 68, 58,
+    58, 69, 59,
+    58, 68, 69,
+    59, 69, 60,
+    69, 70, 60,
+    61, 72, 62,
+    61, 71, 72,
+    62, 72, 63,
+    72, 73, 63,
+    63, 74, 64,
+    63, 73, 74,
+    64, 74, 65,
+    74, 75, 65,
+    65, 76, 66,
+    65, 75, 76,
+    66, 76, 67,
+    76, 77, 67,
+    67, 78, 68,
+    67, 77, 78,
+    68, 78, 69,
+    78, 79, 69,
+    69, 80, 70,
+    69, 79, 80,
+    71, 81, 72,
+    81, 82, 72,
+    72, 83, 73,
+    72, 82, 83,
+    73, 83, 74,
+    83, 84, 74,
+    74, 85, 75,
+    74, 84, 85,
+    75, 85, 76,
+    85, 86, 76,
+    76, 87, 77,
+    76, 86, 87,
+    77, 87, 78,
+    87, 88, 78,
+    78, 89, 79,
+    78, 88, 89,
+    79, 89, 80,
+    89, 90, 80,
+    81, 92, 82,
+    81, 91, 92,
+    82, 92, 83,
+    92, 93, 83,
+    83, 94, 84,
+    83, 93, 94,
+    84, 94, 85,
+    94, 95, 85,
+    85, 96, 86,
+    85, 95, 96,
+    86, 96, 87,
+    96, 97, 87,
+    87, 98, 88,
+    87, 97, 98,
+    88, 98, 89,
+    98, 99, 89,
+    89, 100, 90,
+    89, 99, 100
+]
+
+# fmt: on
+class XPBDClothSim:
+    def __init__(self, device, use_cuda_graph=False):
+        self.frame_dt = 1 / 60
+        self.num_test_frames = 100
+        self.num_substeps = 20
+        self.iterations = 2
+        self.dt = self.frame_dt / self.num_substeps
+        self.device = device
+        self.use_cuda_graph = self.device.is_cuda and use_cuda_graph
+        self.builder = wp.sim.ModelBuilder()
+
+    def set_free_falling_experiment(self):
+        self.input_scale_factor = 1.0
+        self.renderer_scale_factor = 0.01
+        vertices = [wp.vec3(v) * self.input_scale_factor for v in CLOTH_POINTS]
+        faces_flatten = [fv - 1 for fv in CLOTH_FACES]
+
+        self.builder.add_cloth_mesh(
+            vertices=vertices,
+            indices=faces_flatten,
+            scale=0.05,
+            density=10,
+            pos=wp.vec3(0.0, 4.0, 0.0),
+            rot=wp.quat_identity(),
+            vel=wp.vec3(0.0, 0.0, 0.0),
+            edge_ke=1.0e2,
+            add_springs=True,
+            spring_ke=1.0e3,
+            spring_kd=0.0,
+        )
+        self.fixed_particles = []
+        self.num_test_frames = 30
+
+    def finalize(self, ground=True):
+        self.model = self.builder.finalize(device=self.device)
+        self.model.ground = ground
+        self.model.gravity = wp.vec3(0, -10.0, 0)
+        self.model.soft_contact_ke = 1.0e4
+        self.model.soft_contact_kd = 1.0e2
+
+        self.set_points_fixed(self.model, self.fixed_particles)
+
+        self.integrator = wp.sim.XPBDIntegrator(self.iterations)
+        self.state0 = self.model.state()
+        self.state1 = self.model.state()
+
+        self.init_pos = np.array(self.state0.particle_q.numpy(), copy=True)
+
+        self.graph = None
+        if self.use_cuda_graph:
+            with wp.ScopedCapture(device=self.device, force_module_load=False) as capture:
+                self.simulate()
+            self.graph = capture.graph
+
+    def simulate(self):
+        for _step in range(self.num_substeps * self.num_test_frames):
+            self.integrator.simulate(self.model, self.state0, self.state1, self.dt, None)
+            (self.state0, self.state1) = (self.state1, self.state0)
+
+    def run(self):
+        if self.graph:
+            wp.capture_launch(self.graph)
+        else:
+            self.simulate()
+
+    def set_points_fixed(self, model, fixed_particles):
+        if len(fixed_particles):
+            flags = model.particle_flags.numpy()
+            for fixed_v_id in fixed_particles:
+                flags[fixed_v_id] = wp.uint32(int(flags[fixed_v_id]) & ~int(PARTICLE_FLAG_ACTIVE))
+
+            model.particle_flags = wp.array(flags, device=model.device)
+
+
+def test_xpbd_free_falling(test, device):
+    example = XPBDClothSim(device)
+    example.set_free_falling_experiment()
+    example.finalize(ground=False)
+    initial_pos = example.state0.particle_q.numpy().copy()
+
+    example.run()
+
+    # examine that the simulation does not explode
+    final_pos = example.state0.particle_q.numpy()
+    test.assertTrue((final_pos < 1e5).all())
+    # examine that the simulation have moved
+    test.assertTrue((example.init_pos != final_pos).any())
+
+    gravity = np.array(example.model.gravity)
+    diff = final_pos - initial_pos
+    vertical_translation_norm = diff @ gravity[..., None] / (np.linalg.norm(gravity) ** 2)
+    # ensure it's free-falling
+    test.assertTrue((np.abs(vertical_translation_norm - 0.5 * np.linalg.norm(gravity) * (example.dt**2)) < 2e-1).all())
+    horizontal_move = diff - (vertical_translation_norm * gravity)
+    # ensure its horizontal translation is minimal
+    test.assertTrue((np.abs(horizontal_move) < 1e-1).all())
+
+
+devices = get_test_devices(mode="basic")
+
+
+class TestXPBD(unittest.TestCase):
+    pass
+
+
+add_function_test(TestXPBD, "test_xpbd_free_falling", test_xpbd_free_falling, devices=devices)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

warp/tests/test_bool.py

@@ -58,7 +58,7 @@ def identity_test(data: wp.array(dtype=wp.bool)):
     else:
         data[i] = False
 
-    data[i] = wp.select(data[i], False, True)
+    data[i] = wp.where(data[i], True, False)
 
 
 def test_bool_identity_ops(test, device):

warp/tests/test_codegen.py

@@ -482,7 +482,7 @@ def test_error_unmatched_arguments(test, device):
     kernel = wp.Kernel(func=kernel_2_fn)
     with test.assertRaisesRegex(
         RuntimeError,
-        r"Input types must be exactly the same, got \[\"vector\(length=2, dtype=<class 'warp.types.float32'>\)\", \"vector\(length=2, dtype=<class 'warp.types.float16'>\)\"\]",
+        r"Input types must be exactly the same, got \['vec2f', 'vector\(length=2, dtype=float16\)'\]",
     ):
         wp.launch(kernel, dim=1, device=device)
 
@@ -672,6 +672,27 @@ def test_while_condition_eval():
         it.valid = False
 
 
+@wp.kernel
+def conditional_return_or_sum(result: wp.array(dtype=wp.int32)):
+    tid = wp.tid()
+
+    if tid < 256:
+        return
+
+    wp.atomic_add(result, 0, 1)
+
+
+def test_codegen_return_in_kernel(test, device):
+    result = wp.zeros(1, dtype=wp.int32, device=device)
+
+    grid_size = 1024
+
+    # On CUDA devices, this becomes a grid-stride loop
+    wp.launch(conditional_return_or_sum, dim=grid_size, inputs=[result], block_dim=256, max_blocks=1, device=device)
+
+    test.assertEqual(result.numpy()[0], grid_size - 256)
+
+
 class TestCodeGen(unittest.TestCase):
     pass
 
@@ -803,8 +824,8 @@ add_function_test(
 add_kernel_test(TestCodeGen, name="test_call_syntax", kernel=test_call_syntax, dim=1, devices=devices)
 add_kernel_test(TestCodeGen, name="test_shadow_builtin", kernel=test_shadow_builtin, dim=1, devices=devices)
 add_kernel_test(TestCodeGen, name="test_while_condition_eval", kernel=test_while_condition_eval, dim=1, devices=devices)
-
+add_function_test(TestCodeGen, "test_codegen_return_in_kernel", test_codegen_return_in_kernel, devices=devices)
 
 if __name__ == "__main__":
     wp.clear_kernel_cache()
-    unittest.main(verbosity=2, failfast=True)
+    unittest.main(verbosity=2)

warp/tests/test_examples.py

@@ -25,18 +25,18 @@ Generally the test_options[_cpu,_cuda] dictionaries should be used to prevent
 graphical windows from being open by the example {"headless": True} and to
 override example defaults so the example can run in less than ten seconds.
 
-Use {"usd_required": True} and {"torch_required": True} to skip running the test
-if usd-core or torch are not found in the Python environment.
-
-Use "cutlass_required": True} to skip the test if Warp needs to be built with
-CUTLASS.
+To skip tests if the optional dependencies are not found, use the following keys:
+- {"usd_required": True} (requires usd-core)
+- {"torch_required": True} (requires torch)
+- {"pillow_required": True} (requires pillow)
 
 Use the "num_frames" and "train_iters" keys to control the number of steps.
 
-Use "test_timeout" to override the default test timeout threshold of 300 seconds.
+Use "test_timeout" to override the default test timeout threshold of 600 seconds.
 """
 
 import os
+import platform
 import subprocess
 import sys
 import unittest
@@ -52,7 +52,7 @@ from warp.tests.unittest_utils import (
 )
 from warp.utils import check_p2p
 
-wp.init()  # For wp.context.runtime.core.is_cutlass_enabled()
+wp.init()  # For wp.context.runtime.core.is_debug_enabled()
 
 
 def _build_command_line_options(test_options: Dict[str, Any]) -> list:
@@ -119,9 +119,13 @@ def add_example_test(
         if usd_required and not USD_AVAILABLE:
             test.skipTest("Requires usd-core")
 
-        cutlass_required = options.pop("cutlass_required", False)
-        if cutlass_required and not wp.context.runtime.core.is_cutlass_enabled():
-            test.skipTest("Warp was not built with CUTLASS support")
+        # Mark the test as skipped if pillow is not installed but required
+        pillow_required = options.pop("pillow_required", False)
+        if pillow_required:
+            try:
+                import PIL  # noqa: F401
+            except ImportError:
+                test.skipTest("Requires pillow")
 
         # Find the current Warp cache
         warp_cache_path = wp.config.kernel_cache_dir
@@ -169,7 +173,7 @@ def add_example_test(
         command.extend(_build_command_line_options(options))
 
         # Set the test timeout in seconds
-        test_timeout = options.pop("test_timeout", 300)
+        test_timeout = options.pop("test_timeout", 600)
 
         # with wp.ScopedTimer(f"{name}_{sanitize_identifier(device)}"):
         # Run the script as a subprocess
@@ -236,25 +240,38 @@ add_example_test(
     devices=test_devices,
     test_options={"usd_required": True, "headless": True},
 )
+if platform.system() == "Windows":
+    # Skip GPU testing because of obscure NVRTC bug with illegal memory access
+    add_example_test(
+        TestCoreExamples,
+        name="core.example_raymarch",
+        devices=[wp.get_device("cpu")],
+        test_options={"height": 512, "width": 1024, "headless": True},
+    )
+else:
+    add_example_test(
+        TestCoreExamples,
+        name="core.example_raymarch",
+        devices=test_devices,
+        test_options={"height": 512, "width": 1024, "headless": True},
+    )
 add_example_test(
     TestCoreExamples,
-    name="core.example_raymarch",
+    name="core.example_sample_mesh",
     devices=test_devices,
-    test_options={"height": 512, "width": 1024, "headless": True},
+    test_options_cpu={"num_frames": 1},
 )
 add_example_test(
     TestCoreExamples,
     name="core.example_sph",
     devices=test_devices,
     test_options_cpu={"num_frames": 1},
-    test_options_cuda={"test_timeout": 600},
 )
 add_example_test(
     TestCoreExamples,
     name="core.example_torch",
     devices=test_devices,
     test_options={"headless": True, "num_frames": 1000, "torch_required": True},
-    test_options_cpu={"test_timeout": 600},
 )
 add_example_test(TestCoreExamples, name="core.example_wave", devices=test_devices)
 
@@ -268,7 +285,6 @@ add_example_test(
     name="optim.example_bounce",
     devices=test_devices,
     test_options_cpu={"train_iters": 3},
-    test_options_cuda={"test_timeout": 600},
 )
 add_example_test(
     TestOptimExamples,
@@ -281,7 +297,6 @@ add_example_test(
     TestOptimExamples,
     name="optim.example_cloth_throw",
     devices=test_devices,
-    test_options={"test_timeout": 600},
     test_options_cpu={"train_iters": 3},
 )
 add_example_test(
@@ -291,6 +306,12 @@ add_example_test(
     test_options={"usd_required": True, "headless": True},
     test_options_cpu={"train_iters": 2},
 )
+add_example_test(
+    TestOptimExamples,
+    name="optim.example_fluid_checkpoint",
+    devices=cuda_test_devices,
+    test_options={"headless": True, "train_iters": 5, "num_frames": 300, "pillow_required": True},
+)
 add_example_test(TestOptimExamples, name="optim.example_inverse_kinematics", devices=test_devices)
 add_example_test(
     TestOptimExamples,
@@ -305,19 +326,6 @@ add_example_test(
     devices=test_devices,
     test_options={"headless": True, "train_iters": 50},
 )
-# NOTE: This example uses CUTLASS and will run orders of magnitude slower when Warp is built in debug mode
-add_example_test(
-    TestOptimExamples,
-    name="optim.example_walker",
-    devices=test_devices,
-    test_options={"usd_required": True},
-    test_options_cuda={
-        "train_iters": 1 if warp.context.runtime.core.is_debug_enabled() else 3,
-        "num_frames": 1 if warp.context.runtime.core.is_debug_enabled() else 60,
-        "cutlass_required": True,
-    },
-    test_options_cpu={"train_iters": 1, "num_frames": 30},
-)
 add_example_test(
     TestOptimExamples,
     name="optim.example_softbody_properties",
@@ -333,15 +341,13 @@ class TestSimExamples(unittest.TestCase):
     pass
 
 
-add_example_test(
-    TestSimExamples, name="sim.example_cartpole", devices=test_devices, test_options_cuda={"test_timeout": 600}
-)
+add_example_test(TestSimExamples, name="sim.example_cartpole", devices=test_devices)
 add_example_test(
     TestSimExamples,
     name="sim.example_cloth",
     devices=test_devices,
     test_options={"usd_required": True},
-    test_options_cpu={"num_frames": 10, "test_timeout": 600},
+    test_options_cpu={"num_frames": 10},
 )
 add_example_test(
     TestSimExamples, name="sim.example_granular", devices=test_devices, test_options_cpu={"num_frames": 10}
@@ -421,28 +427,24 @@ add_example_test(
     name="fem.example_convection_diffusion",
     devices=test_devices,
     test_options={"resolution": 20, "headless": True},
-    test_options_cpu={"test_timeout": 600},
 )
 add_example_test(
     TestFemExamples,
     name="fem.example_burgers",
     devices=test_devices,
     test_options={"resolution": 20, "num_frames": 25, "degree": 1, "headless": True},
-    test_options_cpu={"test_timeout": 600},
 )
 add_example_test(
     TestFemExamples,
     name="fem.example_convection_diffusion_dg",
     devices=test_devices,
     test_options={"resolution": 20, "num_frames": 25, "headless": True},
-    test_options_cpu={"test_timeout": 600},
 )
 add_example_test(
     TestFemExamples,
     name="fem.example_mixed_elasticity",
     devices=test_devices,
     test_options={"nonconforming_stresses": True, "mesh": "quad", "headless": True},
-    test_options_cpu={"test_timeout": 600},
 )
 add_example_test(
     TestFemExamples, name="fem.example_stokes_transfer", devices=test_devices, test_options={"headless": True}