scipy 1.15.3__cp312-cp312-musllinux_1_2_aarch64.whl → 1.16.0rc2__cp312-cp312-musllinux_1_2_aarch64.whl

scipy/ndimage/tests/test_filters.py

@@ -2,6 +2,7 @@
 import functools
 import itertools
 import re
+import contextlib
 
 import numpy as np
 import pytest
@@ -17,8 +18,8 @@ from scipy._lib._array_api import (
     xp_assert_close,
     xp_assert_equal,
 )
-from scipy._lib._array_api import is_cupy, is_numpy, is_torch, array_namespace
-from scipy.conftest import array_api_compatible
+from scipy._lib._array_api import (is_cupy, is_torch, is_dask, is_jax, array_namespace,
+                                   is_array_api_strict, xp_copy)
 from scipy.ndimage._filters import _gaussian_kernel1d
 
 from . import types, float_types, complex_types
@@ -26,9 +27,18 @@ from . import types, float_types, complex_types
 
 skip_xp_backends = pytest.mark.skip_xp_backends
 xfail_xp_backends = pytest.mark.xfail_xp_backends
-pytestmark = [array_api_compatible, pytest.mark.usefixtures("skip_xp_backends"),
-              pytest.mark.usefixtures("xfail_xp_backends"),
-              skip_xp_backends(cpu_only=True, exceptions=['cupy', 'jax.numpy']),]
+pytestmark = [skip_xp_backends(cpu_only=True, exceptions=['cupy', 'jax.numpy'])]
+
+uses_output_dtype = skip_xp_backends(
+    np_only=True, exceptions=["cupy"],
+    reason="output=dtype is numpy-specific"
+)
+
+
+def uses_output_array(f):
+    return skip_xp_backends("dask.array", reason="output=array requires buffer view")(
+        skip_xp_backends("jax.numpy", reason="output=array requires buffer view")(f))
+
 
 
 def sumsq(a, b, xp=None):
@@ -44,9 +54,8 @@ def _complex_correlate(xp, array, kernel, real_dtype, convolve=False,
     """
     array = xp.asarray(array)
     kernel = xp.asarray(kernel)
-    isdtype = array_namespace(array, kernel).isdtype
-    complex_array = isdtype(array.dtype, 'complex floating')
-    complex_kernel = isdtype(kernel.dtype, 'complex floating')
+    complex_array = xp.isdtype(array.dtype, 'complex floating')
+    complex_kernel = xp.isdtype(kernel.dtype, 'complex floating')
     if array.ndim == 1:
         func = ndimage.convolve1d if convolve else ndimage.correlate1d
     else:
@@ -197,7 +206,7 @@ class TestNdimageFilters:
         assert_array_almost_equal(output, expected)
 
     @xfail_xp_backends('cupy', reason="Differs by a factor of two?")
-    @skip_xp_backends("jax.numpy", reason="output array is read-only.")
+    @uses_output_array
     def test_correlate01_overlap(self, xp):
         array = xp.reshape(xp.arange(256), (16, 16))
         weights = xp.asarray([2])
@@ -348,9 +357,7 @@ class TestNdimageFilters:
         output = ndimage.convolve(array, kernel)
         assert_array_almost_equal(xp.asarray([[6, 8, 9], [9, 11, 12]]), output)
 
-    @xfail_xp_backends(np_only=True,
-                       reason="output=dtype is numpy-specific",
-                       exceptions=['cupy'],)
+    @uses_output_dtype
     @pytest.mark.parametrize('dtype_array', types)
     @pytest.mark.parametrize('dtype_kernel', types)
     def test_correlate13(self, dtype_array, dtype_kernel, xp):
@@ -370,9 +377,7 @@ class TestNdimageFilters:
         assert_array_almost_equal(xp.asarray([[6, 8, 9], [9, 11, 12]]), output)
         assert output.dtype.type == dtype_kernel
 
-    @xfail_xp_backends(np_only=True,
-                       reason="output=dtype is numpy-specific",
-                       exceptions=['cupy'],)
+    @uses_output_array
     @pytest.mark.parametrize('dtype_array', types)
     @pytest.mark.parametrize('dtype_output', types)
     def test_correlate14(self, dtype_array, dtype_output, xp):
@@ -386,15 +391,13 @@ class TestNdimageFilters:
         output = xp.zeros(array.shape, dtype=dtype_output)
         ndimage.correlate(array, kernel, output=output)
         assert_array_almost_equal(xp.asarray([[2, 3, 5], [5, 6, 8]]), output)
-        assert output.dtype.type == dtype_output
+        assert output.dtype == dtype_output
 
         ndimage.convolve(array, kernel, output=output)
         assert_array_almost_equal(xp.asarray([[6, 8, 9], [9, 11, 12]]), output)
-        assert output.dtype.type == dtype_output
+        assert output.dtype == dtype_output
 
-    @xfail_xp_backends(np_only=True,
-                       reason="output=dtype is numpy-specific",
-                       exceptions=['cupy'],)
+    @uses_output_dtype
     @pytest.mark.parametrize('dtype_array', types)
     def test_correlate15(self, dtype_array, xp):
         dtype_array = getattr(xp, dtype_array)
@@ -411,9 +414,7 @@ class TestNdimageFilters:
         assert_array_almost_equal(xp.asarray([[6, 8, 9], [9, 11, 12]]), output)
         assert output.dtype.type == xp.float32
 
-    @xfail_xp_backends(np_only=True,
-                       reason="output=dtype is numpy-specific",
-                       exceptions=['cupy'],)
+    @uses_output_dtype
     @pytest.mark.parametrize('dtype_array', types)
     def test_correlate16(self, dtype_array, xp):
         dtype_array = getattr(xp, dtype_array)
@@ -443,9 +444,7 @@ class TestNdimageFilters:
         output = ndimage.convolve1d(array, kernel, origin=-1)
         assert_array_almost_equal(tcov, output)
 
-    @xfail_xp_backends(np_only=True,
-                       reason="output=dtype is numpy-specific",
-                       exceptions=['cupy'],)
+    @uses_output_dtype
     @pytest.mark.parametrize('dtype_array', types)
     def test_correlate18(self, dtype_array, xp):
         dtype_array = getattr(xp, dtype_array)
@@ -474,9 +473,7 @@ class TestNdimageFilters:
         with assert_raises(RuntimeError):
             ndimage.convolve(array, kernel, mode=['nearest', 'reflect'])
 
-    @xfail_xp_backends(np_only=True,
-                       reason="output=dtype is numpy-specific",
-                       exceptions=['cupy'],)
+    @uses_output_dtype
     @pytest.mark.parametrize('dtype_array', types)
     def test_correlate19(self, dtype_array, xp):
         dtype_array = getattr(xp, dtype_array)
@@ -497,9 +494,7 @@ class TestNdimageFilters:
         assert_array_almost_equal(xp.asarray([[3, 5, 6], [6, 8, 9]]), output)
         assert output.dtype.type == xp.float32
 
-    @xfail_xp_backends(np_only=True,
-                       reason="output=dtype is numpy-specific",
-                       exceptions=['cupy'],)
+    @uses_output_array
     @pytest.mark.parametrize('dtype_array', types)
     @pytest.mark.parametrize('dtype_output', types)
     def test_correlate20(self, dtype_array, dtype_output, xp):
@@ -526,9 +521,7 @@ class TestNdimageFilters:
         output = ndimage.convolve1d(array, weights, axis=0)
         assert_array_almost_equal(output, expected)
 
-    @xfail_xp_backends(np_only=True,
-                       reason="output=dtype is numpy-specific",
-                       exceptions=['cupy'],)
+    @uses_output_array
     @pytest.mark.parametrize('dtype_array', types)
     @pytest.mark.parametrize('dtype_output', types)
     def test_correlate22(self, dtype_array, dtype_output, xp):
@@ -547,7 +540,7 @@ class TestNdimageFilters:
                            mode='wrap', output=output)
         assert_array_almost_equal(output, expected)
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only.")
+    @uses_output_array
     @pytest.mark.parametrize('dtype_array', types)
     @pytest.mark.parametrize('dtype_output', types)
     def test_correlate23(self, dtype_array, dtype_output, xp):
@@ -566,7 +559,7 @@ class TestNdimageFilters:
                            mode='nearest', output=output)
         assert_array_almost_equal(output, expected)
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only.")
+    @uses_output_array
     @pytest.mark.parametrize('dtype_array', types)
     @pytest.mark.parametrize('dtype_output', types)
     def test_correlate24(self, dtype_array, dtype_output, xp):
@@ -586,7 +579,7 @@ class TestNdimageFilters:
                            mode='nearest', output=output, origin=-1)
         assert_array_almost_equal(output, tcov)
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only.")
+    @uses_output_array
     @pytest.mark.parametrize('dtype_array', types)
     @pytest.mark.parametrize('dtype_output', types)
     def test_correlate25(self, dtype_array, dtype_output, xp):
@@ -614,9 +607,7 @@ class TestNdimageFilters:
         y = ndimage.correlate1d(xp.ones(1), xp.ones(5), mode='mirror')
         xp_assert_equal(y, xp.asarray([5.]))
 
-    @xfail_xp_backends(np_only=True,
-                       reason="output=dtype is numpy-specific",
-                       exceptions=['cupy'],)
+    @uses_output_dtype
     @pytest.mark.parametrize('dtype_kernel', complex_types)
     @pytest.mark.parametrize('dtype_input', types)
     @pytest.mark.parametrize('dtype_output', complex_types)
@@ -633,9 +624,7 @@ class TestNdimageFilters:
         self._validate_complex(xp, array, kernel, dtype_output,
                                check_warnings=num_parallel_threads == 1)
 
-    @xfail_xp_backends(np_only=True,
-                       reason="output=dtype is numpy-specific",
-                       exceptions=['cupy'],)
+    @uses_output_dtype
     @pytest.mark.parametrize('dtype_kernel', complex_types)
     @pytest.mark.parametrize('dtype_input', types)
     @pytest.mark.parametrize('dtype_output', complex_types)
@@ -648,7 +637,7 @@ class TestNdimageFilters:
         dtype_output = getattr(xp, dtype_output)
 
         if is_cupy(xp) and mode == 'grid-constant':
-            pytest.xfail('https://github.com/cupy/cupy/issues/8404')
+            pytest.xfail('cupy/cupy#8404')
 
         # test use of non-zero cval with complex inputs
         # also verifies that mode 'grid-constant' does not segfault
@@ -680,7 +669,7 @@ class TestNdimageFilters:
                 func(array, kernel, mode='constant', cval=5.0 + 1.0j,
                      output=xp.complex64)
 
-    @skip_xp_backends(np_only=True, reason='output=dtype is numpy-specific')
+    @uses_output_dtype
     @pytest.mark.parametrize('dtype_kernel', complex_types)
     @pytest.mark.parametrize('dtype_input', types)
     @pytest.mark.parametrize('dtype_output', complex_types)
@@ -695,7 +684,7 @@ class TestNdimageFilters:
         self._validate_complex(xp, array, kernel, dtype_output,
                                check_warnings=num_parallel_threads == 1)
 
-    @skip_xp_backends(np_only=True, reason='output=dtype is numpy-specific')
+    @uses_output_dtype
     @pytest.mark.parametrize('dtype_kernel', complex_types)
     @pytest.mark.parametrize('dtype_input', types)
     @pytest.mark.parametrize('dtype_output', complex_types)
@@ -712,7 +701,7 @@ class TestNdimageFilters:
                                cval=5.0,
                                check_warnings=num_parallel_threads == 1)
 
-    @skip_xp_backends(np_only=True, reason='output=dtype is numpy-specific')
+    @uses_output_dtype
     @pytest.mark.parametrize('dtype_kernel', types)
     @pytest.mark.parametrize('dtype_input', complex_types)
     @pytest.mark.parametrize('dtype_output', complex_types)
@@ -729,7 +718,7 @@ class TestNdimageFilters:
         self._validate_complex(xp, array, kernel, dtype_output,
                                check_warnings=num_parallel_threads == 1)
 
-    @skip_xp_backends(np_only=True, reason='output=dtype is numpy-specific')
+    @uses_output_dtype
     @pytest.mark.parametrize('dtype_kernel', types)
     @pytest.mark.parametrize('dtype_input', complex_types)
     @pytest.mark.parametrize('dtype_output', complex_types)
@@ -744,10 +733,8 @@ class TestNdimageFilters:
         self._validate_complex(xp, array, kernel, dtype_output,
                                check_warnings=num_parallel_threads == 1)
 
-    @xfail_xp_backends('cupy', reason="cupy/cupy#8405")
-    @skip_xp_backends(np_only=True,
-                      reason='output=dtype is numpy-specific',
-                      exceptions=['cupy'])
+    @uses_output_dtype
+    @xfail_xp_backends("cupy", reason="cupy/cupy#8405")
     @pytest.mark.parametrize('dtype_kernel', types)
     @pytest.mark.parametrize('dtype_input', complex_types)
     @pytest.mark.parametrize('dtype_output', complex_types)
@@ -764,7 +751,8 @@ class TestNdimageFilters:
                                cval=5 - 3j,
                                check_warnings=num_parallel_threads == 1)
 
-    @skip_xp_backends(np_only=True, reason='output=dtype is numpy-specific')
+    @uses_output_dtype
+    @xfail_xp_backends("cupy", reason="unhashable type: 'ndarray'")
     @pytest.mark.parametrize('dtype', complex_types)
     @pytest.mark.parametrize('dtype_output', complex_types)
     def test_correlate_complex_input_and_kernel(self, dtype, dtype_output, xp,
@@ -779,10 +767,8 @@ class TestNdimageFilters:
         self._validate_complex(xp, array, kernel, dtype_output,
                                check_warnings=num_parallel_threads == 1)
 
-    @xfail_xp_backends('cupy', reason="cupy/cupy#8405")
-    @skip_xp_backends(np_only=True,
-                      reason="output=dtype is numpy-specific",
-                      exceptions=['cupy'],)
+    @uses_output_dtype
+    @xfail_xp_backends("cupy", reason="cupy/cupy#8405")
     @pytest.mark.parametrize('dtype', complex_types)
     @pytest.mark.parametrize('dtype_output', complex_types)
     def test_correlate_complex_input_and_kernel_cval(self, dtype,
@@ -799,7 +785,8 @@ class TestNdimageFilters:
                                cval=5.0 + 2.0j,
                                check_warnings=num_parallel_threads == 1)
 
-    @skip_xp_backends(np_only=True, reason="output=dtype is numpy-specific")
+    @uses_output_dtype
+    @xfail_xp_backends("cupy", reason="unhashable type: 'ndarray'")
     @pytest.mark.parametrize('dtype', complex_types)
     @pytest.mark.parametrize('dtype_output', complex_types)
     @pytest.mark.thread_unsafe
@@ -813,20 +800,17 @@ class TestNdimageFilters:
         self._validate_complex(xp, array, kernel, dtype_output,
                                check_warnings=num_parallel_threads == 1)
 
+    @uses_output_dtype
+    @xfail_xp_backends("cupy", reason="cupy/cupy#8405")
     @pytest.mark.parametrize('dtype', complex_types)
     @pytest.mark.parametrize('dtype_output', complex_types)
     def test_correlate1d_complex_input_and_kernel_cval(self, dtype,
                                                        dtype_output, xp,
                                                        num_parallel_threads):
-        if not (is_numpy(xp) or is_cupy(xp)):
-            pytest.xfail("output=dtype is numpy-specific")
 
         dtype = getattr(xp, dtype)
         dtype_output = getattr(xp, dtype_output)
 
-        if is_cupy(xp):
-            pytest.xfail("https://github.com/cupy/cupy/issues/8405")
-
         kernel = xp.asarray([1, 1 + 1j], dtype=dtype)
         array = xp.asarray([1, 2j, 3, 1 + 4j, 5, 6j], dtype=dtype)
         self._validate_complex(xp, array, kernel, dtype_output, mode='constant',
@@ -846,10 +830,8 @@ class TestNdimageFilters:
         assert input.dtype == output.dtype
         assert input.shape == output.shape
 
+    @xfail_xp_backends("cupy", reason="cupy/cupy#8403")
     def test_gauss03(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("https://github.com/cupy/cupy/issues/8403")
-
         # single precision data
         input = xp.arange(100 * 100, dtype=xp.float32)
         input = xp.reshape(input, (100, 100))
@@ -865,10 +847,8 @@ class TestNdimageFilters:
         assert_almost_equal(o_sum, i_sum, decimal=0)
         assert sumsq(input, output) > 1.0
 
+    @uses_output_dtype
     def test_gauss04(self, xp):
-        if not (is_numpy(xp) or is_cupy(xp)):
-            pytest.xfail("output=dtype is numpy-specific")
-
         input = xp.arange(100 * 100, dtype=xp.float32)
         input = xp.reshape(input, (100, 100))
         otype = xp.float64
@@ -877,10 +857,8 @@ class TestNdimageFilters:
         assert input.shape == output.shape
         assert sumsq(input, output) > 1.0
 
+    @uses_output_dtype
     def test_gauss05(self, xp):
-        if not (is_numpy(xp) or is_cupy(xp)):
-            pytest.xfail("output=dtype is numpy-specific")
-
         input = xp.arange(100 * 100, dtype=xp.float32)
         input = xp.reshape(input, (100, 100))
         otype = xp.float64
@@ -890,10 +868,8 @@ class TestNdimageFilters:
         assert input.shape == output.shape
         assert sumsq(input, output) > 1.0
 
+    @uses_output_dtype
     def test_gauss06(self, xp):
-        if not (is_numpy(xp) or is_cupy(xp)):
-            pytest.xfail("output=dtype is numpy-specific")
-
         input = xp.arange(100 * 100, dtype=xp.float32)
         input = xp.reshape(input, (100, 100))
         otype = xp.float64
@@ -901,7 +877,7 @@ class TestNdimageFilters:
         output2 = ndimage.gaussian_filter(input, 1.0, output=otype)
         assert_array_almost_equal(output1, output2)
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only.")
+    @uses_output_array
     def test_gauss_memory_overlap(self, xp):
         input = xp.arange(100 * 100, dtype=xp.float32)
         input = xp.reshape(input, (100, 100))
@@ -909,6 +885,7 @@ class TestNdimageFilters:
         ndimage.gaussian_filter(input, 1.0, output=input)
         assert_array_almost_equal(output1, input)
 
+    @xfail_xp_backends("cupy", reason="https://github.com/cupy/cupy/pull/8339")
     @pytest.mark.parametrize(('filter_func', 'extra_args', 'size0', 'size'),
                              [(ndimage.gaussian_filter, (), 0, 1.0),
                               (ndimage.uniform_filter, (), 1, 3),
@@ -923,9 +900,6 @@ class TestNdimageFilters:
         + tuple(itertools.combinations(range(-3, 3), 2))
         + ((0, 1, 2),))
     def test_filter_axes(self, filter_func, extra_args, size0, size, axes, xp):
-        if is_cupy(xp):
-            pytest.xfail("https://github.com/cupy/cupy/pull/8339")
-
         # Note: `size` is called `sigma` in `gaussian_filter`
         array = xp.arange(6 * 8 * 12, dtype=xp.float64)
         array = xp.reshape(array, (6, 8, 12))
@@ -945,8 +919,7 @@ class TestNdimageFilters:
         xp_assert_close(output, expected)
 
     @skip_xp_backends("cupy",
-                      reason="these filters do not yet have axes support",
-    )
+                      reason="these filters do not yet have axes support")
     @pytest.mark.parametrize(('filter_func', 'kwargs'),
                              [(ndimage.laplace, {}),
                               (ndimage.gaussian_gradient_magnitude,
@@ -987,8 +960,7 @@ class TestNdimageFilters:
         xp_assert_close(output, expected)
 
     @skip_xp_backends("cupy",
-                      reason="generic_filter does not yet have axes support",
-    )
+                      reason="generic_filter does not yet have axes support")
     @pytest.mark.parametrize(
         'axes',
         tuple(itertools.combinations(range(-3, 3), 1))
@@ -1010,8 +982,7 @@ class TestNdimageFilters:
         xp_assert_close(output, expected)
 
     @skip_xp_backends("cupy",
-                      reason="https://github.com/cupy/cupy/pull/8339",
-    )
+                      reason="https://github.com/cupy/cupy/pull/8339")
     @pytest.mark.parametrize('func', [ndimage.correlate, ndimage.convolve])
     @pytest.mark.parametrize(
         'dtype', [np.float32, np.float64, np.complex64, np.complex128]
@@ -1051,9 +1022,7 @@ class TestNdimageFilters:
                         mode=['reflect', 'nearest', 'constant'])
     kwargs_rank = dict(origin=(-1, 0, 1))
 
-    @skip_xp_backends("array_api_strict",
-         reason="fancy indexing is only available in 2024 version",
-    )
+    @xfail_xp_backends("cupy", reason="https://github.com/cupy/cupy/pull/8339")
     @pytest.mark.parametrize("filter_func, size0, size, kwargs",
                              [(ndimage.gaussian_filter, 0, 1.0, kwargs_gauss),
                               (ndimage.uniform_filter, 1, 3, kwargs_other),
@@ -1064,10 +1033,6 @@ class TestNdimageFilters:
                               (ndimage.percentile_filter, 1, 3, kwargs_rank)])
     @pytest.mark.parametrize('axes', itertools.combinations(range(-3, 3), 2))
     def test_filter_axes_kwargs(self, filter_func, size0, size, kwargs, axes, xp):
-
-        if is_cupy(xp):
-            pytest.xfail("https://github.com/cupy/cupy/pull/8339")
-
         array = xp.arange(6 * 8 * 12, dtype=xp.float64)
         array = xp.reshape(array, (6, 8, 12))
 
@@ -1108,6 +1073,7 @@ class TestNdimageFilters:
         xp_assert_close(output, expected)
 
 
+    @xfail_xp_backends("cupy", reason="https://github.com/cupy/cupy/pull/8339")
     @pytest.mark.parametrize("filter_func, kwargs",
                              [(ndimage.convolve, {}),
                               (ndimage.correlate, {}),
@@ -1117,9 +1083,6 @@ class TestNdimageFilters:
                               (ndimage.rank_filter, {"rank": 1}),
                               (ndimage.percentile_filter, {"percentile": 30})])
     def test_filter_weights_subset_axes_origins(self, filter_func, kwargs, xp):
-        if is_cupy(xp):
-            pytest.xfail("https://github.com/cupy/cupy/pull/8339")
-
         axes = (-2, -1)
         origins = (0, 1)
         array = xp.arange(6 * 8 * 12, dtype=xp.float64)
@@ -1152,6 +1115,7 @@ class TestNdimageFilters:
                 output[:, :, origins[1]:], output0[:, :, :-origins[1]])
 
 
+    @xfail_xp_backends("cupy", reason="https://github.com/cupy/cupy/pull/8339")
     @pytest.mark.parametrize(
         'filter_func, args',
         [(ndimage.convolve, (np.ones((3, 3, 3)),)),  # args = (weights,)
@@ -1167,9 +1131,6 @@ class TestNdimageFilters:
         'axes', [(1.5,), (0, 1, 2, 3), (3,), (-4,)]
     )
     def test_filter_invalid_axes(self, filter_func, args, axes, xp):
-        if is_cupy(xp):
-            pytest.xfail("https://github.com/cupy/cupy/pull/8339")
-
         array = xp.arange(6 * 8 * 12, dtype=xp.float64)
         array = xp.reshape(array, (6, 8, 12))
         args = [
@@ -1185,6 +1146,7 @@ class TestNdimageFilters:
         with pytest.raises(error_class, match=match):
             filter_func(array, *args, axes=axes)
 
+    @xfail_xp_backends("cupy", reason="https://github.com/cupy/cupy/pull/8339")
     @pytest.mark.parametrize(
         'filter_func, kwargs',
         [(ndimage.convolve, {}),
@@ -1200,9 +1162,6 @@ class TestNdimageFilters:
     @pytest.mark.parametrize('separable_footprint', [False, True])
     def test_filter_invalid_footprint_ndim(self, filter_func, kwargs, axes,
                                            separable_footprint, xp):
-        if is_cupy(xp):
-            pytest.xfail("https://github.com/cupy/cupy/pull/8339")
-
         array = xp.arange(6 * 8 * 12, dtype=xp.float64)
         array = xp.reshape(array, (6, 8, 12))
         # create a footprint with one too many dimensions
@@ -1226,14 +1185,12 @@ class TestNdimageFilters:
         with pytest.raises(RuntimeError, match=match):
             filter_func(array, axes=axes, **kwargs)
 
+    @xfail_xp_backends("cupy", reason="https://github.com/cupy/cupy/pull/8339")
     @pytest.mark.parametrize('n_mismatch', [1, 3])
     @pytest.mark.parametrize('filter_func, kwargs, key, val',
                              _cases_axes_tuple_length_mismatch())
     def test_filter_tuple_length_mismatch(self, n_mismatch, filter_func,
                                           kwargs, key, val, xp):
-        if is_cupy(xp):
-            pytest.xfail("https://github.com/cupy/cupy/pull/8339")
-
         # Test for the intended RuntimeError when a kwargs has an invalid size
         array = xp.arange(6 * 8 * 12, dtype=xp.float64)
         array = xp.reshape(array, (6, 8, 12))
@@ -1248,9 +1205,6 @@ class TestNdimageFilters:
 
     @pytest.mark.parametrize('dtype', types + complex_types)
     def test_prewitt01(self, dtype, xp):
-        if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
-            pytest.xfail("https://github.com/pytorch/pytorch/issues/58734")
-
         dtype = getattr(xp, dtype)
         array = xp.asarray([[3, 2, 5, 1, 4],
                             [5, 8, 3, 7, 1],
@@ -1260,12 +1214,9 @@ class TestNdimageFilters:
         output = ndimage.prewitt(array, 0)
         assert_array_almost_equal(t, output)
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only.")
+    @uses_output_array
     @pytest.mark.parametrize('dtype', types + complex_types)
     def test_prewitt02(self, dtype, xp):
-        if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
-            pytest.xfail("https://github.com/pytorch/pytorch/issues/58734")
-
         dtype = getattr(xp, dtype)
         array = xp.asarray([[3, 2, 5, 1, 4],
                             [5, 8, 3, 7, 1],
@@ -1278,14 +1229,9 @@ class TestNdimageFilters:
 
     @pytest.mark.parametrize('dtype', types + complex_types)
     def test_prewitt03(self, dtype, xp):
-        if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
-            pytest.xfail("https://github.com/pytorch/pytorch/issues/58734")
-
         dtype = getattr(xp, dtype)
         if is_cupy(xp) and dtype in [xp.uint32, xp.uint64]:
             pytest.xfail("uint UB? XXX")
-        if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
-            pytest.xfail("https://github.com/pytorch/pytorch/issues/58734")
 
         array = xp.asarray([[3, 2, 5, 1, 4],
                             [5, 8, 3, 7, 1],
@@ -1297,9 +1243,6 @@ class TestNdimageFilters:
 
     @pytest.mark.parametrize('dtype', types + complex_types)
     def test_prewitt04(self, dtype, xp):
-        if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
-            pytest.xfail("https://github.com/pytorch/pytorch/issues/58734")
-
         dtype = getattr(xp, dtype)
         array = xp.asarray([[3, 2, 5, 1, 4],
                             [5, 8, 3, 7, 1],
@@ -1310,9 +1253,6 @@ class TestNdimageFilters:
 
     @pytest.mark.parametrize('dtype', types + complex_types)
     def test_sobel01(self, dtype, xp):
-        if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
-            pytest.xfail("https://github.com/pytorch/pytorch/issues/58734")
-
         dtype = getattr(xp, dtype)
         array = xp.asarray([[3, 2, 5, 1, 4],
                             [5, 8, 3, 7, 1],
@@ -1322,12 +1262,9 @@ class TestNdimageFilters:
         output = ndimage.sobel(array, 0)
         assert_array_almost_equal(t, output)
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only.",)
+    @uses_output_array
     @pytest.mark.parametrize('dtype', types + complex_types)
     def test_sobel02(self, dtype, xp):
-        if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
-            pytest.xfail("https://github.com/pytorch/pytorch/issues/58734")
-
         dtype = getattr(xp, dtype)
         array = xp.asarray([[3, 2, 5, 1, 4],
                             [5, 8, 3, 7, 1],
@@ -1342,8 +1279,6 @@ class TestNdimageFilters:
     def test_sobel03(self, dtype, xp):
         if is_cupy(xp) and dtype in ["uint32", "uint64"]:
             pytest.xfail("uint UB? XXX")
-        if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
-            pytest.xfail("https://github.com/pytorch/pytorch/issues/58734")
 
         dtype = getattr(xp, dtype)
         array = xp.asarray([[3, 2, 5, 1, 4],
@@ -1357,9 +1292,6 @@ class TestNdimageFilters:
 
     @pytest.mark.parametrize('dtype', types + complex_types)
     def test_sobel04(self, dtype, xp):
-        if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
-            pytest.xfail("https://github.com/pytorch/pytorch/issues/58734")
-
         dtype = getattr(xp, dtype)
         array = xp.asarray([[3, 2, 5, 1, 4],
                             [5, 8, 3, 7, 1],
@@ -1382,7 +1314,7 @@ class TestNdimageFilters:
         output = ndimage.laplace(array)
         assert_array_almost_equal(tmp1 + tmp2, output)
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only",)
+    @uses_output_array
     @pytest.mark.parametrize('dtype',
                              ["int32", "float32", "float64",
                               "complex64", "complex128"])
@@ -1412,7 +1344,7 @@ class TestNdimageFilters:
         output = ndimage.gaussian_laplace(array, 1.0)
         assert_array_almost_equal(tmp1 + tmp2, output)
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only")
+    @uses_output_array
     @pytest.mark.parametrize('dtype',
                              ["int32", "float32", "float64",
                               "complex64", "complex128"])
@@ -1428,12 +1360,9 @@ class TestNdimageFilters:
         ndimage.gaussian_laplace(array, 1.0, output)
         assert_array_almost_equal(tmp1 + tmp2, output)
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only.")
+    @uses_output_array
     @pytest.mark.parametrize('dtype', types + complex_types)
     def test_generic_laplace01(self, dtype, xp):
-        if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
-            pytest.xfail("https://github.com/pytorch/pytorch/issues/58734")
-
         def derivative2(input, axis, output, mode, cval, a, b):
             sigma = np.asarray([a, b / 2.0])
             order = [0] * input.ndim
@@ -1453,7 +1382,6 @@ class TestNdimageFilters:
         ndimage.gaussian_laplace(array, 1.0, output)
         assert_array_almost_equal(tmp, output)
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only")
     @pytest.mark.parametrize('dtype',
                              ["int32", "float32", "float64",
                               "complex64", "complex128"])
@@ -1469,12 +1397,11 @@ class TestNdimageFilters:
         output = ndimage.gaussian_gradient_magnitude(array, 1.0)
         expected = tmp1 * tmp1 + tmp2 * tmp2
 
-        astype = array_namespace(expected).astype
-        expected_float = astype(expected, xp.float64) if is_int_dtype else expected
-        expected = astype(xp.sqrt(expected_float), dtype)
+        expected_float = xp.astype(expected, xp.float64) if is_int_dtype else expected
+        expected = xp.astype(xp.sqrt(expected_float), dtype)
         xp_assert_close(output, expected, rtol=1e-6, atol=1e-6)
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only")
+    @uses_output_array
     @pytest.mark.parametrize('dtype',
                              ["int32", "float32", "float64",
                               "complex64", "complex128"])
@@ -1491,10 +1418,9 @@ class TestNdimageFilters:
         ndimage.gaussian_gradient_magnitude(array, 1.0, output)
         expected = tmp1 * tmp1 + tmp2 * tmp2
 
-        astype = array_namespace(expected).astype
-        fl_expected = astype(expected, xp.float64) if is_int_dtype else expected
+        fl_expected = xp.astype(expected, xp.float64) if is_int_dtype else expected
 
-        expected = astype(xp.sqrt(fl_expected), dtype)
+        expected = xp.astype(xp.sqrt(fl_expected), dtype)
         xp_assert_close(output, expected, rtol=1e-6, atol=1e-6)
 
     def test_generic_gradient_magnitude01(self, xp):
@@ -1514,18 +1440,12 @@ class TestNdimageFilters:
             extra_keywords={'b': 2.0})
         assert_array_almost_equal(tmp1, tmp2)
 
-    @skip_xp_backends("cupy",
-                      reason="https://github.com/cupy/cupy/pull/8430",
-    )
     def test_uniform01(self, xp):
         array = xp.asarray([2, 4, 6])
         size = 2
         output = ndimage.uniform_filter1d(array, size, origin=-1)
         assert_array_almost_equal(xp.asarray([3, 5, 6]), output)
 
-    @skip_xp_backends("cupy",
-                      reason="https://github.com/cupy/cupy/pull/8430",
-    )
     def test_uniform01_complex(self, xp):
         array = xp.asarray([2 + 1j, 4 + 2j, 6 + 3j], dtype=xp.complex128)
         size = 2
@@ -1545,9 +1465,6 @@ class TestNdimageFilters:
         output = ndimage.uniform_filter(array, filter_shape)
         assert_array_almost_equal(array, output)
 
-    @skip_xp_backends("cupy",
-                      reason="https://github.com/cupy/cupy/pull/8430",
-    )
     def test_uniform04(self, xp):
         array = xp.asarray([2, 4, 6])
         filter_shape = [2]
@@ -1560,15 +1477,10 @@ class TestNdimageFilters:
         output = ndimage.uniform_filter(array, filter_shape)
         assert_array_almost_equal(xp.asarray([]), output)
 
-    @skip_xp_backends("cupy",
-                      reason="https://github.com/cupy/cupy/pull/8430",
-    )
+    @uses_output_dtype
     @pytest.mark.parametrize('dtype_array', types)
     @pytest.mark.parametrize('dtype_output', types)
     def test_uniform06(self, dtype_array, dtype_output, xp):
-        if not (is_numpy(xp) or is_cupy(xp)):
-            pytest.xfail("output=dtype is numpy-specific")
-
         dtype_array = getattr(xp, dtype_array)
         dtype_output = getattr(xp, dtype_output)
 
@@ -1580,15 +1492,10 @@ class TestNdimageFilters:
         assert_array_almost_equal(xp.asarray([[4, 6, 10], [10, 12, 16]]), output)
         assert output.dtype.type == dtype_output
 
-    @skip_xp_backends("cupy",
-                      reason="https://github.com/cupy/cupy/pull/8430",
-    )
+    @uses_output_dtype
     @pytest.mark.parametrize('dtype_array', complex_types)
     @pytest.mark.parametrize('dtype_output', complex_types)
     def test_uniform06_complex(self, dtype_array, dtype_output, xp):
-        if not (is_numpy(xp) or is_cupy(xp)):
-            pytest.xfail("output=dtype is numpy-specific")
-
         dtype_array = getattr(xp, dtype_array)
         dtype_output = getattr(xp, dtype_output)
 
@@ -1634,7 +1541,7 @@ class TestNdimageFilters:
                                               [2, 2, 1, 1, 1],
                                               [5, 3, 3, 1, 1]]), output)
 
-    @skip_xp_backends("jax.numpy", reason="assignment destination is read-only")
+    @uses_output_array
     def test_minimum_filter05_overlap(self, xp):
         array = xp.asarray([[3, 2, 5, 1, 4],
                             [7, 6, 9, 3, 5],
@@ -1776,6 +1683,7 @@ class TestNdimageFilters:
                                               [7, 9, 8, 9, 7],
                                               [8, 8, 8, 7, 7]]), output)
 
+    @xfail_xp_backends("cupy", reason="https://github.com/cupy/cupy/pull/8339")
     @pytest.mark.parametrize(
         'axes', tuple(itertools.combinations(range(-3, 3), 2))
     )
@@ -1788,9 +1696,6 @@ class TestNdimageFilters:
          (ndimage.percentile_filter, dict(percentile=60))]
     )
     def test_minmax_nonseparable_axes(self, filter_func, axes, kwargs, xp):
-        if is_cupy(xp):
-            pytest.xfail("https://github.com/cupy/cupy/pull/8339")
-
         array = xp.arange(6 * 8 * 12, dtype=xp.float32)
         array = xp.reshape(array, (6, 8, 12))
         # use 2D triangular footprint because it is non-separable
@@ -1806,8 +1711,7 @@ class TestNdimageFilters:
 
         missing_axis = tuple(set(range(3)) - set(axes % array.ndim))[0]
 
-        expand_dims = array_namespace(footprint).expand_dims
-        footprint_3d = expand_dims(footprint, axis=missing_axis)
+        footprint_3d = xp.expand_dims(footprint, axis=missing_axis)
         expected = filter_func(array, footprint=footprint_3d, **kwargs)
         xp_assert_close(output, expected)
 
@@ -1865,18 +1769,14 @@ class TestNdimageFilters:
         output = ndimage.percentile_filter(array, 17, size=(2, 3))
         xp_assert_equal(expected, output)
 
-    @skip_xp_backends("jax.numpy",
-        reason="assignment destination is read-only",
-    )
+    @xfail_xp_backends("cupy", reason="cupy/cupy#8406")
+    @uses_output_array
     def test_rank06_overlap(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("https://github.com/cupy/cupy/issues/8406")
         array = xp.asarray([[3, 2, 5, 1, 4],
                             [5, 8, 3, 7, 1],
                             [5, 6, 9, 3, 5]])
 
-        asarray = array_namespace(array).asarray
-        array_copy = asarray(array, copy=True)
+        array_copy = xp.asarray(array, copy=True)
         expected = [[2, 2, 1, 1, 1],
                     [3, 3, 2, 1, 1],
                     [5, 5, 3, 3, 1]]
@@ -1969,9 +1869,6 @@ class TestNdimageFilters:
 
     @pytest.mark.parametrize('dtype', types)
     def test_rank12(self, dtype, xp):
-        if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
-            pytest.xfail("https://github.com/pytorch/pytorch/issues/58734")
-
         dtype = getattr(xp, dtype)
         expected = [[3, 3, 2, 4, 4],
                     [3, 5, 2, 5, 1],
@@ -1991,9 +1888,6 @@ class TestNdimageFilters:
 
     @pytest.mark.parametrize('dtype', types)
     def test_rank13(self, dtype, xp):
-        if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
-            pytest.xfail("https://github.com/pytorch/pytorch/issues/58734")
-
         dtype = getattr(xp, dtype)
         expected = [[5, 2, 5, 1, 1],
                     [5, 8, 3, 5, 5],
@@ -2009,9 +1903,6 @@ class TestNdimageFilters:
 
     @pytest.mark.parametrize('dtype', types)
     def test_rank14(self, dtype, xp):
-        if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
-            pytest.xfail("https://github.com/pytorch/pytorch/issues/58734")
-
         dtype = getattr(xp, dtype)
         expected = [[3, 5, 2, 5, 1],
                     [5, 5, 8, 3, 5],
@@ -2027,9 +1918,6 @@ class TestNdimageFilters:
 
     @pytest.mark.parametrize('dtype', types)
     def test_rank15(self, dtype, xp):
-        if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
-            pytest.xfail("https://github.com/pytorch/pytorch/issues/58734")
-
         dtype = getattr(xp, dtype)
         expected = [[2, 3, 1, 4, 1],
                     [5, 3, 7, 1, 1],
@@ -2043,7 +1931,8 @@ class TestNdimageFilters:
                                      origin=[-1, 0])
         xp_assert_equal(expected, output)
 
-    def test_rank16(self, xp):
+    # NumPy-only because test is for list input
+    def test_rank16(self):
         # test that lists are accepted and interpreted as numpy arrays
         array = [3, 2, 5, 1, 4]
         # expected values are: median(3, 2, 5) = 3, median(2, 5, 1) = 2, etc
@@ -2080,20 +1969,20 @@ class TestNdimageFilters:
             y = ndimage.rank_filter(x, -2, size=3)
             assert y.dtype == x.dtype
 
-    @skip_xp_backends(np_only=True, reason="off-by-ones on alt backends")
+    @skip_xp_backends(np_only=True, exceptions=["cupy"],
+                      reason="off-by-ones on alt backends")
+    @xfail_xp_backends("cupy", reason="does not support extra_arguments")
     @pytest.mark.parametrize('dtype', types)
     def test_generic_filter1d01(self, dtype, xp):
         weights = xp.asarray([1.1, 2.2, 3.3])
 
-        if is_cupy(xp):
-            pytest.xfail("CuPy does not support extra_arguments")
-
         def _filter_func(input, output, fltr, total):
             fltr = fltr / total
             for ii in range(input.shape[0] - 2):
                 output[ii] = input[ii] * fltr[0]
                 output[ii] += input[ii + 1] * fltr[1]
                 output[ii] += input[ii + 2] * fltr[2]
+
         a = np.arange(12, dtype=dtype).reshape(3, 4)
         a = xp.asarray(a)
         dtype = getattr(xp, dtype)
@@ -2105,10 +1994,9 @@ class TestNdimageFilters:
             extra_keywords={'total': xp.sum(weights)})
         assert_array_almost_equal(r1, r2)
 
+    @xfail_xp_backends("cupy", reason="does not support extra_arguments")
     @pytest.mark.parametrize('dtype', types)
     def test_generic_filter01(self, dtype, xp):
-        if is_cupy(xp):
-            pytest.xfail("CuPy does not support extra_arguments")
         if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
             pytest.xfail("https://github.com/pytorch/pytorch/issues/58734")
 
@@ -2297,10 +2185,8 @@ class TestNdimageFilters:
         xp_assert_equal(output, expected_value)
 
 
+@xfail_xp_backends("cupy", reason="TypeError")
 def test_ticket_701(xp):
-    if is_cupy(xp):
-        pytest.xfail("CuPy raises a TypeError.")
-
     # Test generic filter sizes
     arr = xp.asarray(np.arange(4).reshape(2, 2))
     def func(x):
@@ -2340,9 +2226,8 @@ def test_gh_5430():
     ndimage._ni_support._normalize_sequence(x, 0)
 
 
+@skip_xp_backends("cupy", reason="tests a private scipy utility")
 def test_gaussian_kernel1d(xp):
-    if is_cupy(xp):
-        pytest.skip("This test tests a private scipy utility.")
     radius = 10
     sigma = 2
     sigma2 = sigma * sigma
@@ -2373,13 +2258,12 @@ def test_orders_gauss(xp):
     assert_raises(ValueError, ndimage.gaussian_filter1d, arr, 1, -1, -1)
 
 
+@xfail_xp_backends("cupy", reason="TypeError")
 def test_valid_origins(xp):
     """Regression test for #1311."""
-    if is_cupy(xp):
-        pytest.xfail("CuPy raises a TypeError.")
-
     def func(x):
         return xp.mean(x)
+
     data = xp.asarray([1, 2, 3, 4, 5], dtype=xp.float64)
     assert_raises(ValueError, ndimage.generic_filter, data, func, size=3,
                   origin=2)
@@ -2418,9 +2302,7 @@ def test_bad_convolve_and_correlate_origins(xp):
     assert_raises(ValueError, ndimage.convolve,
                   xp.ones((3, 5)), xp.ones((2, 2)), origin=[0, -2])
 
-@skip_xp_backends("cupy",
-                  reason="https://github.com/cupy/cupy/pull/8430",
-)
+@skip_xp_backends("cupy", reason="https://github.com/cupy/cupy/pull/8430")
 def test_multiple_modes(xp):
     # Test that the filters with multiple mode capabilities for different
     # dimensions give the same result as applying a single mode.
@@ -2452,14 +2334,13 @@ def test_multiple_modes(xp):
 
 
 @skip_xp_backends("cupy", reason="https://github.com/cupy/cupy/pull/8430")
-@skip_xp_backends("jax.numpy", reason="output array is read-only.")
 def test_multiple_modes_sequentially(xp):
     # Test that the filters with multiple mode capabilities for different
     # dimensions give the same result as applying the filters with
     # different modes sequentially
     arr = xp.asarray([[1., 0., 0.],
-                    [1., 1., 0.],
-                    [0., 0., 0.]])
+                      [1., 1., 0.],
+                      [0., 0., 0.]])
 
     modes = ['reflect', 'wrap']
 
@@ -2567,9 +2448,7 @@ def test_multiple_modes_gaussian_gradient_magnitude(xp):
 
     assert_almost_equal(expected, calculated)
 
-@skip_xp_backends("cupy",
-                  reason="https://github.com/cupy/cupy/pull/8430",
-)
+@skip_xp_backends("cupy", reason="https://github.com/cupy/cupy/pull/8430")
 def test_multiple_modes_uniform(xp):
     # Test uniform filter for multiple extrapolation modes
     arr = xp.asarray([[1., 0., 0.],
@@ -2610,8 +2489,6 @@ def test_gaussian_truncate(xp):
     )
     assert num_nonzeros_5 == 51**2
 
-    nnz_kw = {'as_tuple': True} if is_torch(xp) else {}
-
     # Test truncate when sigma is a sequence.
     f = ndimage.gaussian_filter(arr, [0.5, 2.5], truncate=3.5)
     fpos = f > 0
@@ -2630,22 +2507,20 @@ def test_gaussian_truncate(xp):
 
     # Test gaussian_laplace
     y = ndimage.gaussian_laplace(x, sigma=2, truncate=3.5)
-    nonzero_indices = xp.nonzero(y != 0, **nnz_kw)[0]
+    nonzero_indices = xp.nonzero(y != 0)[0]
 
     n = xp.max(nonzero_indices) - xp.min(nonzero_indices) + 1
     assert n == 15
 
     # Test gaussian_gradient_magnitude
     y = ndimage.gaussian_gradient_magnitude(x, sigma=2, truncate=3.5)
-    nonzero_indices = xp.nonzero(y != 0, **nnz_kw)[0]
+    nonzero_indices = xp.nonzero(y != 0)[0]
     n = xp.max(nonzero_indices) - xp.min(nonzero_indices) + 1
     assert n == 15
 
 
+@xfail_xp_backends("cupy", reason="cupy/cupy#8402")
 def test_gaussian_radius(xp):
-    if is_cupy(xp):
-        pytest.xfail("https://github.com/cupy/cupy/issues/8402")
-
     # Test that Gaussian filters with radius argument produce the same
     # results as the filters with corresponding truncate argument.
     # radius = int(truncate * sigma + 0.5)
@@ -2674,10 +2549,8 @@ def test_gaussian_radius(xp):
     xp_assert_equal(f1, f2)
 
 
+@xfail_xp_backends("cupy", reason="cupy/cupy#8402")
 def test_gaussian_radius_invalid(xp):
-    if is_cupy(xp):
-        pytest.xfail("https://github.com/cupy/cupy/issues/8402")
-
     # radius must be a nonnegative integer
     with assert_raises(ValueError):
         ndimage.gaussian_filter1d(xp.zeros(8), sigma=1, radius=-1)
@@ -2685,7 +2558,7 @@ def test_gaussian_radius_invalid(xp):
         ndimage.gaussian_filter1d(xp.zeros(8), sigma=1, radius=1.1)
 
 
-@skip_xp_backends("jax.numpy", reason="output array is read-only")
+@uses_output_array
 class TestThreading:
     def check_func_thread(self, n, fun, args, out):
         from threading import Thread
@@ -2698,10 +2571,9 @@ class TestThreading:
         for i in range(n):
             fun(*args, output=out[i, ...])
 
+    @xfail_xp_backends("cupy",
+                       reason="XXX thread exception; cannot repro outside of pytest")
     def test_correlate1d(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("XXX thread exception; cannot repro outside of pytest")
-
         d = np.random.randn(5000)
         os = np.empty((4, d.size))
         ot = np.empty_like(os)
@@ -2713,10 +2585,9 @@ class TestThreading:
         self.check_func_thread(4, ndimage.correlate1d, (d, k), ot)
         xp_assert_equal(os, ot)
 
+    @xfail_xp_backends("cupy",
+                       reason="XXX thread exception; cannot repro outside of pytest")
     def test_correlate(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("XXX thread exception; cannot repro outside of pytest")
-
         d = xp.asarray(np.random.randn(500, 500))
         k = xp.asarray(np.random.randn(10, 10))
         os = xp.empty([4] + list(d.shape))
@@ -2725,10 +2596,9 @@ class TestThreading:
         self.check_func_thread(4, ndimage.correlate, (d, k), ot)
         xp_assert_equal(os, ot)
 
+    @xfail_xp_backends("cupy",
+                       reason="XXX thread exception; cannot repro outside of pytest")
     def test_median_filter(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("XXX thread exception; cannot repro outside of pytest")
-
         d = xp.asarray(np.random.randn(500, 500))
         os = xp.empty([4] + list(d.shape))
         ot = xp.empty_like(os)
@@ -2736,10 +2606,9 @@ class TestThreading:
         self.check_func_thread(4, ndimage.median_filter, (d, 3), ot)
         xp_assert_equal(os, ot)
 
+    @xfail_xp_backends("cupy",
+                       reason="XXX thread exception; cannot repro outside of pytest")
     def test_uniform_filter1d(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("XXX thread exception; cannot repro outside of pytest")
-
         d = np.random.randn(5000)
         os = np.empty((4, d.size))
         ot = np.empty_like(os)
@@ -2750,10 +2619,9 @@ class TestThreading:
         self.check_func_thread(4, ndimage.uniform_filter1d, (d, 5), ot)
         xp_assert_equal(os, ot)
 
+    @xfail_xp_backends("cupy",
+                       reason="XXX thread exception; cannot repro outside of pytest")
     def test_minmax_filter(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("XXX thread exception; cannot repro outside of pytest")
-
         d = xp.asarray(np.random.randn(500, 500))
         os = xp.empty([4] + list(d.shape))
         ot = xp.empty_like(os)
@@ -2794,9 +2662,8 @@ def test_minmaximum_filter1d(xp):
     xp_assert_equal(xp.asarray([9, 9, 4, 5, 6, 7, 8, 9, 9, 9]), out)
 
 
+@xfail_xp_backends("cupy", reason="cupy/cupy#8401")
 def test_uniform_filter1d_roundoff_errors(xp):
-    if is_cupy(xp):
-        pytest.xfail("https://github.com/cupy/cupy/issues/8401")
     # gh-6930
     in_ = np.repeat([0, 1, 0], [9, 9, 9])
     in_ = xp.asarray(in_)
@@ -2814,14 +2681,10 @@ def test_footprint_all_zeros(xp):
         ndimage.maximum_filter(arr, footprint=kernel)
 
 
-def test_gaussian_filter(xp):
-    if is_cupy(xp):
-        pytest.xfail("CuPy does not raise")
-
-    if not hasattr(xp, "float16"):
-        pytest.xfail(f"{xp} does not have float16")
-
-    # Test gaussian filter with xp.float16
+@xfail_xp_backends("cupy", reason="does not raise")
+@skip_xp_backends("array_api_strict", reason="no float16")
+@skip_xp_backends("dask.array", reason="no float16")
+def test_gaussian_filter_float16(xp):
     # gh-8207
     data = xp.asarray([1], dtype=xp.float16)
     sigma = 1.0
@@ -2829,10 +2692,8 @@ def test_gaussian_filter(xp):
         ndimage.gaussian_filter(data, sigma)
 
 
+@xfail_xp_backends("cupy", reason="does not raise")
 def test_rank_filter_noninteger_rank(xp):
-    if is_cupy(xp):
-        pytest.xfail("CuPy does not raise")
-
     # regression test for issue 9388: ValueError for
     # non integer rank when performing rank_filter
     arr = xp.asarray(np.random.random((10, 20, 30)))
@@ -2854,12 +2715,12 @@ def test_size_footprint_both_set(xp):
         )
 
 
-@skip_xp_backends(np_only=True, reason='byteorder is numpy-specific')
-def test_byte_order_median(xp):
+# NumPy-only because 'byteorder is numpy-specific'
+def test_byte_order_median():
     """Regression test for #413: median_filter does not handle bytes orders."""
-    a = xp.arange(9, dtype='<f4').reshape(3, 3)
+    a = np.arange(9, dtype='<f4').reshape(3, 3)
     ref = ndimage.median_filter(a, (3, 3))
-    b = xp.arange(9, dtype='>f4').reshape(3, 3)
+    b = np.arange(9, dtype='>f4').reshape(3, 3)
     t = ndimage.median_filter(b, (3, 3))
     assert_array_almost_equal(ref, t)
 
@@ -2909,6 +2770,256 @@ def test_gh_22333():
     assert_array_equal(actual, expected)
 
 
+@pytest.mark.filterwarnings("ignore:The given NumPy array is not writable:UserWarning")
+@pytest.mark.skip_xp_backends(cpu_only=True, exceptions=['cupy'])
+class TestVectorizedFilter:
+    @pytest.mark.parametrize("axes, size",
+                             [(None, (3, 4, 5)), ((0, 2), (3, 4)), ((-1,), (5,))])
+    @pytest.mark.parametrize("origin", [-1, 0, 1])
+    @pytest.mark.parametrize("mode",
+                             ['reflect', 'nearest', 'mirror', 'wrap', 'constant'])
+    @pytest.mark.parametrize("use_output", [False, True])
+    def test_against_generic_filter(self, axes, size, origin, mode, use_output, xp):
+        rng = np.random.default_rng(435982456983456987356)
+
+        if use_output and (is_dask(xp) or is_jax(xp)):
+            pytest.skip("Requires mutable arrays.")
+
+        input = rng.random(size=(11, 12, 13))
+        input_copy = input.copy()  # check that it is not modified
+        output = xp.zeros(input.shape) if use_output else None
+
+        kwargs = dict(axes=axes, size=size, origin=origin, mode=mode)
+        ref = ndimage.generic_filter(input, np.mean, **kwargs)
+        kwargs['output'] = output
+        res = ndimage.vectorized_filter(xp.asarray(input.tolist()),
+                                        xp.mean, **kwargs)
+        xp_assert_close(res, xp.asarray(ref.tolist()), atol=1e-15)
+        if use_output:
+            xp_assert_equal(output, res)
+
+        if not (is_array_api_strict(xp) or is_dask(xp)):
+            # currently requires support for [..., mask] indexing
+            kwargs.pop('size')
+            kwargs.pop('output')
+            kwargs['footprint'] = rng.random(size=size or input.shape) > 0.5
+            ref = ndimage.generic_filter(input, np.mean, **kwargs)
+            kwargs['footprint'] = xp.asarray(kwargs['footprint'])
+            kwargs['output'] = output
+            res = ndimage.vectorized_filter(xp.asarray(input.tolist()),
+                                            xp.mean, **kwargs)
+            xp_assert_close(res, xp.asarray(ref.tolist()), atol=1e-15)
+            if use_output:
+                xp_assert_equal(output, res)
+
+        xp_assert_equal(xp.asarray(input), xp.asarray(input_copy))
+
+    @pytest.mark.parametrize("dtype",
+                             ["uint8", "uint16", "uint32", "uint64",
+                              "int8", "int16", "int32", "int64",
+                              "float32", "float64", "complex64", "complex128"])
+    @pytest.mark.parametrize("batch_memory", [1, 16*3, np.inf])
+    @pytest.mark.parametrize("use_footprint", [False, True])
+    def test_dtype_batch_memory(self, dtype, batch_memory, use_footprint, xp):
+        rng = np.random.default_rng(435982456983456987356)
+        w = 3
+
+        if is_jax(xp) and not (batch_memory == 1):
+            pytest.skip("Requires mutable array.")
+        if is_torch(xp) and dtype in {'uint16', 'uint32', 'uint64'}:
+            pytest.skip("Needs uint support.")
+
+        dtype = getattr(xp, dtype)
+
+        if use_footprint:
+            if (is_dask(xp) or is_array_api_strict(xp)):
+                pytest.skip("Requires [..., mask] indexing.")
+            footprint = xp.asarray([True, False, True])
+            kwargs = dict(footprint=footprint, batch_memory=batch_memory)
+        else:
+            footprint = xp.asarray([True, True, True])
+            kwargs = dict(size=w, batch_memory=batch_memory)
+
+        # The intent here is to exercise all the code paths involved in `batch_memory`
+        # and `output` handling. To test the limited-memory case, `batch_memory=16*3`
+        # is chosen to be just large enough for a *single* window of `complex128` to
+        # fit, and `n` is large enough that a whole sliding window view of `uint8`s
+        # *won't* fit.
+        n = 16*3 + 1
+        input = rng.integers(0, 42, size=(n,))
+        input = input + input*1j if xp.isdtype(dtype, 'complex floating') else input
+        input_padded = xp.asarray(np.pad(input, [(1, 1)], mode='symmetric'),
+                                  dtype=dtype)
+        input = xp.asarray(input, dtype=dtype)
+
+        ref = [xp.sum(input_padded[i: i + w][footprint]) for i in range(n)]
+        sum_dtype = xp.sum(input_padded).dtype
+
+        message = "`batch_memory` is insufficient for minimum chunk size."
+        context = (pytest.raises(ValueError, match=message)
+                   if batch_memory == 1 else contextlib.nullcontext())
+        with context:
+            res = ndimage.vectorized_filter(input, xp.sum, **kwargs)
+            xp_assert_close(res, xp.astype(xp.stack(ref), sum_dtype))
+            assert res.dtype == sum_dtype
+
+            output = xp.empty_like(input)
+            res = ndimage.vectorized_filter(input, xp.sum, output=output, **kwargs)
+            xp_assert_close(res, xp.astype(xp.stack(ref), dtype))
+            assert res.dtype == dtype
+
+    def test_mode_valid(self, xp):
+        rng = np.random.default_rng(435982456983456987356)
+        input = rng.random(size=(10, 11))
+        input_xp = xp.asarray(input)
+        input_xp_copy = xp_copy(input_xp)  # check that it is not modified
+        size = (3, 5)
+
+        res = ndimage.vectorized_filter(input_xp, xp.mean, size=size, mode='valid')
+
+        view = np.lib.stride_tricks.sliding_window_view(input, size)
+        ref = np.mean(view, axis=(-2, -1))
+
+        xp_assert_close(res, xp.asarray(ref))
+        assert res.shape == tuple(input.shape - np.asarray(size) + 1)
+        xp_assert_equal(input_xp, input_xp_copy)
+
+    def test_input_validation(self, xp):
+        input = xp.ones((10, 10))
+        function = xp.mean
+        size = 2
+        footprint = xp.ones((2, 2))
+
+        message = "`function` must be a callable."
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, "eggplant", size=size)
+
+        message = "Either `size` or `footprint` must be provided."
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, function)
+
+        message = "Either `size` or `footprint` may be provided, not both."
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, function, size=size, footprint=footprint)
+
+        message = "All elements of `size` must be positive integers."
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, function, size=(1, -1))
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, function, size=0)
+
+        message = "The length of `axes` may not exceed "
+        axes = (0, 1, 2)
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, function, size=(1, 2), axes=axes)
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, function, footprint=xp.ones((2, 2)),
+                                      axes=axes)
+
+        message = "`axes` must be compatible with the dimensionality..."
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, function, size=(1,))
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, function, size=(2,), axes=(0,1))
+
+        message = "All elements of `origin` must be integers"
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, function, size=size, origin=(1, 1.5))
+
+        message = "`origin` must be an integer or tuple of integers with length..."
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, function, size=size, origin=(1, 2, 3))
+
+        message = "`mode` must be one of..."
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, function, size=size, mode='coconut')
+
+        message = "`mode='valid'` is incompatible with use of `origin`."
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, function, size=size,
+                                      mode='valid', origin=1)
+
+        message = "Use of `cval` is compatible only with `mode='constant'`."
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, function, size=size, mode='valid', cval=1)
+
+        other_messages = "|Unsupported|The array_api_strict|new|Value 'a duck'"
+        message = "`cval` must include only numbers." + other_messages
+        with pytest.raises((ValueError, TypeError), match=message):
+            ndimage.vectorized_filter(input, function, size=size,
+                              mode='constant', cval='a duck')
+
+        message = "`batch_memory` must be positive number." + other_messages
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, function, size=size, batch_memory=0)
+        with pytest.raises(ValueError, match=message):
+            ndimage.vectorized_filter(input, function, size=size, batch_memory=(1, 2))
+        with pytest.raises((ValueError, TypeError), match=message):
+            ndimage.vectorized_filter(input, function, size=size, batch_memory="a duck")
+
+    @pytest.mark.parametrize('shape', [(0,), (1, 0), (0, 1, 0)])
+    def test_zero_size(self, shape, xp):
+        input = xp.empty(shape)
+        res = ndimage.vectorized_filter(input, xp.mean, size=1)
+        xp_assert_equal(res, input)
+
+    @pytest.mark.filterwarnings("ignore:Mean of empty slice.:RuntimeWarning")
+    def test_edge_cases(self, xp):
+        rng = np.random.default_rng(4835982345234982)
+        function = xp.mean
+
+        # 0-D input
+        input = xp.asarray(1.)
+        res = ndimage.vectorized_filter(input, function, size=())
+        xp_assert_equal(res, xp.asarray(function(input, axis=())))
+
+        if not (is_array_api_strict(xp) or is_dask(xp)):
+            res = ndimage.vectorized_filter(input, function, footprint=True)
+            xp_assert_equal(res, xp.asarray(function(input[True], axis=())))
+
+            res = ndimage.vectorized_filter(input, function, footprint=False)
+            xp_assert_equal(res, xp.asarray(function(input[False], axis=())))
+
+        # 1x1 window
+        input = xp.asarray(rng.random((5, 5)))
+        res = ndimage.vectorized_filter(input, function, size=1)
+        xp_assert_equal(res, input)
+
+        # window is bigger than input shouldn't be a problem
+        res = ndimage.vectorized_filter(input, function, size=21)
+        ref = ndimage.vectorized_filter(input, function, size=21)
+        xp_assert_close(res, ref)
+
+    def test_gh23046_feature(self, xp):
+        # The intent of gh-23046 was to always allow `size` to be a scalar.
+        rng = np.random.default_rng(45982734597824)
+        img = xp.asarray(rng.random((5, 5)))
+
+        ref = ndimage.vectorized_filter(img, xp.mean, size=2)
+        res = ndimage.vectorized_filter(img, xp.mean, size=2, axes=(0, 1))
+        xp_assert_close(res, ref)
+
+        ref = ndimage.vectorized_filter(img, xp.mean, size=(2,), axes=(0,))
+        res = ndimage.vectorized_filter(img, xp.mean, size=2, axes=0)
+        xp_assert_close(res, ref)
+
+    def test_gh23046_fix(self, xp):
+        # While investigating the feasibility of gh-23046, I noticed a bug when the
+        # length of an `axes` tuple equals the dimensionality of the image.
+        rng = np.random.default_rng(45982734597824)
+        img = xp.asarray(rng.random((5, 5)))
+        size = (2, 3)
+        ref = ndimage.vectorized_filter(img.T, xp.mean, size=size).T
+        res = ndimage.vectorized_filter(img, xp.mean, size=size, axes=(1, 0))
+        xp_assert_close(res, ref)
+
+        ref = ndimage.vectorized_filter(img, xp.mean, size=size, mode='constant')
+        res = ndimage.vectorized_filter(img, xp.mean, size=size[::-1], axes=(1, 0),
+                                        mode='constant')
+        xp_assert_close(res, ref)
+
+
+
 @given(x=npst.arrays(dtype=np.float64,
                      shape=st.integers(min_value=1, max_value=1000)),
        size=st.integers(min_value=1, max_value=50),