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)