improve test coverage

Author: vtavana

dpnp/dpnp_iface_trigonometric.py

@@ -1305,7 +1305,7 @@ def logaddexp(
     Parameters `where`, `dtype` and `subok` are supported with their default values.
     Keyword arguments `kwargs` are currently unsupported.
     Otherwise the function will be executed sequentially on CPU.
-    Input array data types are limited by supported DPNP :ref:`Data types`.
+    Input array data types are limited by real-valued data types.
 
     See Also
     --------

tests/test_absolute.py

@@ -1,10 +1,15 @@
 import numpy
 import pytest
-from numpy.testing import assert_array_equal, assert_equal
+from numpy.testing import assert_equal
 
 import dpnp
 
-from .helper import get_all_dtypes, get_complex_dtypes, get_float_complex_dtypes
+from .helper import (
+    assert_dtype_allclose,
+    get_all_dtypes,
+    get_complex_dtypes,
+    get_float_complex_dtypes,
+)
 
 
 @pytest.mark.parametrize("func", ["abs", "absolute"])
@@ -15,8 +20,13 @@ def test_abs(func, dtype):
 
     result = getattr(dpnp, func)(ia)
     expected = getattr(numpy, func)(a)
-    assert_array_equal(expected, result)
-    assert_equal(result.dtype, expected.dtype)
+    assert_dtype_allclose(result, expected)
+
+    # out keyword
+    dp_out = dpnp.empty(expected.shape, dtype=expected.dtype)
+    result = getattr(dpnp, func)(ia, out=dp_out)
+    assert result is dp_out
+    assert_dtype_allclose(result, expected)
 
 
 @pytest.mark.parametrize("stride", [-4, -2, -1, 1, 2, 4])

tests/test_bitwise.py

@@ -4,6 +4,8 @@
 
 import dpnp as inp
 
+from .helper import assert_dtype_allclose, get_integer_dtypes
+
 
 @pytest.mark.parametrize(
     "lhs",
@@ -134,3 +136,15 @@ def test_right_shift(self, lhs, rhs, dtype):
             dp_a >>= dp_b
             np_a >>= np_b
             assert_array_equal(dp_a, np_a)
+
+
+@pytest.mark.parametrize("dtype", get_integer_dtypes())
+def test_invert_out(dtype):
+    np_a = numpy.arange(-5, 5, dtype=dtype)
+    dp_a = inp.array(np_a)
+
+    expected = numpy.invert(np_a)
+    dp_out = inp.empty(expected.shape, dtype=expected.dtype)
+    result = inp.invert(dp_a, out=dp_out)
+    assert result is dp_out
+    assert_dtype_allclose(result, expected)

tests/test_logic.py

@@ -250,6 +250,11 @@ def test_logical_not(dtype):
     dpnp_res = dpnp.logical_not(a)
     assert_equal(dpnp_res, np_res)
 
+    dp_out = dpnp.empty(np_res.shape, dtype=dpnp.bool)
+    dpnp_res = dpnp.logical_not(a, out=dp_out)
+    assert dpnp_res is dp_out
+    assert_equal(dpnp_res, np_res)
+
 
 @pytest.mark.parametrize(
     "op",
@@ -316,6 +321,13 @@ def test_elemwise_comparison(op, x1, x2, dtype):
     dpnp_res = getattr(dpnp, op)(dp_x1[::-1], dp_x2)
     assert_equal(dpnp_res, np_res)
 
+    # out keyword
+    np_res = getattr(numpy, op)(np_x1, np_x2)
+    dp_out = dpnp.empty(np_res.shape, dtype=dpnp.bool)
+    dpnp_res = getattr(dpnp, op)(dp_x1, dp_x2, out=dp_out)
+    assert dp_out is dpnp_res
+    assert_equal(dpnp_res, np_res)
+
 
 @pytest.mark.parametrize(
     "op",
@@ -374,6 +386,11 @@ def test_comparison_no_broadcast_with_shapes(op, sh1, sh2):
 @pytest.mark.parametrize("dtype", get_float_complex_dtypes())
 def test_finite(op, data, dtype):
     x = dpnp.asarray(data, dtype=dtype)
-    np_res = getattr(dpnp, op)(x)
-    dpnp_res = getattr(numpy, op)(x.asnumpy())
+    np_res = getattr(numpy, op)(x.asnumpy())
+    dpnp_res = getattr(dpnp, op)(x)
+    assert_equal(dpnp_res, np_res)
+
+    dp_out = dpnp.empty(np_res.shape, dtype=dpnp.bool)
+    dpnp_res = getattr(dpnp, op)(x, out=dp_out)
+    assert dp_out is dpnp_res
     assert_equal(dpnp_res, np_res)

tests/test_mathematical.py

@@ -660,6 +660,17 @@ def test_negative(data, dtype):
     expected = numpy.negative(np_a)
     assert_allclose(result, expected)
 
+    result = -dpnp_a
+    expected = -np_a
+    assert_allclose(result, expected)
+
+    # out keyword
+    if dtype is not None:
+        dp_out = dpnp.empty(expected.shape, dtype=dtype)
+        result = dpnp.negative(dpnp_a, out=dp_out)
+        assert result is dp_out
+        assert_allclose(result, expected)
+
 
 def test_negative_boolean():
     dpnp_a = dpnp.array([True, False])
@@ -686,6 +697,13 @@ def test_positive(data, dtype):
     expected = +np_a
     assert_allclose(result, expected)
 
+    # out keyword
+    if dtype is not None:
+        dp_out = dpnp.empty(expected.shape, dtype=dtype)
+        result = dpnp.positive(dpnp_a, out=dp_out)
+        assert result is dp_out
+        assert_allclose(result, expected)
+
 
 def test_positive_boolean():
     dpnp_a = dpnp.array([True, False])
@@ -811,7 +829,14 @@ def test_sign(data, dtype):
 
     result = dpnp.sign(dpnp_a)
     expected = numpy.sign(np_a)
-    assert_allclose(result, expected)
+    assert_dtype_allclose(result, expected)
+
+    # out keyword
+    if dtype is not None:
+        dp_out = dpnp.empty(expected.shape, dtype=expected.dtype)
+        result = dpnp.sign(dpnp_a, out=dp_out)
+        assert dp_out is result
+        assert_dtype_allclose(result, expected)
 
 
 def test_sign_boolean():
@@ -833,9 +858,20 @@ def test_signbit(data, dtype):
 
     result = dpnp.signbit(dpnp_a)
     expected = numpy.signbit(np_a)
-    assert_allclose(result, expected)
+    assert_dtype_allclose(result, expected)
+
+    # out keyword
+    dp_out = dpnp.empty(expected.shape, dtype=expected.dtype)
+    result = dpnp.signbit(dpnp_a, out=dp_out)
+    assert dp_out is result
+    assert_dtype_allclose(result, expected)
 
 
+@pytest.mark.parametrize(
+    "func",
+    ["real", "imag", "conj"],
+    ids=["real", "imag", "conj"],
+)
 @pytest.mark.parametrize(
     "data",
     [complex(-1, -4), complex(-1, 2), complex(3, -7), complex(4, 12)],
@@ -847,17 +883,20 @@ def test_signbit(data, dtype):
     ],
 )
 @pytest.mark.parametrize("dtype", get_complex_dtypes())
-def test_real_imag(data, dtype):
+def test_complex_funcs(func, data, dtype):
     np_a = numpy.array(data, dtype=dtype)
     dpnp_a = dpnp.array(data, dtype=dtype)
 
-    result = dpnp.real(dpnp_a)
-    expected = numpy.real(np_a)
-    assert_allclose(result, expected)
+    result = getattr(dpnp, func)(dpnp_a)
+    expected = getattr(numpy, func)(np_a)
+    assert_dtype_allclose(result, expected)
 
-    result = dpnp.imag(dpnp_a)
-    expected = numpy.imag(np_a)
-    assert_allclose(result, expected)
+    # out keyword
+    if func == "conj":
+        dp_out = dpnp.empty(expected.shape, dtype=expected.dtype)
+        result = getattr(dpnp, func)(dpnp_a, out=dp_out)
+        assert dp_out is result
+        assert_dtype_allclose(result, expected)
 
 
 @pytest.mark.parametrize("dtype", get_complex_dtypes())
@@ -875,9 +914,16 @@ def test_projection_infinity(dtype):
         complex(dpnp.inf, 0.0),
     ]
 
-    result = dpnp.proj(dpnp.array(X, dtype=dtype))
+    a = dpnp.array(X, dtype=dtype)
+    result = dpnp.proj(a)
     expected = dpnp.array(Y, dtype=dtype)
-    assert_allclose(result, expected)
+    assert_dtype_allclose(result, expected)
+
+    # out keyword
+    dp_out = dpnp.empty(expected.shape, dtype=expected.dtype)
+    result = dpnp.proj(a, out=dp_out)
+    assert dp_out is result
+    assert_dtype_allclose(result, expected)
 
 
 @pytest.mark.parametrize("dtype", get_all_dtypes())