Refactor TestCase subclasses to directly inherit from unittest.TestCase

numba_cuda/numba/cuda/testing.py

@@ -12,7 +12,6 @@
 from numba.cuda.cudadrv import driver, devices, libs
 from numba.cuda.dispatcher import CUDADispatcher
 from numba.cuda import config
-from numba.cuda.tests.support import TestCase
 from pathlib import Path
 
 from typing import Iterable, Union
@@ -32,7 +31,7 @@
 
 
 @pytest.mark.usefixtures("initialize_from_pytest_config")
-class CUDATestCase(TestCase):
+class CUDATestCase(unittest.TestCase):
     """
     For tests that use a CUDA device.
 

numba_cuda/numba/cuda/tests/core/test_serialize.py

@@ -18,13 +18,13 @@
     from numba.core.target_extension import resolve_dispatcher_from_str
 else:
     from numba.cuda.core.errors import TypingError
-from numba.cuda.tests.support import TestCase
 from numba.cuda.cloudpickle import dumps, loads
 from numba.cuda.testing import skip_on_standalone_numba_cuda
+from numba.cuda.tests.support import assertPreciseEqual
 
 
 @skip_on_standalone_numba_cuda
-class TestDispatcherPickling(TestCase):
+class TestDispatcherPickling(unittest.TestCase):
     def run_with_protocols(self, meth, *args, **kwargs):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             meth(proto, *args, **kwargs)
@@ -50,7 +50,7 @@ def check_result(func):
             ):
                 self.assertRaises(expected_result, func, *args)
             else:
-                self.assertPreciseEqual(func(*args), expected_result)
+                assertPreciseEqual(func(*args), expected_result)
 
         # Control
         check_result(func)
@@ -234,7 +234,7 @@ def foo(x):
         subprocess.check_call([sys.executable, "-c", code])
 
 
-class TestSerializationMisc(TestCase):
+class TestSerializationMisc(unittest.TestCase):
     def test_numba_unpickle(self):
         # Test that _numba_unpickle is memorizing its output
         from numba.cuda.serialize import _numba_unpickle
@@ -251,7 +251,7 @@ def test_numba_unpickle(self):
         self.assertIs(got1, got2)
 
 
-class TestCloudPickleIssues(TestCase):
+class TestCloudPickleIssues(unittest.TestCase):
     """This test case includes issues specific to the cloudpickle implementation."""
 
     _numba_parallel_test_ = False

numba_cuda/numba/cuda/tests/cudadrv/test_array_attr.py

@@ -4,6 +4,7 @@
 import numpy as np
 from numba import cuda
 from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
+from numba.cuda.tests.support import assertPreciseEqual
 
 
 class TestArrayAttr(CUDATestCase):
@@ -52,7 +53,7 @@ def test_ravel_1d(self):
             flat = dflat.copy_to_host()
             self.assertTrue(dary is not dflat)  # ravel returns new array
             self.assertEqual(flat.ndim, 1)
-            self.assertPreciseEqual(expect, flat)
+            assertPreciseEqual(expect, flat)
 
     @skip_on_cudasim("CUDA Array Interface is not supported in the simulator")
     def test_ravel_stride_1d(self):
@@ -77,7 +78,7 @@ def test_ravel_c(self):
         flat = dflat.copy_to_host()
         self.assertTrue(dary is not dflat)
         self.assertEqual(flat.ndim, 1)
-        self.assertPreciseEqual(expect, flat)
+        assertPreciseEqual(expect, flat)
 
         # explicit order kwarg
         for order in "CA":
@@ -87,7 +88,7 @@ def test_ravel_c(self):
             flat = dflat.copy_to_host()
             self.assertTrue(dary is not dflat)
             self.assertEqual(flat.ndim, 1)
-            self.assertPreciseEqual(expect, flat)
+            assertPreciseEqual(expect, flat)
 
     @skip_on_cudasim("CUDA Array Interface is not supported in the simulator")
     def test_ravel_stride_c(self):
@@ -112,7 +113,7 @@ def test_ravel_f(self):
             flat = dflat.copy_to_host()
             self.assertTrue(dary is not dflat)
             self.assertEqual(flat.ndim, 1)
-            self.assertPreciseEqual(expect, flat)
+            assertPreciseEqual(expect, flat)
 
     @skip_on_cudasim("CUDA Array Interface is not supported in the simulator")
     def test_ravel_stride_f(self):
@@ -132,15 +133,15 @@ def test_reshape_c(self):
         dary = cuda.to_device(ary)
         dary_reshaped = dary.reshape(2, 5)
         got = dary_reshaped.copy_to_host()
-        self.assertPreciseEqual(expect, got)
+        assertPreciseEqual(expect, got)
 
     def test_reshape_f(self):
         ary = np.arange(10)
         expect = ary.reshape(2, 5, order="F")
         dary = cuda.to_device(ary)
         dary_reshaped = dary.reshape(2, 5, order="F")
         got = dary_reshaped.copy_to_host()
-        self.assertPreciseEqual(expect, got)
+        assertPreciseEqual(expect, got)
 
 
 if __name__ == "__main__":

numba_cuda/numba/cuda/tests/cudapy/cache_usecases.py

@@ -3,6 +3,7 @@
 
 from numba import cuda
 from numba.cuda.testing import CUDATestCase
+from numba.cuda.tests.support import assertPreciseEqual
 import numpy as np
 import sys
 
@@ -214,14 +215,14 @@ class _TestModule(CUDATestCase):
     """
 
     def check_module(self, mod):
-        self.assertPreciseEqual(mod.add_usecase(2, 3), 6)
-        self.assertPreciseEqual(mod.outer_uncached(3, 2), 2)
-        self.assertPreciseEqual(mod.outer(3, 2), 2)
+        assertPreciseEqual(mod.add_usecase(2, 3), 6)
+        assertPreciseEqual(mod.outer_uncached(3, 2), 2)
+        assertPreciseEqual(mod.outer(3, 2), 2)
 
         packed_rec = mod.record_return_packed(mod.packed_arr, 1)
-        self.assertPreciseEqual(tuple(packed_rec), (2, 43.5))
+        assertPreciseEqual(tuple(packed_rec), (2, 43.5))
         aligned_rec = mod.record_return_aligned(mod.aligned_arr, 1)
-        self.assertPreciseEqual(tuple(aligned_rec), (2, 43.5))
+        assertPreciseEqual(tuple(aligned_rec), (2, 43.5))
 
         mod.simple_usecase_caller(2)
 

numba_cuda/numba/cuda/tests/cudapy/cache_with_cpu_usecases.py

@@ -7,6 +7,7 @@
 from numba.cuda import HAS_NUMBA
 from numba.cuda.testing import CUDATestCase, skip_on_standalone_numba_cuda
 from numba.cuda.tests.cudapy.cache_usecases import CUDAUseCase, UseCase
+from numba.cuda.tests.support import assertPreciseEqual
 
 
 class CPUUseCase(UseCase):
@@ -39,10 +40,10 @@ class _TestModule(CUDATestCase):
     """
 
     def check_module(self, mod):
-        self.assertPreciseEqual(mod.assign_cpu(5), 5)
-        self.assertPreciseEqual(mod.assign_cpu(5.5), 5.5)
-        self.assertPreciseEqual(mod.assign_cuda(5), 5)
-        self.assertPreciseEqual(mod.assign_cuda(5.5), 5.5)
+        assertPreciseEqual(mod.assign_cpu(5), 5)
+        assertPreciseEqual(mod.assign_cpu(5.5), 5.5)
+        assertPreciseEqual(mod.assign_cuda(5), 5)
+        assertPreciseEqual(mod.assign_cuda(5.5), 5.5)
 
 
 def self_test():

numba_cuda/numba/cuda/tests/cudapy/test_analysis.py

@@ -17,7 +17,10 @@
 from numba.cuda.core import postproc, rewrites, ir_utils
 from numba.cuda.core.options import ParallelOptions
 from numba.cuda.core.inline_closurecall import InlineClosureCallPass
-from numba.cuda.tests.support import TestCase, override_config
+from numba.cuda.tests.support import (
+    assertPreciseEqual,
+    override_config,
+)
 from numba.cuda.core.analysis import (
     dead_branch_prune,
     rewrite_semantic_constants,
@@ -50,7 +53,7 @@ def compile_to_ir(func):
     return func_ir
 
 
-class TestBranchPruneBase(TestCase):
+class TestBranchPruneBase(unittest.TestCase):
     """
     Tests branch pruning
     """
@@ -159,7 +162,7 @@ def run_func(self, impl, args):
         cres.py_func(*args)
         with override_config("DISABLE_PERFORMANCE_WARNINGS", 1):
             cres[1, 1](*dargs)
-        self.assertPreciseEqual(out[0], cout[0])
+        assertPreciseEqual(out[0], cout[0])
 
 
 class TestBranchPrune(TestBranchPruneBase):

numba_cuda/numba/cuda/tests/cudapy/test_array.py

@@ -9,6 +9,7 @@
 from numba.cuda import config
 import pytest
 from numba.cuda.np.numpy_support import carray, farray
+from numba.cuda.tests.support import assertPreciseEqual
 
 
 if config.ENABLE_CUDASIM:
@@ -302,7 +303,7 @@ def check(pyfunc, kernelfunc, arr, shape):
             expected = pyfunc(arr, shape)
             got = np.zeros(expected.shape, dtype=arr.dtype)
             kernel[1, 1](arr, shape, got)
-            self.assertPreciseEqual(got, expected)
+            assertPreciseEqual(got, expected)
 
         def check_only_shape(kernelfunc, arr, shape, expected_shape):
             kernel = cuda.jit(kernelfunc)

numba_cuda/numba/cuda/tests/cudapy/test_array_reductions.py

@@ -1,16 +1,18 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: BSD-2-Clause
 import numpy as np
+import unittest
 
-from numba.cuda.tests.support import TestCase, MemoryLeakMixin
+from numba.cuda.tests.support import MemoryLeakMixin
 from numba import cuda
 from numba.cuda.testing import skip_on_cudasim, skip_on_nvjitlink_13_1_sm_120
 from numba.cuda.misc.special import literal_unroll
 from numba.cuda import config
+from numba.cuda.tests.support import assertPreciseEqual
 
 
 @skip_on_cudasim("doesn't work in the simulator")
-class TestArrayReductions(MemoryLeakMixin, TestCase):
+class TestArrayReductions(MemoryLeakMixin, unittest.TestCase):
     """
     Test array reduction methods and functions such as .sum(), .max(), etc.
     """
@@ -48,7 +50,7 @@ def kernel(out):
         out = cuda.to_device(np.zeros(len(cases), dtype=np.bool_))
         kernel[1, 1](out)
         got = out.copy_to_host()
-        self.assertPreciseEqual(expected, got)
+        assertPreciseEqual(expected, got)
 
     def test_any_basic(self):
         cases = (
@@ -70,7 +72,7 @@ def kernel(out):
         expected = np.array([np.any(a) for a in cases], dtype=np.bool_)
         out = cuda.to_device(np.zeros(len(cases), dtype=np.bool_))
         kernel[1, 1](out)
-        self.assertPreciseEqual(expected, out.copy_to_host())
+        assertPreciseEqual(expected, out.copy_to_host())
 
     @skip_on_nvjitlink_13_1_sm_120(
         "sum fails at link time on sm_120 + CUDA 13.1"
@@ -100,7 +102,7 @@ def kernel(out):
         expected = np.array([np.sum(a) for a in arrays], dtype=np.float64)
         out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
         kernel[1, 1](out)
-        self.assertPreciseEqual(expected, out.copy_to_host())
+        assertPreciseEqual(expected, out.copy_to_host())
 
     @skip_on_nvjitlink_13_1_sm_120(
         "mean fails at link time on sm_120 + CUDA 13.1"
@@ -130,7 +132,7 @@ def kernel(out):
         expected = np.array([np.mean(a) for a in arrays], dtype=np.float64)
         out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
         kernel[1, 1](out)
-        self.assertPreciseEqual(expected, out.copy_to_host())
+        assertPreciseEqual(expected, out.copy_to_host())
 
     def test_var_basic(self):
         arrays = (
@@ -157,7 +159,7 @@ def kernel(out):
         expected = np.array([np.var(a) for a in arrays], dtype=np.float64)
         out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
         kernel[1, 1](out)
-        self.assertPreciseEqual(expected, out.copy_to_host(), prec="double")
+        assertPreciseEqual(expected, out.copy_to_host(), prec="double")
 
     def test_std_basic(self):
         arrays = (
@@ -184,7 +186,7 @@ def kernel(out):
         expected = np.array([np.std(a) for a in arrays], dtype=np.float64)
         out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
         kernel[1, 1](out)
-        self.assertPreciseEqual(expected, out.copy_to_host())
+        assertPreciseEqual(expected, out.copy_to_host())
 
     def test_min_basic(self):
         arrays = (
@@ -211,7 +213,7 @@ def kernel(out):
         expected = np.array([np.min(a) for a in arrays], dtype=np.float64)
         out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
         kernel[1, 1](out)
-        self.assertPreciseEqual(expected, out.copy_to_host())
+        assertPreciseEqual(expected, out.copy_to_host())
 
     def test_max_basic(self):
         arrays = (
@@ -238,7 +240,7 @@ def kernel(out):
         expected = np.array([np.max(a) for a in arrays], dtype=np.float64)
         out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
         kernel[1, 1](out)
-        self.assertPreciseEqual(expected, out.copy_to_host())
+        assertPreciseEqual(expected, out.copy_to_host())
 
     def test_nanmin_basic(self):
         arrays = (
@@ -263,7 +265,7 @@ def kernel(out):
         expected = np.array([np.nanmin(a) for a in arrays], dtype=np.float64)
         out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
         kernel[1, 1](out)
-        self.assertPreciseEqual(expected, out.copy_to_host())
+        assertPreciseEqual(expected, out.copy_to_host())
 
     def test_nanmax_basic(self):
         arrays = (
@@ -288,7 +290,7 @@ def kernel(out):
         expected = np.array([np.nanmax(a) for a in arrays], dtype=np.float64)
         out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
         kernel[1, 1](out)
-        self.assertPreciseEqual(expected, out.copy_to_host())
+        assertPreciseEqual(expected, out.copy_to_host())
 
     @skip_on_nvjitlink_13_1_sm_120(
         "nanmean fails at link time on sm_120 + CUDA 13.1"
@@ -316,7 +318,7 @@ def kernel(out):
         expected = np.array([np.nanmean(a) for a in arrays], dtype=np.float64)
         out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
         kernel[1, 1](out)
-        self.assertPreciseEqual(expected, out.copy_to_host())
+        assertPreciseEqual(expected, out.copy_to_host())
 
     @skip_on_nvjitlink_13_1_sm_120(
         "nansum fails at link time on sm_120 + CUDA 13.1"
@@ -344,7 +346,7 @@ def kernel(out):
         expected = np.array([np.nansum(a) for a in arrays], dtype=np.float64)
         out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
         kernel[1, 1](out)
-        self.assertPreciseEqual(expected, out.copy_to_host())
+        assertPreciseEqual(expected, out.copy_to_host())
 
     @skip_on_nvjitlink_13_1_sm_120(
         "nanprod fails at link time on sm_120 + CUDA 13.1"
@@ -372,7 +374,7 @@ def kernel(out):
         expected = np.array([np.nanprod(a) for a in arrays], dtype=np.float64)
         out = cuda.to_device(np.zeros(len(arrays), dtype=np.float64))
         kernel[1, 1](out)
-        self.assertPreciseEqual(expected, out.copy_to_host())
+        assertPreciseEqual(expected, out.copy_to_host())
 
     def test_count_nonzero_basic(self):
         cases = (
@@ -396,7 +398,7 @@ def kernel(out):
         expected = np.array([np.count_nonzero(a) for a in cases], dtype=np.intp)
         out = cuda.to_device(np.zeros(len(cases), dtype=np.intp))
         kernel[1, 1](out)
-        self.assertPreciseEqual(expected, out.copy_to_host())
+        assertPreciseEqual(expected, out.copy_to_host())
 
     def test_count_nonzero_bool(self):
         cases = (
@@ -415,7 +417,7 @@ def kernel(out):
         expected = np.array([np.count_nonzero(a) for a in cases], dtype=np.intp)
         out = cuda.to_device(np.zeros(len(cases), dtype=np.intp))
         kernel[1, 1](out)
-        self.assertPreciseEqual(expected, out.copy_to_host())
+        assertPreciseEqual(expected, out.copy_to_host())
 
     def test_count_nonzero_2d(self):
         cases = (
@@ -434,4 +436,4 @@ def kernel(out):
         expected = np.array([np.count_nonzero(a) for a in cases], dtype=np.intp)
         out = cuda.to_device(np.zeros(len(cases), dtype=np.intp))
         kernel[1, 1](out)
-        self.assertPreciseEqual(expected, out.copy_to_host())
+        assertPreciseEqual(expected, out.copy_to_host())

numba_cuda/numba/cuda/tests/cudapy/test_byteflow.py

@@ -7,11 +7,10 @@
 
 import unittest
 
-from numba.cuda.tests.support import TestCase
 from numba.cuda.compiler import run_frontend
 
 
-class TestByteFlowIssues(TestCase):
+class TestByteFlowIssues(unittest.TestCase):
     def test_issue_5087(self):
         # This is an odd issue. The exact number of print below is
         # necessary to trigger it. Too many or too few will alter the behavior.