warp-lang 0.9.0__py3-none-win_amd64.whl → 0.11.0__py3-none-win_amd64.whl

warp/tests/test_volume_write.py

@@ -5,11 +5,13 @@
 # distribution of this software and related documentation without an express
 # license agreement from NVIDIA CORPORATION is strictly prohibited.
 
-import warp as wp
-from warp.tests.test_base import *
+import unittest
 
 import numpy as np
 
+import warp as wp
+from warp.tests.unittest_utils import *
+
 wp.init()
 # wp.config.cache_kernels = False
 
@@ -137,139 +139,127 @@ def test_volume_tile_readback_v(volume: wp.uint64, tiles: wp.array2d(dtype=wp.in
         values[tid * 512 + r] = wp.volume_lookup_v(volume, ii, jj, kk)
 
 
-rng = np.random.default_rng(101215)
-
-
-def register(parent):
-    devices = get_test_devices()
-
-    class TestVolumes(parent):
-        def test_volume_allocation(self):
-            voxel_size = 0.125
-            background_value = 123.456
-            translation = wp.vec3(-12.3, 4.56, -789)
-
-            axis = np.linspace(-11, 11, 23)
-            points_ref = np.array([[x, y, z] for x in axis for y in axis for z in axis])
-            values_ref = np.array([x + 100 * y + 10000 * z for x in axis for y in axis for z in axis])
-            num_points = len(points_ref)
-            bb_max = np.array([11, 11, 11])
-            for device in devices:
-                if device.is_cpu:
-                    continue
-
-                volume_a = wp.Volume.allocate(
-                    -bb_max,
-                    bb_max,
-                    voxel_size=voxel_size,
-                    bg_value=background_value,
-                    translation=translation,
-                    device=device,
-                )
-                volume_b = wp.Volume.allocate(
-                    -bb_max * voxel_size + translation,
-                    bb_max * voxel_size + translation,
-                    voxel_size=voxel_size,
-                    bg_value=background_value,
-                    translation=translation,
-                    points_in_world_space=True,
-                    device=device,
-                )
-                points = wp.array(points_ref, dtype=wp.vec3, device=device)
-                values_a = wp.empty(num_points, dtype=wp.float32, device=device)
-                values_b = wp.empty(num_points, dtype=wp.float32, device=device)
-                wp.launch(test_volume_store_f, dim=num_points, inputs=[volume_a.id, points], device=device)
-                wp.launch(test_volume_store_f, dim=num_points, inputs=[volume_b.id, points], device=device)
-                wp.launch(test_volume_readback_f, dim=num_points, inputs=[volume_a.id, points, values_a], device=device)
-                wp.launch(test_volume_readback_f, dim=num_points, inputs=[volume_b.id, points, values_b], device=device)
-
-                np.testing.assert_equal(values_a.numpy(), values_ref)
-                np.testing.assert_equal(values_b.numpy(), values_ref)
-
-        def test_volume_allocate_by_tiles_f(self):
-            voxel_size = 0.125
-            background_value = 123.456
-            translation = wp.vec3(-12.3, 4.56, -789)
-
-            num_tiles = 1000
-            tiles = rng.integers(-512, 512, size=(num_tiles, 3), dtype=np.int32)
-            points_is = tiles * 8  # points in index space
-            points_ws = points_is * voxel_size + translation  # points in world space
-
-            values_ref = np.empty(num_tiles * 512)
-            for t in range(num_tiles):
-                ti, tj, tk = points_is[t]
-                for i in range(8):
-                    for j in range(8):
-                        for k in range(8):
-                            values_ref[t * 512 + i * 64 + j * 8 + k] = float(100 * (ti + i) + 10 * (tj + j) + (tk + k))
-
-            for device in devices:
-                if device.is_cpu:
-                    continue
-
-                points_is_d = wp.array(points_is, dtype=wp.int32, device=device)
-                points_ws_d = wp.array(points_ws, dtype=wp.vec3, device=device)
-                volume_a = wp.Volume.allocate_by_tiles(
-                    points_is_d, voxel_size, background_value, translation, device=device
-                )
-                volume_b = wp.Volume.allocate_by_tiles(
-                    points_ws_d, voxel_size, background_value, translation, device=device
-                )
-                values_a = wp.empty(num_tiles * 512, dtype=wp.float32, device=device)
-                values_b = wp.empty(num_tiles * 512, dtype=wp.float32, device=device)
-
-                wp.launch(test_volume_tile_store_f, dim=num_tiles, inputs=[volume_a.id, points_is_d], device=device)
-                wp.launch(test_volume_tile_store_ws_f, dim=num_tiles, inputs=[volume_b.id, points_ws_d], device=device)
-                wp.launch(
-                    test_volume_tile_readback_f,
-                    dim=num_tiles,
-                    inputs=[volume_a.id, points_is_d, values_a],
-                    device=device,
-                )
-                wp.launch(
-                    test_volume_tile_readback_f,
-                    dim=num_tiles,
-                    inputs=[volume_b.id, points_is_d, values_b],
-                    device=device,
-                )
-
-                np.testing.assert_equal(values_a.numpy(), values_ref)
-                np.testing.assert_equal(values_b.numpy(), values_ref)
-
-        def test_volume_allocate_by_tiles_v(self):
-            num_tiles = 1000
-            tiles = rng.integers(-512, 512, size=(num_tiles, 3), dtype=np.int32)
-            points_is = tiles * 8
-
-            values_ref = np.empty((len(tiles) * 512, 3))
-            for t in range(len(tiles)):
-                ti, tj, tk = points_is[t]
-                for i in range(8):
-                    for j in range(8):
-                        for k in range(8):
-                            values_ref[t * 512 + i * 64 + j * 8 + k] = [ti + i, tj + j, tk + k]
-
-            for device in devices:
-                if device.is_cpu:
-                    continue
-
-                points_d = wp.array(points_is, dtype=wp.int32, device=device)
-                volume = wp.Volume.allocate_by_tiles(points_d, 0.1, wp.vec3(1, 2, 3), device=device)
-                values = wp.empty(len(points_d) * 512, dtype=wp.vec3, device=device)
-
-                wp.launch(test_volume_tile_store_v, dim=len(points_d), inputs=[volume.id, points_d], device=device)
-                wp.launch(
-                    test_volume_tile_readback_v, dim=len(points_d), inputs=[volume.id, points_d, values], device=device
-                )
-
-                values_res = values.numpy()
-                np.testing.assert_equal(values_res, values_ref)
-
-    return TestVolumes
+def test_volume_allocation(test, device):
+    voxel_size = 0.125
+    background_value = 123.456
+    translation = wp.vec3(-12.3, 4.56, -789)
+
+    axis = np.linspace(-11, 11, 23)
+    points_ref = np.array([[x, y, z] for x in axis for y in axis for z in axis])
+    values_ref = np.array([x + 100 * y + 10000 * z for x in axis for y in axis for z in axis])
+    num_points = len(points_ref)
+    bb_max = np.array([11, 11, 11])
+    volume_a = wp.Volume.allocate(
+        -bb_max,
+        bb_max,
+        voxel_size=voxel_size,
+        bg_value=background_value,
+        translation=translation,
+        device=device,
+    )
+    volume_b = wp.Volume.allocate(
+        -bb_max * voxel_size + translation,
+        bb_max * voxel_size + translation,
+        voxel_size=voxel_size,
+        bg_value=background_value,
+        translation=translation,
+        points_in_world_space=True,
+        device=device,
+    )
+    points = wp.array(points_ref, dtype=wp.vec3, device=device)
+    values_a = wp.empty(num_points, dtype=wp.float32, device=device)
+    values_b = wp.empty(num_points, dtype=wp.float32, device=device)
+    wp.launch(test_volume_store_f, dim=num_points, inputs=[volume_a.id, points], device=device)
+    wp.launch(test_volume_store_f, dim=num_points, inputs=[volume_b.id, points], device=device)
+    wp.launch(test_volume_readback_f, dim=num_points, inputs=[volume_a.id, points, values_a], device=device)
+    wp.launch(test_volume_readback_f, dim=num_points, inputs=[volume_b.id, points, values_b], device=device)
+
+    np.testing.assert_equal(values_a.numpy(), values_ref)
+    np.testing.assert_equal(values_b.numpy(), values_ref)
+
+
+def test_volume_allocate_by_tiles_f(test, device):
+    voxel_size = 0.125
+    background_value = 123.456
+    translation = wp.vec3(-12.3, 4.56, -789)
+
+    num_tiles = 1000
+    rng = np.random.default_rng(101215)
+    tiles = rng.integers(-512, 512, size=(num_tiles, 3), dtype=np.int32)
+    points_is = tiles * 8  # points in index space
+    points_ws = points_is * voxel_size + translation  # points in world space
+
+    values_ref = np.empty(num_tiles * 512)
+    for t in range(num_tiles):
+        ti, tj, tk = points_is[t]
+        for i in range(8):
+            for j in range(8):
+                for k in range(8):
+                    values_ref[t * 512 + i * 64 + j * 8 + k] = float(100 * (ti + i) + 10 * (tj + j) + (tk + k))
+
+    points_is_d = wp.array(points_is, dtype=wp.int32, device=device)
+    points_ws_d = wp.array(points_ws, dtype=wp.vec3, device=device)
+    volume_a = wp.Volume.allocate_by_tiles(points_is_d, voxel_size, background_value, translation, device=device)
+    volume_b = wp.Volume.allocate_by_tiles(points_ws_d, voxel_size, background_value, translation, device=device)
+    values_a = wp.empty(num_tiles * 512, dtype=wp.float32, device=device)
+    values_b = wp.empty(num_tiles * 512, dtype=wp.float32, device=device)
+
+    wp.launch(test_volume_tile_store_f, dim=num_tiles, inputs=[volume_a.id, points_is_d], device=device)
+    wp.launch(test_volume_tile_store_ws_f, dim=num_tiles, inputs=[volume_b.id, points_ws_d], device=device)
+    wp.launch(
+        test_volume_tile_readback_f,
+        dim=num_tiles,
+        inputs=[volume_a.id, points_is_d, values_a],
+        device=device,
+    )
+    wp.launch(
+        test_volume_tile_readback_f,
+        dim=num_tiles,
+        inputs=[volume_b.id, points_is_d, values_b],
+        device=device,
+    )
+
+    np.testing.assert_equal(values_a.numpy(), values_ref)
+    np.testing.assert_equal(values_b.numpy(), values_ref)
+
+
+def test_volume_allocate_by_tiles_v(test, device):
+    num_tiles = 1000
+    rng = np.random.default_rng(101215)
+    tiles = rng.integers(-512, 512, size=(num_tiles, 3), dtype=np.int32)
+    points_is = tiles * 8
+
+    values_ref = np.empty((len(tiles) * 512, 3))
+    for t in range(len(tiles)):
+        ti, tj, tk = points_is[t]
+        for i in range(8):
+            for j in range(8):
+                for k in range(8):
+                    values_ref[t * 512 + i * 64 + j * 8 + k] = [ti + i, tj + j, tk + k]
+
+    points_d = wp.array(points_is, dtype=wp.int32, device=device)
+    volume = wp.Volume.allocate_by_tiles(points_d, 0.1, wp.vec3(1, 2, 3), device=device)
+    values = wp.empty(len(points_d) * 512, dtype=wp.vec3, device=device)
+
+    wp.launch(test_volume_tile_store_v, dim=len(points_d), inputs=[volume.id, points_d], device=device)
+    wp.launch(test_volume_tile_readback_v, dim=len(points_d), inputs=[volume.id, points_d, values], device=device)
+
+    values_res = values.numpy()
+    np.testing.assert_equal(values_res, values_ref)
+
+
+devices = get_unique_cuda_test_devices()
+
+
+class TestVolumeWrite(unittest.TestCase):
+    pass
+
+
+add_function_test(TestVolumeWrite, "test_volume_allocation", test_volume_allocation, devices=devices)
+add_function_test(TestVolumeWrite, "test_volume_allocate_by_tiles_f", test_volume_allocate_by_tiles_f, devices=devices)
+add_function_test(TestVolumeWrite, "test_volume_allocate_by_tiles_v", test_volume_allocate_by_tiles_v, devices=devices)
 
 
 if __name__ == "__main__":
-    wp.force_load()
-    c = register(unittest.TestCase)
+    wp.build.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/unittest_serial.py

@@ -0,0 +1,35 @@
+# 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 warp as wp
+from warp.tests.unittest_utils import TeamCityTestRunner
+
+
+def run_suite() -> bool:
+    """Run a test suite"""
+
+    import warp.tests.unittest_suites
+
+    # force rebuild of all kernels
+    wp.build.clear_kernel_cache()
+    print("Cleared Warp kernel cache")
+
+    runner = TeamCityTestRunner(verbosity=2, failfast=False)
+
+    # Can swap out warp.tests.unittest_suites.explicit_suite()
+    suite = warp.tests.unittest_suites.auto_discover_suite()
+    print(f"Test suite has {suite.countTestCases()} tests")
+
+    ret = not runner.run(suite, "WarpTests").wasSuccessful()
+    return ret
+
+
+if __name__ == "__main__":
+    ret = run_suite()
+    import sys
+
+    sys.exit(ret)

warp/tests/unittest_suites.py

@@ -0,0 +1,341 @@
+# 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.
+
+"""Warp Test Suites
+
+This file is intended to define functions that return TestSuite objects, which
+can be used in parallel or serial unit tests (with optional code coverage)
+"""
+
+import os
+import sys
+import unittest
+
+START_DIRECTORY = os.path.realpath(os.path.dirname(__file__))
+TOP_LEVEL_DIRECTORY = os.path.realpath(os.path.join(START_DIRECTORY, "..", ".."))
+
+
+def _create_suite_from_test_classes(test_loader, test_classes):
+    suite = unittest.TestSuite()
+
+    for test in test_classes:
+        sub_suite = unittest.TestSuite()
+        # Note that the test_loader might have testNamePatterns set
+        sub_suite.addTest(test_loader.loadTestsFromTestCase(test))
+        suite.addTest(sub_suite)
+
+    return suite
+
+
+def auto_discover_suite(loader=unittest.defaultTestLoader, pattern="test*.py"):
+    """Uses unittest auto-discovery to build a test suite (test_*.py pattern)"""
+
+    return loader.discover(start_dir=START_DIRECTORY, pattern=pattern, top_level_dir=TOP_LEVEL_DIRECTORY)
+
+
+def _iter_class_suites(test_suite):
+    """Iterate class-level test suites - test suites that contains test cases
+
+    From unittest_parallel.py
+    """
+    has_cases = any(isinstance(suite, unittest.TestCase) for suite in test_suite)
+    if has_cases:
+        yield test_suite
+    else:
+        for suite in test_suite:
+            yield from _iter_class_suites(suite)
+
+
+def compare_unittest_suites(
+    test_loader: unittest.TestLoader, test_suite_name: str, reference_suite: unittest.TestSuite
+) -> None:
+    """Prints the tests in `test_suite` that are not in `reference_suite`."""
+
+    test_suite_fn = getattr(sys.modules[__name__], test_suite_name + "_suite")
+
+    test_suite = test_suite_fn(test_loader)
+
+    test_suite_classes_str = set(
+        type(test_suite._tests[0]).__name__
+        for test_suite in list(_iter_class_suites(test_suite))
+        if test_suite.countTestCases() > 0
+    )
+
+    reference_suite_classes_str = set(
+        type(test_suite._tests[0]).__name__
+        for test_suite in list(_iter_class_suites(reference_suite))
+        if test_suite.countTestCases() > 0
+    )
+
+    set_difference = reference_suite_classes_str - test_suite_classes_str
+
+    print(f"Selected test suite '{test_suite_name}'")
+    if len(set_difference) > 0:
+        print(f"Test suite '{test_suite_name}' omits the following test classes:")
+        for test_entry in set_difference:
+            print(f"    {test_entry}")
+
+    return test_suite
+
+
+def default_suite(test_loader: unittest.TestLoader):
+    """Example of a manually constructed test suite.
+
+    Intended to be modified to create additional test suites
+    """
+    from warp.tests.test_adam import TestAdam
+    from warp.tests.test_arithmetic import TestArithmetic
+    from warp.tests.test_array import TestArray
+    from warp.tests.test_array_reduce import TestArrayReduce
+    from warp.tests.test_atomic import TestAtomic
+    from warp.tests.test_bool import TestBool
+    from warp.tests.test_builtins_resolution import TestBuiltinsResolution
+    from warp.tests.test_bvh import TestBvh
+    from warp.tests.test_closest_point_edge_edge import TestClosestPointEdgeEdgeMethods
+    from warp.tests.test_codegen import TestCodeGen
+    from warp.tests.test_compile_consts import TestConstants
+    from warp.tests.test_conditional import TestConditional
+    from warp.tests.test_copy import TestCopy
+    from warp.tests.test_ctypes import TestCTypes
+    from warp.tests.test_dense import TestDense
+    from warp.tests.test_devices import TestDevices
+    from warp.tests.test_dlpack import TestDLPack
+    from warp.tests.test_examples import TestExamples, TestFemExamples, TestSimExamples
+    from warp.tests.test_fabricarray import TestFabricArray
+    from warp.tests.test_fast_math import TestFastMath
+    from warp.tests.test_fem import TestFem, TestFemShapeFunctions
+    from warp.tests.test_fp16 import TestFp16
+    from warp.tests.test_func import TestFunc
+    from warp.tests.test_generics import TestGenerics
+    from warp.tests.test_grad import TestGrad
+    from warp.tests.test_grad_customs import TestGradCustoms
+    from warp.tests.test_hash_grid import TestHashGrid
+    from warp.tests.test_import import TestImport
+    from warp.tests.test_indexedarray import TestIndexedArray
+    from warp.tests.test_intersect import TestIntersect
+    from warp.tests.test_large import TestLarge
+    from warp.tests.test_launch import TestLaunch
+    from warp.tests.test_lerp import TestLerp
+    from warp.tests.test_linear_solvers import TestLinearSolvers
+    from warp.tests.test_lvalue import TestLValue
+    from warp.tests.test_marching_cubes import TestMarchingCubes
+    from warp.tests.test_mat import TestMat
+    from warp.tests.test_mat_lite import TestMatLite
+    from warp.tests.test_mat_scalar_ops import TestMatScalarOps
+    from warp.tests.test_math import TestMath
+    from warp.tests.test_matmul import TestMatmul
+    from warp.tests.test_matmul_lite import TestMatmulLite
+    from warp.tests.test_mesh import TestMesh
+    from warp.tests.test_mesh_query_aabb import TestMeshQueryAABBMethods
+    from warp.tests.test_mesh_query_point import TestMeshQueryPoint
+    from warp.tests.test_mesh_query_ray import TestMeshQueryRay
+    from warp.tests.test_mlp import TestMLP
+    from warp.tests.test_model import TestModel
+    from warp.tests.test_modules_lite import TestModuleLite
+    from warp.tests.test_multigpu import TestMultiGPU
+    from warp.tests.test_noise import TestNoise
+    from warp.tests.test_operators import TestOperators
+    from warp.tests.test_options import TestOptions
+    from warp.tests.test_pinned import TestPinned
+    from warp.tests.test_print import TestPrint
+    from warp.tests.test_quat import TestQuat
+    from warp.tests.test_rand import TestRand
+    from warp.tests.test_reload import TestReload
+    from warp.tests.test_rounding import TestRounding
+    from warp.tests.test_runlength_encode import TestRunlengthEncode
+    from warp.tests.test_smoothstep import TestSmoothstep
+    from warp.tests.test_snippet import TestSnippets
+    from warp.tests.test_sparse import TestSparse
+    from warp.tests.test_spatial import TestSpatial
+    from warp.tests.test_streams import TestStreams
+    from warp.tests.test_struct import TestStruct
+    from warp.tests.test_tape import TestTape
+    from warp.tests.test_torch import TestTorch
+    from warp.tests.test_transient_module import TestTransientModule
+    from warp.tests.test_types import TestTypes
+    from warp.tests.test_utils import TestUtils
+    from warp.tests.test_vec import TestVec
+    from warp.tests.test_vec_lite import TestVecLite
+    from warp.tests.test_vec_scalar_ops import TestVecScalarOps
+    from warp.tests.test_volume import TestVolume
+    from warp.tests.test_volume_write import TestVolumeWrite
+
+    test_classes = [
+        TestAdam,
+        TestArithmetic,
+        TestArray,
+        TestArrayReduce,
+        TestAtomic,
+        TestBool,
+        TestBuiltinsResolution,
+        TestBvh,
+        TestClosestPointEdgeEdgeMethods,
+        TestCodeGen,
+        TestConstants,
+        TestConditional,
+        TestCopy,
+        TestCTypes,
+        TestDense,
+        TestDevices,
+        TestDLPack,
+        TestExamples,
+        TestFemExamples,
+        TestSimExamples,
+        TestFabricArray,
+        TestFastMath,
+        TestFem,
+        TestFemShapeFunctions,
+        TestFp16,
+        TestFunc,
+        TestGenerics,
+        TestGrad,
+        TestGradCustoms,
+        TestHashGrid,
+        TestImport,
+        TestIndexedArray,
+        TestIntersect,
+        TestLarge,
+        TestLaunch,
+        TestLerp,
+        TestLinearSolvers,
+        TestLValue,
+        TestMarchingCubes,
+        TestMat,
+        TestMatLite,
+        TestMatScalarOps,
+        TestMath,
+        TestMatmul,
+        TestMatmulLite,
+        TestMesh,
+        TestMeshQueryAABBMethods,
+        TestMeshQueryPoint,
+        TestMeshQueryRay,
+        TestMLP,
+        TestModel,
+        TestModuleLite,
+        TestMultiGPU,
+        TestNoise,
+        TestOperators,
+        TestOptions,
+        TestPinned,
+        TestPrint,
+        TestQuat,
+        TestRand,
+        TestReload,
+        TestRounding,
+        TestRunlengthEncode,
+        TestSmoothstep,
+        TestSparse,
+        TestSnippets,
+        TestSpatial,
+        TestStreams,
+        TestStruct,
+        TestTape,
+        TestTorch,
+        TestTransientModule,
+        TestTypes,
+        TestUtils,
+        TestVec,
+        TestVecLite,
+        TestVecScalarOps,
+        TestVolume,
+        TestVolumeWrite,
+    ]
+
+    return _create_suite_from_test_classes(test_loader, test_classes)
+
+
+def kit_suite(test_loader: unittest.TestLoader):
+    """Tries to mimic the test suite used for testing omni.warp.core in Kit
+
+    Requires manual updates with test_ext.py for now.
+    """
+    from warp.tests.test_array import TestArray
+    from warp.tests.test_array_reduce import TestArrayReduce
+    from warp.tests.test_bvh import TestBvh
+    from warp.tests.test_codegen import TestCodeGen
+    from warp.tests.test_compile_consts import TestConstants
+    from warp.tests.test_conditional import TestConditional
+    from warp.tests.test_ctypes import TestCTypes
+    from warp.tests.test_devices import TestDevices
+    from warp.tests.test_dlpack import TestDLPack
+    from warp.tests.test_fabricarray import TestFabricArray
+    from warp.tests.test_func import TestFunc
+    from warp.tests.test_generics import TestGenerics
+    from warp.tests.test_grad_customs import TestGradCustoms
+    from warp.tests.test_hash_grid import TestHashGrid
+    from warp.tests.test_indexedarray import TestIndexedArray
+    from warp.tests.test_launch import TestLaunch
+    from warp.tests.test_marching_cubes import TestMarchingCubes
+    from warp.tests.test_mat_lite import TestMatLite
+    from warp.tests.test_math import TestMath
+    from warp.tests.test_matmul_lite import TestMatmulLite
+    from warp.tests.test_mesh import TestMesh
+    from warp.tests.test_mesh_query_aabb import TestMeshQueryAABBMethods
+    from warp.tests.test_mesh_query_point import TestMeshQueryPoint
+    from warp.tests.test_mesh_query_ray import TestMeshQueryRay
+    from warp.tests.test_modules_lite import TestModuleLite
+    from warp.tests.test_noise import TestNoise
+    from warp.tests.test_operators import TestOperators
+    from warp.tests.test_quat import TestQuat
+    from warp.tests.test_rand import TestRand
+    from warp.tests.test_rounding import TestRounding
+    from warp.tests.test_runlength_encode import TestRunlengthEncode
+    from warp.tests.test_sparse import TestSparse
+    from warp.tests.test_streams import TestStreams
+    from warp.tests.test_tape import TestTape
+    from warp.tests.test_transient_module import TestTransientModule
+    from warp.tests.test_types import TestTypes
+    from warp.tests.test_utils import TestUtils
+    from warp.tests.test_vec_lite import TestVecLite
+    from warp.tests.test_volume import TestVolume
+    from warp.tests.test_volume_write import TestVolumeWrite
+
+    test_classes = [
+        TestArray,
+        TestArrayReduce,
+        TestBvh,
+        TestCodeGen,
+        TestConstants,
+        TestConditional,
+        TestCTypes,
+        TestDevices,
+        TestDLPack,
+        TestFabricArray,
+        TestFunc,
+        TestGenerics,
+        TestGradCustoms,
+        TestHashGrid,
+        TestIndexedArray,
+        TestLaunch,
+        TestMarchingCubes,
+        TestMatLite,
+        TestMath,
+        TestMatmulLite,
+        TestMesh,
+        TestMeshQueryAABBMethods,
+        TestMeshQueryPoint,
+        TestMeshQueryRay,
+        TestModuleLite,
+        TestNoise,
+        TestOperators,
+        TestQuat,
+        TestRand,
+        TestRounding,
+        TestRunlengthEncode,
+        TestSparse,
+        TestStreams,
+        TestTape,
+        TestTransientModule,
+        TestTypes,
+        TestUtils,
+        TestVecLite,
+        TestVolume,
+        TestVolumeWrite,
+    ]
+
+    return _create_suite_from_test_classes(test_loader, test_classes)