add new tests to improve coverage

Author: Vahid Tavanashad

dpctl/tensor/_elementwise_common.py

@@ -93,8 +93,8 @@ def __call__(self, x, out=None, order="K"):
             else:
                 if res_dt != out.dtype:
                     raise TypeError(
-                        f"Expected output array of type {res_dt} is supported"
-                        f", got {out.dtype}"
+                        f"Output array of type {res_dt} is needed,"
+                        f" got {out.dtype}"
                     )
 
             ht, _ = self.unary_fn_(x, out, sycl_queue=exec_q)
@@ -119,8 +119,7 @@ def __call__(self, x, out=None, order="K"):
         else:
             if buf_dt != out.dtype:
                 raise TypeError(
-                    f"Expected output array of type {buf_dt} is supported,"
-                    f"got {out.dtype}"
+                    f"Output array of type {buf_dt} is needed, got {out.dtype}"
                 )
 
         ht, _ = self.unary_fn_(buf, out, sycl_queue=exec_q, depends=[copy_ev])

dpctl/tests/elementwise/test_abs.py

@@ -22,9 +22,17 @@ def test_abs_out_type(dtype):
             np.dtype("c16"): np.dtype("f8"),
         }
         assert dpt.abs(X).dtype == type_map[arg_dt]
+
+        out = dpt.empty_like(X, dtype=type_map[arg_dt])
+        dpt.abs(X, out)
+        assert np.allclose(dpt.asnumpy(out), dpt.asnumpy(dpt.abs(X)))
     else:
         assert dpt.abs(X).dtype == arg_dt
 
+        out = dpt.empty_like(X, dtype=arg_dt)
+        dpt.abs(X, out)
+        assert np.allclose(dpt.asnumpy(out), dpt.asnumpy(dpt.abs(X)))
+
 
 @pytest.mark.parametrize("usm_type", _usm_types)
 def test_abs_usm_type(usm_type):
@@ -89,20 +97,3 @@ def test_abs_complex(dtype):
             np.testing.assert_allclose(
                 dpt.asnumpy(Y), expected_Y, atol=tol, rtol=tol
             )
-
-
-@pytest.mark.parametrize("dtype", _all_dtypes[:-2])
-def test_abs_out_keyword(dtype):
-    q = get_queue_or_skip()
-    skip_if_dtype_not_supported(dtype, q)
-
-    arg_dt = np.dtype(dtype)
-    input_shape = (10, 10, 10, 10)
-    X = dpt.empty(input_shape, dtype=arg_dt, sycl_queue=q)
-    X[..., 0::2] = 1
-    X[..., 1::2] = 0
-    Y = dpt.empty_like(X, dtype=arg_dt)
-    dpt.abs(X, Y)
-
-    expected_Y = dpt.asnumpy(X)
-    assert np.allclose(dpt.asnumpy(Y), expected_Y)

dpctl/tests/elementwise/test_add.py

@@ -7,6 +7,7 @@
 import dpctl
 import dpctl.tensor as dpt
 from dpctl.tests.helper import get_queue_or_skip, skip_if_dtype_not_supported
+from dpctl.utils import ExecutionPlacementError
 
 from .utils import _all_dtypes, _compare_dtypes, _usm_types
 
@@ -32,6 +33,10 @@ def test_add_dtype_matrix(op1_dtype, op2_dtype):
     assert (dpt.asnumpy(r) == np.full(r.shape, 2, dtype=r.dtype)).all()
     assert r.sycl_queue == ar1.sycl_queue
 
+    out = dpt.empty_like(ar1, dtype=expected_dtype)
+    dpt.add(ar1, ar2, out)
+    assert (dpt.asnumpy(out) == np.full(out.shape, 2, dtype=out.dtype)).all()
+
     ar3 = dpt.ones(sz, dtype=op1_dtype)
     ar4 = dpt.ones(2 * sz, dtype=op2_dtype)
 
@@ -44,6 +49,10 @@ def test_add_dtype_matrix(op1_dtype, op2_dtype):
     assert r.shape == ar3.shape
     assert (dpt.asnumpy(r) == np.full(r.shape, 2, dtype=r.dtype)).all()
 
+    out = dpt.empty_like(ar1, dtype=expected_dtype)
+    dpt.add(ar3[::-1], ar4[::2], out)
+    assert (dpt.asnumpy(out) == np.full(out.shape, 2, dtype=out.dtype)).all()
+
 
 @pytest.mark.parametrize("op1_usm_type", _usm_types)
 @pytest.mark.parametrize("op2_usm_type", _usm_types)
@@ -105,7 +114,6 @@ def test_add_broadcasting():
     v = dpt.arange(5, dtype="i4")
 
     r = dpt.add(m, v)
-
     assert (dpt.asnumpy(r) == np.arange(1, 6, dtype="i4")[np.newaxis, :]).all()
 
     r2 = dpt.add(v, m)
@@ -180,26 +188,8 @@ def __sycl_usm_array_interface__(self):
         dpt.add(a, c)
 
 
-@pytest.mark.parametrize("op1_dtype", _all_dtypes)
-@pytest.mark.parametrize("op2_dtype", _all_dtypes)
-def test_add_dtype_out_keyword(op1_dtype, op2_dtype):
-    q = get_queue_or_skip()
-    skip_if_dtype_not_supported(op1_dtype, q)
-    skip_if_dtype_not_supported(op2_dtype, q)
-
-    sz = 127
-    ar1 = dpt.ones(sz, dtype=op1_dtype)
-    ar2 = dpt.ones_like(ar1, dtype=op2_dtype)
-
-    r = dpt.add(ar1, ar2)
-
-    y = dpt.zeros_like(ar1, dtype=r.dtype)
-    dpt.add(ar1, ar2, y)
-
-    assert np.array_equal(dpt.asnumpy(r), dpt.asnumpy(y))
-
-
 def test_add_errors():
+    get_queue_or_skip()
     try:
         gpu_queue = dpctl.SyclQueue("gpu")
     except dpctl.SyclQueueCreationError:
@@ -245,11 +235,14 @@ def test_add_errors():
         y,
     )
 
-    ar1 = dpt.ones(2, dtype="float32")
-    ar2 = dpt.ones_like(ar1, dtype="int32")
-    y = dpt.empty_like(ar1, dtype="int32")
+    ar1 = np.ones(2, dtype="float32")
+    ar2 = np.ones_like(ar1, dtype="int32")
     assert_raises_regex(
-        TypeError, "Output array of type.*is needed", dpt.add, ar1, ar2, y
+        ExecutionPlacementError,
+        "Execution placement can not be unambiguously inferred.*",
+        dpt.add,
+        ar1,
+        ar2,
     )
 
     ar1 = dpt.ones(2, dtype="float32")
@@ -263,3 +256,19 @@ def test_add_errors():
         ar2,
         y,
     )
+
+
+@pytest.mark.parametrize("dtype", _all_dtypes)
+def test_add_dtype_error(
+    dtype,
+):
+    q = get_queue_or_skip()
+    skip_if_dtype_not_supported(dtype, q)
+
+    ar1 = dpt.ones(5, dtype=dtype)
+    ar2 = dpt.ones_like(ar1, dtype="f8")
+
+    y = dpt.zeros_like(ar1, dtype="int8")
+    assert_raises_regex(
+        TypeError, "Output array of type.*is needed", dpt.add, ar1, ar2, y
+    )

dpctl/tests/elementwise/test_cos.py

@@ -21,6 +21,13 @@ def test_cos_out_type(dtype):
     expected_dtype = _map_to_device_dtype(expected_dtype, q.sycl_device)
     assert dpt.cos(X).dtype == expected_dtype
 
+    X = dpt.asarray(0, dtype=dtype, sycl_queue=q)
+    expected_dtype = np.cos(np.array(0, dtype=dtype)).dtype
+    expected_dtype = _map_to_device_dtype(expected_dtype, q.sycl_device)
+    Y = dpt.empty_like(X, dtype=expected_dtype)
+    dpt.cos(X, Y)
+    np.testing.assert_allclose(dpt.asnumpy(dpt.cos(X)), dpt.asnumpy(Y))
+
 
 @pytest.mark.parametrize("dtype", ["f2", "f4", "f8", "c8", "c16"])
 def test_cos_output(dtype):
@@ -40,6 +47,13 @@ def test_cos_output(dtype):
         dpt.asnumpy(Y), np.repeat(np.cos(Xnp), n_rep), atol=tol, rtol=tol
     )
 
+    Z = dpt.empty_like(X, dtype=dtype)
+    dpt.cos(X, Z)
+
+    np.testing.assert_allclose(
+        dpt.asnumpy(Z), np.repeat(np.cos(Xnp), n_rep), atol=tol, rtol=tol
+    )
+
 
 @pytest.mark.parametrize("usm_type", ["device", "shared", "host"])
 def test_cos_usm_type(usm_type):
@@ -89,27 +103,8 @@ def test_cos_order(dtype):
             )
 
 
-@pytest.mark.parametrize("dtype", ["f2", "f4", "f8", "c8", "c16"])
-def test_cos_out_keyword(dtype):
-    q = get_queue_or_skip()
-    skip_if_dtype_not_supported(dtype, q)
-
-    n_seq = 100
-    n_rep = 137
-
-    Xnp = np.linspace(-np.pi / 4, np.pi / 4, num=n_seq, dtype=dtype)
-    X = dpt.asarray(np.repeat(Xnp, n_rep), dtype=dtype, sycl_queue=q)
-    Y = dpt.empty_like(X, dtype=dtype)
-
-    dpt.cos(X, Y)
-    tol = 8 * dpt.finfo(Y.dtype).resolution
-
-    np.testing.assert_allclose(
-        dpt.asnumpy(Y), np.repeat(np.cos(Xnp), n_rep), atol=tol, rtol=tol
-    )
-
-
 def test_cos_errors():
+    get_queue_or_skip()
     try:
         gpu_queue = dpctl.SyclQueue("gpu")
     except dpctl.SyclQueueCreationError:
@@ -145,14 +140,20 @@ def test_cos_errors():
         TypeError, "Input and output arrays have memory overlap", dpt.cos, x, y
     )
 
-    x = dpt.zeros(2, dtype="int32")
-    y = dpt.empty_like(x, dtype="int32")
-    assert_raises_regex(
-        TypeError, "Expected output array of type.*is supported", dpt.cos, x, y
-    )
-
     x = dpt.zeros(2, dtype="float32")
     y = np.empty_like(x)
     assert_raises_regex(
         TypeError, "output array must be of usm_ndarray type", dpt.cos, x, y
     )
+
+
+@pytest.mark.parametrize("dtype", _all_dtypes)
+def test_cos_error_dtype(dtype):
+    q = get_queue_or_skip()
+    skip_if_dtype_not_supported(dtype, q)
+
+    x = dpt.zeros(5, dtype=dtype)
+    y = dpt.empty_like(x, dtype="int16")
+    assert_raises_regex(
+        TypeError, "Output array of type.*is needed", dpt.cos, x, y
+    )

dpctl/tests/elementwise/test_isfinite.py

@@ -41,6 +41,10 @@ def test_isfinite_complex(dtype):
     Y = dpt.asarray(Ynp, sycl_queue=q)
     assert np.array_equal(dpt.asnumpy(dpt.isfinite(Y)), np.isfinite(Ynp))
 
+    out = dpt.empty_like(Y, dtype="bool")
+    dpt.isfinite(Y, out)
+    assert np.array_equal(dpt.asnumpy(out)[()], np.isfinite(Ynp))
+
 
 @pytest.mark.parametrize("dtype", ["f2", "f4", "f8"])
 def test_isfinite_floats(dtype):
@@ -56,6 +60,10 @@ def test_isfinite_floats(dtype):
         Y = dpt.asarray(Ynp, sycl_queue=q)
         assert np.array_equal(dpt.asnumpy(dpt.isfinite(Y)), np.isfinite(Ynp))
 
+        out = dpt.empty_like(Y, dtype="bool")
+        dpt.isfinite(Y, out)
+        assert np.array_equal(dpt.asnumpy(out)[()], np.isfinite(Ynp))
+
 
 @pytest.mark.parametrize("dtype", _all_dtypes)
 def test_isfinite_order(dtype):
@@ -72,38 +80,3 @@ def test_isfinite_order(dtype):
             Y = dpt.isfinite(U, order=ord)
             expected_Y = np.full(Y.shape, True, dtype=Y.dtype)
             assert np.allclose(dpt.asnumpy(Y), expected_Y)
-
-
-@pytest.mark.parametrize("dtype", ["c8", "c16"])
-def test_isnan_complex_out_keyword(dtype):
-    q = get_queue_or_skip()
-    skip_if_dtype_not_supported(dtype, q)
-
-    y1 = complex(np.nan, np.nan)
-    y2 = complex(1, np.nan)
-    y3 = complex(np.nan, 1)
-    y4 = complex(2, 1)
-    y5 = complex(np.inf, 1)
-
-    Ynp = np.repeat(np.array([y1, y2, y3, y4, y5], dtype=dtype), 12)
-    Y = dpt.asarray(Ynp, sycl_queue=q)
-    out = dpt.empty_like(Y, dtype="bool")
-    dpt.isfinite(Y, out)
-    assert np.array_equal(dpt.asnumpy(out)[()], np.isfinite(Ynp))
-
-
-@pytest.mark.parametrize("dtype", ["f2", "f4", "f8"])
-def test_isfinite_floats_out_keyword(dtype):
-    q = get_queue_or_skip()
-    skip_if_dtype_not_supported(dtype, q)
-
-    y1 = np.nan
-    y2 = 1
-    y3 = np.inf
-
-    for mult in [123, 137, 255, 271, 272]:
-        Ynp = np.repeat(np.array([y1, y2, y3], dtype=dtype), mult)
-        Y = dpt.asarray(Ynp, sycl_queue=q)
-        out = dpt.empty_like(Y, dtype="bool")
-        dpt.isfinite(Y, out)
-        assert np.array_equal(dpt.asnumpy(out)[()], np.isfinite(Ynp))

dpctl/tests/elementwise/test_isnan.py

@@ -41,6 +41,10 @@ def test_isnan_complex(dtype):
     Y = dpt.asarray(Ynp, sycl_queue=q)
     assert np.array_equal(dpt.asnumpy(dpt.isnan(Y)), np.isnan(Ynp))
 
+    out = dpt.empty_like(Y, dtype="bool")
+    dpt.isnan(Y, out)
+    assert np.array_equal(dpt.asnumpy(out)[()], np.isnan(Ynp))
+
 
 @pytest.mark.parametrize("dtype", ["f2", "f4", "f8"])
 def test_isnan_floats(dtype):
@@ -56,6 +60,10 @@ def test_isnan_floats(dtype):
         Y = dpt.asarray(Ynp, sycl_queue=q)
         assert np.array_equal(dpt.asnumpy(dpt.isnan(Y)), np.isnan(Ynp))
 
+        out = dpt.empty_like(Y, dtype="bool")
+        dpt.isnan(Y, out)
+        assert np.array_equal(dpt.asnumpy(out)[()], np.isnan(Ynp))
+
 
 @pytest.mark.parametrize("dtype", _all_dtypes)
 def test_isnan_order(dtype):
@@ -72,38 +80,3 @@ def test_isnan_order(dtype):
             Y = dpt.isnan(U, order=ord)
             expected_Y = np.full(Y.shape, False, dtype=Y.dtype)
             assert np.allclose(dpt.asnumpy(Y), expected_Y)
-
-
-@pytest.mark.parametrize("dtype", ["c8", "c16"])
-def test_isnan_complex_out_keyword(dtype):
-    q = get_queue_or_skip()
-    skip_if_dtype_not_supported(dtype, q)
-
-    y1 = complex(np.nan, np.nan)
-    y2 = complex(1, np.nan)
-    y3 = complex(np.nan, 1)
-    y4 = complex(2, 1)
-    y5 = complex(np.inf, 1)
-
-    Ynp = np.repeat(np.array([y1, y2, y3, y4, y5], dtype=dtype), 123)
-    Y = dpt.asarray(Ynp, sycl_queue=q)
-    out = dpt.empty_like(Y, dtype="bool")
-    dpt.isnan(Y, out)
-    assert np.array_equal(dpt.asnumpy(out)[()], np.isnan(Ynp))
-
-
-@pytest.mark.parametrize("dtype", ["f2", "f4", "f8"])
-def test_isnan_floats_out_keyword(dtype):
-    q = get_queue_or_skip()
-    skip_if_dtype_not_supported(dtype, q)
-
-    y1 = np.nan
-    y2 = 1
-    y3 = np.inf
-
-    for mult in [123, 137, 255, 271, 272]:
-        Ynp = np.repeat(np.array([y1, y2, y3], dtype=dtype), mult)
-        Y = dpt.asarray(Ynp, sycl_queue=q)
-        out = dpt.empty_like(Y, dtype="bool")
-        dpt.isnan(Y, out)
-        assert np.array_equal(dpt.asnumpy(out)[()], np.isnan(Ynp))