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)
def test_may_not_use_unrepresentable_elements(fill, dtype, strat, data):
"""Strategy with elements not representable by the dtype raises helpful error."""
if fill:
kw = {"elements": st.nothing(), "fill": strat}
else:
kw = {"elements": strat}
strat = xps.arrays(dtype=dtype, shape=1, **kw)
data.draw(strat)
def test_minimize_float_arrays():
"""Strategy with float dtype minimizes to a good example.
We filter runtime warnings and expect flaky array generation for
specifically NumPy - this behaviour may not be required when testing
with other array libraries.
"""
smallest = minimal(xps.arrays(xp.float32, 50), lambda x: xp.sum(x) >= 1.0)
assert xp.sum(smallest) in (1, 50)
def test_passing_inferred_strategies_in_arrays(dtype):
"""Inferred strategies usable in arrays strategy."""
elements = xps.from_dtype(dtype)
@given(xps.arrays(dtype, 10, elements=elements))
def smoke_test(_):
pass
smoke_test()
def test_may_reuse_distinct_integers_if_asked():
"""Strategy with shared elements and fill strategies of distinct integers
may generate arrays with non-distinct values."""
find_any(
xps.arrays(
xp.uint64, 10, elements=distinct_integers(), fill=distinct_integers()
),
lambda x: count_unique(x) < x.size,
)
def test_minimize_large_uint_arrays():
"""Strategy with uint dtype and largely sized shape minimizes to a good
example."""
smallest = minimal(
xps.arrays(xp.uint8, 100),
lambda x: xp.any(x) and not xp.all(x),
timeout_after=60,
)
assert xp.all(xp.logical_or(smallest == 0, smallest == 1))
idx = xp.nonzero(smallest)[0]
assert idx.size in (1, smallest.size - 1)
def test_may_fill_unique_arrays_with_nan():
"""Unique strategy with NaN fill can generate arrays holding NaNs."""
find_any(
xps.arrays(
dtype=xp.float32,
shape=10,
elements=st.floats(allow_nan=False),
unique=True,
fill=st.just(xp.nan),
),
lambda x: xp.any(xp.isnan(x)),
)
def test_array_element_rewriting(data, start, size):
"""Unique strategy generates arrays with expected elements."""
x = data.draw(
xps.arrays(
dtype=xp.int64,
shape=size,
elements=st.integers(start, start + size - 1),
unique=True,
))
x_set_expect = xp.linspace(start, start + size - 1, size, dtype=xp.int64)
x_set = xp.sort(xp.unique_values(x))
assert xp.all(x_set == x_set_expect)
def test_excluded_min_in_float_arrays(dtype, low, data):
"""Strategy with elements strategy excluding min does not generate arrays
with elements less or equal to said min."""
strat = xps.arrays(
dtype=dtype,
shape=(),
elements={
"min_value": low,
"max_value": low + 1,
"exclude_min": True,
},
)
x = data.draw(strat, label="array")
assert xp.all(x > low)
def test_cannot_draw_subnormals_for_ftz_float32():
"""For FTZ builds of array modules, strategy with subnormal elements
strategy raises helpful error."""
strat = xps.arrays(
xp.float32,
10,
elements={
"min_value": 0.0,
"max_value": width_smallest_normals[32],
"exclude_min": True,
"exclude_max": True,
"allow_subnormal": True,
},
)
with pytest.raises(InvalidArgument, match="Generated subnormal float"):
strat.example()
def test_draw_arrays_from_dtype_name_strategies(names, data):
"""Draw arrays from dtype name strategies."""
names_strategy = st.sampled_from(names)
x = data.draw(xps.arrays(names_strategy, ()))
assert_array_namespace(x)
def test_draw_arrays_from_dtype_strategies(strat, data):
"""Draw arrays from dtype strategies."""
x = data.draw(xps.arrays(strat, ()))
assert_array_namespace(x)
def test_draw_arrays_from_int_shapes(size, data):
"""Draw arrays from integers as shapes."""
x = data.draw(xps.arrays(xp.int8, size))
assert x.shape == (size,)
assert_array_namespace(x)
def test_draw_arrays_from_shapes(shape, data):
"""Draw arrays from shapes."""
x = data.draw(xps.arrays(xp.int8, shape))
assert x.ndim == len(shape)
assert x.shape == shape
assert_array_namespace(x)
"""Namespaced method objects have good meta attributes."""
func = getattr(xps, name)
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):
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)
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.data())
def test_draw_arrays_from_dtype_strategies(strat, data):
"""Draw arrays from dtype strategies."""
x = data.draw(xps.arrays(strat, ()))
assert_array_namespace(x)
@given(st.lists(st.sampled_from(DTYPE_NAMES), min_size=1, unique=True), st.data())
def test_draw_arrays_from_dtype_name_strategies(names, data):
"""Draw arrays from dtype name strategies."""
names_strategy = st.sampled_from(names)
x = data.draw(xps.arrays(names_strategy, ()))
assert_array_namespace(x)
@given(xps.arrays(xp.int8, xps.array_shapes()))
def test_generate_arrays_from_shapes_strategy(x):
"""Generate arrays from shapes strategy."""
assert_array_namespace(x)
@given(xps.arrays(xp.int8, st.integers(0, 100)))
def test_generate_arrays_from_integers_strategy_as_shape(x):
"""Generate arrays from integers strategy as shapes strategy."""
assert_array_namespace(x)
@given(xps.arrays(xp.int8, ()))
def test_generate_arrays_from_zero_dimensions(x):
"""Generate arrays from empty shape."""
assert x.shape == ()
def test_may_not_use_overflowing_integers(kwargs, data):
"""Strategy with elements strategy range outside the dtype's bounds raises
helpful error."""
strat = xps.arrays(dtype=xp.int8, shape=1, **kwargs)
data.draw(strat)
def test_minimizes_to_fill():
"""Strategy with single fill value minimizes to arrays only containing said
fill value."""
smallest = minimal(xps.arrays(xp.float32, 10, fill=st.just(3.0)))
assert xp.all(smallest == 3.0)
def test_minimize_arrays_with_0d_shape_strategy():
"""Strategy with shape strategy that can generate empty tuples minimizes to
0d arrays."""
smallest = minimal(xps.arrays(xp.int8, xps.array_shapes(min_dims=0)))
assert smallest.shape == ()
def test_minimizes_numeric_arrays(dtype):
"""Strategies with numeric dtypes minimize to zero-filled arrays."""
smallest = minimal(xps.arrays(dtype, (2, 2)))
assert xp.all(smallest == 0)
