rule(target=a, a=st.integers())

rule(target=varied_floats, source=varied_floats, offset=integers(-100, 100))

rule(target=nodes, source=st.lists(nodes))

rule(target=nodes, source=lists(nodes))

rule(target=strategy_tuples, left=strategy_tuples, right=strategy_tuples)

rule(targets=(charges,), child=charges)

rule(target=b1)

initialize(target=buns)

stateful.rule(target=Stuff, name=st.text())

stateful.rule(target=Things, name=st.text())

rule(target=b2, consumed=consumes(b1))

rule(target=b)

rule(target=values, value=st.lists(values))

rule(target=strategies, source=strategies, level=integers(1, 10), mixer=text())

rule( target=strategies, source=strategies, result1=strategies, result2=strate

rule(target=varied_floats, source=floats())

rule(target=strategies, left=varied_floats, right=varied_floats)

rule(target=objects, strat=strategies, data=data())

rule(target=stuff)

initialize(targets=[bundles[name] for name in bundle_names])

initialize(target=data, value=integers())

initialize(target=a)

initialize(target=a, dep=just("dep"))

rule(target=strategies, left=integers(), right=integers())

rule(target=strategies, value=objects)

rule(target=keys, k=st.binary())

rule(target=keys, k=st.binary())

rule(target=keys, k=st.binary())

rule(target=keys, k=binary())

rule(target=trees, x=st.booleans())

rule(target=strategies, elements=strategies)

rule(key=st.integers(), score=st.integers(0, 100), target=keys)

settings(phases=[Phase.target, Phase.shrink, Phase.explain])

rule(targets=(charges,))

rule(target=strategies, left=strategies, right=strategies)

rule(targets=(b1, b2))

rule(target=b1)

rule(target=b, items=lists(elements=integers(), max_size=10))

rule(target=strategies, values=lists(integers() | text(), min_size=1))

initialize(target=my_bundle)

rule(target=strategy_tuples, source=strategies)

rule(target=trees, left=trees, right=trees)

rule( target=strategies, spec=sampled_from( ( integers(),

rule(target=strategies, spec=strategy_tuples)

pytest.mark.parametrize( "type_", [ # Old-style `List` because `list[int]() == list()`, so no

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="takes 2000s; large & s

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="takes 2 hours" )

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="takes ~30s each; Cross

pytest.mark.parametrize( "thing", [ annotated_func, # Works via typing.get_type_hints

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="takes hours; may get f

mock.patch("math.atan")

mock.patch("math.atan")

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="takes ~11 mins; datast

given(rare_value_strategy(n=128, target=80))

given(clamp_inputs())

pytest.mark.parametrize("skip_target", [False, True])

pytest.mark.parametrize( "cli,code", [ # Passing one argument falls back to one-argument tests

pytest.mark.xfail( condition=settings.get_current_profile_name() != "ci", strict=False, reason="Re

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="isn't threadsafe" )

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="takes ages" )

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="takes ~10 minutes; man

pytest.mark.parametrize( "predicate", [ (lambda x: len(x) < 3), (lambda x: len(x) > 5)

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="not threadsafe" )

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="takes 3-5 mins and rai

pytest.mark.xfail( settings.get_current_profile_name() == "threading", reason=( "dynamic @exam

pytest.mark.parametrize( "exceptions,output", [ # Discard subclasses of other exceptions to ca

skipif_time_unpatched

pytest.mark.parametrize( "strategy, predicate, min_value, max_value", [ # Floats with integer

pytest.mark.parametrize( "strategy, predicate, start, end", [ # Finitude check (st.int

pytest.mark.parametrize( "predicate, start, end", [ # Simple lambdas (lambda x: len(x)

pytest.mark.parametrize( "predicate, start, end", [ # Simple lambdas (lambda x: len(x)

pytest.mark.parametrize( "strategy, predicate, start, end", [ # text with integer bounds

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="takes ~10 mins; path t

pytest.mark.parametrize( "dtype, kwargs, pred", [ # Floating point: bounds, exclusive bounds,

pytest.mark.parametrize( "buffer_type", [bytes, bytearray, memoryview, io.BytesIO], ids=attrgetter

pytest.mark.parametrize( "strat, type_", [ (st.from_type, MyGeneric[T]), (st.from_type

pytest.mark.parametrize( "generic", ( Callable, list, Sequence, # you

pytest.mark.parametrize( "pf, names", [ (partial(func, 1), "b c d"), (partial(func, 1,

pytest.mark.parametrize( "strategy, imports", # The specifics don't matter much here; we're just demon

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="takes ~30s each; Cross

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="Crosshair is too much

fails_with_output(""" Falsifying example: test_inquisitor_builds_kwargs_subargs( obj=MyClass( x=0,

fails_with_output(""" Falsifying example: test_inquisitor_builds_subargs( obj=MyClass( 0, # or an

fails_with_output(""" Falsifying example: test_inquisitor_comments_basic_fail_if_either( # The test always

fails_with_output(""" Falsifying example: test_inquisitor_comments_basic_fail_if_not_all( # The test somet

fails_with_output(""" Falsifying example: test_inquisitor_doesnt_break_on_varying_forced_nodes( n1=100,

fails_with_output(""" Falsifying example: test_inquisitor_duplicate_param_names( kw=0, # or any other gen

fails_with_output(""" Falsifying example: test_inquisitor_fixeddict_subargs( d={ 'x': 0, # or any

fails_with_output(""" Falsifying example: test_inquisitor_multi_level_nesting( bare=0, # or any other gen

fails_with_output(""" Falsifying example: test_inquisitor_no_misleading_comment_for_eq_args( n1=0, n2=

fails_with_output(""" Falsifying example: test_inquisitor_no_together_comment_if_single_argument( a='',

fails_with_output(""" Falsifying example: test_inquisitor_skip_subset_slices( obj=MyClass( (0, Fal

fails_with_output(""" Falsifying example: test_inquisitor_tuple_multiple_varying( t=( 0, # or any

fails_with_output(""" Falsifying example: test_inquisitor_tuple_subargs( t=( 0, # or any other ge

pytest.mark.parametrize("fname", ["", "<ipython-input-18-f7c304bea5eb>"])

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="takes ~7 mins; first b

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="takes ~15 minutes, mos

pytest.mark.skipif( Settings.get_current_profile_name() == "crosshair", reason="takes hours; too much

pytest.mark.parametrize( "target_sig", ("(i),(i)->()", "(m,n),(n,p)->(m,p)", "(n),(n,p)->(p)", "(m,n),

pytest.mark.skipif( settings.get_current_profile_name() == "crosshair", reason="takes ~6 mins in CI, b