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

warp/tests/test_codegen.py

@@ -5,12 +5,11 @@
 # distribution of this software and related documentation without an express
 # license agreement from NVIDIA CORPORATION is strictly prohibited.
 
-# include parent path
 import sys
 import unittest
 
 import warp as wp
-from warp.tests.test_base import *
+from warp.tests.unittest_utils import *
 
 # wp.config.mode = "debug"
 
@@ -212,6 +211,18 @@ def test_break_early(n: int):
     wp.expect_eq(a, 1)
 
 
+@wp.kernel
+def test_break_unroll():
+    a = int(0)
+
+    for i in range(0, 10):
+        if i > 5:
+            a = i
+            break
+
+    wp.expect_eq(a, 6)
+
+
 @wp.kernel
 def test_break_multiple(n: int):
     a = int(0)
@@ -245,6 +256,19 @@ def test_continue(n: int):
     wp.expect_eq(a, n - 1)
 
 
+@wp.kernel
+def test_continue_unroll():
+    a = int(0)
+
+    for i in range(0, 10):
+        if i == 5:
+            continue
+
+        a += 1
+
+    wp.expect_eq(a, 9)
+
+
 lower = wp.constant(-3)
 upper = wp.constant(3)
 step = wp.constant(2)
@@ -292,9 +316,36 @@ def test_range_constant_dynamic_nested(m: int):
     wp.expect_eq(s, N * m * N)
 
 
+@wp.kernel
+def test_range_expression():
+    idx = 1
+    batch_size = 100
+
+    a = wp.float(0.0)
+    c = wp.float(1.0)
+
+    # constant expression with a function
+    for i in range(4 * idx, wp.min(4 * idx + 4, batch_size)):
+        a += c
+
+    for i in range(4 * idx, min(4 * idx + 4, batch_size)):
+        a += c
+
+    tid = wp.tid()
+
+    # dynamic expression with a function
+    for i in range(4 * idx, wp.min(4 * idx, tid + 1000)):
+        a += c
+
+    for i in range(4 * idx, min(4 * idx, tid + 1000)):
+        a += c
+
+    wp.expect_eq(a, 8.0)
+
+
 def test_unresolved_func(test, device):
     # kernel with unresolved function must be in a separate module, otherwise the current module would fail to load
-    from warp.tests.test_unresolved_func import unresolved_func_kernel
+    from warp.tests.aux_test_unresolved_func import unresolved_func_kernel
 
     # ensure that an appropriate exception is raised when the bad module gets loaded
     with test.assertRaisesRegex(RuntimeError, "Could not find function wp.missing_func"):
@@ -302,13 +353,13 @@ def test_unresolved_func(test, device):
 
     # remove all references to the bad module so that subsequent calls to wp.force_load()
     # won't try to load it unless we explicitly re-import it again
-    del wp.context.user_modules["warp.tests.test_unresolved_func"]
-    del sys.modules["warp.tests.test_unresolved_func"]
+    del wp.context.user_modules["warp.tests.aux_test_unresolved_func"]
+    del sys.modules["warp.tests.aux_test_unresolved_func"]
 
 
 def test_unresolved_symbol(test, device):
     # kernel with unresolved symbol must be in a separate module, otherwise the current module would fail to load
-    from warp.tests.test_unresolved_symbol import unresolved_symbol_kernel
+    from warp.tests.aux_test_unresolved_symbol import unresolved_symbol_kernel
 
     # ensure that an appropriate exception is raised when the bad module gets loaded
     with test.assertRaisesRegex(KeyError, "Referencing undefined symbol: missing_symbol"):
@@ -316,133 +367,187 @@ def test_unresolved_symbol(test, device):
 
     # remove all references to the bad module so that subsequent calls to wp.force_load()
     # won't try to load it unless we explicitly re-import it again
-    del wp.context.user_modules["warp.tests.test_unresolved_symbol"]
-    del sys.modules["warp.tests.test_unresolved_symbol"]
-
-
-def register(parent):
-    class TestCodeGen(parent):
-        pass
-
-    devices = get_test_devices()
-
-    add_kernel_test(TestCodeGen, name="test_inplace", kernel=test_inplace, dim=1, devices=devices)
-    add_kernel_test(TestCodeGen, name="test_rename", kernel=test_rename, dim=1, devices=devices)
-    add_kernel_test(TestCodeGen, name="test_constant", kernel=test_constant, inputs=[1.0], dim=1, devices=devices)
-    add_kernel_test(
-        TestCodeGen, name="test_dynamic_for_rename", kernel=test_dynamic_for_rename, inputs=[10], dim=1, devices=devices
-    )
-    add_kernel_test(
-        TestCodeGen,
-        name="test_dynamic_for_inplace",
-        kernel=test_dynamic_for_inplace,
-        inputs=[10],
-        dim=1,
-        devices=devices,
-    )
-    add_kernel_test(TestCodeGen, name="test_reassign", kernel=test_reassign, dim=1, devices=devices)
-    add_kernel_test(
-        TestCodeGen, name="test_dynamic_reassign", kernel=test_dynamic_reassign, inputs=[2], dim=1, devices=devices
-    )
+    del wp.context.user_modules["warp.tests.aux_test_unresolved_symbol"]
+    del sys.modules["warp.tests.aux_test_unresolved_symbol"]
 
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_dynamic_forward",
-        kernel=test_range_dynamic,
-        dim=1,
-        inputs=[0, 4, 1],
-        expect=[0, 1, 2, 3],
-        devices=devices,
-    )
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_dynamic_reverse",
-        kernel=test_range_dynamic,
-        dim=1,
-        inputs=[4, 0, -1],
-        expect=[4, 3, 2, 1],
-        devices=devices,
-    )
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_dynamic_foward_step",
-        kernel=test_range_dynamic,
-        dim=1,
-        inputs=[0, 8, 2],
-        expect=[0, 2, 4, 6],
-        devices=devices,
-    )
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_dynamic_reverse_step",
-        kernel=test_range_dynamic,
-        dim=1,
-        inputs=[8, 0, -2],
-        expect=[8, 6, 4, 2],
-        devices=devices,
-    )
-
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_static_sum",
-        kernel=test_range_static_sum,
-        dim=1,
-        expect=[10, 10, 10],
-        devices=devices,
-    )
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_dynamic_sum",
-        kernel=test_range_dynamic_sum,
-        dim=1,
-        inputs=[0, 10, 2],
-        expect=[10, 10, 10, 10],
-        devices=devices,
-    )
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_dynamic_sum_zero",
-        kernel=test_range_dynamic_sum,
-        dim=1,
-        inputs=[0, 0, 1],
-        expect=[0, 0, 0, 0],
-        devices=devices,
-    )
-    add_kernel_test(TestCodeGen, name="test_range_constant", kernel=test_range_constant, dim=1, devices=devices)
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_constant_dynamic_nested",
-        kernel=test_range_constant_dynamic_nested,
-        dim=1,
-        inputs=[10],
-        devices=devices,
-    )
-    add_kernel_test(
-        TestCodeGen,
-        name="test_range_dynamic_nested",
-        kernel=test_range_dynamic_nested,
-        dim=1,
-        inputs=[4],
-        devices=devices,
-    )
-
-    add_kernel_test(TestCodeGen, name="test_while_zero", kernel=test_while, dim=1, inputs=[0], devices=devices)
-    add_kernel_test(TestCodeGen, name="test_while_positive", kernel=test_while, dim=1, inputs=[16], devices=devices)
-    add_kernel_test(TestCodeGen, name="test_pass", kernel=test_pass, dim=1, inputs=[16], devices=devices)
 
-    add_kernel_test(TestCodeGen, name="test_break", kernel=test_break, dim=1, inputs=[10], devices=devices)
-    add_kernel_test(TestCodeGen, name="test_break_early", kernel=test_break_early, dim=1, inputs=[10], devices=devices)
-    add_kernel_test(
-        TestCodeGen, name="test_break_multiple", kernel=test_break_multiple, dim=1, inputs=[10], devices=devices
+def test_error_global_var(test, device):
+    arr = wp.array(
+        (1.0, 2.0, 3.0),
+        dtype=float,
+        device=device,
     )
-    add_kernel_test(TestCodeGen, name="test_continue", kernel=test_continue, dim=1, inputs=[10], devices=devices)
-
-    add_function_test(TestCodeGen, func=test_unresolved_func, name="test_unresolved_func", devices=devices)
-    add_function_test(TestCodeGen, func=test_unresolved_symbol, name="test_unresolved_symbol", devices=devices)
 
-    return TestCodeGen
+    def kernel_1_fn(
+        out: wp.array(dtype=float),
+    ):
+        out[0] = arr[0]
+
+    def kernel_2_fn(
+        out: wp.array(dtype=float),
+    ):
+        out[0] = arr
+
+    def kernel_3_fn(
+        out: wp.array(dtype=float),
+    ):
+        out[0] = wp.lower_bound(arr, 2.0)
+
+    out = wp.empty_like(arr)
+
+    kernel = wp.Kernel(func=kernel_1_fn)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"Cannot reference a global variable from a kernel unless `wp.constant\(\)` is being used",
+    ):
+        wp.launch(kernel, dim=out.shape, inputs=(), outputs=(out,))
+
+    kernel = wp.Kernel(func=kernel_2_fn)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"Cannot reference a global variable from a kernel unless `wp.constant\(\)` is being used",
+    ):
+        wp.launch(kernel, dim=out.shape, inputs=(), outputs=(out,))
+
+    kernel = wp.Kernel(func=kernel_3_fn)
+    with test.assertRaisesRegex(
+        RuntimeError,
+        r"Cannot reference a global variable from a kernel unless `wp.constant\(\)` is being used",
+    ):
+        wp.launch(kernel, dim=out.shape, inputs=(), outputs=(out,))
+
+
+class TestCodeGen(unittest.TestCase):
+    pass
+
+
+devices = get_test_devices()
+
+add_kernel_test(TestCodeGen, name="test_inplace", kernel=test_inplace, dim=1, devices=devices)
+add_kernel_test(TestCodeGen, name="test_rename", kernel=test_rename, dim=1, devices=devices)
+add_kernel_test(TestCodeGen, name="test_constant", kernel=test_constant, inputs=[1.0], dim=1, devices=devices)
+add_kernel_test(
+    TestCodeGen, name="test_dynamic_for_rename", kernel=test_dynamic_for_rename, inputs=[10], dim=1, devices=devices
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_dynamic_for_inplace",
+    kernel=test_dynamic_for_inplace,
+    inputs=[10],
+    dim=1,
+    devices=devices,
+)
+add_kernel_test(TestCodeGen, name="test_reassign", kernel=test_reassign, dim=1, devices=devices)
+add_kernel_test(
+    TestCodeGen, name="test_dynamic_reassign", kernel=test_dynamic_reassign, inputs=[2], dim=1, devices=devices
+)
+
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_dynamic_forward",
+    kernel=test_range_dynamic,
+    dim=1,
+    inputs=[0, 4, 1],
+    expect=[0, 1, 2, 3],
+    devices=devices,
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_dynamic_reverse",
+    kernel=test_range_dynamic,
+    dim=1,
+    inputs=[4, 0, -1],
+    expect=[4, 3, 2, 1],
+    devices=devices,
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_dynamic_forward_step",
+    kernel=test_range_dynamic,
+    dim=1,
+    inputs=[0, 8, 2],
+    expect=[0, 2, 4, 6],
+    devices=devices,
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_dynamic_reverse_step",
+    kernel=test_range_dynamic,
+    dim=1,
+    inputs=[8, 0, -2],
+    expect=[8, 6, 4, 2],
+    devices=devices,
+)
+
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_static_sum",
+    kernel=test_range_static_sum,
+    dim=1,
+    expect=[10, 10, 10],
+    devices=devices,
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_dynamic_sum",
+    kernel=test_range_dynamic_sum,
+    dim=1,
+    inputs=[0, 10, 2],
+    expect=[10, 10, 10, 10],
+    devices=devices,
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_dynamic_sum_zero",
+    kernel=test_range_dynamic_sum,
+    dim=1,
+    inputs=[0, 0, 1],
+    expect=[0, 0, 0, 0],
+    devices=devices,
+)
+add_kernel_test(TestCodeGen, name="test_range_constant", kernel=test_range_constant, dim=1, devices=devices)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_constant_dynamic_nested",
+    kernel=test_range_constant_dynamic_nested,
+    dim=1,
+    inputs=[10],
+    devices=devices,
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_dynamic_nested",
+    kernel=test_range_dynamic_nested,
+    dim=1,
+    inputs=[4],
+    devices=devices,
+)
+add_kernel_test(
+    TestCodeGen,
+    name="test_range_expression",
+    kernel=test_range_expression,
+    dim=1,
+    devices=devices,
+)
+
+add_kernel_test(TestCodeGen, name="test_while_zero", kernel=test_while, dim=1, inputs=[0], devices=devices)
+add_kernel_test(TestCodeGen, name="test_while_positive", kernel=test_while, dim=1, inputs=[16], devices=devices)
+add_kernel_test(TestCodeGen, name="test_pass", kernel=test_pass, dim=1, inputs=[16], devices=devices)
+
+add_kernel_test(TestCodeGen, name="test_break", kernel=test_break, dim=1, inputs=[10], devices=devices)
+add_kernel_test(TestCodeGen, name="test_break_early", kernel=test_break_early, dim=1, inputs=[10], devices=devices)
+add_kernel_test(TestCodeGen, name="test_break_unroll", kernel=test_break_unroll, dim=1, devices=devices)
+add_kernel_test(
+    TestCodeGen, name="test_break_multiple", kernel=test_break_multiple, dim=1, inputs=[10], devices=devices
+)
+add_kernel_test(TestCodeGen, name="test_continue", kernel=test_continue, dim=1, inputs=[10], devices=devices)
+add_kernel_test(TestCodeGen, name="test_continue_unroll", kernel=test_continue_unroll, dim=1, devices=devices)
+
+add_function_test(TestCodeGen, func=test_unresolved_func, name="test_unresolved_func", devices=devices)
+add_function_test(TestCodeGen, func=test_unresolved_symbol, name="test_unresolved_symbol", devices=devices)
+add_function_test(TestCodeGen, func=test_error_global_var, name="test_error_global_var", devices=devices)
 
 
 if __name__ == "__main__":
-    c = register(unittest.TestCase)
+    wp.build.clear_kernel_cache()
     unittest.main(verbosity=2, failfast=True)

warp/tests/test_compile_consts.py

@@ -5,14 +5,11 @@
 # distribution of this software and related documentation without an express
 # license agreement from NVIDIA CORPORATION is strictly prohibited.
 
-import os
-import sys
-
 import unittest
-from warp.tests.test_base import *
-import warp.tests.test_compile_consts_dummy
 
 import warp as wp
+import warp.tests.aux_test_compile_consts_dummy
+from warp.tests.unittest_utils import *
 
 wp.init()
 
@@ -20,6 +17,8 @@ LOCAL_ONE = wp.constant(1)
 
 SQRT3_OVER_3 = wp.constant(0.57735026919)
 UNIT_VEC = wp.constant(wp.vec3(SQRT3_OVER_3, SQRT3_OVER_3, SQRT3_OVER_3))
+ONE_FP16 = wp.constant(wp.float16(1.0))
+TEST_BOOL = wp.constant(True)
 
 
 class Foobar:
@@ -27,10 +26,18 @@ class Foobar:
     TWO = wp.constant(2)
 
 
+@wp.kernel
+def test_constants_bool():
+    if TEST_BOOL:
+        expect_eq(1.0, 1.0)
+    else:
+        expect_eq(1.0, -1.0)
+
+
 @wp.kernel
 def test_constants_int(a: int):
     if Foobar.ONE > 0:
-        a = 123 + Foobar.TWO + warp.tests.test_compile_consts_dummy.MINUS_ONE
+        a = 123 + Foobar.TWO + warp.tests.aux_test_compile_consts_dummy.MINUS_ONE
     else:
         a = 456 + LOCAL_ONE
     expect_eq(a, 124)
@@ -45,6 +52,9 @@ def test_constants_float(x: float):
     approx_one = wp.dot(UNIT_VEC, UNIT_VEC)
     expect_near(approx_one, 1.0, 1e-6)
 
+    # test casting
+    expect_near(wp.float32(ONE_FP16), 1.0, 1e-6)
+
 
 def test_constant_math(test, device):
     # test doing math with Python defined constants in *Python* scope
@@ -60,8 +70,7 @@ def test_constant_closure_capture(test, device):
         def closure_kernel_fn(expected: int):
             wp.expect_eq(cst, expected)
 
-        key = f"test_constant_closure_capture_{cst}"
-        return wp.Kernel(func=closure_kernel_fn, key=key, module=wp.get_module(closure_kernel_fn.__module__))
+        return wp.Kernel(func=closure_kernel_fn)
 
     one_closure = make_closure_kernel(Foobar.ONE)
     two_closure = make_closure_kernel(Foobar.TWO)
@@ -70,24 +79,23 @@ def test_constant_closure_capture(test, device):
     wp.launch(two_closure, dim=(1), inputs=[2], device=device)
 
 
-def register(parent):
-    class TestConstants(parent):
-        pass
+class TestConstants(unittest.TestCase):
+    pass
 
-    a = 0
-    x = 0.0
 
-    devices = get_test_devices()
+a = 0
+x = 0.0
 
-    add_kernel_test(TestConstants, test_constants_int, dim=1, inputs=[a], devices=devices)
-    add_kernel_test(TestConstants, test_constants_float, dim=1, inputs=[x], devices=devices)
+devices = get_test_devices()
 
-    add_function_test(TestConstants, "test_constant_math", test_constant_math, devices=devices)
-    add_function_test(TestConstants, "test_constant_closure_capture", test_constant_closure_capture, devices=devices)
+add_kernel_test(TestConstants, test_constants_bool, dim=1, inputs=[], devices=devices)
+add_kernel_test(TestConstants, test_constants_int, dim=1, inputs=[a], devices=devices)
+add_kernel_test(TestConstants, test_constants_float, dim=1, inputs=[x], devices=devices)
 
-    return TestConstants
+add_function_test(TestConstants, "test_constant_math", test_constant_math, devices=devices)
+add_function_test(TestConstants, "test_constant_closure_capture", test_constant_closure_capture, devices=devices)
 
 
 if __name__ == "__main__":
-    c = register(unittest.TestCase)
+    wp.build.clear_kernel_cache()
     unittest.main(verbosity=2)

warp/tests/test_conditional.py

@@ -5,17 +5,10 @@
 # distribution of this software and related documentation without an express
 # license agreement from NVIDIA CORPORATION is strictly prohibited.
 
-# include parent path
-import os
-import sys
-import numpy as np
-import math
-import ctypes
+import unittest
 
 import warp as wp
-from warp.tests.test_base import *
-
-import unittest
+from warp.tests.unittest_utils import *
 
 wp.init()
 
@@ -138,25 +131,116 @@ def test_bool_param_conditional(foo: bool):
     wp.expect_eq(x, 123)
 
 
-def register(parent):
-    devices = get_test_devices()
+@wp.kernel
+def test_conditional_chain_basic():
+    x = -1
+
+    if 0 < x < 1:
+        success = False
+    else:
+        success = True
+    wp.expect_eq(success, True)
+
+
+@wp.kernel
+def test_conditional_chain_empty_range():
+    x = -1
+    y = 4
+
+    if -2 <= x <= 10 <= y:
+        success = False
+    else:
+        success = True
+    wp.expect_eq(success, True)
+
+
+@wp.kernel
+def test_conditional_chain_faker():
+    x = -1
+
+    # Not actually a chained inequality
+    if (-2 < x) < (1 > 0):
+        success = False
+    else:
+        success = True
+    wp.expect_eq(success, True)
+
+
+@wp.kernel
+def test_conditional_chain_and():
+    x = -1
+
+    if (-2 < x < 0) and (-1 <= x <= -1):
+        success = True
+    else:
+        success = False
+    wp.expect_eq(success, True)
+
+
+@wp.kernel
+def test_conditional_chain_eqs():
+    x = wp.int32(10)
+    y = 10
+    z = -10
+
+    if x == y != z:
+        success = True
+    else:
+        success = False
+    wp.expect_eq(success, True)
+
+
+@wp.kernel
+def test_conditional_chain_mixed():
+    x = 0
+
+    if x < 10 == 1:
+        success = False
+    else:
+        success = True
+    wp.expect_eq(success, True)
+
+
+def test_conditional_unequal_types(test: unittest.TestCase, device):
+    # The bad kernel must be in a separate module, otherwise the current module would fail to load
+    from warp.tests.aux_test_conditional_unequal_types_kernels import (
+        unequal_types_kernel,
+    )
+
+    with test.assertRaises(TypeError):
+        wp.launch(unequal_types_kernel, dim=(1,), inputs=[], device=device)
+
+    # remove all references to the bad module so that subsequent calls to wp.force_load()
+    # won't try to load it unless we explicitly re-import it again
+    del wp.context.user_modules["warp.tests.aux_test_conditional_unequal_types_kernels"]
+    del sys.modules["warp.tests.aux_test_conditional_unequal_types_kernels"]
+
+
+devices = get_test_devices()
+
 
-    class TestConditional(parent):
-        pass
+class TestConditional(unittest.TestCase):
+    pass
 
-    add_kernel_test(TestConditional, kernel=test_conditional_if_else, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_conditional_if_else_nested, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_boolean_and, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_boolean_or, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_boolean_compound, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_boolean_literal, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_int_logical_not, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_int_conditional_assign_overload, dim=1, devices=devices)
-    add_kernel_test(TestConditional, kernel=test_bool_param_conditional, dim=1, inputs=[True], devices=devices)
 
-    return TestConditional
+add_kernel_test(TestConditional, kernel=test_conditional_if_else, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_conditional_if_else_nested, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_boolean_and, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_boolean_or, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_boolean_compound, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_boolean_literal, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_int_logical_not, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_int_conditional_assign_overload, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_bool_param_conditional, dim=1, inputs=[True], devices=devices)
+add_kernel_test(TestConditional, kernel=test_conditional_chain_basic, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_conditional_chain_empty_range, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_conditional_chain_faker, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_conditional_chain_and, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_conditional_chain_eqs, dim=1, devices=devices)
+add_kernel_test(TestConditional, kernel=test_conditional_chain_mixed, dim=1, devices=devices)
+add_function_test(TestConditional, "test_conditional_unequal_types", test_conditional_unequal_types, devices=devices)
 
 
 if __name__ == "__main__":
-    c = register(unittest.TestCase)
+    wp.build.clear_kernel_cache()
     unittest.main(verbosity=2)