Add more tests to improve tests coverage for DPNPBinaryTwoOutputsFunc class

Author: antonwolfy

dpnp/dpnp_algo/dpnp_elementwise_common.py

@@ -304,6 +304,30 @@ def nout(self):
         """Returns the number of arguments treated as outputs."""
         return 2
 
+    @property
+    def types(self):
+        """
+        Returns information about types supported by implementation function,
+        using NumPy's character encoding for data type.
+
+        Examples
+        --------
+        >>> import dpnp as np
+        >>> np.frexp.types
+        ['e->ei', 'f->fi', 'd->di']
+
+        """
+
+        types = self.types_
+        if not types:
+            types = []
+            for dt1 in dtu._all_data_types(True, True):
+                dt2 = self.result_type_resolver_fn_(dt1)
+                if all(dt for dt in dt2):
+                    types.append(f"{dt1.char}->{dt2[0].char}{dt2[1].char}")
+            self.types_ = types
+        return types
+
     def __call__(
         self,
         x,
@@ -852,6 +876,35 @@ def nout(self):
         """Returns the number of arguments treated as outputs."""
         return 2
 
+    @property
+    def types(self):
+        """
+        Returns information about types supported by implementation function,
+        using NumPy's character encoding for data types, e.g.
+
+        Examples
+        --------
+        >>> import dpnp as np
+        >>> np.divmod.types
+        ['bb->bb', 'BB->BB', 'hh->hh', 'HH->HH', 'ii->ii', 'II->II',
+         'll->ll', 'LL->LL', 'ee->ee', 'ff->ff', 'dd->dd']
+
+        """
+
+        types = self.types_
+        if not types:
+            types = []
+            _all_dtypes = dtu._all_data_types(True, True)
+            for dt1 in _all_dtypes:
+                for dt2 in _all_dtypes:
+                    dt3 = self.result_type_resolver_fn_(dt1, dt2)
+                    if all(dt for dt in dt3):
+                        types.append(
+                            f"{dt1.char}{dt2.char}->{dt3[0].char}{dt3[1].char}"
+                        )
+            self.types_ = types
+        return types
+
     def __call__(
         self,
         x1,
@@ -916,7 +969,9 @@ def __call__(
         sycl_dev = exec_q.sycl_device
         x1_dt = _get_dtype(x1, sycl_dev)
         x2_dt = _get_dtype(x2, sycl_dev)
-        if not all(_validate_dtype(dt) for dt in [x1_dt, x2_dt]):
+        if not all(
+            _validate_dtype(dt) for dt in [x1_dt, x2_dt]
+        ):  # pragma: no cover
             raise ValueError("Operands have unsupported data types")
 
         x1_dt, x2_dt = self.get_array_dtype_scalar_type_resolver_function()(
@@ -1001,7 +1056,6 @@ def __call__(
                     # Note if `dt` is not None, a temporary copy of `x` will be
                     # created, so the array overlap check isn't needed.
                     out[i] = dpt.empty_like(res)
-                    break
 
         x1 = dpnp.as_usm_ndarray(x1, dtype=x1_dt, sycl_queue=exec_q)
         x2 = dpnp.as_usm_ndarray(x2, dtype=x2_dt, sycl_queue=exec_q)

dpnp/tests/helper.py

@@ -188,7 +188,7 @@ def generate_random_numpy_array(
     numpy.random.seed(seed_value)
 
     if numpy.issubdtype(dtype, numpy.unsignedinteger):
-        low = 0
+        low = max(low, 0)
 
     # dtype=int is needed for 0d arrays
     size = numpy.prod(shape, dtype=int)

dpnp/tests/test_binary_two_outputs_ufuncs.py

@@ -217,6 +217,42 @@ def test_out1_overlap(self, func, dt):
         _ = getattr(numpy, func)(a[size::], 1, a[::2])
         assert_array_equal(ia, a)
 
+    def test_out_scalar_input(self, func):
+        a = generate_random_numpy_array((3, 7), low=1, dtype=int)
+        out = numpy.zeros_like(a)
+        ia, iout = dpnp.array(a), dpnp.array(out)
+
+        res1, res2 = getattr(dpnp, func)(ia, 3, out=(None, iout))
+        exp1, exp2 = getattr(numpy, func)(a, 3, out=(None, out))
+        assert_array_equal(res1, exp1)
+        assert_array_equal(res2, exp2)
+        assert res2 is iout
+
+        res1, res2 = getattr(dpnp, func)(7, ia, iout)
+        exp1, exp2 = getattr(numpy, func)(7, a, out)
+        assert_array_equal(res1, exp1)
+        assert_array_equal(res2, exp2)
+        assert res1 is iout
+
+    def test_out_same_logical_tensor(self, func):
+        a = generate_random_numpy_array(8, low=1, dtype=int)
+        ia = dpnp.array(a)
+
+        res1, res2 = getattr(dpnp, func)(ia, 3, out=(None, ia))
+        exp1, exp2 = getattr(numpy, func)(a, 3, out=(None, a))
+        assert_array_equal(res1, exp1)
+        assert_array_equal(res2, exp2)
+        assert res2 is ia
+
+        a = generate_random_numpy_array(8, low=1, dtype=int)
+        ia = dpnp.array(a)
+
+        res1, res2 = getattr(dpnp, func)(7, ia, ia)
+        exp1, exp2 = getattr(numpy, func)(7, a, a)
+        assert_array_equal(res1, exp1)
+        assert_array_equal(res2, exp2)
+        assert res1 is ia
+
     @pytest.mark.parametrize("dt", ALL_FLOAT_DTYPES)
     def test_empty(self, func, dt):
         a = numpy.empty(0, dtype=dt)
@@ -236,6 +272,35 @@ def test_complex_dtype(self, func, xp, dt):
         with pytest.raises((TypeError, ValueError)):
             _ = getattr(xp, func)(a, 7)
 
+    def test_f_contiguous_input(self, func):
+        a = generate_random_numpy_array((3, 7), low=1, dtype="i2", order="F")
+        b = generate_random_numpy_array((3, 7), low=1, dtype="u2", order="F")
+        ia, ib = dpnp.array(a), dpnp.array(b)
+
+        res1, res2 = getattr(dpnp, func)(ia, ib)
+        exp1, exp2 = getattr(numpy, func)(a, b)
+        assert_array_equal(res1, exp1)
+        assert_array_equal(res2, exp2)
+
+        out = numpy.zeros_like(a)
+        iout = dpnp.array(out)
+
+        res1, res2 = getattr(dpnp, func)(ia, ib, iout)
+        exp1, exp2 = getattr(numpy, func)(a, b, out)
+        assert_array_equal(res1, exp1)
+        assert_array_equal(res2, exp2)
+        assert res1 is iout
+
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
+    def test_broadcast_error(self, func, xp):
+        a = xp.arange(10).reshape((2, 5))
+        b = xp.ones(2)
+        with pytest.raises(
+            ValueError,
+            match="operands could not be broadcast together with shapes",
+        ):
+            _ = getattr(xp, func)(a, b)
+
 
 class TestDivmod:
     @pytest.mark.usefixtures("suppress_divide_numpy_warnings")

dpnp/tests/test_mathematical.py

@@ -2127,8 +2127,9 @@ def test_unary_two_outs_cfd_error(self, func):
 
     @pytest.mark.parametrize("func", ["abs", "frexp", "add", "divmod"])
     @pytest.mark.parametrize("order", [None, "K", "A", "f", "c"])
-    def test_order(self, func, order):
-        a = numpy.array([1, 2, 3])
+    @pytest.mark.parametrize("in_order", ["C", "F"])
+    def test_order(self, func, order, in_order):
+        a = numpy.arange(1, 7).reshape((2, 3), order=in_order)
         ia = dpnp.array(a)
 
         fn = getattr(numpy, func)
@@ -2140,10 +2141,23 @@ def test_order(self, func, order):
         result = ifn(*iargs, order=order)
         expected = fn(*args, order=order)
         if fn.nout == 1:
-            assert_dtype_allclose(result, expected)
-        else:
-            for i in range(fn.nout):
-                assert_dtype_allclose(result[i], expected[i])
+            result = (result,)
+            expected = (expected,)
+
+        for i in range(fn.nout):
+            assert_dtype_allclose(result[i], expected[i])
+            assert (
+                result[i].flags.c_contiguous == expected[i].flags.c_contiguous
+            )
+            assert (
+                result[i].flags.f_contiguous == expected[i].flags.f_contiguous
+            )
+
+    @pytest.mark.parametrize("func", ["abs", "frexp", "add", "divmod"])
+    def test_types(self, func):
+        types = getattr(dpnp, func).types
+        assert isinstance(types, list)
+        assert len(types) > 0
 
 
 class TestUnwrap: