fix issues

Author: vtavana

dpnp/tests/test_indexing.py

@@ -22,6 +22,8 @@
     get_all_dtypes,
     get_integer_dtypes,
     has_support_aspect64,
+    is_win_platform,
+    numpy_version,
 )
 from .third_party.cupy import testing
 
@@ -700,10 +702,12 @@ def test_1d(self, a_dt, ind_dt, indices, mode):
             assert_array_equal(result, expected)
         elif numpy.issubdtype(ind_dt, numpy.uint64):
             # For this special case, although casting `ind_dt` to numpy.intp
-            # is not safe, dpnp do not raise an error
-            # NumPy only raises an error on Windows
+            # is not safe, both NumPy and dpnp work properly
+            # NumPy < "2.2.0" raises an error on Windows
+            if numpy_version() < "2.2.0" and is_win_platform():
+                ind = ind.astype(numpy.int64)
             result = dpnp.take(ia, iind, mode=mode)
-            expected = numpy.take(a, ind.astype(numpy.int64), mode=mode)
+            expected = numpy.take(a, ind, mode=mode)
             assert_array_equal(result, expected)
         else:
             assert_raises(TypeError, ia.take, iind, mode=mode)

dpnp/tests/test_mathematical.py

@@ -67,7 +67,8 @@ def test_angle(self, dtype, deg):
         result = dpnp.angle(dp_a, deg=deg)
 
         # For dtype=int8, uint8, NumPy returns float16, but dpnp returns float32
-        assert_dtype_allclose(result, expected, check_only_type_kind=True)
+        dt_int8 = dtype in [dpnp.int8, dpnp.uint8]
+        assert_dtype_allclose(result, expected, check_only_type_kind=dt_int8)
 
     @pytest.mark.parametrize("dtype", get_complex_dtypes())
     def test_angle_complex(self, dtype, deg):
@@ -1352,8 +1353,7 @@ def test_1d(self, dt):
         expected = numpy.i0(a)
         # NumPy promotes result of integer inputs to float64, but dpnp
         # follows Type Promotion Rules
-        skip_dtype = [numpy.int8, numpy.int16, numpy.uint8, numpy.uint16]
-        flag = True if dt in skip_dtype else False
+        flag = dt in [numpy.int8, numpy.int16, numpy.uint8, numpy.uint16]
         assert_dtype_allclose(result, expected, check_only_type_kind=flag)
 
     @pytest.mark.parametrize("dt", get_float_dtypes())
@@ -2034,7 +2034,8 @@ def test_basic(self, dt):
         expected = numpy.sinc(a)
         # numpy promotes result for integer inputs to float64 dtype, but dpnp
         # follows Type Promotion Rules similar to other trigonometric functions
-        assert_dtype_allclose(result, expected, check_only_type_kind=True)
+        flag = dt in [numpy.int8, numpy.int16, numpy.uint8, numpy.uint16]
+        assert_dtype_allclose(result, expected, check_only_type_kind=flag)
 
     def test_bool(self):
         a = numpy.array([True, False, True])
@@ -2054,7 +2055,8 @@ def test_zero(self, dt):
         expected = numpy.sinc(a)
         # numpy promotes result for integer inputs to float64 dtype, but dpnp
         # follows Type Promotion Rules similar to other trigonometric functions
-        assert_dtype_allclose(result, expected, check_only_type_kind=True)
+        flag = dt in [numpy.int8, numpy.int16, numpy.uint8, numpy.uint16]
+        assert_dtype_allclose(result, expected, check_only_type_kind=flag)
 
     # TODO: add a proper NumPy version once resolved
     @testing.with_requires("numpy>=2.0.0")
@@ -2499,7 +2501,7 @@ def test_divide_scalar(shape, dtype):
 )
 def test_negative(data, dtype):
     np_a = numpy.array(data, dtype=dtype)
-    dpnp_a = dpnp.array(data, dtype=dtype)
+    dpnp_a = dpnp.array(np_a)
 
     result = dpnp.negative(dpnp_a)
     expected = numpy.negative(np_a)
@@ -2529,12 +2531,10 @@ def test_negative_boolean():
     [[[1.0, -1.0], [0.1, -0.1]], [-2, -1, 0, 1, 2]],
     ids=["[[1., -1.], [0.1, -0.1]]", "[-2, -1, 0, 1, 2]"],
 )
-@pytest.mark.parametrize(
-    "dtype", get_all_dtypes(no_bool=True, no_unsigned=True)
-)
+@pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
 def test_positive(data, dtype):
-    np_a = numpy.array(data, dtype=dtype)
-    dpnp_a = dpnp.array(data, dtype=dtype)
+    np_a = get_abs_array(data, dtype=dtype)
+    dpnp_a = dpnp.array(np_a)
 
     result = dpnp.positive(dpnp_a)
     expected = numpy.positive(np_a)

dpnp/tests/test_product.py

@@ -12,6 +12,8 @@
     generate_random_numpy_array,
     get_all_dtypes,
     get_complex_dtypes,
+    is_win_platform,
+    numpy_version,
 )
 from .third_party.cupy import testing
 
@@ -508,8 +510,9 @@ def test_scalar(self, dtype):
 
         result = dpnp.kron(ib, a)
         expected = numpy.kron(b, a)
-        # NumPy returns incorrect dtype on Windows, add check_type=False
-        assert_dtype_allclose(result, expected, check_type=False)
+        # NumPy returns incorrect dtype on Windows
+        flag = not is_win_platform() if numpy_version() < "2.0.0" else True
+        assert_dtype_allclose(result, expected, check_type=flag)
 
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     @pytest.mark.parametrize(

dpnp/tests/test_strides.py

@@ -163,13 +163,8 @@ def test_logsumexp(dtype):
     expected = numpy.logaddexp.reduce(a)
     # for int8, uint8, NumPy returns float16 but dpnp returns float64
     # for int16, uint16, NumPy returns float32 but dpnp returns float64
-    if dtype in [dpnp.int8, dpnp.uint8, dpnp.int16, dpnp.uint16]:
-        check_only_type_kind = True
-    else:
-        check_only_type_kind = False
-    assert_dtype_allclose(
-        result, expected, check_only_type_kind=check_only_type_kind
-    )
+    flag = dtype in [dpnp.int8, dpnp.uint8, dpnp.int16, dpnp.uint16]
+    assert_dtype_allclose(result, expected, check_only_type_kind=flag)
 
 
 @pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True, no_complex=True))
@@ -181,13 +176,8 @@ def test_cumlogsumexp(dtype):
     expected = numpy.logaddexp.accumulate(a)
     # for int8, uint8, NumPy returns float16 but dpnp returns float64
     # for int16, uint16, NumPy returns float32 but dpnp returns float64
-    if dtype in [dpnp.int8, dpnp.uint8, dpnp.int16, dpnp.uint16]:
-        check_only_type_kind = True
-    else:
-        check_only_type_kind = False
-    assert_dtype_allclose(
-        result, expected, check_only_type_kind=check_only_type_kind
-    )
+    flag = dtype in [dpnp.int8, dpnp.uint8, dpnp.int16, dpnp.uint16]
+    assert_dtype_allclose(result, expected, check_only_type_kind=flag)
 
 
 @pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True, no_complex=True))
@@ -199,13 +189,8 @@ def test_reduce_hypot(dtype):
     expected = numpy.hypot.reduce(a)
     # for int8, uint8, NumPy returns float16 but dpnp returns float64
     # for int16, uint16, NumPy returns float32 but dpnp returns float64
-    if dtype in [dpnp.int8, dpnp.uint8, dpnp.int16, dpnp.uint16]:
-        check_only_type_kind = True
-    else:
-        check_only_type_kind = False
-    assert_dtype_allclose(
-        result, expected, check_only_type_kind=check_only_type_kind
-    )
+    flag = dtype in [dpnp.int8, dpnp.uint8, dpnp.int16, dpnp.uint16]
+    assert_dtype_allclose(result, expected, check_only_type_kind=flag)
 
 
 @pytest.mark.parametrize(

dpnp/tests/test_sum.py

@@ -51,12 +51,15 @@ def test_sum(shape, dtype_in, dtype_out, transpose, keepdims, order):
     axes.append(tuple(axes_range))
 
     for axis in axes:
-        if numpy.issubdtype(dtype_out, numpy.bool_):
+        if (
+            numpy.issubdtype(dtype_out, numpy.bool_)
+            and numpy.issubdtype(dtype_in, numpy.signedinteger)
+            and not a_np.sum(axis=axis).all()
+        ):
             # If summation is zero and dtype=numpy.bool is passed to numpy.sum
             # NumPy returns True which is not correct
-            numpy_res = a_np.sum(axis=axis, keepdims=keepdims).astype(
-                numpy.bool_
-            )
+            numpy_res = a_np.sum(axis=axis, keepdims=keepdims)
+            numpy_res = numpy_res.astype(numpy.bool_)
         else:
             numpy_res = a_np.sum(axis=axis, dtype=dtype_out, keepdims=keepdims)
         dpnp_res = a.sum(axis=axis, dtype=dtype_out, keepdims=keepdims)