Add a test for full()

Author: cr313

array_api_tests/_array_module.py

@@ -54,7 +54,7 @@ def __repr__(self):
     __getattr__ = _raise
 
 _integer_dtypes = [
-        'int8',
+    'int8',
     'int16',
     'int32',
     'int64',

array_api_tests/hypothesis_helpers.py

@@ -4,12 +4,15 @@
 
 from hypothesis.strategies import (lists, integers, builds, sampled_from,
                                    shared, tuples as hypotheses_tuples,
-                                   floats, just, composite, one_of, none)
+                                   floats, just, composite, one_of, none,
+                                   booleans)
 from hypothesis import assume
 
 from .pytest_helpers import nargs
+from .array_helpers import dtype_ranges
 from ._array_module import (_integer_dtypes, _floating_dtypes,
-                            _numeric_dtypes, _dtypes, ones, full)
+                            _numeric_dtypes, _dtypes, ones, full, float32,
+                            float64, bool as bool_dtype)
 from . import _array_module
 
 from .function_stubs import elementwise_functions
@@ -73,6 +76,24 @@ def tuples(elements, *, min_size=0, max_size=None, unique_by=None, unique=False)
 # TODO: Generate general arrays here, rather than just scalars.
 numeric_arrays = builds(full, just((1,)), floats())
 
+@composite
+def shared_scalars(draw):
+    """
+    Strategy to generate a scalar that matches the dtype from shared_dtypes
+    """
+    dtype = draw(shared_dtypes)
+    if dtype in dtype_ranges:
+        m, M = dtype_ranges[dtype]
+        return draw(integers(m, M))
+    elif dtype == bool_dtype:
+        return draw(booleans())
+    elif dtype == float64:
+        return draw(floats())
+    elif dtype == float32:
+        return draw(floats(width=32))
+    else:
+        raise ValueError(f"Unrecognized dtype {dtype}")
+
 @composite
 def integer_indices(draw, sizes):
     size = draw(sizes)

array_api_tests/test_creation_functions.py

@@ -1,7 +1,9 @@
-from ._array_module import arange, ceil, empty, _floating_dtypes, eye
+from ._array_module import (arange, ceil, empty, _floating_dtypes, eye, full,
+equal, all)
 from .array_helpers import is_integer_dtype, dtype_ranges
 from .hypothesis_helpers import (numeric_dtypes, dtypes, MAX_ARRAY_SIZE,
-                                 shapes, sizes, sqrt_sizes)
+                                 shapes, sizes, sqrt_sizes, shared_dtypes,
+                                 shared_scalars)
 
 from hypothesis import assume, given
 from hypothesis.strategies import integers, floats, one_of, none
@@ -98,3 +100,19 @@ def test_eye(N, M, k, dtype):
                 assert a[i, j] == 1, "eye() did not produce a 1 on the diagonal"
             else:
                 assert a[i, j] == 0, "eye() did not produce a 0 off the diagonal"
+
+@given(shapes, shared_scalars(), one_of(none(), shared_dtypes))
+def test_full(shape, fill_value, dtype):
+    kwargs = {} if dtype is None else {'dtype': dtype}
+
+    a = full(shape, fill_value, **kwargs)
+
+    if dtype is None:
+        # TODO: Should it actually match the fill_value?
+        # assert a.dtype in _floating_dtypes, "eye() should produce an array with the default floating point dtype"
+        pass
+    else:
+        assert a.dtype == dtype
+
+    assert a.shape == shape, "full() produced an array with incorrect shape"
+    assert all(equal(a, fill_value)), "full() array did not equal the fill value"