add new tests

Author: Vahid Tavanashad

dpnp/dpnp_algo/dpnp_elementwise_common.py

@@ -513,7 +513,7 @@ def __call__(self, x, deg=False, out=None, order="K"):
 
 
 class DPNPFix(DPNPUnaryFunc):
-    """Class that implements dpnp.real unary element-wise functions."""
+    """Class that implements dpnp.fix unary element-wise functions."""
 
     def __init__(
         self,
@@ -534,14 +534,16 @@ def __call__(self, x, out=None, order="K"):
             pass  # pass to raise error in main implementation
         elif dpnp.issubdtype(x.dtype, dpnp.inexact):
             pass  # for inexact types, pass to calculate in the backend
-        elif out is not None and (
-            not dpnp.is_supported_array_type(out) or out.dtype != x.dtype
-        ):
+        elif out is not None and not dpnp.is_supported_array_type(out):
             pass  # pass to raise error in main implementation
+        elif out is not None and out.dtype != x.dtype:
+            raise ValueError(
+                f"Output array of type {x.dtype} is needed, got {out.dtype}"
+            )
         else:
             # for exact types, return the input
             if out is None:
-                return dpnp.asarray(x, copy=True)
+                return dpnp.copy(x, order=order)
 
             if isinstance(out, dpt.usm_ndarray):
                 out = dpnp_array._create_from_usm_ndarray(out)

dpnp/tests/test_mathematical.py

@@ -2227,19 +2227,37 @@ def test_complex(self, func, xp, dt):
 
     @testing.with_requires("numpy>=2.1.0")
     @pytest.mark.parametrize(
-        "dt", get_all_dtypes(no_none=True, no_complex=True)
+        "dt_in", get_all_dtypes(no_none=True, no_complex=True)
     )
-    def test_out(self, func, dt):
-        a = generate_random_numpy_array(10, dt)
-        # TODO: use dt_out = dt when dpctl#2030 is fixed
-        dt_out = numpy.int8 if dt == dpnp.bool else dt
+    @pytest.mark.parametrize(
+        "dt_out", get_all_dtypes(no_none=True, no_complex=True)
+    )
+    def test_out(self, func, dt_in, dt_out):
+        a = generate_random_numpy_array(10, dt_in)
         out = numpy.empty(a.shape, dtype=dt_out)
         ia, iout = dpnp.array(a), dpnp.array(out)
 
-        expected = getattr(numpy, func)(a, out=out)
-        result = getattr(dpnp, func)(ia, out=iout)
-        assert result is iout
-        assert_array_equal(result, expected)
+        if dt_in != dt_out:
+            if numpy.can_cast(dt_in, dt_out, casting="same_kind"):
+                # NumPy allows "same_kind" casting, dpnp does not
+                if func != "fix" and dt_in == dpnp.bool and dt_out == dpnp.int8:
+                    # TODO: get rid of w/a when dpctl#2030 is fixed
+                    pass
+                else:
+                    assert_raises(ValueError, getattr(dpnp, func), ia, out=iout)
+            else:
+                assert_raises(ValueError, getattr(dpnp, func), ia, out=iout)
+                assert_raises(TypeError, getattr(numpy, func), a, out=out)
+        else:
+            if func != "fix" and dt_in == dpnp.bool:
+                # TODO: get rid of w/a when dpctl#2030 is fixed
+                out = out.astype(numpy.int8)
+                iout = iout.astype(dpnp.int8)
+
+            expected = getattr(numpy, func)(a, out=out)
+            result = getattr(dpnp, func)(ia, out=iout)
+            assert result is iout
+            assert_array_equal(result, expected)
 
     @pytest.mark.skipif(not has_support_aspect16(), reason="no fp16 support")
     def test_out_float16(self, func):
@@ -2252,22 +2270,22 @@ def test_out_float16(self, func):
         assert result is iout
         assert_array_equal(result, expected)
 
-    @pytest.mark.parametrize("xp", [numpy, dpnp])
     @pytest.mark.parametrize(
-        "dt_out", get_all_dtypes(no_none=True, no_complex=True)[:-1]
+        "dt", get_all_dtypes(no_none=True, no_complex=True)
     )
-    def test_invalid_dtype(self, func, xp, dt_out):
-        dt_in = get_all_dtypes(no_none=True, no_complex=True)[-1]
-        a = xp.arange(10, dtype=dt_in)
-        out = xp.empty(10, dtype=dt_out)
-        if dt_out == numpy.float32 and dt_in == numpy.float64:
-            if xp == dpnp:
-                # NumPy allows "same_kind" casting, dpnp does not
-                assert_raises(ValueError, getattr(dpnp, func), a, out=out)
-        else:
-            assert_raises(
-                (ValueError, TypeError), getattr(xp, func), a, out=out
-            )
+    def test_out_usm_ndarray(self, func, dt):
+        a = generate_random_numpy_array(10, dt)
+        out = numpy.empty(a.shape, dtype=dt)
+        ia, usm_out = dpnp.array(a), dpt.asarray(out)
+
+        if func != "fix" and dt == dpnp.bool:
+            # TODO: get rid of w/a when dpctl#2030 is fixed
+            out = out.astype(numpy.int8)
+            usm_out = dpt.asarray(usm_out, dtype=dpnp.int8)
+
+        expected = getattr(numpy, func)(a, out=out)
+        result = getattr(dpnp, func)(ia, out=usm_out)
+        assert_array_equal(result, expected)
 
     @pytest.mark.parametrize("xp", [numpy, dpnp])
     @pytest.mark.parametrize(
@@ -2278,9 +2296,15 @@ def test_invalid_shape(self, func, xp, shape):
         out = xp.empty(shape, dtype=xp.float32)
         assert_raises(ValueError, getattr(xp, func), a, out=out)
 
-    def test_scalar(self, func):
+    def test_error(self, func):
+        # scalar, unsupported input
         assert_raises(TypeError, getattr(dpnp, func), -3.4)
 
+        # unsupported out
+        a = dpnp.array([1, 2, 3])
+        out = numpy.empty_like(3, dtype=a.dtype)
+        assert_raises(TypeError, getattr(dpnp, func), a, out=out)
+
 
 class TestHypot:
     @pytest.mark.parametrize(