Update tests to cover new behavior

Author: antonwolfy

dpnp/tests/test_mathematical.py

@@ -1480,37 +1480,34 @@ def test_boolean_array(self):
         expected = numpy.nan_to_num(a)
         assert_allclose(result, expected)
 
-    def test_errors(self):
-        ia = dpnp.array([0, 1, dpnp.nan, dpnp.inf, -dpnp.inf])
-
-        # unsupported type `a`
-        a = dpnp.asnumpy(ia)
-        assert_raises(TypeError, dpnp.nan_to_num, a)
-
-        # unsupported type `nan`
-        i_nan = dpnp.array(1)
-        assert_raises(TypeError, dpnp.nan_to_num, ia, nan=i_nan)
+    @pytest.mark.parametrize("kw_name", ["nan", "posinf", "neginf"])
+    @pytest.mark.parametrize("val", [[1, 2, -1, -2, 7], (7,), numpy.array(1)])
+    def test_nan_infs_array_like(self, kw_name, val):
+        a = numpy.array([0, 1, dpnp.nan, dpnp.inf, -dpnp.inf])
+        ia = dpnp.array(a)
 
-        # unsupported type `posinf`
-        i_posinf = dpnp.array(1)
-        assert_raises(TypeError, dpnp.nan_to_num, ia, posinf=i_posinf)
+        result = dpnp.nan_to_num(ia, **{kw_name: val})
+        expected = numpy.nan_to_num(a, **{kw_name: val})
+        assert_allclose(result, expected)
 
-        # unsupported type `neginf`
-        i_neginf = dpnp.array(1)
-        assert_raises(TypeError, dpnp.nan_to_num, ia, neginf=i_neginf)
+    @pytest.mark.parametrize("xp", [dpnp, numpy])
+    @pytest.mark.parametrize("kw_name", ["nan", "posinf", "neginf"])
+    def test_nan_infs_complex_dtype(self, xp, kw_name):
+        ia = xp.array([0, 1, xp.nan, xp.inf, -xp.inf])
+        with pytest.raises((TypeError, ValueError), match="complex.*type"):
+            xp.nan_to_num(ia, **{kw_name: 1j})
 
-    @pytest.mark.parametrize("kwarg", ["nan", "posinf", "neginf"])
-    @pytest.mark.parametrize("value", [1 - 0j, [1, 2], (1,)])
-    def test_errors_diff_types(self, kwarg, value):
-        ia = dpnp.array([0, 1, dpnp.nan, dpnp.inf, -dpnp.inf])
-        with pytest.raises(TypeError):
-            dpnp.nan_to_num(ia, **{kwarg: value})
+    def test_numpy_input_array(self):
+        a = numpy.array([0, 1, dpnp.nan, dpnp.inf, -dpnp.inf])
+        with pytest.raises(TypeError, match="must be any of supported type"):
+            dpnp.nan_to_num(a)
 
-    def test_error_readonly(self):
-        a = dpnp.array([0, 1, dpnp.nan, dpnp.inf, -dpnp.inf])
-        a.flags.writable = False
-        with pytest.raises(ValueError):
-            dpnp.nan_to_num(a, copy=False)
+    @pytest.mark.parametrize("xp", [dpnp, numpy])
+    def test_error_readonly(self, xp):
+        a = xp.array([0, 1, xp.nan, xp.inf, -xp.inf])
+        a.flags["W"] = False
+        with pytest.raises(ValueError, match="read-only"):
+            xp.nan_to_num(a, copy=False)
 
     @pytest.mark.parametrize("copy", [True, False])
     @pytest.mark.parametrize("dt", get_all_dtypes(no_bool=True, no_none=True))
@@ -1522,9 +1519,9 @@ def test_strided(self, copy, dt):
         if dt.kind in "fc":
             a[::4] = numpy.nan
             ia[::4] = dpnp.nan
+
         result = dpnp.nan_to_num(ia[::-2], copy=copy, nan=57.0)
         expected = numpy.nan_to_num(a[::-2], copy=copy, nan=57.0)
-
         assert_dtype_allclose(result, expected)
 
 

dpnp/tests/third_party/cupy/math_tests/test_misc.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import numpy
 import pytest
 
 import dpnp as cupy
-from dpnp.tests.helper import has_support_aspect64
+from dpnp.tests.helper import has_support_aspect64, numpy_version
 from dpnp.tests.third_party.cupy import testing
 
 
@@ -155,10 +157,7 @@ def test_external_clip4(self, dtype):
             # (min or max) as a keyword argument according to Python Array API.
             # In older versions of numpy, both arguments must be positional;
             # passing only one raises a TypeError.
-            if (
-                xp is numpy
-                and numpy.lib.NumpyVersion(numpy.__version__) < "2.1.0"
-            ):
+            if xp is numpy and numpy_version() < "2.1.0":
                 with pytest.raises(TypeError):
                     xp.clip(a, 3)
             else:
@@ -257,9 +256,10 @@ def test_nan_to_num_inf(self):
     def test_nan_to_num_nan(self):
         self.check_unary_nan("nan_to_num")
 
-    @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
+    @pytest.mark.skip("no scalar support")
+    @testing.numpy_cupy_allclose(atol=1e-5)
     def test_nan_to_num_scalar_nan(self, xp):
-        return xp.nan_to_num(xp.array(xp.nan))
+        return xp.nan_to_num(xp.nan)
 
     @pytest.mark.filterwarnings("ignore::RuntimeWarning")
     def test_nan_to_num_inf_nan(self):
@@ -286,14 +286,44 @@ def test_nan_to_num_inplace(self, xp):
         return y
 
     @pytest.mark.parametrize("kwarg", ["nan", "posinf", "neginf"])
-    def test_nan_to_num_broadcast(self, kwarg):
+    @testing.numpy_cupy_array_equal()
+    def test_nan_to_num_broadcast_same_shapes(self, xp, kwarg):
+        x = xp.asarray(
+            [[0, 1, xp.nan, 4], [11, xp.inf, 12, 13]],
+            dtype=cupy.default_float_type(),
+        )
+        y = xp.zeros((2, 4), dtype=x.dtype)
+        return xp.nan_to_num(x, **{kwarg: y})
+
+    @pytest.mark.parametrize("kwarg", ["nan", "posinf", "neginf"])
+    @testing.numpy_cupy_array_equal()
+    def test_nan_to_num_broadcast_different_columns(self, xp, kwarg):
+        x = xp.asarray(
+            [[0, 1, xp.nan, 4], [11, xp.inf, 12, 13]],
+            dtype=cupy.default_float_type(),
+        )
+        y = xp.zeros((2, 1), dtype=x.dtype)
+        return xp.nan_to_num(x, **{kwarg: y})
+
+    @pytest.mark.parametrize("kwarg", ["nan", "posinf", "neginf"])
+    @testing.numpy_cupy_array_equal()
+    def test_nan_to_num_broadcast_different_rows(self, xp, kwarg):
+        x = xp.asarray(
+            [[0, 1, xp.nan, 4], [11, -xp.inf, 12, 13]],
+            dtype=cupy.default_float_type(),
+        )
+        y = xp.zeros((1, 4), dtype=x.dtype)
+        return xp.nan_to_num(x, **{kwarg: y})
+
+    @pytest.mark.parametrize("kwarg", ["nan", "posinf", "neginf"])
+    def test_nan_to_num_broadcast_invalid_shapes(self, kwarg):
         for xp in (numpy, cupy):
             x = xp.asarray([0, 1, xp.nan, 4], dtype=cupy.default_float_type())
-            y = xp.zeros((2, 4), dtype=cupy.default_float_type())
-            with pytest.raises((ValueError, TypeError)):
+            y = xp.zeros((2, 4), dtype=x.dtype)
+            with pytest.raises(ValueError):
                 xp.nan_to_num(x, **{kwarg: y})
-            with pytest.raises((ValueError, TypeError)):
-                xp.nan_to_num(0.0, **{kwarg: y})
+            with pytest.raises(ValueError):
+                xp.nan_to_num(xp.array(0.0), **{kwarg: y})
 
     @testing.for_all_dtypes(no_bool=True, no_complex=True)
     @testing.numpy_cupy_array_equal()