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

scipy/ndimage/tests/test_morphology.py

@@ -1,6 +1,6 @@
 import numpy as np
 from scipy._lib._array_api import (
-    is_cupy, is_numpy, is_torch, array_namespace,
+    is_cupy, is_numpy,
     xp_assert_close, xp_assert_equal, assert_array_almost_equal
 )
 import pytest
@@ -10,12 +10,9 @@ from scipy import ndimage
 
 from . import types
 
-from scipy.conftest import array_api_compatible
 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'])]
 
 
 class TestNdimageMorphology:
@@ -118,7 +115,7 @@ class TestNdimageMorphology:
                      [0, 1, 2, 3, 4, 5, 6, 7, 8],
                      [0, 1, 2, 3, 4, 5, 6, 7, 8]]]
         expected = xp.asarray(expected)
-        assert_array_almost_equal(expected, ft)
+        assert_array_almost_equal(ft, expected)
 
     @xfail_xp_backends('cupy', reason='CuPy does not have distance_transform_bf.')
     @pytest.mark.parametrize('dtype', types)
@@ -224,7 +221,7 @@ class TestNdimageMorphology:
         for ft in fts:
             assert_array_almost_equal(tft, ft)
 
-    @xfail_xp_backends('cupy', reason='CuPy does not have distance_transform_bf.')
+    @xfail_xp_backends('cupy', reason='CuPy does not have distance_transform_bf')
     @pytest.mark.parametrize('dtype', types)
     def test_distance_transform_bf05(self, dtype, xp):
         dtype = getattr(xp, dtype)
@@ -273,7 +270,7 @@ class TestNdimageMorphology:
         expected = xp.asarray(expected)
         assert_array_almost_equal(ft, expected)
 
-    @xfail_xp_backends('cupy', reason='CuPy does not have distance_transform_bf.')
+    @xfail_xp_backends('cupy', reason='CuPy does not have distance_transform_bf')
     @pytest.mark.parametrize('dtype', types)
     def test_distance_transform_bf06(self, dtype, xp):
         dtype = getattr(xp, dtype)
@@ -322,10 +319,8 @@ class TestNdimageMorphology:
         expected = xp.asarray(expected)
         assert_array_almost_equal(ft, expected)
 
+    @xfail_xp_backends("cupy", reason="CuPy does not have distance_transform_bf")
     def test_distance_transform_bf07(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("CuPy does not have distance_transform_bf.")
-
         # test input validation per discussion on PR #13302
         data = xp.asarray([[0, 0, 0, 0, 0, 0, 0, 0, 0],
                            [0, 0, 0, 0, 0, 0, 0, 0, 0],
@@ -341,11 +336,10 @@ class TestNdimageMorphology:
                 data, return_distances=False, return_indices=False
             )
 
+    @xfail_xp_backends("cupy", reason="CuPy does not have distance_transform_cdt")
     @pytest.mark.parametrize('dtype', types)
     def test_distance_transform_cdt01(self, dtype, xp):
         dtype = getattr(xp, dtype)
-        if is_cupy(xp):
-            pytest.xfail("CuPy does not have distance_transform_cdt.")
 
         # chamfer type distance (cdt) transform
         data = xp.asarray([[0, 0, 0, 0, 0, 0, 0, 0, 0],
@@ -383,12 +377,10 @@ class TestNdimageMorphology:
         expected = xp.asarray(expected)
         assert_array_almost_equal(ft, expected)
 
+    @xfail_xp_backends("cupy", reason="CuPy does not have distance_transform_cdt")
     @pytest.mark.parametrize('dtype', types)
     def test_distance_transform_cdt02(self, dtype, xp):
         dtype = getattr(xp, dtype)
-        if is_cupy(xp):
-            pytest.xfail("CuPy does not have distance_transform_cdt.")
-
         data = xp.asarray([[0, 0, 0, 0, 0, 0, 0, 0, 0],
                            [0, 0, 0, 0, 0, 0, 0, 0, 0],
                            [0, 0, 0, 1, 1, 1, 0, 0, 0],
@@ -500,13 +492,11 @@ class TestNdimageMorphology:
                 indices=indices_out
             )
 
+    @xfail_xp_backends("cupy", reason="CuPy does not have distance_transform_cdt")
+    @xfail_xp_backends("torch", reason="int overflow")
     @pytest.mark.parametrize('dtype', types)
     def test_distance_transform_cdt05(self, dtype, xp):
         dtype = getattr(xp, dtype)
-        if is_cupy(xp):
-            pytest.xfail("CuPy does not have distance_transform_cdt.")
-        elif is_torch(xp):
-            pytest.xfail("int overflow")
 
         # test custom metric type per discussion on issue #17381
         data = xp.asarray([[0, 0, 0, 0, 0, 0, 0, 0, 0],
@@ -522,11 +512,10 @@ class TestNdimageMorphology:
         actual = ndimage.distance_transform_cdt(data, metric=metric_arg)
         assert xp.sum(actual) == -21
 
+    @xfail_xp_backends("cupy", reason="CuPy does not have distance_transform_bf")
     @pytest.mark.parametrize('dtype', types)
     def test_distance_transform_edt01(self, dtype, xp):
         dtype = getattr(xp, dtype)
-        if is_cupy(xp):
-            pytest.xfail("CuPy does not have distance_transform_bf")
 
         # euclidean distance transform (edt)
         data = xp.asarray([[0, 0, 0, 0, 0, 0, 0, 0, 0],
@@ -617,11 +606,10 @@ class TestNdimageMorphology:
         for ft in fts:
             assert_array_almost_equal(tft, ft)
 
+    @xfail_xp_backends("cupy", reason="CuPy does not have distance_transform_bf")
     @pytest.mark.parametrize('dtype', types)
     def test_distance_transform_edt03(self, dtype, xp):
         dtype = getattr(xp, dtype)
-        if is_cupy(xp):
-            pytest.xfail("CuPy does not have distance_transform_bf")
 
         data = xp.asarray([[0, 0, 0, 0, 0, 0, 0, 0, 0],
                            [0, 0, 0, 0, 0, 0, 0, 0, 0],
@@ -634,13 +622,12 @@ class TestNdimageMorphology:
                            [0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=dtype)
         ref = ndimage.distance_transform_bf(data, 'euclidean', sampling=[2, 2])
         out = ndimage.distance_transform_edt(data, sampling=[2, 2])
-        assert_array_almost_equal(ref, out)
+        assert_array_almost_equal(out, ref)
 
+    @xfail_xp_backends("cupy", reason="CuPy does not have distance_transform_bf")
     @pytest.mark.parametrize('dtype', types)
     def test_distance_transform_edt4(self, dtype, xp):
         dtype = getattr(xp, dtype)
-        if is_cupy(xp):
-            pytest.xfail("CuPy does not have distance_transform_bf")
 
         data = xp.asarray([[0, 0, 0, 0, 0, 0, 0, 0, 0],
                            [0, 0, 0, 0, 0, 0, 0, 0, 0],
@@ -653,14 +640,17 @@ class TestNdimageMorphology:
                            [0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=dtype)
         ref = ndimage.distance_transform_bf(data, 'euclidean', sampling=[2, 1])
         out = ndimage.distance_transform_edt(data, sampling=[2, 1])
-        assert_array_almost_equal(ref, out)
+        assert_array_almost_equal(out, ref)
 
+    @xfail_xp_backends(
+        "cupy", reason="Only 2D and 3D distance transforms are supported in CuPy"
+    )
     def test_distance_transform_edt5(self, xp):
         # Ticket #954 regression test
-        out = ndimage.distance_transform_edt(False)
-        assert_array_almost_equal(out, [0.])
+        out = ndimage.distance_transform_edt(xp.asarray(False))
+        assert_array_almost_equal(out, xp.asarray([0.]))
 
-    @skip_xp_backends(
+    @xfail_xp_backends(
         np_only=True, reason='XXX: does not raise unless indices is a numpy array'
     )
     def test_distance_transform_edt6(self, xp):
@@ -683,20 +673,28 @@ class TestNdimageMorphology:
                 distances=distances_out
             )
 
+    @skip_xp_backends(np_only=True,
+                      reason="generate_binary_structure always generates numpy objects")
     def test_generate_structure01(self, xp):
         struct = ndimage.generate_binary_structure(0, 1)
         assert struct == 1
 
+    @skip_xp_backends(np_only=True,
+                      reason="generate_binary_structure always generates numpy objects")
     def test_generate_structure02(self, xp):
         struct = ndimage.generate_binary_structure(1, 1)
         assert_array_almost_equal(struct, [1, 1, 1])
 
+    @skip_xp_backends(np_only=True,
+                      reason="generate_binary_structure always generates numpy objects")
     def test_generate_structure03(self, xp):
         struct = ndimage.generate_binary_structure(2, 1)
         assert_array_almost_equal(struct, [[0, 1, 0],
                                            [1, 1, 1],
                                            [0, 1, 0]])
 
+    @skip_xp_backends(np_only=True,
+                      reason="generate_binary_structure always generates numpy objects")
     def test_generate_structure04(self, xp):
         struct = ndimage.generate_binary_structure(2, 2)
         assert_array_almost_equal(struct, [[1, 1, 1],
@@ -783,6 +781,15 @@ class TestNdimageMorphology:
         out = ndimage.binary_erosion(data)
         assert_array_almost_equal(out, xp.asarray([0, 1, 0]))
 
+    @pytest.mark.parametrize('dtype', types)
+    @xfail_xp_backends("cupy", reason="https://github.com/cupy/cupy/issues/8912")
+    def test_binary_erosion05_broadcasted(self, dtype, xp):
+        dtype = getattr(xp, dtype)
+        data = xp.ones((1, ), dtype=dtype)
+        data = xp.broadcast_to(data, (3, ))
+        out = ndimage.binary_erosion(data)
+        assert_array_almost_equal(out, xp.asarray([0, 1, 0]))
+
     @pytest.mark.parametrize('dtype', types)
     def test_binary_erosion06(self, dtype, xp):
         dtype = getattr(xp, dtype)
@@ -1039,10 +1046,10 @@ class TestNdimageMorphology:
                                      origin=(-1, -1))
         assert_array_almost_equal(out, expected)
 
+    @xfail_xp_backends(
+        "cupy", reason="CuPy: NotImplementedError: only brute_force iteration"
+    )
     def test_binary_erosion27(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("CuPy: NotImplementedError: only brute_force iteration")
-
         struct = [[0, 1, 0],
                   [1, 1, 1],
                   [0, 1, 0]]
@@ -1067,9 +1074,10 @@ class TestNdimageMorphology:
                                      iterations=2)
         assert_array_almost_equal(out, expected)
 
-    @skip_xp_backends(
-        np_only=True, reason='inplace out= arguments are numpy-specific'
-    )
+    @skip_xp_backends(np_only=True, exceptions=["cupy"],
+                      reason='inplace out= arguments are numpy-specific')
+    @xfail_xp_backends("cupy",
+                       reason="NotImplementedError: only brute_force iteration")
     def test_binary_erosion28(self, xp):
         struct = [[0, 1, 0],
                   [1, 1, 1],
@@ -1098,10 +1106,10 @@ class TestNdimageMorphology:
                                iterations=2, output=out)
         assert_array_almost_equal(out, expected)
 
+    @xfail_xp_backends(
+        "cupy", reason="CuPy: NotImplementedError: only brute_force iteration"
+    )
     def test_binary_erosion29(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("CuPy: NotImplementedError: only brute_force iteration")
-
         struct = [[0, 1, 0],
                   [1, 1, 1],
                   [0, 1, 0]]
@@ -1126,13 +1134,11 @@ class TestNdimageMorphology:
                                      border_value=1, iterations=3)
         assert_array_almost_equal(out, expected)
 
-    @skip_xp_backends(
-        np_only=True, reason='inplace out= arguments are numpy-specific'
-    )
+    @skip_xp_backends(np_only=True, exceptions=["cupy"],
+                      reason='inplace out= arguments are numpy-specific')
+    @xfail_xp_backends("cupy",
+                       reason="NotImplementedError: only brute_force iteration")
     def test_binary_erosion30(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("CuPy: NotImplementedError: only brute_force iteration")
-
         struct = [[0, 1, 0],
                   [1, 1, 1],
                   [0, 1, 0]]
@@ -1165,9 +1171,8 @@ class TestNdimageMorphology:
                                iterations=3, output=data)
         assert_array_almost_equal(data, expected)
 
-    @skip_xp_backends(
-        np_only=True, reason='inplace out= arguments are numpy-specific'
-    )
+    @skip_xp_backends(np_only=True, exceptions=["cupy"],
+                      reason='inplace out= arguments are numpy-specific')
     def test_binary_erosion31(self, xp):
         struct = [[0, 1, 0],
                   [1, 1, 1],
@@ -1196,10 +1201,9 @@ class TestNdimageMorphology:
                                iterations=1, output=out, origin=(-1, -1))
         assert_array_almost_equal(out, expected)
 
+    @xfail_xp_backends("cupy",
+                       reason="NotImplementedError: only brute_force iteration")
     def test_binary_erosion32(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("CuPy: NotImplementedError: only brute_force iteration")
-
         struct = [[0, 1, 0],
                   [1, 1, 1],
                   [0, 1, 0]]
@@ -1224,10 +1228,9 @@ class TestNdimageMorphology:
                                      border_value=1, iterations=2)
         assert_array_almost_equal(out, expected)
 
+    @xfail_xp_backends("cupy",
+                       reason="NotImplementedError: only brute_force iteration")
     def test_binary_erosion33(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("CuPy: NotImplementedError: only brute_force iteration")
-
         struct = [[0, 1, 0],
                   [1, 1, 1],
                   [0, 1, 0]]
@@ -1293,9 +1296,8 @@ class TestNdimageMorphology:
                                      border_value=1, mask=mask)
         assert_array_almost_equal(out, expected)
 
-    @skip_xp_backends(
-        np_only=True, reason='inplace out= arguments are numpy-specific'
-    )
+    @skip_xp_backends(np_only=True, exceptions=["cupy"], 
+                      reason='inplace out= arguments are numpy-specific')
     def test_binary_erosion35(self, xp):
         struct = [[0, 1, 0],
                   [1, 1, 1],
@@ -1337,10 +1339,9 @@ class TestNdimageMorphology:
                                origin=(-1, -1), mask=mask)
         assert_array_almost_equal(out, expected)
 
+    @xfail_xp_backends("cupy",
+                       reason="NotImplementedError: only brute_force iteration")
     def test_binary_erosion36(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("CuPy: NotImplementedError: only brute_force iteration")
-
         struct = [[0, 1, 0],
                   [1, 0, 1],
                   [0, 1, 0]]
@@ -1381,9 +1382,10 @@ class TestNdimageMorphology:
                                      border_value=1, origin=(-1, -1))
         assert_array_almost_equal(out, expected)
 
-    @skip_xp_backends(
-        np_only=True, reason='inplace out= arguments are numpy-specific'
-    )
+    @skip_xp_backends(np_only=True, exceptions=["cupy"],
+                      reason='inplace out= arguments are numpy-specific')
+    @xfail_xp_backends("cupy",
+                       reason="NotImplementedError: only brute_force iteration")
     def test_binary_erosion37(self, xp):
         a = np.asarray([[1, 0, 1],
                         [0, 1, 0],
@@ -1407,9 +1409,10 @@ class TestNdimageMorphology:
         with assert_raises(TypeError):
             _ = ndimage.binary_erosion(data, iterations=iterations)
 
-    @skip_xp_backends(
-        np_only=True, reason='inplace out= arguments are numpy-specific'
-    )
+    @skip_xp_backends(np_only=True, exceptions=["cupy"],
+                      reason='inplace out= arguments are numpy-specific')
+    @xfail_xp_backends("cupy",
+                       reason="NotImplementedError: only brute_force iteration")
     def test_binary_erosion39(self, xp):
         iterations = np.int32(3)
         struct = [[0, 1, 0],
@@ -1439,9 +1442,10 @@ class TestNdimageMorphology:
                                iterations=iterations, output=out)
         assert_array_almost_equal(out, expected)
 
-    @skip_xp_backends(
-        np_only=True, reason='inplace out= arguments are numpy-specific'
-    )
+    @skip_xp_backends(np_only=True, exceptions=["cupy"],
+                      reason='inplace out= arguments are numpy-specific')
+    @xfail_xp_backends("cupy",
+                       reason="NotImplementedError: only brute_force iteration")
     def test_binary_erosion40(self, xp):
         iterations = np.int64(3)
         struct = [[0, 1, 0],
@@ -1506,6 +1510,14 @@ class TestNdimageMorphology:
         out = ndimage.binary_dilation(data)
         assert_array_almost_equal(out, xp.asarray([1, 1, 1]))
 
+    @pytest.mark.parametrize('dtype', types)
+    def test_binary_dilation05_broadcasted(self, dtype, xp):
+        dtype = getattr(xp, dtype)
+        data = xp.ones((1, ), dtype=dtype)
+        data = xp.broadcast_to(data, (3,))
+        out = ndimage.binary_dilation(data)
+        assert_array_almost_equal(out, xp.asarray([1, 1, 1]))
+
     @pytest.mark.parametrize('dtype', types)
     def test_binary_dilation06(self, dtype, xp):
         dtype = getattr(xp, dtype)
@@ -1801,10 +1813,9 @@ class TestNdimageMorphology:
         out = ndimage.binary_dilation(data, border_value=1)
         assert_array_almost_equal(out, expected)
 
+    @xfail_xp_backends("cupy",
+                       reason="NotImplementedError: only brute_force iteration")
     def test_binary_dilation29(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("CuPy: NotImplementedError: only brute_force iteration")
-
         struct = [[0, 1],
                   [1, 1]]
         expected = [[0, 0, 0, 0, 0],
@@ -1823,10 +1834,11 @@ class TestNdimageMorphology:
         out = ndimage.binary_dilation(data, struct, iterations=2)
         assert_array_almost_equal(out, expected)
 
-    @skip_xp_backends(np_only=True, reason='output= arrays are numpy-specific')
+    @skip_xp_backends(np_only=True, exceptions=["cupy"],
+                      reason='output= arrays are numpy-specific')
+    @xfail_xp_backends("cupy",
+                       reason="NotImplementedError: only brute_force iteration")
     def test_binary_dilation30(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("CuPy: NotImplementedError: only brute_force iteration")
         struct = [[0, 1],
                   [1, 1]]
         expected = [[0, 0, 0, 0, 0],
@@ -1847,10 +1859,9 @@ class TestNdimageMorphology:
         ndimage.binary_dilation(data, struct, iterations=2, output=out)
         assert_array_almost_equal(out, expected)
 
+    @xfail_xp_backends("cupy",
+                       reason="NotImplementedError: only brute_force iteration")
     def test_binary_dilation31(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("CuPy: NotImplementedError: only brute_force iteration")
-
         struct = [[0, 1],
                   [1, 1]]
         expected = [[0, 0, 0, 1, 0],
@@ -1869,11 +1880,11 @@ class TestNdimageMorphology:
         out = ndimage.binary_dilation(data, struct, iterations=3)
         assert_array_almost_equal(out, expected)
 
-    @skip_xp_backends(np_only=True, reason='output= arrays are numpy-specific')
+    @skip_xp_backends(np_only=True, exceptions=["cupy"],
+                      reason='output= arrays are numpy-specific')
+    @xfail_xp_backends("cupy",
+                       reason="NotImplementedError: only brute_force iteration")
     def test_binary_dilation32(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("CuPy: NotImplementedError: only brute_force iteration")
-
         struct = [[0, 1],
                   [1, 1]]
         expected = [[0, 0, 0, 1, 0],
@@ -1894,9 +1905,9 @@ class TestNdimageMorphology:
         ndimage.binary_dilation(data, struct, iterations=3, output=out)
         assert_array_almost_equal(out, expected)
 
+    @xfail_xp_backends("cupy",
+                       reason="NotImplementedError: only brute_force iteration")
     def test_binary_dilation33(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("CuPy: NotImplementedError: only brute_force iteration")
         struct = [[0, 1, 0],
                   [1, 1, 1],
                   [0, 1, 0]]
@@ -1933,13 +1944,11 @@ class TestNdimageMorphology:
                                       mask=mask, border_value=0)
         assert_array_almost_equal(out, expected)
 
-    @skip_xp_backends(
-        np_only=True, reason='inplace output= arrays are numpy-specific',
-    )
+    @skip_xp_backends(np_only=True, exceptions=["cupy"],
+                      reason='inplace output= arrays are numpy-specific')
+    @xfail_xp_backends("cupy",
+                       reason="NotImplementedError: only brute_force iteration")
     def test_binary_dilation34(self, xp):
-        if is_cupy(xp):
-            pytest.xfail("CuPy: NotImplementedError: only brute_force iteration")
-
         struct = [[0, 1, 0],
                   [1, 1, 1],
                   [0, 1, 0]]
@@ -2322,7 +2331,8 @@ class TestNdimageMorphology:
                                               [2, 3, 1, 3, 1],
                                               [5, 5, 3, 3, 1]]))
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only.")
+    @skip_xp_backends("jax.numpy", reason="output=array requires buffer view")
+    @skip_xp_backends("dask.array", reason="output=array requires buffer view")
     @xfail_xp_backends("cupy", reason="https://github.com/cupy/cupy/issues/8398")
     def test_grey_erosion01_overlap(self, xp):
 
@@ -2437,7 +2447,7 @@ class TestNdimageMorphology:
         tmp = ndimage.grey_dilation(array, footprint=footprint)
         expected = ndimage.grey_erosion(tmp, footprint=footprint)
         output = ndimage.grey_closing(array, footprint=footprint)
-        assert_array_almost_equal(expected, output)
+        assert_array_almost_equal(output, expected)
 
     def test_grey_closing02(self, xp):
         array = xp.asarray([[3, 2, 5, 1, 4],
@@ -2451,7 +2461,7 @@ class TestNdimageMorphology:
                                         structure=structure)
         output = ndimage.grey_closing(array, footprint=footprint,
                                       structure=structure)
-        assert_array_almost_equal(expected, output)
+        assert_array_almost_equal(output, expected)
 
     @skip_xp_backends(np_only=True, reason='output= arrays are numpy-specific')
     def test_morphological_gradient01(self, xp):
@@ -2468,7 +2478,7 @@ class TestNdimageMorphology:
         output = xp.zeros(array.shape, dtype=array.dtype)
         ndimage.morphological_gradient(array, footprint=footprint,
                                        structure=structure, output=output)
-        assert_array_almost_equal(expected, output)
+        assert_array_almost_equal(output, expected)
 
     def test_morphological_gradient02(self, xp):
         array = xp.asarray([[3, 2, 5, 1, 4],
@@ -2483,7 +2493,7 @@ class TestNdimageMorphology:
         expected = tmp1 - tmp2
         output = ndimage.morphological_gradient(array, footprint=footprint,
                                                 structure=structure)
-        assert_array_almost_equal(expected, output)
+        assert_array_almost_equal(output, expected)
 
     @skip_xp_backends(np_only=True, reason='output= arrays are numpy-specific')
     def test_morphological_laplace01(self, xp):
@@ -2500,7 +2510,7 @@ class TestNdimageMorphology:
         output = xp.zeros(array.shape, dtype=array.dtype)
         ndimage.morphological_laplace(array, footprint=footprint,
                                       structure=structure, output=output)
-        assert_array_almost_equal(expected, output)
+        assert_array_almost_equal(output, expected)
 
     def test_morphological_laplace02(self, xp):
         array = xp.asarray([[3, 2, 5, 1, 4],
@@ -2515,9 +2525,10 @@ class TestNdimageMorphology:
         expected = tmp1 + tmp2 - 2 * array
         output = ndimage.morphological_laplace(array, footprint=footprint,
                                                structure=structure)
-        assert_array_almost_equal(expected, output)
+        assert_array_almost_equal(output, expected)
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only.")
+    @skip_xp_backends("jax.numpy", reason="output=array requires buffer view")
+    @skip_xp_backends("dask.array", reason="output=array requires buffer view")
     def test_white_tophat01(self, xp):
         array = xp.asarray([[3, 2, 5, 1, 4],
                             [7, 6, 9, 3, 5],
@@ -2530,7 +2541,7 @@ class TestNdimageMorphology:
         output = xp.zeros(array.shape, dtype=array.dtype)
         ndimage.white_tophat(array, footprint=footprint,
                              structure=structure, output=output)
-        assert_array_almost_equal(expected, output)
+        assert_array_almost_equal(output, expected)
 
     def test_white_tophat02(self, xp):
         array = xp.asarray([[3, 2, 5, 1, 4],
@@ -2543,7 +2554,7 @@ class TestNdimageMorphology:
         expected = array - tmp
         output = ndimage.white_tophat(array, footprint=footprint,
                                       structure=structure)
-        assert_array_almost_equal(expected, output)
+        assert_array_almost_equal(output, expected)
 
     @xfail_xp_backends('cupy', reason="cupy#8399")
     def test_white_tophat03(self, xp):
@@ -2568,9 +2579,10 @@ class TestNdimageMorphology:
         expected = xp.asarray(expected)
 
         output = ndimage.white_tophat(array, structure=structure)
-        xp_assert_equal(expected, output)
+        xp_assert_equal(output, expected)
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only.")
+    @skip_xp_backends("jax.numpy", reason="output=array requires buffer view")
+    @skip_xp_backends("dask.array", reason="output=array requires buffer view")
     def test_white_tophat04(self, xp):
         array = np.eye(5, dtype=bool)
         structure = np.ones((3, 3), dtype=bool)
@@ -2582,7 +2594,8 @@ class TestNdimageMorphology:
         output = xp.empty_like(array, dtype=xp.float64)
         ndimage.white_tophat(array, structure=structure, output=output)
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only.")
+    @skip_xp_backends("jax.numpy", reason="output=array requires buffer view")
+    @skip_xp_backends("dask.array", reason="output=array requires buffer view")
     def test_black_tophat01(self, xp):
         array = xp.asarray([[3, 2, 5, 1, 4],
                             [7, 6, 9, 3, 5],
@@ -2595,7 +2608,7 @@ class TestNdimageMorphology:
         output = xp.zeros(array.shape, dtype=array.dtype)
         ndimage.black_tophat(array, footprint=footprint,
                              structure=structure, output=output)
-        assert_array_almost_equal(expected, output)
+        assert_array_almost_equal(output, expected)
 
     def test_black_tophat02(self, xp):
         array = xp.asarray([[3, 2, 5, 1, 4],
@@ -2608,7 +2621,7 @@ class TestNdimageMorphology:
         expected = tmp - array
         output = ndimage.black_tophat(array, footprint=footprint,
                                       structure=structure)
-        assert_array_almost_equal(expected, output)
+        assert_array_almost_equal(output, expected)
 
     @xfail_xp_backends('cupy', reason="cupy/cupy#8399")
     def test_black_tophat03(self, xp):
@@ -2633,9 +2646,10 @@ class TestNdimageMorphology:
         expected = xp.asarray(expected)
 
         output = ndimage.black_tophat(array, structure=structure)
-        xp_assert_equal(expected, output)
+        xp_assert_equal(output, expected)
 
-    @skip_xp_backends("jax.numpy", reason="output array is read-only.")
+    @skip_xp_backends("jax.numpy", reason="output=array requires buffer view")
+    @skip_xp_backends("dask.array", reason="output=array requires buffer view")
     def test_black_tophat04(self, xp):
         array = xp.asarray(np.eye(5, dtype=bool))
         structure = xp.asarray(np.ones((3, 3), dtype=bool))
@@ -2700,11 +2714,10 @@ class TestNdimageMorphology:
             out = func(data, axes=axes, **kwargs)
         xp_assert_close(out, expected)
 
+    @skip_xp_backends(np_only=True, exceptions=["cupy"],
+                      reason="inplace output= is numpy-specific")
     @pytest.mark.parametrize('dtype', types)
     def test_hit_or_miss01(self, dtype, xp):
-        if not (is_numpy(xp) or is_cupy(xp)):
-            pytest.xfail("inplace output= is numpy-specific")
-
         dtype = getattr(xp, dtype)
         struct = [[0, 1, 0],
                   [1, 1, 1],
@@ -2729,7 +2742,7 @@ class TestNdimageMorphology:
                            [0, 0, 0, 0, 0]], dtype=dtype)
         out = xp.asarray(np.zeros(data.shape, dtype=bool))
         ndimage.binary_hit_or_miss(data, struct, output=out)
-        assert_array_almost_equal(expected, out)
+        assert_array_almost_equal(out, expected)
 
     @pytest.mark.parametrize('dtype', types)
     def test_hit_or_miss02(self, dtype, xp):
@@ -2748,7 +2761,7 @@ class TestNdimageMorphology:
                            [0, 1, 0, 1, 1, 1, 1, 0],
                            [0, 0, 0, 0, 0, 0, 0, 0]], dtype=dtype)
         out = ndimage.binary_hit_or_miss(data, struct)
-        assert_array_almost_equal(expected, out)
+        assert_array_almost_equal(out, expected)
 
     @pytest.mark.parametrize('dtype', types)
     def test_hit_or_miss03(self, dtype, xp):
@@ -2779,7 +2792,7 @@ class TestNdimageMorphology:
                            [0, 1, 1, 1, 1, 1, 1, 0],
                            [0, 0, 0, 0, 0, 0, 0, 0]], dtype=dtype)
         out = ndimage.binary_hit_or_miss(data, struct1, struct2)
-        assert_array_almost_equal(expected, out)
+        assert_array_almost_equal(out, expected)
 
 
 class TestDilateFix:
@@ -2800,9 +2813,7 @@ class TestDilateFix:
         if is_numpy(xp):
             self.dilated3x3 = dilated3x3.view(xp.uint8)
         else:
-            astype = array_namespace(dilated3x3).astype
-            self.dilated3x3 = astype(dilated3x3, xp.uint8)
-
+            self.dilated3x3 = xp.astype(dilated3x3, xp.uint8)
 
     def test_dilation_square_structure(self, xp):
         self._setup(xp)
@@ -2874,14 +2885,12 @@ def test_binary_closing_noninteger_iterations(xp):
     assert_raises(TypeError, ndimage.binary_closing, data, iterations=1.5)
 
 
+@xfail_xp_backends(
+    "cupy", reason="CuPy: NotImplementedError: only brute_force iteration"
+)
 def test_binary_closing_noninteger_brute_force_passes_when_true(xp):
-    # regression test for gh-9905, gh-9909: ValueError for
-    # non integer iterations
-    if is_cupy(xp):
-        pytest.xfail("CuPy: NotImplementedError: only brute_force iteration")
-
+    # regression test for gh-9905, gh-9909: ValueError for non integer iterations
     data = xp.ones([1])
-
     xp_assert_equal(ndimage.binary_erosion(data, iterations=2, brute_force=1.5),
                     ndimage.binary_erosion(data, iterations=2, brute_force=bool(1.5))
     )
@@ -2890,6 +2899,9 @@ def test_binary_closing_noninteger_brute_force_passes_when_true(xp):
     )
 
 
+@skip_xp_backends(np_only=True, exceptions=["cupy"],
+                  reason="inplace output= is numpy-specific")
+@xfail_xp_backends("cupy", reason="NotImplementedError: only brute_force iteration")
 @pytest.mark.parametrize(
     'function',
     ['binary_erosion', 'binary_dilation', 'binary_opening', 'binary_closing'],
@@ -2899,6 +2911,7 @@ def test_binary_closing_noninteger_brute_force_passes_when_true(xp):
 def test_binary_input_as_output(function, iterations, brute_force, xp):
     rstate = np.random.RandomState(123)
     data = rstate.randint(low=0, high=2, size=100).astype(bool)
+    data = xp.asarray(data)
     ndi_func = getattr(ndimage, function)
 
     # input data is not modified
@@ -2908,15 +2921,15 @@ def test_binary_input_as_output(function, iterations, brute_force, xp):
 
     # data should now contain the expected result
     ndi_func(data, brute_force=brute_force, iterations=iterations, output=data)
-    xp_assert_equal(expected, data)
+    xp_assert_equal(data, expected)
 
 
+@skip_xp_backends(np_only=True, exceptions=["cupy"],
+                  reason="inplace output= is numpy-specific")
 def test_binary_hit_or_miss_input_as_output(xp):
-    if not (is_numpy(xp) or is_cupy(xp)):
-        pytest.xfail("inplace output= is numpy-specific")
-
     rstate = np.random.RandomState(123)
     data = rstate.randint(low=0, high=2, size=100).astype(bool)
+    data = xp.asarray(data)
 
     # input data is not modified
     data_orig = data.copy()
@@ -2925,13 +2938,12 @@ def test_binary_hit_or_miss_input_as_output(xp):
 
     # data should now contain the expected result
     ndimage.binary_hit_or_miss(data, output=data)
-    xp_assert_equal(expected, data)
+    xp_assert_equal(data, expected)
 
 
+@xfail_xp_backends("cupy",
+                   reason="CuPy does not have distance_transform_cdt")
 def test_distance_transform_cdt_invalid_metric(xp):
-    if is_cupy(xp):
-        pytest.xfail("CuPy does not have distance_transform_cdt")
-
     msg = 'invalid metric provided'
     with pytest.raises(ValueError, match=msg):
         ndimage.distance_transform_cdt(xp.ones((5, 5)),