numba-cuda 0.19.0__py3-none-any.whl → 0.20.0__py3-none-any.whl

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

@@ -1,10 +1,274 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import functools
+import warnings
 import numpy as np
 import unittest
 
-from numba import config, cuda, types
+from numba import cuda, types, njit, typeof
+from numba.cuda import config
+from numba.np import numpy_support
 from numba.cuda.tests.support import TestCase
-from numba.tests.test_ufuncs import BasicUFuncTest
+from numba.cuda.tests.support import MemoryLeakMixin
+
+
+class BaseUFuncTest(MemoryLeakMixin):
+    def setUp(self):
+        super(BaseUFuncTest, self).setUp()
+        self.inputs = [
+            (np.uint32(0), types.uint32),
+            (np.uint32(1), types.uint32),
+            (np.int32(-1), types.int32),
+            (np.int32(0), types.int32),
+            (np.int32(1), types.int32),
+            (np.uint64(0), types.uint64),
+            (np.uint64(1), types.uint64),
+            (np.int64(-1), types.int64),
+            (np.int64(0), types.int64),
+            (np.int64(1), types.int64),
+            (np.float32(-0.5), types.float32),
+            (np.float32(0.0), types.float32),
+            (np.float32(0.5), types.float32),
+            (np.float64(-0.5), types.float64),
+            (np.float64(0.0), types.float64),
+            (np.float64(0.5), types.float64),
+            (np.array([0, 1], dtype="u4"), types.Array(types.uint32, 1, "C")),
+            (np.array([0, 1], dtype="u8"), types.Array(types.uint64, 1, "C")),
+            (
+                np.array([-1, 0, 1], dtype="i4"),
+                types.Array(types.int32, 1, "C"),
+            ),
+            (
+                np.array([-1, 0, 1], dtype="i8"),
+                types.Array(types.int64, 1, "C"),
+            ),
+            (
+                np.array([-0.5, 0.0, 0.5], dtype="f4"),
+                types.Array(types.float32, 1, "C"),
+            ),
+            (
+                np.array([-0.5, 0.0, 0.5], dtype="f8"),
+                types.Array(types.float64, 1, "C"),
+            ),
+            (np.array([0, 1], dtype=np.int8), types.Array(types.int8, 1, "C")),
+            (
+                np.array([0, 1], dtype=np.int16),
+                types.Array(types.int16, 1, "C"),
+            ),
+            (
+                np.array([0, 1], dtype=np.uint8),
+                types.Array(types.uint8, 1, "C"),
+            ),
+            (
+                np.array([0, 1], dtype=np.uint16),
+                types.Array(types.uint16, 1, "C"),
+            ),
+        ]
+
+    @functools.lru_cache(maxsize=None)
+    def _compile(self, pyfunc, args, nrt=False):
+        # NOTE: to test the implementation of Numpy ufuncs, we disable
+        # rewriting of array expressions.
+        return njit(args, _nrt=nrt, no_rewrites=True)(pyfunc)
+
+    def _determine_output_type(
+        self, input_type, int_output_type=None, float_output_type=None
+    ):
+        ty = input_type
+        if isinstance(ty, types.Array):
+            ndim = ty.ndim
+            ty = ty.dtype
+        else:
+            ndim = 1
+
+        if ty in types.signed_domain:
+            if int_output_type:
+                output_type = types.Array(int_output_type, ndim, "C")
+            else:
+                output_type = types.Array(ty, ndim, "C")
+        elif ty in types.unsigned_domain:
+            if int_output_type:
+                output_type = types.Array(int_output_type, ndim, "C")
+            else:
+                output_type = types.Array(ty, ndim, "C")
+        else:
+            if float_output_type:
+                output_type = types.Array(float_output_type, ndim, "C")
+            else:
+                output_type = types.Array(ty, ndim, "C")
+        return output_type
+
+
+class BasicUFuncTest(BaseUFuncTest):
+    def _make_ufunc_usecase(self, ufunc):
+        return _make_ufunc_usecase(ufunc)
+
+    def basic_ufunc_test(
+        self,
+        ufunc,
+        skip_inputs=[],
+        additional_inputs=[],
+        int_output_type=None,
+        float_output_type=None,
+        kinds="ifc",
+        positive_only=False,
+    ):
+        # Necessary to avoid some Numpy warnings being silenced, despite
+        # the simplefilter() call below.
+        self.reset_module_warnings(__name__)
+
+        pyfunc = self._make_ufunc_usecase(ufunc)
+
+        inputs = list(self.inputs) + additional_inputs
+
+        for input_tuple in inputs:
+            input_operand = input_tuple[0]
+            input_type = input_tuple[1]
+
+            is_tuple = isinstance(input_operand, tuple)
+            if is_tuple:
+                args = input_operand
+            else:
+                args = (input_operand,) * ufunc.nin
+
+            if input_type in skip_inputs:
+                continue
+            if positive_only and np.any(args[0] < 0):
+                continue
+
+            # Some ufuncs don't allow all kinds of arguments
+            if args[0].dtype.kind not in kinds:
+                continue
+
+            output_type = self._determine_output_type(
+                input_type, int_output_type, float_output_type
+            )
+
+            input_types = (input_type,) * ufunc.nin
+            output_types = (output_type,) * ufunc.nout
+            argtys = input_types + output_types
+            cfunc = self._compile(pyfunc, argtys)
+
+            if isinstance(args[0], np.ndarray):
+                results = [
+                    np.zeros(args[0].shape, dtype=out_ty.dtype.name)
+                    for out_ty in output_types
+                ]
+                expected = [
+                    np.zeros(args[0].shape, dtype=out_ty.dtype.name)
+                    for out_ty in output_types
+                ]
+            else:
+                results = [
+                    np.zeros(1, dtype=out_ty.dtype.name)
+                    for out_ty in output_types
+                ]
+                expected = [
+                    np.zeros(1, dtype=out_ty.dtype.name)
+                    for out_ty in output_types
+                ]
+
+            invalid_flag = False
+            with warnings.catch_warnings(record=True) as warnlist:
+                warnings.simplefilter("always")
+                pyfunc(*args, *expected)
+
+                warnmsg = "invalid value encountered"
+                for thiswarn in warnlist:
+                    if issubclass(thiswarn.category, RuntimeWarning) and str(
+                        thiswarn.message
+                    ).startswith(warnmsg):
+                        invalid_flag = True
+
+            cfunc(*args, *results)
+
+            for expected_i, result_i in zip(expected, results):
+                msg = "\n".join(
+                    [
+                        "ufunc '{0}' failed",
+                        "inputs ({1}):",
+                        "{2}",
+                        "got({3})",
+                        "{4}",
+                        "expected ({5}):",
+                        "{6}",
+                    ]
+                ).format(
+                    ufunc.__name__,
+                    input_type,
+                    input_operand,
+                    output_type,
+                    result_i,
+                    expected_i.dtype,
+                    expected_i,
+                )
+                try:
+                    np.testing.assert_array_almost_equal(
+                        expected_i, result_i, decimal=5, err_msg=msg
+                    )
+                except AssertionError:
+                    if invalid_flag:
+                        # Allow output to mismatch for invalid input
+                        print(
+                            "Output mismatch for invalid input",
+                            input_tuple,
+                            result_i,
+                            expected_i,
+                        )
+                    else:
+                        raise
+
+    def signed_unsigned_cmp_test(self, comparison_ufunc):
+        self.basic_ufunc_test(comparison_ufunc)
+
+        if numpy_support.numpy_version < (1, 25):
+            return
+
+        # Test additional implementations that specifically handle signed /
+        # unsigned comparisons added in NumPy 1.25:
+        # https://github.com/numpy/numpy/pull/23713
+        additional_inputs = (
+            (np.int64(-1), np.uint64(0)),
+            (np.int64(-1), np.uint64(1)),
+            (np.int64(0), np.uint64(0)),
+            (np.int64(0), np.uint64(1)),
+            (np.int64(1), np.uint64(0)),
+            (np.int64(1), np.uint64(1)),
+            (np.uint64(0), np.int64(-1)),
+            (np.uint64(0), np.int64(0)),
+            (np.uint64(0), np.int64(1)),
+            (np.uint64(1), np.int64(-1)),
+            (np.uint64(1), np.int64(0)),
+            (np.uint64(1), np.int64(1)),
+            (
+                np.array([-1, -1, 0, 0, 1, 1], dtype=np.int64),
+                np.array([0, 1, 0, 1, 0, 1], dtype=np.uint64),
+            ),
+            (
+                np.array([0, 1, 0, 1, 0, 1], dtype=np.uint64),
+                np.array([-1, -1, 0, 0, 1, 1], dtype=np.int64),
+            ),
+        )
+
+        pyfunc = self._make_ufunc_usecase(comparison_ufunc)
+
+        for a, b in additional_inputs:
+            input_types = (typeof(a), typeof(b))
+            output_type = types.Array(types.bool_, 1, "C")
+            argtys = input_types + (output_type,)
+            cfunc = self._compile(pyfunc, argtys)
+
+            if isinstance(a, np.ndarray):
+                result = np.zeros(a.shape, dtype=np.bool_)
+            else:
+                result = np.zeros(1, dtype=np.bool_)
+
+            expected = np.zeros_like(result)
+
+            pyfunc(a, b, expected)
+            cfunc(a, b, result)
+            np.testing.assert_equal(expected, result)
 
 
 def _make_ufunc_usecase(ufunc):

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

@@ -1,6 +1,9 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from numba.cuda.testing import unittest, CUDATestCase
 from numba import cuda
-from numba.core import config
+from numba.cuda.core import config
 
 
 class MyError(Exception):

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

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 """
 CUDA vector type tests. Note that this test file imports
 `cuda.vector_type` module to programmatically test all the
@@ -8,7 +11,7 @@ corresponding vector type from `cuda` module in kernel to use them.
 
 import numpy as np
 
-from numba.core import config
+from numba.cuda.core import config
 from numba.cuda.testing import CUDATestCase
 
 from numba import cuda

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

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import numpy as np
 
 from collections import namedtuple

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

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import numpy as np
 from numba import vectorize
 from numba.cuda.testing import skip_on_cudasim, CUDATestCase

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

@@ -1,15 +1,124 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import numpy as np
+import math
 
-from numba import vectorize, cuda
-from numba.tests.npyufunc.test_vectorize_decor import (
-    BaseVectorizeDecor,
-    BaseVectorizeNopythonArg,
-    BaseVectorizeUnrecognizedArg,
-)
+from numba import vectorize, cuda, int32, uint32, float32, float64
 from numba.cuda.testing import skip_on_cudasim, CUDATestCase
+from numba.cuda.tests.support import CheckWarningsMixin
+
 import unittest
 
 
+pi = math.pi
+
+
+def sinc(x):
+    if x == 0.0:
+        return 1.0
+    else:
+        return math.sin(x * pi) / (pi * x)
+
+
+def scaled_sinc(x, scale):
+    if x == 0.0:
+        return scale
+    else:
+        return scale * (math.sin(x * pi) / (pi * x))
+
+
+def vector_add(a, b):
+    return a + b
+
+
+class BaseVectorizeDecor(object):
+    target = None
+    wrapper = None
+    funcs = {
+        "func1": sinc,
+        "func2": scaled_sinc,
+        "func3": vector_add,
+    }
+
+    @classmethod
+    def _run_and_compare(cls, func, sig, A, *args, **kwargs):
+        if cls.wrapper is not None:
+            func = cls.wrapper(func)
+        numba_func = vectorize(sig, target=cls.target)(func)
+        numpy_func = np.vectorize(func)
+        result = numba_func(A, *args)
+        gold = numpy_func(A, *args)
+        np.testing.assert_allclose(result, gold, **kwargs)
+
+    def test_1(self):
+        sig = ["float64(float64)", "float32(float32)"]
+        func = self.funcs["func1"]
+        A = np.arange(100, dtype=np.float64)
+        self._run_and_compare(func, sig, A)
+
+    def test_2(self):
+        sig = [float64(float64), float32(float32)]
+        func = self.funcs["func1"]
+        A = np.arange(100, dtype=np.float64)
+        self._run_and_compare(func, sig, A)
+
+    def test_3(self):
+        sig = ["float64(float64, uint32)"]
+        func = self.funcs["func2"]
+        A = np.arange(100, dtype=np.float64)
+        scale = np.uint32(3)
+        self._run_and_compare(func, sig, A, scale, atol=1e-8)
+
+    def test_4(self):
+        sig = [
+            int32(int32, int32),
+            uint32(uint32, uint32),
+            float32(float32, float32),
+            float64(float64, float64),
+        ]
+        func = self.funcs["func3"]
+        A = np.arange(100, dtype=np.float64)
+        self._run_and_compare(func, sig, A, A)
+        A = A.astype(np.float32)
+        self._run_and_compare(func, sig, A, A)
+        A = A.astype(np.int32)
+        self._run_and_compare(func, sig, A, A)
+        A = A.astype(np.uint32)
+        self._run_and_compare(func, sig, A, A)
+
+
+class BaseVectorizeNopythonArg(unittest.TestCase, CheckWarningsMixin):
+    """
+    Test passing the nopython argument to the vectorize decorator.
+    """
+
+    def _test_target_nopython(self, target, warnings, with_sig=True):
+        a = np.array([2.0], dtype=np.float32)
+        b = np.array([3.0], dtype=np.float32)
+        sig = [float32(float32, float32)]
+        args = with_sig and [sig] or []
+        with self.check_warnings(warnings):
+            f = vectorize(*args, target=target, nopython=True)(vector_add)
+            f(a, b)
+
+
+class BaseVectorizeUnrecognizedArg(unittest.TestCase, CheckWarningsMixin):
+    """
+    Test passing an unrecognized argument to the vectorize decorator.
+    """
+
+    def _test_target_unrecognized_arg(self, target, with_sig=True):
+        a = np.array([2.0], dtype=np.float32)
+        b = np.array([3.0], dtype=np.float32)
+        sig = [float32(float32, float32)]
+        args = with_sig and [sig] or []
+        with self.assertRaises(KeyError) as raises:
+            f = vectorize(*args, target=target, nonexistent=2)(vector_add)
+            f(a, b)
+        self.assertIn("Unrecognized options", str(raises.exception))
+
+
 @skip_on_cudasim("ufunc API unsupported in the simulator")
 class TestVectorizeDecor(CUDATestCase, BaseVectorizeDecor):
     """

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

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from numba import vectorize
 from numba import cuda, float32
 import numpy as np

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

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import numpy as np
 from numba import vectorize
 from numba import cuda, float64

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

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import numpy as np
 from numba import cuda
 from numba.cuda.cudadrv import driver
@@ -12,7 +15,7 @@ from numba.cuda.tests.support import (
     run_in_subprocess,
 )
 from numba.core.errors import NumbaPerformanceWarning
-from numba.core import config
+from numba.cuda.core import config
 import warnings
 
 

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

@@ -1,10 +1,13 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import re
 
 import numpy as np
 from numba import cuda, int32, int64, float32, float64
 from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
 from numba.cuda.compiler import compile_ptx
-from numba.core import config
+from numba.cuda.core import config
 
 
 def useful_syncwarp(ary):

numba_cuda/numba/cuda/tests/cudasim/__init__.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from numba.cuda.tests import load_testsuite
 import os
 

numba_cuda/numba/cuda/tests/cudasim/support.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from numba import cuda
 
 

numba_cuda/numba/cuda/tests/cudasim/test_cudasim_issues.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import threading
 
 import numpy as np

numba_cuda/numba/cuda/tests/data/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause

numba_cuda/numba/cuda/tests/data/cta_barrier.cu

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
 #include <cooperative_groups.h>
 #include <cuda/barrier>
 

numba_cuda/numba/cuda/tests/data/cuda_include.cu

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
 // Not all CUDA includes are safe to include in device code compiled by NVRTC,
 // because it does not have paths to all system include directories. Headers
 // such as cuda_device_runtime_api.h are safe to use in NVRTC without adding

numba_cuda/numba/cuda/tests/data/error.cu

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
 extern "C" __device__
 int bar(int* out, int a) {
   // Explicitly placed to generate an error

numba_cuda/numba/cuda/tests/data/include/add.cuh

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
 // Templated addition function: myadd
 template <typename T>
 __device__ T myadd(T a, T b) { return a + b; }

numba_cuda/numba/cuda/tests/data/jitlink.cu

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
 // Compile with:
 //
 //   nvcc -gencode arch=compute_50,code=compute_50 -rdc true -ptx jitlink.cu

numba_cuda/numba/cuda/tests/data/warn.cu

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
 extern "C" __device__
 int bar(int* out, int a) {
   // Explicitly placed to generate a warning for testing the NVRTC program log

numba_cuda/numba/cuda/tests/doc_examples/__init__.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 from numba.cuda.tests import load_testsuite
 import os
 

numba_cuda/numba/cuda/tests/doc_examples/ffi/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause

numba_cuda/numba/cuda/tests/doc_examples/ffi/functions.cu

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
 // magictoken.ex_mul_f32_f32.begin
 // Foreign function example: multiplication of a pair of floats
 

numba_cuda/numba/cuda/tests/doc_examples/ffi/include/mul.cuh

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
 // Templated multiplication function: mymul
 template <typename T>
 __device__ T mymul(T a, T b) { return a * b; }

numba_cuda/numba/cuda/tests/doc_examples/ffi/saxpy.cu

@@ -1,3 +1,8 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
 #include <add.cuh> // In numba/cuda/tests/data/include
 #include <mul.cuh> // In numba/cuda/tests/doc_examples/ffi/include
 

numba_cuda/numba/cuda/tests/doc_examples/test_cg.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 # Contents in this file are referenced from the sphinx-generated docs.
 # "magictoken" is used for markers as beginning and ending of example text.
 
@@ -7,13 +10,11 @@ from numba.cuda.testing import (
     skip_on_cudasim,
     skip_if_cudadevrt_missing,
     skip_unless_cc_60,
-    skip_if_mvc_enabled,
 )
 
 
 @skip_if_cudadevrt_missing
 @skip_unless_cc_60
-@skip_if_mvc_enabled("CG not supported with MVC")
 @skip_on_cudasim("cudasim doesn't support cuda import at non-top-level")
 class TestCooperativeGroups(CUDATestCase):
     def test_ex_grid_sync(self):

numba_cuda/numba/cuda/tests/doc_examples/test_cpointer.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import unittest
 
 from numba.cuda.testing import CUDATestCase, skip_on_cudasim

numba_cuda/numba/cuda/tests/doc_examples/test_cpu_gpu_compat.py

@@ -1,3 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
 import unittest
 
 from numba.cuda.testing import CUDATestCase, skip_on_cudasim