def sampled_from(elements):
"""Returns a strategy which generates any value present in the iterable
elements.
Note that as with just, values will not be copied and thus you
should be careful of using mutable data
"""
from hypothesis.searchstrategy.misc import SampledFromStrategy, \
JustStrategy
elements = tuple(iter(elements))
if not elements:
raise InvalidArgument(
u'sampled_from requires at least one value'
)
if len(elements) == 1:
result = JustStrategy(elements[0])
else:
result = SampledFromStrategy(elements)
return ReprWrapperStrategy(
result, u'sampled_from((%s))' % (u', '.join(
map(unicode_safe_repr, elements)
))
)
def builds(target, *args, **kwargs):
"""Generates values by drawing from args and kwargs and passing them to
target in the appropriate argument position.
e.g. builds(target,
integers(), flag=booleans()) would draw an integer i and a boolean b and
call target(i, flag=b).
"""
from hypothesis.internal.reflection import nicerepr
def splat(value):
return target(*value[0], **value[1])
target_name = getattr(target, u'__name__', type(target).__name__)
splat.__name__ = str(u'splat(%s)' % (target_name, ))
def calc_repr():
return u'builds(%s)' % (
u', '.join([nicerepr(target)] + list(map(nicerepr, args)) +
sorted([u'%s=%r' % (k, v) for k, v in kwargs.items()])))
return ReprWrapperStrategy(
tuples(tuples(*args), fixed_dictionaries(kwargs)).map(splat),
calc_repr)
def just(value):
"""Return a strategy which only generates value.
Note: value is not copied. Be wary of using mutable values.
"""
from hypothesis.searchstrategy.misc import JustStrategy
return ReprWrapperStrategy(
JustStrategy(value), u'just(%s)' % (unicode_safe_repr(value),))
def uuids():
"""Returns a strategy that generates UUIDs.
All returned values from this will be unique, so e.g. if you do
lists(uuids()) the resulting list will never contain duplicates.
"""
from uuid import UUID
return ReprWrapperStrategy(
shared(randoms(), key='hypothesis.strategies.uuids.generator').map(
lambda r: UUID(int=r.getrandbits(128))), 'uuids()')
def accept(*args, **kwargs):
result = strategy_definition(*args, **kwargs)
args, kwargs = convert_positional_arguments(strategy_definition, args,
kwargs)
kwargs_for_repr = dict(kwargs)
for k, v in defaults.items():
if k in kwargs_for_repr and kwargs_for_repr[k] is defaults[k]:
del kwargs_for_repr[k]
representation = u'%s(%s)' % (strategy_definition.__name__,
arg_string(strategy_definition, args,
kwargs_for_repr))
return ReprWrapperStrategy(result, representation)
def builds(target, *args, **kwargs):
"""Generates values by drawing from args and kwargs and passing them to
target in the appropriate argument position.
e.g. builds(target,
integers(), flag=booleans()) would draw an integer i and a boolean b and
call target(i, flag=b).
"""
def splat(value):
return target(*value[0], **value[1])
target_name = getattr(target, '__name__', type(target).__name__)
splat.__name__ = str('splat(%s)' % (target_name, ))
return ReprWrapperStrategy(
tuples(tuples(*args), fixed_dictionaries(kwargs)).map(splat),
'builds(%s, %s)' % (target_name, ', '.join(
list(map(repr, args)) +
['%s=%r' % (k, v) for k, v in kwargs.items()])))
def choices():
"""Strategy that generates a function that behaves like random.choice.
Will note choices made for reproducibility.
"""
from hypothesis.control import note, current_build_context
def build_chooser(stream):
index = [-1]
choice_count = [0]
context = current_build_context()
context.mark_captured()
def choice(values):
if not values:
raise IndexError('Cannot choose from empty sequence')
k = len(values) - 1
if k == 0:
chosen = 0
else:
mask = _right_saturate(k)
while True:
index[0] += 1
probe = stream[index[0]] & mask
if probe <= k:
chosen = probe
break
choice_count[0] += 1
result = values[chosen]
with context.local():
note('Choice #%d: %r' % (choice_count[0], result))
return result
return choice
return ReprWrapperStrategy(
shared(builds(build_chooser, streaming(integers(min_value=0))),
key='hypothesis.strategies.chooser.choice_function'),
'chooser()')
def choices():
"""Strategy that generates a function that behaves like random.choice.
Will note choices made for reproducibility.
"""
from hypothesis.control import note, current_build_context
from hypothesis.internal.conjecture.utils import choice
class Chooser(object):
def __init__(self, build_context, data):
self.build_context = build_context
self.data = data
self.choice_count = 0
def __call__(self, values):
if not values:
raise IndexError('Cannot choose from empty sequence')
result = choice(self.data, values)
with self.build_context.local():
self.choice_count += 1
note('Choice #%d: %r' % (self.choice_count, result))
return result
def __repr__(self):
return 'choice'
class ChoiceStrategy(SearchStrategy):
supports_find = False
def do_draw(self, data):
return Chooser(current_build_context(), data)
return ReprWrapperStrategy(
shared(
ChoiceStrategy(),
key='hypothesis.strategies.chooser.choice_function'
), 'choices()')