def test_minimize_arrays_with_default_dtype_shape_strategies():
"""Strategy with default scalar_dtypes and array_shapes strategies minimize
to a boolean 1-dimensional array of size 1."""
smallest = minimal(xps.arrays(xps.scalar_dtypes(), xps.array_shapes()))
assert smallest.shape == (1,)
assert smallest.dtype == xp.bool
assert not xp.any(smallest)
from tests.common.debug import find_any, minimal
from tests.common.utils import fails_with, flaky
needs_xp_unique = pytest.mark.skipif(not hasattr(xp, "unique"), reason="optional API")
def assert_array_namespace(x):
"""Check array has __array_namespace__() and it returns the correct module.
This check is skipped if a mock array module is being used.
"""
if COMPLIANT_XP:
assert x.__array_namespace__() is xp
@given(xps.scalar_dtypes(), st.data())
def test_draw_arrays_from_dtype(dtype, data):
"""Draw arrays from dtypes."""
x = data.draw(xps.arrays(dtype, ()))
assert x.dtype == dtype
assert_array_namespace(x)
@given(st.sampled_from(DTYPE_NAMES), st.data())
def test_draw_arrays_from_scalar_names(name, data):
"""Draw arrays from dtype names."""
x = data.draw(xps.arrays(name, ()))
assert x.dtype == getattr(xp, name)
assert_array_namespace(x)
assert func.__name__ == name
assert func.__doc__ is not None
# The (private) top-level strategy methods may expose a xp argument in their
# function signatures. make_strategies_namespace() exists to wrap these
# top-level methods by binding the passed xp argument, and so the namespace
# it returns should not expose xp in any of its function signatures.
assert "xp" not in signature(func).parameters.keys()
@pytest.mark.parametrize(
"name, strat",
[
("from_dtype", xps.from_dtype(xp.int8)),
("arrays", xps.arrays(xp.int8, 5)),
("array_shapes", xps.array_shapes()),
("scalar_dtypes", xps.scalar_dtypes()),
("boolean_dtypes", xps.boolean_dtypes()),
("numeric_dtypes", xps.numeric_dtypes()),
("integer_dtypes", xps.integer_dtypes()),
("unsigned_integer_dtypes", xps.unsigned_integer_dtypes()),
("floating_dtypes", xps.floating_dtypes()),
("valid_tuple_axes", xps.valid_tuple_axes(0)),
("broadcastable_shapes", xps.broadcastable_shapes(())),
("mutually_broadcastable_shapes",
xps.mutually_broadcastable_shapes(3)),
("indices", xps.indices((5, ))),
],
)
def test_namespaced_strategies_repr(name, strat):
"""Namespaced strategies have good repr."""
assert repr(strat).startswith(name +
# obtain one at https://mozilla.org/MPL/2.0/.
#
# END HEADER
import math
import pytest
from hypothesis import given, strategies as st
from hypothesis.extra.array_api import DTYPE_NAMES, find_castable_builtin_for_dtype
from tests.array_api.common import xp, xps
from tests.common.debug import minimal
@given(xps.scalar_dtypes())
def test_strategies_have_reusable_values(dtype):
"""Inferred strategies have reusable values."""
strat = xps.from_dtype(dtype)
assert strat.has_reusable_values
DTYPES = [getattr(xp, name) for name in DTYPE_NAMES]
@pytest.mark.parametrize("dtype", DTYPES)
def test_produces_castable_instances_from_dtype(dtype):
"""Strategies inferred by dtype generate values of a builtin type castable
to the dtype."""
builtin = find_castable_builtin_for_dtype(xp, dtype)
def test_minimise_scalar_dtypes():
assert minimal(xps.scalar_dtypes()) == xp.bool