more coverage

Author: cakedev0

src/array_api_extra/_delegation.py

@@ -1070,9 +1070,6 @@ def quantile(
     if nan_policy not in nan_policies:
         msg = f"`nan_policy` must be one of {nan_policies}"
         raise ValueError(msg)
-    if keepdims not in {True, False}:
-        msg = "If specified, `keepdims` must be True or False."
-        raise ValueError(msg)
 
     a = xp.asarray(a)
     if not xp.isdtype(a.dtype, ("integral", "real floating")):
@@ -1090,7 +1087,7 @@ def quantile(
         raise ValueError(msg)
     if weights is None:
         if nan_policy != "propagate":
-            msg = ""
+            msg = "When `weights` aren't provided, `nan_policy` must be 'propagate'"
             raise ValueError(msg)
     else:
         if ndim > 2:
@@ -1107,7 +1104,7 @@ def quantile(
                 )
                 raise ValueError(msg)
         if axis is None and ndim == 2:
-            msg = "When weights are provided, axis must be specified when `a` is 2d"
+            msg = "Axis must be specified when `a` and ̀ weights` are 2d."
             raise ValueError(msg)
 
     # Align result dtype with what numpy does:

tests/test_funcs.py

@@ -1543,6 +1543,12 @@ def test_basic(self, xp: ModuleType):
         expect = xp.asarray(3.0, dtype=xp.float64)
         xp_assert_close(actual, expect)
 
+    def test_xp(self, xp: ModuleType):
+        x = xp.asarray([1, 2, 3, 4, 5])
+        actual = quantile(x, 0.5, xp=xp)
+        expect = xp.asarray(3.0, dtype=xp.float64)
+        xp_assert_close(actual, expect)
+
     def test_multiple_quantiles(self, xp: ModuleType):
         x = xp.asarray([1, 2, 3, 4, 5])
         actual = quantile(x, xp.asarray([0.25, 0.5, 0.75]))
@@ -1729,15 +1735,49 @@ def test_invalid_q(self, xp: ModuleType):
         ):
             _ = quantile(x, -0.5)
 
+    def test_invalid_shape(self, xp: ModuleType):
+        with pytest.raises(TypeError, match="at least 1-dimensional"):
+            _ = quantile(xp.asarray(3.0), 0.5)
+        with pytest.raises(ValueError, match="not compatible with the dimension"):
+            _ = quantile(xp.asarray([3.0]), 0.5, axis=1)
+        # with weights:
+        method = "inverted_cdf"
+        shape = (2, 3, 4)
+        with pytest.raises(ValueError, match="dimension of `a` must be 1 or 2"):
+            _ = quantile(
+                xp.ones(shape), 0.5, axis=1, weights=xp.ones(shape), method=method
+            )
+        with pytest.raises(TypeError, match="Axis must be specified"):
+            _ = quantile(xp.ones((2, 3)), 0.5, weights=xp.ones(3), method=method)
+        with pytest.raises(ValueError, match="Shape of weights must be consistent"):
+            _ = quantile(
+                xp.ones((2, 3)), 0.5, axis=0, weights=xp.ones(3), method=method
+            )
+        with pytest.raises(ValueError, match="Axis must be specified"):
+            _ = quantile(xp.ones((2, 3)), 0.5, weights=xp.ones((2, 3)), method=method)
+
+    def test_invalid_dtype(self, xp: ModuleType):
+        with pytest.raises(ValueError, match="`a` must have real dtype"):
+            _ = quantile(xp.ones(5, dtype=xp.bool), 0.5)
+
+        with pytest.raises(ValueError, match="`q` must have real floating dtype"):
+            _ = quantile(xp.ones(5), xp.asarray([0, 1]))
+
+    def test_invalid_method(self, xp: ModuleType):
+        with pytest.raises(ValueError, match="`method` must be one of"):
+            _ = quantile(xp.ones(5), 0.5, method="invalid")
+        # TODO: with weights?
+
+    def test_invalid_nan_policy(self, xp: ModuleType):
+        with pytest.raises(ValueError, match="`nan_policy` must be one of"):
+            _ = quantile(xp.ones(5), 0.5, nan_policy="invalid")
+
+        with pytest.raises(ValueError, match="must be 'propagate'"):
+            _ = quantile(xp.ones(5), 0.5, nan_policy="omit")
+
     def test_device(self, xp: ModuleType, device: Device):
         if hasattr(device, "type") and device.type == "meta":  # pyright: ignore[reportAttributeAccessIssue]
             pytest.xfail("No Tensor.item() on meta device")
         x = xp.asarray([1, 2, 3, 4, 5], device=device)
         actual = quantile(x, 0.5)
         assert get_device(actual) == device
-
-    def test_xp(self, xp: ModuleType):
-        x = xp.asarray([1, 2, 3, 4, 5])
-        actual = quantile(x, 0.5, xp=xp)
-        expect = xp.asarray(3.0, dtype=xp.float64)
-        xp_assert_close(actual, expect)