update tests

Author: npolina4

dpnp/dpnp_iface_libmath.py

@@ -81,7 +81,7 @@ def erf(in_array1):
     x1_desc = dpnp.get_dpnp_descriptor(
         in_array1, copy_when_strides=False, copy_when_nondefault_queue=False
     )
-    if x1_desc and dpnp.is_cuda_backend(in_array1):
+    if x1_desc and not dpnp.is_cuda_backend(in_array1):
         return dpnp_erf(x1_desc).get_pyobj()
 
     result = create_output_descriptor_py(

dpnp/random/dpnp_random_state.py

@@ -82,8 +82,6 @@ def __init__(self, seed=None, device=None, sycl_queue=None):
             device=device, sycl_queue=sycl_queue
         )
 
-        dpnp.not_implemented_for_cuda_backend(self._sycl_queue)
-
         self._sycl_device = self._sycl_queue.sycl_device
 
         is_cpu = self._sycl_device.is_cpu

tests/skipped_tests_cuda.tbl

@@ -1,6 +1,7 @@
 import unittest
 
 import numpy
+import pytest
 
 from tests.helper import has_support_aspect64
 from tests.third_party.cupy import testing
@@ -9,6 +10,7 @@
 class TestArithmetic(unittest.TestCase):
     @testing.for_float_dtypes()
     @testing.numpy_cupy_allclose()
+    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_modf_part1(self, xp, dtype):
         a = xp.array([-2.5, -1.5, -0.5, 0, 0.5, 1.5, 2.5], dtype=dtype)
         b, _ = xp.modf(a)
@@ -17,6 +19,7 @@ def test_modf_part1(self, xp, dtype):
 
     @testing.for_float_dtypes()
     @testing.numpy_cupy_allclose()
+    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_modf_part2(self, xp, dtype):
         a = xp.array([-2.5, -1.5, -0.5, 0, 0.5, 1.5, 2.5], dtype=dtype)
         _, c = xp.modf(a)

tests/test_arithmetic.py

@@ -718,7 +718,7 @@ class TestTakeAlongAxis:
         ],
     )
     def test_argequivalent(self, func, argfunc, kwargs):
-        a = dpnp.random.random(size=(3, 4, 5))
+        a = dpnp.asarray(numpy.random.random(size=(3, 4, 5)))
 
         for axis in list(range(a.ndim)) + [None]:
             a_func = func(a, axis=axis, **kwargs)

tests/test_indexing.py

@@ -396,12 +396,15 @@ def test_elemwise_comparison(op, x1, x2, dtype):
     "sh2", [[12], [4, 8], [1, 8, 6]], ids=["(12,)", "(4, 8)", "(1, 8, 6)"]
 )
 def test_comparison_no_broadcast_with_shapes(op, sh1, sh2):
-    x1, x2 = dpnp.random.randn(*sh1), dpnp.random.randn(*sh2)
+    x1_np = numpy.random.randn(*sh1)
+    x2_np = numpy.random.randn(*sh2)
+    x1 = dpnp.asarray(x1_np)
+    x2 = dpnp.asarray(x2_np)
 
     # x1 OP x2
     with pytest.raises(ValueError):
         getattr(dpnp, op)(x1, x2)
-        getattr(numpy, op)(x1.asnumpy(), x2.asnumpy())
+        getattr(numpy, op)(x1_np, x2_np)
 
 
 @pytest.mark.parametrize(

tests/test_logic.py

@@ -45,6 +45,7 @@ def check_seed(self, dist_name, params):
         assert_allclose(a1, a2, rtol=1e-07, atol=0)
 
 
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 @pytest.mark.parametrize(
     "func",
     [dpnp.random.chisquare, dpnp.random.rand, dpnp.random.randn],
@@ -61,6 +62,7 @@ def test_input_size(func):
     assert output_shape == res.shape
 
 
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 @pytest.mark.parametrize(
     "func",
     [
@@ -82,6 +84,7 @@ def test_input_shape(func):
     assert shape == res.shape
 
 
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 @pytest.mark.parametrize(
     "func",
     [
@@ -104,6 +107,7 @@ def test_check_output(func):
     assert dpnp.all(res < 1)
 
 
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 @pytest.mark.parametrize(
     "func",
     [
@@ -130,6 +134,7 @@ def test_seed(func):
     assert_allclose(a1, a2, rtol=1e-07, atol=0)
 
 
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 def test_randn_normal_distribution():
     """
     Check the moments of the normal distribution sample obtained
@@ -667,6 +672,7 @@ def test_seed(self):
 
 
 @pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsNormal(TestDistribution):
     def test_extreme_value(self):
         loc = 5
@@ -827,11 +833,13 @@ def test_seed(self):
         self.check_seed("rayleigh", {"scale": scale})
 
 
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsStandardCauchy(TestDistribution):
     def test_seed(self):
         self.check_seed("standard_cauchy", {})
 
 
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsStandardExponential(TestDistribution):
     def test_moments(self):
         shape = 0.8
@@ -867,6 +875,7 @@ def test_seed(self):
         self.check_seed("standard_gamma", {"shape": 0.0})
 
 
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsStandardNormal(TestDistribution):
     def test_moments(self):
         expected_mean = 0.0
@@ -944,6 +953,7 @@ def test_seed(self):
 
 
 @pytest.mark.skipif(not has_support_aspect64(), reason="Failed on Iris Xe")
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestDistributionsUniform(TestDistribution):
     def test_extreme_value(self):
         low = 1.0
@@ -1070,6 +1080,7 @@ def test_seed(self):
         self.check_seed("zipf", {"a": a})
 
 
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestPermutationsTestShuffle:
     @pytest.mark.parametrize(
         "dtype",

tests/test_random.py

@@ -366,6 +366,7 @@ def test_complex(self, dtype):
         assert result.dtype == expected.dtype
 
 
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 @pytest.mark.parametrize("kth", [0, 1], ids=["0", "1"])
 @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
 @pytest.mark.parametrize(

tests/test_sort.py

@@ -18,6 +18,7 @@
 )
 
 
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 @pytest.mark.parametrize(
     "dtype", get_all_dtypes(no_none=True, no_bool=True, no_complex=True)
 )

tests/test_statistics.py

@@ -1190,6 +1190,7 @@ def test_out_2in_1out(func, data1, data2, device):
     assert_sycl_queue_equal(result.sycl_queue, x2.sycl_queue)
 
 
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 @pytest.mark.parametrize(
     "device",
     valid_devices,

tests/test_sycl_queue.py

@@ -11,24 +11,18 @@
 
 def _gen_array(dtype, alloc_q=None):
     if cupy.issubdtype(dtype, numpy.unsignedinteger):
-        array = cupy.random.randint(
-            0, 10, size=(2, 3), sycl_queue=alloc_q
-        ).astype(dtype)
+        array = numpy.random.randint(0, 10, size=(2, 3))
     elif cupy.issubdtype(dtype, cupy.integer):
-        array = cupy.random.randint(
-            -10, 10, size=(2, 3), sycl_queue=alloc_q
-        ).astype(dtype)
+        array = numpy.random.randint(-10, 10, size=(2, 3))
     elif cupy.issubdtype(dtype, cupy.floating):
-        array = cupy.random.rand(2, 3, sycl_queue=alloc_q).astype(dtype)
+        array = numpy.random.rand(2, 3)
     elif cupy.issubdtype(dtype, cupy.complexfloating):
-        array = cupy.random.random((2, 3), sycl_queue=alloc_q).astype(dtype)
+        array = numpy.random.random((2, 3))
     elif dtype == cupy.bool_:
-        array = cupy.random.randint(
-            0, 2, size=(2, 3), sycl_queue=alloc_q
-        ).astype(cupy.bool_)
+        array = numpy.random.randint(0, 2, size=(2, 3))
     else:
         assert False, f"unrecognized dtype: {dtype}"
-    return array
+    return cupy.asarray(array, sycl_queue=alloc_q).astype(dtype)
 
 
 class TestDLPackConversion(unittest.TestCase):

tests/third_party/cupy/core_tests/test_dlpack.py

@@ -205,6 +205,7 @@ def test_extract_empty_1dim(self, xp):
         return xp.extract(b, a)
 
 
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestChoose(unittest.TestCase):
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
@@ -213,39 +214,34 @@ def test_choose(self, xp, dtype):
         c = testing.shaped_arange((3, 4), xp, dtype)
         return a.choose(c)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
     def test_choose_broadcast(self, xp, dtype):
         a = xp.array([[1, 0, 1], [0, 1, 0], [1, 0, 1]])
         c = xp.array([-10, 10]).astype(dtype)
         return a.choose(c)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
     def test_choose_broadcast2(self, xp, dtype):
         a = xp.array([0, 1])
         c = testing.shaped_arange((3, 5, 2), xp, dtype)
         return a.choose(c)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
     def test_choose_wrap(self, xp, dtype):
         a = xp.array([0, 3, -1, 5])
         c = testing.shaped_arange((3, 4), xp, dtype)
         return a.choose(c, mode="wrap")
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.for_all_dtypes()
     @testing.numpy_cupy_array_equal()
     def test_choose_clip(self, xp, dtype):
         a = xp.array([0, 3, -1, 5])
         c = testing.shaped_arange((3, 4), xp, dtype)
         return a.choose(c, mode="clip")
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.with_requires("numpy>=1.19")
     def test_unknown_clip(self):
         for xp in (numpy, cupy):
@@ -254,14 +250,12 @@ def test_unknown_clip(self):
             with pytest.raises(ValueError):
                 a.choose(c, mode="unknown")
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_raise(self):
         a = cupy.array([2])
         c = cupy.array([[0, 1]])
         with self.assertRaises(ValueError):
             a.choose(c)
 
-    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @testing.for_all_dtypes()
     def test_choose_broadcast_fail(self, dtype):
         for xp in (numpy, cupy):

tests/third_party/cupy/indexing_tests/test_indexing.py

@@ -61,8 +61,12 @@ def test_solve(self):
 
     def check_shape(self, a_shape, b_shape, error_types):
         for xp, error_type in error_types.items():
-            a = xp.random.rand(*a_shape)
-            b = xp.random.rand(*b_shape)
+            if xp is cupy and cupy.is_cuda_backend():
+                a = xp.asarray(numpy.random.rand(*a_shape))
+                b = xp.asarray(numpy.random.rand(*b_shape))
+            else:
+                a = xp.random.rand(*a_shape)
+                b = xp.random.rand(*b_shape)
             with pytest.raises(error_type):
                 xp.linalg.solve(a, b)
 
@@ -137,7 +141,7 @@ def check_x(self, a_shape, dtype):
         testing.assert_array_equal(a_gpu_copy, a_gpu)
 
     def check_shape(self, a_shape):
-        a = cupy.random.rand(*a_shape)
+        a = cupy.asarray(numpy.random.rand(*a_shape))
         with self.assertRaises(cupy.linalg.LinAlgError):
             cupy.linalg.inv(a)
 
@@ -254,8 +258,8 @@ def check_lstsq_solution(
         return results
 
     def check_invalid_shapes(self, a_shape, b_shape):
-        a = cupy.random.rand(*a_shape)
-        b = cupy.random.rand(*b_shape)
+        a = cupy.asarray(numpy.random.rand(*a_shape))
+        b = cupy.asarray(numpy.random.rand(*b_shape))
         with pytest.raises(cupy.linalg.LinAlgError):
             cupy.linalg.lstsq(a, b, rcond=None)
 
@@ -330,12 +334,12 @@ def check_x(self, a_shape, ind, dtype):
         testing.assert_array_equal(a_gpu_copy, a_gpu)
 
     def check_shape(self, a_shape, ind):
-        a = cupy.random.rand(*a_shape)
+        a = cupy.asarray(numpy.random.rand(*a_shape))
         with self.assertRaises(cupy.linalg.LinAlgError):
             cupy.linalg.tensorinv(a, ind=ind)
 
     def check_ind(self, a_shape, ind):
-        a = cupy.random.rand(*a_shape)
+        a = cupy.asarray(numpy.random.rand(*a_shape))
         with self.assertRaises(ValueError):
             cupy.linalg.tensorinv(a, ind=ind)
 

tests/third_party/cupy/linalg_tests/test_solve.py

@@ -685,6 +685,7 @@ def test_casting_dtype_unsafe_ignore_warnings(
 class TestArithmeticModf:
     @testing.for_float_dtypes()
     @testing.numpy_cupy_allclose()
+    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_modf(self, xp, dtype):
         a = xp.array([-2.5, -1.5, -0.5, 0, 0.5, 1.5, 2.5], dtype=dtype)
         b, c = xp.modf(a)

tests/third_party/cupy/math_tests/test_arithmetic.py

@@ -599,6 +599,7 @@ def test_rayleigh_for_negative_scale(self, scale_dtype):
     )
 )
 class TestDistributionsStandardCauchy(RandomDistributionsTestCase):
+    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_standard_cauchy(self):
         self.check_distribution("standard_cauchy", {})
 
@@ -611,6 +612,7 @@ def test_standard_cauchy(self):
     )
 )
 class TestDistributionsStandardExponential(RandomDistributionsTestCase):
+    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_standard_exponential(self):
         self.check_distribution("standard_exponential", {})
 
@@ -639,6 +641,7 @@ def test_standard_gamma(self, shape_dtype):
     )
 )
 class TestDistributionsStandardNormal(RandomDistributionsTestCase):
+    @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     def test_standard_normal(self):
         self.check_distribution("standard_normal", {})
 

tests/third_party/cupy/random_tests/test_distributions.py

@@ -10,6 +10,7 @@
 from tests.third_party.cupy.testing import _condition, _hypothesis
 
 
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestRandint(unittest.TestCase):
     def test_lo_hi_reversed(self):
         with self.assertRaises(ValueError):
@@ -52,7 +53,7 @@ def test_bound_1(self):
     @pytest.mark.usefixtures("allow_fall_back_on_numpy")
     @_condition.repeat(3, 10)
     def test_bound_2(self):
-        vals = [random.randint(0, 2) for _ in range(20)]
+        vals = [random.randint(0, 2, ()) for _ in range(20)]
         for val in vals:
             self.assertEqual(val.shape, ())
         self.assertEqual(min(_.min() for _ in vals), 0)
@@ -106,6 +107,7 @@ def test_goodness_of_fit_2(self):
         self.assertTrue(_hypothesis.chi_square_test(counts, expected))
 
 
+@pytest.mark.usefixtures("allow_fall_back_on_numpy")
 class TestRandintDtype(unittest.TestCase):
     # numpy.int8, numpy.uint8, numpy.int16, numpy.uint16, numpy.int32])
     @testing.for_dtypes([numpy.int32])
@@ -131,11 +133,11 @@ def test_dtype2(self, dtype):
         self.assertLessEqual(max(x), iinfo.max)
 
         # Lower bound check
-        with self.assertRaises(OverflowError):
+        with self.assertRaises((OverflowError, ValueError)):
             random.randint(iinfo.min - 1, iinfo.min + 10, size, dtype)
 
         # Upper bound check
-        with self.assertRaises(OverflowError):
+        with self.assertRaises((OverflowError, ValueError)):
             random.randint(iinfo.max - 10, iinfo.max + 2, size, dtype)