Add more tests

Author: Vahid Tavanashad

dpnp/dpnp_iface_manipulation.py

@@ -119,7 +119,7 @@ def _check_stack_arrays(arrays):
 def _delete_with_slice(a, obj, axis):
     """Utility function for ``dpnp.delete`` when obj is slice."""
 
-    a_ndim, order, axis, slobj, n, a_shape = _calc_parameters(a, axis)
+    a, a_ndim, order, axis, slobj, n, a_shape = _calc_parameters(a, axis)
     start, stop, step = obj.indices(n)
     xr = range(start, stop, step)
     num_del = len(xr)
@@ -179,7 +179,7 @@ def _delete_with_slice(a, obj, axis):
 def _delete_without_slice(a, obj, axis, single_value):
     """Utility function for ``dpnp.delete`` when obj is int or array of int."""
 
-    a_ndim, order, axis, slobj, n, a_shape = _calc_parameters(a, axis)
+    a, a_ndim, order, axis, slobj, n, a_shape = _calc_parameters(a, axis)
     if single_value:
         # optimization for a single value
         if obj < -n or obj >= n:
@@ -242,7 +242,7 @@ def _calc_parameters(a, axis):
     n = a.shape[axis]
     a_shape = list(a.shape)
 
-    return a_ndim, order, axis, slobj, n, a_shape
+    return a, a_ndim, order, axis, slobj, n, a_shape
 
 
 def _unique_1d(

tests/test_manipulation.py

@@ -333,34 +333,56 @@ def test_no_copy(self):
 
 
 class TestDelete:
-    def _check_inverse_of_slicing(self, indices):
+    @pytest.mark.parametrize(
+        "obj", [slice(0, 4, 2), 3, [2, 3]], ids=["slice", "int", "list"]
+    )
+    @pytest.mark.parametrize("dt", get_all_dtypes(no_none=True))
+    def test_dtype(self, dt, obj):
+        a = numpy.array([0, 1, 2, 3, 4, 5], dtype=dt)
+        a_dp = dpnp.array(a)
+
+        expected = numpy.delete(a, obj)
+        result = dpnp.delete(a_dp, obj)
+        assert result.dtype == dt
+        assert_array_equal(result, expected)
+
+    @pytest.mark.parametrize("start", [-6, -2, 0, 1, 2, 4, 5])
+    @pytest.mark.parametrize("stop", [-6, -2, 0, 1, 2, 4, 5])
+    @pytest.mark.parametrize("step", [-3, -1, 1, 3])
+    def test_slice_1D(self, start, stop, step):
+        indices = slice(start, stop, step)
+        # 1D array
         a = numpy.arange(5)
-        b = numpy.arange(10).reshape(1, 5, 2)
         a_dp = dpnp.array(a)
-        b_dp = dpnp.array(b)
+        expected = numpy.delete(a, indices)
+        result = dpnp.delete(a_dp, indices)
+        assert_array_equal(result, expected)
+
+        # N-D array
+        a = numpy.arange(10).reshape(1, 5, 2)
+        a_dp = dpnp.array(a)
+        for axis in [None, 1, -1]:
+            expected = numpy.delete(a, indices, axis=axis)
+            result = dpnp.delete(a_dp, indices, axis=axis)
+            assert_array_equal(result, expected)
 
-        expected1 = numpy.delete(a, indices)
-        expected2 = numpy.delete(b, indices, axis=1)
-        result1 = dpnp.delete(a_dp, indices)
-        result2 = dpnp.delete(b_dp, indices, axis=1)
-        assert_array_equal(result1, expected1)
-        assert_array_equal(result2, expected2)
-
-    def test_slices(self):
-        lims = [-6, -2, 0, 1, 2, 4, 5]
-        steps = [-3, -1, 1, 3]
-        for start in lims:
-            for stop in lims:
-                for step in steps:
-                    s = slice(start, stop, step)
-                    self._check_inverse_of_slicing(s)
-
-    def test_obj(self):
-        self._check_inverse_of_slicing([0, -1, 2, 2])
-        self._check_inverse_of_slicing([True, False, False, True, False])
-        self._check_inverse_of_slicing(0)
-        self._check_inverse_of_slicing(-4)
-        self._check_inverse_of_slicing([])
+    @pytest.mark.parametrize(
+        "indices", [0, -4, [], [0, -1, 2, 2], [True, False, False, True, False]]
+    )
+    def test_indices_1D(self, indices):
+        # 1D array
+        a = numpy.arange(5)
+        a_dp = dpnp.array(a)
+        expected = numpy.delete(a, indices)
+        result = dpnp.delete(a_dp, indices)
+        assert_array_equal(result, expected)
+
+        # N-D array
+        a = numpy.arange(10).reshape(1, 5, 2)
+        a_dp = dpnp.array(a)
+        expected = numpy.delete(a, indices, axis=1)
+        result = dpnp.delete(a_dp, indices, axis=1)
+        assert_array_equal(result, expected)
 
     def test_obj_ndarray(self):
         # 1D array
@@ -413,8 +435,9 @@ def test_error(self):
         with pytest.raises(IndexError):
             dpnp.delete(a, dpnp.array([], dtype=float))
 
-    def test_order(self):
-        a = numpy.arange(10).reshape(2, 5, order="F")
+    @pytest.mark.parametrize("order", ["C", "F"])
+    def test_order(self, order):
+        a = numpy.arange(10).reshape(2, 5, order=order)
         a_dp = dpnp.array(a)
 
         expected = numpy.delete(a, slice(3, None), axis=1)