warp-lang 1.0.2__py3-none-win_amd64.whl → 1.2.0__py3-none-win_amd64.whl

warp/tests/test_examples.py

@@ -1,378 +1,403 @@
-# Copyright (c) 2023 NVIDIA CORPORATION.  All rights reserved.
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-import importlib
-import os
-import unittest
-
-import warp as wp
-from warp.tests.unittest_utils import (
-    USD_AVAILABLE,
-    get_test_devices,
-    get_unique_cuda_test_devices,
-    sanitize_identifier,
-)
-
-wp.init()
-
-
-# registers an example to run as a TestCase
-def add_example_test(cls, name, devices=None, options={}):
-    def run(test, device):
-        # The copy() is needed because pop() is used to avoid passing extra args to Example()
-        # Can remove once all examples accept **kwargs and we no longer need to pop()
-        test_options = options.copy()
-
-        try:
-            module = importlib.import_module(f"warp.examples.{name}")
-
-            torch_cuda_required = test_options.setdefault("torch_cuda_required", False)
-            test_options.pop("torch_cuda_required", None)
-            if torch_cuda_required and wp.get_device(device).is_cuda:
-                # Ensure torch has CUDA support
-                import torch
-
-                if not torch.cuda.is_available():
-                    test.skipTest("Torch not compiled with CUDA support")
-
-        except Exception as e:
-            test.skipTest(f"{e}")
-
-        # create default USD stage output path which many examples expect
-        test_options.setdefault(
-            "stage",
-            (
-                os.path.join(os.path.dirname(__file__), f"outputs/{name}_{sanitize_identifier(device)}.usd")
-                if USD_AVAILABLE
-                else None
-            ),
-        )
-
-        if test_options["stage"]:
-            try:
-                os.remove(test_options["stage"])
-            except OSError:
-                pass
-
-        num_frames = test_options.get("num_frames", 10)
-        test_options.pop("num_frames", None)
-
-        # Don't want to force load all modules by default for serial test runner
-        wp.config.enable_graph_capture_module_load_by_default = False
-
-        with wp.ScopedTimer(f"{name}_{sanitize_identifier(device)}"):
-            try:
-                enable_backward = test_options.get("enable_backward", True)
-                wp.set_module_options({"enable_backward": enable_backward}, module)
-                test_options.pop("enable_backward", None)
-
-                with wp.ScopedDevice(device):
-                    wp.load_module(module, device=wp.get_device())
-                    extra_load_modules = test_options.get("load_modules", [])
-                    for module_name in extra_load_modules:
-                        wp.load_module(module_name, device=wp.get_device())
-                    test_options.pop("load_modules", None)
-
-                    e = module.Example(**test_options)
-
-                    # disable scoped timer to avoid log spam from time steps
-                    wp.ScopedTimer.enabled = False
-
-                    for _ in range(num_frames):
-                        e.step()
-                        e.render()
-            except Exception as e:
-                test.fail(f"{e}")
-            finally:
-                wp.ScopedTimer.enabled = True
-                wp.config.enable_graph_capture_module_load_by_default = True
-
-    from warp.tests.unittest_utils import add_function_test
-
-    add_function_test(cls, f"test_{name}", run, devices=devices, check_output=False)
-
-
-# TODO: Make the example classes use the passed in device
-cuda_test_devices = get_unique_cuda_test_devices()
-test_devices = get_test_devices()
-
-# NOTE: To give the parallel test runner more opportunities to parallelize test cases,
-# we break up the tests into multiple TestCase classes that should be non-conflicting
-# w.r.t. kernel compilation
-
-
-class TestExamples(unittest.TestCase):
-    pass
-
-
-# Exclude unless we can run headless somehow
-# add_example_test(TestExamples, name="example_render_opengl", options={})
-
-add_example_test(TestExamples, name="core.example_dem", devices=cuda_test_devices)
-add_example_test(TestExamples, name="core.example_fluid", devices=cuda_test_devices)
-add_example_test(TestExamples, name="core.example_marching_cubes", devices=cuda_test_devices)
-add_example_test(TestExamples, name="core.example_mesh", devices=cuda_test_devices)
-add_example_test(TestExamples, name="core.example_mesh_intersect", devices=cuda_test_devices, options={"num_frames": 1})
-add_example_test(TestExamples, name="core.example_nvdb", devices=cuda_test_devices)
-add_example_test(TestExamples, name="core.example_raycast", devices=cuda_test_devices)
-add_example_test(TestExamples, name="core.example_raymarch", devices=cuda_test_devices)
-add_example_test(TestExamples, name="core.example_sph", devices=cuda_test_devices)
-add_example_test(TestExamples, name="core.example_wave", devices=cuda_test_devices)
-
-
-class TestSimExamples(unittest.TestCase):
-    pass
-
-
-warp_sim_modules = [
-    "warp.sim.integrator",
-    "warp.sim.integrator_euler",
-    "warp.sim.particles",
-    "warp.sim.collide",
-    "warp.sim.articulation",
-    "warp.sim.integrator_xpbd",
-    "warp.sim.integrator_featherstone",
-    "warp.sim.integrator_euler",
-    "warp.sim.integrator",
-    "warp.sim.utils",
-]
-
-add_example_test(
-    TestSimExamples,
-    name="optim.example_bounce",
-    devices=cuda_test_devices,
-    options={"load_modules": warp_sim_modules},
-)
-add_example_test(
-    TestSimExamples,
-    name="sim.example_cartpole",
-    devices=cuda_test_devices,
-    options={"load_modules": warp_sim_modules},
-)
-add_example_test(
-    TestSimExamples,
-    name="sim.example_cloth",
-    devices=cuda_test_devices,
-    options={"load_modules": warp_sim_modules},
-)
-add_example_test(
-    TestSimExamples,
-    name="optim.example_cloth_throw",
-    devices=cuda_test_devices,
-    options={"load_modules": warp_sim_modules},
-)
-add_example_test(TestSimExamples, name="optim.example_diffray", devices=cuda_test_devices)
-add_example_test(
-    TestSimExamples,
-    name="optim.example_drone",
-    devices=cuda_test_devices,
-    options={
-        "load_modules": warp_sim_modules + ["warp.optim.sgd"],
-        "num_frames": 1,
-        "drone_path": os.path.join(os.path.dirname(__file__), "..", "examples", "assets", "crazyflie.usd"),
-    },
-)
-# add_example_test(
-#     TestSimExamples,
-#     name="optim.example_walker",
-#     devices=cuda_test_devices,
-#     options={
-#         "load_modules": warp_sim_modules + ["warp.optim.adam", "warp.utils"],
-#         "num_frames": 1,
-#     },
-# )
-add_example_test(
-    TestSimExamples,
-    name="sim.example_granular",
-    devices=cuda_test_devices,
-    options={
-        "load_modules": warp_sim_modules,
-    },
-)
-add_example_test(
-    TestSimExamples,
-    name="sim.example_granular_collision_sdf",
-    devices=cuda_test_devices,
-    options={
-        "load_modules": warp_sim_modules,
-    },
-)
-add_example_test(
-    TestSimExamples,
-    name="optim.example_inverse_kinematics",
-    devices=cuda_test_devices,
-    options={
-        "load_modules": warp_sim_modules,
-    },
-)
-add_example_test(
-    TestSimExamples,
-    name="optim.example_inverse_kinematics_torch",
-    devices=cuda_test_devices,
-    options={
-        "torch_cuda_required": True,
-        "load_modules": warp_sim_modules,
-    },
-)
-add_example_test(TestExamples, name="sim.example_jacobian_ik", devices=cuda_test_devices)
-add_example_test(
-    TestSimExamples,
-    name="sim.example_particle_chain",
-    devices=cuda_test_devices,
-    options={"load_modules": warp_sim_modules},
-)
-add_example_test(
-    TestSimExamples,
-    name="sim.example_quadruped",
-    devices=cuda_test_devices,
-    options={"load_modules": warp_sim_modules},
-)
-add_example_test(
-    TestSimExamples,
-    name="sim.example_rigid_chain",
-    devices=cuda_test_devices,
-    options={"load_modules": warp_sim_modules},
-)
-add_example_test(
-    TestSimExamples,
-    name="sim.example_rigid_contact",
-    devices=cuda_test_devices,
-    options={"load_modules": warp_sim_modules},
-)
-add_example_test(
-    TestSimExamples,
-    name="sim.example_rigid_soft_contact",
-    devices=cuda_test_devices,
-    options={"load_modules": warp_sim_modules},
-)
-add_example_test(
-    TestSimExamples,
-    name="sim.example_rigid_force",
-    devices=cuda_test_devices,
-    options={"load_modules": warp_sim_modules},
-)
-add_example_test(
-    TestSimExamples,
-    name="sim.example_rigid_gyroscopic",
-    devices=cuda_test_devices,
-    options={"load_modules": warp_sim_modules},
-)
-add_example_test(
-    TestSimExamples,
-    name="sim.example_soft_body",
-    devices=cuda_test_devices,
-    options={"load_modules": warp_sim_modules},
-)
-add_example_test(
-    TestSimExamples,
-    name="optim.example_spring_cage",
-    devices=cuda_test_devices,
-    options={"load_modules": warp_sim_modules},
-)
-add_example_test(
-    TestSimExamples,
-    name="optim.example_trajectory",
-    devices=cuda_test_devices,
-    options={"load_modules": warp_sim_modules},
-)
-
-
-class TestFemExamples(unittest.TestCase):
-    pass
-
-
-class TestFemDiffusionExamples(unittest.TestCase):
-    pass
-
-
-add_example_test(
-    TestFemDiffusionExamples,
-    name="fem.example_diffusion_mgpu",
-    devices=cuda_test_devices,
-    options={"quiet": True, "num_frames": 1, "enable_backward": False},
-)
-
-# The following examples do not need CUDA
-add_example_test(
-    TestFemExamples,
-    name="fem.example_apic_fluid",
-    devices=test_devices,
-    options={"quiet": True, "res": [16, 16, 16], "enable_backward": False},
-)
-add_example_test(
-    TestFemDiffusionExamples,
-    name="fem.example_diffusion",
-    devices=test_devices,
-    options={"quiet": True, "resolution": 10, "mesh": "tri", "num_frames": 1, "enable_backward": False},
-)
-add_example_test(
-    TestFemDiffusionExamples,
-    name="fem.example_diffusion_3d",
-    devices=test_devices,
-    options={"quiet": True, "resolution": 10, "num_frames": 1, "enable_backward": False},
-)
-add_example_test(
-    TestFemExamples,
-    name="fem.example_deformed_geometry",
-    devices=test_devices,
-    options={"quiet": True, "resolution": 10, "num_frames": 1, "mesh": "tri", "enable_backward": False},
-)
-add_example_test(
-    TestFemExamples,
-    name="fem.example_convection_diffusion",
-    devices=test_devices,
-    options={"quiet": True, "resolution": 20, "enable_backward": False},
-)
-add_example_test(
-    TestFemExamples,
-    name="fem.example_convection_diffusion_dg0",
-    devices=test_devices,
-    options={"quiet": True, "resolution": 20, "num_frames": 25, "mesh": "quad", "enable_backward": False},
-)
-add_example_test(
-    TestFemExamples,
-    name="fem.example_convection_diffusion_dg",
-    devices=test_devices,
-    options={"quiet": True, "resolution": 20, "num_frames": 25, "mesh": "tri", "enable_backward": False},
-)
-add_example_test(
-    TestFemExamples,
-    name="fem.example_mixed_elasticity",
-    devices=test_devices,
-    options={"quiet": True, "nonconforming_stresses": True, "mesh": "quad", "num_frames": 1, "enable_backward": False},
-)
-add_example_test(
-    TestFemExamples,
-    name="fem.example_stokes_transfer",
-    devices=test_devices,
-    options={"quiet": True, "num_frames": 1, "enable_backward": False},
-)
-add_example_test(
-    TestFemExamples,
-    name="fem.example_stokes",
-    devices=test_devices,
-    options={
-        "quiet": True,
-        "num_frames": 1,
-        "resolution": 10,
-        "nonconforming_pressures": True,
-        "enable_backward": False,
-    },
-)
-add_example_test(
-    TestFemExamples,
-    name="fem.example_navier_stokes",
-    devices=test_devices,
-    options={"quiet": True, "num_frames": 100, "resolution": 10, "tri_mesh": True, "enable_backward": False},
-)
-
-
-if __name__ == "__main__":
-    # force rebuild of all kernels
-    wp.build.clear_kernel_cache()
-
-    unittest.main(verbosity=2, failfast=True)
+# Copyright (c) 2023 NVIDIA CORPORATION.  All rights reserved.
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+"""Test Warp examples with unittest.
+
+This module tests the Warp examples registered in it using the unittest
+framework. When registering tests with add_example_test(), three optional
+dictionaries can be provided: test_options, test_options_cuda, and
+test_options_cpu. These are added to the command line arguments in-order, so
+if a parameter is specified in both test_options and test_options_cuda, the
+one in test_options_cuda will take precedence due to how argparse works.
+
+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 the "num_frames" and "train_iters" keys to control the number of steps.
+"""
+
+import os
+import subprocess
+import sys
+import unittest
+from typing import Any, Dict, Optional, Type
+
+import warp as wp
+import warp.tests.unittest_utils
+from warp.tests.unittest_utils import (
+    USD_AVAILABLE,
+    get_selected_cuda_test_devices,
+    get_test_devices,
+    sanitize_identifier,
+)
+
+
+def _build_command_line_options(test_options: Dict[str, Any]) -> list:
+    """Helper function to build command-line options from the test options dictionary."""
+    additional_options = []
+
+    for key, value in test_options.items():
+        if key == "headless" and value:
+            additional_options.extend(["--headless"])
+        else:
+            # Just add --key value
+            additional_options.extend(["--" + key, str(value)])
+
+    return additional_options
+
+
+def _merge_options(base_options: Dict[str, Any], device_options: Dict[str, Any]) -> Dict[str, Any]:
+    """Helper function to merge base test options with device-specific test options."""
+    merged_options = base_options.copy()
+
+    #  Update options with device-specific dictionary, overwriting existing keys with the more-specific values
+    merged_options.update(device_options)
+    return merged_options
+
+
+def add_example_test(
+    cls: Type,
+    name: str,
+    devices: Optional[list] = None,
+    test_options: Optional[Dict[str, Any]] = None,
+    test_options_cpu: Optional[Dict[str, Any]] = None,
+    test_options_cuda: Optional[Dict[str, Any]] = None,
+):
+    """Registers a Warp example to run on ``devices`` as a TestCase."""
+
+    if test_options is None:
+        test_options = {}
+    if test_options_cpu is None:
+        test_options_cpu = {}
+    if test_options_cuda is None:
+        test_options_cuda = {}
+
+    def run(test, device):
+        if wp.get_device(device).is_cuda:
+            options = _merge_options(test_options, test_options_cuda)
+        else:
+            options = _merge_options(test_options, test_options_cpu)
+
+        # Mark the test as skipped if Torch is not installed but required
+        torch_required = options.pop("torch_required", False)
+        if torch_required:
+            try:
+                import torch
+
+                if wp.get_device(device).is_cuda and not torch.cuda.is_available():
+                    # Ensure torch has CUDA support
+                    test.skipTest("Torch not compiled with CUDA support")
+
+            except Exception as e:
+                test.skipTest(f"{e}")
+
+        # Mark the test as skipped if USD is not installed but required
+        usd_required = options.pop("usd_required", False)
+        if usd_required and not USD_AVAILABLE:
+            test.skipTest("Requires usd-core")
+
+        # Find the current Warp cache
+        warp_cache_path = wp.config.kernel_cache_dir
+
+        env_vars = os.environ.copy()
+        if warp_cache_path is not None:
+            env_vars["WARP_CACHE_PATH"] = warp_cache_path
+
+        if warp.tests.unittest_utils.coverage_enabled:
+            import tempfile
+
+            # Generate a random coverage data file name - file is deleted along with containing directory
+            with tempfile.NamedTemporaryFile(
+                dir=warp.tests.unittest_utils.coverage_temp_dir, delete=False
+            ) as coverage_file:
+                pass
+
+            command = ["coverage", "run", f"--data-file={coverage_file.name}"]
+
+            if warp.tests.unittest_utils.coverage_branch:
+                command.append("--branch")
+
+        else:
+            command = [sys.executable]
+
+        # Append Warp commands
+        command.extend(["-m", f"warp.examples.{name}", "--device", str(device)])
+
+        stage_path = (
+            options.pop(
+                "stage_path",
+                os.path.join(os.path.dirname(__file__), f"outputs/{name}_{sanitize_identifier(device)}.usd"),
+            )
+            if USD_AVAILABLE
+            else "None"
+        )
+
+        if stage_path:
+            command.extend(["--stage_path", stage_path])
+            try:
+                os.remove(stage_path)
+            except OSError:
+                pass
+
+        command.extend(_build_command_line_options(options))
+
+        # with wp.ScopedTimer(f"{name}_{sanitize_identifier(device)}"):
+        # Run the script as a subprocess
+        result = subprocess.run(command, capture_output=True, text=True, env=env_vars)
+
+        # Check the return code (0 is standard for success)
+        test.assertEqual(
+            result.returncode,
+            0,
+            msg=f"Failed with return code {result.returncode}, command: {' '.join(command)}\n\nOutput:\n{result.stdout}\n{result.stderr}",
+        )
+
+        # If the test succeeded, try to clean up the output by default
+        if stage_path and result.returncode == 0:
+            try:
+                os.remove(stage_path)
+            except OSError:
+                pass
+
+    from warp.tests.unittest_utils import add_function_test
+
+    add_function_test(cls, f"test_{name}", run, devices=devices, check_output=False)
+
+
+cuda_test_devices = get_selected_cuda_test_devices(mode="basic")  # Don't test on multiple GPUs to save time
+test_devices = get_test_devices(mode="basic")
+
+# NOTE: To give the parallel test runner more opportunities to parallelize test cases,
+# we break up the tests into multiple TestCase classes
+
+
+class TestCoreExamples(unittest.TestCase):
+    pass
+
+
+# Exclude unless we can run headless somehow
+# add_example_test(TestCoreExamples, name="example_render_opengl")
+
+add_example_test(TestCoreExamples, name="core.example_dem", devices=test_devices, test_options_cpu={"num_frames": 2})
+add_example_test(
+    TestCoreExamples,
+    name="core.example_fluid",
+    devices=test_devices,
+    test_options={"num_frames": 100, "headless": True},
+)
+add_example_test(
+    TestCoreExamples,
+    name="core.example_graph_capture",
+    devices=test_devices,
+    test_options={"headless": True},
+    test_options_cpu={"num_frames": 100},
+)
+add_example_test(TestCoreExamples, name="core.example_marching_cubes", devices=cuda_test_devices)
+add_example_test(TestCoreExamples, name="core.example_mesh", devices=test_devices, test_options={"usd_required": True})
+add_example_test(
+    TestCoreExamples, name="core.example_mesh_intersect", devices=test_devices, test_options={"usd_required": True}
+)
+add_example_test(TestCoreExamples, name="core.example_nvdb", devices=test_devices)
+add_example_test(
+    TestCoreExamples,
+    name="core.example_raycast",
+    devices=test_devices,
+    test_options={"usd_required": True, "headless": True},
+)
+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_sph", devices=test_devices, test_options_cpu={"num_frames": 1})
+add_example_test(
+    TestCoreExamples,
+    name="core.example_torch",
+    devices=test_devices,
+    test_options={"headless": True, "num_frames": 1000, "torch_required": True},
+)
+add_example_test(TestCoreExamples, name="core.example_wave", devices=test_devices)
+
+
+class TestOptimExamples(unittest.TestCase):
+    pass
+
+
+add_example_test(
+    TestOptimExamples, name="optim.example_bounce", devices=test_devices, test_options_cpu={"train_iters": 3}
+)
+add_example_test(
+    TestOptimExamples,
+    name="optim.example_drone",
+    devices=test_devices,
+    test_options={"headless": True},
+    test_options_cpu={"num_frames": 10},
+)
+add_example_test(
+    TestOptimExamples, name="optim.example_cloth_throw", devices=test_devices, test_options_cpu={"train_iters": 3}
+)
+add_example_test(
+    TestOptimExamples,
+    name="optim.example_diffray",
+    devices=test_devices,
+    test_options={"usd_required": True, "headless": True},
+    test_options_cpu={"train_iters": 2},
+)
+add_example_test(TestOptimExamples, name="optim.example_inverse_kinematics", devices=test_devices)
+add_example_test(
+    TestOptimExamples,
+    name="optim.example_inverse_kinematics_torch",
+    devices=test_devices,
+    test_options={"torch_required": True},
+)
+add_example_test(TestOptimExamples, name="optim.example_spring_cage", devices=test_devices)
+add_example_test(
+    TestOptimExamples,
+    name="optim.example_trajectory",
+    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,
+    },
+    test_options_cpu={"train_iters": 1, "num_frames": 30},
+)
+
+
+class TestSimExamples(unittest.TestCase):
+    pass
+
+
+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},
+)
+add_example_test(
+    TestSimExamples, name="sim.example_granular", devices=test_devices, test_options_cpu={"num_frames": 10}
+)
+add_example_test(TestSimExamples, name="sim.example_granular_collision_sdf", devices=cuda_test_devices)
+add_example_test(TestSimExamples, name="sim.example_jacobian_ik", devices=test_devices)
+add_example_test(TestSimExamples, name="sim.example_particle_chain", devices=test_devices)
+add_example_test(
+    TestSimExamples, name="sim.example_quadruped", devices=test_devices, test_options_cpu={"num_frames": 100}
+)
+add_example_test(TestSimExamples, name="sim.example_rigid_chain", devices=test_devices)
+add_example_test(
+    TestSimExamples,
+    name="sim.example_rigid_contact",
+    devices=test_devices,
+    test_options={"usd_required": True},
+    test_options_cpu={"num_frames": 3},
+)
+add_example_test(
+    TestSimExamples, name="sim.example_rigid_soft_contact", devices=test_devices, test_options_cpu={"num_frames": 10}
+)
+add_example_test(TestSimExamples, name="sim.example_rigid_force", devices=test_devices)
+add_example_test(TestSimExamples, name="sim.example_rigid_gyroscopic", devices=test_devices)
+add_example_test(
+    TestSimExamples, name="sim.example_soft_body", devices=test_devices, test_options_cpu={"num_frames": 10}
+)
+
+
+class TestFemExamples(unittest.TestCase):
+    pass
+
+
+class TestFemDiffusionExamples(unittest.TestCase):
+    pass
+
+
+add_example_test(
+    TestFemDiffusionExamples,
+    name="fem.example_diffusion_mgpu",
+    devices=get_selected_cuda_test_devices(mode="basic"),
+    test_options={"headless": True},
+)
+
+add_example_test(
+    TestFemExamples,
+    name="fem.example_apic_fluid",
+    devices=get_selected_cuda_test_devices(),
+    test_options={"num_frames": 5, "voxel_size": 2.0},
+)
+
+# The following examples do not need CUDA
+add_example_test(
+    TestFemDiffusionExamples,
+    name="fem.example_diffusion",
+    devices=test_devices,
+    test_options={"resolution": 10, "mesh": "tri", "headless": True},
+)
+add_example_test(
+    TestFemDiffusionExamples, name="fem.example_diffusion_3d", devices=test_devices, test_options={"headless": True}
+)
+add_example_test(
+    TestFemExamples,
+    name="fem.example_deformed_geometry",
+    devices=test_devices,
+    test_options={"resolution": 10, "mesh": "tri", "headless": True},
+)
+add_example_test(
+    TestFemExamples,
+    name="fem.example_convection_diffusion",
+    devices=test_devices,
+    test_options={"resolution": 20, "headless": True},
+)
+add_example_test(
+    TestFemExamples,
+    name="fem.example_burgers",
+    devices=test_devices,
+    test_options={"resolution": 20, "num_frames": 25, "degree": 1, "headless": True},
+)
+add_example_test(
+    TestFemExamples,
+    name="fem.example_convection_diffusion_dg",
+    devices=test_devices,
+    test_options={"resolution": 20, "num_frames": 25, "mesh": "quad", "headless": True},
+)
+add_example_test(
+    TestFemExamples,
+    name="fem.example_mixed_elasticity",
+    devices=test_devices,
+    test_options={"nonconforming_stresses": True, "mesh": "quad", "headless": True},
+)
+add_example_test(
+    TestFemExamples, name="fem.example_stokes_transfer", devices=test_devices, test_options={"headless": True}
+)
+add_example_test(
+    TestFemExamples,
+    name="fem.example_stokes",
+    devices=test_devices,
+    test_options={"resolution": 10, "nonconforming_pressures": True, "headless": True},
+)
+add_example_test(
+    TestFemExamples,
+    name="fem.example_navier_stokes",
+    devices=test_devices,
+    test_options={"num_frames": 101, "resolution": 10, "tri_mesh": True, "headless": True},
+)
+
+if __name__ == "__main__":
+    # force rebuild of all kernels
+    wp.build.clear_kernel_cache()
+
+    unittest.main(verbosity=2, failfast=True)