diff --git a/dpnp/dpnp_iface.py b/dpnp/dpnp_iface.py index 7da1ca23430..a852d1c7fd8 100644 --- a/dpnp/dpnp_iface.py +++ b/dpnp/dpnp_iface.py @@ -68,6 +68,7 @@ "get_result_array", "get_usm_ndarray", "get_usm_ndarray_or_scalar", + "is_cuda_backend", "is_supported_array_or_scalar", "is_supported_array_type", "synchronize_array_data", @@ -681,6 +682,41 @@ 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 data of the input object resides on 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 46e0d610ced..85547433a8f 100644 --- a/dpnp/dpnp_iface_indexing.py +++ b/dpnp/dpnp_iface_indexing.py @@ -128,6 +128,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 = [] @@ -137,6 +138,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 c814ccb9f92..9bb6328cb19 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 cd3a658a1e5..25d8c7e01c8 100644 --- a/dpnp/dpnp_iface_mathematical.py +++ b/dpnp/dpnp_iface_mathematical.py @@ -2945,8 +2945,16 @@ 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 kwargs: + pass + else: + 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 b045b9a9c65..010491887bb 100644 --- a/dpnp/dpnp_iface_sorting.py +++ b/dpnp/dpnp_iface_sorting.py @@ -192,6 +192,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/random/dpnp_iface_random.py b/dpnp/random/dpnp_iface_random.py index 07fe858c44c..74c7d378b19 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): @@ -1427,6 +1524,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): @@ -1503,6 +1605,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: @@ -1547,6 +1655,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: @@ -1587,6 +1700,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) @@ -1612,6 +1729,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) @@ -1640,6 +1761,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): @@ -1718,6 +1844,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): @@ -1754,6 +1885,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): @@ -1862,6 +1998,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): @@ -1898,6 +2039,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): @@ -1934,6 +2080,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): @@ -1966,6 +2117,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 7df58cb2e1c..7cd6e05c81f 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(self): + 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(self): + 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(self): + 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 5bd99223ece..c931182c12b 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 ff378bd0434..e0c200374fd 100644 --- a/dpnp/tests/helper.py +++ b/dpnp/tests/helper.py @@ -248,6 +248,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..563a1fb69d6 --- /dev/null +++ b/dpnp/tests/skipped_tests_cuda.tbl @@ -0,0 +1,830 @@ +# 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_full_range +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-args0-kwargs0] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-rand-args1-kwargs1] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-randint-args2-kwargs2] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-randn-args3-kwargs3] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-random-args4-kwargs4] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-random_integers-args5-kwargs5] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-random_sample-args6-kwargs6] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-ranf-args7-kwargs7] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-sample-args8-kwargs8] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-standard_normal-args9-kwargs9] +tests/test_sycl_queue.py::test_random[host-cuda:gpu:0-uniform-args10-kwargs10] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-normal-args0-kwargs0] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-rand-args1-kwargs1] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-randint-args2-kwargs2] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-randn-args3-kwargs3] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-random-args4-kwargs4] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-random_integers-args5-kwargs5] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-random_sample-args6-kwargs6] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-ranf-args7-kwargs7] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-sample-args8-kwargs8] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-standard_normal-args9-kwargs9] +tests/test_sycl_queue.py::test_random[device-cuda:gpu:0-uniform-args10-kwargs10] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-normal-args0-kwargs0] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-rand-args1-kwargs1] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-randint-args2-kwargs2] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-randn-args3-kwargs3] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-random-args4-kwargs4] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-random_integers-args5-kwargs5] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-random_sample-args6-kwargs6] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-ranf-args7-kwargs7] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-sample-args8-kwargs8] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-standard_normal-args9-kwargs9] +tests/test_sycl_queue.py::test_random[shared-cuda:gpu:0-uniform-args10-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::test_beta[_param_0_{a_shape=(), b_shape=(), dtype=None, shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsBeta::test_beta[_param_1_{a_shape=(), b_shape=(), dtype=None, shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsBeta::test_beta[_param_2_{a_shape=(), b_shape=(3, 2), dtype=None, shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsBeta::test_beta[_param_3_{a_shape=(), b_shape=(3, 2), dtype=None, shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsBeta::test_beta[_param_4_{a_shape=(3, 2), b_shape=(), dtype=None, shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsBeta::test_beta[_param_5_{a_shape=(3, 2), b_shape=(), dtype=None, shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsBeta::test_beta[_param_6_{a_shape=(3, 2), b_shape=(3, 2), dtype=None, shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsBeta::test_beta[_param_7_{a_shape=(3, 2), b_shape=(3, 2), dtype=None, shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsChisquare::test_chisquare[_param_0_{df_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsChisquare::test_chisquare[_param_1_{df_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsChisquare::test_chisquare[_param_2_{df_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsChisquare::test_chisquare[_param_3_{df_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsExponential::test_exponential[_param_0_{scale_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsExponential::test_exponential[_param_1_{scale_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsExponential::test_exponential[_param_2_{scale_shape=(), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsExponential::test_exponential[_param_3_{scale_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsExponential::test_exponential[_param_4_{scale_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsExponential::test_exponential[_param_5_{scale_shape=(3, 2), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsExponentialError::test_negative_scale +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF::test_f[_param_0_{dfden_shape=(), dfnum_shape=(), dtype=None, shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF::test_f[_param_1_{dfden_shape=(), dfnum_shape=(), dtype=None, shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF::test_f[_param_2_{dfden_shape=(), dfnum_shape=(3, 2), dtype=None, shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF::test_f[_param_3_{dfden_shape=(), dfnum_shape=(3, 2), dtype=None, shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF::test_f[_param_4_{dfden_shape=(3, 2), dfnum_shape=(), dtype=None, shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF::test_f[_param_5_{dfden_shape=(3, 2), dfnum_shape=(), dtype=None, shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF::test_f[_param_6_{dfden_shape=(3, 2), dfnum_shape=(3, 2), dtype=None, shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsF::test_f[_param_7_{dfden_shape=(3, 2), dfnum_shape=(3, 2), dtype=None, shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma::test_gamma_legacy[_param_0_{dtype=None, scale_shape=(), shape=(4, 3, 2), shape_shape=()}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma::test_gamma_legacy[_param_1_{dtype=None, scale_shape=(), shape=(4, 3, 2), shape_shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma::test_gamma_legacy[_param_2_{dtype=None, scale_shape=(), shape=(3, 2), shape_shape=()}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma::test_gamma_legacy[_param_3_{dtype=None, scale_shape=(), shape=(3, 2), shape_shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma::test_gamma_legacy[_param_4_{dtype=None, scale_shape=(), shape=None, shape_shape=()}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma::test_gamma_legacy[_param_5_{dtype=None, scale_shape=(), shape=None, shape_shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma::test_gamma_legacy[_param_6_{dtype=None, scale_shape=(3, 2), shape=(4, 3, 2), shape_shape=()}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma::test_gamma_legacy[_param_7_{dtype=None, scale_shape=(3, 2), shape=(4, 3, 2), shape_shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma::test_gamma_legacy[_param_8_{dtype=None, scale_shape=(3, 2), shape=(3, 2), shape_shape=()}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma::test_gamma_legacy[_param_9_{dtype=None, scale_shape=(3, 2), shape=(3, 2), shape_shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma::test_gamma_legacy[_param_10_{dtype=None, scale_shape=(3, 2), shape=None, shape_shape=()}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGamma::test_gamma_legacy[_param_11_{dtype=None, scale_shape=(3, 2), shape=None, shape_shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGeometric::test_geometric[_param_0_{dtype=None, p_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGeometric::test_geometric[_param_1_{dtype=None, p_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGeometric::test_geometric[_param_2_{dtype=None, p_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGeometric::test_geometric[_param_3_{dtype=None, p_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGumbel::test_gumbel[_param_0_{loc_shape=(), scale_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGumbel::test_gumbel[_param_1_{loc_shape=(), scale_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGumbel::test_gumbel[_param_2_{loc_shape=(), scale_shape=(), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGumbel::test_gumbel[_param_3_{loc_shape=(), scale_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGumbel::test_gumbel[_param_4_{loc_shape=(), scale_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGumbel::test_gumbel[_param_5_{loc_shape=(), scale_shape=(3, 2), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGumbel::test_gumbel[_param_6_{loc_shape=(3, 2), scale_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGumbel::test_gumbel[_param_7_{loc_shape=(3, 2), scale_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGumbel::test_gumbel[_param_8_{loc_shape=(3, 2), scale_shape=(), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGumbel::test_gumbel[_param_9_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGumbel::test_gumbel[_param_10_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsGumbel::test_gumbel[_param_11_{loc_shape=(3, 2), scale_shape=(3, 2), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_0_{dtype=None, nbad_shape=(), ngood_shape=(), nsample_dtype=int32, nsample_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_1_{dtype=None, nbad_shape=(), ngood_shape=(), nsample_dtype=int32, nsample_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_2_{dtype=None, nbad_shape=(), ngood_shape=(), nsample_dtype=int32, nsample_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_3_{dtype=None, nbad_shape=(), ngood_shape=(), nsample_dtype=int32, nsample_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_4_{dtype=None, nbad_shape=(), ngood_shape=(), nsample_dtype=int64, nsample_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_5_{dtype=None, nbad_shape=(), ngood_shape=(), nsample_dtype=int64, nsample_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_6_{dtype=None, nbad_shape=(), ngood_shape=(), nsample_dtype=int64, nsample_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_7_{dtype=None, nbad_shape=(), ngood_shape=(), nsample_dtype=int64, nsample_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_8_{dtype=None, nbad_shape=(), ngood_shape=(3, 2), nsample_dtype=int32, nsample_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_9_{dtype=None, nbad_shape=(), ngood_shape=(3, 2), nsample_dtype=int32, nsample_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_10_{dtype=None, nbad_shape=(), ngood_shape=(3, 2), nsample_dtype=int32, nsample_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_11_{dtype=None, nbad_shape=(), ngood_shape=(3, 2), nsample_dtype=int32, nsample_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_12_{dtype=None, nbad_shape=(), ngood_shape=(3, 2), nsample_dtype=int64, nsample_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_13_{dtype=None, nbad_shape=(), ngood_shape=(3, 2), nsample_dtype=int64, nsample_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_14_{dtype=None, nbad_shape=(), ngood_shape=(3, 2), nsample_dtype=int64, nsample_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_15_{dtype=None, nbad_shape=(), ngood_shape=(3, 2), nsample_dtype=int64, nsample_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_16_{dtype=None, nbad_shape=(3, 2), ngood_shape=(), nsample_dtype=int32, nsample_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_17_{dtype=None, nbad_shape=(3, 2), ngood_shape=(), nsample_dtype=int32, nsample_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_18_{dtype=None, nbad_shape=(3, 2), ngood_shape=(), nsample_dtype=int32, nsample_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_19_{dtype=None, nbad_shape=(3, 2), ngood_shape=(), nsample_dtype=int32, nsample_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_20_{dtype=None, nbad_shape=(3, 2), ngood_shape=(), nsample_dtype=int64, nsample_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_21_{dtype=None, nbad_shape=(3, 2), ngood_shape=(), nsample_dtype=int64, nsample_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_22_{dtype=None, nbad_shape=(3, 2), ngood_shape=(), nsample_dtype=int64, nsample_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_23_{dtype=None, nbad_shape=(3, 2), ngood_shape=(), nsample_dtype=int64, nsample_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_24_{dtype=None, nbad_shape=(3, 2), ngood_shape=(3, 2), nsample_dtype=int32, nsample_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_25_{dtype=None, nbad_shape=(3, 2), ngood_shape=(3, 2), nsample_dtype=int32, nsample_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_26_{dtype=None, nbad_shape=(3, 2), ngood_shape=(3, 2), nsample_dtype=int32, nsample_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_27_{dtype=None, nbad_shape=(3, 2), ngood_shape=(3, 2), nsample_dtype=int32, nsample_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_28_{dtype=None, nbad_shape=(3, 2), ngood_shape=(3, 2), nsample_dtype=int64, nsample_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_29_{dtype=None, nbad_shape=(3, 2), ngood_shape=(3, 2), nsample_dtype=int64, nsample_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_30_{dtype=None, nbad_shape=(3, 2), ngood_shape=(3, 2), nsample_dtype=int64, nsample_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsHyperGeometric::test_hypergeometric[_param_31_{dtype=None, nbad_shape=(3, 2), ngood_shape=(3, 2), nsample_dtype=int64, nsample_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsuLaplace::test_laplace[_param_0_{loc_shape=(), scale_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsuLaplace::test_laplace[_param_1_{loc_shape=(), scale_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsuLaplace::test_laplace[_param_2_{loc_shape=(), scale_shape=(), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsuLaplace::test_laplace[_param_3_{loc_shape=(), scale_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsuLaplace::test_laplace[_param_4_{loc_shape=(), scale_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsuLaplace::test_laplace[_param_5_{loc_shape=(), scale_shape=(3, 2), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsuLaplace::test_laplace[_param_6_{loc_shape=(3, 2), scale_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsuLaplace::test_laplace[_param_7_{loc_shape=(3, 2), scale_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsuLaplace::test_laplace[_param_8_{loc_shape=(3, 2), scale_shape=(), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsuLaplace::test_laplace[_param_9_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsuLaplace::test_laplace[_param_10_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsuLaplace::test_laplace[_param_11_{loc_shape=(3, 2), scale_shape=(3, 2), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLogistic::test_logistic[_param_0_{loc_shape=(), scale_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLogistic::test_logistic[_param_1_{loc_shape=(), scale_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLogistic::test_logistic[_param_2_{loc_shape=(), scale_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLogistic::test_logistic[_param_3_{loc_shape=(), scale_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLogistic::test_logistic[_param_4_{loc_shape=(3, 2), scale_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLogistic::test_logistic[_param_5_{loc_shape=(3, 2), scale_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLogistic::test_logistic[_param_6_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLogistic::test_logistic[_param_7_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLognormal::test_lognormal[_param_0_{mean_shape=(), shape=(4, 3, 2), sigma_shape=()}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLognormal::test_lognormal[_param_1_{mean_shape=(), shape=(4, 3, 2), sigma_shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLognormal::test_lognormal[_param_2_{mean_shape=(), shape=(3, 2), sigma_shape=()}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLognormal::test_lognormal[_param_3_{mean_shape=(), shape=(3, 2), sigma_shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLognormal::test_lognormal[_param_4_{mean_shape=(), shape=None, sigma_shape=()}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLognormal::test_lognormal[_param_5_{mean_shape=(), shape=None, sigma_shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLognormal::test_lognormal[_param_6_{mean_shape=(3, 2), shape=(4, 3, 2), sigma_shape=()}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLognormal::test_lognormal[_param_7_{mean_shape=(3, 2), shape=(4, 3, 2), sigma_shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLognormal::test_lognormal[_param_8_{mean_shape=(3, 2), shape=(3, 2), sigma_shape=()}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLognormal::test_lognormal[_param_9_{mean_shape=(3, 2), shape=(3, 2), sigma_shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLognormal::test_lognormal[_param_10_{mean_shape=(3, 2), shape=None, sigma_shape=()}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsLognormal::test_lognormal[_param_11_{mean_shape=(3, 2), shape=None, sigma_shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial[_param_0_{dtype=None, n_shape=(), p_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial[_param_1_{dtype=None, n_shape=(), p_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial[_param_2_{dtype=None, n_shape=(), p_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial[_param_3_{dtype=None, n_shape=(), p_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial[_param_4_{dtype=None, n_shape=(3, 2), p_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial[_param_5_{dtype=None, n_shape=(3, 2), p_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial[_param_6_{dtype=None, n_shape=(3, 2), p_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial[_param_7_{dtype=None, n_shape=(3, 2), p_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial_for_noninteger_n[_param_0_{dtype=None, n_shape=(), p_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial_for_noninteger_n[_param_1_{dtype=None, n_shape=(), p_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial_for_noninteger_n[_param_2_{dtype=None, n_shape=(), p_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial_for_noninteger_n[_param_3_{dtype=None, n_shape=(), p_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial_for_noninteger_n[_param_4_{dtype=None, n_shape=(3, 2), p_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial_for_noninteger_n[_param_5_{dtype=None, n_shape=(3, 2), p_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial_for_noninteger_n[_param_6_{dtype=None, n_shape=(3, 2), p_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNegativeBinomial::test_negative_binomial_for_noninteger_n[_param_7_{dtype=None, n_shape=(3, 2), p_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare[_param_0_{df_shape=(), dtype=None, nonc_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare[_param_1_{df_shape=(), dtype=None, nonc_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare[_param_2_{df_shape=(), dtype=None, nonc_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare[_param_3_{df_shape=(), dtype=None, nonc_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare[_param_4_{df_shape=(3, 2), dtype=None, nonc_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare[_param_5_{df_shape=(3, 2), dtype=None, nonc_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare[_param_6_{df_shape=(3, 2), dtype=None, nonc_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare[_param_7_{df_shape=(3, 2), dtype=None, nonc_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare_for_invalid_params[_param_0_{df_shape=(), dtype=None, nonc_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare_for_invalid_params[_param_1_{df_shape=(), dtype=None, nonc_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare_for_invalid_params[_param_2_{df_shape=(), dtype=None, nonc_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare_for_invalid_params[_param_3_{df_shape=(), dtype=None, nonc_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare_for_invalid_params[_param_4_{df_shape=(3, 2), dtype=None, nonc_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare_for_invalid_params[_param_5_{df_shape=(3, 2), dtype=None, nonc_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare_for_invalid_params[_param_6_{df_shape=(3, 2), dtype=None, nonc_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNoncentralChisquare::test_noncentral_chisquare_for_invalid_params[_param_7_{df_shape=(3, 2), dtype=None, nonc_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal::test_normal[_param_0_{loc_shape=(), scale_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal::test_normal[_param_1_{loc_shape=(), scale_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal::test_normal[_param_2_{loc_shape=(), scale_shape=(), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal::test_normal[_param_3_{loc_shape=(), scale_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal::test_normal[_param_4_{loc_shape=(), scale_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal::test_normal[_param_5_{loc_shape=(), scale_shape=(3, 2), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal::test_normal[_param_6_{loc_shape=(3, 2), scale_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal::test_normal[_param_7_{loc_shape=(3, 2), scale_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal::test_normal[_param_8_{loc_shape=(3, 2), scale_shape=(), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal::test_normal[_param_9_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal::test_normal[_param_10_{loc_shape=(3, 2), scale_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsNormal::test_normal[_param_11_{loc_shape=(3, 2), scale_shape=(3, 2), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPareto::test_pareto[_param_0_{a_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPareto::test_pareto[_param_1_{a_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPareto::test_pareto[_param_2_{a_shape=(), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPareto::test_pareto[_param_3_{a_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPareto::test_pareto[_param_4_{a_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPareto::test_pareto[_param_5_{a_shape=(3, 2), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPoisson::test_poisson_legacy[_param_0_{lam_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPoisson::test_poisson_legacy[_param_1_{lam_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPoisson::test_poisson_legacy[_param_2_{lam_shape=(), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPoisson::test_poisson_legacy[_param_3_{lam_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPoisson::test_poisson_legacy[_param_4_{lam_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPoisson::test_poisson_legacy[_param_5_{lam_shape=(3, 2), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPoissonInvalid::test_none_lam_legacy +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPower::test_power[_param_0_{a_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPower::test_power[_param_1_{a_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPower::test_power_for_negative_a[_param_0_{a_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsPower::test_power_for_negative_a[_param_1_{a_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh[_param_0_{scale_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh[_param_1_{scale_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh[_param_2_{scale_shape=(), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh[_param_3_{scale_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh[_param_4_{scale_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh[_param_5_{scale_shape=(3, 2), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh_for_zero_scale[_param_0_{scale_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh_for_zero_scale[_param_1_{scale_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh_for_zero_scale[_param_2_{scale_shape=(), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh_for_zero_scale[_param_3_{scale_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh_for_zero_scale[_param_4_{scale_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh_for_zero_scale[_param_5_{scale_shape=(3, 2), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh_for_negative_scale[_param_0_{scale_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh_for_negative_scale[_param_1_{scale_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh_for_negative_scale[_param_2_{scale_shape=(), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh_for_negative_scale[_param_3_{scale_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh_for_negative_scale[_param_4_{scale_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsRayleigh::test_rayleigh_for_negative_scale[_param_5_{scale_shape=(3, 2), shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardCauchy::test_standard_cauchy[_param_0_{shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardCauchy::test_standard_cauchy[_param_1_{shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardExponential::test_standard_exponential[_param_0_{shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardExponential::test_standard_exponential[_param_1_{shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardExponential::test_standard_exponential[_param_2_{shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardGamma::test_standard_gamma_legacy[_param_0_{shape=(4, 3, 2), shape_shape=()}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardGamma::test_standard_gamma_legacy[_param_1_{shape=(4, 3, 2), shape_shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardGamma::test_standard_gamma_legacy[_param_2_{shape=(3, 2), shape_shape=()}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardGamma::test_standard_gamma_legacy[_param_3_{shape=(3, 2), shape_shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardGamma::test_standard_gamma_legacy[_param_4_{shape=None, shape_shape=()}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardGamma::test_standard_gamma_legacy[_param_5_{shape=None, shape_shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardGammaInvalid::test_none_shape_legacy +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardNormal::test_standard_normal[_param_0_{shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardNormal::test_standard_normal[_param_1_{shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardNormal::test_standard_normal[_param_2_{shape=None}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardT::test_standard_t[_param_0_{df_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardT::test_standard_t[_param_1_{df_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardT::test_standard_t[_param_2_{df_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsStandardT::test_standard_t[_param_3_{df_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_0_{dtype=None, left_shape=(), mode_shape=(), right_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_1_{dtype=None, left_shape=(), mode_shape=(), right_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_2_{dtype=None, left_shape=(), mode_shape=(), right_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_3_{dtype=None, left_shape=(), mode_shape=(), right_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_4_{dtype=None, left_shape=(), mode_shape=(3, 2), right_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_5_{dtype=None, left_shape=(), mode_shape=(3, 2), right_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_6_{dtype=None, left_shape=(), mode_shape=(3, 2), right_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_7_{dtype=None, left_shape=(), mode_shape=(3, 2), right_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_8_{dtype=None, left_shape=(3, 2), mode_shape=(), right_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_9_{dtype=None, left_shape=(3, 2), mode_shape=(), right_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_10_{dtype=None, left_shape=(3, 2), mode_shape=(), right_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_11_{dtype=None, left_shape=(3, 2), mode_shape=(), right_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_12_{dtype=None, left_shape=(3, 2), mode_shape=(3, 2), right_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_13_{dtype=None, left_shape=(3, 2), mode_shape=(3, 2), right_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_14_{dtype=None, left_shape=(3, 2), mode_shape=(3, 2), right_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular[_param_15_{dtype=None, left_shape=(3, 2), mode_shape=(3, 2), right_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_0_{dtype=None, left_shape=(), mode_shape=(), right_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_1_{dtype=None, left_shape=(), mode_shape=(), right_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_2_{dtype=None, left_shape=(), mode_shape=(), right_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_3_{dtype=None, left_shape=(), mode_shape=(), right_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_4_{dtype=None, left_shape=(), mode_shape=(3, 2), right_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_5_{dtype=None, left_shape=(), mode_shape=(3, 2), right_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_6_{dtype=None, left_shape=(), mode_shape=(3, 2), right_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_7_{dtype=None, left_shape=(), mode_shape=(3, 2), right_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_8_{dtype=None, left_shape=(3, 2), mode_shape=(), right_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_9_{dtype=None, left_shape=(3, 2), mode_shape=(), right_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_10_{dtype=None, left_shape=(3, 2), mode_shape=(), right_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_11_{dtype=None, left_shape=(3, 2), mode_shape=(), right_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_12_{dtype=None, left_shape=(3, 2), mode_shape=(3, 2), right_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_13_{dtype=None, left_shape=(3, 2), mode_shape=(3, 2), right_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_14_{dtype=None, left_shape=(3, 2), mode_shape=(3, 2), right_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsTriangular::test_triangular_for_invalid_params[_param_15_{dtype=None, left_shape=(3, 2), mode_shape=(3, 2), right_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsUniform::test_uniform[_param_0_{high_shape=(), low_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsUniform::test_uniform[_param_1_{high_shape=(), low_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsUniform::test_uniform[_param_2_{high_shape=(), low_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsUniform::test_uniform[_param_3_{high_shape=(), low_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsUniform::test_uniform[_param_4_{high_shape=(3, 2), low_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsUniform::test_uniform[_param_5_{high_shape=(3, 2), low_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsUniform::test_uniform[_param_6_{high_shape=(3, 2), low_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsUniform::test_uniform[_param_7_{high_shape=(3, 2), low_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises::test_vonmises[_param_0_{dtype=None, kappa_shape=(), mu_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises::test_vonmises[_param_1_{dtype=None, kappa_shape=(), mu_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises::test_vonmises[_param_2_{dtype=None, kappa_shape=(), mu_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises::test_vonmises[_param_3_{dtype=None, kappa_shape=(), mu_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises::test_vonmises[_param_4_{dtype=None, kappa_shape=(3, 2), mu_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises::test_vonmises[_param_5_{dtype=None, kappa_shape=(3, 2), mu_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises::test_vonmises[_param_6_{dtype=None, kappa_shape=(3, 2), mu_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsVonmises::test_vonmises[_param_7_{dtype=None, kappa_shape=(3, 2), mu_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWald::test_wald[_param_0_{dtype=None, mean_shape=(), scale_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWald::test_wald[_param_1_{dtype=None, mean_shape=(), scale_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWald::test_wald[_param_2_{dtype=None, mean_shape=(), scale_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWald::test_wald[_param_3_{dtype=None, mean_shape=(), scale_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWald::test_wald[_param_4_{dtype=None, mean_shape=(3, 2), scale_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWald::test_wald[_param_5_{dtype=None, mean_shape=(3, 2), scale_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWald::test_wald[_param_6_{dtype=None, mean_shape=(3, 2), scale_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWald::test_wald[_param_7_{dtype=None, mean_shape=(3, 2), scale_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull::test_weibull[_param_0_{a_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull::test_weibull[_param_1_{a_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull::test_weibull[_param_2_{a_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull::test_weibull[_param_3_{a_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull::test_weibull_for_inf_a[_param_0_{a_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull::test_weibull_for_inf_a[_param_1_{a_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull::test_weibull_for_inf_a[_param_2_{a_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull::test_weibull_for_inf_a[_param_3_{a_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull::test_weibull_for_negative_a[_param_0_{a_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull::test_weibull_for_negative_a[_param_1_{a_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull::test_weibull_for_negative_a[_param_2_{a_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsWeibull::test_weibull_for_negative_a[_param_3_{a_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsZipf::test_zipf[_param_0_{a_shape=(), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsZipf::test_zipf[_param_1_{a_shape=(), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsZipf::test_zipf[_param_2_{a_shape=(3, 2), shape=(4, 3, 2)}] +tests/third_party/cupy/random_tests/test_distributions.py::TestDistributionsZipf::test_zipf[_param_3_{a_shape=(3, 2), shape=(3, 2)}] +tests/third_party/cupy/random_tests/test_permutations.py::TestPermutations_param_0_{seed=None}::test_permutation_seed1 +tests/third_party/cupy/random_tests/test_permutations.py::TestPermutations_param_0_{seed=None}::test_permutation_sort_1dim +tests/third_party/cupy/random_tests/test_permutations.py::TestPermutations_param_0_{seed=None}::test_permutation_sort_ndim +tests/third_party/cupy/random_tests/test_permutations.py::TestShuffle::test_shuffle_seed1 +tests/third_party/cupy/random_tests/test_permutations.py::TestShuffle::test_shuffle_sort_1dim +tests/third_party/cupy/random_tests/test_permutations.py::TestShuffle::test_shuffle_sort_ndim +tests/third_party/cupy/random_tests/test_permutations.py::TestPermutationSoundness_param_0_{num=0}::test_permutation_soundness +tests/third_party/cupy/random_tests/test_permutations.py::TestPermutationSoundness_param_1_{num=1}::test_permutation_soundness +tests/third_party/cupy/random_tests/test_permutations.py::TestPermutationSoundness_param_2_{num=100}::test_permutation_soundness +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_float1 +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::TestRandint2::test_goodness_of_fit +tests/third_party/cupy/random_tests/test_sample.py::TestRandint2::test_goodness_of_fit_2 +tests/third_party/cupy/random_tests/test_sample.py::TestRandomIntegers2::test_bound_1 +tests/third_party/cupy/random_tests/test_sample.py::TestRandomIntegers2::test_bound_2 +tests/third_party/cupy/random_tests/test_sample.py::TestRandomIntegers2::test_goodness_of_fit +tests/third_party/cupy/random_tests/test_sample.py::TestRandomIntegers2::test_goodness_of_fit_2 + +# 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 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 a12f908db05..c54401fd8bf 100644 --- a/dpnp/tests/test_fft.py +++ b/dpnp/tests/test_fft.py @@ -14,6 +14,7 @@ get_all_dtypes, get_complex_dtypes, get_float_dtypes, + is_cuda_device, ) @@ -178,8 +179,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) @@ -442,6 +443,11 @@ def setup_method(self): @pytest.mark.parametrize("norm", [None, "backward", "forward", "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 + else: + pytest.skip("SAT-7587") a_np = generate_random_numpy_array((2, 3, 4, 5), dtype, order) a = dpnp.array(a_np) @@ -476,6 +482,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") a_np = generate_random_numpy_array((2, 3, 4, 5), dtype=numpy.complex64) a = dpnp.array(a_np) @@ -495,6 +504,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") a_np = generate_random_numpy_array((2, 3, 4, 5), dtype=numpy.complex64) a = dpnp.array(a_np) @@ -1060,6 +1074,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") x = numpy.random.uniform(-10, 10, 120) a_np = numpy.array(x, 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 61b91015461..595151008eb 100644 --- a/dpnp/tests/test_indexing.py +++ b/dpnp/tests/test_indexing.py @@ -783,7 +783,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 646fd443bbe..a150d823d75 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 @@ -324,6 +325,12 @@ def test_bool(self, p): "p", [None, -dpnp.inf, -2, -1, 1, 2, dpnp.inf, "fro"] ) def test_nan(self, p): + # dpnp.linalg.cond uses dpnp.linalg.inv() + # for the case when p is not None or p != -2 or p != 2 + # For singular matrices cuSolver raises an error + # while OneMKL returns nans + if is_cuda_device() and p in [-dpnp.inf, -1, 1, dpnp.inf, "fro"]: + pytest.skip("Different behavior on CUDA") a = generate_random_numpy_array((2, 2, 2, 2)) a[0, 0] = 0 a[1, 1] = 0 @@ -2373,6 +2380,12 @@ class TestQr: ) @pytest.mark.parametrize("mode", ["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") a = generate_random_numpy_array(shape, dtype, seed_value=81) ia = dpnp.array(a) 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_sycl_queue.py b/dpnp/tests/test_sycl_queue.py index 59f8b241824..dff8618cca6 100644 --- a/dpnp/tests/test_sycl_queue.py +++ b/dpnp/tests/test_sycl_queue.py @@ -20,6 +20,7 @@ ) list_of_backend_str = [ + "cuda", "host", "level_zero", "opencl", @@ -1580,8 +1581,7 @@ def test_cholesky(data, is_empty, device): ) @pytest.mark.parametrize("p", [None, -dpnp.inf, -2, -1, 1, 2, dpnp.inf, "fro"]) def test_cond(device, p): - numpy.random.seed(42) - a = numpy.array(numpy.random.uniform(-5, 5, 16)).reshape(4, 4) + a = generate_random_numpy_array((2, 4, 4), seed_value=42) ia = dpnp.array(a, device=device) result = dpnp.linalg.cond(ia, p=p) diff --git a/dpnp/tests/test_usm_type.py b/dpnp/tests/test_usm_type.py index e8e97d2ea38..f80b4bbedfd 100644 --- a/dpnp/tests/test_usm_type.py +++ b/dpnp/tests/test_usm_type.py @@ -10,7 +10,10 @@ 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, +) list_of_usm_types = ["device", "shared", "host"] @@ -863,7 +866,8 @@ 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): - ia = dp.arange(32, usm_type=usm_type).reshape(2, 4, 4) + a = generate_random_numpy_array((2, 4, 4), seed_value=42) + ia = dp.array(a, usm_type=usm_type) result = dp.linalg.cond(ia, p=p) assert ia.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 14b6a1d9937..15e4c9c72fb 100644 --- a/dpnp/tests/third_party/cupy/core_tests/test_dlpack.py +++ b/dpnp/tests/third_party/cupy/core_tests/test_dlpack.py @@ -7,26 +7,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 DLDummy: 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 f0ea1a6f996..ba82ca6c4b4 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 @@ -521,7 +521,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 f4bc6533cb6..e7c4fb09364 100644 --- a/dpnp/tests/third_party/cupy/fft_tests/test_fft.py +++ b/dpnp/tests/third_party/cupy/fft_tests/test_fft.py @@ -5,7 +5,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 from dpnp.tests.third_party.cupy.testing._loops import _wraps_partial @@ -413,6 +413,8 @@ class TestFft2: type_check=has_support_aspect64(), ) def test_fft2(self, xp, dtype, order, enable_nd): + if is_cuda_device() and self.shape == (2, 3, 4, 5): + pytest.skip("SAT-7587") # assert config.enable_nd_planning == enable_nd a = testing.shaped_random(self.shape, xp, dtype) if order == "F": @@ -440,6 +442,8 @@ def test_fft2(self, xp, dtype, order, enable_nd): type_check=has_support_aspect64(), ) def test_ifft2(self, xp, dtype, order, enable_nd): + if is_cuda_device() and self.shape == (2, 3, 4, 5): + pytest.skip("SAT-7587") # assert config.enable_nd_planning == enable_nd a = testing.shaped_random(self.shape, xp, dtype) if order == "F": @@ -503,6 +507,8 @@ class TestFftn: type_check=has_support_aspect64(), ) def test_fftn(self, xp, dtype, order, enable_nd): + if is_cuda_device() and self.shape == (2, 3, 4, 5): + pytest.skip("SAT-7587") # assert config.enable_nd_planning == enable_nd a = testing.shaped_random(self.shape, xp, dtype) if order == "F": @@ -530,6 +536,8 @@ def test_fftn(self, xp, dtype, order, enable_nd): type_check=has_support_aspect64(), ) def test_ifftn(self, xp, dtype, order, enable_nd): + if is_cuda_device() and self.shape == (2, 3, 4, 5): + pytest.skip("SAT-7587") # assert config.enable_nd_planning == enable_nd a = testing.shaped_random(self.shape, xp, dtype) if order == "F": 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 9948f4d0a92..47e7dd23b3a 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, ) from dpnp.tests.third_party.cupy import testing from dpnp.tests.third_party.cupy.testing import _condition @@ -162,7 +163,14 @@ def test_decomposition(self, dtype): class TestQRDecomposition(unittest.TestCase): @testing.for_dtypes("fdFD") + # skip cases with 'complete' and 'reduce' modes on CUDA (SAT-7611) 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_solve.py b/dpnp/tests/third_party/cupy/linalg_tests/test_solve.py index ecb13f3a139..d0c0f5c61c2 100644 --- a/dpnp/tests/third_party/cupy/linalg_tests/test_solve.py +++ b/dpnp/tests/third_party/cupy/linalg_tests/test_solve.py @@ -64,8 +64,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) @@ -169,7 +176,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) @@ -289,8 +298,11 @@ 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) @@ -363,12 +375,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 36c11cca1dd..123098b1e13 100644 --- a/dpnp/tests/third_party/cupy/math_tests/test_rational.py +++ b/dpnp/tests/third_party/cupy/math_tests/test_rational.py @@ -1,8 +1,10 @@ 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 @@ -10,8 +12,18 @@ 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) @@ -24,8 +36,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 703385c3769..52afc7139a9 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): @_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: assert val.shape == () assert min(vals) == 0 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 46294681b8b..ff9480cf8fb 100644 --- a/dpnp/tests/third_party/cupy/statistics_tests/test_histogram.py +++ b/dpnp/tests/third_party/cupy/statistics_tests/test_histogram.py @@ -143,7 +143,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():