def integers(min_value=None, max_value=None):
"""Returns a strategy which generates integers (in Python 2 these may be
ints or longs).
If min_value is not None then all values will be >=
min_value. If max_value is not None then all values will be <= max_value
"""
from hypothesis.searchstrategy.numbers import IntegersFromStrategy, \
BoundedIntStrategy, RandomGeometricIntStrategy, WideRangeIntStrategy
if min_value is None:
if max_value is None:
return (
RandomGeometricIntStrategy() |
WideRangeIntStrategy()
)
else:
check_type(integer_types, max_value)
return IntegersFromStrategy(0).map(lambda x: max_value - x)
else:
check_type(integer_types, min_value)
if max_value is None:
return IntegersFromStrategy(min_value)
else:
if min_value == max_value:
return just(min_value)
elif min_value > max_value:
raise InvalidArgument(
u'Cannot have max_value=%r < min_value=%r' % (
max_value, min_value
))
return BoundedIntStrategy(min_value, max_value)
def integers(min_value=None, max_value=None):
"""Returns a strategy which generates integers (in Python 2 these may be
ints or longs).
If min_value is not None then all values will be >=
min_value. If max_value is not None then all values will be <= max_value
"""
check_valid_integer(min_value)
check_valid_integer(max_value)
check_valid_interval(min_value, max_value, 'min_value', 'max_value')
from hypothesis.searchstrategy.numbers import IntegersFromStrategy, \
BoundedIntStrategy, RandomGeometricIntStrategy, WideRangeIntStrategy
if min_value is None:
if max_value is None:
return (RandomGeometricIntStrategy() | WideRangeIntStrategy())
else:
return IntegersFromStrategy(0).map(lambda x: max_value - x)
else:
if max_value is None:
return IntegersFromStrategy(min_value)
else:
if min_value == max_value:
return just(min_value)
return BoundedIntStrategy(min_value, max_value)
def integers(min_value=None, max_value=None):
"""Returns a strategy which generates integers (in Python 2 these may be
ints or longs).
If min_value is not None then all values will be >= min_value. If
max_value is not None then all values will be <= max_value
"""
check_valid_bound(min_value, 'min_value')
check_valid_bound(max_value, 'max_value')
check_valid_interval(min_value, max_value, 'min_value', 'max_value')
from hypothesis.searchstrategy.numbers import IntegersFromStrategy, \
BoundedIntStrategy, WideRangeIntStrategy
min_int_value = None
if min_value is not None:
min_int_value = int(min_value)
if min_int_value != min_value and min_value > 0:
min_int_value += 1
max_int_value = None
if max_value is not None:
max_int_value = int(max_value)
if max_int_value != max_value and max_value < 0:
max_int_value -= 1
if min_int_value is None:
if max_int_value is None:
return (
WideRangeIntStrategy()
)
else:
return IntegersFromStrategy(0).map(lambda x: max_int_value - x)
else:
if max_int_value is None:
return IntegersFromStrategy(min_int_value)
else:
assert min_int_value <= max_int_value
if min_int_value == max_int_value:
return just(min_int_value)
elif min_int_value >= 0:
return BoundedIntStrategy(min_int_value, max_int_value)
elif max_int_value <= 0:
return BoundedIntStrategy(
-max_int_value, -min_int_value
).map(lambda t: -t)
else:
return integers(min_value=0, max_value=max_int_value) | \
integers(min_value=min_int_value, max_value=0)
def lists(elements=None, min_size=None, average_size=None, max_size=None):
"""Returns a list containining values drawn from elements length in the
interval [min_size, max_size] (no bounds in that direction if these are
None). If max_size is 0 then elements may be None and only the empty list
will be drawn.
average_size may be used as a size hint to roughly control the size
of list but it may not be the actual average of sizes you get, due
to a variety of factors.
"""
check_valid_sizes(min_size, average_size, max_size)
from hypothesis.searchstrategy.collections import ListStrategy, \
SingleElementListStrategy
if min_size is None:
min_size = 0
if average_size is None:
if max_size is None:
average_size = Settings.default.average_list_length
else:
average_size = (min_size + max_size) * 0.5
if elements is None or (max_size is not None and max_size <= 0):
if max_size is None or max_size > 0:
raise InvalidArgument(
'Cannot create non-empty lists without an element type')
else:
return ListStrategy(())
else:
check_strategy(elements)
if elements.template_upper_bound == 1:
from hypothesis.searchstrategy.numbers import IntegersFromStrategy
if max_size is None:
length_strat = IntegersFromStrategy(min_size,
average_size=average_size -
min_size)
else:
length_strat = integers(min_size, max_size)
return SingleElementListStrategy(elements, length_strat)
return ListStrategy(
(elements, ),
average_length=average_size,
min_size=min_size,
max_size=max_size,
)
def lists(
elements=None, min_size=None, average_size=None, max_size=None,
unique_by=None
):
"""Returns a list containining values drawn from elements length in the
interval [min_size, max_size] (no bounds in that direction if these are
None). If max_size is 0 then elements may be None and only the empty list
will be drawn.
average_size may be used as a size hint to roughly control the size
of list but it may not be the actual average of sizes you get, due
to a variety of factors.
if unique_by is not None it must be a function returning a hashable type
when given a value drawn from elements. The resulting list will satisfy the
condition that for i != j, unique_by(result[i]) != unique_by(result[j]).
"""
if unique_by is not None:
from hypothesis.searchstrategy.collections import UniqueListStrategy
if max_size == 0:
return builds(list)
check_strategy(elements)
if min_size is not None and elements.template_upper_bound < min_size:
raise InvalidArgument((
u'Cannot generate unique lists of size %d from %r, which '
u'contains no more than %d distinct values') % (
min_size, elements, elements.template_upper_bound,
))
min_size = min_size or 0
max_size = max_size or float(u'inf')
max_size = min(max_size, elements.template_upper_bound)
if average_size is None:
if max_size < float(u'inf'):
if max_size <= 5:
average_size = min_size + 0.75 * (max_size - min_size)
else:
average_size = (max_size + min_size) / 2
else:
average_size = max(
Settings.default.average_list_length,
min_size * 2
)
check_valid_sizes(min_size, average_size, max_size)
result = UniqueListStrategy(
elements=elements,
average_size=average_size,
max_size=max_size,
min_size=min_size,
key=unique_by
)
return result
check_valid_sizes(min_size, average_size, max_size)
from hypothesis.searchstrategy.collections import ListStrategy, \
SingleElementListStrategy
if min_size is None:
min_size = 0
if average_size is None:
if max_size is None:
average_size = Settings.default.average_list_length
else:
average_size = (min_size + max_size) * 0.5
if elements is None or (max_size is not None and max_size <= 0):
if max_size is None or max_size > 0:
raise InvalidArgument(
u'Cannot create non-empty lists without an element type'
)
else:
return ListStrategy(())
else:
check_strategy(elements)
if elements.template_upper_bound == 1:
from hypothesis.searchstrategy.numbers import IntegersFromStrategy
if max_size is None:
length_strat = IntegersFromStrategy(
min_size, average_size=average_size - min_size)
else:
length_strat = integers(min_size, max_size)
return SingleElementListStrategy(elements, length_strat)
return ListStrategy(
(elements,), average_length=average_size,
min_size=min_size, max_size=max_size,
)
def lists(
elements=None,
min_size=None,
average_size=None,
max_size=None,
unique_by=None,
unique=False,
):
"""Returns a list containing values drawn from elements length in the
interval [min_size, max_size] (no bounds in that direction if these are
None). If max_size is 0 then elements may be None and only the empty list
will be drawn.
average_size may be used as a size hint to roughly control the size
of list but it may not be the actual average of sizes you get, due
to a variety of factors.
If unique is True (or something that evaluates to True), we compare direct
object equality, as if unique_by was `lambda x: x`. This comparison only
works for hashable types.
if unique_by is not None it must be a function returning a hashable type
when given a value drawn from elements. The resulting list will satisfy the
condition that for i != j, unique_by(result[i]) != unique_by(result[j]).
"""
if unique:
if unique_by is not None:
raise InvalidArgument(
('cannot specify both unique and unique_by (you probably only '
'want to set unique_by)'))
else:
unique_by = lambda x: x
if unique_by is not None:
from hypothesis.searchstrategy.collections import UniqueListStrategy
if max_size == 0:
return builds(list)
check_strategy(elements)
if min_size is not None and elements.template_upper_bound < min_size:
raise InvalidArgument(
('Cannot generate unique lists of size %d from %r, which '
'contains no more than %d distinct values') % (
min_size,
elements,
elements.template_upper_bound,
))
min_size = min_size or 0
max_size = max_size or float(u'inf')
max_size = min(max_size, elements.template_upper_bound)
if average_size is None:
if max_size < float(u'inf'):
if max_size <= 5:
average_size = min_size + 0.75 * (max_size - min_size)
else:
average_size = (max_size + min_size) / 2
else:
average_size = max(_AVERAGE_LIST_LENGTH, min_size * 2)
check_valid_sizes(min_size, average_size, max_size)
result = UniqueListStrategy(elements=elements,
average_size=average_size,
max_size=max_size,
min_size=min_size,
key=unique_by)
return result
check_valid_sizes(min_size, average_size, max_size)
from hypothesis.searchstrategy.collections import ListStrategy, \
SingleElementListStrategy
if min_size is None:
min_size = 0
if average_size is None:
if max_size is None:
average_size = _AVERAGE_LIST_LENGTH
else:
average_size = (min_size + max_size) * 0.5
if elements is None or (max_size is not None and max_size <= 0):
if max_size is None or max_size > 0:
raise InvalidArgument(
'Cannot create non-empty lists without an element type')
else:
return ListStrategy(())
else:
check_strategy(elements)
if elements.template_upper_bound == 1:
from hypothesis.searchstrategy.numbers import IntegersFromStrategy
if max_size is None:
length_strat = IntegersFromStrategy(min_size,
average_size=average_size -
min_size)
else:
length_strat = integers(min_size, max_size)
return SingleElementListStrategy(elements, length_strat)
return ListStrategy(
(elements, ),
average_length=average_size,
min_size=min_size,
max_size=max_size,
)
