def test_groups(pattern, is_unicode, invert):
if u'd' in pattern.lower():
group_pred = is_digit
elif u'w' in pattern.lower():
group_pred = is_word
else:
# Special behaviour due to \x1c, INFORMATION SEPARATOR FOUR
group_pred = is_unicode_space if is_unicode else is_space
if invert:
pattern = pattern.swapcase()
_p = group_pred
def group_pred(s):
return not _p(s)
pattern = u'^%s\\Z' % (pattern,)
compiler = unicode_regex if is_unicode else ascii_regex
strategy = st.from_regex(compiler(pattern))
find_any(strategy.filter(group_pred), is_ascii)
if is_unicode:
find_any(strategy, lambda s: group_pred(s) and not is_ascii(s))
assert_all_examples(strategy, group_pred)
def test_groupref_exists():
assert_all_examples(
st.from_regex(u"^(<)?a(?(1)>)$"),
lambda s: s in (u"a", u"a\n", u"<a>", u"<a>\n"),
)
assert_all_examples(
st.from_regex(u"^(a)?(?(1)b|c)$"), lambda s: s in (u"ab", u"ab\n", u"c", u"c\n")
)
def test_groupref_exists():
assert_all_examples(
st.from_regex(u'^(<)?a(?(1)>)$'),
lambda s: s in (u'a', u'a\n', u'<a>', u'<a>\n')
)
assert_all_examples(
st.from_regex(u'^(a)?(?(1)b|c)$'),
lambda s: s in (u'ab', u'ab\n', u'c', u'c\n')
)
def test_step_stays_within_bounds(size):
# indices -> (start, stop, step)
# Stop is exclusive so we use -1 as the floor.
# This uses the indices that slice produces to make this test more readable
# due to how splice processes None being a little complex
assert_all_examples(
st.slices(size),
lambda x: (
x.indices(size)[0] + x.indices(size)[2] <= size
and x.indices(size)[0] + x.indices(size)[2] >= -1
)
or x.start == x.stop,
)
def test_can_generate(pattern, encode):
if encode:
pattern = pattern.encode('ascii')
assert_all_examples(st.from_regex(pattern), re.compile(pattern).search)
def test_timezone_lookup(type_):
assert issubclass(type_, datetime.tzinfo)
assert_all_examples(st.from_type(type_), lambda t: isinstance(t, type_))
def test_typevars_can_be_redefined():
"""We test that one can register a custom strategy for all type vars."""
A = typing.TypeVar("A")
with temp_registered(typing.TypeVar, st.just(1)):
assert_all_examples(st.from_type(A), lambda obj: obj == 1)
def test_fullmatch_matches(pattern, eqiv_pattern):
assert_all_examples(st.from_regex(pattern, fullmatch=True),
lambda s: re.match(eqiv_pattern, s))
def test_start_stay_within_bounds(size):
assert_all_examples(
st.slices(size), lambda x: x.start is None or (x.start >= 0 and x.start <= size)
)
def test_not_literal_with_ignorecase(pattern):
assert_all_examples(
st.from_regex(pattern),
lambda s: s[0] not in (u"a", u"A") and s[1] not in (u"b", u"B"),
)
def test_can_generate(pattern, encode):
if encode:
pattern = pattern.encode('ascii')
assert_all_examples(st.from_regex(pattern), re.compile(pattern).search)
def test_can_generate_integer_dtypes(xp, xps):
int_dtypes = [getattr(xp, name) for name in INT_NAMES]
assert_all_examples(xps.integer_dtypes(),
lambda dtype: dtype in int_dtypes)
def test_can_generate_numeric_dtypes(xp, xps):
numeric_dtypes = [getattr(xp, name) for name in NUMERIC_NAMES]
assert_all_examples(xps.numeric_dtypes(),
lambda dtype: dtype in numeric_dtypes)
def test_can_generate_boolean_dtypes(xp, xps):
assert_all_examples(xps.boolean_dtypes(), lambda dtype: dtype == xp.bool)
def test_can_generate_scalar_dtypes(xp, xps):
dtypes = [getattr(xp, name) for name in DTYPE_NAMES]
assert_all_examples(xps.scalar_dtypes(), lambda dtype: dtype in dtypes)
def test_any_doesnt_generate_newline():
assert_all_examples(st.from_regex(u"\\A.\\Z"), lambda s: s != u"\n")
def test_any_doesnt_generate_newline():
assert_all_examples(st.from_regex(u'.'), lambda s: s != u'\n')
def test_can_generate_unsigned_integer_dtypes(xp, xps):
uint_dtypes = [getattr(xp, name) for name in UINT_NAMES]
assert_all_examples(xps.unsigned_integer_dtypes(),
lambda dtype: dtype in uint_dtypes)
def test_groupref_exists():
assert_all_examples(st.from_regex(u'^(<)?a(?(1)>)$'), lambda s: s in
(u'a', u'a\n', u'<a>', u'<a>\n'))
assert_all_examples(st.from_regex(u'^(a)?(?(1)b|c)$'), lambda s: s in
(u'ab', u'ab\n', u'c', u'c\n'))
def test_can_generate_floating_dtypes(xp, xps):
float_dtypes = [getattr(xp, name) for name in FLOAT_NAMES]
assert_all_examples(xps.floating_dtypes(),
lambda dtype: dtype in float_dtypes)
def test_any_doesnt_generate_newline():
assert_all_examples(st.from_regex(u'.'), lambda s: s != u'\n')
def test_size_is_equal_0():
assert_all_examples(
st.slices(0), lambda x: x.step != 0 and x.start is None and x.stop is None
)
def test_can_handle_binary_regex_which_is_not_ascii():
bad = b'\xad'
assert_all_examples(st.from_regex(bad), lambda x: bad in x)
def test_generic_origin_concrete_builds():
with temp_registered(MyGeneric, st.builds(MyGeneric, st.integers())):
assert_all_examples(st.builds(using_generic),
lambda example: isinstance(example, int))
def test_fullmatch_matches(pattern, eqiv_pattern):
assert_all_examples(st.from_regex(pattern, fullmatch=True),
lambda s: re.match(eqiv_pattern, s))
def test_stop_stays_within_bounds(size):
assert_all_examples(
st.slices(size),
lambda x: x.stop is None or (x.stop >= 0 and x.stop <= size))
def test_generic_collections_only_use_hashable_elements(typ):
assert_all_examples(from_type(typ), lambda x: True)
def test_start_stay_within_bounds(size):
assert_all_examples(
st.slices(size),
lambda x: x.start is None or (x.start >= 0 and x.start <= size))
def test_typevars_can_be_redefine_with_factory():
"""We test that one can register a custom strategy for all type vars."""
A = typing.TypeVar("A")
with temp_registered(typing.TypeVar, lambda thing: st.just(thing.__name__)):
assert_all_examples(st.from_type(A), lambda obj: obj == "A")
def test_step_will_not_be_zero(size):
assert_all_examples(st.slices(size), lambda x: x.step != 0)
def test_cannot_generate_newaxis_when_disabled(xp, xps):
"""Strategy does not generate newaxis when disabled (i.e. the default)."""
assert_all_examples(xps.indices((3, 3, 3)), lambda idx: None not in idx)
def test_can_generate(pattern, encode):
if encode:
pattern = pattern.encode("ascii")
with local_settings(
settings(suppress_health_check=[HealthCheck.data_too_large])):
assert_all_examples(st.from_regex(pattern), re.compile(pattern).search)
def test_not_literal_with_ignorecase(pattern):
assert_all_examples(
st.from_regex(pattern), lambda s: s[0] not in
(u'a', u'A') and s[1] not in (u'b', u'B'))
def test_not_literal_with_ignorecase(pattern):
assert_all_examples(
st.from_regex(pattern),
lambda s: s[0] not in ("a", "A") and s[1] not in ("b", "B"),
)
def test_end_with_terminator_does_not_pad():
assert_all_examples(st.from_regex(u'abc\\Z'), lambda x: x[-3:] == u"abc")
def test_any_doesnt_generate_newline():
assert_all_examples(st.from_regex("\\A.\\Z"), lambda s: s != "\n")
def test_negative_lookbehind():
# no efficient support
strategy = st.from_regex(u'[abc]*(?<!abc)d')
assert_all_examples(strategy, lambda s: not s.endswith(u'abcd'))
assert_no_examples(strategy, lambda s: s.endswith(u'abcd'))
def test_end_with_terminator_does_not_pad():
assert_all_examples(st.from_regex(u'abc\Z'), lambda x: x[-3:] == u"abc")
def test_not_literal_with_ignorecase(pattern):
assert_all_examples(
st.from_regex(pattern),
lambda s: s[0] not in (u'a', u'A') and s[1] not in (u'b', u'B')
)
def test_negative_lookbehind():
# no efficient support
strategy = st.from_regex(u'[abc]*(?<!abc)d')
assert_all_examples(strategy, lambda s: not s.endswith(u'abcd'))
assert_no_examples(strategy, lambda s: s.endswith(u'abcd'))
def test_groupref_exists():
assert_all_examples(st.from_regex("^(<)?a(?(1)>)$"), lambda s: s in
("a", "a\n", "<a>", "<a>\n"))
assert_all_examples(st.from_regex("^(a)?(?(1)b|c)$"), lambda s: s in
("ab", "ab\n", "c", "c\n"))
def test_step_will_not_be_zero(size):
assert_all_examples(st.slices(size), lambda x: x.step != 0)
def test_negative_lookahead():
# no efficient support
strategy = st.from_regex("^ab(?!cd)[abcd]*")
assert_all_examples(strategy, lambda s: not s.startswith("abcd"))
assert_no_examples(strategy, lambda s: s.startswith("abcd"))
def test_can_handle_binary_regex_which_is_not_ascii():
bad = b"\xad"
assert_all_examples(st.from_regex(bad), lambda x: bad in x)
def test_negative_lookahead():
# no efficient support
strategy = st.from_regex(u'^ab(?!cd)[abcd]*')
assert_all_examples(strategy, lambda s: not s.startswith(u'abcd'))
assert_no_examples(strategy, lambda s: s.startswith(u'abcd'))
def test_does_not_left_pad_beginning_of_string_marker():
assert_all_examples(st.from_regex("\\Afoo"), lambda x: x.startswith("foo"))
def test_does_not_left_pad_beginning_of_string_marker():
assert_all_examples(
st.from_regex(u'\\Afoo'), lambda x: x.startswith(u'foo'))
def test_stop_stays_within_bounds(size):
assert_all_examples(
st.slices(size), lambda x: x.stop is None or (x.stop >= 0 and x.stop <= size)
)
