Add more tests to improve the coverage

Author: antonwolfy

dpnp/dpnp_algo/dpnp_elementwise_common.py

@@ -319,7 +319,7 @@ def __call__(
         if not isinstance(out, tuple):
             raise TypeError("'out' must be a tuple of arrays")
 
-        if len(out) != 2:
+        if len(out) != self.nout:
             raise ValueError(
                 "'out' tuple must have exactly one entry per ufunc output"
             )
@@ -341,7 +341,7 @@ def __call__(
 
             res = dpnp.get_usm_ndarray(out[i])
             if not res.flags.writable:
-                raise ValueError("provided output array is read-only")
+                raise ValueError("output array is read-only")
 
             if res.shape != x.shape:
                 raise ValueError(

dpnp/tests/test_mathematical.py

@@ -802,12 +802,6 @@ def test_strides_out(self, stride, dt):
         assert_array_equal(iout_mant, out_mant)
         assert_array_equal(iout_exp, out_exp)
 
-    @pytest.mark.parametrize("xp", [numpy, dpnp])
-    def test_out_wrong_type(self, xp):
-        a = xp.array(0.5)
-        with pytest.raises(TypeError, match="'out' must be a tuple of arrays"):
-            _ = xp.frexp(a, out=xp.empty(()))
-
     @pytest.mark.parametrize("xp", [numpy, dpnp])
     @pytest.mark.parametrize("dt", get_complex_dtypes())
     def test_complex_dtype(self, xp, dt):
@@ -2080,7 +2074,7 @@ def test_not_supported_kwargs(self, func, kwargs):
 
     @pytest.mark.parametrize("func", ["abs", "frexp", "add"])
     @pytest.mark.parametrize("x", [1, [1, 2], numpy.ones(5)])
-    def test_wrong_input(self, func, x):
+    def test_unary_wrong_input(self, func, x):
         fn = getattr(dpnp, func)
         args = [x] * fn.nin
         with pytest.raises(TypeError):
@@ -2115,8 +2109,62 @@ def test_out_dtype(self, func):
         ):
             fn(*args, out=out, dtype="f4")
 
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
+    def test_unary_two_outs_out_ndarray(self, xp):
+        x = xp.array(0.5)
+        with pytest.raises(TypeError, match="'out' must be a tuple of arrays"):
+            _ = xp.frexp(x, out=xp.empty(()))
+
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
+    @pytest.mark.parametrize("out", [(), (1,), (1, 2, 3)])
+    def test_unary_two_outs_out_wrong_tuple_len(self, xp, out):
+        x = xp.array(0.5)
+        with pytest.raises(
+            ValueError,
+            match="'out' tuple must have exactly one entry per ufunc output",
+        ):
+            _ = xp.frexp(x, out=out)
+
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
+    def test_unary_two_outs_out_mixed(self, xp):
+        x = xp.array(0.5)
+        with pytest.raises(
+            TypeError,
+            match="cannot specify 'out' as both a positional and keyword",
+        ):
+            _ = xp.frexp(x, xp.empty(()), out=(xp.empty(()), None))
+
+    @pytest.mark.parametrize("func", ["abs", "add"])
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
+    def test_unary_two_outs_out_not_writable(self, func, xp):
+        x = xp.array(0.5)
+        out1 = xp.empty(())
+        out1.flags["W"] = False
+
+        fn = getattr(xp, func)
+        args = [x] * fn.nin
+        with pytest.raises(ValueError, match="array is read-only"):
+            _ = fn(*args, out1)
+
+        out2 = xp.empty((), dtype="i")
+        out2.flags["W"] = False
+        with pytest.raises(ValueError, match="array is read-only"):
+            _ = fn(*args, out=(None, out2))
+
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
+    def test_unary_two_outs_out_wrong_shape(self, xp):
+        x = xp.full(6, fill_value=0.5)
+        out1 = xp.empty(12)
+        with pytest.raises(ValueError):
+            _ = xp.frexp(x, out1)
+
+        out2 = xp.empty((2, 3), dtype="i")
+        with pytest.raises(ValueError):
+            _ = xp.frexp(x, out=(None, out2))
+
     @pytest.mark.parametrize("func", ["abs", "frexp", "add"])
-    def test_order_none(self, func):
+    @pytest.mark.parametrize("order", [None, "K", "A", "f", "c"])
+    def test_order(self, func, order):
         a = numpy.array([1, 2, 3])
         ia = dpnp.array(a)
 
@@ -2126,8 +2174,8 @@ def test_order_none(self, func):
         args = [a] * fn.nin
         iargs = [ia] * ifn.nin
 
-        result = ifn(*iargs, order=None)
-        expected = fn(*args, order=None)
+        result = ifn(*iargs, order=order)
+        expected = fn(*args, order=order)
         if fn.nout == 1:
             assert_dtype_allclose(result, expected)
         else: