diff --git a/dpnp/dpnp_iface.py b/dpnp/dpnp_iface.py index 46dc8f2353c..a8aa5237f27 100644 --- a/dpnp/dpnp_iface.py +++ b/dpnp/dpnp_iface.py @@ -68,6 +68,7 @@ "get_normalized_queue_device", "get_result_array", "get_usm_ndarray", + "is_cuda_backend", "get_usm_ndarray_or_scalar", "is_supported_array_or_scalar", "is_supported_array_type", @@ -736,6 +737,40 @@ def get_usm_ndarray_or_scalar(a): return a if dpnp.isscalar(a) else get_usm_ndarray(a) +def is_cuda_backend(obj=None): + """ + Checks that object has a CUDA backend. + + Parameters + ---------- + obj : {Device, SyclDevice, SyclQueue, dpnp.ndarray, usm_ndarray, None}, + optional + An input object with sycl_device property to check device backend. + If `obj` is ``None``, device backend will be checked for the default + queue. + Default: ``None``. + + Returns + ------- + out : bool + Return ``True`` if object has a CUDA backend, otherwise ``False``. + + """ + + if obj is None: + sycl_device = dpctl.select_default_device() + elif isinstance(obj, dpctl.SyclDevice): + sycl_device = obj + else: + sycl_device = getattr(obj, "sycl_device", None) + if ( + sycl_device is not None + and sycl_device.backend == dpctl.backend_type.cuda + ): + return True + return False + + def is_supported_array_or_scalar(a): """ Return ``True`` if `a` is a scalar or an array of either diff --git a/dpnp/dpnp_iface_indexing.py b/dpnp/dpnp_iface_indexing.py index 21ec32f2400..a8656006be2 100644 --- a/dpnp/dpnp_iface_indexing.py +++ b/dpnp/dpnp_iface_indexing.py @@ -127,6 +127,7 @@ def choose(x1, choices, out=None, mode="raise"): :obj:`dpnp.take_along_axis` : Preferable if choices is an array. """ + x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False) choices_list = [] @@ -136,6 +137,11 @@ def choose(x1, choices, out=None, mode="raise"): ) if x1_desc: + if dpnp.is_cuda_backend(x1_desc.get_array()): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + if any(not desc for desc in choices_list): pass elif out is not None: diff --git a/dpnp/dpnp_iface_libmath.py b/dpnp/dpnp_iface_libmath.py index 82b86f3b9c5..6889cab5fc2 100644 --- a/dpnp/dpnp_iface_libmath.py +++ b/dpnp/dpnp_iface_libmath.py @@ -82,6 +82,10 @@ def erf(in_array1): in_array1, copy_when_strides=False, copy_when_nondefault_queue=False ) if x1_desc: + if dpnp.is_cuda_backend(x1_desc.get_array()): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) return dpnp_erf(x1_desc).get_pyobj() result = create_output_descriptor_py( diff --git a/dpnp/dpnp_iface_mathematical.py b/dpnp/dpnp_iface_mathematical.py index 073de3d8996..67261896053 100644 --- a/dpnp/dpnp_iface_mathematical.py +++ b/dpnp/dpnp_iface_mathematical.py @@ -2949,8 +2949,14 @@ def modf(x1, **kwargs): """ x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False) - if x1_desc and not kwargs: - return dpnp_modf(x1_desc) + if x1_desc: + if dpnp.is_cuda_backend(x1_desc.get_array()): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + + if not kwargs: + return dpnp_modf(x1_desc) return call_origin(numpy.modf, x1, **kwargs) diff --git a/dpnp/dpnp_iface_sorting.py b/dpnp/dpnp_iface_sorting.py index 640f17da55b..9ca48e34764 100644 --- a/dpnp/dpnp_iface_sorting.py +++ b/dpnp/dpnp_iface_sorting.py @@ -187,6 +187,11 @@ def partition(x1, kth, axis=-1, kind="introselect", order=None): x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False) if x1_desc: + if dpnp.is_cuda_backend(x1_desc.get_array()): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + if not isinstance(kth, int): pass elif x1_desc.ndim == 0: diff --git a/dpnp/dpnp_iface_statistics.py b/dpnp/dpnp_iface_statistics.py index c266f7c397e..d64f616da8e 100644 --- a/dpnp/dpnp_iface_statistics.py +++ b/dpnp/dpnp_iface_statistics.py @@ -484,6 +484,13 @@ def correlate(x1, x2, mode="valid"): x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False) x2_desc = dpnp.get_dpnp_descriptor(x2, copy_when_nondefault_queue=False) if x1_desc and x2_desc: + if dpnp.is_cuda_backend(x1_desc.get_array()) or dpnp.is_cuda_backend( + x2_desc.get_array() + ): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + if x1_desc.size != x2_desc.size or x1_desc.size == 0: pass elif x1_desc.shape != x2_desc.shape: diff --git a/dpnp/random/dpnp_iface_random.py b/dpnp/random/dpnp_iface_random.py index 49d2adad2c2..a0c00bd50eb 100644 --- a/dpnp/random/dpnp_iface_random.py +++ b/dpnp/random/dpnp_iface_random.py @@ -140,6 +140,11 @@ def beta(a, b, size=None): """ if not use_origin_backend(a): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `a`, `b` if not dpnp.isscalar(a): @@ -186,6 +191,11 @@ def binomial(n, p, size=None): """ if not use_origin_backend(n): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `p` param if not dpnp.isscalar(n): @@ -238,6 +248,11 @@ def chisquare(df, size=None): """ if not use_origin_backend(df): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `df` if not dpnp.isscalar(df): @@ -306,6 +321,11 @@ def exponential(scale=1.0, size=None): """ if not use_origin_backend(scale): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `scale` if not dpnp.isscalar(scale): @@ -338,6 +358,11 @@ def f(dfnum, dfden, size=None): """ if not use_origin_backend(dfnum): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `dfnum` and `dfden` if not dpnp.isscalar(dfnum): @@ -376,6 +401,11 @@ def gamma(shape, scale=1.0, size=None): """ if not use_origin_backend(scale): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `scale` and `shape` if not dpnp.isscalar(scale): @@ -414,6 +444,11 @@ def geometric(p, size=None): """ if not use_origin_backend(p): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `p` param if not dpnp.isscalar(p): @@ -448,6 +483,11 @@ def gumbel(loc=0.0, scale=1.0, size=None): """ if not use_origin_backend(loc): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `loc` and `scale` params if not dpnp.isscalar(scale): @@ -486,6 +526,11 @@ def hypergeometric(ngood, nbad, nsample, size=None): """ if not use_origin_backend(ngood): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of ints for `ngood`, `nbad`, `nsample` param if not dpnp.isscalar(ngood): @@ -534,6 +579,11 @@ def laplace(loc=0.0, scale=1.0, size=None): """ if not use_origin_backend(loc): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `loc` and `scale` if not dpnp.isscalar(loc): @@ -568,6 +618,11 @@ def logistic(loc=0.0, scale=1.0, size=None): """ if not use_origin_backend(loc): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `loc` and `scale` if not dpnp.isscalar(loc): @@ -609,6 +664,11 @@ def lognormal(mean=0.0, sigma=1.0, size=None): """ if not use_origin_backend(mean): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `mean` and `sigma` params if not dpnp.isscalar(mean): @@ -666,6 +726,11 @@ def multinomial(n, pvals, size=None): pvals_sum = sum(pvals) pvals_desc = dpnp.get_dpnp_descriptor(dpnp.array(pvals)) d = len(pvals) + if dpnp.is_cuda_backend(pvals_desc.get_array()): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + if n < 0: pass elif n > dpnp.iinfo(dpnp.int32).max: @@ -713,6 +778,13 @@ def multivariate_normal(mean, cov, size=None, check_valid="warn", tol=1e-8): if not use_origin_backend(mean): mean_ = dpnp.get_dpnp_descriptor(dpnp.array(mean, dtype=dpnp.float64)) cov_ = dpnp.get_dpnp_descriptor(dpnp.array(cov, dtype=dpnp.float64)) + if dpnp.is_cuda_backend(mean_.get_array()) or dpnp.is_cuda_backend( + cov_.get_array() + ): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + if size is None: shape = [] elif isinstance(size, (int, dpnp.integer)): @@ -767,6 +839,11 @@ def negative_binomial(n, p, size=None): """ if not use_origin_backend(n): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `p` and `n` params if not dpnp.isscalar(n): @@ -852,6 +929,11 @@ def noncentral_chisquare(df, nonc, size=None): """ if not use_origin_backend(df): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `mean` and `scale` if not dpnp.isscalar(df): @@ -906,6 +988,11 @@ def pareto(a, size=None): """ if not use_origin_backend(a): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `a` if not dpnp.isscalar(a): @@ -975,6 +1062,11 @@ def poisson(lam=1.0, size=None): """ if not use_origin_backend(lam): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `lam` param if not dpnp.isscalar(lam): @@ -1010,6 +1102,11 @@ def power(a, size=None): """ if not use_origin_backend(a): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `a` if not dpnp.isscalar(a): @@ -1417,6 +1514,11 @@ def rayleigh(scale=1.0, size=None): """ if not use_origin_backend(scale): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `scale` params if not dpnp.isscalar(scale): @@ -1493,6 +1595,12 @@ def shuffle(x1): x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_strides=False) if x1_desc: + + if dpnp.is_cuda_backend(x1_desc.get_array()): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + if not dpnp.is_type_supported(x1_desc.dtype): pass else: @@ -1537,6 +1645,11 @@ def seed(seed=None, device=None, sycl_queue=None): ) if not use_origin_backend(seed): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of ints for `seed` if seed is None: @@ -1577,6 +1690,10 @@ def standard_cauchy(size=None): """ if not use_origin_backend(size): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) return dpnp_rng_standard_cauchy(size).get_pyobj() return call_origin(numpy.random.standard_cauchy, size) @@ -1602,6 +1719,10 @@ def standard_exponential(size=None): """ if not use_origin_backend(size): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) return dpnp_rng_standard_exponential(size).get_pyobj() return call_origin(numpy.random.standard_exponential, size) @@ -1630,6 +1751,11 @@ def standard_gamma(shape, size=None): """ if not use_origin_backend(shape): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `shape` if not dpnp.isscalar(shape): @@ -1708,6 +1834,11 @@ def standard_t(df, size=None): """ if not use_origin_backend(df): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `df` if not dpnp.isscalar(df): @@ -1744,6 +1875,11 @@ def triangular(left, mode, right, size=None): """ if not use_origin_backend(left): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `left`, `mode`, `right`. if not dpnp.isscalar(left): @@ -1852,6 +1988,11 @@ def vonmises(mu, kappa, size=None): """ if not use_origin_backend(mu): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `mu`, `kappa`. if not dpnp.isscalar(mu): @@ -1888,6 +2029,11 @@ def wald(mean, scale, size=None): """ if not use_origin_backend(mean): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `mean` and `scale` if not dpnp.isscalar(mean): @@ -1924,6 +2070,11 @@ def weibull(a, size=None): """ if not use_origin_backend(a): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `a` param if not dpnp.isscalar(a): @@ -1956,6 +2107,11 @@ def zipf(a, size=None): """ if not use_origin_backend(a): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + # TODO: # array_like of floats for `a` param if not dpnp.isscalar(a): diff --git a/dpnp/random/dpnp_random_state.py b/dpnp/random/dpnp_random_state.py index 21bafdd9194..83888dee43e 100644 --- a/dpnp/random/dpnp_random_state.py +++ b/dpnp/random/dpnp_random_state.py @@ -81,6 +81,7 @@ def __init__(self, seed=None, device=None, sycl_queue=None): self._sycl_queue = dpnp.get_normalized_queue_device( device=device, sycl_queue=sycl_queue ) + self._sycl_device = self._sycl_queue.sycl_device is_cpu = self._sycl_device.is_cpu @@ -234,6 +235,11 @@ def normal( """ if not use_origin_backend(): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + if not dpnp.isscalar(loc): pass elif not dpnp.isscalar(scale): @@ -363,6 +369,11 @@ def randint(self, low, high=None, size=None, dtype=int, usm_type="device"): """ if not use_origin_backend(low): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + if not dpnp.isscalar(low): pass elif not (high is None or dpnp.isscalar(high)): @@ -587,6 +598,11 @@ def uniform( """ if not use_origin_backend(): + if dpnp.is_cuda_backend(): + raise NotImplementedError( + "Running on CUDA is currently not supported" + ) + if not dpnp.isscalar(low): pass elif not dpnp.isscalar(high): diff --git a/dpnp/tests/conftest.py b/dpnp/tests/conftest.py index be5b6b0d6ed..a32a5ae8da7 100644 --- a/dpnp/tests/conftest.py +++ b/dpnp/tests/conftest.py @@ -123,13 +123,18 @@ def pytest_collection_modifyitems(config, items): test_path, "skipped_tests_gpu_no_fp64.tbl" ) + # global skip file for cuda backend + test_exclude_file_cuda = os.path.join(test_path, "skipped_tests_cuda.tbl") + dev = dpctl.select_default_device() is_cpu = dev.is_cpu is_gpu_no_fp64 = not dev.has_aspect_fp64 + is_cuda = dpnp.is_cuda_backend(dev) print("") print(f"DPNP current device is CPU: {is_cpu}") print(f"DPNP current device is GPU without fp64 support: {is_gpu_no_fp64}") + print(f"DPNP current device is GPU with cuda backend: {is_cuda}") print(f"DPNP version: {dpnp.__version__}, location: {dpnp}") print(f"NumPy version: {numpy.__version__}, location: {numpy}") print(f"Python version: {sys.version}") @@ -140,6 +145,8 @@ def pytest_collection_modifyitems(config, items): excluded_tests.extend( get_excluded_tests(test_exclude_file_gpu_no_fp64) ) + if is_cuda: + excluded_tests.extend(get_excluded_tests(test_exclude_file_cuda)) else: excluded_tests.extend(get_excluded_tests(test_exclude_file)) diff --git a/dpnp/tests/helper.py b/dpnp/tests/helper.py index 2db95fdeb77..2404bec60dd 100644 --- a/dpnp/tests/helper.py +++ b/dpnp/tests/helper.py @@ -225,6 +225,14 @@ def is_cpu_device(device=None): return dev.has_aspect_cpu +def is_cuda_device(device=None): + """ + Return True if a test is running on CUDA device, False otherwise. + """ + dev = dpctl.select_default_device() if device is None else device + return dev.backend == dpctl.backend_type.cuda + + def is_win_platform(): """ Return True if a test is running on Windows OS, False otherwise. diff --git a/dpnp/tests/skipped_tests_cuda.tbl b/dpnp/tests/skipped_tests_cuda.tbl new file mode 100644 index 00000000000..456b268f903 --- /dev/null +++ b/dpnp/tests/skipped_tests_cuda.tbl @@ -0,0 +1,710 @@ +# NotImplementedError + +# modf +tests/test_arithmetic.py::TestArithmetic::test_modf_part1 +tests/test_arithmetic.py::TestArithmetic::test_modf_part2 +tests/test_sycl_queue.py::test_modf[cuda:gpu:0] +tests/test_umath.py::test_umaths[('modf', 'f')] +tests/test_umath.py::test_umaths[('modf', 'd')] +tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticModf::test_modf + +# random +tests/test_random_state.py::TestNormal::test_distr[host-float32] +tests/test_random_state.py::TestNormal::test_distr[host-float64] +tests/test_random_state.py::TestNormal::test_distr[host-None] +tests/test_random_state.py::TestNormal::test_distr[device-float32] +tests/test_random_state.py::TestNormal::test_distr[device-float64] +tests/test_random_state.py::TestNormal::test_distr[device-None] +tests/test_random_state.py::TestNormal::test_distr[shared-float32] +tests/test_random_state.py::TestNormal::test_distr[shared-float64] +tests/test_random_state.py::TestNormal::test_distr[shared-None] +tests/test_random_state.py::TestNormal::test_scale[host-float32] +tests/test_random_state.py::TestNormal::test_scale[host-float64] +tests/test_random_state.py::TestNormal::test_scale[host-None] +tests/test_random_state.py::TestNormal::test_scale[device-float32] +tests/test_random_state.py::TestNormal::test_scale[device-float64] +tests/test_random_state.py::TestNormal::test_scale[device-None] +tests/test_random_state.py::TestNormal::test_scale[shared-float32] +tests/test_random_state.py::TestNormal::test_scale[shared-float64] +tests/test_random_state.py::TestNormal::test_scale[shared-None] +tests/test_random_state.py::TestNormal::test_inf_loc[numpy.inf] +tests/test_random_state.py::TestNormal::test_inf_loc[-numpy.inf] +tests/test_random_state.py::TestNormal::test_inf_loc[nextafter(max, 0)] +tests/test_random_state.py::TestNormal::test_inf_loc[nextafter(min, 0)] +tests/test_random_state.py::TestNormal::test_inf_scale +tests/test_random_state.py::TestNormal::test_inf_loc_scale[numpy.inf] +tests/test_random_state.py::TestNormal::test_inf_loc_scale[-numpy.inf] +tests/test_random_state.py::TestNormal::test_extreme_bounds +tests/test_random_state.py::TestNormal::test_fallback[[2]-dpnp.array([3])] +tests/test_random_state.py::TestNormal::test_fallback[[2]-numpy.array([3])] +tests/test_random_state.py::TestNormal::test_fallback[dpnp.array([2])-dpnp.array([3])] +tests/test_random_state.py::TestNormal::test_fallback[dpnp.array([2])-numpy.array([3])] +tests/test_random_state.py::TestNormal::test_fallback[numpy.array([2])-dpnp.array([3])] +tests/test_random_state.py::TestNormal::test_fallback[numpy.array([2])-numpy.array([3])] +tests/test_random_state.py::TestNormal::test_invalid_dtype[dpnp.float16] +tests/test_random_state.py::TestNormal::test_invalid_dtype[float] +tests/test_random_state.py::TestNormal::test_invalid_dtype[dpnp.int64] +tests/test_random_state.py::TestNormal::test_invalid_dtype[dpnp.int32] +tests/test_random_state.py::TestNormal::test_invalid_dtype[dpnp.int] +tests/test_random_state.py::TestNormal::test_invalid_dtype[int] +tests/test_random_state.py::TestNormal::test_invalid_dtype[numpy.clongdouble] +tests/test_random_state.py::TestNormal::test_invalid_dtype[dpnp.complex128] +tests/test_random_state.py::TestNormal::test_invalid_dtype[dpnp.complex64] +tests/test_random_state.py::TestNormal::test_invalid_dtype[dpnp.bool] +tests/test_random_state.py::TestNormal::test_invalid_dtype[dpnp.bool_] +tests/test_random_state.py::TestNormal::test_invalid_usm_type[Empty] +tests/test_random_state.py::TestNormal::test_invalid_usm_type[Unknown] +tests/test_random_state.py::TestRand::test_distr[host] +tests/test_random_state.py::TestRand::test_distr[device] +tests/test_random_state.py::TestRand::test_distr[shared] +tests/test_random_state.py::TestRand::test_zero_dims[(0,)] +tests/test_random_state.py::TestRand::test_zero_dims[(3, 0)] +tests/test_random_state.py::TestRand::test_zero_dims[(3, 0, 10)] +tests/test_random_state.py::TestRand::test_zero_dims[()] +tests/test_random_state.py::TestRand::test_wrong_dims +tests/test_random_state.py::TestRandInt::test_distr[host-int] +tests/test_random_state.py::TestRandInt::test_distr[host-dpnp.int32] +tests/test_random_state.py::TestRandInt::test_distr[device-int] +tests/test_random_state.py::TestRandInt::test_distr[device-dpnp.int32] +tests/test_random_state.py::TestRandInt::test_distr[shared-int] +tests/test_random_state.py::TestRandInt::test_distr[shared-dpnp.int32] +tests/test_random_state.py::TestRandInt::test_float_bounds +tests/test_random_state.py::TestRandInt::test_negative_bounds +tests/test_random_state.py::TestRandInt::test_negative_interval +tests/test_random_state.py::TestRandInt::test_bounds_checking +tests/test_random_state.py::TestRandInt::test_rng_zero_and_extremes +tests/test_random_state.py::TestRandInt::test_full_range +tests/test_random_state.py::TestRandInt::test_in_bounds_fuzz +tests/test_random_state.py::TestRandInt::test_zero_size[(3, 0, 4)] +tests/test_random_state.py::TestRandInt::test_zero_size[0] +tests/test_random_state.py::TestRandInt::test_zero_size[(0,)] +tests/test_random_state.py::TestRandInt::test_zero_size[()] +tests/test_random_state.py::TestRandInt::test_bounds_fallback[[2]-dpnp.array([3])] +tests/test_random_state.py::TestRandInt::test_bounds_fallback[[2]-numpy.array([3])] +tests/test_random_state.py::TestRandInt::test_bounds_fallback[dpnp.array([2])-dpnp.array([3])] +tests/test_random_state.py::TestRandInt::test_bounds_fallback[dpnp.array([2])-numpy.array([3])] +tests/test_random_state.py::TestRandInt::test_bounds_fallback[numpy.array([2])-dpnp.array([3])] +tests/test_random_state.py::TestRandInt::test_bounds_fallback[numpy.array([2])-numpy.array([3])] +tests/test_random_state.py::TestRandInt::test_dtype_fallback[dpnp.int64] +tests/test_random_state.py::TestRandInt::test_dtype_fallback[dpnp.int] +tests/test_random_state.py::TestRandInt::test_dtype_fallback[dpnp.bool] +tests/test_random_state.py::TestRandInt::test_dtype_fallback[dpnp.bool_] +tests/test_random_state.py::TestRandInt::test_dtype_fallback[bool] +tests/test_random_state.py::TestRandInt::test_invalid_usm_type[Empty] +tests/test_random_state.py::TestRandInt::test_invalid_usm_type[Unknown] +tests/test_random_state.py::TestRandN::test_distr[host] +tests/test_random_state.py::TestRandN::test_distr[device] +tests/test_random_state.py::TestRandN::test_distr[shared] +tests/test_random_state.py::TestRandN::test_zero_dims[(0,)] +tests/test_random_state.py::TestRandN::test_zero_dims[(3, 0)] +tests/test_random_state.py::TestRandN::test_zero_dims[(3, 0, 10)] +tests/test_random_state.py::TestRandN::test_zero_dims[()] +tests/test_random_state.py::TestRandN::test_wrong_dims +tests/test_random_state.py::TestSeed::test_scalar[normal] +tests/test_random_state.py::TestSeed::test_scalar[standard_normal] +tests/test_random_state.py::TestSeed::test_scalar[random_sample] +tests/test_random_state.py::TestSeed::test_scalar[uniform] +tests/test_random_state.py::TestStandardNormal::test_distr[host] +tests/test_random_state.py::TestStandardNormal::test_distr[device] +tests/test_random_state.py::TestStandardNormal::test_distr[shared] +tests/test_random_state.py::TestStandardNormal::test_wrong_dims +tests/test_random_state.py::TestRandSample::test_distr[host] +tests/test_random_state.py::TestRandSample::test_distr[device] +tests/test_random_state.py::TestRandSample::test_distr[shared] +tests/test_random_state.py::TestRandSample::test_wrong_dims +tests/test_random_state.py::TestUniform::test_distr[host-float32-(low, high)=[1.23, 10.54]] +tests/test_random_state.py::TestUniform::test_distr[host-float32-(low, high)=[10.54, 1.23]] +tests/test_random_state.py::TestUniform::test_distr[host-float64-(low, high)=[1.23, 10.54]] +tests/test_random_state.py::TestUniform::test_distr[host-float64-(low, high)=[10.54, 1.23]] +tests/test_random_state.py::TestUniform::test_distr[host-int32-(low, high)=[1.23, 10.54]] +tests/test_random_state.py::TestUniform::test_distr[host-int32-(low, high)=[10.54, 1.23]] +tests/test_random_state.py::TestUniform::test_distr[host-None-(low, high)=[1.23, 10.54]] +tests/test_random_state.py::TestUniform::test_distr[host-None-(low, high)=[10.54, 1.23]] +tests/test_random_state.py::TestUniform::test_distr[device-float32-(low, high)=[1.23, 10.54]] +tests/test_random_state.py::TestUniform::test_distr[device-float32-(low, high)=[10.54, 1.23]] +tests/test_random_state.py::TestUniform::test_distr[device-float64-(low, high)=[1.23, 10.54]] +tests/test_random_state.py::TestUniform::test_distr[device-float64-(low, high)=[10.54, 1.23]] +tests/test_random_state.py::TestUniform::test_distr[device-int32-(low, high)=[1.23, 10.54]] +tests/test_random_state.py::TestUniform::test_distr[device-int32-(low, high)=[10.54, 1.23]] +tests/test_random_state.py::TestUniform::test_distr[device-None-(low, high)=[1.23, 10.54]] +tests/test_random_state.py::TestUniform::test_distr[device-None-(low, high)=[10.54, 1.23]] +tests/test_random_state.py::TestUniform::test_distr[shared-float32-(low, high)=[1.23, 10.54]] +tests/test_random_state.py::TestUniform::test_distr[shared-float32-(low, high)=[10.54, 1.23]] +tests/test_random_state.py::TestUniform::test_distr[shared-float64-(low, high)=[1.23, 10.54]] +tests/test_random_state.py::TestUniform::test_distr[shared-float64-(low, high)=[10.54, 1.23]] +tests/test_random_state.py::TestUniform::test_distr[shared-int32-(low, high)=[1.23, 10.54]] +tests/test_random_state.py::TestUniform::test_distr[shared-int32-(low, high)=[10.54, 1.23]] +tests/test_random_state.py::TestUniform::test_distr[shared-None-(low, high)=[1.23, 10.54]] +tests/test_random_state.py::TestUniform::test_distr[shared-None-(low, high)=[10.54, 1.23]] +tests/test_random_state.py::TestUniform::test_low_high_equal[host-float32] +tests/test_random_state.py::TestUniform::test_low_high_equal[host-float64] +tests/test_random_state.py::TestUniform::test_low_high_equal[host-int32] +tests/test_random_state.py::TestUniform::test_low_high_equal[host-None] +tests/test_random_state.py::TestUniform::test_low_high_equal[device-float32] +tests/test_random_state.py::TestUniform::test_low_high_equal[device-float64] +tests/test_random_state.py::TestUniform::test_low_high_equal[device-int32] +tests/test_random_state.py::TestUniform::test_low_high_equal[device-None] +tests/test_random_state.py::TestUniform::test_low_high_equal[shared-float32] +tests/test_random_state.py::TestUniform::test_low_high_equal[shared-float64] +tests/test_random_state.py::TestUniform::test_low_high_equal[shared-int32] +tests/test_random_state.py::TestUniform::test_low_high_equal[shared-None] +tests/test_random_state.py::TestUniform::test_range_bounds +tests/test_random_state.py::TestUniform::test_fallback[[2]-dpnp.array([3])] +tests/test_random_state.py::TestUniform::test_fallback[[2]-numpy.array([3])] +tests/test_random_state.py::TestUniform::test_fallback[dpnp.array([2])-dpnp.array([3])] +tests/test_random_state.py::TestUniform::test_fallback[dpnp.array([2])-numpy.array([3])] +tests/test_random_state.py::TestUniform::test_fallback[numpy.array([2])-dpnp.array([3])] +tests/test_random_state.py::TestUniform::test_fallback[numpy.array([2])-numpy.array([3])] +tests/test_random_state.py::TestUniform::test_invalid_dtype[dpnp.float16] +tests/test_random_state.py::TestUniform::test_invalid_dtype[float] +tests/test_random_state.py::TestUniform::test_invalid_dtype[dpnp.int64] +tests/test_random_state.py::TestUniform::test_invalid_dtype[dpnp.int] +tests/test_random_state.py::TestUniform::test_invalid_dtype[int] +tests/test_random_state.py::TestUniform::test_invalid_dtype[numpy.clongdouble] +tests/test_random_state.py::TestUniform::test_invalid_dtype[dpnp.complex128] +tests/test_random_state.py::TestUniform::test_invalid_dtype[dpnp.complex64] +tests/test_random_state.py::TestUniform::test_invalid_dtype[dpnp.bool] +tests/test_random_state.py::TestUniform::test_invalid_dtype[dpnp.bool_] +tests/test_random_state.py::TestUniform::test_invalid_usm_type[Empty] +tests/test_random_state.py::TestUniform::test_invalid_usm_type[Unknown] + +tests/test_random.py::test_input_size[chisquare] +tests/test_random.py::test_input_size[rand] +tests/test_random.py::test_input_size[randn] +tests/test_random.py::test_input_shape[chisquare] +tests/test_random.py::test_input_shape[random] +tests/test_random.py::test_input_shape[random_sample] +tests/test_random.py::test_input_shape[ranf] +tests/test_random.py::test_input_shape[sample] +tests/test_random.py::test_check_output[random] +tests/test_random.py::test_check_output[random_sample] +tests/test_random.py::test_check_output[ranf] +tests/test_random.py::test_check_output[sample] +tests/test_random.py::test_check_output[rand] +tests/test_random.py::test_seed[random] +tests/test_random.py::test_seed[random_sample] +tests/test_random.py::test_seed[ranf] +tests/test_random.py::test_seed[sample] +tests/test_random.py::test_seed[rand] +tests/test_random.py::test_randn_normal_distribution +tests/test_random.py::TestDistributionsBeta::test_invalid_args +tests/test_random.py::TestDistributionsBeta::test_moments +tests/test_random.py::TestDistributionsBeta::test_seed +tests/test_random.py::TestDistributionsBinomial::test_extreme_value +tests/test_random.py::TestDistributionsBinomial::test_invalid_args +tests/test_random.py::TestDistributionsBinomial::test_moments +tests/test_random.py::TestDistributionsBinomial::test_seed +tests/test_random.py::TestDistributionsChisquare::test_invalid_args +tests/test_random.py::TestDistributionsChisquare::test_seed +tests/test_random.py::TestDistributionsExponential::test_invalid_args +tests/test_random.py::TestDistributionsExponential::test_seed +tests/test_random.py::TestDistributionsF::test_invalid_args +tests/test_random.py::TestDistributionsF::test_moments +tests/test_random.py::TestDistributionsF::test_seed +tests/test_random.py::TestDistributionsGamma::test_invalid_args +tests/test_random.py::TestDistributionsGamma::test_moments +tests/test_random.py::TestDistributionsGamma::test_seed +tests/test_random.py::TestDistributionsGeometric::test_extreme_value +tests/test_random.py::TestDistributionsGeometric::test_invalid_args +tests/test_random.py::TestDistributionsGeometric::test_moments +tests/test_random.py::TestDistributionsGeometric::test_seed +tests/test_random.py::TestDistributionsGumbel::test_extreme_value +tests/test_random.py::TestDistributionsGumbel::test_invalid_args +tests/test_random.py::TestDistributionsGumbel::test_moments +tests/test_random.py::TestDistributionsGumbel::test_seed +tests/test_random.py::TestDistributionsHypergeometric::test_extreme_value +tests/test_random.py::TestDistributionsHypergeometric::test_invalid_args +tests/test_random.py::TestDistributionsHypergeometric::test_moments +tests/test_random.py::TestDistributionsHypergeometric::test_seed +tests/test_random.py::TestDistributionsLaplace::test_extreme_value +tests/test_random.py::TestDistributionsLaplace::test_invalid_args +tests/test_random.py::TestDistributionsLaplace::test_moments +tests/test_random.py::TestDistributionsLaplace::test_seed +tests/test_random.py::TestDistributionsLogistic::test_invalid_args +tests/test_random.py::TestDistributionsLogistic::test_moments +tests/test_random.py::TestDistributionsLogistic::test_seed +tests/test_random.py::TestDistributionsLognormal::test_extreme_value +tests/test_random.py::TestDistributionsLognormal::test_invalid_args +tests/test_random.py::TestDistributionsLognormal::test_moments +tests/test_random.py::TestDistributionsLognormal::test_seed +tests/test_random.py::TestDistributionsMultinomial::test_check_sum +tests/test_random.py::TestDistributionsMultinomial::test_extreme_value +tests/test_random.py::TestDistributionsMultinomial::test_invalid_args +tests/test_random.py::TestDistributionsMultinomial::test_moments +tests/test_random.py::TestDistributionsMultinomial::test_seed +tests/test_random.py::TestDistributionsMultinomial::test_seed1 +tests/test_random.py::TestDistributionsMultivariateNormal::test_invalid_args +tests/test_random.py::TestDistributionsNegativeBinomial::test_extreme_value +tests/test_random.py::TestDistributionsNegativeBinomial::test_invalid_args +tests/test_random.py::TestDistributionsNegativeBinomial::test_seed +tests/test_random.py::TestDistributionsNormal::test_extreme_value +tests/test_random.py::TestDistributionsNormal::test_invalid_args +tests/test_random.py::TestDistributionsNormal::test_moments +tests/test_random.py::TestDistributionsNormal::test_seed +tests/test_random.py::TestDistributionsNoncentralChisquare::test_moments[df_grt_1] +tests/test_random.py::TestDistributionsNoncentralChisquare::test_moments[df_eq_1] +tests/test_random.py::TestDistributionsNoncentralChisquare::test_moments[df_less_1] +tests/test_random.py::TestDistributionsNoncentralChisquare::test_invalid_args +tests/test_random.py::TestDistributionsNoncentralChisquare::test_seed[df_grt_1] +tests/test_random.py::TestDistributionsNoncentralChisquare::test_seed[df_eq_1] +tests/test_random.py::TestDistributionsNoncentralChisquare::test_seed[df_less_1] +tests/test_random.py::TestDistributionsPareto::test_invalid_args +tests/test_random.py::TestDistributionsPareto::test_moments +tests/test_random.py::TestDistributionsPareto::test_seed +tests/test_random.py::TestDistributionsPoisson::test_extreme_value +tests/test_random.py::TestDistributionsPoisson::test_invalid_args +tests/test_random.py::TestDistributionsPoisson::test_moments +tests/test_random.py::TestDistributionsPoisson::test_seed +tests/test_random.py::TestDistributionsPower::test_invalid_args +tests/test_random.py::TestDistributionsPower::test_moments +tests/test_random.py::TestDistributionsPower::test_seed +tests/test_random.py::TestDistributionsRayleigh::test_extreme_value +tests/test_random.py::TestDistributionsRayleigh::test_invalid_args +tests/test_random.py::TestDistributionsRayleigh::test_moments +tests/test_random.py::TestDistributionsRayleigh::test_seed +tests/test_random.py::TestDistributionsStandardCauchy::test_seed +tests/test_random.py::TestDistributionsStandardExponential::test_moments +tests/test_random.py::TestDistributionsStandardExponential::test_seed +tests/test_random.py::TestDistributionsStandardGamma::test_extreme_value +tests/test_random.py::TestDistributionsStandardGamma::test_invalid_args +tests/test_random.py::TestDistributionsStandardGamma::test_moments +tests/test_random.py::TestDistributionsStandardGamma::test_seed +tests/test_random.py::TestDistributionsStandardNormal::test_moments +tests/test_random.py::TestDistributionsStandardNormal::test_seed +tests/test_random.py::TestDistributionsStandardT::test_invalid_args +tests/test_random.py::TestDistributionsStandardT::test_moments +tests/test_random.py::TestDistributionsStandardT::test_seed +tests/test_random.py::TestDistributionsTriangular::test_invalid_args +tests/test_random.py::TestDistributionsTriangular::test_moments +tests/test_random.py::TestDistributionsTriangular::test_seed +tests/test_random.py::TestDistributionsUniform::test_extreme_value +tests/test_random.py::TestDistributionsUniform::test_moments +tests/test_random.py::TestDistributionsUniform::test_seed +tests/test_random.py::TestDistributionsVonmises::test_moments[large_kappa] +tests/test_random.py::TestDistributionsVonmises::test_moments[small_kappa] +tests/test_random.py::TestDistributionsVonmises::test_invalid_args +tests/test_random.py::TestDistributionsVonmises::test_seed[large_kappa] +tests/test_random.py::TestDistributionsVonmises::test_seed[small_kappa] +tests/test_random.py::TestDistributionsWald::test_invalid_args +tests/test_random.py::TestDistributionsWald::test_moments +tests/test_random.py::TestDistributionsWald::test_seed +tests/test_random.py::TestDistributionsWeibull::test_extreme_value +tests/test_random.py::TestDistributionsWeibull::test_invalid_args +tests/test_random.py::TestDistributionsWeibull::test_seed +tests/test_random.py::TestDistributionsZipf::test_invalid_args +tests/test_random.py::TestDistributionsZipf::test_seed +tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.array([])] +tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.astype(dpnp.asarray(x), dpnp.float32)] +tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray([[i, i] for i in x])] +tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1_fallback[lambda x: x] +tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1_fallback[lambda x: [(i, i) for i in x]] + +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-normal-kwargs0] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-rand-kwargs1] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-randint-kwargs2] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-randn-kwargs3] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-random-kwargs4] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-random_integers-kwargs5] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-random_sample-kwargs6] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-ranf-kwargs7] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-sample-kwargs8] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-standard_normal-kwargs9] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-uniform-kwargs10] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-normal-kwargs0] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-rand-kwargs1] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-randint-kwargs2] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-randn-kwargs3] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-random-kwargs4] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-random_integers-kwargs5] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-random_sample-kwargs6] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-ranf-kwargs7] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-sample-kwargs8] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-standard_normal-kwargs9] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-uniform-kwargs10] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-normal-kwargs0] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-rand-kwargs1] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-randint-kwargs2] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-randn-kwargs3] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-random-kwargs4] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-random_integers-kwargs5] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-random_sample-kwargs6] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-ranf-kwargs7] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-sample-kwargs8] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-standard_normal-kwargs9] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-uniform-kwargs10] +tests/test_sycl_queue.py::test_random_state[host-cuda:gpu:0-normal-args0-kwargs0] +tests/test_sycl_queue.py::test_random_state[host-cuda:gpu:0-rand-args1-kwargs1] +tests/test_sycl_queue.py::test_random_state[host-cuda:gpu:0-randint-args2-kwargs2] +tests/test_sycl_queue.py::test_random_state[host-cuda:gpu:0-randn-args3-kwargs3] +tests/test_sycl_queue.py::test_random_state[host-cuda:gpu:0-random_sample-args4-kwargs4] +tests/test_sycl_queue.py::test_random_state[host-cuda:gpu:0-standard_normal-args5-kwargs5] +tests/test_sycl_queue.py::test_random_state[host-cuda:gpu:0-uniform-args6-kwargs6] +tests/test_sycl_queue.py::test_random_state[device-cuda:gpu:0-normal-args0-kwargs0] +tests/test_sycl_queue.py::test_random_state[device-cuda:gpu:0-rand-args1-kwargs1] +tests/test_sycl_queue.py::test_random_state[device-cuda:gpu:0-randint-args2-kwargs2] +tests/test_sycl_queue.py::test_random_state[device-cuda:gpu:0-randn-args3-kwargs3] +tests/test_sycl_queue.py::test_random_state[device-cuda:gpu:0-random_sample-args4-kwargs4] +tests/test_sycl_queue.py::test_random_state[device-cuda:gpu:0-standard_normal-args5-kwargs5] +tests/test_sycl_queue.py::test_random_state[device-cuda:gpu:0-uniform-args6-kwargs6] +tests/test_sycl_queue.py::test_random_state[shared-cuda:gpu:0-normal-args0-kwargs0] +tests/test_sycl_queue.py::test_random_state[shared-cuda:gpu:0-rand-args1-kwargs1] +tests/test_sycl_queue.py::test_random_state[shared-cuda:gpu:0-randint-args2-kwargs2] +tests/test_sycl_queue.py::test_random_state[shared-cuda:gpu:0-randn-args3-kwargs3] +tests/test_sycl_queue.py::test_random_state[shared-cuda:gpu:0-random_sample-args4-kwargs4] +tests/test_sycl_queue.py::test_random_state[shared-cuda:gpu:0-standard_normal-args5-kwargs5] +tests/test_sycl_queue.py::test_random_state[shared-cuda:gpu:0-uniform-args6-kwargs6] + +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsBeta_param_6_{a_shape=(3, 2), b_shape=(3, 2), shape=(4, 3, 2)}::test_beta +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsBeta_param_7_{a_shape=(3, 2), b_shape=(3, 2), shape=(3, 2)}::test_beta +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsChisquare_param_0_{df_shape=(), shape=(4, 3, 2)}::test_chisquare +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsChisquare_param_1_{df_shape=(), shape=(3, 2)}::test_chisquare +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsChisquare_param_2_{df_shape=(3, 2), shape=(4, 3, 2)}::test_chisquare +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsChisquare_param_3_{df_shape=(3, 2), shape=(3, 2)}::test_chisquare +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsExponential_param_3_{scale_shape=(3, 2), shape=(4, 3, 2)}::test_exponential +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsExponential_param_4_{scale_shape=(3, 2), shape=(3, 2)}::test_exponential +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsExponential_param_5_{scale_shape=(3, 2), shape=None}::test_exponential +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsExponentialError::test_negative_scale +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF_param_0_{dfden_shape=(), dfnum_shape=(), shape=(4, 3, 2)}::test_f +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF_param_1_{dfden_shape=(), dfnum_shape=(), shape=(3, 2)}::test_f +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF_param_2_{dfden_shape=(), dfnum_shape=(3, 2), shape=(4, 3, 2)}::test_f +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF_param_3_{dfden_shape=(), dfnum_shape=(3, 2), shape=(3, 2)}::test_f +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF_param_4_{dfden_shape=(3, 2), dfnum_shape=(), shape=(4, 3, 2)}::test_f +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF_param_5_{dfden_shape=(3, 2), dfnum_shape=(), shape=(3, 2)}::test_f +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF_param_6_{dfden_shape=(3, 2), dfnum_shape=(3, 2), shape=(4, 3, 2)}::test_f +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF_param_7_{dfden_shape=(3, 2), dfnum_shape=(3, 2), shape=(3, 2)}::test_f +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma_param_0_{scale_shape=(), shape=(4, 3, 2), shape_shape=()}::test_gamma +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma_param_1_{scale_shape=(), shape=(4, 3, 2), shape_shape=(3, 2)}::test_gamma +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma_param_2_{scale_shape=(), shape=(3, 2), shape_shape=()}::test_gamma +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma_param_3_{scale_shape=(), shape=(3, 2), shape_shape=(3, 2)}::test_gamma +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma_param_4_{scale_shape=(3, 2), shape=(4, 3, 2), shape_shape=()}::test_gamma +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma_param_5_{scale_shape=(3, 2), shape=(4, 3, 2), shape_shape=(3, 2)}::test_gamma +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma_param_6_{scale_shape=(3, 2), shape=(3, 2), shape_shape=()}::test_gamma +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma_param_7_{scale_shape=(3, 2), shape=(3, 2), shape_shape=(3, 2)}::test_gamma +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGumbel_param_6_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(4, 3, 2)}::test_gumbel +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGumbel_param_7_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(3, 2)}::test_gumbel +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsuLaplace_param_6_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(4, 3, 2)}::test_laplace +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsuLaplace_param_7_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(3, 2)}::test_laplace +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLogistic_param_6_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(4, 3, 2)}::test_logistic +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLogistic_param_7_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(3, 2)}::test_logistic +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial_param_6_{n_shape=(3, 2), p_shape=(3, 2), shape=(4, 3, 2)}::test_negative_binomial +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial_param_6_{n_shape=(3, 2), p_shape=(3, 2), shape=(4, 3, 2)}::test_negative_binomial_for_noninteger_n +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial_param_7_{n_shape=(3, 2), p_shape=(3, 2), shape=(3, 2)}::test_negative_binomial +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial_param_7_{n_shape=(3, 2), p_shape=(3, 2), shape=(3, 2)}::test_negative_binomial_for_noninteger_n +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare_param_0_{df_shape=(), nonc_shape=(), shape=(4, 3, 2)}::test_noncentral_chisquare_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare_param_1_{df_shape=(), nonc_shape=(), shape=(3, 2)}::test_noncentral_chisquare_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare_param_2_{df_shape=(), nonc_shape=(3, 2), shape=(4, 3, 2)}::test_noncentral_chisquare_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare_param_3_{df_shape=(), nonc_shape=(3, 2), shape=(3, 2)}::test_noncentral_chisquare_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare_param_4_{df_shape=(3, 2), nonc_shape=(), shape=(4, 3, 2)}::test_noncentral_chisquare_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare_param_5_{df_shape=(3, 2), nonc_shape=(), shape=(3, 2)}::test_noncentral_chisquare_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare_param_6_{df_shape=(3, 2), nonc_shape=(3, 2), shape=(4, 3, 2)}::test_noncentral_chisquare +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare_param_6_{df_shape=(3, 2), nonc_shape=(3, 2), shape=(4, 3, 2)}::test_noncentral_chisquare_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare_param_7_{df_shape=(3, 2), nonc_shape=(3, 2), shape=(3, 2)}::test_noncentral_chisquare +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare_param_7_{df_shape=(3, 2), nonc_shape=(3, 2), shape=(3, 2)}::test_noncentral_chisquare_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal_param_0_{loc_shape=(), scale_shape=(), shape=(4, 3, 2)}::test_normal +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal_param_1_{loc_shape=(), scale_shape=(), shape=(3, 2)}::test_normal +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal_param_2_{loc_shape=(), scale_shape=(3, 2), shape=(4, 3, 2)}::test_normal +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal_param_3_{loc_shape=(), scale_shape=(3, 2), shape=(3, 2)}::test_normal +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal_param_4_{loc_shape=(3, 2), scale_shape=(), shape=(4, 3, 2)}::test_normal +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal_param_5_{loc_shape=(3, 2), scale_shape=(), shape=(3, 2)}::test_normal +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal_param_6_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(4, 3, 2)}::test_normal +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal_param_7_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(3, 2)}::test_normal +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPareto_param_0_{a_shape=(), shape=(4, 3, 2)}::test_pareto +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPareto_param_1_{a_shape=(), shape=(3, 2)}::test_pareto +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPareto_param_2_{a_shape=(3, 2), shape=(4, 3, 2)}::test_pareto +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPareto_param_3_{a_shape=(3, 2), shape=(3, 2)}::test_pareto +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh_param_2_{scale_shape=(3, 2), shape=(4, 3, 2)}::test_rayleigh +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh_param_2_{scale_shape=(3, 2), shape=(4, 3, 2)}::test_rayleigh_for_negative_scale +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh_param_2_{scale_shape=(3, 2), shape=(4, 3, 2)}::test_rayleigh_for_zero_scale +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh_param_3_{scale_shape=(3, 2), shape=(3, 2)}::test_rayleigh +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh_param_3_{scale_shape=(3, 2), shape=(3, 2)}::test_rayleigh_for_negative_scale +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh_param_3_{scale_shape=(3, 2), shape=(3, 2)}::test_rayleigh_for_zero_scale +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardCauchy_param_0_{shape=(4, 3, 2)}::test_standard_cauchy +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardCauchy_param_1_{shape=(3, 2)}::test_standard_cauchy +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardExponential_param_0_{shape=(4, 3, 2)}::test_standard_exponential +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardExponential_param_1_{shape=(3, 2)}::test_standard_exponential +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardGamma_param_1_{shape=(4, 3, 2), shape_shape=(3, 2)}::test_standard_gamma +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardGamma_param_3_{shape=(3, 2), shape_shape=(3, 2)}::test_standard_gamma +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardNormal_param_0_{shape=(4, 3, 2)}::test_standard_normal +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardNormal_param_1_{shape=(3, 2)}::test_standard_normal +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardT_param_0_{df_shape=(), shape=(4, 3, 2)}::test_standard_t +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardT_param_1_{df_shape=(), shape=(3, 2)}::test_standard_t +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardT_param_2_{df_shape=(3, 2), shape=(4, 3, 2)}::test_standard_t +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardT_param_3_{df_shape=(3, 2), shape=(3, 2)}::test_standard_t +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_0_{left_shape=(), mode_shape=(), right_shape=(), shape=(4, 3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_1_{left_shape=(), mode_shape=(), right_shape=(), shape=(3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_2_{left_shape=(), mode_shape=(), right_shape=(3, 2), shape=(4, 3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_3_{left_shape=(), mode_shape=(), right_shape=(3, 2), shape=(3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_4_{left_shape=(), mode_shape=(3, 2), right_shape=(), shape=(4, 3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_5_{left_shape=(), mode_shape=(3, 2), right_shape=(), shape=(3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_6_{left_shape=(), mode_shape=(3, 2), right_shape=(3, 2), shape=(4, 3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_7_{left_shape=(), mode_shape=(3, 2), right_shape=(3, 2), shape=(3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_8_{left_shape=(3, 2), mode_shape=(), right_shape=(), shape=(4, 3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_9_{left_shape=(3, 2), mode_shape=(), right_shape=(), shape=(3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_10_{left_shape=(3, 2), mode_shape=(), right_shape=(3, 2), shape=(4, 3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_11_{left_shape=(3, 2), mode_shape=(), right_shape=(3, 2), shape=(3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_12_{left_shape=(3, 2), mode_shape=(3, 2), right_shape=(), shape=(4, 3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_13_{left_shape=(3, 2), mode_shape=(3, 2), right_shape=(), shape=(3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_14_{left_shape=(3, 2), mode_shape=(3, 2), right_shape=(3, 2), shape=(4, 3, 2)}::test_triangular +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_14_{left_shape=(3, 2), mode_shape=(3, 2), right_shape=(3, 2), shape=(4, 3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_15_{left_shape=(3, 2), mode_shape=(3, 2), right_shape=(3, 2), shape=(3, 2)}::test_triangular +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular_param_15_{left_shape=(3, 2), mode_shape=(3, 2), right_shape=(3, 2), shape=(3, 2)}::test_triangular_for_invalid_params +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsUniform_param_2_{high_shape=(), low_shape=(3, 2), shape=(4, 3, 2)}::test_uniform +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsUniform_param_3_{high_shape=(), low_shape=(3, 2), shape=(3, 2)}::test_uniform +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsUniform_param_6_{high_shape=(3, 2), low_shape=(3, 2), shape=(4, 3, 2)}::test_uniform +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsUniform_param_7_{high_shape=(3, 2), low_shape=(3, 2), shape=(3, 2)}::test_uniform +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises_param_0_{kappa_shape=(), mu_shape=(), shape=(4, 3, 2)}::test_vonmises +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises_param_1_{kappa_shape=(), mu_shape=(), shape=(3, 2)}::test_vonmises +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises_param_2_{kappa_shape=(), mu_shape=(3, 2), shape=(4, 3, 2)}::test_vonmises +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises_param_3_{kappa_shape=(), mu_shape=(3, 2), shape=(3, 2)}::test_vonmises +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises_param_4_{kappa_shape=(3, 2), mu_shape=(), shape=(4, 3, 2)}::test_vonmises +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises_param_5_{kappa_shape=(3, 2), mu_shape=(), shape=(3, 2)}::test_vonmises +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises_param_6_{kappa_shape=(3, 2), mu_shape=(3, 2), shape=(4, 3, 2)}::test_vonmises +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises_param_7_{kappa_shape=(3, 2), mu_shape=(3, 2), shape=(3, 2)}::test_vonmises +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWald_param_6_{mean_shape=(3, 2), scale_shape=(3, 2), shape=(4, 3, 2)}::test_wald +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWald_param_7_{mean_shape=(3, 2), scale_shape=(3, 2), shape=(3, 2)}::test_wald +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull_param_2_{a_shape=(3, 2), shape=(4, 3, 2)}::test_weibull +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull_param_2_{a_shape=(3, 2), shape=(4, 3, 2)}::test_weibull_for_inf_a +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull_param_2_{a_shape=(3, 2), shape=(4, 3, 2)}::test_weibull_for_negative_a +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull_param_3_{a_shape=(3, 2), shape=(3, 2)}::test_weibull +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull_param_3_{a_shape=(3, 2), shape=(3, 2)}::test_weibull_for_inf_a +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull_param_3_{a_shape=(3, 2), shape=(3, 2)}::test_weibull_for_negative_a +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsZipf_param_2_{a_shape=(3, 2), shape=(4, 3, 2)}::test_zipf +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsZipf_param_3_{a_shape=(3, 2), shape=(3, 2)}::test_zipf +tests/third_party/cupy/random_tests/test_sample.py::TestRandint::test_lo_hi_equal +tests/third_party/cupy/random_tests/test_sample.py::TestRandint::test_lo_hi_nonrandom +tests/third_party/cupy/random_tests/test_sample.py::TestRandint::test_lo_hi_reversed +tests/third_party/cupy/random_tests/test_sample.py::TestRandint::test_zero_sizes +tests/third_party/cupy/random_tests/test_sample.py::TestRandint2::test_bound_1 +tests/third_party/cupy/random_tests/test_sample.py::TestRandint2::test_bound_2 +tests/third_party/cupy/random_tests/test_sample.py::TestRandint2::test_bound_float2 +tests/third_party/cupy/random_tests/test_sample.py::TestRandint2::test_bound_overflow +tests/third_party/cupy/random_tests/test_sample.py::TestRandintDtype::test_dtype +tests/third_party/cupy/random_tests/test_sample.py::TestRandintDtype::test_dtype2 + +# partition +tests/test_sort.py::test_partition[[3, 4, 2, 1]-bool-0] +tests/test_sort.py::test_partition[[3, 4, 2, 1]-bool-1] +tests/test_sort.py::test_partition[[3, 4, 2, 1]-int32-0] +tests/test_sort.py::test_partition[[3, 4, 2, 1]-int32-1] +tests/test_sort.py::test_partition[[3, 4, 2, 1]-int64-0] +tests/test_sort.py::test_partition[[3, 4, 2, 1]-int64-1] +tests/test_sort.py::test_partition[[3, 4, 2, 1]-float32-0] +tests/test_sort.py::test_partition[[3, 4, 2, 1]-float32-1] +tests/test_sort.py::test_partition[[3, 4, 2, 1]-float64-0] +tests/test_sort.py::test_partition[[3, 4, 2, 1]-float64-1] +tests/test_sort.py::test_partition[[3, 4, 2, 1]-complex64-0] +tests/test_sort.py::test_partition[[3, 4, 2, 1]-complex64-1] +tests/test_sort.py::test_partition[[3, 4, 2, 1]-complex128-0] +tests/test_sort.py::test_partition[[3, 4, 2, 1]-complex128-1] +tests/test_sort.py::test_partition[[[1, 0], [3, 0]]-bool-0] +tests/test_sort.py::test_partition[[[1, 0], [3, 0]]-bool-1] +tests/test_sort.py::test_partition[[[1, 0], [3, 0]]-int32-0] +tests/test_sort.py::test_partition[[[1, 0], [3, 0]]-int32-1] +tests/test_sort.py::test_partition[[[1, 0], [3, 0]]-int64-0] +tests/test_sort.py::test_partition[[[1, 0], [3, 0]]-int64-1] +tests/test_sort.py::test_partition[[[1, 0], [3, 0]]-float32-0] +tests/test_sort.py::test_partition[[[1, 0], [3, 0]]-float32-1] +tests/test_sort.py::test_partition[[[1, 0], [3, 0]]-float64-0] +tests/test_sort.py::test_partition[[[1, 0], [3, 0]]-float64-1] +tests/test_sort.py::test_partition[[[1, 0], [3, 0]]-complex64-0] +tests/test_sort.py::test_partition[[[1, 0], [3, 0]]-complex64-1] +tests/test_sort.py::test_partition[[[1, 0], [3, 0]]-complex128-0] +tests/test_sort.py::test_partition[[[1, 0], [3, 0]]-complex128-1] +tests/test_sort.py::test_partition[[[3, 2], [1, 6]]-bool-0] +tests/test_sort.py::test_partition[[[3, 2], [1, 6]]-bool-1] +tests/test_sort.py::test_partition[[[3, 2], [1, 6]]-int32-0] +tests/test_sort.py::test_partition[[[3, 2], [1, 6]]-int32-1] +tests/test_sort.py::test_partition[[[3, 2], [1, 6]]-int64-0] +tests/test_sort.py::test_partition[[[3, 2], [1, 6]]-int64-1] +tests/test_sort.py::test_partition[[[3, 2], [1, 6]]-float32-0] +tests/test_sort.py::test_partition[[[3, 2], [1, 6]]-float32-1] +tests/test_sort.py::test_partition[[[3, 2], [1, 6]]-float64-0] +tests/test_sort.py::test_partition[[[3, 2], [1, 6]]-float64-1] +tests/test_sort.py::test_partition[[[3, 2], [1, 6]]-complex64-0] +tests/test_sort.py::test_partition[[[3, 2], [1, 6]]-complex64-1] +tests/test_sort.py::test_partition[[[3, 2], [1, 6]]-complex128-0] +tests/test_sort.py::test_partition[[[3, 2], [1, 6]]-complex128-1] +tests/test_sort.py::test_partition[[[4, 2, 3], [3, 4, 1]]-bool-0] +tests/test_sort.py::test_partition[[[4, 2, 3], [3, 4, 1]]-bool-1] +tests/test_sort.py::test_partition[[[4, 2, 3], [3, 4, 1]]-int32-0] +tests/test_sort.py::test_partition[[[4, 2, 3], [3, 4, 1]]-int32-1] +tests/test_sort.py::test_partition[[[4, 2, 3], [3, 4, 1]]-int64-0] +tests/test_sort.py::test_partition[[[4, 2, 3], [3, 4, 1]]-int64-1] +tests/test_sort.py::test_partition[[[4, 2, 3], [3, 4, 1]]-float32-0] +tests/test_sort.py::test_partition[[[4, 2, 3], [3, 4, 1]]-float32-1] +tests/test_sort.py::test_partition[[[4, 2, 3], [3, 4, 1]]-float64-0] +tests/test_sort.py::test_partition[[[4, 2, 3], [3, 4, 1]]-float64-1] +tests/test_sort.py::test_partition[[[4, 2, 3], [3, 4, 1]]-complex64-0] +tests/test_sort.py::test_partition[[[4, 2, 3], [3, 4, 1]]-complex64-1] +tests/test_sort.py::test_partition[[[4, 2, 3], [3, 4, 1]]-complex128-0] +tests/test_sort.py::test_partition[[[4, 2, 3], [3, 4, 1]]-complex128-1] +tests/test_sort.py::test_partition[[[[1, -3], [3, 0]], [[5, 2], [0, 1]], [[1, 0], [0, 1]]]-bool-0] +tests/test_sort.py::test_partition[[[[1, -3], [3, 0]], [[5, 2], [0, 1]], [[1, 0], [0, 1]]]-bool-1] +tests/test_sort.py::test_partition[[[[1, -3], [3, 0]], [[5, 2], [0, 1]], [[1, 0], [0, 1]]]-int32-0] +tests/test_sort.py::test_partition[[[[1, -3], [3, 0]], [[5, 2], [0, 1]], [[1, 0], [0, 1]]]-int32-1] +tests/test_sort.py::test_partition[[[[1, -3], [3, 0]], [[5, 2], [0, 1]], [[1, 0], [0, 1]]]-int64-0] +tests/test_sort.py::test_partition[[[[1, -3], [3, 0]], [[5, 2], [0, 1]], [[1, 0], [0, 1]]]-int64-1] +tests/test_sort.py::test_partition[[[[1, -3], [3, 0]], [[5, 2], [0, 1]], [[1, 0], [0, 1]]]-float32-0] +tests/test_sort.py::test_partition[[[[1, -3], [3, 0]], [[5, 2], [0, 1]], [[1, 0], [0, 1]]]-float32-1] +tests/test_sort.py::test_partition[[[[1, -3], [3, 0]], [[5, 2], [0, 1]], [[1, 0], [0, 1]]]-float64-0] +tests/test_sort.py::test_partition[[[[1, -3], [3, 0]], [[5, 2], [0, 1]], [[1, 0], [0, 1]]]-float64-1] +tests/test_sort.py::test_partition[[[[1, -3], [3, 0]], [[5, 2], [0, 1]], [[1, 0], [0, 1]]]-complex64-0] +tests/test_sort.py::test_partition[[[[1, -3], [3, 0]], [[5, 2], [0, 1]], [[1, 0], [0, 1]]]-complex64-1] +tests/test_sort.py::test_partition[[[[1, -3], [3, 0]], [[5, 2], [0, 1]], [[1, 0], [0, 1]]]-complex128-0] +tests/test_sort.py::test_partition[[[[1, -3], [3, 0]], [[5, 2], [0, 1]], [[1, 0], [0, 1]]]-complex128-1] +tests/test_sort.py::test_partition[[[[[8, 2], [3, 0]], [[5, 2], [0, 1]]], [[[1, 3], [3, 1]], [[5, 2], [0, 1]]]]-bool-0] +tests/test_sort.py::test_partition[[[[[8, 2], [3, 0]], [[5, 2], [0, 1]]], [[[1, 3], [3, 1]], [[5, 2], [0, 1]]]]-bool-1] +tests/test_sort.py::test_partition[[[[[8, 2], [3, 0]], [[5, 2], [0, 1]]], [[[1, 3], [3, 1]], [[5, 2], [0, 1]]]]-int32-0] +tests/test_sort.py::test_partition[[[[[8, 2], [3, 0]], [[5, 2], [0, 1]]], [[[1, 3], [3, 1]], [[5, 2], [0, 1]]]]-int32-1] +tests/test_sort.py::test_partition[[[[[8, 2], [3, 0]], [[5, 2], [0, 1]]], [[[1, 3], [3, 1]], [[5, 2], [0, 1]]]]-int64-0] +tests/test_sort.py::test_partition[[[[[8, 2], [3, 0]], [[5, 2], [0, 1]]], [[[1, 3], [3, 1]], [[5, 2], [0, 1]]]]-int64-1] +tests/test_sort.py::test_partition[[[[[8, 2], [3, 0]], [[5, 2], [0, 1]]], [[[1, 3], [3, 1]], [[5, 2], [0, 1]]]]-float32-0] +tests/test_sort.py::test_partition[[[[[8, 2], [3, 0]], [[5, 2], [0, 1]]], [[[1, 3], [3, 1]], [[5, 2], [0, 1]]]]-float32-1] +tests/test_sort.py::test_partition[[[[[8, 2], [3, 0]], [[5, 2], [0, 1]]], [[[1, 3], [3, 1]], [[5, 2], [0, 1]]]]-float64-0] +tests/test_sort.py::test_partition[[[[[8, 2], [3, 0]], [[5, 2], [0, 1]]], [[[1, 3], [3, 1]], [[5, 2], [0, 1]]]]-float64-1] +tests/test_sort.py::test_partition[[[[[8, 2], [3, 0]], [[5, 2], [0, 1]]], [[[1, 3], [3, 1]], [[5, 2], [0, 1]]]]-complex64-0] +tests/test_sort.py::test_partition[[[[[8, 2], [3, 0]], [[5, 2], [0, 1]]], [[[1, 3], [3, 1]], [[5, 2], [0, 1]]]]-complex64-1] +tests/test_sort.py::test_partition[[[[[8, 2], [3, 0]], [[5, 2], [0, 1]]], [[[1, 3], [3, 1]], [[5, 2], [0, 1]]]]-complex128-0] +tests/test_sort.py::test_partition[[[[[8, 2], [3, 0]], [[5, 2], [0, 1]]], [[[1, 3], [3, 1]], [[5, 2], [0, 1]]]]-complex128-1] + +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_0_{external=False, length=10}::test_partition_axis +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_0_{external=False, length=10}::test_partition_invalid_axis1 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_0_{external=False, length=10}::test_partition_invalid_axis2 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_0_{external=False, length=10}::test_partition_invalid_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_0_{external=False, length=10}::test_partition_invalid_negative_axis1 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_0_{external=False, length=10}::test_partition_invalid_negative_axis2 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_0_{external=False, length=10}::test_partition_invalid_negative_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_0_{external=False, length=10}::test_partition_negative_axis +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_0_{external=False, length=10}::test_partition_negative_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_0_{external=False, length=10}::test_partition_non_contiguous +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_0_{external=False, length=10}::test_partition_one_dim +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_0_{external=False, length=10}::test_partition_sequence_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_0_{external=False, length=10}::test_partition_zero_dim +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_1_{external=False, length=20000}::test_partition_axis +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_1_{external=False, length=20000}::test_partition_invalid_axis1 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_1_{external=False, length=20000}::test_partition_invalid_axis2 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_1_{external=False, length=20000}::test_partition_invalid_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_1_{external=False, length=20000}::test_partition_invalid_negative_axis1 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_1_{external=False, length=20000}::test_partition_invalid_negative_axis2 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_1_{external=False, length=20000}::test_partition_invalid_negative_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_1_{external=False, length=20000}::test_partition_negative_axis +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_1_{external=False, length=20000}::test_partition_negative_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_1_{external=False, length=20000}::test_partition_non_contiguous +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_1_{external=False, length=20000}::test_partition_one_dim +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_1_{external=False, length=20000}::test_partition_sequence_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_1_{external=False, length=20000}::test_partition_zero_dim +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_2_{external=True, length=10}::test_partition_axis +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_2_{external=True, length=10}::test_partition_invalid_axis1 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_2_{external=True, length=10}::test_partition_invalid_axis2 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_2_{external=True, length=10}::test_partition_invalid_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_2_{external=True, length=10}::test_partition_invalid_negative_axis1 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_2_{external=True, length=10}::test_partition_invalid_negative_axis2 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_2_{external=True, length=10}::test_partition_invalid_negative_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_2_{external=True, length=10}::test_partition_negative_axis +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_2_{external=True, length=10}::test_partition_negative_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_2_{external=True, length=10}::test_partition_non_contiguous +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_2_{external=True, length=10}::test_partition_none_axis +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_2_{external=True, length=10}::test_partition_one_dim +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_2_{external=True, length=10}::test_partition_sequence_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_2_{external=True, length=10}::test_partition_zero_dim +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_3_{external=True, length=20000}::test_partition_axis +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_3_{external=True, length=20000}::test_partition_invalid_axis1 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_3_{external=True, length=20000}::test_partition_invalid_axis2 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_3_{external=True, length=20000}::test_partition_invalid_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_3_{external=True, length=20000}::test_partition_invalid_negative_axis1 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_3_{external=True, length=20000}::test_partition_invalid_negative_axis2 +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_3_{external=True, length=20000}::test_partition_invalid_negative_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_3_{external=True, length=20000}::test_partition_negative_axis +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_3_{external=True, length=20000}::test_partition_negative_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_3_{external=True, length=20000}::test_partition_non_contiguous +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_3_{external=True, length=20000}::test_partition_none_axis +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_3_{external=True, length=20000}::test_partition_one_dim +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_3_{external=True, length=20000}::test_partition_sequence_kth +tests/third_party/cupy/sorting_tests/test_sort.py::TestPartition_param_3_{external=True, length=20000}::test_partition_zero_dim + +# erf +tests/test_special.py::test_erf +tests/test_special.py::test_erf_fallback +tests/test_strides.py::test_strides_erf[(10,)-int32] +tests/test_strides.py::test_strides_erf[(10,)-int64] +tests/test_strides.py::test_strides_erf[(10,)-float32] +tests/test_strides.py::test_strides_erf[(10,)-float64] +tests/test_strides.py::test_strides_erf[(10,)-None] + +# choose +tests/third_party/cupy/indexing_tests/test_indexing.py::TestChoose::test_choose +tests/third_party/cupy/indexing_tests/test_indexing.py::TestChoose::test_choose_broadcast +tests/third_party/cupy/indexing_tests/test_indexing.py::TestChoose::test_choose_broadcast2 +tests/third_party/cupy/indexing_tests/test_indexing.py::TestChoose::test_choose_broadcast_fail +tests/third_party/cupy/indexing_tests/test_indexing.py::TestChoose::test_choose_clip +tests/third_party/cupy/indexing_tests/test_indexing.py::TestChoose::test_choose_wrap +tests/third_party/cupy/indexing_tests/test_indexing.py::TestChoose::test_raise +tests/third_party/cupy/indexing_tests/test_indexing.py::TestChoose::test_unknown_clip + +# correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_0_{mode='valid', shape1=(5,), shape2=(5,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_1_{mode='valid', shape1=(5,), shape2=(6,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_2_{mode='valid', shape1=(5,), shape2=(20,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_3_{mode='valid', shape1=(5,), shape2=(21,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_4_{mode='valid', shape1=(6,), shape2=(5,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_5_{mode='valid', shape1=(6,), shape2=(6,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_6_{mode='valid', shape1=(6,), shape2=(20,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_7_{mode='valid', shape1=(6,), shape2=(21,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_8_{mode='valid', shape1=(20,), shape2=(5,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_9_{mode='valid', shape1=(20,), shape2=(6,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_10_{mode='valid', shape1=(20,), shape2=(20,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_11_{mode='valid', shape1=(20,), shape2=(21,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_12_{mode='valid', shape1=(21,), shape2=(5,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_13_{mode='valid', shape1=(21,), shape2=(6,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_14_{mode='valid', shape1=(21,), shape2=(20,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_15_{mode='valid', shape1=(21,), shape2=(21,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_16_{mode='same', shape1=(5,), shape2=(5,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_17_{mode='same', shape1=(5,), shape2=(6,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_18_{mode='same', shape1=(5,), shape2=(20,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_19_{mode='same', shape1=(5,), shape2=(21,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_20_{mode='same', shape1=(6,), shape2=(5,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_21_{mode='same', shape1=(6,), shape2=(6,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_22_{mode='same', shape1=(6,), shape2=(20,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_23_{mode='same', shape1=(6,), shape2=(21,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_24_{mode='same', shape1=(20,), shape2=(5,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_25_{mode='same', shape1=(20,), shape2=(6,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_26_{mode='same', shape1=(20,), shape2=(20,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_27_{mode='same', shape1=(20,), shape2=(21,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_28_{mode='same', shape1=(21,), shape2=(5,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_29_{mode='same', shape1=(21,), shape2=(6,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_30_{mode='same', shape1=(21,), shape2=(20,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_31_{mode='same', shape1=(21,), shape2=(21,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_32_{mode='full', shape1=(5,), shape2=(5,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_33_{mode='full', shape1=(5,), shape2=(6,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_34_{mode='full', shape1=(5,), shape2=(20,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_35_{mode='full', shape1=(5,), shape2=(21,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_36_{mode='full', shape1=(6,), shape2=(5,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_37_{mode='full', shape1=(6,), shape2=(6,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_38_{mode='full', shape1=(6,), shape2=(20,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_39_{mode='full', shape1=(6,), shape2=(21,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_40_{mode='full', shape1=(20,), shape2=(5,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_41_{mode='full', shape1=(20,), shape2=(6,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_42_{mode='full', shape1=(20,), shape2=(20,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_43_{mode='full', shape1=(20,), shape2=(21,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_44_{mode='full', shape1=(21,), shape2=(5,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_45_{mode='full', shape1=(21,), shape2=(6,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_46_{mode='full', shape1=(21,), shape2=(20,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateShapeCombination_param_47_{mode='full', shape1=(21,), shape2=(21,)}::test_correlate +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelate_param_0_{mode='valid'}::test_correlate_diff_types +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelate_param_0_{mode='valid'}::test_correlate_large_non_contiguous +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelate_param_0_{mode='valid'}::test_correlate_non_contiguous +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelate_param_1_{mode='full'}::test_correlate_diff_types +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelate_param_1_{mode='full'}::test_correlate_large_non_contiguous +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelate_param_1_{mode='full'}::test_correlate_non_contiguous +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelate_param_2_{mode='same'}::test_correlate_diff_types +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelate_param_2_{mode='same'}::test_correlate_large_non_contiguous +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelate_param_2_{mode='same'}::test_correlate_non_contiguous +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateInvalid_param_0_{mode='valid'}::test_correlate_empty +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateInvalid_param_0_{mode='valid'}::test_correlate_ndim +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateInvalid_param_0_{mode='valid'}::test_correlate_zero_dim +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateInvalid_param_1_{mode='same'}::test_correlate_empty +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateInvalid_param_1_{mode='same'}::test_correlate_ndim +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateInvalid_param_1_{mode='same'}::test_correlate_zero_dim +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateInvalid_param_2_{mode='full'}::test_correlate_empty +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateInvalid_param_2_{mode='full'}::test_correlate_ndim +tests/third_party/cupy/statistics_tests/test_correlation.py::TestCorrelateInvalid_param_2_{mode='full'}::test_correlate_zero_dim diff --git a/dpnp/tests/test_arithmetic.py b/dpnp/tests/test_arithmetic.py index 0da904b80bf..2d1741b9d22 100644 --- a/dpnp/tests/test_arithmetic.py +++ b/dpnp/tests/test_arithmetic.py @@ -9,7 +9,6 @@ class TestArithmetic(unittest.TestCase): 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) - return b @testing.for_float_dtypes() @@ -17,7 +16,6 @@ def test_modf_part1(self, xp, dtype): 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) - return c @testing.for_float_dtypes() @@ -37,5 +35,4 @@ def test_nansum(self, xp, dtype): def test_remainder(self, xp, dtype): a = xp.array([5, -3, -2, -1, -5], dtype=dtype) b = xp.full(a.size, 3, dtype=dtype) - return xp.remainder(a, b) diff --git a/dpnp/tests/test_fft.py b/dpnp/tests/test_fft.py index d2e730692ff..24f484d7c9e 100644 --- a/dpnp/tests/test_fft.py +++ b/dpnp/tests/test_fft.py @@ -13,6 +13,7 @@ get_all_dtypes, get_complex_dtypes, get_float_dtypes, + is_cuda_device, ) @@ -196,8 +197,8 @@ def test_fft_1D_out(self, dtype, n, norm): @pytest.mark.parametrize("axis", [0, 1]) def test_fft_inplace_out(self, axis): # Test some weirder in-place combinations - y = dpnp.random.rand(20, 20) + 1j * dpnp.random.rand(20, 20) - y_np = y.asnumpy() + y_np = numpy.random.rand(20, 20) + 1j * numpy.random.rand(20, 20) + y = dpnp.asarray(y_np) # Fully in-place. y1 = y.copy() expected1 = numpy.fft.fft(y1.asnumpy(), axis=axis) @@ -480,6 +481,13 @@ def setup_method(self): @pytest.mark.parametrize("norm", ["forward", "backward", "ortho"]) @pytest.mark.parametrize("order", ["C", "F"]) def test_fftn(self, dtype, axes, norm, order): + if is_cuda_device(): + if order == "C" and axes == (0, 1, 2): + pass + elif order == "F" and axes == (-1, -4, -2): + pass + else: + pytest.skip("SAT-7587") x1 = numpy.random.uniform(-10, 10, 120) x2 = numpy.random.uniform(-10, 10, 120) a_np = numpy.array(x1 + 1j * x2, dtype=dtype).reshape( @@ -522,6 +530,9 @@ def test_fftn_repeated_axes(self, axes): @pytest.mark.parametrize("axes", [(2, 3, 3, 2), (0, 0, 3, 3)]) @pytest.mark.parametrize("s", [(5, 4, 3, 3), (7, 8, 10, 9)]) def test_fftn_repeated_axes_with_s(self, axes, s): + if is_cuda_device(): + if axes == (0, 0, 3, 3) and s == (7, 8, 10, 9): + pytest.skip("SAT-7587") x1 = numpy.random.uniform(-10, 10, 120) x2 = numpy.random.uniform(-10, 10, 120) a_np = numpy.array(x1 + 1j * x2, dtype=numpy.complex64).reshape( @@ -545,6 +556,11 @@ def test_fftn_repeated_axes_with_s(self, axes, s): @pytest.mark.parametrize("axes", [(0, 1, 2, 3), (1, 2, 1, 2), (2, 2, 2, 3)]) @pytest.mark.parametrize("s", [(2, 3, 4, 5), (5, 4, 7, 8), (2, 5, 1, 2)]) def test_fftn_out(self, axes, s): + if is_cuda_device(): + if axes == (0, 1, 2, 3): + pytest.skip("SAT-7587") + elif s == (2, 5, 1, 2) and axes in [(1, 2, 1, 2), (2, 2, 2, 3)]: + pytest.skip("SAT-7587") x1 = numpy.random.uniform(-10, 10, 120) x2 = numpy.random.uniform(-10, 10, 120) a_np = numpy.array(x1 + 1j * x2, dtype=numpy.complex64).reshape( @@ -1151,6 +1167,9 @@ def test_rfftn_repeated_axes_with_s(self, axes, s): @pytest.mark.parametrize("axes", [(0, 1, 2, 3), (1, 2, 1, 2), (2, 2, 2, 3)]) @pytest.mark.parametrize("s", [(2, 3, 4, 5), (5, 6, 7, 9), (2, 5, 1, 2)]) def test_rfftn_out(self, axes, s): + if is_cuda_device(): + if axes == (0, 1, 2, 3) and s == (2, 5, 1, 2): + pytest.skip("SAT-7587") x1 = numpy.random.uniform(-10, 10, 120) a_np = numpy.array(x1, dtype=numpy.float32).reshape(2, 3, 4, 5) a = dpnp.asarray(a_np) diff --git a/dpnp/tests/test_indexing.py b/dpnp/tests/test_indexing.py index 2bff01cf1b5..ae8285bb84a 100644 --- a/dpnp/tests/test_indexing.py +++ b/dpnp/tests/test_indexing.py @@ -775,7 +775,9 @@ class TestTakeAlongAxis: ], ) def test_argequivalent(self, func, argfunc, kwargs): - a = dpnp.random.random(size=(3, 4, 5)) + # TODO: to roll back the change once the issue with CUDA support is resolved for random + # 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) diff --git a/dpnp/tests/test_linalg.py b/dpnp/tests/test_linalg.py index a0ce71b8208..265460adb31 100644 --- a/dpnp/tests/test_linalg.py +++ b/dpnp/tests/test_linalg.py @@ -23,6 +23,7 @@ get_float_complex_dtypes, has_support_aspect64, is_cpu_device, + is_cuda_device, ) from .third_party.cupy import testing @@ -367,6 +368,7 @@ def test_cond_complex(self, dtype, shape, p): expected = numpy.linalg.cond(a, p=p) assert_dtype_allclose(result, expected) + @pytest.mark.skipif(is_cuda_device(), reason="SAT-7589") @pytest.mark.parametrize( "p", [-inp.inf, -1, 1, inp.inf, "fro"], @@ -387,6 +389,9 @@ def test_cond_nan_input(self, p): ids=["None", "-dpnp.inf", "-2", "-1", "1", "2", "dpnp.inf", "fro"], ) def test_cond_nan(self, p): + if is_cuda_device(): + if p in [-inp.inf, -1, 1, inp.inf, "fro"]: + pytest.skip("SAT-7589") a = numpy.array(numpy.random.uniform(-5, 5, 16)).reshape(2, 2, 2, 2) a[0, 0] = 0 a[1, 1] = 0 @@ -1893,6 +1898,9 @@ class TestLstsq: ], ) def test_lstsq(self, a_shape, b_shape, dtype): + if is_cuda_device(): + if a_shape == (2, 4): + pytest.skip("SAT-7589") a_np = numpy.random.rand(*a_shape).astype(dtype) b_np = numpy.random.rand(*b_shape).astype(dtype) @@ -2272,6 +2280,9 @@ def test_norm_1D_complex(self, dtype, ord, axis, keepdims): ) @pytest.mark.parametrize("keepdims", [True, False]) def test_norm_2D(self, dtype, ord, axis, keepdims): + if is_cuda_device(): + if ord in [-2, 2, "nuc"] and axis == None: + pytest.skip("SAT-7589") a = numpy.array(numpy.random.uniform(-5, 5, 15), dtype=dtype).reshape( 3, 5 ) @@ -2299,6 +2310,9 @@ def test_norm_2D(self, dtype, ord, axis, keepdims): ) @pytest.mark.parametrize("keepdims", [True, False]) def test_norm_2D_complex(self, dtype, ord, axis, keepdims): + if is_cuda_device(): + if ord in [-2, 2, "nuc"] and axis == None: + pytest.skip("SAT-7589") x1 = numpy.random.uniform(-5, 5, 15) x2 = numpy.random.uniform(-5, 5, 15) a = numpy.array(x1 + 1j * x2, dtype=dtype).reshape(3, 5) @@ -2328,6 +2342,9 @@ def test_norm_2D_complex(self, dtype, ord, axis, keepdims): ) @pytest.mark.parametrize("keepdims", [True, False]) def test_norm_ND(self, dtype, ord, axis, keepdims): + if is_cuda_device(): + if ord in [-2, 2, "nuc"] and axis == (0, 1): + pytest.skip("SAT-7589") a = numpy.array(numpy.random.uniform(-5, 5, 120), dtype=dtype).reshape( 2, 3, 4, 5 ) @@ -2361,6 +2378,9 @@ def test_norm_ND(self, dtype, ord, axis, keepdims): ) @pytest.mark.parametrize("keepdims", [True, False]) def test_norm_ND_complex(self, dtype, ord, axis, keepdims): + if is_cuda_device(): + if ord in [-2, 2, "nuc"] and axis == (0, 1): + pytest.skip("SAT-7589") x1 = numpy.random.uniform(-5, 5, 120) x2 = numpy.random.uniform(-5, 5, 120) a = numpy.array(x1 + 1j * x2, dtype=dtype).reshape(2, 3, 4, 5) @@ -2394,6 +2414,9 @@ def test_norm_ND_complex(self, dtype, ord, axis, keepdims): ) @pytest.mark.parametrize("keepdims", [True, False]) def test_norm_usm_ndarray(self, dtype, ord, axis, keepdims): + if is_cuda_device(): + if ord in [-2, 2, "nuc"] and axis in [(0, 1), (-2, -1)]: + pytest.skip("SAT-7589") a = numpy.array(numpy.random.uniform(-5, 5, 120), dtype=dtype).reshape( 2, 3, 4, 5 ) @@ -2473,6 +2496,9 @@ def test_norm_strided_ND(self, axis, stride): ) @pytest.mark.parametrize("keepdims", [True, False]) def test_matrix_norm(self, ord, keepdims): + if is_cuda_device(): + if ord in [-2, 2, "nuc"]: + pytest.skip("SAT-7589") a = numpy.array(numpy.random.uniform(-5, 5, 15)).reshape(3, 5) ia = inp.array(a) @@ -2570,6 +2596,12 @@ class TestQr: ids=["r", "raw", "complete", "reduced"], ) def test_qr(self, dtype, shape, mode): + if ( + is_cuda_device() + and mode in ["complete", "reduced"] + and shape in [(16, 16), (2, 2, 4)] + ): + pytest.skip("SAT-7589") # Set seed_value=81 to prevent # random generation of the input singular matrix a = generate_random_numpy_array(shape, dtype, seed_value=81) @@ -3021,6 +3053,9 @@ def check_decomposition( ids=["(2,2)", "(3,4)", "(5,3)", "(16,16)"], ) def test_svd(self, dtype, shape): + if is_cuda_device(): + if shape == (3, 4): + pytest.skip("SAT-7589") a = numpy.arange(shape[0] * shape[1], dtype=dtype).reshape(shape) dp_a = inp.array(a) @@ -3092,6 +3127,9 @@ class TestSvdvals: ids=["(3,5)", "(4,2)", "(2,3,3)", "(3,5,2)"], ) def test_svdvals(self, dtype, shape): + if is_cuda_device(): + if shape == (3, 5): + pytest.skip("SAT-7589") a = numpy.arange(numpy.prod(shape), dtype=dtype).reshape(shape) dp_a = inp.array(a) @@ -3162,6 +3200,9 @@ def check_types_shapes(self, dp_B, np_B): ], ) def test_pinv(self, dtype, shape): + if is_cuda_device(): + if shape in [(3, 4), (2, 2, 4)]: + pytest.skip("SAT-7589") # Set seed_value=81 to prevent # random generation of the input singular matrix a = generate_random_numpy_array(shape, dtype, seed_value=81) diff --git a/dpnp/tests/test_logic.py b/dpnp/tests/test_logic.py index 44fc8baaf2e..658ef5b966b 100644 --- a/dpnp/tests/test_logic.py +++ b/dpnp/tests/test_logic.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( diff --git a/dpnp/tests/test_mathematical.py b/dpnp/tests/test_mathematical.py index baa9c60310c..211b949d3e9 100644 --- a/dpnp/tests/test_mathematical.py +++ b/dpnp/tests/test_mathematical.py @@ -30,6 +30,7 @@ get_integer_dtypes, has_support_aspect16, has_support_aspect64, + is_cuda_device, ) from .test_umath import ( _get_numpy_arrays_1in_1out, @@ -2129,6 +2130,9 @@ def test_basic(self, sign, dt): @pytest.mark.parametrize("dt", get_float_dtypes()) def test_zeros(self, dt): + if is_cuda_device(): + if dt is dpnp.float32: + pytest.skip("SAT-7588") a = numpy.array([0.0, -0.0], dtype=dt) ia = dpnp.array(a) diff --git a/dpnp/tests/test_sycl_queue.py b/dpnp/tests/test_sycl_queue.py index 74ec14c1b82..8050b56083e 100644 --- a/dpnp/tests/test_sycl_queue.py +++ b/dpnp/tests/test_sycl_queue.py @@ -16,6 +16,7 @@ assert_dtype_allclose, generate_random_numpy_array, get_all_dtypes, + is_cuda_device, is_win_platform, ) @@ -39,6 +40,9 @@ for device in available_devices: if device.default_selector_score < 0: pass + elif device.backend.name in "cuda": + valid_devices = [device] + break elif device.backend.name not in list_of_backend_str: pass elif device.device_type.name not in list_of_device_type_str: @@ -1798,6 +1802,9 @@ def test_matrix_rank(data, tol, device): ids=["-1", "0", "1", "(0, 1)", "(-2, -1)", "None"], ) def test_norm(device, ord, axis): + if is_cuda_device(): + if axis in [(0, 1), (-2, -1)] and ord in [-2, 2, "nuc"]: + pytest.skip("SAT-7589") a = numpy.arange(120).reshape(2, 3, 4, 5) ia = dpnp.array(a, device=device) if (axis in [-1, 0, 1] and ord in ["nuc", "fro"]) or ( @@ -1897,6 +1904,9 @@ def test_qr(shape, mode, device): ], ) def test_svd(shape, full_matrices, compute_uv, device): + if is_cuda_device(): + if shape in [(1, 4), (2, 2, 3)]: + pytest.skip("SAT-7589") dtype = dpnp.default_float_type(device) count_elems = numpy.prod(shape) @@ -2504,6 +2514,9 @@ def test_slogdet(shape, is_empty, device): ids=[device.filter_string for device in valid_devices], ) def test_pinv(shape, hermitian, rcond_as_array, device): + if is_cuda_device(): + if shape == (2, 2, 3): + pytest.skip("SAT-7589") dtype = dpnp.default_float_type(device) # Set seed_value=81 to prevent # random generation of the input singular matrix diff --git a/dpnp/tests/test_usm_type.py b/dpnp/tests/test_usm_type.py index 8e06639a97c..f5735138915 100644 --- a/dpnp/tests/test_usm_type.py +++ b/dpnp/tests/test_usm_type.py @@ -10,7 +10,11 @@ import dpnp as dp from dpnp.dpnp_utils import get_usm_allocations -from .helper import assert_dtype_allclose, generate_random_numpy_array +from .helper import ( + assert_dtype_allclose, + generate_random_numpy_array, + is_cuda_device, +) list_of_usm_types = ["device", "shared", "host"] @@ -542,6 +546,9 @@ def test_meshgrid(usm_type_x, usm_type_y): ids=["-1", "0", "1", "(0, 1)", "(-2, -1)", "None"], ) def test_norm(usm_type, ord, axis): + if is_cuda_device(): + if axis in [(0, 1), (-2, -1)] and ord in [-2, 2, "nuc"]: + pytest.skip("SAT-7589") ia = dp.arange(120, usm_type=usm_type).reshape(2, 3, 4, 5) if (axis in [-1, 0, 1] and ord in ["nuc", "fro"]) or ( isinstance(axis, tuple) and ord == 3 @@ -862,6 +869,11 @@ def test_split(func, data1, usm_type): @pytest.mark.parametrize("usm_type", list_of_usm_types, ids=list_of_usm_types) @pytest.mark.parametrize("p", [None, -dp.inf, -2, -1, 1, 2, dp.inf, "fro"]) def test_cond(usm_type, p): + if is_cuda_device(): + if p in [None, -2, 2]: + pass + else: + pytest.skip("SAT-7589") ia = dp.arange(32, usm_type=usm_type).reshape(2, 4, 4) result = dp.linalg.cond(ia, p=p) @@ -1445,6 +1457,9 @@ def test_inv(shape, is_empty, usm_type): ], ) def test_svd(usm_type, shape, full_matrices_param, compute_uv_param): + if is_cuda_device(): + if shape in [(1, 4), (2, 2, 3)]: + pytest.skip("SAT-7589") x = dp.ones(shape, usm_type=usm_type) if compute_uv_param: @@ -1513,6 +1528,9 @@ def test_matrix_rank(data, tol, usm_type): ], ) def test_pinv(shape, hermitian, usm_type): + if is_cuda_device(): + if shape == (2, 2, 3): + pytest.skip("SAT-7589") a_np = generate_random_numpy_array(shape, hermitian=hermitian) a = dp.array(a_np, usm_type=usm_type) diff --git a/dpnp/tests/third_party/cupy/core_tests/test_dlpack.py b/dpnp/tests/third_party/cupy/core_tests/test_dlpack.py index bce0d3a4d18..2408745e143 100644 --- a/dpnp/tests/third_party/cupy/core_tests/test_dlpack.py +++ b/dpnp/tests/third_party/cupy/core_tests/test_dlpack.py @@ -9,26 +9,21 @@ from dpnp.tests.third_party.cupy import testing +# TODO: to roll back the changes once the issue with CUDA support is resolved for random 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): diff --git a/dpnp/tests/third_party/cupy/creation_tests/test_from_data.py b/dpnp/tests/third_party/cupy/creation_tests/test_from_data.py index 679f9260fab..995b443186f 100644 --- a/dpnp/tests/third_party/cupy/creation_tests/test_from_data.py +++ b/dpnp/tests/third_party/cupy/creation_tests/test_from_data.py @@ -6,7 +6,7 @@ import pytest import dpnp as cupy -from dpnp.tests.helper import has_support_aspect64 +from dpnp.tests.helper import has_support_aspect64, is_cuda_device from dpnp.tests.third_party.cupy import testing @@ -520,7 +520,13 @@ def test_copy_multigpu(self, dtype, order): q1 = dpctl.SyclQueue() q2 = dpctl.SyclQueue() - src = cupy.random.uniform(-1, 1, (2, 3), device=q1).astype(dtype) + # TODO: remove it once the issue with CUDA support is resolved + # for dpnp.random + if is_cuda_device(): + src_np = numpy.random.uniform(-1, 1, (2, 3)).astype(dtype) + src = cupy.array(src_np, device=q1) + else: + src = cupy.random.uniform(-1, 1, (2, 3), device=q1).astype(dtype) dst = cupy.copy(src, order, device=q2) testing.assert_allclose(src, dst, rtol=0, atol=0) diff --git a/dpnp/tests/third_party/cupy/fft_tests/test_fft.py b/dpnp/tests/third_party/cupy/fft_tests/test_fft.py index 918b6e2a23f..0989029b60d 100644 --- a/dpnp/tests/third_party/cupy/fft_tests/test_fft.py +++ b/dpnp/tests/third_party/cupy/fft_tests/test_fft.py @@ -4,7 +4,7 @@ import pytest import dpnp as cupy -from dpnp.tests.helper import has_support_aspect64 +from dpnp.tests.helper import has_support_aspect64, is_cuda_device from dpnp.tests.third_party.cupy import testing @@ -162,6 +162,8 @@ class TestFft2: type_check=has_support_aspect64(), ) def test_fft2(self, xp, dtype, order): + if is_cuda_device() and self.shape == (2, 3, 4, 5): + pytest.skip("SAT-7587") a = testing.shaped_random(self.shape, xp, dtype) if order == "F": a = xp.asfortranarray(a) @@ -186,6 +188,8 @@ def test_fft2(self, xp, dtype, order): type_check=has_support_aspect64(), ) def test_ifft2(self, xp, dtype, order): + if is_cuda_device() and self.shape == (2, 3, 4, 5): + pytest.skip("SAT-7587") a = testing.shaped_random(self.shape, xp, dtype) if order == "F": a = xp.asfortranarray(a) @@ -249,6 +253,8 @@ class TestFftn: type_check=has_support_aspect64(), ) def test_fftn(self, xp, dtype, order): + if is_cuda_device() and self.shape == (2, 3, 4, 5): + pytest.skip("SAT-7587") a = testing.shaped_random(self.shape, xp, dtype) if order == "F": a = xp.asfortranarray(a) @@ -273,6 +279,8 @@ def test_fftn(self, xp, dtype, order): type_check=has_support_aspect64(), ) def test_ifftn(self, xp, dtype, order): + if is_cuda_device() and self.shape == (2, 3, 4, 5): + pytest.skip("SAT-7587") a = testing.shaped_random(self.shape, xp, dtype) if order == "F": a = xp.asfortranarray(a) diff --git a/dpnp/tests/third_party/cupy/linalg_tests/test_decomposition.py b/dpnp/tests/third_party/cupy/linalg_tests/test_decomposition.py index d2c3ac69aac..6960c1e628b 100644 --- a/dpnp/tests/third_party/cupy/linalg_tests/test_decomposition.py +++ b/dpnp/tests/third_party/cupy/linalg_tests/test_decomposition.py @@ -7,6 +7,7 @@ from dpnp.tests.helper import ( has_support_aspect64, is_cpu_device, + is_cuda_device, is_win_platform, ) from dpnp.tests.third_party.cupy import testing @@ -256,13 +257,17 @@ def check_singular(self, shape, xp, dtype): @_condition.repeat(3, 10) def test_svd_rank2(self): - self.check_usv((3, 7)) + # skip case where n < m on CUDA (SAT-7589) + if not is_cuda_device(): + self.check_usv((3, 7)) self.check_usv((2, 2)) self.check_usv((7, 3)) @_condition.repeat(3, 10) def test_svd_rank2_no_uv(self): - self.check_singular((3, 7)) + # SAT-7589 + if not is_cuda_device(): + self.check_singular((3, 7)) self.check_singular((2, 2)) self.check_singular((7, 3)) @@ -288,8 +293,10 @@ def test_svd_rank2_empty_array_compute_uv_false(self, xp): ) @_condition.repeat(3, 10) def test_svd_rank3(self): - self.check_usv((2, 3, 4)) - self.check_usv((2, 3, 7)) + # SAT-7589 + if not is_cuda_device(): + self.check_usv((2, 3, 4)) + self.check_usv((2, 3, 7)) self.check_usv((2, 4, 4)) self.check_usv((2, 7, 3)) self.check_usv((2, 4, 3)) @@ -303,12 +310,16 @@ def test_svd_rank3_loop(self): # This tests the loop-based batched gesvd on CUDA (_gesvd_batched) self.check_usv((2, 64, 64)) self.check_usv((2, 64, 32)) - self.check_usv((2, 32, 64)) + # SAT-7589 + if not is_cuda_device(): + self.check_usv((2, 32, 64)) @_condition.repeat(3, 10) def test_svd_rank3_no_uv(self): - self.check_singular((2, 3, 4)) - self.check_singular((2, 3, 7)) + # SAT-7589 + if not is_cuda_device(): + self.check_singular((2, 3, 4)) + self.check_singular((2, 3, 7)) self.check_singular((2, 4, 4)) self.check_singular((2, 7, 3)) self.check_singular((2, 4, 3)) @@ -318,7 +329,9 @@ def test_svd_rank3_no_uv_loop(self): # This tests the loop-based batched gesvd on CUDA (_gesvd_batched) self.check_singular((2, 64, 64)) self.check_singular((2, 64, 32)) - self.check_singular((2, 32, 64)) + # SAT-7589 + if not is_cuda_device(): + self.check_singular((2, 32, 64)) @testing.with_requires("numpy>=1.16") def test_svd_rank3_empty_array(self): @@ -350,8 +363,10 @@ def test_svd_rank3_empty_array_compute_uv_false2(self, xp): ) @_condition.repeat(3, 10) def test_svd_rank4(self): - self.check_usv((2, 2, 3, 4)) - self.check_usv((2, 2, 3, 7)) + # SAT-7589 + if not is_cuda_device(): + self.check_usv((2, 2, 3, 4)) + self.check_usv((2, 2, 3, 7)) self.check_usv((2, 2, 4, 4)) self.check_usv((2, 2, 7, 3)) self.check_usv((2, 2, 4, 3)) @@ -365,12 +380,16 @@ def test_svd_rank4_loop(self): # This tests the loop-based batched gesvd on CUDA (_gesvd_batched) self.check_usv((3, 2, 64, 64)) self.check_usv((3, 2, 64, 32)) - self.check_usv((3, 2, 32, 64)) + # SAT-7589 + if not is_cuda_device(): + self.check_usv((3, 2, 32, 64)) @_condition.repeat(3, 10) def test_svd_rank4_no_uv(self): - self.check_singular((2, 2, 3, 4)) - self.check_singular((2, 2, 3, 7)) + # SAT-7589 + if not is_cuda_device(): + self.check_singular((2, 2, 3, 4)) + self.check_singular((2, 2, 3, 7)) self.check_singular((2, 2, 4, 4)) self.check_singular((2, 2, 7, 3)) self.check_singular((2, 2, 4, 3)) @@ -380,7 +399,9 @@ def test_svd_rank4_no_uv_loop(self): # This tests the loop-based batched gesvd on CUDA (_gesvd_batched) self.check_singular((3, 2, 64, 64)) self.check_singular((3, 2, 64, 32)) - self.check_singular((3, 2, 32, 64)) + # SAT-7589 + if not is_cuda_device(): + self.check_singular((3, 2, 32, 64)) @testing.with_requires("numpy>=1.16") def test_svd_rank4_empty_array(self): @@ -398,7 +419,14 @@ def test_svd_rank4_empty_array(self): ) class TestQRDecomposition(unittest.TestCase): @testing.for_dtypes("fdFD") + # skip cases with 'complete' and 'reduce' modes on CUDA (SAT-7589) def check_mode(self, array, mode, dtype): + if ( + is_cuda_device() + and array.size > 0 + and mode in ["complete", "reduced"] + ): + return a_cpu = numpy.asarray(array, dtype=dtype) a_gpu = cupy.asarray(array, dtype=dtype) result_gpu = cupy.linalg.qr(a_gpu, mode=mode) diff --git a/dpnp/tests/third_party/cupy/linalg_tests/test_norms.py b/dpnp/tests/third_party/cupy/linalg_tests/test_norms.py index 786428707a8..07b583b1c63 100644 --- a/dpnp/tests/third_party/cupy/linalg_tests/test_norms.py +++ b/dpnp/tests/third_party/cupy/linalg_tests/test_norms.py @@ -4,7 +4,7 @@ import pytest import dpnp as cupy -from dpnp.tests.helper import is_cpu_device +from dpnp.tests.helper import is_cpu_device, is_cuda_device from dpnp.tests.third_party.cupy import testing @@ -62,6 +62,12 @@ class TestNorm(unittest.TestCase): @testing.numpy_cupy_allclose(rtol=1e-3, atol=1e-4, type_check=False) # since dtype of sum is different in dpnp and NumPy, type_check=False def test_norm(self, xp, dtype): + if ( + is_cuda_device() + and self.shape == (1, 2) + and self.ord in [-2, 2, "nuc"] + ): + pytest.skip("SAT-7589") a = testing.shaped_arange(self.shape, xp, dtype) res = xp.linalg.norm(a, self.ord, self.axis, self.keepdims) if xp == numpy and not isinstance(res, numpy.ndarray): diff --git a/dpnp/tests/third_party/cupy/linalg_tests/test_solve.py b/dpnp/tests/third_party/cupy/linalg_tests/test_solve.py index 5fb6533be33..adb0bb5d862 100644 --- a/dpnp/tests/third_party/cupy/linalg_tests/test_solve.py +++ b/dpnp/tests/third_party/cupy/linalg_tests/test_solve.py @@ -7,6 +7,7 @@ from dpnp.tests.helper import ( assert_dtype_allclose, has_support_aspect64, + is_cuda_device, ) from dpnp.tests.third_party.cupy import testing from dpnp.tests.third_party.cupy.testing import _condition @@ -62,8 +63,15 @@ 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) + # TODO: to roll back the change once the issue with CUDA support is resolved for random + # 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) @@ -142,7 +150,9 @@ 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) + # TODO: to roll back the change once the issue with CUDA support is resolved for random + # a = cupy.random.rand(*a_shape) + a = cupy.asarray(numpy.random.rand(*a_shape)) with self.assertRaises(cupy.linalg.LinAlgError): cupy.linalg.inv(a) @@ -207,17 +217,23 @@ def check_x(self, a_shape, rcond, dtype): def test_pinv(self): self.check_x((3, 3), rcond=1e-15) - self.check_x((2, 4), rcond=1e-15) + # skip case where n < m on CUDA (SAT-7589) + if not is_cuda_device(): + self.check_x((2, 4), rcond=1e-15) self.check_x((3, 2), rcond=1e-15) self.check_x((4, 4), rcond=0.3) - self.check_x((2, 5), rcond=0.5) + # SAT-7589 + if not is_cuda_device(): + self.check_x((2, 5), rcond=0.5) self.check_x((5, 3), rcond=0.6) + @pytest.mark.skipif(is_cuda_device(), reason="SAT-7589") def test_pinv_batched(self): self.check_x((2, 3, 4), rcond=1e-15) self.check_x((2, 3, 4, 5), rcond=1e-15) + @pytest.mark.skipif(is_cuda_device(), reason="SAT-7589") def test_pinv_batched_vector_rcond(self): self.check_x((2, 3, 4), rcond=[0.2, 0.8]) self.check_x((2, 3, 4, 5), rcond=[[0.2, 0.9, 0.1], [0.7, 0.2, 0.5]]) @@ -259,11 +275,15 @@ 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) + # TODO: to roll back the change once the issue with CUDA support is resolved for random + # 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) + @pytest.mark.skipif(is_cuda_device(), reason="SAT-7589") def test_lstsq_solutions(self): # Compares numpy.linalg.lstsq and cupy.linalg.lstsq solutions for: # a shapes range from (3, 3) to (5, 3) and (3, 5) @@ -335,12 +355,16 @@ 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) + # TODO: to roll back the change once the issue with CUDA support is resolved for random + # 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) + # TODO: to roll back the change once the issue with CUDA support is resolved for random + # a = cupy.random.rand(*a_shape) + a = cupy.asarray(numpy.random.rand(*a_shape)) with self.assertRaises(ValueError): cupy.linalg.tensorinv(a, ind=ind) diff --git a/dpnp/tests/third_party/cupy/math_tests/test_rational.py b/dpnp/tests/third_party/cupy/math_tests/test_rational.py index 218bd791805..9895b39ab01 100644 --- a/dpnp/tests/third_party/cupy/math_tests/test_rational.py +++ b/dpnp/tests/third_party/cupy/math_tests/test_rational.py @@ -1,16 +1,28 @@ import unittest +import numpy import pytest import dpnp as cupy +from dpnp.tests.helper import is_cuda_device from dpnp.tests.third_party.cupy import testing class TestRational(unittest.TestCase): @testing.for_dtypes(["?", "e", "f", "d", "F", "D"]) def test_gcd_dtype_check(self, dtype): - a = cupy.random.randint(-10, 10, size=(10, 10)).astype(dtype) - b = cupy.random.randint(-10, 10, size=(10, 10)).astype(dtype) + # TODO: remove it once the issue with CUDA support is resolved + # for dpnp.random + if is_cuda_device(): + a = cupy.asarray( + numpy.random.randint(-10, 10, size=(10, 10)).astype(dtype) + ) + b = cupy.asarray( + numpy.random.randint(-10, 10, size=(10, 10)).astype(dtype) + ) + else: + a = cupy.random.randint(-10, 10, size=(10, 10)).astype(dtype) + b = cupy.random.randint(-10, 10, size=(10, 10)).astype(dtype) with pytest.raises(ValueError): cupy.gcd(a, b) @@ -23,8 +35,16 @@ def test_gcd_check_boundary_cases(self, xp, dtype): @testing.for_dtypes(["?", "e", "f", "d", "F", "D"]) def test_lcm_dtype_check(self, dtype): - a = cupy.random.randint(-10, 10, size=(10, 10)).astype(dtype) - b = cupy.random.randint(-10, 10, size=(10, 10)).astype(dtype) + if is_cuda_device(): + a = cupy.asarray( + numpy.random.randint(-10, 10, size=(10, 10)).astype(dtype) + ) + b = cupy.asarray( + numpy.random.randint(-10, 10, size=(10, 10)).astype(dtype) + ) + else: + a = cupy.random.randint(-10, 10, size=(10, 10)).astype(dtype) + b = cupy.random.randint(-10, 10, size=(10, 10)).astype(dtype) with pytest.raises(ValueError): cupy.lcm(a, b) diff --git a/dpnp/tests/third_party/cupy/random_tests/test_sample.py b/dpnp/tests/third_party/cupy/random_tests/test_sample.py index 8ce99ca4fdf..868602afa88 100644 --- a/dpnp/tests/third_party/cupy/random_tests/test_sample.py +++ b/dpnp/tests/third_party/cupy/random_tests/test_sample.py @@ -52,7 +52,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) @@ -131,11 +131,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) diff --git a/dpnp/tests/third_party/cupy/statistics_tests/test_histogram.py b/dpnp/tests/third_party/cupy/statistics_tests/test_histogram.py index 88832a070aa..cc018e56ec8 100644 --- a/dpnp/tests/third_party/cupy/statistics_tests/test_histogram.py +++ b/dpnp/tests/third_party/cupy/statistics_tests/test_histogram.py @@ -140,7 +140,9 @@ def test_histogram_float_weights_dtype(self, xp, dtype): return h def test_histogram_weights_basic(self): - v = cupy.random.rand(100) + # TODO: to roll back the change once the issue with CUDA support is resolved for random + # v = cupy.random.rand(100) + v = cupy.asarray(numpy.random.rand(100)) w = cupy.ones(100) * 5 a, b = cupy.histogram(v) na, nb = cupy.histogram(v, density=True) diff --git a/dpnp/tests/third_party/cupy/testing/_random.py b/dpnp/tests/third_party/cupy/testing/_random.py index a4dc897bb9c..4f7e529afb5 100644 --- a/dpnp/tests/third_party/cupy/testing/_random.py +++ b/dpnp/tests/third_party/cupy/testing/_random.py @@ -8,6 +8,7 @@ import numpy import dpnp as cupy +from dpnp.tests.helper import is_cuda_device _old_python_random_state = None _old_numpy_random_state = None @@ -33,11 +34,15 @@ def do_setup(deterministic=True): if not deterministic: random.seed() numpy.random.seed() - cupy.random.seed() + # TODO: remove it once the issue with CUDA support is resolved + # for dpnp.random + if not is_cuda_device(): + cupy.random.seed() else: random.seed(99) numpy.random.seed(100) - cupy.random.seed(101) + if not is_cuda_device(): + cupy.random.seed(101) def do_teardown():