def pack(self, value):
try:
result = self.model(**value)
result.save()
return result
except (IntegrityError, ValidationError):
assume(False)
def test_density_voronoi_1(points):
assume(does_not_raise_Qhull_error(points))
assume(all_unique(points))
cell_size = 0.1
density = density_voronoi_1(points, cell_size=cell_size)
assert True
def pack(self, value):
try:
result = self.model(**value)
result.save()
return result
except IntegrityError:
assume(False)
def do_draw(self, data):
def draw_float_bytes(random, n):
assert n == 8
while True:
i = random.randint(1, 10)
if i <= 4:
f = random.choice(NASTY_FLOATS)
elif i == 5:
return bytes_from_list(
random.randint(0, 255) for _ in range(8))
elif i == 6:
f = random.random() * (
random.randint(0, 1) * 2 - 1
)
elif i == 7:
f = random.gauss(0, 1)
elif i == 8:
f = float(random.randint(-2 ** 63, 2 ** 63))
else:
f = random.gauss(
random.randint(-2 ** 63, 2 ** 63), 1
)
if self.permitted(f):
return struct.pack(b'!d', f)
result = struct.unpack(b'!d', bytes(
data.draw_bytes(8, draw_float_bytes)))[0]
assume(self.permitted(result))
return result
def pack(self, value):
try:
result = self.model(**value)
result.save()
return result
except (IntegrityError, ValidationError):
assume(False)
def do_draw(self, data):
seen = set()
result = []
if self.max_size == self.min_size:
while len(result) < self.max_size:
v = data.draw(self.element_strategy)
k = self.key(v)
if k not in seen:
result.append(v)
seen.add(k)
return result
stopping_value = 1 - 1.0 / (1 + self.average_size)
duplicates = 0
while len(result) < self.max_size:
data.start_example()
if len(result) >= self.min_size:
more = cu.biased_coin(data, stopping_value)
else:
more = True
if not more:
data.stop_example()
break
value = data.draw(self.element_strategy)
data.stop_example()
k = self.key(value)
if k in seen:
duplicates += 1
assume(duplicates <= len(result))
continue
seen.add(k)
result.append(value)
assume(len(result) >= self.min_size)
return result
def splat(value):
try:
result = target(*value[0], **value[1])
result.validate()
return result
except InvalidArgument:
assume(False)
def do_draw(self, data):
def draw_float_bytes(random, n):
assert n == 8
while True:
i = random.randint(1, 10)
if i <= 4:
f = random.choice(NASTY_FLOATS)
elif i == 5:
return bytes_from_list(
random.randint(0, 255) for _ in range(8))
elif i == 6:
f = random.random() * (random.randint(0, 1) * 2 - 1)
elif i == 7:
f = random.gauss(0, 1)
elif i == 8:
f = float(random.randint(-2**63, 2**63))
else:
f = random.gauss(random.randint(-2**63, 2**63), 1)
if self.permitted(f):
return struct.pack(b'!d', f)
result = struct.unpack(b'!d',
bytes(data.draw_bytes(8, draw_float_bytes)))[0]
assume(self.permitted(result))
return result
def pack(self, value):
try:
result = self.model(**value)
result.save()
return result
except IntegrityError:
assume(False)
def do_draw(self, data):
seen = set()
result = []
if self.max_size == self.min_size:
while len(result) < self.max_size:
v = data.draw(self.element_strategy)
k = self.key(v)
if k not in seen:
result.append(v)
seen.add(k)
return result
stopping_value = 1 - 1.0 / (1 + self.average_size)
duplicates = 0
while len(result) < self.max_size:
data.start_example()
if len(result) >= self.min_size:
more = cu.biased_coin(data, stopping_value)
else:
more = True
if not more:
data.stop_example()
break
value = data.draw(self.element_strategy)
data.stop_example()
k = self.key(value)
if k in seen:
duplicates += 1
assume(duplicates <= len(result))
continue
seen.add(k)
result.append(value)
assume(len(result) >= self.min_size)
return result
def do_draw(self, data):
f = self.lower_bound + (self.upper_bound -
self.lower_bound) * d.fractional_float(data)
if self.width < 64:
f = float_of(f, self.width)
assume(self.lower_bound <= f <= self.upper_bound)
return f
def splat(value):
try:
result = target(*value[0], **value[1])
result.validate()
return result
except InvalidArgument:
assume(False)
def build_dict(data):
result = dict_class()
for k, v in data:
result[k] = v
if max_size is not None and len(result) >= max_size:
break
assume(min_size is None or len(result) >= min_size)
return result
def build_dict(data):
result = dict_class()
for k, v in data:
result[k] = v
if max_size is not None and len(result) >= max_size:
break
assume(min_size is None or len(result) >= min_size)
return result
def do_draw(self, data):
f = self.lower_bound + (self.upper_bound -
self.lower_bound) * d.fractional_float(data)
if self.width < 64:
f = float_of(f, self.width)
assume(self.lower_bound <= f <= self.upper_bound)
if not self.allow_subnormal:
assume(f == 0 or abs(f) >= width_smallest_normals[self.width])
return f
def do_draw(self, data):
f = self.lower_bound + (
self.upper_bound - self.lower_bound) * d.fractional_float(data)
assume(self.lower_bound <= f <= self.upper_bound)
assume(sign(self.lower_bound) <= sign(f) <= sign(self.upper_bound))
# Special handling for bounds of -0.0
for g in [self.lower_bound, self.upper_bound]:
if f == g:
f = math.copysign(f, g)
return f
def do_draw(self, data):
f = self.lower_bound + (self.upper_bound -
self.lower_bound) * d.fractional_float(data)
if self.width < 64:
try:
f = float_of(f, self.width)
except OverflowError: # pragma: no cover
reject()
assume(self.lower_bound <= f <= self.upper_bound)
return f
def do_draw(self, data):
for _ in hrange(3):
start_index = data.index
value = data.draw(self.filtered_strategy)
if self.condition(value):
return value
else:
# This is to guard against the case where we consume no data.
# As long as we consume data, we'll eventually pass or raise.
# But if we don't this could be an infinite loop.
assume(data.index > start_index)
data.mark_invalid()
def do_draw(self, data):
for _ in hrange(3):
start_index = data.index
value = data.draw(self.filtered_strategy)
if self.condition(value):
return value
else:
# This is to guard against the case where we consume no data.
# As long as we consume data, we'll eventually pass or raise.
# But if we don't this could be an infinite loop.
assume(data.index > start_index)
data.mark_invalid()
def reify(self, template):
tz = template[-1]
d = dt.datetime(
year=template[0], month=template[1], day=template[2],
hour=template[3], minute=template[4], second=template[5],
microsecond=template[6]
)
if tz:
try:
d = pytz.timezone(tz).localize(d)
except OverflowError:
assume(False)
return d
def do_draw(self, data):
def draw_float_bytes(random, n):
assert n == 8
i = random.randint(0, 20)
if i <= 2:
f = random.choice(self.critical)
else:
f = random.random() * (self.upper_bound - self.lower_bound) + self.lower_bound
return struct.pack(b"!d", f)
f = struct.unpack(b"!d", bytes(data.draw_bytes(8, draw_float_bytes)))[0]
assume(self.lower_bound <= f <= self.upper_bound)
assume(sign(self.lower_bound) <= sign(f) <= sign(self.upper_bound))
return f
def default_do_filtered_draw(self, data):
for i in hrange(3):
start_index = data.index
value = data.draw(self.filtered_strategy)
if self.condition(value):
return value
else:
if i == 0:
self.note_retried(data)
# This is to guard against the case where we consume no data.
# As long as we consume data, we'll eventually pass or raise.
# But if we don't this could be an infinite loop.
assume(data.index > start_index)
return filter_not_satisfied
def default_do_filtered_draw(self, data):
for i in hrange(3):
start_index = data.index
value = data.draw(self.filtered_strategy)
if self.condition(value):
return value
else:
if i == 0:
self.note_retried(data)
# This is to guard against the case where we consume no data.
# As long as we consume data, we'll eventually pass or raise.
# But if we don't this could be an infinite loop.
assume(data.index > start_index)
return filter_not_satisfied
def do_draw(self, data):
def draw_float_bytes(random, n):
assert n == 8
i = random.randint(0, 20)
if i <= 2:
f = random.choice(self.critical)
else:
f = random.random() * (self.upper_bound -
self.lower_bound) + self.lower_bound
return struct.pack(b'!d', f)
f = struct.unpack(b'!d', bytes(data.draw_bytes(8,
draw_float_bytes)))[0]
assume(self.lower_bound <= f <= self.upper_bound)
assume(sign(self.lower_bound) <= sign(f) <= sign(self.upper_bound))
return f
def default_do_filtered_draw(self, data):
for i in range(3):
start_index = data.index
data.start_example(FILTERED_SEARCH_STRATEGY_DO_DRAW_LABEL)
value = data.draw(self.filtered_strategy)
if self.condition(value):
data.stop_example()
return value
else:
data.stop_example(discard=True)
if i == 0:
self.note_retried(data)
# This is to guard against the case where we consume no data.
# As long as we consume data, we'll eventually pass or raise.
# But if we don't this could be an infinite loop.
assume(data.index > start_index)
return filter_not_satisfied
def do_draw(self, data):
for i in hrange(3):
start_index = data.index
value = data.draw(self.filtered_strategy)
if self.condition(value):
return value
else:
if i == 0:
data.note_event(lazyformat(
'Retried draw from %r to satisfy filter', self,))
# This is to guard against the case where we consume no data.
# As long as we consume data, we'll eventually pass or raise.
# But if we don't this could be an infinite loop.
assume(data.index > start_index)
data.note_event('Aborted test because unable to satisfy %r' % (
self,
))
data.mark_invalid()
def do_draw(self, data):
for i in hrange(3):
start_index = data.index
value = data.draw(self.filtered_strategy)
if self.condition(value):
return value
else:
if i == 0:
data.note_event(deferredformat(
'Retried draw from %r to satisfy filter', self,))
# This is to guard against the case where we consume no data.
# As long as we consume data, we'll eventually pass or raise.
# But if we don't this could be an infinite loop.
assume(data.index > start_index)
data.note_event('Aborted test because unable to satisfy %r' % (
self,
))
data.mark_invalid()
def reify(self, template):
assume(self.min_year <= template.year <= self.max_year)
tz = template[-1]
if tz is None:
assume(self.allow_naive)
else:
assume(template.tzinfo in self.timezones)
try:
return template.to_datetime()
except (OverflowError, ValueError):
assume(False)
def reify(self, template):
assume(self.min_year <= template.year <= self.max_year)
tz = template[-1]
if tz is None:
assume(self.allow_naive)
else:
assume(template.tzinfo in self.timezones)
try:
return template.to_datetime()
except (OverflowError, ValueError):
assume(False)
def do_draw(self, data):
# type: (ConjectureData) -> Ex
for i in hrange(3):
start_index = data.index
value = data.draw(self.filtered_strategy)
if self.condition(value):
return value
else:
if i == 0:
data.note_event(
lazyformat("Retried draw from %r to satisfy filter",
self))
# This is to guard against the case where we consume no data.
# As long as we consume data, we'll eventually pass or raise.
# But if we don't this could be an infinite loop.
assume(data.index > start_index)
data.note_event("Aborted test because unable to satisfy %r" % (self, ))
data.mark_invalid()
raise AssertionError("Unreachable, for Mypy") # pragma: no cover
def do_draw(self, data):
# type: (ConjectureData) -> Ex
for i in hrange(3):
start_index = data.index
value = data.draw(self.filtered_strategy)
if self.condition(value):
return value
else:
if i == 0:
data.note_event(lazyformat(
'Retried draw from %r to satisfy filter', self,))
# This is to guard against the case where we consume no data.
# As long as we consume data, we'll eventually pass or raise.
# But if we don't this could be an infinite loop.
assume(data.index > start_index)
data.note_event('Aborted test because unable to satisfy %r' % (
self,
))
data.mark_invalid()
raise AssertionError('Unreachable, for Mypy') # pragma: no cover
def reify(self, template):
assert self.min_size <= template.size <= self.max_size
if template.values is not None:
assert len(template.values) == template.size
seen = set()
result = []
for t in template.values:
v = self.elements.reify(t)
k = self.key(v)
assume(k not in seen)
seen.add(k)
result.append(v)
assert len(result) == len(template.values)
return result
values = []
results = []
seen = set()
random = Random(template.template_seed)
for i in range(template.size * 10):
assert len(values) < template.size
try:
eltemplate = self.elements.draw_template(
random, template.parameter)
except BadTemplateDraw: # pragma: no cover
continue
elvalue = self.elements.reify(eltemplate)
k = self.key(elvalue)
if k in seen:
continue
seen.add(k)
values.append(eltemplate)
results.append(elvalue)
if len(results) == template.size:
template.values = values
return results
assume(len(results) >= self.min_size)
template.values = values
template.size = len(results)
return results
def reify(self, template):
assert self.min_size <= template.size <= self.max_size
if template.values is not None:
assert len(template.values) == template.size
seen = set()
result = []
for t in template.values:
v = self.elements.reify(t)
k = self.key(v)
assume(k not in seen)
seen.add(k)
result.append(v)
assert len(result) == len(template.values)
return result
values = []
results = []
seen = set()
random = Random(template.template_seed)
for i in range(template.size * 10):
assert len(values) < template.size
try:
eltemplate = self.elements.draw_template(
random, template.parameter)
except BadTemplateDraw:
continue
elvalue = self.elements.reify(eltemplate)
k = self.key(elvalue)
if k in seen:
continue
seen.add(k)
values.append(eltemplate)
results.append(elvalue)
if len(results) == template.size:
template.values = values
return results
assume(len(results) >= self.min_size)
template.values = values
template.size = len(results)
return results
def template_condition(template):
result = search.reify(template)
success = condition(result)
if success:
successful_examples[0] += 1
if not successful_examples[0]:
verbose_report(lambda: 'Trying example %s' % (show(result), ))
elif success:
if successful_examples[0] == 1:
verbose_report(lambda: 'Found satisfying example %s' %
(show(result), ))
else:
verbose_report(lambda: 'Shrunk example to %s' %
(show(result), ))
return assume(success)
def template_condition(template):
result = search.reify(template)
success = condition(result)
if success:
successful_examples[0] += 1
if not successful_examples[0]:
verbose_report(lambda: 'Trying example %s' % (
show(result),
))
elif success:
if successful_examples[0] == 1:
verbose_report(lambda: 'Found satisfying example %s' % (
show(result),
))
else:
verbose_report(lambda: 'Shrunk example to %s' % (
show(result),
))
return assume(success)
def pack(self, value):
assume(self.condition(value))
return value
def template_condition(template):
return assume(condition(search.reify(template)))
def do_draw(self, data):
block = data.draw_bytes(self.block_size, self.distribution)
assert len(block) == self.block_size
value = self.from_bytes(block)
assume(self.is_acceptable(value))
return value
def floats(
min_value=None, max_value=None, allow_nan=None, allow_infinity=None
):
"""Returns a strategy which generates floats.
- If min_value is not None, all values will be >= min_value.
- If max_value is not None, all values will be <= max_value.
- If min_value or max_value is not None, it is an error to enable
allow_nan.
- If both min_value and max_value are not None, it is an error to enable
allow_infinity.
Where not explicitly ruled out by the bounds, all of infinity, -infinity
and NaN are possible values generated by this strategy.
"""
if allow_nan is None:
allow_nan = bool(min_value is None and max_value is None)
elif allow_nan:
if min_value is not None or max_value is not None:
raise InvalidArgument(
u'Cannot have allow_nan=%r, with min_value or max_value' % (
allow_nan
))
check_valid_bound(min_value, u'min_value')
check_valid_bound(max_value, u'max_value')
check_valid_interval(min_value, max_value, u'min_value', u'max_value')
if min_value is not None:
min_value = float(min_value)
if max_value is not None:
max_value = float(max_value)
if min_value == float(u'-inf'):
min_value = None
if max_value == float(u'inf'):
max_value = None
if allow_infinity is None:
allow_infinity = bool(min_value is None or max_value is None)
elif allow_infinity:
if min_value is not None and max_value is not None:
raise InvalidArgument(
u'Cannot have allow_infinity=%r, with both min_value and '
u'max_value' % (
allow_infinity
))
from hypothesis.searchstrategy.numbers import WrapperFloatStrategy, \
GaussianFloatStrategy, BoundedFloatStrategy, ExponentialFloatStrategy,\
JustIntFloats, NastyFloats, FullRangeFloats, \
FixedBoundedFloatStrategy
if min_value is None and max_value is None:
return WrapperFloatStrategy(
GaussianFloatStrategy() |
BoundedFloatStrategy() |
ExponentialFloatStrategy() |
JustIntFloats() |
NastyFloats(allow_nan, allow_infinity) |
FullRangeFloats(allow_nan, allow_infinity)
)
elif min_value is not None and max_value is not None:
if min_value == max_value:
return just(min_value)
elif math.isinf(max_value - min_value):
assert min_value < 0 and max_value > 0
return floats(min_value=0, max_value=max_value) | floats(
min_value=min_value, max_value=0
)
elif count_between_floats(min_value, max_value) > 1000:
critical_values = [
min_value, max_value, min_value + (max_value - min_value) / 2]
if min_value <= 0 <= max_value:
if not is_negative(max_value):
critical_values.append(0.0)
if is_negative(min_value):
critical_values.append(-0.0)
return FixedBoundedFloatStrategy(
lower_bound=min_value, upper_bound=max_value
) | sampled_from(critical_values)
elif is_negative(max_value):
assert is_negative(min_value)
ub_int = float_to_int(max_value)
lb_int = float_to_int(min_value)
assert ub_int <= lb_int
return integers(min_value=ub_int, max_value=lb_int).map(
int_to_float
)
elif is_negative(min_value):
return floats(min_value=min_value, max_value=-0.0) | floats(
min_value=0, max_value=max_value
)
else:
ub_int = float_to_int(max_value)
lb_int = float_to_int(min_value)
assert lb_int <= ub_int
return integers(min_value=lb_int, max_value=ub_int).map(
int_to_float
)
elif min_value is not None:
critical_values = [min_value]
if allow_infinity:
critical_values.append(float(u'inf'))
if is_negative(min_value):
critical_values.append(-0.0)
if min_value <= 0:
critical_values.append(0.0)
return (
floats(allow_infinity=allow_infinity, allow_nan=False).map(
lambda x: assume(not math.isnan(x)) and min_value + abs(x)
)
) | sampled_from(critical_values)
else:
assert max_value is not None
critical_values = [max_value]
if allow_infinity:
critical_values.append(float(u'-inf'))
if max_value >= 0:
critical_values.append(-0.0)
if not is_negative(max_value):
critical_values.append(0.0)
return (
floats(allow_infinity=allow_infinity, allow_nan=False).map(
lambda x: assume(not math.isnan(x)) and max_value - abs(x)
)
) | sampled_from(critical_values)
def floats(min_value=None, max_value=None):
"""Returns a strategy which generates floats. If min_value is not None,
all values will be >= min_value. If max_value is not None, all values will
be <= max_value.
Where not explicitly ruled out by the bounds, all of infinity, -infinity
and NaN are possible values generated by this strategy.
"""
for e in (min_value, max_value):
if e is not None and math.isnan(e):
raise InvalidArgument(u'nan is not a valid end point')
if min_value is not None:
min_value = float(min_value)
if max_value is not None:
max_value = float(max_value)
if min_value == float(u'-inf'):
min_value = None
if max_value == float(u'inf'):
max_value = None
from hypothesis.searchstrategy.numbers import WrapperFloatStrategy, \
GaussianFloatStrategy, BoundedFloatStrategy, ExponentialFloatStrategy,\
JustIntFloats, NastyFloats, FullRangeFloats, \
FixedBoundedFloatStrategy
if min_value is None and max_value is None:
return WrapperFloatStrategy(GaussianFloatStrategy()
| BoundedFloatStrategy()
| ExponentialFloatStrategy()
| JustIntFloats() | NastyFloats()
| FullRangeFloats())
elif min_value is not None and max_value is not None:
if max_value < min_value:
raise InvalidArgument(u'Cannot have max_value=%r < min_value=%r' %
(max_value, min_value))
elif min_value == max_value:
return just(min_value)
elif math.isinf(max_value - min_value):
assert min_value < 0 and max_value > 0
return floats(min_value=0, max_value=max_value) | floats(
min_value=min_value, max_value=0)
elif count_between_floats(min_value, max_value) > 1000:
critical_values = [
min_value, max_value, min_value + (max_value - min_value) / 2
]
if min_value <= 0 <= max_value:
if not is_negative(max_value):
critical_values.append(0.0)
if is_negative(min_value):
critical_values.append(-0.0)
return FixedBoundedFloatStrategy(
lower_bound=min_value,
upper_bound=max_value) | sampled_from(critical_values)
elif is_negative(max_value):
assert is_negative(min_value)
ub_int = float_to_int(max_value)
lb_int = float_to_int(min_value)
assert ub_int <= lb_int
return integers(min_value=ub_int,
max_value=lb_int).map(int_to_float)
elif is_negative(min_value):
return floats(min_value=min_value, max_value=-0.0) | floats(
min_value=0, max_value=max_value)
else:
ub_int = float_to_int(max_value)
lb_int = float_to_int(min_value)
assert lb_int <= ub_int
return integers(min_value=lb_int,
max_value=ub_int).map(int_to_float)
elif min_value is not None:
critical_values = [min_value, float(u'inf')]
if is_negative(min_value):
critical_values.append(-0.0)
if min_value <= 0:
critical_values.append(0.0)
return (floats().map(lambda x: assume(not math.isnan(x)) and min_value
+ abs(x))) | sampled_from(critical_values)
else:
assert max_value is not None
critical_values = [max_value, float(u'-inf')]
if max_value >= 0:
critical_values.append(-0.0)
if not is_negative(max_value):
critical_values.append(0.0)
return (floats().map(lambda x: assume(not math.isnan(x)) and max_value
- abs(x))) | sampled_from(critical_values)
def floats(min_value=None, max_value=None):
"""Returns a strategy which generates floats. If min_value is not None,
all values will be >= min_value. If max_value is not None, all values will
be <= max_value.
Where not explicitly ruled out by the bounds, all of infinity, -infinity
and NaN are possible values generated by this strategy.
"""
for e in (min_value, max_value):
if e is not None and math.isnan(e):
raise InvalidArgument(u'nan is not a valid end point')
if min_value is not None:
min_value = float(min_value)
if max_value is not None:
max_value = float(max_value)
if min_value == float(u'-inf'):
min_value = None
if max_value == float(u'inf'):
max_value = None
from hypothesis.searchstrategy.numbers import WrapperFloatStrategy, \
GaussianFloatStrategy, BoundedFloatStrategy, ExponentialFloatStrategy,\
JustIntFloats, NastyFloats, FullRangeFloats, \
FixedBoundedFloatStrategy
if min_value is None and max_value is None:
return WrapperFloatStrategy(
GaussianFloatStrategy() |
BoundedFloatStrategy() |
ExponentialFloatStrategy() |
JustIntFloats() |
NastyFloats() |
FullRangeFloats()
)
elif min_value is not None and max_value is not None:
if max_value < min_value:
raise InvalidArgument(
u'Cannot have max_value=%r < min_value=%r' % (
max_value, min_value
))
elif min_value == max_value:
return just(min_value)
elif math.isinf(max_value - min_value):
assert min_value < 0 and max_value > 0
return floats(min_value=0, max_value=max_value) | floats(
min_value=min_value, max_value=0
)
elif count_between_floats(min_value, max_value) > 1000:
critical_values = [
min_value, max_value, min_value + (max_value - min_value) / 2]
if min_value <= 0 <= max_value:
if not is_negative(max_value):
critical_values.append(0.0)
if is_negative(min_value):
critical_values.append(-0.0)
return FixedBoundedFloatStrategy(
lower_bound=min_value, upper_bound=max_value
) | sampled_from(critical_values)
elif is_negative(max_value):
assert is_negative(min_value)
ub_int = float_to_int(max_value)
lb_int = float_to_int(min_value)
assert ub_int <= lb_int
return integers(min_value=ub_int, max_value=lb_int).map(
int_to_float
)
elif is_negative(min_value):
return floats(min_value=min_value, max_value=-0.0) | floats(
min_value=0, max_value=max_value
)
else:
ub_int = float_to_int(max_value)
lb_int = float_to_int(min_value)
assert lb_int <= ub_int
return integers(min_value=lb_int, max_value=ub_int).map(
int_to_float
)
elif min_value is not None:
critical_values = [min_value, float(u'inf')]
if is_negative(min_value):
critical_values.append(-0.0)
if min_value <= 0:
critical_values.append(0.0)
return (
floats().map(
lambda x: assume(not math.isnan(x)) and min_value + abs(x)
)
) | sampled_from(critical_values)
else:
assert max_value is not None
critical_values = [max_value, float(u'-inf')]
if max_value >= 0:
critical_values.append(-0.0)
if not is_negative(max_value):
critical_values.append(0.0)
return (
floats().map(
lambda x: assume(not math.isnan(x)) and max_value - abs(x)
)
) | sampled_from(critical_values)
def pack(self, value):
assume(self.condition(value))
return value
def floats(
min_value=None, max_value=None, allow_nan=None, allow_infinity=None
):
"""Returns a strategy which generates floats.
- If min_value is not None, all values will be >= min_value.
- If max_value is not None, all values will be <= max_value.
- If min_value or max_value is not None, it is an error to enable
allow_nan.
- If both min_value and max_value are not None, it is an error to enable
allow_infinity.
Where not explicitly ruled out by the bounds, all of infinity, -infinity
and NaN are possible values generated by this strategy.
"""
if allow_nan is None:
allow_nan = bool(min_value is None and max_value is None)
elif allow_nan:
if min_value is not None or max_value is not None:
raise InvalidArgument(
'Cannot have allow_nan=%r, with min_value or max_value' % (
allow_nan
))
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')
if min_value is not None:
min_value = float(min_value)
if max_value is not None:
max_value = float(max_value)
if min_value == float(u'-inf'):
min_value = None
if max_value == float(u'inf'):
max_value = None
if allow_infinity is None:
allow_infinity = bool(min_value is None or max_value is None)
elif allow_infinity:
if min_value is not None and max_value is not None:
raise InvalidArgument(
'Cannot have allow_infinity=%r, with both min_value and '
'max_value' % (
allow_infinity
))
from hypothesis.searchstrategy.numbers import FloatStrategy, \
FixedBoundedFloatStrategy
if min_value is None and max_value is None:
return FloatStrategy(
allow_infinity=allow_infinity, allow_nan=allow_nan,
)
elif min_value is not None and max_value is not None:
if min_value == max_value:
return just(min_value)
elif math.isinf(max_value - min_value):
assert min_value < 0 and max_value > 0
return floats(min_value=0, max_value=max_value) | floats(
min_value=min_value, max_value=0
)
elif count_between_floats(min_value, max_value) > 1000:
return FixedBoundedFloatStrategy(
lower_bound=min_value, upper_bound=max_value
)
elif is_negative(max_value):
assert is_negative(min_value)
ub_int = float_to_int(max_value)
lb_int = float_to_int(min_value)
assert ub_int <= lb_int
return integers(min_value=ub_int, max_value=lb_int).map(
int_to_float
)
elif is_negative(min_value):
return floats(min_value=min_value, max_value=-0.0) | floats(
min_value=0, max_value=max_value
)
else:
ub_int = float_to_int(max_value)
lb_int = float_to_int(min_value)
assert lb_int <= ub_int
return integers(min_value=lb_int, max_value=ub_int).map(
int_to_float
)
elif min_value is not None:
if min_value < 0:
result = floats(
min_value=0.0
) | floats(min_value=min_value, max_value=0.0)
else:
result = (
floats(allow_infinity=allow_infinity, allow_nan=False).map(
lambda x: assume(not math.isnan(x)) and min_value + abs(x)
)
)
if min_value == 0 and not is_negative(min_value):
result = result.filter(lambda x: math.copysign(1.0, x) == 1)
return result
else:
assert max_value is not None
if max_value > 0:
result = floats(
min_value=0.0,
max_value=max_value,
) | floats(max_value=0.0)
else:
result = (
floats(allow_infinity=allow_infinity, allow_nan=False).map(
lambda x: assume(not math.isnan(x)) and max_value - abs(x)
)
)
if max_value == 0 and is_negative(max_value):
result = result.filter(is_negative)
return result
def splat(value):
try:
return target(*value[0], **value[1])
except InvalidArgument:
assume(False)
def template_condition(template):
return assume(condition(search.reify(template)))
def do_draw(self, data):
b = int_from_bytes(data.draw_bytes(2))
assume(b == 3)
print('ohai')
def test_insertInsertWeak(k1, v1, k2, v2, t):
control.assume(k1 != k2)
assert eqWeak(insert((k1, v1), insert((k2, v2), t)),
insert((k2, v2), insert((k1, v1), t)))
def test_deleteInsertWeak(k1, k2, v2, t):
control.assume(k1 != k2)
assert eqWeak(delete(k1, insert((k2, v2), t)),
insert((k2, v2), delete(k1, t)))
def trade(self, offer, buyer):
assume(offer.id in self.market.offers)
self.market.accept_offer(offer, buyer)
def do_draw(self, data):
b = int_from_bytes(data.draw_bytes(2))
assume(b == 3)
print('ohai')
def floats(min_value=None,
max_value=None,
allow_nan=None,
allow_infinity=None):
"""Returns a strategy which generates floats.
- If min_value is not None, all values will be >= min_value.
- If max_value is not None, all values will be <= max_value.
- If min_value or max_value is not None, it is an error to enable
allow_nan.
- If both min_value and max_value are not None, it is an error to enable
allow_infinity.
Where not explicitly ruled out by the bounds, all of infinity, -infinity
and NaN are possible values generated by this strategy.
"""
if allow_nan is None:
allow_nan = bool(min_value is None and max_value is None)
elif allow_nan:
if min_value is not None or max_value is not None:
raise InvalidArgument(
'Cannot have allow_nan=%r, with min_value or max_value' %
(allow_nan))
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')
if min_value is not None:
min_value = float(min_value)
if max_value is not None:
max_value = float(max_value)
if min_value == float(u'-inf'):
min_value = None
if max_value == float(u'inf'):
max_value = None
if allow_infinity is None:
allow_infinity = bool(min_value is None or max_value is None)
elif allow_infinity:
if min_value is not None and max_value is not None:
raise InvalidArgument(
'Cannot have allow_infinity=%r, with both min_value and '
'max_value' % (allow_infinity))
from hypothesis.searchstrategy.numbers import FloatStrategy, \
FixedBoundedFloatStrategy
if min_value is None and max_value is None:
return FloatStrategy(
allow_infinity=allow_infinity,
allow_nan=allow_nan,
)
elif min_value is not None and max_value is not None:
if min_value == max_value:
return just(min_value)
elif math.isinf(max_value - min_value):
assert min_value < 0 and max_value > 0
return floats(min_value=0, max_value=max_value) | floats(
min_value=min_value, max_value=0)
elif count_between_floats(min_value, max_value) > 1000:
return FixedBoundedFloatStrategy(lower_bound=min_value,
upper_bound=max_value)
elif is_negative(max_value):
assert is_negative(min_value)
ub_int = float_to_int(max_value)
lb_int = float_to_int(min_value)
assert ub_int <= lb_int
return integers(min_value=ub_int,
max_value=lb_int).map(int_to_float)
elif is_negative(min_value):
return floats(min_value=min_value, max_value=-0.0) | floats(
min_value=0, max_value=max_value)
else:
ub_int = float_to_int(max_value)
lb_int = float_to_int(min_value)
assert lb_int <= ub_int
return integers(min_value=lb_int,
max_value=ub_int).map(int_to_float)
elif min_value is not None:
if min_value < 0:
result = floats(min_value=0.0) | floats(min_value=min_value,
max_value=0.0)
else:
result = (floats(allow_infinity=allow_infinity,
allow_nan=False).map(lambda x: assume(
not math.isnan(x)) and min_value + abs(x)))
if min_value == 0 and not is_negative(min_value):
result = result.filter(lambda x: math.copysign(1.0, x) == 1)
return result
else:
assert max_value is not None
if max_value > 0:
result = floats(
min_value=0.0,
max_value=max_value,
) | floats(max_value=0.0)
else:
result = (floats(allow_infinity=allow_infinity,
allow_nan=False).map(lambda x: assume(
not math.isnan(x)) and max_value - abs(x)))
if max_value == 0 and is_negative(max_value):
result = result.filter(is_negative)
return result
def pack(self, value):
try:
result, _ = self.model.objects.get_or_create(**value)
return result
except IntegrityError:
assume(False)
def do_draw(self, data):
block = data.draw_bytes(self.block_size, self.distribution)
assert len(block) == self.block_size
value = self.from_bytes(block)
assume(self.is_acceptable(value))
return value