def example_generator(ex: ArgsKwargsType) -> None:
for validator in validators:
try:
validator(*ex[0], **ex[1])
except Exception:
hypothesis.reject()
examples.append(ex)
def test_arbitrary_data_frames(data):
columns = data.draw(st.lists(
column_strategy(),
unique_by=lambda c: c.name if c.name is not None else float('nan')
))
try:
df = data.draw(pdst.data_frames(columns))
except Exception as e:
if type(e).__name__ == 'OutOfBoundsDatetime':
# See https://github.com/HypothesisWorks/hypothesis-python/pull/826
reject()
else:
raise
data_frame_columns = list(df)
assert len(data_frame_columns) == len(columns)
for i, (c, n) in enumerate(zip(columns, df)):
if c.name is None:
assert n == i
else:
assert c.name == n
for i, c in enumerate(columns):
column_name = data_frame_columns[i]
values = df[column_name]
if c.unique:
assert len(set(values)) == len(values)
def test_parse_duration_input(
hours,
minutes,
seconds,
):
"""Assert time input parsing is correct."""
wanted_seconds = 0
input_str = ""
if hours is None:
hours = 0
if minutes is None:
minutes = 0
if seconds is None:
seconds = 0
input_str += f"{hours}h"
input_str += f"{minutes}m"
input_str += f"{seconds}s"
total_seconds = (60.0 * 60 * hours + 60 * minutes + seconds)
try:
assert meditate.parse_duration_input(
input_str=input_str, ) == total_seconds
except meditate.DurationConfigurationException as e:
reject()
def test_no_exceptions(
source_code,
default_options,
parse_ast_tree,
parse_tokens,
):
"""
This testcase is a complex example of magic.
We use property based-test to generate python programs for us.
And then we ensure that our linter does not crash on arbitary input.
"""
try:
tree = parse_ast_tree(str(source_code.encode('utf-8-sig')))
except (UnicodeEncodeError, SyntaxError):
reject()
raise
lines = io.StringIO(source_code)
tokens = list(tokenize.generate_tokens(lambda: next(lines)))
Checker.parse_options(default_options)
checker = Checker(tree, tokens)
for violation in checker.run():
assert isinstance(violation[0], int)
assert isinstance(violation[1], int)
assert violation[2].startswith('WPS'), violation[2]
assert 'WPS0' not in violation[2]
assert violation[3] == Checker
def test_arbitrary_data_frames(data):
columns = data.draw(
st.lists(
column_strategy(),
unique_by=lambda c: c.name if c.name is not None else float("nan"),
)
)
try:
df = data.draw(pdst.data_frames(columns))
except Exception as e:
if type(e).__name__ == "OutOfBoundsDatetime":
# See https://github.com/HypothesisWorks/hypothesis-python/pull/826
reject()
else:
raise
data_frame_columns = list(df)
assert len(data_frame_columns) == len(columns)
for i, (c, n) in enumerate(zip(columns, df)):
if c.name is None:
assert n == i
else:
assert c.name == n
for i, c in enumerate(columns):
column_name = data_frame_columns[i]
values = df[column_name]
if c.unique:
assert len(set(values)) == len(values)
def test_compression_is_invertible(self, string):
# not ready for unicode
if any(ord(x) > 255 or ord(x) & 0x80 for x in string):
reject()
# can't have null terminated string
if any(ord(x) == 0x00 for x in string):
reject()
assume(len(string) > 0 and len(string) < 100)
length = len(string)
original = (ctypes.c_uint8 * length)()
out = (ctypes.c_uint8 * length)()
for i, x in enumerate(string):
original[i] = ord(x)
compressor = Compressor(compressor_successor_table, packs)
decompressor = Decompressor(decompressor_successor_table, packs, min_char)
out_length = compressor.compress(original, length, out, length)
assert out_length <= length
out2 = (ctypes.c_uint8 * length)()
out2_length = decompressor.decompress(out, out_length, out2, length)
final = ""
for i in range(out2_length):
final += chr(out2[i])
assert out2_length == length
assert final == string
def test_convert_python_file_to_module_qualname(project_root_path,
python_file):
#try:
if any(x in project_root_path
for x in ("+", ")", "(", "[", "]", "-", "*", "$", "?")):
reject()
convert_python_file_to_module_qualname(project_root_path, python_file)
def test_fuzz_hanging_indent_with_parentheses(
statement,
imports,
white_space,
indent,
line_length,
comments,
line_separator,
comment_prefix,
include_trailing_comma,
remove_comments,
):
try:
isort.wrap_modes.hanging_indent_with_parentheses(
statement=statement,
imports=imports,
white_space=white_space,
indent=indent,
line_length=line_length,
comments=comments,
line_separator=line_separator,
comment_prefix=comment_prefix,
include_trailing_comma=include_trailing_comma,
remove_comments=remove_comments,
)
except ValueError:
reject()
def test_reusable_strategies_are_all_reusable(s):
try:
s.validate()
except InvalidArgument:
reject()
assert s.has_reusable_values
def test_reusable_strategies_are_all_reusable(s):
try:
s.validate()
except InvalidArgument:
reject()
assert s.has_reusable_values
def reject_invalid_code(source_code: str, mode: str) -> None:
"""Input validation helper shared by modules, statements, and expressions."""
# We start by compiling our source code to byte code, and rejecting inputs
# where this fails. This is to guard against spurious failures due to
# e.g. `eval` only being a keyword in Python 3.7
assert mode in {"eval", "exec", "single"}
hypothesis.note(source_code)
try:
compile(source_code, "<string>", mode)
except Exception:
# We're going to check here that libCST also rejects this string.
# If libCST parses it's a test failure; if not we reject this input
# so Hypothesis spends as little time as possible exploring invalid
# code. (usually I'd use a custom mutator, but this is free so...)
parser = dict(
eval=libcst.parse_expression,
exec=libcst.parse_module,
single=libcst.parse_statement,
)
try:
tree = parser[mode](source_code)
msg = f"libCST parsed a string rejected by compile() into {tree!r}"
assert False, msg
except Exception:
hypothesis.reject()
assert False, "unreachable"
def test_fuzz_vertical_prefix_from_module_import(
statement,
imports,
white_space,
indent,
line_length,
comments,
line_separator,
comment_prefix,
include_trailing_comma,
remove_comments,
):
try:
isort.wrap_modes.vertical_prefix_from_module_import(
statement=statement,
imports=imports,
white_space=white_space,
indent=indent,
line_length=line_length,
comments=comments,
line_separator=line_separator,
comment_prefix=comment_prefix,
include_trailing_comma=include_trailing_comma,
remove_comments=remove_comments,
)
except ValueError:
reject()
def test_fuzz_floats_bounds(data):
bound = none() | floats(allow_nan=False)
low, high = data.draw(tuples(bound, bound), label="low, high")
if low is not None and high is not None and low > high:
low, high = high, low
exmin = low is not None and low != inf and data.draw(booleans(),
label="ex_min")
exmax = high is not None and high != -inf and data.draw(booleans(),
label="ex_max")
try:
val = data.draw(floats(low, high, exclude_min=exmin,
exclude_max=exmax),
label="value")
assume(val) # positive/negative zero is an issue
except (InvalidArgument, HypothesisDeprecationWarning):
assert ((exmin and exmax and low == next_down(high))
or (low == high and (exmin or exmax))
or (low == high == 0 and copysign(1.0, low) == 1
and copysign(1.0, high) == -1))
reject() # no floats in required range
if low is not None:
assert low <= val
if high is not None:
assert val <= high
if exmin:
assert low != val
if exmax:
assert high != val
def setup(self, filename):
mock_process = MagicMock()
try:
self.running_bag = prb.BagPlayer(filename)
except prb.MissingBagError:
hyp.reject()
self.running_bag.process = mock_process
def test_always_reduces_integers_to_smallest_suitable_sizes(problem):
n, blob = problem
blob = hbytes(blob)
try:
d = ConjectureData.for_buffer(blob)
k = d.draw(st.integers())
stop = blob[len(d.buffer)]
except (StopTest, IndexError):
reject()
assume(k > n)
assume(stop > 0)
def f(data):
k = data.draw(st.integers())
data.output = repr(k)
if data.draw_bits(8) == stop and k >= n:
data.mark_interesting()
runner = ConjectureRunner(
f,
random=Random(0),
settings=settings(
suppress_health_check=HealthCheck.all(),
phases=(Phase.shrink, ),
database=None,
verbosity=Verbosity.debug,
),
database_key=None,
)
runner.cached_test_function(blob)
assert runner.interesting_examples
v, = runner.interesting_examples.values()
shrinker = runner.new_shrinker(v, lambda x: x.status == Status.INTERESTING)
shrinker.fixate_shrink_passes(["minimize_individual_blocks"])
v = shrinker.shrink_target
m = ConjectureData.for_buffer(v.buffer).draw(st.integers())
assert m == n
# Upper bound on the length needed is calculated as follows:
# * We have an initial byte at the beginning to decide the length of the
# integer.
# * We have a terminal byte as the stop value.
# * The rest is the integer payload. This should be n. Including the sign
# bit, n needs (1 + n.bit_length()) / 8 bytes (rounded up). But we only
# have power of two sizes, so it may be up to a factor of two more than
# that.
bits_needed = 1 + n.bit_length()
actual_bits_needed = min(
[s for s in WideRangeIntStrategy.sizes if s >= bits_needed])
bytes_needed = actual_bits_needed // 8
# 3 extra bytes: two for the sampler, one for the capping value.
assert len(v.buffer) == 3 + bytes_needed
def test_arbitrary_data_frames(data):
columns = data.draw(
st.lists(
column_strategy(),
unique_by=lambda c: c.name if c.name is not None else float("nan"),
)
)
try:
# Use raw data to work around pandas bug in repr. See
# https://github.com/pandas-dev/pandas/issues/27484
df = data.conjecture_data.draw(pdst.data_frames(columns))
except Exception as e:
if type(e).__name__ == "OutOfBoundsDatetime":
# See https://github.com/HypothesisWorks/hypothesis-python/pull/826
reject()
else:
raise
data_frame_columns = list(df)
assert len(data_frame_columns) == len(columns)
for i, (c, n) in enumerate(zip(columns, df)):
if c.name is None:
assert n == i
else:
assert c.name == n
for i, c in enumerate(columns):
column_name = data_frame_columns[i]
values = df[column_name]
if c.unique:
assert len(set(values)) == len(values)
def test_reusable_strategies_are_all_reusable(s):
try:
s.validate()
except (InvalidArgument, HypothesisDeprecationWarning):
reject()
assert s.has_reusable_values
def test_minmax_magnitude_equal(data, mag):
val = data.draw(st.complex_numbers(min_magnitude=mag, max_magnitude=mag))
try:
assert math.isclose(abs(val), mag)
except OverflowError:
reject()
except AttributeError:
pass # Python 2.7.3 does not have math.isclose
def test_minmax_magnitude_equal(data, mag):
val = data.draw(st.complex_numbers(min_magnitude=mag, max_magnitude=mag))
try:
# Cap magnitude at 10e300 to avoid float overflow, and imprecision
# at very large exponents (which makes math.isclose fail)
assert math.isclose(abs(val), mag)
except OverflowError:
reject()
def arrays(draw, type, size=None):
if isinstance(type, st.SearchStrategy):
type = draw(type)
elif not isinstance(type, pa.DataType):
raise TypeError('Type must be a pyarrow DataType')
if isinstance(size, st.SearchStrategy):
size = draw(size)
elif size is None:
size = draw(_default_array_sizes)
elif not isinstance(size, int):
raise TypeError('Size must be an integer')
shape = (size, )
if pa.types.is_list(type):
offsets = draw(npst.arrays(np.uint8(), shape=shape)).cumsum() // 20
offsets = np.insert(offsets, 0, 0, axis=0) # prepend with zero
values = draw(arrays(type.value_type, size=int(offsets.sum())))
return pa.ListArray.from_arrays(offsets, values)
if pa.types.is_struct(type):
h.assume(len(type) > 0)
names, child_arrays = [], []
for field in type:
names.append(field.name)
child_arrays.append(draw(arrays(field.type, size=size)))
# fields' metadata are lost here, because from_arrays doesn't accept
# a fields argumentum, only names
return pa.StructArray.from_arrays(child_arrays, names=names)
if (pa.types.is_boolean(type) or pa.types.is_integer(type)
or pa.types.is_floating(type)):
values = npst.arrays(type.to_pandas_dtype(), shape=(size, ))
return pa.array(draw(values), type=type)
if pa.types.is_null(type):
value = st.none()
elif pa.types.is_time(type):
value = st.times()
elif pa.types.is_date(type):
value = st.dates()
elif pa.types.is_timestamp(type):
tz = pytz.timezone(type.tz) if type.tz is not None else None
value = st.datetimes(timezones=st.just(tz))
elif pa.types.is_binary(type):
value = st.binary()
elif pa.types.is_string(type):
value = st.text()
elif pa.types.is_decimal(type):
# TODO(kszucs): properly limit the precision
# value = st.decimals(places=type.scale, allow_infinity=False)
h.reject()
else:
raise NotImplementedError(type)
values = st.lists(value, min_size=size, max_size=size)
return pa.array(draw(values), type=type)
def test_minmax_magnitude_equal(data, mag):
val = data.draw(st.complex_numbers(min_magnitude=mag, max_magnitude=mag))
try:
assume(abs(val) < float('inf'))
assert math.isclose(abs(val), mag)
except OverflowError:
reject()
except AttributeError:
pass # Python 2.7.3 does not have math.isclose
def test_enter_returns_self(self, filenames):
with patch.object(prb, "time", autospec=True):
try:
raw_bag = prb.Bag(filenames)
with prb.Bag(filenames) as context_bag:
assert context_bag.filenames == raw_bag.filenames
assert context_bag.process == raw_bag.process
except prb.MissingBagError:
hyp.reject()
def test_builtin_works_on_many_examples(source_code):
try:
source = source_code.encode('utf-8-sig')
except UnicodeEncodeError:
reject()
raise
tree = ast.parse(source)
checker = BuiltinsChecker(tree, '/home/script.py')
assert isinstance([c for c in checker.run()], list)
def test_always_reduces_integers_to_smallest_suitable_sizes(problem):
n, blob = problem
blob = hbytes(blob)
try:
d = ConjectureData.for_buffer(blob)
k = d.draw(st.integers())
stop = blob[len(d.buffer)]
except (StopTest, IndexError):
reject()
assume(k > n)
assume(stop > 0)
def f(data):
k = data.draw(st.integers())
data.output = repr(k)
if data.draw_bits(8) == stop and k >= n:
data.mark_interesting()
runner = ConjectureRunner(f, random=Random(0), settings=settings(
suppress_health_check=HealthCheck.all(), timeout=unlimited,
phases=(Phase.shrink,), database=None, verbosity=Verbosity.debug
), database_key=None)
runner.test_function(ConjectureData.for_buffer(blob))
assert runner.interesting_examples
v, = runner.interesting_examples.values()
shrinker = runner.new_shrinker(v, lambda x: x.status == Status.INTERESTING)
shrinker.clear_passes()
shrinker.add_new_pass('minimize_individual_blocks')
shrinker.shrink()
v = shrinker.shrink_target
m = ConjectureData.for_buffer(v.buffer).draw(st.integers())
assert m == n
# Upper bound on the length needed is calculated as follows:
# * We have an initial byte at the beginning to decide the length of the
# integer.
# * We have a terminal byte as the stop value.
# * The rest is the integer payload. This should be n. Including the sign
# bit, n needs (1 + n.bit_length()) / 8 bytes (rounded up). But we only
# have power of two sizes, so it may be up to a factor of two more than
# that.
bits_needed = 1 + n.bit_length()
actual_bits_needed = min(
[s for s in WideRangeIntStrategy.sizes if s >= bits_needed])
bytes_needed = actual_bits_needed // 8
# 3 extra bytes: two for the sampler, one for the capping value.
assert len(v.buffer) == 3 + bytes_needed
def test_fuzz_show_unified_diff(file_input, file_output, file_path, output):
try:
isort.format.show_unified_diff(
file_input=file_input,
file_output=file_output,
file_path=file_path,
output=output,
)
except UnicodeEncodeError:
reject()
def test_decoding_may_fail(t):
try:
decode_failure(t)
reject()
except UnsatisfiedAssumption:
raise # don't silence the reject()
except InvalidArgument:
pass
except Exception as e:
assert False, 'decoding failed with %r, not InvalidArgument' % (e,)
def test_decoding_may_fail(t):
try:
decode_failure(t)
reject()
except UnsatisfiedAssumption:
raise # don't silence the reject()
except InvalidArgument:
pass
except Exception as e:
raise AssertionError("Expected an InvalidArgument exception") from e
def test_fuzz_add_to_line(comments, original_string, removed, comment_prefix):
try:
isort.comments.add_to_line(
comments=comments,
original_string=original_string,
removed=removed,
comment_prefix=comment_prefix,
)
except ValueError:
reject()
def test_generated_data_matches_schema(schema_strategy, data):
"""Check that an object drawn from an arbitrary schema is valid."""
schema = data.draw(schema_strategy)
try:
value = data.draw(from_schema(schema), "value from schema")
except InvalidArgument:
reject()
jsonschema.validate(value, schema)
# This checks that our canonicalisation is semantically equivalent.
jsonschema.validate(value, canonicalish(schema))
def test_decoding_may_fail(t):
try:
decode_failure(t)
reject()
except UnsatisfiedAssumption:
raise # don't silence the reject()
except InvalidArgument:
pass
except Exception as e:
assert False, "decoding failed with %r, not InvalidArgument" % (e, )
def cant_serialize(media_type: str) -> NoReturn: # type: ignore
"""Reject the current example if we don't know how to send this data to the application."""
event_text = f"Can't serialize data to `{media_type}`."
note(
f"{event_text}. "
f"You can register your own serializer with `schemathesis.serializers.register` and Schemathesis will be able "
f"to make API calls with this media type."
)
event(event_text)
reject() # type: ignore
def test_minmax_magnitude_equal(data, mag):
val = data.draw(st.complex_numbers(min_magnitude=mag, max_magnitude=mag))
try:
# Cap magnitude at 10e300 to avoid float overflow, and imprecision
# at very large exponents (which makes math.isclose fail)
assert math.isclose(abs(val), mag)
except OverflowError:
reject()
except AttributeError:
pass # Python 2.7.3 does not have math.isclose
def test_query_hypothesis_with_real_url(query):
print("running test_query_hyphotesis_for_query_api()")
try:
response = query_api(query)
if len(response) > 0:
assert response == 'http://api.skywatch.co/?types=star&vmag=gt0'
else:
assert response == ""
except Exception as e:
reject()
def test(x):
try:
i = next(testit)
except StopIteration:
return
if i == 1:
return
elif i == 2:
reject()
else:
raise Nope()
def _wrap(self, test_func: F) -> F:
def wrapper(case: ArgsKwargsType, *args, **kwargs) -> None:
ex = case
__tracebackhide__ = True
for validator in self.validators:
try:
validator(*ex[0], **ex[1])
except Exception:
hypothesis.reject()
case = self.make_case(*ex[0], **ex[1])
test_func(case, *args, **kwargs)
def test(x):
try:
i = next(testit)
except StopIteration:
return
if i == 1:
return
elif i == 2:
reject()
else:
raise Nope()
def test_tokenize_round_trip_bytes(source_code):
try:
source = source_code.encode("utf-8-sig")
except UnicodeEncodeError:
reject()
tokens = list(tokenize.tokenize(io.BytesIO(source).readline))
outbytes = tokenize.untokenize(
tokens) # may have changed whitespace from source
output = list(tokenize.tokenize(io.BytesIO(outbytes).readline))
assert [(t.type, t.string) for t in tokens] == [(t.type, t.string)
for t in output]
def test_fuzz_stuff(data):
pattern = data.draw(
st.text(min_size=1, max_size=5) |
st.binary(min_size=1, max_size=5) |
CONSERVATIVE_REGEX.filter(bool)
)
try:
regex = re.compile(pattern)
except re.error:
reject()
ex = data.draw(st.from_regex(regex))
assert regex.search(ex)
def test_generate_arbitrary_indices(data):
min_size = data.draw(st.integers(0, 10), "min_size")
max_size = data.draw(st.none() | st.integers(min_size, min_size + 10), "max_size")
unique = data.draw(st.booleans(), "unique")
dtype = data.draw(npst.scalar_dtypes(), "dtype")
assume(supported_by_pandas(dtype))
# Pandas bug: https://github.com/pandas-dev/pandas/pull/14916 until 0.20;
# then int64 indexes are inferred from uint64 values.
assume(dtype.kind != "u")
pass_elements = data.draw(st.booleans(), "pass_elements")
converted_dtype = pandas.Index([], dtype=dtype).dtype
try:
inferred_dtype = pandas.Index([data.draw(npst.from_dtype(dtype))]).dtype
if pass_elements:
elements = npst.from_dtype(dtype)
dtype = None
else:
elements = None
index = data.draw(
pdst.indexes(
elements=elements,
dtype=dtype,
min_size=min_size,
max_size=max_size,
unique=unique,
)
)
except Exception as e:
if type(e).__name__ == "OutOfBoundsDatetime":
# See https://github.com/HypothesisWorks/hypothesis-python/pull/826
reject()
else:
raise
if dtype is None:
if pandas.__version__ >= "0.19":
assert index.dtype == inferred_dtype
else:
assert index.dtype == converted_dtype
if unique:
assert len(set(index.values)) == len(index)
def test_floats_are_in_range(x, y, s):
assume(not (math.isnan(x) or math.isnan(y)))
assume(not (math.isinf(x) or math.isinf(y)))
x, y = sorted((x, y))
assume(x < y)
@given(floats(x, y))
@seed(s)
@settings(max_examples=10)
def test_is_in_range(t):
assert x <= t <= y
try:
test_is_in_range()
except Unsatisfiable:
reject()
def test_fuzz_fractions_bounds(data):
denom = data.draw(none() | integers(1, 100), label="denominator")
fracs = none() | fractions(max_denominator=denom)
low, high = data.draw(tuples(fracs, fracs), label="low, high")
if low is not None and high is not None and low > high:
low, high = high, low
try:
val = data.draw(fractions(low, high, denom), label="value")
except InvalidArgument:
reject() # fractions too close for given max_denominator
if low is not None:
assert low <= val
if high is not None:
assert val <= high
if denom is not None:
assert 1 <= val.denominator <= denom
def test_explore_arbitrary_function(strat, data):
cache = {}
def predicate(x):
try:
return cache[x]
except KeyError:
return cache.setdefault(x, data.draw(st.booleans(), label=repr(x)))
try:
find(
strat, predicate,
settings=settings(
database=None, verbosity=Verbosity.quiet, max_shrinks=1000)
)
except NoSuchExample:
reject()
def test_fuzz_decimals_bounds(data):
places = data.draw(none() | integers(0, 20), label='places')
finite_decs = decimals(allow_nan=False, allow_infinity=False,
places=places) | none()
low, high = data.draw(tuples(finite_decs, finite_decs), label='low, high')
if low is not None and high is not None and low > high:
low, high = high, low
ctx = decimal.Context(prec=data.draw(integers(1, 100), label='precision'))
try:
with decimal.localcontext(ctx):
strat = decimals(low, high, allow_nan=False,
allow_infinity=False, places=places)
val = data.draw(strat, label='value')
except InvalidArgument:
reject() # decimals too close for given places
if low is not None:
assert low <= val
if high is not None:
assert val <= high
if places is not None:
assert val.as_tuple().exponent == -places
def test_generate_arbitrary_indices(data):
min_size = data.draw(st.integers(0, 10), 'min_size')
max_size = data.draw(
st.none() | st.integers(min_size, min_size + 10), 'max_size')
unique = data.draw(st.booleans(), 'unique')
dtype = data.draw(npst.scalar_dtypes(), 'dtype')
assume(supported_by_pandas(dtype))
pass_elements = data.draw(st.booleans(), 'pass_elements')
converted_dtype = pandas.Index([], dtype=dtype).dtype
try:
inferred_dtype = pandas.Index(
[data.draw(npst.from_dtype(dtype))]).dtype
if pass_elements:
elements = npst.from_dtype(dtype)
dtype = None
else:
elements = None
index = data.draw(pdst.indexes(
elements=elements, dtype=dtype, min_size=min_size,
max_size=max_size, unique=unique,
))
except Exception as e:
if type(e).__name__ == 'OutOfBoundsDatetime':
# See https://github.com/HypothesisWorks/hypothesis-python/pull/826
reject()
else:
raise
if dtype is None:
assert index.dtype == inferred_dtype
else:
assert index.dtype == converted_dtype
if unique:
assert len(set(index.values)) == len(index)
def test_load_characters(filename):
try:
characters = load_characters(filename)
assert isinstance(characters, list)
except IOError:
reject()
def track(x):
count[0] += 1
reject()
def reuse_group(draw, group_name):
cache = draw(GROUP_CACHE_STRATEGY)
try:
return cache[group_name]
except KeyError:
reject()
def this_has_a_totally_unique_name(x):
calls[0] += 1
reject()
def _models_impl(draw, strat):
"""Handle the nasty part of drawing a value for models()"""
try:
return draw(strat)[0]
except IntegrityError:
reject()
def this_has_a_unique_name_and_lives_on_a_class(self, x):
reject()
def test_assume_false(x):
reject()
def arrays(draw, type, size=None):
if isinstance(type, st.SearchStrategy):
type = draw(type)
elif not isinstance(type, pa.DataType):
raise TypeError('Type must be a pyarrow DataType')
if isinstance(size, st.SearchStrategy):
size = draw(size)
elif size is None:
size = draw(_default_array_sizes)
elif not isinstance(size, int):
raise TypeError('Size must be an integer')
shape = (size,)
if pa.types.is_list(type):
offsets = draw(npst.arrays(np.uint8(), shape=shape)).cumsum() // 20
offsets = np.insert(offsets, 0, 0, axis=0) # prepend with zero
values = draw(arrays(type.value_type, size=int(offsets.sum())))
return pa.ListArray.from_arrays(offsets, values)
if pa.types.is_struct(type):
h.assume(len(type) > 0)
names, child_arrays = [], []
for field in type:
names.append(field.name)
child_arrays.append(draw(arrays(field.type, size=size)))
# fields' metadata are lost here, because from_arrays doesn't accept
# a fields argumentum, only names
return pa.StructArray.from_arrays(child_arrays, names=names)
if (pa.types.is_boolean(type) or pa.types.is_integer(type) or
pa.types.is_floating(type)):
values = npst.arrays(type.to_pandas_dtype(), shape=(size,))
np_arr = draw(values)
if pa.types.is_floating(type):
# Workaround ARROW-4952: no easy way to assert array equality
# in a NaN-tolerant way.
np_arr[np.isnan(np_arr)] = -42.0
return pa.array(np_arr, type=type)
if pa.types.is_null(type):
value = st.none()
elif pa.types.is_time(type):
value = st.times()
elif pa.types.is_date(type):
value = st.dates()
elif pa.types.is_timestamp(type):
tz = pytz.timezone(type.tz) if type.tz is not None else None
value = st.datetimes(timezones=st.just(tz))
elif pa.types.is_binary(type):
value = st.binary()
elif pa.types.is_string(type):
value = st.text()
elif pa.types.is_decimal(type):
# TODO(kszucs): properly limit the precision
# value = st.decimals(places=type.scale, allow_infinity=False)
h.reject()
else:
raise NotImplementedError(type)
values = st.lists(value, min_size=size, max_size=size)
return pa.array(draw(values), type=type)
def test_slow_test_times_out(x):
time.sleep(0.05)
reject()
def this_has_a_unique_name_and_lives_on_a_class(self, x):
calls2[0] += 1
reject()
def inner(*args, **kwargs):
try:
return contract_func(*args, **kwargs)
except PreconditionError:
reject()
def track(x):
tracker.add(x)
reject()
def nope(x):
reject()
def test(x):
reject()
def this_has_a_totally_unique_name(x):
reject()
def predicate(x):
reject()
