SYMBOL INDEX (6126 symbols across 409 files)

FILE: hypothesis-python/benchmark/graph.py
  function plot_vega (line 19) | def plot_vega(vega_spec, data, *, to, parameters=None):
  function _mean_difference_ci (line 37) | def _mean_difference_ci(n1, n2, *, confidence):
  function _process_benchmark_data (line 52) | def _process_benchmark_data(data):
  function plot (line 114) | def plot(data, out):

FILE: hypothesis-python/docs/_ext/hypothesis_linkcheck.py
  function is_intersphinx_link (line 32) | def is_intersphinx_link(uri):
  class HypothesisLinkChecker (line 40) | class HypothesisLinkChecker(HyperlinkAvailabilityChecker):
    method is_ignored_uri (line 41) | def is_ignored_uri(self, uri: str) -> bool:
  function on_builder_inited (line 52) | def on_builder_inited(app: Sphinx) -> None:
  function setup (line 57) | def setup(app: Sphinx):

FILE: hypothesis-python/docs/_ext/hypothesis_redirects.py
  function setup (line 43) | def setup(app: Sphinx) -> dict:
  function init (line 54) | def init(app: Sphinx) -> Sequence | None:
  class Reredirects (line 68) | class Reredirects:
    method __init__ (line 69) | def __init__(self, app: Sphinx) -> None:
    method grab_redirects (line 74) | def grab_redirects(self) -> Mapping[str, str]:
    method docname_out_path (line 104) | def docname_out_path(self, docname: str, suffix: str) -> Sequence[str]:
    method create_redirects (line 127) | def create_redirects(self, to_be_redirected: Mapping[str, str]) -> None:
    method _contains_wildcard (line 154) | def _contains_wildcard(text: str) -> bool:
    method _apply_placeholders (line 159) | def _apply_placeholders(source: str, target: str) -> str:
    method _create_redirect_file (line 163) | def _create_redirect_file(self, at_path: Path, to_uri: str) -> None:
    method _render_redirect_template (line 173) | def _render_redirect_template(self, to_uri: str) -> str:
  function collect_redirects_for_linkcheck (line 183) | def collect_redirects_for_linkcheck(app):

FILE: hypothesis-python/docs/conf.py
  class VersionRole (line 97) | class VersionRole(SphinxRole):
    method __init__ (line 98) | def __init__(self, prefix):
    method run (line 101) | def run(self):
  function setup (line 110) | def setup(app):

FILE: hypothesis-python/examples/example_hypothesis_entrypoint/example_hypothesis_entrypoint.py
  class MyCustomType (line 18) | class MyCustomType:
    method __init__ (line 19) | def __init__(self, x: int):
  function _hypothesis_setup_hook (line 24) | def _hypothesis_setup_hook():

FILE: hypothesis-python/examples/example_hypothesis_entrypoint/test_entrypoint.py
  function test_registered_from_entrypoint (line 17) | def test_registered_from_entrypoint(x):

FILE: hypothesis-python/examples/test_basic.py
  class Product (line 15) | class Product:
    method __init__ (line 16) | def __init__(self, price: float) -> None:
    method get_discount_price (line 19) | def get_discount_price(self, discount_percentage: float):
  function test_a_discounted_price_is_not_higher_than_the_original_price (line 30) | def test_a_discounted_price_is_not_higher_than_the_original_price(

FILE: hypothesis-python/examples/test_binary_search.py
  function binary_search (line 26) | def binary_search(ls, v):
  function is_sorted (line 73) | def is_sorted(ls):
  function test_insert_is_sorted (line 92) | def test_insert_is_sorted(ls, v):
  function test_is_minimal (line 101) | def test_is_minimal(ls, v):
  function test_inserts_into_same_place_twice (line 111) | def test_inserts_into_same_place_twice(ls, v):

FILE: hypothesis-python/examples/test_rle.py
  function run_length_encode (line 28) | def run_length_encode(seq):
  function run_length_decode (line 51) | def run_length_decode(seq):
  function test_decodes_to_starting_sequence (line 67) | def test_decodes_to_starting_sequence(ls):
  function test_duplicating_an_element_does_not_increase_length (line 77) | def test_duplicating_an_element_does_not_increase_length(ls, data):

FILE: hypothesis-python/src/_hypothesis_ftz_detector.py
  function flush_to_zero (line 46) | def flush_to_zero() -> bool:
  function run_in_process (line 51) | def run_in_process(fn: Callable[..., FTZCulprits], *args: object) -> FTZ...
  function target (line 63) | def target(
  function always_imported_modules (line 69) | def always_imported_modules() -> FTZCulprits:
  function modules_imported_by (line 73) | def modules_imported_by(mod: str) -> FTZCulprits:
  function identify_ftz_culprits (line 90) | def identify_ftz_culprits() -> str:

FILE: hypothesis-python/src/_hypothesis_pytestplugin.py
  class StoringReporter (line 56) | class StoringReporter:
    method __init__ (line 57) | def __init__(self, config):
    method __call__ (line 65) | def __call__(self, msg):
  function pytest_addoption (line 100) | def pytest_addoption(parser):
  function _any_hypothesis_option (line 131) | def _any_hypothesis_option(config):
  function pytest_report_header (line 134) | def pytest_report_header(config):
  function pytest_configure (line 153) | def pytest_configure(config):
  function pytest_runtest_call (line 190) | def pytest_runtest_call(item):
  function _stash_get (line 325) | def _stash_get(config, key, default):
  function pytest_runtest_makereport (line 336) | def pytest_runtest_makereport(item, call):
  function pytest_terminal_summary (line 386) | def pytest_terminal_summary(terminalreporter):
  function pytest_collection_modifyitems (line 424) | def pytest_collection_modifyitems(items):
  function pytest_sessionstart (line 446) | def pytest_sessionstart(session):
  function _ban_given_call (line 456) | def _ban_given_call(self, function):
  function pytest_ignore_collect (line 473) | def pytest_ignore_collect(collection_path, config):
  function load (line 491) | def load():

FILE: hypothesis-python/src/hypothesis/_settings.py
  class Verbosity (line 65) | class Verbosity(Enum):
    method _missing_ (line 98) | def _missing_(cls, value):
    method __repr__ (line 114) | def __repr__(self) -> str:
    method _int_value (line 118) | def _int_value(value: "Verbosity") -> int:
    method __eq__ (line 130) | def __eq__(self, other: Any) -> bool:
    method __gt__ (line 135) | def __gt__(self, other: Any) -> bool:
  class Phase (line 142) | class Phase(Enum):
    method _missing_ (line 179) | def _missing_(cls, value):
    method __repr__ (line 202) | def __repr__(self) -> str:
  class HealthCheckMeta (line 206) | class HealthCheckMeta(EnumMeta):
    method __iter__ (line 207) | def __iter__(self):
  class HealthCheck (line 213) | class HealthCheck(Enum, metaclass=HealthCheckMeta):
    method _missing_ (line 258) | def _missing_(cls, value):
    method __repr__ (line 284) | def __repr__(self) -> str:
    method all (line 288) | def all(cls) -> list["HealthCheck"]:
  class duration (line 382) | class duration(datetime.timedelta):
    method __repr__ (line 385) | def __repr__(self) -> str:
  function is_in_ci (line 409) | def is_in_ci() -> bool:
  function _validate_choices (line 419) | def _validate_choices(name: str, value: T, *, choices: Sequence[object])...
  function _validate_enum_value (line 426) | def _validate_enum_value(cls: Any, value: object, *, name: str) -> Any:
  function _validate_max_examples (line 436) | def _validate_max_examples(max_examples: int) -> int:
  function _validate_database (line 446) | def _validate_database(
  function _validate_phases (line 460) | def _validate_phases(phases: Collection[Phase]) -> Sequence[Phase]:
  function _validate_stateful_step_count (line 469) | def _validate_stateful_step_count(stateful_step_count: int) -> int:
  function _validate_suppress_health_check (line 478) | def _validate_suppress_health_check(suppressions: object) -> tuple[Healt...
  function _validate_deadline (line 494) | def _validate_deadline(
  function _validate_backend (line 524) | def _validate_backend(backend: str) -> str:
  class settingsMeta (line 536) | class settingsMeta(type):
    method __init__ (line 537) | def __init__(cls, *args, **kwargs):
    method default (line 541) | def default(cls) -> Optional["settings"]:
    method __setattr__ (line 551) | def __setattr__(cls, name: str, value: object) -> None:
    method __repr__ (line 566) | def __repr__(cls):
  class settings (line 570) | class settings(metaclass=settingsMeta):
    method __init__ (line 660) | def __init__(
    method max_examples (line 755) | def max_examples(self):
    method derandomize (line 782) | def derandomize(self):
    method database (line 799) | def database(self):
    method verbosity (line 837) | def verbosity(self):
    method phases (line 884) | def phases(self):
    method stateful_step_count (line 944) | def stateful_step_count(self):
    method report_multiple_bugs (line 957) | def report_multiple_bugs(self):
    method suppress_health_check (line 969) | def suppress_health_check(self):
    method deadline (line 996) | def deadline(self):
    method print_blob (line 1011) | def print_blob(self):
    method backend (line 1021) | def backend(self):
    method __call__ (line 1033) | def __call__(self, test: T) -> T:
    method __setattr__ (line 1082) | def __setattr__(self, name: str, value: object) -> None:
    method __repr__ (line 1087) | def __repr__(self) -> str:
    method show_changed (line 1095) | def show_changed(self) -> str:
    method register_profile (line 1104) | def register_profile(
    method get_profile (line 1150) | def get_profile(name: str) -> "settings":
    method load_profile (line 1162) | def load_profile(name: str) -> None:
    method get_current_profile_name (line 1173) | def get_current_profile_name() -> str:
  function local_settings (line 1188) | def local_settings(s: settings) -> Generator[settings, None, None]:

FILE: hypothesis-python/src/hypothesis/configuration.py
  function set_hypothesis_home_dir (line 24) | def set_hypothesis_home_dir(directory: str | Path | None) -> None:
  function storage_directory (line 29) | def storage_directory(*names: str, intent_to_write: bool = True) -> Path:
  function check_sideeffect_during_initialization (line 47) | def check_sideeffect_during_initialization(
  function notice_initialization_restarted (line 93) | def notice_initialization_restarted(*, warn: bool = True) -> None:

FILE: hypothesis-python/src/hypothesis/control.py
  function _calling_function_location (line 33) | def _calling_function_location(what: str, frame: Any) -> str:
  function reject (line 38) | def reject() -> NoReturn:
  function assume (line 53) | def assume(condition: Literal[False] | None) -> NoReturn: ...
  function assume (line 55) | def assume(condition: object) -> Literal[True]: ...
  function assume (line 58) | def assume(condition: object) -> Literal[True]:
  function currently_in_test_context (line 84) | def currently_in_test_context() -> bool:
  function current_build_context (line 95) | def current_build_context() -> "BuildContext":
  function deprecate_random_in_strategy (line 103) | def deprecate_random_in_strategy(fmt, *args):
  class BuildContext (line 140) | class BuildContext:
    method __init__ (line 141) | def __init__(
    method track_arg_label (line 164) | def track_arg_label(self, label: str) -> Generator[ArgLabelsT, None, N...
    method record_call (line 187) | def record_call(
    method prep_args_kwargs_from_strategies (line 207) | def prep_args_kwargs_from_strategies(
    method __enter__ (line 224) | def __enter__(self):
    method __exit__ (line 229) | def __exit__(self, exc_type, exc_value, tb):
  function cleanup (line 243) | def cleanup(teardown):
  function should_note (line 258) | def should_note():
  function note (line 265) | def note(value: object) -> None:
  function event (line 273) | def event(value: str, payload: str | int | float = "") -> None:
  function _event_to_string (line 296) | def _event_to_string(event, *, allowed_types=str, avoid_realization):
  function target (line 319) | def target(observation: int | float, *, label: str = "") -> int | float:

FILE: hypothesis-python/src/hypothesis/core.py
  class Example (line 162) | class Example:
  class ReportableError (line 171) | class ReportableError:
  class example (line 179) | class example:
    method __init__ (line 231) | def __init__(self, *args: Any, **kwargs: Any) -> None:
    method __call__ (line 242) | def __call__(self, test: TestFunc) -> TestFunc:
    method xfail (line 248) | def xfail(
    method via (line 308) | def via(self, whence: str, /) -> "example":
  function seed (line 338) | def seed(seed: Hashable) -> Callable[[TestFunc], TestFunc]:
  function reproduce_failure (line 383) | def reproduce_failure(version: str, blob: bytes) -> Callable[[TestFunc],...
  function reproduction_decorator (line 414) | def reproduction_decorator(choices: Iterable[ChoiceT]) -> str:
  function encode_failure (line 418) | def encode_failure(choices: Iterable[ChoiceT]) -> bytes:
  function decode_failure (line 428) | def decode_failure(blob: bytes) -> Sequence[ChoiceT]:
  function _invalid (line 456) | def _invalid(message, *, exc=InvalidArgument, test, given_kwargs):
  function is_invalid_test (line 470) | def is_invalid_test(test, original_sig, given_arguments, given_kwargs):
  function execute_explicit_examples (line 535) | def execute_explicit_examples(state, wrapped_test, arguments, kwargs, or...
  function get_random_for_wrapped_test (line 708) | def get_random_for_wrapped_test(test, wrapped_test):
  class Stuff (line 729) | class Stuff:
  function process_arguments_to_given (line 736) | def process_arguments_to_given(
  function skip_exceptions_to_reraise (line 772) | def skip_exceptions_to_reraise():
  function failure_exceptions_to_catch (line 792) | def failure_exceptions_to_catch() -> tuple[type[BaseException], ...]:
  function new_given_signature (line 808) | def new_given_signature(original_sig, given_kwargs):
  function default_executor (line 823) | def default_executor(data, function):
  function get_executor (line 827) | def get_executor(runner):
  function _flatten_group (line 857) | def _flatten_group(excgroup: BaseExceptionGroup[T]) -> list[T]:
  function unwrap_markers_from_group (line 868) | def unwrap_markers_from_group() -> Generator[None, None, None]:
  class StateForActualGivenExecution (line 917) | class StateForActualGivenExecution:
    method __init__ (line 918) | def __init__(
    method test_identifier (line 957) | def test_identifier(self) -> str:
    method _should_trace (line 962) | def _should_trace(self):
    method execute_once (line 975) | def execute_once(
    method _flaky_replay_to_failure (line 1182) | def _flaky_replay_to_failure(
    method _execute_once_for_engine (line 1199) | def _execute_once_for_engine(self, data: ConjectureData) -> None:
    method _deliver_information_message (line 1368) | def _deliver_information_message(
    method run_engine (line 1381) | def run_engine(self):
  function _simplify_explicit_errors (line 1588) | def _simplify_explicit_errors(errors: list[ReportableError]) -> list[Rep...
  function _raise_to_user (line 1622) | def _raise_to_user(
  function fake_subTest (line 1660) | def fake_subTest(self, msg=None, **__):
  class HypothesisHandle (line 1679) | class HypothesisHandle:
    method fuzz_one_input (line 1699) | def fuzz_one_input(
  function given (line 1793) | def given(
  function given (line 1802) | def given(
  function given (line 1811) | def given(
  function given (line 1819) | def given(
  function find (line 2373) | def find(

FILE: hypothesis-python/src/hypothesis/database.py
  function _usable_dir (line 67) | def _usable_dir(path: StrPathT) -> bool:
  function _db_for_path (line 85) | def _db_for_path(
  class _EDMeta (line 112) | class _EDMeta(abc.ABCMeta):
    method __call__ (line 113) | def __call__(self, *args: Any, **kwargs: Any) -> "ExampleDatabase":
  class ExampleDatabase (line 171) | class ExampleDatabase(metaclass=_EDMeta):
    method __init__ (line 230) | def __init__(self) -> None:
    method save (line 234) | def save(self, key: bytes, value: bytes) -> None:
    method fetch (line 242) | def fetch(self, key: bytes) -> Iterable[bytes]:
    method delete (line 247) | def delete(self, key: bytes, value: bytes) -> None:
    method move (line 254) | def move(self, src: bytes, dest: bytes, value: bytes) -> None:
    method add_listener (line 270) | def add_listener(self, f: ListenerT, /) -> None:
    method remove_listener (line 294) | def remove_listener(self, f: ListenerT, /) -> None:
    method clear_listeners (line 306) | def clear_listeners(self) -> None:
    method _broadcast_change (line 313) | def _broadcast_change(self, event: ListenerEventT) -> None:
    method _start_listening (line 334) | def _start_listening(self) -> None:
    method _stop_listening (line 351) | def _stop_listening(self) -> None:
  class InMemoryExampleDatabase (line 367) | class InMemoryExampleDatabase(ExampleDatabase):
    method __init__ (line 376) | def __init__(self) -> None:
    method __repr__ (line 380) | def __repr__(self) -> str:
    method __eq__ (line 383) | def __eq__(self, other: object) -> bool:
    method fetch (line 386) | def fetch(self, key: bytes) -> Iterable[bytes]:
    method save (line 389) | def save(self, key: bytes, value: bytes) -> None:
    method delete (line 398) | def delete(self, key: bytes, value: bytes) -> None:
    method _start_listening (line 407) | def _start_listening(self) -> None:
    method _stop_listening (line 413) | def _stop_listening(self) -> None:
  function _hash (line 417) | def _hash(key: bytes) -> str:
  class DirectoryBasedExampleDatabase (line 421) | class DirectoryBasedExampleDatabase(ExampleDatabase):
    method __init__ (line 444) | def __init__(self, path: StrPathT) -> None:
    method __repr__ (line 450) | def __repr__(self) -> str:
    method __eq__ (line 453) | def __eq__(self, other: object) -> bool:
    method _key_path (line 458) | def _key_path(self, key: bytes) -> Path:
    method _value_path (line 466) | def _value_path(self, key: bytes, value: bytes) -> Path:
    method fetch (line 469) | def fetch(self, key: bytes) -> Iterable[bytes]:
    method save (line 484) | def save(self, key: bytes, value: bytes) -> None:
    method move (line 521) | def move(self, src: bytes, dest: bytes, value: bytes) -> None:
    method delete (line 539) | def delete(self, key: bytes, value: bytes) -> None:
    method _start_listening (line 557) | def _start_listening(self) -> None:
    method _stop_listening (line 669) | def _stop_listening(self) -> None:
  class ReadOnlyDatabase (line 676) | class ReadOnlyDatabase(ExampleDatabase):
    method __init__ (line 687) | def __init__(self, db: ExampleDatabase) -> None:
    method __repr__ (line 692) | def __repr__(self) -> str:
    method __eq__ (line 695) | def __eq__(self, other: object) -> bool:
    method fetch (line 698) | def fetch(self, key: bytes) -> Iterable[bytes]:
    method save (line 701) | def save(self, key: bytes, value: bytes) -> None:
    method delete (line 704) | def delete(self, key: bytes, value: bytes) -> None:
    method _start_listening (line 707) | def _start_listening(self) -> None:
    method _stop_listening (line 711) | def _stop_listening(self) -> None:
  class MultiplexedDatabase (line 715) | class MultiplexedDatabase(ExampleDatabase):
    method __init__ (line 741) | def __init__(self, *dbs: ExampleDatabase) -> None:
    method __repr__ (line 746) | def __repr__(self) -> str:
    method __eq__ (line 749) | def __eq__(self, other: object) -> bool:
    method fetch (line 754) | def fetch(self, key: bytes) -> Iterable[bytes]:
    method save (line 762) | def save(self, key: bytes, value: bytes) -> None:
    method delete (line 766) | def delete(self, key: bytes, value: bytes) -> None:
    method move (line 770) | def move(self, src: bytes, dest: bytes, value: bytes) -> None:
    method _start_listening (line 774) | def _start_listening(self) -> None:
    method _stop_listening (line 778) | def _stop_listening(self) -> None:
  class GitHubArtifactDatabase (line 783) | class GitHubArtifactDatabase(ExampleDatabase):
    method __init__ (line 853) | def __init__(
    method __repr__ (line 895) | def __repr__(self) -> str:
    method __eq__ (line 901) | def __eq__(self, other: object) -> bool:
    method _prepare_for_io (line 910) | def _prepare_for_io(self) -> None:
    method _initialize_db (line 952) | def _initialize_db(self) -> None:
    method _get_bytes (line 1007) | def _get_bytes(self, url: str) -> bytes | None:  # pragma: no cover
    method _fetch_artifact (line 1049) | def _fetch_artifact(self) -> Path | None:  # pragma: no cover
    method _key_path (line 1090) | def _key_path(key: bytes) -> PurePath:
    method fetch (line 1093) | def fetch(self, key: bytes) -> Iterable[bytes]:
    method save (line 1115) | def save(self, key: bytes, value: bytes) -> None:
    method move (line 1118) | def move(self, src: bytes, dest: bytes, value: bytes) -> None:
    method delete (line 1121) | def delete(self, key: bytes, value: bytes) -> None:
  class BackgroundWriteDatabase (line 1125) | class BackgroundWriteDatabase(ExampleDatabase):
    method __init__ (line 1132) | def __init__(self, db: ExampleDatabase) -> None:
    method _ensure_thread (line 1138) | def _ensure_thread(self):
    method __repr__ (line 1146) | def __repr__(self) -> str:
    method __eq__ (line 1149) | def __eq__(self, other: object) -> bool:
    method _worker (line 1152) | def _worker(self) -> None:
    method _join (line 1158) | def _join(self, timeout: float | None = None) -> None:
    method fetch (line 1164) | def fetch(self, key: bytes) -> Iterable[bytes]:
    method save (line 1168) | def save(self, key: bytes, value: bytes) -> None:
    method delete (line 1172) | def delete(self, key: bytes, value: bytes) -> None:
    method move (line 1176) | def move(self, src: bytes, dest: bytes, value: bytes) -> None:
    method _start_listening (line 1180) | def _start_listening(self) -> None:
    method _stop_listening (line 1183) | def _stop_listening(self) -> None:
  function _pack_uleb128 (line 1187) | def _pack_uleb128(value: int) -> bytes:
  function _unpack_uleb128 (line 1211) | def _unpack_uleb128(buffer: bytes) -> tuple[int, int]:
  function choices_to_bytes (line 1226) | def choices_to_bytes(choices: Iterable[ChoiceT], /) -> bytes:
  function _choices_from_bytes (line 1266) | def _choices_from_bytes(buffer: bytes, /) -> tuple[ChoiceT, ...]:
  function choices_from_bytes (line 1297) | def choices_from_bytes(buffer: bytes, /) -> tuple[ChoiceT, ...] | None:

FILE: hypothesis-python/src/hypothesis/entry_points.py
  function run (line 22) | def run() -> None:

FILE: hypothesis-python/src/hypothesis/errors.py
  class HypothesisException (line 17) | class HypothesisException(Exception):
  class _Trimmable (line 21) | class _Trimmable(HypothesisException):
  class UnsatisfiedAssumption (line 25) | class UnsatisfiedAssumption(HypothesisException):
    method __init__ (line 31) | def __init__(self, reason: str | None = None) -> None:
  class NoSuchExample (line 35) | class NoSuchExample(HypothesisException):
    method __init__ (line 42) | def __init__(self, condition_string: str, extra: str = "") -> None:
  class Unsatisfiable (line 46) | class Unsatisfiable(_Trimmable):
  class ChoiceTooLarge (line 59) | class ChoiceTooLarge(HypothesisException):
  class Flaky (line 63) | class Flaky(_Trimmable):
  class FlakyReplay (line 74) | class FlakyReplay(Flaky):
    method __init__ (line 82) | def __init__(self, reason, interesting_origins=None):
  class FlakyStrategyDefinition (line 88) | class FlakyStrategyDefinition(Flaky):
  class _WrappedBaseException (line 103) | class _WrappedBaseException(Exception):
  class FlakyFailure (line 107) | class FlakyFailure(ExceptionGroup, Flaky):
    method __new__ (line 128) | def __new__(cls, msg, group):
    method derive (line 144) | def derive(self, excs):
  class FlakyBackendFailure (line 148) | class FlakyBackendFailure(FlakyFailure):
  class InvalidArgument (line 159) | class InvalidArgument(_Trimmable, TypeError):
  class ResolutionFailed (line 164) | class ResolutionFailed(InvalidArgument):
  class InvalidState (line 173) | class InvalidState(HypothesisException):
  class InvalidDefinition (line 177) | class InvalidDefinition(_Trimmable, TypeError):
  class HypothesisWarning (line 182) | class HypothesisWarning(HypothesisException, Warning):
  class FailedHealthCheck (line 186) | class FailedHealthCheck(_Trimmable):
  class NonInteractiveExampleWarning (line 190) | class NonInteractiveExampleWarning(HypothesisWarning):
  class HypothesisDeprecationWarning (line 199) | class HypothesisDeprecationWarning(HypothesisWarning, FutureWarning):
  class HypothesisSideeffectWarning (line 211) | class HypothesisSideeffectWarning(HypothesisWarning):
  class Frozen (line 218) | class Frozen(HypothesisException):
  function __getattr__ (line 223) | def __getattr__(name: str) -> Any:
  class DeadlineExceeded (line 240) | class DeadlineExceeded(_Trimmable):
    method __init__ (line 246) | def __init__(self, runtime: timedelta, deadline: timedelta) -> None:
    method __reduce__ (line 256) | def __reduce__(
  class StopTest (line 262) | class StopTest(BaseException):
    method __init__ (line 267) | def __init__(self, testcounter: int) -> None:
  class DidNotReproduce (line 272) | class DidNotReproduce(HypothesisException):
  class Found (line 276) | class Found(HypothesisException):
  class RewindRecursive (line 280) | class RewindRecursive(Exception):
    method __init__ (line 283) | def __init__(self, target: object) -> None:
  class SmallSearchSpaceWarning (line 287) | class SmallSearchSpaceWarning(HypothesisWarning):
  class BackendCannotProceed (line 296) | class BackendCannotProceed(HypothesisException):
    method __init__ (line 320) | def __init__(self, scope: CannotProceedScopeT = "other", /) -> None:

FILE: hypothesis-python/src/hypothesis/extra/_array_helpers.py
  class BroadcastableShapes (line 56) | class BroadcastableShapes(NamedTuple):
  function check_argument (line 62) | def check_argument(condition, fail_message, *f_args, **f_kwargs):
  function order_check (line 68) | def order_check(name, floor, min_, max_):
  function check_valid_dims (line 84) | def check_valid_dims(dims, name):
  function array_shapes (line 93) | def array_shapes(
  function valid_tuple_axes (line 131) | def valid_tuple_axes(
  function broadcastable_shapes (line 176) | def broadcastable_shapes(
  class _GUfuncSig (line 296) | class _GUfuncSig(NamedTuple):
  function _hypothesis_parse_gufunc_signature (line 301) | def _hypothesis_parse_gufunc_signature(signature):
  function mutually_broadcastable_shapes (line 357) | def mutually_broadcastable_shapes(
  class MutuallyBroadcastableShapesStrategy (line 496) | class MutuallyBroadcastableShapesStrategy(st.SearchStrategy):
    method __init__ (line 497) | def __init__(
    method do_draw (line 519) | def do_draw(self, data):
    method _draw_core_dimensions (line 546) | def _draw_core_dimensions(self, data):
    method _draw_loop_dimensions (line 568) | def _draw_loop_dimensions(self, data, use=None):
  class BasicIndexStrategy (line 639) | class BasicIndexStrategy(st.SearchStrategy):
    method __init__ (line 640) | def __init__(
    method do_draw (line 660) | def do_draw(self, data):

FILE: hypothesis-python/src/hypothesis/extra/_patching.py
  function dedent (line 61) | def dedent(text: str) -> tuple[str, str]:
  function indent (line 68) | def indent(text: str, prefix: str) -> str:
  class AddExamplesCodemod (line 72) | class AddExamplesCodemod(VisitorBasedCodemodCommand):
    method __init__ (line 75) | def __init__(
    method __call_node_to_example_dec (line 111) | def __call_node_to_example_dec(
    method leave_FunctionDef (line 147) | def leave_FunctionDef(
  function get_patch_for (line 162) | def get_patch_for(
  function _get_patch_for (line 192) | def _get_patch_for(
  function make_patch (line 294) | def make_patch(
  function save_patch (line 324) | def save_patch(patch: str, *, slug: str = "") -> Path:  # pragma: no cover
  function gc_patches (line 335) | def gc_patches(slug: str = "") -> None:  # pragma: no cover

FILE: hypothesis-python/src/hypothesis/extra/array_api.py
  function check_xp_attributes (line 81) | def check_xp_attributes(xp: Any, attributes: list[str]) -> None:
  function partition_attributes_and_stubs (line 90) | def partition_attributes_and_stubs(
  function warn_on_missing_dtypes (line 104) | def warn_on_missing_dtypes(xp: Any, stubs: list[str]) -> None:
  function find_castable_builtin_for_dtype (line 114) | def find_castable_builtin_for_dtype(
  function dtype_from_name (line 160) | def dtype_from_name(xp: Any, name: str) -> Any:
  function _from_dtype (line 175) | def _from_dtype(
  class ArrayStrategy (line 307) | class ArrayStrategy(st.SearchStrategy):
    method __init__ (line 308) | def __init__(
    method check_set_value (line 322) | def check_set_value(self, val, val_0d, strategy):
    method do_draw (line 349) | def do_draw(self, data):
  function _arrays (line 451) | def _arrays(
  function check_dtypes (line 581) | def check_dtypes(xp: Any, dtypes: list[DataType], stubs: list[str]) -> N...
  function _scalar_dtypes (line 593) | def _scalar_dtypes(xp: Any, api_version: NominalVersion) -> st.SearchStr...
  function _boolean_dtypes (line 598) | def _boolean_dtypes(xp: Any) -> st.SearchStrategy[DataType]:
  function _real_dtypes (line 608) | def _real_dtypes(xp: Any) -> st.SearchStrategy[DataType]:
  function _numeric_dtypes (line 617) | def _numeric_dtypes(
  function check_valid_sizes (line 628) | def check_valid_sizes(
  function numeric_dtype_names (line 643) | def numeric_dtype_names(base_name: str, sizes: Sequence[int]) -> Iterato...
  function _integer_dtypes (line 653) | def _integer_dtypes(
  function _unsigned_integer_dtypes (line 671) | def _unsigned_integer_dtypes(
  function _floating_dtypes (line 691) | def _floating_dtypes(
  function _complex_dtypes (line 709) | def _complex_dtypes(
  function valid_tuple_axes (line 728) | def valid_tuple_axes(*args, **kwargs):
  function mutually_broadcastable_shapes (line 742) | def mutually_broadcastable_shapes(
  function indices (line 765) | def indices(
  function make_strategies_namespace (line 842) | def make_strategies_namespace(
  class FloatInfo (line 1082) | class FloatInfo(NamedTuple):
  function mock_finfo (line 1089) | def mock_finfo(dtype: DataType) -> FloatInfo:

FILE: hypothesis-python/src/hypothesis/extra/cli.py
  function main (line 60) | def main():
  function main (line 74) | def main():
  function obj_name (line 77) | def obj_name(s: str) -> object:
  function _refactor (line 157) | def _refactor(func, fname):
  function codemod (line 184) | def codemod(path):
  function write (line 286) | def write(func, writer, except_, style, annotate):  # \b disables autowrap

FILE: hypothesis-python/src/hypothesis/extra/codemods.py
  function refactor (line 52) | def refactor(code: str) -> str:
  function match_qualname (line 73) | def match_qualname(name):
  class HypothesisFixComplexMinMagnitude (line 85) | class HypothesisFixComplexMinMagnitude(VisitorBasedCodemodCommand):
    method leave_Arg (line 100) | def leave_Arg(self, original_node, updated_node):
  function get_fn (line 109) | def get_fn(import_path):
  class HypothesisFixPositionalKeywonlyArgs (line 114) | class HypothesisFixPositionalKeywonlyArgs(VisitorBasedCodemodCommand):
    method leave_Call (line 174) | def leave_Call(self, original_node, updated_node):
  class HypothesisFixHealthCheckAll (line 225) | class HypothesisFixHealthCheckAll(VisitorBasedCodemodCommand):
    method replace_healthcheck (line 231) | def replace_healthcheck(self, original_node, updated_node):
  class HypothesisFixCharactersArguments (line 238) | class HypothesisFixCharactersArguments(VisitorBasedCodemodCommand):
    method fn (line 270) | def fn(self, original_node, updated_node):

FILE: hypothesis-python/src/hypothesis/extra/dateutil.py
  function __zone_sort_key (line 32) | def __zone_sort_key(zone):
  function timezones (line 44) | def timezones() -> st.SearchStrategy[dt.tzinfo]:

FILE: hypothesis-python/src/hypothesis/extra/django/_fields.py
  function numeric_bounds_from_validators (line 42) | def numeric_bounds_from_validators(
  function integers_for_field (line 53) | def integers_for_field(min_value, max_value):
  function timezones (line 61) | def timezones():
  function register_for (line 113) | def register_for(field_type):
  function _for_datetime (line 123) | def _for_datetime(field):
  function using_sqlite (line 134) | def using_sqlite():
  function _for_model_time (line 147) | def _for_model_time(field):
  function _for_form_time (line 155) | def _for_form_time(field):
  function _for_duration (line 162) | def _for_duration(field):
  function _for_slug (line 172) | def _for_slug(field):
  function _for_model_ip (line 184) | def _for_model_ip(field):
  function _for_form_ip (line 193) | def _for_form_ip(field):
  function _for_decimal (line 208) | def _for_decimal(field):
  function length_bounds_from_validators (line 218) | def length_bounds_from_validators(field):
  function _for_binary (line 230) | def _for_binary(field):
  function _for_text (line 241) | def _for_text(field):
  function _for_form_boolean (line 278) | def _for_form_boolean(field):
  function _model_choice_strategy (line 284) | def _model_choice_strategy(field):
  function _for_model_choice (line 323) | def _for_model_choice(field):
  function _for_model_multiple_choice (line 328) | def _for_model_multiple_choice(field):
  function register_field_strategy (line 333) | def register_field_strategy(
  function from_field (line 356) | def from_field(field: F) -> st.SearchStrategy[F | None]:

FILE: hypothesis-python/src/hypothesis/extra/django/_impl.py
  class HypothesisTestCase (line 29) | class HypothesisTestCase:
    method setup_example (line 30) | def setup_example(self):
    method teardown_example (line 33) | def teardown_example(self, example):
    method __call__ (line 36) | def __call__(self, result=None):
  class SimpleTestCase (line 44) | class SimpleTestCase(HypothesisTestCase, dt.SimpleTestCase):
  class TestCase (line 48) | class TestCase(HypothesisTestCase, dt.TestCase):
  class TransactionTestCase (line 52) | class TransactionTestCase(HypothesisTestCase, dt.TransactionTestCase):
  class LiveServerTestCase (line 56) | class LiveServerTestCase(HypothesisTestCase, dt.LiveServerTestCase):
  class StaticLiveServerTestCase (line 60) | class StaticLiveServerTestCase(HypothesisTestCase, dst.StaticLiveServerT...
  function from_model (line 65) | def from_model(
  function _models_impl (line 126) | def _models_impl(draw, strat):
  function from_form (line 135) | def from_form(
  function _forms_impl (line 225) | def _forms_impl(draw, strat):

FILE: hypothesis-python/src/hypothesis/extra/dpcontracts.py
  function fulfill (line 26) | def fulfill(contract_func):

FILE: hypothesis-python/src/hypothesis/extra/ghostwriter.py
  function _dedupe_exceptions (line 151) | def _dedupe_exceptions(exc: tuple[type[Exception], ...]) -> tuple[type[E...
  function _check_except (line 162) | def _check_except(except_: Except) -> tuple[type[Exception], ...]:
  function _exception_string (line 179) | def _exception_string(except_: tuple[type[Exception], ...]) -> tuple[Imp...
  function _check_style (line 195) | def _check_style(style: str) -> None:
  function _exceptions_from_docstring (line 200) | def _exceptions_from_docstring(doc: str) -> tuple[type[Exception], ...]:
  function _type_from_doc_fragment (line 218) | def _type_from_doc_fragment(token: str) -> type | None:
  function _strip_typevars (line 246) | def _strip_typevars(type_):
  function _strategy_for (line 253) | def _strategy_for(param: inspect.Parameter, docstring: str) -> st.Search...
  function _guess_strategy_by_argname (line 336) | def _guess_strategy_by_argname(name: str) -> st.SearchStrategy:
  function _get_params_builtin_fn (line 433) | def _get_params_builtin_fn(func: Callable) -> list[inspect.Parameter]:
  function _get_params_ufunc (line 465) | def _get_params_ufunc(func: Callable) -> list[inspect.Parameter]:
  function _get_params (line 480) | def _get_params(func: Callable) -> dict[str, inspect.Parameter]:
  function _params_to_dict (line 507) | def _params_to_dict(
  function _with_any_registered (line 515) | def _with_any_registered():
  function _get_strategies (line 533) | def _get_strategies(
  function _assert_eq (line 578) | def _assert_eq(style: str, a: str, b: str) -> str:
  function _imports_for_object (line 587) | def _imports_for_object(obj):
  function _imports_for_strategy (line 611) | def _imports_for_strategy(strategy):
  function _valid_syntax_repr (line 667) | def _valid_syntax_repr(strategy):
  function _get_module_helper (line 727) | def _get_module_helper(obj):
  function _get_module (line 747) | def _get_module(obj):
  function _get_qualname (line 762) | def _get_qualname(obj: Any, *, include_module: bool = False) -> str:
  function _write_call (line 771) | def _write_call(
  function _st_strategy_names (line 807) | def _st_strategy_names(s: str) -> str:
  function _make_test_body (line 817) | def _make_test_body(
  function _annotate_args (line 885) | def _annotate_args(
  class _AnnotationData (line 909) | class _AnnotationData(NamedTuple):
  function _parameters_to_annotation_name (line 914) | def _parameters_to_annotation_name(
  function _join_generics (line 937) | def _join_generics(
  function _join_argument_annotations (line 963) | def _join_argument_annotations(
  function _parameter_to_annotation (line 978) | def _parameter_to_annotation(parameter: Any) -> _AnnotationData | None:
  function _are_annotations_used (line 1062) | def _are_annotations_used(*functions: Callable) -> bool:
  function _make_test (line 1074) | def _make_test(imports: ImportSet, body: str) -> str:
  function _is_probably_ufunc (line 1102) | def _is_probably_ufunc(obj):
  function _get_testable_functions (line 1144) | def _get_testable_functions(thing: object) -> dict[str, Callable]:
  function magic (line 1198) | def magic(
  function fuzz (line 1355) | def fuzz(
  function idempotent (line 1419) | def idempotent(
  function _make_roundtrip_body (line 1483) | def _make_roundtrip_body(funcs, except_, style, annotate):
  function roundtrip (line 1503) | def roundtrip(
  function _get_varnames (line 1536) | def _get_varnames(funcs):
  function _make_equiv_body (line 1545) | def _make_equiv_body(funcs, except_, style, annotate):
  function _make_equiv_errors_body (line 1585) | def _make_equiv_errors_body(funcs, except_, style, annotate):
  function equivalent (line 1620) | def equivalent(
  function binary_operation (line 1668) | def binary_operation(
  function _make_binop_body (line 1735) | def _make_binop_body(
  function ufunc (line 1870) | def ufunc(
  function _make_ufunc_body (line 1901) | def _make_ufunc_body(func, *, except_, style, annotate):

FILE: hypothesis-python/src/hypothesis/extra/lark.py
  function get_terminal_names (line 41) | def get_terminal_names(
  class LarkStrategy (line 57) | class LarkStrategy(st.SearchStrategy):
    method __init__ (line 63) | def __init__(
    method do_draw (line 157) | def do_draw(self, data: ConjectureData) -> str:
    method rule_label (line 163) | def rule_label(self, name: str) -> int:
    method draw_symbol (line 171) | def draw_symbol(
    method gen_ignore (line 189) | def gen_ignore(self, data: ConjectureData, draw_state: list[str]) -> N...
    method calc_has_reusable_values (line 194) | def calc_has_reusable_values(self, recur):
  function check_explicit (line 198) | def check_explicit(name):
  function from_lark (line 208) | def from_lark(

FILE: hypothesis-python/src/hypothesis/extra/numpy.py
  function _try_import (line 65) | def _try_import(mod_name: str, attr_name: str) -> Any:
  function from_dtype (line 114) | def from_dtype(
  class ArrayStrategy (line 237) | class ArrayStrategy(st.SearchStrategy):
    method __init__ (line 238) | def __init__(self, element_strategy, shape, dtype, fill, unique):
    method __repr__ (line 248) | def __repr__(self):
    method set_element (line 254) | def set_element(self, val, result, idx, *, fill=False):
    method do_draw (line 308) | def do_draw(self, data):
  function fill_for (line 431) | def fill_for(elements, unique, fill, name=""):
  function arrays (line 447) | def arrays(
  function arrays (line 458) | def arrays(
  function arrays (line 469) | def arrays(
  function scalar_dtypes (line 593) | def scalar_dtypes() -> st.SearchStrategy[np.dtype]:
  function defines_dtype_strategy (line 606) | def defines_dtype_strategy(strat: T) -> T:
  function boolean_dtypes (line 616) | def boolean_dtypes() -> st.SearchStrategy["np.dtype[np.bool_]"]:
  function dtype_factory (line 621) | def dtype_factory(kind, sizes, valid_sizes, endianness):
  function unsigned_integer_dtypes (line 651) | def unsigned_integer_dtypes(
  function unsigned_integer_dtypes (line 659) | def unsigned_integer_dtypes(
  function unsigned_integer_dtypes (line 667) | def unsigned_integer_dtypes(
  function unsigned_integer_dtypes (line 675) | def unsigned_integer_dtypes(
  function unsigned_integer_dtypes (line 683) | def unsigned_integer_dtypes(
  function unsigned_integer_dtypes (line 691) | def unsigned_integer_dtypes(
  function integer_dtypes (line 714) | def integer_dtypes(
  function integer_dtypes (line 722) | def integer_dtypes(
  function integer_dtypes (line 730) | def integer_dtypes(
  function integer_dtypes (line 738) | def integer_dtypes(
  function integer_dtypes (line 746) | def integer_dtypes(
  function integer_dtypes (line 754) | def integer_dtypes(
  function floating_dtypes (line 773) | def floating_dtypes(
  function floating_dtypes (line 781) | def floating_dtypes(
  function floating_dtypes (line 789) | def floating_dtypes(
  function floating_dtypes (line 797) | def floating_dtypes(
  function floating_dtypes (line 805) | def floating_dtypes(
  function floating_dtypes (line 813) | def floating_dtypes(
  function complex_number_dtypes (line 835) | def complex_number_dtypes(
  function complex_number_dtypes (line 843) | def complex_number_dtypes(
  function complex_number_dtypes (line 851) | def complex_number_dtypes(
  function complex_number_dtypes (line 859) | def complex_number_dtypes(
  function complex_number_dtypes (line 867) | def complex_number_dtypes(
  function validate_time_slice (line 885) | def validate_time_slice(max_period, min_period):
  function datetime64_dtypes (line 911) | def datetime64_dtypes(
  function timedelta64_dtypes (line 925) | def timedelta64_dtypes(
  function byte_string_dtypes (line 939) | def byte_string_dtypes(
  function unicode_string_dtypes (line 954) | def unicode_string_dtypes(
  function _no_title_is_name_of_a_titled_field (line 968) | def _no_title_is_name_of_a_titled_field(ls):
  function array_dtypes (line 981) | def array_dtypes(
  function nested_dtypes (line 1017) | def nested_dtypes(
  function valid_tuple_axes (line 1039) | def valid_tuple_axes(*args, **kwargs):
  function mutually_broadcastable_shapes (line 1054) | def mutually_broadcastable_shapes(*args, **kwargs):
  function basic_indices (line 1100) | def basic_indices(
  function basic_indices (line 1113) | def basic_indices(
  function basic_indices (line 1124) | def basic_indices(
  function basic_indices (line 1135) | def basic_indices(
  function basic_indices (line 1146) | def basic_indices(
  function integer_array_indices (line 1230) | def integer_array_indices(
  function integer_array_indices (line 1238) | def integer_array_indices(
  function integer_array_indices (line 1247) | def integer_array_indices(
  function _unpack_dtype (line 1317) | def _unpack_dtype(dtype):
  function _dtype_from_args (line 1331) | def _dtype_from_args(args):
  function _from_type (line 1348) | def _from_type(thing: type[Ex]) -> st.SearchStrategy[Ex] | None:

FILE: hypothesis-python/src/hypothesis/extra/pandas/impl.py
  function dtype_for_elements_strategy (line 43) | def dtype_for_elements_strategy(s):
  function infer_dtype_if_necessary (line 50) | def infer_dtype_if_necessary(dtype, values, elements, draw):
  function elements_and_dtype (line 57) | def elements_and_dtype(elements, dtype, source=None):
  class ValueIndexStrategy (line 143) | class ValueIndexStrategy(st.SearchStrategy):
    method __init__ (line 144) | def __init__(self, elements, dtype, min_size, max_size, unique, name):
    method do_draw (line 153) | def do_draw(self, data):
  function range_indexes (line 187) | def range_indexes(
  function indexes (line 214) | def indexes(
  function series (line 257) | def series(
  class column (line 367) | class column(Generic[Ex]):
  function columns (line 391) | def columns(
  function data_frames (line 419) | def data_frames(

FILE: hypothesis-python/src/hypothesis/extra/pytz.py
  function timezones (line 39) | def timezones() -> st.SearchStrategy[dt.tzinfo]:

FILE: hypothesis-python/src/hypothesis/extra/redis.py
  class RedisExampleDatabase (line 24) | class RedisExampleDatabase(ExampleDatabase):
    method __init__ (line 36) | def __init__(
    method __repr__ (line 55) | def __repr__(self) -> str:
    method __eq__ (line 60) | def __eq__(self, other: object) -> bool:
    method _pipeline (line 69) | def _pipeline(
    method _publish (line 92) | def _publish(self, event):
    method _encode (line 96) | def _encode(self, value: bytes) -> str:
    method _decode (line 99) | def _decode(self, value: str) -> bytes:
    method fetch (line 102) | def fetch(self, key: bytes) -> Iterable[bytes]:
    method save (line 107) | def save(self, key: bytes, value: bytes) -> None:
    method delete (line 111) | def delete(self, key: bytes, value: bytes) -> None:
    method move (line 115) | def move(self, src: bytes, dest: bytes, value: bytes) -> None:
    method _handle_message (line 132) | def _handle_message(self, message: dict) -> None:
    method _start_listening (line 142) | def _start_listening(self) -> None:
    method _stop_listening (line 146) | def _stop_listening(self) -> None:

FILE: hypothesis-python/src/hypothesis/internal/cache.py
  class Entry (line 23) | class Entry(Generic[K, V]):
    method sort_key (line 30) | def sort_key(self) -> tuple[int, ...]:
  class GenericCache (line 40) | class GenericCache(Generic[K, V]):
    method __init__ (line 65) | def __init__(self, max_size: int):
    method keys_to_indices (line 79) | def keys_to_indices(self) -> dict[K, int]:
    method data (line 87) | def data(self) -> list[Entry[K, V]]:
    method __len__ (line 94) | def __len__(self) -> int:
    method __contains__ (line 98) | def __contains__(self, key: K) -> bool:
    method __getitem__ (line 101) | def __getitem__(self, key: K) -> V:
    method __setitem__ (line 107) | def __setitem__(self, key: K, value: V) -> None:
    method __iter__ (line 138) | def __iter__(self):
    method pin (line 141) | def pin(self, key: K, value: V) -> None:
    method unpin (line 155) | def unpin(self, key: K) -> None:
    method is_pinned (line 166) | def is_pinned(self, key: K) -> bool:
    method clear (line 171) | def clear(self) -> None:
    method __repr__ (line 176) | def __repr__(self) -> str:
    method new_entry (line 179) | def new_entry(self, key: K, value: V) -> int:
    method on_access (line 187) | def on_access(self, key: K, value: V, score: Any) -> Any:
    method on_evict (line 195) | def on_evict(self, key: K, value: V, score: Any) -> Any:
    method check_valid (line 199) | def check_valid(self) -> None:
    method __entry_was_accessed (line 212) | def __entry_was_accessed(self, i: int) -> None:
    method __swap (line 222) | def __swap(self, i: int, j: int) -> None:
    method __balance (line 229) | def __balance(self, i: int) -> None:
    method __out_of_order (line 250) | def __out_of_order(self, i: int, j: int) -> bool:
  class LRUReusedCache (line 259) | class LRUReusedCache(GenericCache[K, V]):
    method __init__ (line 276) | def __init__(self, max_size: int):
    method tick (line 280) | def tick(self) -> int:
    method new_entry (line 284) | def new_entry(self, key: K, value: V) -> Any:
    method on_access (line 287) | def on_access(self, key: K, value: V, score: Any) -> Any:
  class LRUCache (line 291) | class LRUCache(Generic[K, V]):
    method __init__ (line 313) | def __init__(self, max_size: int) -> None:
    method cache (line 319) | def cache(self) -> OrderedDict[K, V]:
    method __setitem__ (line 326) | def __setitem__(self, key: K, value: V) -> None:
    method __getitem__ (line 333) | def __getitem__(self, key: K) -> V:
    method __iter__ (line 338) | def __iter__(self):
    method __len__ (line 341) | def __len__(self) -> int:
    method __contains__ (line 344) | def __contains__(self, key: K) -> bool:
    method check_valid (line 348) | def check_valid(self) -> None:

FILE: hypothesis-python/src/hypothesis/internal/cathetus.py
  function cathetus (line 15) | def cathetus(h: float, a: float) -> float:

FILE: hypothesis-python/src/hypothesis/internal/charmap.py
  function charmap_file (line 72) | def charmap_file(fname: str = "charmap") -> Path:
  function charmap (line 81) | def charmap() -> dict[CategoryName, IntervalsT]:
  function intervals_from_codec (line 145) | def intervals_from_codec(codec_name: str) -> IntervalSet:  # pragma: no ...
  function categories (line 184) | def categories() -> Categories:
  function as_general_categories (line 202) | def as_general_categories(cats: Categories, name: str = "cats") -> Categ...
  function _category_key (line 234) | def _category_key(cats: Iterable[str] | None) -> CategoriesTuple:
  function _query_for_key (line 250) | def _query_for_key(key: Categories) -> IntervalsT:
  function query (line 288) | def query(

FILE: hypothesis-python/src/hypothesis/internal/compat.py
  class NotRequired (line 58) | class NotRequired:
    method __class_getitem__ (line 61) | def __class_getitem__(cls, item):
  function add_note (line 83) | def add_note(exc, note):
  function escape_unicode_characters (line 95) | def escape_unicode_characters(s: str) -> str:
  function int_from_bytes (line 99) | def int_from_bytes(data: bytes | bytearray) -> int:
  function int_to_bytes (line 103) | def int_to_bytes(i: int, size: int) -> bytes:
  function int_to_byte (line 107) | def int_to_byte(i: int) -> bytes:
  function is_typed_named_tuple (line 111) | def is_typed_named_tuple(cls: type) -> bool:
  function _hint_and_args (line 126) | def _hint_and_args(x):
  function get_type_hints (line 130) | def get_type_hints(thing: object) -> dict[str, Any]:
  function floor (line 206) | def floor(x):
  function ceil (line 213) | def ceil(x):
  function extract_bits (line 220) | def extract_bits(x: int, /, width: int | None = None) -> list[int]:
  function bad_django_TestCase (line 239) | def bad_django_TestCase(runner: Optional["ConjectureRunner"]) -> bool:
  function _asdict_inner (line 254) | def _asdict_inner(obj, dict_factory):
  function dataclass_asdict (line 279) | def dataclass_asdict(obj, *, dict_factory=dict):
  function batched (line 299) | def batched(iterable, n, *, strict=False):

FILE: hypothesis-python/src/hypothesis/internal/conjecture/choice.py
  class IntegerConstraints (line 31) | class IntegerConstraints(TypedDict):
  class FloatConstraints (line 38) | class FloatConstraints(TypedDict):
  class StringConstraints (line 45) | class StringConstraints(TypedDict):
  class BytesConstraints (line 51) | class BytesConstraints(TypedDict):
  class BooleanConstraints (line 56) | class BooleanConstraints(TypedDict):
  class ChoiceTemplate (line 75) | class ChoiceTemplate:
    method __post_init__ (line 79) | def __post_init__(self) -> None:
  class ChoiceNode (line 85) | class ChoiceNode:
    method copy (line 92) | def copy(
    method trivial (line 115) | def trivial(self) -> bool:
    method __eq__ (line 154) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 165) | def __hash__(self) -> int:
    method __repr__ (line 175) | def __repr__(self) -> str:
  function _size_to_index (line 180) | def _size_to_index(size: int, *, alphabet_size: int) -> int:
  function _index_to_size (line 194) | def _index_to_size(index: int, alphabet_size: int) -> int:
  function collection_index (line 223) | def collection_index(
  function collection_value (line 252) | def collection_value(
  function zigzag_index (line 288) | def zigzag_index(value: int, *, shrink_towards: int) -> int:
  function zigzag_value (line 297) | def zigzag_value(index: int, *, shrink_towards: int) -> int:
  function choice_to_index (line 307) | def choice_to_index(choice: ChoiceT, constraints: ChoiceConstraintsT) ->...
  function choice_from_index (line 425) | def choice_from_index(
  function choice_permitted (line 524) | def choice_permitted(choice: ChoiceT, constraints: ChoiceConstraintsT) -...
  function choices_key (line 567) | def choices_key(choices: Sequence[ChoiceT]) -> tuple[ChoiceKeyT, ...]:
  function choice_key (line 571) | def choice_key(choice: ChoiceT) -> ChoiceKeyT:
  function choice_equal (line 582) | def choice_equal(choice1: ChoiceT, choice2: ChoiceT) -> bool:
  function choice_constraints_equal (line 587) | def choice_constraints_equal(
  function choice_constraints_key (line 597) | def choice_constraints_key(
  function choices_size (line 619) | def choices_size(choices: Iterable[ChoiceT]) -> int:

FILE: hypothesis-python/src/hypothesis/internal/conjecture/data.py
  function __getattr__ (line 83) | def __getattr__(name: str) -> Any:
  class Status (line 112) | class Status(IntEnum):
    method __repr__ (line 118) | def __repr__(self) -> str:
  class StructuralCoverageTag (line 123) | class StructuralCoverageTag:
  function structural_coverage (line 130) | def structural_coverage(label: int) -> StructuralCoverageTag:
  class Span (line 142) | class Span:
    method __init__ (line 172) | def __init__(self, owner: "Spans", index: int) -> None:
    method __eq__ (line 176) | def __eq__(self, other: object) -> bool:
    method __ne__ (line 183) | def __ne__(self, other: object) -> bool:
    method __repr__ (line 190) | def __repr__(self) -> str:
    method label (line 194) | def label(self) -> int:
    method parent (line 201) | def parent(self) -> int | None:
    method start (line 208) | def start(self) -> int:
    method end (line 212) | def end(self) -> int:
    method depth (line 216) | def depth(self) -> int:
    method discarded (line 223) | def discarded(self) -> bool:
    method choice_count (line 232) | def choice_count(self) -> int:
    method children (line 237) | def children(self) -> "list[Span]":
  class SpanProperty (line 243) | class SpanProperty:
    method __init__ (line 252) | def __init__(self, spans: "Spans"):
    method run (line 258) | def run(self) -> Any:
    method __push (line 274) | def __push(self, label_index: int) -> None:
    method __pop (line 281) | def __pop(self, *, discarded: bool) -> None:
    method start_span (line 285) | def start_span(self, i: int, label_index: int) -> None:
    method stop_span (line 290) | def stop_span(self, i: int, *, discarded: bool) -> None:
    method finish (line 295) | def finish(self) -> Any:
  class TrailType (line 299) | class TrailType(IntEnum):
  class SpanRecord (line 308) | class SpanRecord:
    method __init__ (line 319) | def __init__(self) -> None:
    method freeze (line 325) | def freeze(self) -> None:
    method record_choice (line 328) | def record_choice(self) -> None:
    method start_span (line 331) | def start_span(self, label: int) -> None:
    method stop_span (line 340) | def stop_span(self, *, discard: bool) -> None:
  class _starts_and_ends (line 347) | class _starts_and_ends(SpanProperty):
    method __init__ (line 348) | def __init__(self, spans: "Spans") -> None:
    method start_span (line 353) | def start_span(self, i: int, label_index: int) -> None:
    method stop_span (line 356) | def stop_span(self, i: int, *, discarded: bool) -> None:
    method finish (line 359) | def finish(self) -> tuple[IntList, IntList]:
  class _discarded (line 363) | class _discarded(SpanProperty):
    method __init__ (line 364) | def __init__(self, spans: "Spans") -> None:
    method finish (line 368) | def finish(self) -> frozenset[int]:
    method stop_span (line 371) | def stop_span(self, i: int, *, discarded: bool) -> None:
  class _parentage (line 376) | class _parentage(SpanProperty):
    method __init__ (line 377) | def __init__(self, spans: "Spans") -> None:
    method stop_span (line 381) | def stop_span(self, i: int, *, discarded: bool) -> None:
    method finish (line 385) | def finish(self) -> IntList:
  class _depths (line 389) | class _depths(SpanProperty):
    method __init__ (line 390) | def __init__(self, spans: "Spans") -> None:
    method start_span (line 394) | def start_span(self, i: int, label_index: int) -> None:
    method finish (line 397) | def finish(self) -> IntList:
  class _label_indices (line 401) | class _label_indices(SpanProperty):
    method __init__ (line 402) | def __init__(self, spans: "Spans") -> None:
    method start_span (line 406) | def start_span(self, i: int, label_index: int) -> None:
    method finish (line 409) | def finish(self) -> IntList:
  class _mutator_groups (line 413) | class _mutator_groups(SpanProperty):
    method __init__ (line 414) | def __init__(self, spans: "Spans") -> None:
    method start_span (line 418) | def start_span(self, i: int, label_index: int) -> None:
    method finish (line 425) | def finish(self) -> Iterable[set[tuple[int, int]]]:
  class Spans (line 431) | class Spans:
    method __init__ (line 442) | def __init__(self, record: SpanRecord) -> None:
    method starts_and_ends (line 451) | def starts_and_ends(self) -> tuple[IntList, IntList]:
    method starts (line 455) | def starts(self) -> IntList:
    method ends (line 459) | def ends(self) -> IntList:
    method discarded (line 463) | def discarded(self) -> frozenset[int]:
    method parentage (line 467) | def parentage(self) -> IntList:
    method depths (line 471) | def depths(self) -> IntList:
    method label_indices (line 475) | def label_indices(self) -> IntList:
    method mutator_groups (line 479) | def mutator_groups(self) -> list[set[tuple[int, int]]]:
    method children (line 483) | def children(self) -> list[Sequence[int]]:
    method __len__ (line 497) | def __len__(self) -> int:
    method __getitem__ (line 500) | def __getitem__(self, i: int) -> Span:
    method __iter__ (line 510) | def __iter__(self) -> Iterator[Span]:
  class _Overrun (line 515) | class _Overrun:
    method __repr__ (line 518) | def __repr__(self) -> str:
  class DataObserver (line 525) | class DataObserver:
    method conclude_test (line 530) | def conclude_test(
    method kill_branch (line 541) | def kill_branch(self) -> None:
    method draw_integer (line 544) | def draw_integer(
    method draw_float (line 549) | def draw_float(
    method draw_string (line 554) | def draw_string(
    method draw_bytes (line 559) | def draw_bytes(
    method draw_boolean (line 564) | def draw_boolean(
  class ConjectureResult (line 571) | class ConjectureResult:
    method as_result (line 592) | def as_result(self) -> "ConjectureResult":
    method choices (line 596) | def choices(self) -> tuple[ChoiceT, ...]:
  class ConjectureData (line 600) | class ConjectureData:
    method for_choices (line 602) | def for_choices(
    method __init__ (line 620) | def __init__(
    method __repr__ (line 718) | def __repr__(self) -> str:
    method choices (line 726) | def choices(self) -> tuple[ChoiceT, ...]:
    method _draw (line 739) | def _draw(
    method _draw (line 749) | def _draw(
    method _draw (line 759) | def _draw(
    method _draw (line 769) | def _draw(
    method _draw (line 779) | def _draw(
    method _draw (line 788) | def _draw(
    method draw_integer (line 864) | def draw_integer(
    method draw_float (line 903) | def draw_float(
    method draw_string (line 947) | def draw_string(
    method draw_bytes (line 971) | def draw_bytes(
    method draw_boolean (line 987) | def draw_boolean(
    method _pooled_constraints (line 1001) | def _pooled_constraints(
    method _pooled_constraints (line 1006) | def _pooled_constraints(
    method _pooled_constraints (line 1011) | def _pooled_constraints(
    method _pooled_constraints (line 1016) | def _pooled_constraints(
    method _pooled_constraints (line 1021) | def _pooled_constraints(
    method _pooled_constraints (line 1025) | def _pooled_constraints(
    method _pop_choice (line 1040) | def _pop_choice(
    method as_result (line 1129) | def as_result(self) -> ConjectureResult | _Overrun:
    method __assert_not_frozen (line 1157) | def __assert_not_frozen(self, name: str) -> None:
    method note (line 1161) | def note(self, value: Any) -> None:
    method draw (line 1167) | def draw(
    method start_span (line 1229) | def start_span(self, label: int) -> None:
    method stop_span (line 1244) | def stop_span(self, *, discard: bool = False) -> None:
    method spans (line 1290) | def spans(self) -> Spans:
    method freeze (line 1296) | def freeze(self) -> None:
    method choice (line 1310) | def choice(
    method conclude_test (line 1326) | def conclude_test(
    method mark_interesting (line 1338) | def mark_interesting(self, interesting_origin: InterestingOrigin) -> N...
    method mark_invalid (line 1341) | def mark_invalid(self, why: str | None = None) -> NoReturn:
    method mark_overrun (line 1346) | def mark_overrun(self) -> NoReturn:
  function draw_choice (line 1350) | def draw_choice(

FILE: hypothesis-python/src/hypothesis/internal/conjecture/datatree.py
  class PreviouslyUnseenBehaviour (line 52) | class PreviouslyUnseenBehaviour(HypothesisException):
  class Killed (line 67) | class Killed:
    method _repr_pretty_ (line 75) | def _repr_pretty_(self, p: "RepresentationPrinter", cycle: bool) -> None:
  function _node_pretty (line 80) | def _node_pretty(
  class Branch (line 92) | class Branch:
    method max_children (line 101) | def max_children(self) -> int:
    method _repr_pretty_ (line 106) | def _repr_pretty_(self, p: "RepresentationPrinter", cycle: bool) -> None:
  class Conclusion (line 120) | class Conclusion:
    method _repr_pretty_ (line 126) | def _repr_pretty_(self, p: "RepresentationPrinter", cycle: bool) -> None:
  function _count_distinct_strings (line 161) | def _count_distinct_strings(*, alphabet_size: int, min_size: int, max_si...
  function compute_max_children (line 201) | def compute_max_children(
  function _floats_between (line 288) | def _floats_between(a: float, b: float) -> Generator[float, None, None]:
  function all_children (line 293) | def all_children(
  class TreeNode (line 337) | class TreeNode:
    method forced (line 431) | def forced(self) -> Set[int]:
    method mark_forced (line 436) | def mark_forced(self, i: int) -> None:
    method split_at (line 445) | def split_at(self, i: int) -> None:
    method check_exhausted (line 480) | def check_exhausted(self) -> bool:
    method _repr_pretty_ (line 524) | def _repr_pretty_(self, p: "RepresentationPrinter", cycle: bool) -> None:
  class DataTree (line 549) | class DataTree:
    method __init__ (line 693) | def __init__(self) -> None:
    method is_exhausted (line 698) | def is_exhausted(self) -> bool:
    method generate_novel_prefix (line 705) | def generate_novel_prefix(self, random: Random) -> tuple[ChoiceT, ...]:
    method rewrite (line 820) | def rewrite(self, choices):
    method simulate_test_function (line 832) | def simulate_test_function(self, data: ConjectureData) -> None:
    method new_observer (line 880) | def new_observer(self):
    method _draw (line 883) | def _draw(
    method _get_children_cache (line 906) | def _get_children_cache(
    method _draw_from_cache (line 926) | def _draw_from_cache(
    method _reject_child (line 956) | def _reject_child(
    method _repr_pretty_ (line 987) | def _repr_pretty_(self, p: "RepresentationPrinter", cycle: bool) -> None:
  class TreeRecordingObserver (line 992) | class TreeRecordingObserver(DataObserver):
    method __init__ (line 993) | def __init__(self, tree: DataTree):
    method draw_integer (line 1003) | def draw_integer(
    method draw_float (line 1010) | def draw_float(
    method draw_string (line 1015) | def draw_string(
    method draw_bytes (line 1020) | def draw_bytes(
    method draw_boolean (line 1025) | def draw_boolean(
    method draw_value (line 1032) | def draw_value(
    method kill_branch (line 1119) | def kill_branch(self) -> None:
    method conclude_test (line 1140) | def conclude_test(
    method __update_exhausted (line 1181) | def __update_exhausted(self) -> None:

FILE: hypothesis-python/src/hypothesis/internal/conjecture/engine.py
  function shortlex (line 111) | def shortlex(s):
  class HealthCheckState (line 116) | class HealthCheckState:
    method total_draw_time (line 125) | def total_draw_time(self) -> float:
    method timing_report (line 128) | def timing_report(self) -> str:
  function _invalid_thresholds (line 157) | def _invalid_thresholds(*, r: float, c: float) -> tuple[int, int]:
  class ExitReason (line 169) | class ExitReason(Enum):
    method describe (line 180) | def describe(self, settings: Settings) -> str:
  class RunIsComplete (line 184) | class RunIsComplete(Exception):
  function _get_provider (line 188) | def _get_provider(backend: str) -> PrimitiveProvider | type[PrimitivePro...
  class CallStats (line 205) | class CallStats(TypedDict):
  function choice_count (line 235) | def choice_count(choices: Sequence[ChoiceT | ChoiceTemplate]) -> int | N...
  class DiscardObserver (line 247) | class DiscardObserver(DataObserver):
    method kill_branch (line 249) | def kill_branch(self) -> NoReturn:
  function realize_choices (line 253) | def realize_choices(data: ConjectureData, *, for_failure: bool) -> None:
  class ConjectureRunner (line 280) | class ConjectureRunner:
    method __init__ (line 281) | def __init__(
    method _with_switch_to_hypothesis_provider (line 357) | def _with_switch_to_hypothesis_provider(
    method using_hypothesis_backend (line 368) | def using_hypothesis_backend(self) -> bool:
    method explain_next_call_as (line 373) | def explain_next_call_as(self, explanation: str) -> None:
    method clear_call_explanation (line 376) | def clear_call_explanation(self) -> None:
    method _log_phase_statistics (line 380) | def _log_phase_statistics(
    method should_optimise (line 397) | def should_optimise(self) -> bool:
    method __tree_is_exhausted (line 400) | def __tree_is_exhausted(self) -> bool:
    method __stoppable_test_function (line 403) | def __stoppable_test_function(self, data: ConjectureData) -> None:
    method _cache_key (line 426) | def _cache_key(self, choices: Sequence[ChoiceT]) -> tuple[ChoiceKeyT, ...
    method _cache (line 429) | def _cache(self, data: ConjectureData) -> None:
    method cached_test_function (line 434) | def cached_test_function(
    method test_function (line 511) | def test_function(self, data: ConjectureData) -> None:
    method on_pareto_evict (line 749) | def on_pareto_evict(self, data: ConjectureResult) -> None:
    method generate_novel_prefix (line 752) | def generate_novel_prefix(self) -> tuple[ChoiceT, ...]:
    method record_for_health_check (line 762) | def record_for_health_check(self, data: ConjectureData) -> None:
    method save_choices (line 890) | def save_choices(
    method downgrade_choices (line 899) | def downgrade_choices(self, choices: Sequence[ChoiceT]) -> None:
    method sub_key (line 904) | def sub_key(self, sub_key: bytes | None) -> bytes | None:
    method secondary_key (line 912) | def secondary_key(self) -> bytes | None:
    method pareto_key (line 916) | def pareto_key(self) -> bytes | None:
    method debug (line 919) | def debug(self, message: str) -> None:
    method report_debug_info (line 924) | def report_debug_info(self) -> bool:
    method debug_data (line 927) | def debug_data(self, data: ConjectureData | ConjectureResult) -> None:
    method observe_for_provider (line 944) | def observe_for_provider(self) -> AbstractContextManager:
    method run (line 964) | def run(self) -> None:
    method database (line 978) | def database(self) -> ExampleDatabase | None:
    method has_existing_examples (line 983) | def has_existing_examples(self) -> bool:
    method reuse_existing_examples (line 986) | def reuse_existing_examples(self) -> None:
    method exit_with (line 1084) | def exit_with(self, reason: ExitReason) -> None:
    method should_generate_more (line 1094) | def should_generate_more(self) -> bool:
    method generate_new_examples (line 1134) | def generate_new_examples(self) -> None:
    method generate_mutations_from (line 1325) | def generate_mutations_from(self, data: ConjectureData | ConjectureRes...
    method optimise_targets (line 1483) | def optimise_targets(self) -> None:
    method pareto_optimise (line 1523) | def pareto_optimise(self) -> None:
    method _run (line 1527) | def _run(self) -> None:
    method new_conjecture_data (line 1553) | def new_conjecture_data(
    method shrink_interesting_examples (line 1575) | def shrink_interesting_examples(self) -> None:
    method clear_secondary_key (line 1626) | def clear_secondary_key(self) -> None:
    method shrink (line 1656) | def shrink(
    method new_shrinker (line 1668) | def new_shrinker(
    method passing_choice_sequences (line 1685) | def passing_choice_sequences(
  class ContainsDiscard (line 1699) | class ContainsDiscard(Exception):

FILE: hypothesis-python/src/hypothesis/internal/conjecture/floats.py
  function exponent_key (line 82) | def exponent_key(e: int) -> float:
  function decode_exponent (line 101) | def decode_exponent(e: int) -> int:
  function encode_exponent (line 108) | def encode_exponent(e: int) -> int:
  function reverse_byte (line 115) | def reverse_byte(b: int) -> int:
  function reverse64 (line 131) | def reverse64(v: int) -> int:
  function reverse_bits (line 158) | def reverse_bits(x: int, n: int) -> int:
  function update_mantissa (line 165) | def update_mantissa(unbiased_exponent: int, mantissa: int) -> int:
  function lex_to_float (line 176) | def lex_to_float(i: int) -> float:
  function float_to_lex (line 193) | def float_to_lex(f: float) -> int:
  function base_float_to_lex (line 200) | def base_float_to_lex(f: float) -> int:
  function is_simple (line 212) | def is_simple(f: float) -> int:

FILE: hypothesis-python/src/hypothesis/internal/conjecture/junkdrawer.py
  function replace_all (line 41) | def replace_all(
  class IntList (line 63) | class IntList(Sequence[int]):
    method __init__ (line 76) | def __init__(self, values: Sequence[int] = ()):
    method of_length (line 92) | def of_length(cls, n: int) -> "IntList":
    method _array_or_list (line 96) | def _array_or_list(
    method count (line 103) | def count(self, value: int) -> int:
    method __repr__ (line 106) | def __repr__(self) -> str:
    method __len__ (line 109) | def __len__(self) -> int:
    method __getitem__ (line 113) | def __getitem__(self, i: int) -> int: ...  # pragma: no cover
    method __getitem__ (line 116) | def __getitem__(
    method __getitem__ (line 120) | def __getitem__(self, i: int | slice) -> "int | list[int] | ArrayType[...
    method __delitem__ (line 123) | def __delitem__(self, i: int | slice) -> None:
    method insert (line 126) | def insert(self, i: int, v: int) -> None:
    method __iter__ (line 129) | def __iter__(self) -> Iterator[int]:
    method __eq__ (line 132) | def __eq__(self, other: object) -> bool:
    method __ne__ (line 139) | def __ne__(self, other: object) -> bool:
    method append (line 146) | def append(self, n: int) -> None:
    method __setitem__ (line 156) | def __setitem__(self, i: int, n: int) -> None:
    method extend (line 165) | def extend(self, ls: Iterable[int]) -> None:
    method __upgrade (line 169) | def __upgrade(self) -> None:
  function binary_search (line 175) | def binary_search(lo: int, hi: int, f: Callable[[int], bool]) -> int:
  class LazySequenceCopy (line 193) | class LazySequenceCopy(Generic[T]):
    method __init__ (line 200) | def __init__(self, values: Sequence[T]):
    method __len__ (line 206) | def __len__(self) -> int:
    method pop (line 211) | def pop(self, i: int = -1) -> T:
    method swap (line 227) | def swap(self, i: int, j: int) -> None:
    method __getitem__ (line 233) | def __getitem__(self, i: int) -> T:
    method __setitem__ (line 242) | def __setitem__(self, i: int, v: T) -> None:
    method __underlying_index (line 248) | def __underlying_index(self, i: int) -> int:
    method __iter__ (line 274) | def __iter__(self) -> Iterable[T]:
  function stack_depth_of_caller (line 279) | def stack_depth_of_caller() -> int:
  class StackframeLimiter (line 295) | class StackframeLimiter:
    method __init__ (line 310) | def __init__(self):
    method _setrecursionlimit (line 315) | def _setrecursionlimit(self, new_limit: int, *, check: bool = True) ->...
    method enter_context (line 331) | def enter_context(self, new_limit: int, *, current_limit: int) -> None:
    method exit_context (line 342) | def exit_context(self, new_limit: int, *, check: bool = True) -> None:
  class ensure_free_stackframes (line 366) | class ensure_free_stackframes:
    method __enter__ (line 371) | def __enter__(self) -> None:
    method __exit__ (line 401) | def __exit__(self, *args, **kwargs):
  function find_integer (line 406) | def find_integer(f: Callable[[int], bool]) -> int:
  function gc_cumulative_time (line 453) | def gc_cumulative_time() -> float:
  function startswith (line 504) | def startswith(l1: Sequence[T], l2: Sequence[T]) -> bool:
  function endswith (line 510) | def endswith(l1: Sequence[T], l2: Sequence[T]) -> bool:
  function bits_to_bytes (line 516) | def bits_to_bytes(n: int) -> int:

FILE: hypothesis-python/src/hypothesis/internal/conjecture/optimiser.py
  class Optimiser (line 19) | class Optimiser:
    method __init__ (line 35) | def __init__(
    method run (line 52) | def run(self) -> None:
    method score_function (line 55) | def score_function(self, data: ConjectureResult) -> float:
    method current_score (line 59) | def current_score(self) -> float:
    method consider_new_data (line 62) | def consider_new_data(self, data: ConjectureResult | _Overrun) -> bool:
    method hill_climb (line 84) | def hill_climb(self) -> None:

FILE: hypothesis-python/src/hypothesis/internal/conjecture/pareto.py
  class DominanceRelation (line 34) | class DominanceRelation(Enum):
  function dominance (line 41) | def dominance(left: ConjectureResult, right: ConjectureResult) -> Domina...
  class ParetoFront (line 104) | class ParetoFront:
    method __init__ (line 140) | def __init__(self, random: Random) -> None:
    method add (line 149) | def add(self, data: ConjectureData | ConjectureResult | _Overrun) -> b...
    method on_evict (line 257) | def on_evict(self, f: Callable[[ConjectureResult], None]) -> None:
    method __contains__ (line 262) | def __contains__(self, data: object) -> bool:
    method __iter__ (line 272) | def __iter__(self) -> Iterator[ConjectureResult]:
    method __getitem__ (line 275) | def __getitem__(self, i: int) -> ConjectureResult:
    method __len__ (line 278) | def __len__(self) -> int:
    method _remove (line 281) | def _remove(self, data: ConjectureResult) -> None:
  class ParetoOptimiser (line 291) | class ParetoOptimiser:
    method __init__ (line 301) | def __init__(self, engine: "ConjectureRunner") -> None:
    method run (line 306) | def run(self) -> None:

FILE: hypothesis-python/src/hypothesis/internal/conjecture/provider_conformance.py
  function build_intervals (line 43) | def build_intervals(intervals: list[int]) -> list[tuple[int, int]]:
  function interval_lists (line 51) | def interval_lists(
  function intervals (line 65) | def intervals(
  function integer_weights (line 77) | def integer_weights(
  function integer_constraints (line 101) | def integer_constraints(
  function _collection_constraints (line 168) | def _collection_constraints(
  function string_constraints (line 204) | def string_constraints(
  function bytes_constraints (line 229) | def bytes_constraints(
  function float_constraints (line 247) | def float_constraints(
  function boolean_constraints (line 307) | def boolean_constraints(draw: DrawFn, *, use_forced: bool = False) -> Any:
  function constraints_strategy (line 315) | def constraints_strategy(choice_type, strategy_constraints=None, *, use_...
  function choice_types_constraints (line 328) | def choice_types_constraints(strategy_constraints=None, *, use_forced=Fa...
  function run_conformance_test (line 339) | def run_conformance_test(

FILE: hypothesis-python/src/hypothesis/internal/conjecture/providers.py
  function _get_local_constants (line 282) | def _get_local_constants() -> Constants:
  function with_register_backend (line 348) | def with_register_backend(name, provider_cls):
  class _BackendInfoMsg (line 356) | class _BackendInfoMsg(TypedDict):
  class PrimitiveProvider (line 365) | class PrimitiveProvider(abc.ABC):
    method __init__ (line 427) | def __init__(self, conjecturedata: Optional["ConjectureData"], /) -> N...
    method draw_boolean (line 431) | def draw_boolean(
    method draw_integer (line 452) | def draw_integer(
    method draw_float (line 481) | def draw_float(
    method draw_string (line 507) | def draw_string(
    method draw_bytes (line 529) | def draw_bytes(
    method per_test_case_context_manager (line 546) | def per_test_case_context_manager(self) -> AbstractContextManager:
    method realize (line 563) | def realize(self, value: T, *, for_failure: bool = False) -> T:
    method replay_choices (line 582) | def replay_choices(self, choices: tuple[ChoiceT, ...]) -> None:
    method observe_test_case (line 594) | def observe_test_case(self) -> dict[str, Any]:
    method observe_information_messages (line 603) | def observe_information_messages(
    method on_observation (line 615) | def on_observation(self, observation: TestCaseObservation) -> None:  #...
    method span_start (line 651) | def span_start(self, label: int, /) -> None:  # noqa: B027  # non-abst...
    method span_end (line 709) | def span_end(self, discard: bool, /) -> None:  # noqa: B027
  class HypothesisProvider (line 721) | class HypothesisProvider(PrimitiveProvider):
    method __init__ (line 724) | def __init__(self, conjecturedata: Optional["ConjectureData"], /):
    method _local_constants (line 729) | def _local_constants(self):
    method _maybe_draw_constant (line 733) | def _maybe_draw_constant(
    method draw_boolean (line 782) | def draw_boolean(
    method draw_integer (line 795) | def draw_integer(
    method draw_float (line 867) | def draw_float(
    method draw_string (line 933) | def draw_string(
    method draw_bytes (line 981) | def draw_bytes(
    method _draw_float (line 1014) | def _draw_float(self) -> float:
    method _draw_unbounded_integer (line 1021) | def _draw_unbounded_integer(self) -> int:
    method _draw_bounded_integer (line 1034) | def _draw_bounded_integer(
  class BytestringProvider (line 1067) | class BytestringProvider(PrimitiveProvider):
    method __init__ (line 1070) | def __init__(
    method _draw_bits (line 1078) | def _draw_bits(self, n):
    method draw_boolean (line 1092) | def draw_boolean(
    method draw_integer (line 1112) | def draw_integer(
    method draw_float (line 1144) | def draw_float(
    method _draw_collection (line 1163) | def _draw_collection(self, min_size, max_size, *, alphabet_size):
    method draw_string (line 1180) | def draw_string(
    method draw_bytes (line 1190) | def draw_bytes(
  class URandom (line 1199) | class URandom(Random):
    method _urandom (line 1204) | def _urandom(size: int) -> bytes:
    method getrandbits (line 1208) | def getrandbits(self, k: int) -> int:
    method random (line 1215) | def random(self) -> float:
  class URandomProvider (line 1220) | class URandomProvider(HypothesisProvider):
    method __init__ (line 1230) | def __init__(self, conjecturedata: Optional["ConjectureData"], /):

FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinker.py
  function sort_key (line 68) | def sort_key(nodes: Sequence[ChoiceNode]) -> tuple[int, tuple[int, ...]]:
  class ShrinkPass (line 93) | class ShrinkPass:
    method __post_init__ (line 104) | def __post_init__(self):
    method __hash__ (line 108) | def __hash__(self):
  class StopShrinking (line 112) | class StopShrinking(Exception):
  class Shrinker (line 116) | class Shrinker:
    method derived_value (line 251) | def derived_value(fn):
    method __init__ (line 268) | def __init__(
    method cached_calculations (line 332) | def cached_calculations(self):
    method cached (line 335) | def cached(self, *keys):
    method calls (line 346) | def calls(self) -> int:
    method misaligned (line 352) | def misaligned(self) -> int:
    method check_calls (line 355) | def check_calls(self) -> None:
    method cached_test_function (line 359) | def cached_test_function(
    method consider_new_nodes (line 383) | def consider_new_nodes(self, nodes: Sequence[ChoiceNode]) -> bool:
    method incorporate_test_data (line 386) | def incorporate_test_data(self, data):
    method debug (line 398) | def debug(self, msg: str) -> None:
    method random (line 402) | def random(self) -> "Random":
    method shrink (line 405) | def shrink(self) -> None:
    method explain (line 461) | def explain(self) -> None:
    method greedy_shrink (line 614) | def greedy_shrink(self) -> None:
    method initial_coarse_reduction (line 623) | def initial_coarse_reduction(self):
    method spans_starting_at (line 637) | def spans_starting_at(self):
    method reduce_each_alternative (line 645) | def reduce_each_alternative(self):
    method try_lower_node_as_alternative (line 706) | def try_lower_node_as_alternative(self, i, v):
    method shrink_pass_choice_trees (line 738) | def shrink_pass_choice_trees(self) -> dict[Any, ChoiceTree]:
    method step (line 741) | def step(self, shrink_pass: ShrinkPass, *, random_order: bool = False)...
    method fixate_shrink_passes (line 771) | def fixate_shrink_passes(self, passes: list[ShrinkPass]) -> None:
    method nodes (line 866) | def nodes(self) -> tuple[ChoiceNode, ...]:
    method choices (line 870) | def choices(self) -> tuple[ChoiceT, ...]:
    method spans (line 874) | def spans(self) -> Spans:
    method spans_by_label (line 878) | def spans_by_label(self):
    method distinct_labels (line 890) | def distinct_labels(self):
    method pass_to_descendant (line 893) | def pass_to_descendant(self, chooser):
    method lower_common_node_offset (line 951) | def lower_common_node_offset(self):
    method clear_change_tracking (line 1031) | def clear_change_tracking(self):
    method mark_changed (line 1035) | def mark_changed(self, i):
    method __changed_nodes (line 1039) | def __changed_nodes(self) -> set[int]:
    method update_shrink_target (line 1064) | def update_shrink_target(self, new_target):
    method try_shrinking_nodes (line 1080) | def try_shrinking_nodes(self, nodes, n):
    method remove_discarded (line 1224) | def remove_discarded(self):
    method duplicated_nodes (line 1267) | def duplicated_nodes(self):
    method node_program (line 1274) | def node_program(self, program: str) -> ShrinkPass:
    method _node_program (line 1280) | def _node_program(self, chooser, program):
    method minimize_duplicated_choices (line 1313) | def minimize_duplicated_choices(self, chooser):
    method redistribute_numeric_pairs (line 1342) | def redistribute_numeric_pairs(self, chooser):
    method lower_integers_together (line 1418) | def lower_integers_together(self, chooser):
    method lower_duplicated_characters (line 1450) | def lower_duplicated_characters(self, chooser):
    method minimize_nodes (line 1511) | def minimize_nodes(self, nodes):
    method try_trivial_spans (line 1572) | def try_trivial_spans(self, chooser):
    method minimize_individual_choices (line 1602) | def minimize_individual_choices(self, chooser):
    method reorder_spans (line 1702) | def reorder_spans(self, chooser):
    method run_node_program (line 1749) | def run_node_program(self, i, program, original, repeats=1):

FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/bytes.py
  class Bytes (line 15) | class Bytes(Collection):
    method __init__ (line 16) | def __init__(self, initial, predicate, **kwargs):

FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/choicetree.py
  function prefix_selection_order (line 18) | def prefix_selection_order(
  function random_selection_order (line 38) | def random_selection_order(random: Random) -> Callable[[int, int], Itera...
  class Chooser (line 50) | class Chooser:
    method __init__ (line 53) | def __init__(
    method choose (line 63) | def choose(
    method finish (line 95) | def finish(self) -> Sequence[int]:
  class ChoiceTree (line 116) | class ChoiceTree:
    method __init__ (line 123) | def __init__(self) -> None:
    method exhausted (line 127) | def exhausted(self) -> bool:
    method step (line 130) | def step(
  class TreeNode (line 145) | class TreeNode:
    method __init__ (line 146) | def __init__(self) -> None:
    method exhausted (line 152) | def exhausted(self) -> bool:
  class DeadBranch (line 160) | class DeadBranch(Exception):

FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/collection.py
  class Collection (line 18) | class Collection(Shrinker):
    method setup (line 19) | def setup(
    method make_immutable (line 27) | def make_immutable(self, value):
    method short_circuit (line 30) | def short_circuit(self):
    method left_is_better (line 34) | def left_is_better(self, left, right):
    method run_step (line 49) | def run_step(self):

FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/common.py
  class Shrinker (line 14) | class Shrinker:
    method __init__ (line 19) | def __init__(
    method calls (line 41) | def calls(self) -> int:
    method __repr__ (line 44) | def __repr__(self) -> str:
    method setup (line 52) | def setup(self, **kwargs):
    method delegate (line 59) | def delegate(self, other_class, convert_to, convert_from, **kwargs):
    method call_shrinker (line 69) | def call_shrinker(self, other_class, initial, predicate, **kwargs):
    method debug (line 78) | def debug(self, *args: object) -> None:
    method shrink (line 83) | def shrink(cls, initial, predicate, **kwargs):
    method run (line 93) | def run(self):
    method consider (line 110) | def consider(self, value):
    method make_canonical (line 137) | def make_canonical(self, value):
    method make_immutable (line 148) | def make_immutable(self, value):
    method check_invariants (line 157) | def check_invariants(self, value):
    method short_circuit (line 164) | def short_circuit(self):
    method left_is_better (line 172) | def left_is_better(self, left, right):
    method run_step (line 177) | def run_step(self):

FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/floats.py
  class Float (line 20) | class Float(Shrinker):
    method setup (line 21) | def setup(self):
    method make_canonical (line 24) | def make_canonical(self, f):
    method check_invariants (line 31) | def check_invariants(self, value):
    method left_is_better (line 36) | def left_is_better(self, left, right):
    method short_circuit (line 41) | def short_circuit(self):
    method run_step (line 53) | def run_step(self):

FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/integer.py
  class Integer (line 19) | class Integer(Shrinker):
    method short_circuit (line 26) | def short_circuit(self):
    method check_invariants (line 37) | def check_invariants(self, value):
    method left_is_better (line 40) | def left_is_better(self, left, right):
    method run_step (line 43) | def run_step(self):
    method shift_right (line 48) | def shift_right(self):
    method mask_high_bits (line 52) | def mask_high_bits(self):
    method size (line 64) | def size(self) -> int:
    method shrink_by_multiples (line 67) | def shrink_by_multiples(self, k):

FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/ordering.py
  class Ordering (line 16) | class Ordering(Shrinker):
    method setup (line 23) | def setup(self, key=identity):
    method make_immutable (line 26) | def make_immutable(self, value):
    method short_circuit (line 29) | def short_circuit(self):
    method left_is_better (line 33) | def left_is_better(self, left, right):
    method check_invariants (line 36) | def check_invariants(self, value):
    method run_step (line 40) | def run_step(self):
    method sort_regions (line 44) | def sort_regions(self):
    method sort_regions_with_gaps (line 64) | def sort_regions_with_gaps(self):

FILE: hypothesis-python/src/hypothesis/internal/conjecture/shrinking/string.py
  class String (line 15) | class String(Collection):
    method __init__ (line 16) | def __init__(self, initial, predicate, *, intervals, **kwargs):

FILE: hypothesis-python/src/hypothesis/internal/conjecture/utils.py
  function calc_label_from_name (line 34) | def calc_label_from_name(name: str) -> int:
  function calc_label_from_callable (line 39) | def calc_label_from_callable(f: Callable) -> int:
  function calc_label_from_cls (line 53) | def calc_label_from_cls(cls: type) -> int:
  function calc_label_from_hash (line 57) | def calc_label_from_hash(obj: object) -> int:
  function combine_labels (line 61) | def combine_labels(*labels: int) -> int:
  function identity (line 76) | def identity(v: T) -> T:
  function check_sample (line 80) | def check_sample(
  function compute_sampler_table (line 113) | def compute_sampler_table(weights: tuple[float, ...]) -> list[tuple[int,...
  class Sampler (line 179) | class Sampler:
    method __init__ (line 199) | def __init__(self, weights: Sequence[float], *, observe: bool = True):
    method sample (line 203) | def sample(
  class many (line 252) | class many:
    method __init__ (line 264) | def __init__(
    method stop_span (line 288) | def stop_span(self):
    method start_span (line 292) | def start_span(self, label):
    method more (line 296) | def more(self) -> bool:
    method reject (line 335) | def reject(self, why: str | None = None) -> None:
  function _calc_p_continue (line 355) | def _calc_p_continue(desired_avg: float, max_size: int | float) -> float:
  function _p_continue_to_avg (line 393) | def _p_continue_to_avg(p_continue: float, max_size: int | float) -> float:

FILE: hypothesis-python/src/hypothesis/internal/constants_ast.py
  class Constants (line 35) | class Constants:
    method __init__ (line 36) | def __init__(
    method set_for_type (line 49) | def set_for_type(
    method add (line 62) | def add(self, constant: ConstantT) -> None:
    method __contains__ (line 65) | def __contains__(self, constant: ConstantT) -> bool:
    method __or__ (line 68) | def __or__(self, other: "Constants") -> "Constants":
    method __iter__ (line 76) | def __iter__(self) -> Iterator[ConstantT]:
    method __len__ (line 79) | def __len__(self) -> int:
    method __repr__ (line 84) | def __repr__(self) -> str:
    method __eq__ (line 87) | def __eq__(self, other: object) -> bool:
  class TooManyConstants (line 98) | class TooManyConstants(Exception):
  class ConstantVisitor (line 104) | class ConstantVisitor(NodeVisitor):
    method __init__ (line 107) | def __init__(self, *, limit: bool):
    method _add_constant (line 112) | def _add_constant(self, value: object) -> None:
    method visit_UnaryOp (line 148) | def visit_UnaryOp(self, node: UnaryOp) -> None:
    method visit_Expr (line 162) | def visit_Expr(self, node: Expr) -> None:
    method visit_JoinedStr (line 168) | def visit_JoinedStr(self, node):
    method visit_Constant (line 173) | def visit_Constant(self, node):
  function _constants_from_source (line 178) | def _constants_from_source(source: str | bytes, *, limit: bool) -> Const...
  function _constants_file_str (line 192) | def _constants_file_str(constants: Constants) -> str:
  function constants_from_module (line 197) | def constants_from_module(module: ModuleType, *, limit: bool = True) -> ...
  function is_local_module_file (line 250) | def is_local_module_file(path: str) -> bool:

FILE: hypothesis-python/src/hypothesis/internal/coverage.py
  function pretty_file_name (line 37) | def pretty_file_name(f):
  function record_branch (line 61) | def record_branch(name, value):
  function check_block (line 70) | def check_block(name, depth):
  function check (line 89) | def check(name):
  function check_function (line 93) | def check_function(f: Func) -> Func:
  function check_function (line 104) | def check_function(f: Func) -> Func:
  function check (line 108) | def check(name):

FILE: hypothesis-python/src/hypothesis/internal/detection.py
  function is_hypothesis_test (line 14) | def is_hypothesis_test(f: object) -> bool:

FILE: hypothesis-python/src/hypothesis/internal/entropy.py
  class RandomLike (line 31) | class RandomLike(Protocol):
    method seed (line 32) | def seed(self, *args: Any, **kwargs: Any) -> Any: ...
    method getstate (line 33) | def getstate(self, *args: Any, **kwargs: Any) -> Any: ...
    method setstate (line 34) | def setstate(self, *args: Any, **kwargs: Any) -> Any: ...
  class NumpyRandomWrapper (line 49) | class NumpyRandomWrapper:
    method __init__ (line 50) | def __init__(self) -> None:
  function _get_platform_base_refcount (line 66) | def _get_platform_base_refcount(r: Any) -> int:
  function register_random (line 77) | def register_random(r: RandomLike) -> None:
  function get_seeder_and_restorer (line 165) | def get_seeder_and_restorer(
  function deterministic_PRNG (line 244) | def deterministic_PRNG(seed: int = 0) -> Generator[None, None, None]:

FILE: hypothesis-python/src/hypothesis/internal/escalation.py
  function belongs_to (line 31) | def belongs_to(package: ModuleType) -> Callable[[str], bool]:
  function get_trimmed_traceback (line 60) | def get_trimmed_traceback(
  class InterestingOrigin (line 95) | class InterestingOrigin:
    method __str__ (line 108) | def __str__(self) -> str:
    method from_exception (line 119) | def from_exception(
  function _get_exceptioninfo (line 149) | def _get_exceptioninfo():
  function format_exception (line 161) | def format_exception(err, tb):

FILE: hypothesis-python/src/hypothesis/internal/filtering.py
  class ConstructivePredicate (line 50) | class ConstructivePredicate(NamedTuple):
    method unchanged (line 72) | def unchanged(cls, predicate: Predicate) -> "ConstructivePredicate":
    method __repr__ (line 75) | def __repr__(self) -> str:
  function convert (line 83) | def convert(node: ast.AST, argname: str) -> object:
  function comp_to_constraints (line 99) | def comp_to_constraints(x: ast.AST, op: ast.AST, y: ast.AST, *, argname:...
  function merge_preds (line 134) | def merge_preds(*con_predicates: ConstructivePredicate) -> ConstructiveP...
  function numeric_bounds_from_ast (line 178) | def numeric_bounds_from_ast(
  function get_numeric_predicate_bounds (line 220) | def get_numeric_predicate_bounds(predicate: Predicate) -> ConstructivePr...
  function get_integer_predicate_bounds (line 304) | def get_integer_predicate_bounds(predicate: Predicate) -> ConstructivePr...
  function get_float_predicate_bounds (line 332) | def get_float_predicate_bounds(predicate: Predicate) -> ConstructivePred...
  function max_len (line 359) | def max_len(size: int, element: Collection[object]) -> bool:
  function min_len (line 363) | def min_len(size: int, element: Collection[object]) -> bool:

FILE: hypothesis-python/src/hypothesis/internal/floats.py
  function reinterpret_bits (line 38) | def reinterpret_bits(x: float | int, from_: str, to: str) -> float | int:
  function float_of (line 44) | def float_of(x: SupportsFloat, width: Width) -> float:
  function is_negative (line 54) | def is_negative(x: SupportsFloat) -> bool:
  function count_between_floats (line 63) | def count_between_floats(x: float, y: float, width: int = 64) -> int:
  function float_to_int (line 77) | def float_to_int(value: float, width: int = 64) -> int:
  function int_to_float (line 84) | def int_to_float(value: int, width: int = 64) -> float:
  function next_up (line 89) | def next_up(value: float, width: int = 64) -> float:
  function next_down (line 110) | def next_down(value: float, width: int = 64) -> float:
  function next_down_normal (line 114) | def next_down_normal(value: float, width: int, *, allow_subnormal: bool)...
  function next_up_normal (line 121) | def next_up_normal(value: float, width: int, *, allow_subnormal: bool) -...
  function make_float_clamper (line 138) | def make_float_clamper(
  function sign_aware_lte (line 186) | def sign_aware_lte(x: float | int, y: float | int) -> bool:
  function clamp (line 194) | def clamp(lower: float | int, value: float | int, upper: float | int) ->...

FILE: hypothesis-python/src/hypothesis/internal/healthcheck.py
  function fail_health_check (line 14) | def fail_health_check(settings, message, label):

FILE: hypothesis-python/src/hypothesis/internal/intervalsets.py
  class IntervalSet (line 28) | class IntervalSet:
    method from_string (line 37) | def from_string(cls, s: str) -> "Self":
    method __init__ (line 46) | def __init__(self, intervals: Iterable[Sequence[int]] = ()) -> None:
    method __len__ (line 61) | def __len__(self) -> int:
    method __iter__ (line 64) | def __iter__(self) -> Iterable[int]:
    method __getitem__ (line 68) | def __getitem__(self, i: int) -> int:
    method __contains__ (line 93) | def __contains__(self, elem: str | int) -> bool:
    method __repr__ (line 99) | def __repr__(self) -> str:
    method index (line 102) | def index(self, value: int) -> int:
    method index_above (line 112) | def index_above(self, value: int) -> int:
    method __or__ (line 120) | def __or__(self, other: "Self") -> "Self":
    method __sub__ (line 123) | def __sub__(self, other: "Self") -> "Self":
    method __and__ (line 126) | def __and__(self, other: "Self") -> "Self":
    method __eq__ (line 129) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 132) | def __hash__(self) -> int:
    method union (line 135) | def union(self, other: "Self") -> "Self":
    method difference (line 171) | def difference(self, other: "Self") -> "Self":
    method intersection (line 248) | def intersection(self, other: "Self") -> "Self":
    method char_in_shrink_order (line 268) | def char_in_shrink_order(self, i: int) -> str:
    method index_from_char_in_shrink_order (line 292) | def index_from_char_in_shrink_order(self, c: str) -> int:

FILE: hypothesis-python/src/hypothesis/internal/lambda_sources.py
  function extract_all_lambdas (line 43) | def extract_all_lambdas(tree):
  function extract_all_attributes (line 56) | def extract_all_attributes(tree):
  function _function_key (line 68) | def _function_key(f, *, bounded_size=False, ignore_name=False):
  class _op (line 103) | class _op:
  function _normalize_code (line 112) | def _normalize_code(f, l):
  function _mimic_lambda_from_node (line 215) | def _mimic_lambda_from_node(f, node):
  function _lambda_code_matches_node (line 292) | def _lambda_code_matches_node(f, node):
  function _check_unknown_perfectly_aligned_lambda (line 304) | def _check_unknown_perfectly_aligned_lambda(candidate):  # pragma: no cover
  function _lambda_description (line 310) | def _lambda_description(f, leeway=50, *, fail_if_confused_with_perfect_c...
  function lambda_description (line 393) | def lambda_description(f):

FILE: hypothesis-python/src/hypothesis/internal/observability.py
  class PredicateCounts (line 73) | class PredicateCounts:
    method update_count (line 77) | def update_count(self, *, condition: bool) -> None:
  function _choice_to_json (line 84) | def _choice_to_json(choice: ChoiceT | None) -> Any:
  function choices_to_json (line 104) | def choices_to_json(choices: tuple[ChoiceT, ...]) -> list[Any]:
  function _constraints_to_json (line 108) | def _constraints_to_json(
  function nodes_to_json (line 159) | def nodes_to_json(nodes: tuple[ChoiceNode, ...]) -> list[dict[str, Any]]:
  class ObservationMetadata (line 172) | class ObservationMetadata:
    method to_json (line 186) | def to_json(self) -> dict[str, Any]:
  class BaseObservation (line 226) | class BaseObservation:
  class InfoObservation (line 237) | class InfoObservation(BaseObservation):
  class TestCaseObservation (line 244) | class TestCaseObservation(BaseObservation):
  function add_observability_callback (line 259) | def add_observability_callback(f: CallbackT, /, *, all_threads: bool = F...
  function remove_observability_callback (line 291) | def remove_observability_callback(f: CallbackT, /) -> None:
  function observability_enabled (line 315) | def observability_enabled() -> bool:
  function with_observability_callback (line 329) | def with_observability_callback(
  function deliver_observation (line 343) | def deliver_observation(observation: Observation) -> None:
  class _TestcaseCallbacks (line 353) | class _TestcaseCallbacks:
    method __bool__ (line 354) | def __bool__(self):
    method _note_deprecation (line 358) | def _note_deprecation(self):
    method append (line 368) | def append(self, f):
    method remove (line 372) | def remove(self, f):
  function make_testcase (line 392) | def make_testcase(
  function _deliver_to_file (line 484) | def _deliver_to_file(
  function _system_metadata (line 512) | def _system_metadata() -> dict[str, Any]:

FILE: hypothesis-python/src/hypothesis/internal/reflection.py
  function is_mock (line 44) | def is_mock(obj: object) -> bool:
  function _clean_source (line 56) | def _clean_source(src: str) -> bytes:
  function function_digest (line 83) | def function_digest(function: Any) -> bytes:
  function check_signature (line 119) | def check_signature(sig: Signature) -> None:  # pragma: no cover  # 3.10...
  function get_signature (line 131) | def get_signature(
  function arg_is_required (line 167) | def arg_is_required(param: Parameter) -> bool:
  function required_args (line 174) | def required_args(
  function convert_keyword_arguments (line 204) | def convert_keyword_arguments(
  function convert_positional_arguments (line 216) | def convert_positional_arguments(
  function ast_arguments_matches_signature (line 240) | def ast_arguments_matches_signature(args: ast.arguments, sig: Signature)...
  function is_first_param_referenced_in_function (line 255) | def is_first_param_referenced_in_function(f: Any) -> bool:
  function get_pretty_function_description (line 270) | def get_pretty_function_description(f: object) -> str:
  function nicerepr (line 292) | def nicerepr(v: Any) -> str:
  function repr_call (line 302) | def repr_call(
  function check_valid_identifier (line 333) | def check_valid_identifier(identifier: str) -> None:
  function source_exec_as_module (line 341) | def source_exec_as_module(source: str) -> ModuleType:
  function get_varargs (line 365) | def get_varargs(
  function define_function_signature (line 374) | def define_function_signature(name, docstring, signature):
  function impersonate (line 462) | def impersonate(target):
  function proxies (line 489) | def proxies(target: T) -> Callable[[Callable], T]:
  function is_identity_function (line 502) | def is_identity_function(f: Callable) -> bool:

FILE: hypothesis-python/src/hypothesis/internal/scrutineer.py
  function should_trace_file (line 39) | def should_trace_file(fname: str) -> bool:
  class Tracer (line 54) | class Tracer:
    method __init__ (line 64) | def __init__(self, *, should_trace: bool) -> None:
    method can_trace (line 71) | def can_trace() -> bool:
    method branches (line 79) | def branches(self) -> Trace:
    method trace (line 82) | def trace(self, frame, event, arg):
    method trace_line (line 95) | def trace_line(self, code: types.CodeType, line_number: int) -> None:
    method __enter__ (line 106) | def __enter__(self) -> "Self":
    method __exit__ (line 131) | def __exit__(self, *args, **kwargs):
  function _glob_to_re (line 173) | def _glob_to_re(locs: Iterable[str]) -> str:
  function get_explaining_locations (line 188) | def get_explaining_locations(traces):
  class ModuleLocation (line 254) | class ModuleLocation(IntEnum):
    method from_path (line 261) | def from_path(cls, path: str) -> "ModuleLocation":
  function _sort_key (line 273) | def _sort_key(path: str, lineno: int) -> tuple[int, str, int]:
  function make_report (line 277) | def make_report(explanations, *, cap_lines_at=5):
  function explanatory_lines (line 291) | def explanatory_lines(traces, settings):
  function _get_git_repo_root (line 304) | def _get_git_repo_root() -> Path:
  function tractable_coverage_report (line 320) | def tractable_coverage_report(trace: Trace) -> dict[str, list[int]]:

FILE: hypothesis-python/src/hypothesis/internal/validation.py
  function check_type (line 20) | def check_type(typ: type | tuple[type, ...], arg: object, name: str) -> ...
  function check_valid_integer (line 41) | def check_valid_integer(value, name):
  function check_valid_bound (line 52) | def check_valid_bound(value, name):
  function check_valid_magnitude (line 66) | def check_valid_magnitude(value, name):
  function try_convert (line 80) | def try_convert(typ, value, name):
  function check_valid_size (line 95) | def check_valid_size(value, name):
  function check_valid_interval (line 109) | def check_valid_interval(lower_bound, upper_bound, lower_name, upper_name):
  function check_valid_sizes (line 124) | def check_valid_sizes(min_size, max_size):

FILE: hypothesis-python/src/hypothesis/provisional.py
  function get_top_level_domains (line 37) | def get_top_level_domains() -> tuple[str, ...]:
  function _recase_randomly (line 50) | def _recase_randomly(draw: DrawFn, tld: str) -> str:
  class DomainNameStrategy (line 59) | class DomainNameStrategy(st.SearchStrategy[str]):
    method clean_inputs (line 61) | def clean_inputs(
    method __init__ (line 76) | def __init__(
    method do_draw (line 132) | def do_draw(self, data: ConjectureData) -> str:
  function domains (line 151) | def domains(
  function urls (line 182) | def urls() -> st.SearchStrategy[str]:

FILE: hypothesis-python/src/hypothesis/reporting.py
  function default (line 20) | def default(value: object) -> None:
  function current_reporter (line 31) | def current_reporter() -> ReporterT:
  function with_reporter (line 35) | def with_reporter(new_reporter: ReporterT) -> AbstractContextManager[None]:
  function current_verbosity (line 39) | def current_verbosity() -> Verbosity:
  function verbose_report (line 44) | def verbose_report(text: str) -> None:
  function debug_report (line 49) | def debug_report(text: str) -> None:
  function report (line 54) | def report(text: str) -> None:
  function base_report (line 59) | def base_report(text: str) -> None:

FILE: hypothesis-python/src/hypothesis/stateful.py
  function _is_singleton (line 67) | def _is_singleton(obj: object) -> bool:
  class _OmittedArgument (line 81) | class _OmittedArgument:
  class TestCaseProperty (line 86) | class TestCaseProperty:  # pragma: no cover
    method __get__ (line 87) | def __get__(self, obj, typ=None):
    method __set__ (line 92) | def __set__(self, obj, value):
    method __delete__ (line 95) | def __delete__(self, obj):
  function get_state_machine_test (line 99) | def get_state_machine_test(
  function run_state_machine_as_test (line 253) | def run_state_machine_as_test(state_machine_factory, *, settings=None, _...
  class StateMachineMeta (line 280) | class StateMachineMeta(type):
    method __setattr__ (line 281) | def __setattr__(cls, name, value):
  class _SetupState (line 293) | class _SetupState:
  class RuleBasedStateMachine (line 299) | class RuleBasedStateMachine(metaclass=StateMachineMeta):
    method __init__ (line 312) | def __init__(self) -> None:
    method _pretty_print (line 343) | def _pretty_print(self, value):
    method __repr__ (line 359) | def __repr__(self):
    method _new_name (line 362) | def _new_name(self, target):
    method _last_names (line 368) | def _last_names(self, n: int) -> list[str]:
    method bundle (line 373) | def bundle(self, name):
    method setup_state (line 377) | def setup_state(cls):
    method _repr_step (line 416) | def _repr_step(self, rule: "Rule", data: Any, result: Any) -> str:
    method _add_results_to_targets (line 448) | def _add_results_to_targets(self, targets, results):
    method check_invariants (line 464) | def check_invariants(self, settings, output, runtimes):
    method teardown (line 489) | def teardown(self):
    method _to_test_case (line 500) | def _to_test_case(cls):
  class Rule (line 516) | class Rule:
    method __post_init__ (line 526) | def __post_init__(self):
    method __repr__ (line 537) | def __repr__(self) -> str:
    method __hash__ (line 548) | def __hash__(self):
  class BundleReferenceStrategy (line 567) | class BundleReferenceStrategy(SearchStrategy):
    method __init__ (line 568) | def __init__(self, name: str, *, consume: bool = False):
    method do_draw (line 573) | def do_draw(self, data):
  class Bundle (line 588) | class Bundle(SearchStrategy[Ex]):
    method __init__ (line 610) | def __init__(
    method do_draw (line 618) | def do_draw(self, data):
    method __repr__ (line 623) | def __repr__(self):
    method calc_is_empty (line 629) | def calc_is_empty(self, recur):
    method is_currently_empty (line 633) | def is_currently_empty(self, data):
    method flatmap (line 640) | def flatmap(self, expand):
    method __hash__ (line 649) | def __hash__(self):
  class BundleConsumer (line 658) | class BundleConsumer(Bundle[Ex]):
    method __init__ (line 659) | def __init__(self, bundle: Bundle[Ex]) -> None:
  function consumes (line 663) | def consumes(bundle: Bundle[Ex]) -> SearchStrategy[Ex]:
  class MultipleResults (line 682) | class MultipleResults(Iterable[Ex]):
    method __iter__ (line 685) | def __iter__(self):
  function multiple (line 689) | def multiple(*args: T) -> MultipleResults[T]:
  function _convert_targets (line 699) | def _convert_targets(targets, target):
  function _rule_qualname (line 746) | def _rule_qualname(f: Any) -> str:
  function rule (line 782) | def rule(
  function rule (line 792) | def rule(
  function rule (line 799) | def rule(
  function rule (line 808) | def rule(
  function initialize (line 877) | def initialize(
  function initialize (line 887) | def initialize(
  function initialize (line 894) | def initialize(
  function initialize (line 903) | def initialize(
  class VarReference (line 965) | class VarReference:
  function precondition (line 971) | def precondition(precond: Callable[[Any], bool]) -> Callable[[TestFunc],...
  class Invariant (line 1034) | class Invariant:
    method __repr__ (line 1039) | def __repr__(self) -> str:
  function invariant (line 1048) | def invariant(*, check_during_init: bool = False) -> Callable[[TestFunc]...
  class RuleStrategy (line 1098) | class RuleStrategy(SearchStrategy):
    method __init__ (line 1099) | def __init__(self, machine: RuleBasedStateMachine) -> None:
    method __repr__ (line 1125) | def __repr__(self):
    method do_draw (line 1128) | def do_draw(self, data):
    method is_valid (line 1160) | def is_valid(self, rule):

FILE: hypothesis-python/src/hypothesis/statistics.py
  function note_statistics (line 25) | def note_statistics(stats_dict: "StatisticsDict") -> None:
  function describe_targets (line 31) | def describe_targets(best_targets: dict[str, float]) -> list[str]:
  function format_ms (line 49) | def format_ms(times: Iterable[float]) -> str:
  function describe_statistics (line 68) | def describe_statistics(stats_dict: "StatisticsDict") -> str:

FILE: hypothesis-python/src/hypothesis/strategies/__init__.py
  function _check_exports (line 119) | def _check_exports(_public):

FILE: hypothesis-python/src/hypothesis/strategies/_internal/attrs.py
  function get_attribute_by_alias (line 43) | def get_attribute_by_alias(
  function from_attrs (line 73) | def from_attrs(
  function from_attrs_attribute (line 91) | def from_attrs_attribute(
  function types_to_strategy (line 156) | def types_to_strategy(attrib: Attribute, types: Collection[Any]) -> Sear...
  function ordered_intersection (line 199) | def ordered_intersection(in_: Sequence[Iterable[T]]) -> Generator[T, Non...
  function all_substrings (line 208) | def all_substrings(s: str) -> Generator[str, None, None]:

FILE: hypothesis-python/src/hypothesis/strategies/_internal/collections.py
  class TupleStrategy (line 49) | class TupleStrategy(SearchStrategy[tuple[Ex, ...]]):
    method __init__ (line 53) | def __init__(self, strategies: Iterable[SearchStrategy[Any]]):
    method do_validate (line 57) | def do_validate(self) -> None:
    method calc_label (line 61) | def calc_label(self) -> int:
    method __repr__ (line 66) | def __repr__(self) -> str:
    method calc_has_reusable_values (line 70) | def calc_has_reusable_values(self, recur: RecurT) -> bool:
    method do_draw (line 73) | def do_draw(self, data: ConjectureData) -> tuple[Ex, ...]:
    method calc_is_empty (line 89) | def calc_is_empty(self, recur: RecurT) -> bool:
  function tuples (line 94) | def tuples() -> SearchStrategy[tuple[()]]:  # pragma: no cover
  function tuples (line 99) | def tuples(__a1: SearchStrategy[Ex]) -> SearchStrategy[tuple[Ex]]:  # pr...
  function tuples (line 104) | def tuples(
  function tuples (line 111) | def tuples(
  function tuples (line 118) | def tuples(
  function tuples (line 128) | def tuples(
  function tuples (line 139) | def tuples(
  function tuples (line 147) | def tuples(*args: SearchStrategy[Any]) -> SearchStrategy[tuple[Any, ...]]:
  class ListStrategy (line 162) | class ListStrategy(SearchStrategy[list[Ex]]):
    method __init__ (line 168) | def __init__(
    method calc_label (line 191) | def calc_label(self) -> int:
    method do_validate (line 194) | def do_validate(self) -> None:
    method calc_is_empty (line 208) | def calc_is_empty(self, recur: RecurT) -> bool:
    method do_draw (line 213) | def do_draw(self, data: ConjectureData) -> list[Ex]:
    method __repr__ (line 229) | def __repr__(self) -> str:
    method filter (line 235) | def filter(self, condition: Callable[[list[Ex]], Any]) -> SearchStrate...
  class UniqueListStrategy (line 270) | class UniqueListStrategy(ListStrategy[Ex]):
    method __init__ (line 271) | def __init__(
    method do_draw (line 285) | def do_draw(self, data: ConjectureData) -> list[Ex]:
  class UniqueSampledListStrategy (line 330) | class UniqueSampledListStrategy(UniqueListStrategy):
    method do_draw (line 331) | def do_draw(self, data: ConjectureData) -> list[Ex]:
  class FixedDictStrategy (line 365) | class FixedDictStrategy(SearchStrategy[dict[Any, Any]]):
    method __init__ (line 373) | def __init__(
    method do_draw (line 388) | def do_draw(self, data: ConjectureData) -> dict[Any, Any]:
    method calc_is_empty (line 420) | def calc_is_empty(self, recur: RecurT) -> bool:
    method __repr__ (line 423) | def __repr__(self) -> str:

FILE: hypothesis-python/src/hypothesis/strategies/_internal/core.py
  function booleans (line 146) | def booleans() -> SearchStrategy[bool]:
  function sampled_from (line 156) | def sampled_from(elements: Sequence[T]) -> SearchStrategy[T]:  # pragma:...
  function sampled_from (line 161) | def sampled_from(elements: type[enum.Enum]) -> SearchStrategy[Any]:  # p...
  function sampled_from (line 167) | def sampled_from(
  function sampled_from (line 174) | def sampled_from(
  function _gets_first_item (line 271) | def _gets_first_item(fn: Callable) -> bool:
  function lists (line 281) | def lists(
  function sets (line 409) | def sets(
  function frozensets (line 431) | def frozensets(
  class PrettyIter (line 444) | class PrettyIter:
    method __init__ (line 445) | def __init__(self, values):
    method __iter__ (line 449) | def __iter__(self):
    method __next__ (line 452) | def __next__(self):
    method __repr__ (line 455) | def __repr__(self) -> str:
  function iterables (line 460) | def iterables(
  function fixed_dictionaries (line 518) | def fixed_dictionaries(
  function dictionaries (line 564) | def dictionaries(
  function characters (line 599) | def characters(
  function text (line 794) | def text(
  function from_regex (line 867) | def from_regex(
  function from_regex (line 876) | def from_regex(
  function from_regex (line 887) | def from_regex(
  function binary (line 943) | def binary(
  function randoms (line 962) | def randoms(
  class RandomSeeder (line 994) | class RandomSeeder:
    method __init__ (line 995) | def __init__(self, seed):
    method __repr__ (line 998) | def __repr__(self):
  class RandomModule (line 1002) | class RandomModule(SearchStrategy):
    method do_draw (line 1003) | def do_draw(self, data: ConjectureData) -> RandomSeeder:
  function random_module (line 1017) | def random_module() -> SearchStrategy[RandomSeeder]:
  class BuildsStrategy (line 1034) | class BuildsStrategy(SearchStrategy[Ex]):
    method __init__ (line 1035) | def __init__(
    method calc_label (line 1046) | def calc_label(self) -> int:
    method do_draw (line 1055) | def do_draw(self, data: ConjectureData) -> Ex:
    method do_validate (line 1107) | def do_validate(self) -> None:
    method __repr__ (line 1111) | def __repr__(self) -> str:
  function builds (line 1120) | def builds(
  function from_type (line 1209) | def from_type(thing: type[T]) -> SearchStrategy[T]:
  function _from_type_deferred (line 1268) | def _from_type_deferred(thing: type[Ex]) -> SearchStrategy[Ex]:
  function _from_type (line 1293) | def _from_type(thing: type[Ex]) -> SearchStrategy[Ex]:
  function fractions (line 1642) | def fractions(
  function _as_finite_decimal (line 1726) | def _as_finite_decimal(
  function decimals (line 1769) | def decimals(
  function recursive (line 1857) | def recursive(
  class PermutationStrategy (line 1888) | class PermutationStrategy(SearchStrategy):
    method __init__ (line 1889) | def __init__(self, values):
    method do_draw (line 1893) | def do_draw(self, data):
  function permutations (line 1905) | def permutations(values: Sequence[T]) -> SearchStrategy[list[T]]:
  class CompositeStrategy (line 1919) | class CompositeStrategy(SearchStrategy):
    method __init__ (line 1920) | def __init__(self, definition, args, kwargs):
    method do_draw (line 1926) | def do_draw(self, data):
    method calc_label (line 1929) | def calc_label(self) -> int:
  class DrawFn (line 1936) | class DrawFn(Protocol):
    method __init__ (line 1951) | def __init__(self):
    method __call__ (line 1961) | def __call__(self, strategy: SearchStrategy[Ex], label: object = None)...
  function _composite (line 1965) | def _composite(f):
  function composite (line 2060) | def composite(
  function composite (line 2068) | def composite(f: Callable[..., Ex]) -> Callable[..., SearchStrategy[Ex]]:
  function complex_numbers (line 2077) | def complex_numbers(
  function shared (line 2202) | def shared(
  function _maybe_nil_uuids (line 2227) | def _maybe_nil_uuids(draw, uuid):
  function uuids (line 2236) | def uuids(
  class RunnerStrategy (line 2268) | class RunnerStrategy(SearchStrategy):
    method __init__ (line 2269) | def __init__(self, default):
    method do_draw (line 2273) | def do_draw(self, data):
  function runner (line 2285) | def runner(*, default: Any = not_set) -> SearchStrategy[Any]:
  class DataObject (line 2302) | class DataObject:
    method __init__ (line 2310) | def __init__(self, data: ConjectureData) -> None:
    method __repr__ (line 2316) | def __repr__(self) -> str:
    method draw (line 2319) | def draw(self, strategy: SearchStrategy[Ex], label: Any = None) -> Ex:
  class DataStrategy (line 2339) | class DataStrategy(SearchStrategy):
    method do_draw (line 2340) | def do_draw(self, data):
    method __repr__ (line 2345) | def __repr__(self) -> str:
    method map (line 2348) | def map(self, f):
    method filter (line 2351) | def filter(self, condition: Callable[[Ex], Any]) -> NoReturn:
    method flatmap (line 2354) | def flatmap(self, f):
    method example (line 2357) | def example(self) -> NoReturn:
    method __not_a_first_class_strategy (line 2360) | def __not_a_first_class_strategy(self, name: str) -> NoReturn:
  function data (line 2369) | def data() -> SearchStrategy[DataObject]:
  function register_type_strategy (line 2434) | def register_type_strategy(
  function deferred (line 2518) | def deferred(definition: Callable[[], SearchStrategy[Ex]]) -> SearchStra...
  function domains (line 2551) | def domains() -> SearchStrategy[str]:
  function emails (line 2558) | def emails(
  function _functions (line 2579) | def _functions(*, like, returns, pure):
  function functions (line 2599) | def functions(
  function functions (line 2605) | def functions(
  function functions (line 2613) | def functions(
  function functions (line 2621) | def functions(
  function functions (line 2630) | def functions(*, like=lambda: None, returns=..., pure=False):
  function functions (line 2658) | def functions(
  function slices (line 2688) | def slices(draw: Any, size: int) -> slice:

FILE: hypothesis-python/src/hypothesis/strategies/_internal/datetime.py
  function is_pytz_timezone (line 31) | def is_pytz_timezone(tz):
  function replace_tzinfo (line 38) | def replace_tzinfo(value, timezone):
  function datetime_does_not_exist (line 57) | def datetime_does_not_exist(value):
  function draw_capped_multipart (line 91) | def draw_capped_multipart(
  class DatetimeStrategy (line 121) | class DatetimeStrategy(SearchStrategy):
    method __init__ (line 122) | def __init__(self, min_value, max_value, timezones_strat, allow_imagin...
    method do_draw (line 136) | def do_draw(self, data):
    method draw_naive_datetime_and_combine (line 152) | def draw_naive_datetime_and_combine(self, data, tz):
  function datetimes (line 164) | def datetimes(
  class TimeStrategy (line 221) | class TimeStrategy(SearchStrategy):
    method __init__ (line 222) | def __init__(self, min_value, max_value, timezones_strat):
    method do_draw (line 228) | def do_draw(self, data):
  function times (line 235) | def times(
  class DateStrategy (line 260) | class DateStrategy(SearchStrategy):
    method __init__ (line 261) | def __init__(self, min_value, max_value):
    method do_draw (line 269) | def do_draw(self, data):
    method filter (line 274) | def filter(self, condition):
  function dates (line 307) | def dates(
  class TimedeltaStrategy (line 324) | class TimedeltaStrategy(SearchStrategy):
    method __init__ (line 325) | def __init__(self, min_value, max_value):
    method do_draw (line 333) | def do_draw(self, data):
  function timedeltas (line 348) | def timedeltas(
  function _valid_key_cacheable (line 367) | def _valid_key_cacheable(tzpath, key):
  function timezone_keys (line 386) | def timezone_keys(
  function timezones (line 457) | def timezones(*, no_cache: bool = False) -> SearchStrategy["zoneinfo.Zon...

FILE: hypothesis-python/src/hypothesis/strategies/_internal/deferred.py
  class DeferredStrategy (line 26) | class DeferredStrategy(SearchStrategy[Ex]):
    method __init__ (line 29) | def __init__(self, definition: Callable[[], SearchStrategy[Ex]]):
    method wrapped_strategy (line 36) | def wrapped_strategy(self) -> SearchStrategy[Ex]:
    method branches (line 57) | def branches(self) -> Sequence[SearchStrategy[Ex]]:
    method calc_label (line 60) | def calc_label(self) -> int:
    method calc_is_empty (line 73) | def calc_is_empty(self, recur: RecurT) -> bool:
    method calc_has_reusable_values (line 76) | def calc_has_reusable_values(self, recur: RecurT) -> bool:
    method __repr__ (line 79) | def __repr__(self) -> str:
    method do_draw (line 92) | def do_draw(self, data: ConjectureData) -> Ex:

FILE: hypothesis-python/src/hypothesis/strategies/_internal/featureflags.py
  class FeatureFlags (line 21) | class FeatureFlags:
    method __init__ (line 38) | def __init__(
    method is_enabled (line 77) | def is_enabled(self, name: Any) -> bool:
    method __repr__ (line 115) | def __repr__(self) -> str:
  class FeatureStrategy (line 126) | class FeatureStrategy(SearchStrategy[FeatureFlags]):
    method __init__ (line 127) | def __init__(self, at_least_one_of: Iterable[Hashable] = ()):
    method do_draw (line 131) | def do_draw(self, data: ConjectureData) -> FeatureFlags:

FILE: hypothesis-python/src/hypothesis/strategies/_internal/flatmapped.py
  class FlatMapStrategy (line 30) | class FlatMapStrategy(SearchStrategy[MappedTo], Generic[MappedFrom, Mapp...
    method __init__ (line 31) | def __init__(
    method calc_is_empty (line 40) | def calc_is_empty(self, recur: RecurT) -> bool:
    method calc_label (line 43) | def calc_label(self) -> int:
    method __repr__ (line 50) | def __repr__(self) -> str:
    method do_draw (line 57) | def do_draw(self, data: ConjectureData) -> MappedTo:
    method branches (line 64) | def branches(self) -> list[SearchStrategy[MappedTo]]:

FILE: hypothesis-python/src/hypothesis/strategies/_internal/functions.py
  class FunctionStrategy (line 24) | class FunctionStrategy(SearchStrategy):
    method __init__ (line 25) | def __init__(self, like, returns, pure):
    method calc_is_empty (line 34) | def calc_is_empty(self, recur: RecurT) -> bool:
    method do_draw (line 37) | def do_draw(self, data):

FILE: hypothesis-python/src/hypothesis/strategies/_internal/ipaddress.py
  function ip_addresses (line 74) | def ip_addresses(

FILE: hypothesis-python/src/hypothesis/strategies/_internal/lazy.py
  function unwrap_strategies (line 31) | def unwrap_strategies(s):
  class LazyStrategy (line 66) | class LazyStrategy(SearchStrategy[Ex]):
    method __init__ (line 73) | def __init__(
    method calc_is_empty (line 90) | def calc_is_empty(self, recur: RecurT) -> bool:
    method calc_has_reusable_values (line 93) | def calc_has_reusable_values(self, recur: RecurT) -> bool:
    method calc_is_cacheable (line 96) | def calc_is_cacheable(self, recur: RecurT) -> bool:
    method calc_label (line 103) | def calc_label(self) -> int:
    method wrapped_strategy (line 107) | def wrapped_strategy(self) -> SearchStrategy[Ex]:
    method __with_transform (line 127) | def __with_transform(self, method, fn):
    method map (line 139) | def map(self, pack):
    method filter (line 142) | def filter(self, condition):
    method do_validate (line 145) | def do_validate(self) -> None:
    method __repr__ (line 150) | def __repr__(self) -> str:
    method do_draw (line 175) | def do_draw(self, data: ConjectureData) -> Ex:

FILE: hypothesis-python/src/hypothesis/strategies/_internal/misc.py
  class JustStrategy (line 31) | class JustStrategy(SampledFromStrategy[Ex]):
    method value (line 45) | def value(self) -> Ex:
    method __repr__ (line 48) | def __repr__(self) -> str:
    method calc_is_cacheable (line 57) | def calc_is_cacheable(self, recur: RecurT) -> bool:
    method do_filtered_draw (line 60) | def do_filtered_draw(self, data: ConjectureData) -> Ex | UniqueIdentif...
  function just (line 68) | def just(value: T) -> SearchStrategy[T]:
  function none (line 83) | def none() -> SearchStrategy[None]:
  class Nothing (line 92) | class Nothing(SearchStrategy["Never"]):
    method calc_is_empty (line 93) | def calc_is_empty(self, recur: RecurT) -> bool:
    method do_draw (line 96) | def do_draw(self, data: ConjectureData) -> NoReturn:
    method calc_has_reusable_values (line 101) | def calc_has_reusable_values(self, recur: RecurT) -> bool:
    method __repr__ (line 104) | def __repr__(self) -> str:
    method map (line 107) | def map(self, pack: Callable[[Any], Any]) -> SearchStrategy["Never"]:
    method filter (line 110) | def filter(self, condition: Callable[[Any], Any]) -> "SearchStrategy[N...
    method flatmap (line 113) | def flatmap(
  function nothing (line 124) | def nothing() -> SearchStrategy["Never"]:
  class BooleansStrategy (line 133) | class BooleansStrategy(SearchStrategy[bool]):
    method do_draw (line 134) | def do_draw(self, data: ConjectureData) -> bool:
    method __repr__ (line 137) | def __repr__(self) -> str:

FILE: hypothesis-python/src/hypothesis/strategies/_internal/numbers.py
  class IntegersStrategy (line 51) | class IntegersStrategy(SearchStrategy[int]):
    method __init__ (line 52) | def __init__(self, start: int | None, end: int | None) -> None:
    method __repr__ (line 60) | def __repr__(self) -> str:
    method do_draw (line 69) | def do_draw(self, data: ConjectureData) -> int:
    method filter (line 88) | def filter(self, condition):
  function integers (line 112) | def integers(
  class FloatStrategy (line 146) | class FloatStrategy(SearchStrategy[float]):
    method __init__ (line 149) | def __init__(
    method __repr__ (line 178) | def __repr__(self) -> str:
    method do_draw (line 184) | def do_draw(self, data: ConjectureData) -> float:
    method filter (line 192) | def filter(self, condition):
  function floats (line 250) | def floats(
  class NanStrategy (line 519) | class NanStrategy(SearchStrategy[float]):
    method do_draw (line 522) | def do_draw(self, data: ConjectureData) -> float:

FILE: hypothesis-python/src/hypothesis/strategies/_internal/random.py
  class HypothesisRandom (line 27) | class HypothesisRandom(Random, abc.ABC):
    method __init__ (line 31) | def __init__(self, *, note_method_calls: bool) -> None:
    method __deepcopy__ (line 34) | def __deepcopy__(self, table):
    method seed (line 38) | def seed(self, seed):
    method getstate (line 42) | def getstate(self):
    method setstate (line 46) | def setstate(self, state):
    method _hypothesis_do_random (line 50) | def _hypothesis_do_random(self, method, kwargs):
    method _hypothesis_log_random (line 53) | def _hypothesis_log_random(self, method, kwargs, result):
  function getrandbits (line 95) | def getrandbits(self, n: int) -> int:  # type: ignore
  function random (line 99) | def random(self) -> float:  # type: ignore
  function _randbelow (line 103) | def _randbelow(self, n: int) -> int:  # type: ignore
  function sig_of (line 113) | def sig_of(name):
  function define_copy_method (line 125) | def define_copy_method(name):
  class RandomState (line 150) | class RandomState:
  function state_for_seed (line 155) | def state_for_seed(data, seed):
  function normalize_zero (line 169) | def normalize_zero(f: float) -> float:
  class ArtificialRandom (line 176) | class ArtificialRandom(HypothesisRandom):
    method __init__ (line 179) | def __init__(self, *, note_method_calls: bool, data: ConjectureData) -...
    method __repr__ (line 184) | def __repr__(self) -> str:
    method __copy__ (line 187) | def __copy__(self) -> "ArtificialRandom":
    method __convert_result (line 195) | def __convert_result(self, method, kwargs, result):
    method _hypothesis_do_random (line 209) | def _hypothesis_do_random(self, method, kwargs):
    method seed (line 334) | def seed(self, seed):
    method getstate (line 337) | def getstate(self):
    method setstate (line 349) | def setstate(self, state):
  function convert_kwargs (line 356) | def convert_kwargs(name, kwargs):
  class TrueRandom (line 392) | class TrueRandom(HypothesisRandom):
    method __init__ (line 393) | def __init__(self, seed, note_method_calls):
    method _hypothesis_do_random (line 398) | def _hypothesis_do_random(self, method, kwargs):
    method __copy__ (line 407) | def __copy__(self) -> "TrueRandom":
    method __repr__ (line 415) | def __repr__(self) -> str:
    method seed (line 418) | def seed(self, seed):
    method getstate (line 422) | def getstate(self):
    method setstate (line 425) | def setstate(self, state):
  class RandomStrategy (line 429) | class RandomStrategy(SearchStrategy[HypothesisRandom]):
    method __init__ (line 430) | def __init__(self, *, note_method_calls: bool, use_true_random: bool) ...
    method do_draw (line 435) | def do_draw(self, data: ConjectureData) -> HypothesisRandom:

FILE: hypothesis-python/src/hypothesis/strategies/_internal/recursive.py
  class LimitReached (line 31) | class LimitReached(BaseException):
  class LimitedStrategy (line 35) | class LimitedStrategy(SearchStrategy):
    method __init__ (line 36) | def __init__(self, strategy):
    method marker (line 42) | def marker(self):
    method marker (line 46) | def marker(self, value):
    method currently_capped (line 50) | def currently_capped(self):
    method currently_capped (line 54) | def currently_capped(self, value):
    method __repr__ (line 57) | def __repr__(self) -> str:
    method do_validate (line 60) | def do_validate(self) -> None:
    method do_draw (line 63) | def do_draw(self, data):
    method capped (line 71) | def capped(self, max_templates):
  class RecursiveStrategy (line 81) | class RecursiveStrategy(SearchStrategy):
    method __init__ (line 82) | def __init__(
    method __repr__ (line 104) | def __repr__(self) -> str:
    method do_validate (line 113) | def do_validate(self) -> None:
    method do_draw (line 160) | def do_draw(self, data):

FILE: hypothesis-python/src/hypothesis/strategies/_internal/regex.py
  class IncompatibleWithAlphabet (line 66) | class IncompatibleWithAlphabet(InvalidArgument):
  function update_group (line 71) | def update_group(draw, group_name, strategy):
  function reuse_group (line 79) | def reuse_group(draw, group_name):
  function group_conditional (line 88) | def group_conditional(draw, group_name, if_yes, if_no):
  function clear_cache_after_draw (line 97) | def clear_cache_after_draw(draw, base_strategy):
  function chars_not_in_alphabet (line 104) | def chars_not_in_alphabet(alphabet, string):
  class Context (line 112) | class Context:
    method __init__ (line 115) | def __init__(self, flags):
  class CharactersBuilder (line 119) | class CharactersBuilder:
    method __init__ (line 129) | def __init__(self, *, negate=False, flags=0, alphabet):
    method strategy (line 143) | def strategy(self):
    method add_category (line 162) | def add_category(self, category):
    method add_char (line 183) | def add_char(self, c):
  class BytesBuilder (line 194) | class BytesBuilder(CharactersBuilder):
    method __init__ (line 195) | def __init__(self, *, negate=False, flags=0):
    method strategy (line 204) | def strategy(self):
    method add_category (line 211) | def add_category(self, category):
  function maybe_pad (line 217) | def maybe_pad(draw, regex, strategy, left_pad_strategy, right_pad_strate...
  function base_regex_strategy (line 230) | def base_regex_strategy(regex, parsed=None, alphabet=None):
  function regex_strategy (line 246) | def regex_strategy(
  function _strategy (line 312) | def _strategy(codes, context, is_unicode, *, alphabet):

FILE: hypothesis-python/src/hypothesis/strategies/_internal/shared.py
  class SharedStrategy (line 21) | class SharedStrategy(SearchStrategy[Ex]):
    method __init__ (line 22) | def __init__(self, base: SearchStrategy[Ex], key: Hashable | None = No...
    method __repr__ (line 27) | def __repr__(self) -> str:
    method calc_label (line 33) | def calc_label(self) -> int:
    method do_draw (line 38) | def do_draw(self, data: ConjectureData) -> Any:

FILE: hypothesis-python/src/hypothesis/strategies/_internal/strategies.py
  function recursive_property (line 82) | def recursive_property(strategy: "SearchStrategy", name: str, default: o...
  class SearchStrategy (line 221) | class SearchStrategy(Generic[Ex]):
    method __init__ (line 236) | def __init__(self):
    method is_currently_empty (line 239) | def is_currently_empty(self, data: ConjectureData) -> bool:
    method is_empty (line 255) | def is_empty(self) -> Any:
    method has_reusable_values (line 272) | def has_reusable_values(self) -> Any:
    method is_cacheable (line 276) | def is_cacheable(self) -> Any:
    method calc_is_cacheable (line 283) | def calc_is_cacheable(self, recur: RecurT) -> bool:
    method calc_is_empty (line 286) | def calc_is_empty(self, recur: RecurT) -> bool:
    method calc_has_reusable_values (line 295) | def calc_has_reusable_values(self, recur: RecurT) -> bool:
    method example (line 298) | def example(self) -> Ex:  # FIXME
    method map (line 378) | def map(self, pack: Callable[[Ex], T]) -> "SearchStrategy[T]":
    method flatmap (line 387) | def flatmap(
    method filter (line 417) | def filter(self, condition: Callable[[Ex], Any]) -> "SearchStrategy[Ex]":
    method branches (line 438) | def branches(self) -> Sequence["SearchStrategy[Ex]"]:
    method __or__ (line 441) | def __or__(self, other: "SearchStrategy[T]") -> "SearchStrategy[Ex | T]":
    method __bool__ (line 471) | def __bool__(self) -> bool:
    method validate (line 479) | def validate(self) -> None:
    method class_label (line 516) | def class_label(self) -> int:
    method label (line 527) | def label(self) -> int:
    method calc_label (line 539) | def calc_label(self) -> int:
    method do_validate (line 542) | def do_validate(self) -> None:
    method do_draw (line 545) | def do_draw(self, data: ConjectureData) -> Ex:
  function _is_hashable (line 549) | def _is_hashable(value: object) -> tuple[bool, int | None]:
  function is_hashable (line 558) | def is_hashable(value: object) -> bool:
  class SampledFromStrategy (line 562) | class SampledFromStrategy(SearchStrategy[Ex]):
    method __init__ (line 570) | def __init__(
    method map (line 590) | def map(self, pack: Callable[[Ex], T]) -> SearchStrategy[T]:
    method filter (line 600) | def filter(self, condition: Callable[[Ex], Any]) -> SearchStrategy[Ex]:
    method __repr__ (line 608) | def __repr__(self):
    method calc_label (line 628) | def calc_label(self) -> int:
    method calc_has_reusable_values (line 679) | def calc_has_reusable_values(self, recur: RecurT) -> bool:
    method calc_is_cacheable (line 686) | def calc_is_cacheable(self, recur: RecurT) -> bool:
    method _transform (line 689) | def _transform(
    method do_draw (line 709) | def do_draw(self, data: ConjectureData) -> Ex:
    method get_element (line 724) | def get_element(self, i: int) -> Ex | UniqueIdentifier:
    method do_filtered_draw (line 727) | def do_filtered_draw(self, data: ConjectureData) -> Ex | UniqueIdentif...
  class OneOfStrategy (line 785) | class OneOfStrategy(SearchStrategy[Ex]):
    method __init__ (line 794) | def __init__(self, strategies: Sequence[SearchStrategy[Ex]]):
    method calc_is_empty (line 801) | def calc_is_empty(self, recur: RecurT) -> bool:
    method calc_has_reusable_values (line 804) | def calc_has_reusable_values(self, recur: RecurT) -> bool:
    method calc_is_cacheable (line 807) | def calc_is_cacheable(self, recur: RecurT) -> bool:
    method element_strategies (line 811) | def element_strategies(self) -> Sequence[SearchStrategy[Ex]]:
    method calc_label (line 840) | def calc_label(self) -> int:
    method do_draw (line 845) | def do_draw(self, data: ConjectureData) -> Ex:
    method __repr__ (line 853) | def __repr__(self) -> str:
    method do_validate (line 856) | def do_validate(self) -> None:
    method branches (line 861) | def branches(self) -> Sequence[SearchStrategy[Ex]]:
    method filter (line 876) | def filter(self, condition: Callable[[Ex], Any]) -> SearchStrategy[Ex]:
  function one_of (line 884) | def one_of(
  function one_of (line 891) | def one_of(__a1: SearchStrategy[Ex]) -> SearchStrategy[Ex]:  # pragma: n...
  function one_of (line 896) | def one_of(
  function one_of (line 903) | def one_of(
  function one_of (line 910) | def one_of(
  function one_of (line 920) | def one_of(
  function one_of (line 931) | def one_of(*args: SearchStrategy[Any]) -> SearchStrategy[Any]:  # pragma...
  function one_of (line 936) | def one_of(
  class MappedStrategy (line 985) | class MappedStrategy(SearchStrategy[MappedTo], Generic[MappedFrom, Mappe...
    method __init__ (line 992) | def __init__(
    method calc_is_empty (line 1001) | def calc_is_empty(self, recur: RecurT) -> bool:
    method calc_is_cacheable (line 1004) | def calc_is_cacheable(self, recur: RecurT) -> bool:
    method __repr__ (line 1007) | def __repr__(self) -> str:
    method do_validate (line 1012) | def do_validate(self) -> None:
    method do_draw (line 1015) | def do_draw(self, data: ConjectureData) -> MappedTo:
    method branches (line 1036) | def branches(self) -> Sequence[SearchStrategy[MappedTo]]:
    method filter (line 1042) | def filter(
  function _list_strategy_type (line 1066) | def _list_strategy_type() -> Any:
  function _collection_ish_functions (line 1072) | def _collection_ish_functions() -> Sequence[Any]:
  class FilteredStrategy (line 1105) | class FilteredStrategy(SearchStrategy[Ex]):
    method __init__ (line 1106) | def __init__(
    method calc_is_empty (line 1125) | def calc_is_empty(self, recur: RecurT) -> bool:
    method calc_is_cacheable (line 1128) | def calc_is_cacheable(self, recur: RecurT) -> bool:
    method __repr__ (line 1131) | def __repr__(self) -> str:
    method do_validate (line 1142) | def do_validate(self) -> None:
    method filter (line 1164) | def filter(self, condition: Callable[[Ex], Any]) -> "FilteredStrategy[...
    method condition (line 1180) | def condition(self) -> Callable[[Ex], Any]:
    method do_draw (line 1200) | def do_draw(self, data: ConjectureData) -> Ex:
    method do_filtered_draw (line 1207) | def do_filtered_draw(self, data: ConjectureData) -> Ex | UniqueIdentif...
    method branches (line 1222) | def branches(self) -> Sequence[SearchStrategy[Ex]]:
  function check_strategy (line 1230) | def check_strategy(arg: object, name: str = "") -> None:

FILE: hypothesis-python/src/hypothesis/strategies/_internal/strings.py
  function _check_is_single_character (line 40) | def _check_is_single_character(c: object) -> str:
  class OneCharStringStrategy (line 51) | class OneCharStringStrategy(SearchStrategy[str]):
    method __init__ (line 54) | def __init__(self, intervals: IntervalSet, force_repr: str | None = No...
    method from_characters_args (line 61) | def from_characters_args(
    method from_alphabet (line 107) | def from_alphabet(cls, alphabet: str | SearchStrategy) -> "OneCharStri...
    method __repr__ (line 131) | def __repr__(self) -> str:
    method do_draw (line 134) | def do_draw(self, data: ConjectureData) -> str:
  class TextStrategy (line 165) | class TextStrategy(ListStrategy[str]):
    method do_draw (line 166) | def do_draw(self, data):
    method __repr__ (line 184) | def __repr__(self) -> str:
    method filter (line 209) | def filter(self, condition):
  function _string_filter_rewrite (line 236) | def _string_filter_rewrite(self, kind, condition):
  function _identifier_characters (line 329) | def _identifier_characters() -> tuple[IntervalSet, IntervalSet]:
  class BytesStrategy (line 357) | class BytesStrategy(SearchStrategy):
    method __init__ (line 358) | def __init__(self, min_size: int, max_size: int | None):
    method do_draw (line 365) | def do_draw(self, data: ConjectureData) -> bytes:
    method filter (line 377) | def filter(self, condition):

FILE: hypothesis-python/src/hypothesis/strategies/_internal/types.py
  function type_sorting_key (line 213) | def type_sorting_key(t):
  function _compatible_args (line 222) | def _compatible_args(args, superclass_args):
  function try_issubclass (line 236) | def try_issubclass(thing, superclass):
  function _evaluate_type_alias_type (line 260) | def _evaluate_type_alias_type(thing, *, typevars):  # pragma: no cover #...
  function evaluate_type_alias_type (line 312) | def evaluate_type_alias_type(thing):  # pragma: no cover # covered on 3.12+
  function is_a_type_alias_type (line 321) | def is_a_type_alias_type(thing):  # pragma: no cover # covered by 3.12+ ...
  function is_a_union (line 332) | def is_a_union(thing: object) -> bool:
  function is_a_type (line 337) | def is_a_type(thing: object) -> bool:
  function is_typing_literal (line 353) | def is_typing_literal(thing: object) -> bool:
  function is_annotated_type (line 360) | def is_annotated_type(thing: object) -> bool:
  function get_constraints_filter_map (line 367) | def get_constraints_filter_map():
  function _get_constraints (line 382) | def _get_constraints(args: tuple[Any, ...]) -> Iterator["at.BaseMetadata"]:
  function _flat_annotated_repr_parts (line 397) | def _flat_annotated_repr_parts(annotated_type):
  function find_annotated_strategy (line 415) | def find_annotated_strategy(annotated_type):
  function has_type_arguments (line 457) | def has_type_arguments(type_):
  function is_generic_type (line 469) | def is_generic_type(type_):
  function _try_import_forward_ref (line 485) | def _try_import_forward_ref(thing, typ, *, type_params):  # pragma: no c...
  function from_typing_type (line 506) | def from_typing_type(thing):
  function can_cast (line 685) | def can_cast(type, value):
  function _networks (line 694) | def _networks(bits):
  function _from_numpy_type (line 910) | def _from_numpy_type(thing: type) -> st.SearchStrategy | None:
  function register (line 922) | def register(type_, fallback=None, *, module=typing):
  function resolve_Type (line 954) | def resolve_Type(thing):
  function resolve_List (line 975) | def resolve_List(thing):
  function resolve_Tuple (line 980) | def resolve_Tuple(thing):
  function _can_hash (line 992) | def _can_hash(val):
  function _from_hashable_type (line 1009) | def _from_hashable_type(type_):
  function resolve_Set (line 1018) | def resolve_Set(thing):
  function resolve_FrozenSet (line 1023) | def resolve_FrozenSet(thing):
  function resolve_Dict (line 1028) | def resolve_Dict(thing):
  function resolve_DefaultDict (line 1039) | def resolve_DefaultDict(thing):
  function resolve_ItemsView (line 1044) | def resolve_ItemsView(thing):
  function resolve_KeysView (line 1049) | def resolve_KeysView(thing):
  function resolve_ValuesView (line 1056) | def resolve_ValuesView(thing):
  function resolve_Iterator (line 1063) | def resolve_Iterator(thing):
  function resolve_Counter (line 1068) | def resolve_Counter(thing):
  function resolve_deque (line 1076) | def resolve_deque(thing):
  function resolve_ChainMap (line 1081) | def resolve_ChainMap(thing):
  function resolve_OrderedDict (line 1086) | def resolve_OrderedDict(thing):
  function resolve_Pattern (line 1091) | def resolve_Pattern(thing):
  function resolve_Match (line 1103) | def resolve_Match(thing):
  class GeneratorStrategy (line 1113) | class GeneratorStrategy(st.SearchStrategy):
    method __init__ (line 1114) | def __init__(self, yields, returns):
    method __repr__ (line 1121) | def __repr__(self) -> str:
    method do_draw (line 1124) | def do_draw(self, data):
  function resolve_Generator (line 1132) | def resolve_Generator(thing):
  function resolve_Callable (line 1138) | def resolve_Callable(thing):
  function resolve_TypeVar (line 1179) | def resolve_TypeVar(thing):
  function resolve_memoryview (line 1230) | def resolve_memoryview(thing):

FILE: hypothesis-python/src/hypothesis/strategies/_internal/utils.py
  function _value_key (line 36) | def _value_key(value: object) -> ValueKey:
  function clear_strategy_cache (line 42) | def clear_strategy_cache() -> None:
  function cacheable (line 46) | def cacheable(fn: T) -> T:
  function defines_strategy (line 84) | def defines_strategy(
  function _to_jsonable (line 159) | def _to_jsonable(obj: object, *, avoid_realization: bool, seen: set[int]...
  function to_jsonable (line 217) | def to_jsonable(obj: object, *, avoid_realization: bool) -> object:

FILE: hypothesis-python/src/hypothesis/utils/conventions.py
  class UniqueIdentifier (line 12) | class UniqueIdentifier:
    method __init__ (line 15) | def __init__(self, identifier: str) -> None:
    method __repr__ (line 18) | def __repr__(self) -> str:

FILE: hypothesis-python/src/hypothesis/utils/deprecation.py
  function note_deprecation (line 17) | def note_deprecation(

FILE: hypothesis-python/src/hypothesis/utils/dynamicvariables.py
  class DynamicVariable (line 19) | class DynamicVariable(Generic[T]):
    method __init__ (line 20) | def __init__(self, default: T) -> None:
    method value (line 25) | def value(self) -> T:
    method value (line 29) | def value(self, value: T) -> None:
    method with_value (line 33) | def with_value(self, value: T) -> Generator[None, None, None]:

FILE: hypothesis-python/src/hypothesis/utils/terminal.py
  function guess_background_color (line 15) | def guess_background_color() -> Literal["light", "dark", "unknown"]:

FILE: hypothesis-python/src/hypothesis/utils/threading.py
  class ThreadLocal (line 16) | class ThreadLocal:
    method __init__ (line 25) | def __init__(self, **kwargs: Callable) -> None:
    method __getattr__ (line 35) | def __getattr__(self, name: str) -> Any:
    method __setattr__ (line 45) | def __setattr__(self, name: str, value: Any) -> None:

FILE: hypothesis-python/src/hypothesis/vendor/pretty.py
  function _safe_getattr (line 97) | def _safe_getattr(obj: object, attr: str, default: Any | None = None) ->...
  function pretty (line 110) | def pretty(obj: object, *, cycle: bool = False) -> str:
  class IDKey (line 117) | class IDKey:
    method __init__ (line 118) | def __init__(self, value: object):
    method __hash__ (line 121) | def __hash__(self) -> int:
    method __eq__ (line 124) | def __eq__(self, __o: object) -> bool:
  class RepresentationPrinter (line 128) | class RepresentationPrinter:
    method __init__ (line 138) | def __init__(
    method pretty (line 196) | def pretty(self, obj: object, *, cycle: bool = False) -> None:
    method _break_outer_groups (line 284) | def _break_outer_groups(self) -> None:
    method text (line 298) | def text(self, obj: str) -> None:
    method breakable (line 313) | def breakable(self, sep: str = " ") -> None:
    method break_ (line 333) | def break_(self) -> None:
    method indent (line 342) | def indent(self, indent: int) -> Generator[None, None, None]:
    method group (line 351) | def group(
    method begin_group (line 368) | def begin_group(self, indent: int = 0, open: str = "") -> None:
    method end_group (line 381) | def end_group(self, dedent: int = 0, close: str = "") -> None:
    method _enumerate (line 390) | def _enumerate(self, seq: Iterable[T]) -> Generator[tuple[int, T], Non...
    method flush (line 400) | def flush(self) -> None:
    method getvalue (line 407) | def getvalue(self) -> str:
    method maybe_repr_known_object_as_call (line 412) | def maybe_repr_known_object_as_call(
    method repr_call (line 448) | def repr_call(
  class Printable (line 523) | class Printable:
    method output (line 524) | def output(self, stream: TextIOBase, output_width: int) -> int:  # pra...
  class Text (line 528) | class Text(Printable):
    method __init__ (line 529) | def __init__(self) -> None:
    method output (line 533) | def output(self, stream: TextIOBase, output_width: int) -> int:
    method add (line 538) | def add(self, obj: str, width: int) -> None:
  class Breakable (line 543) | class Breakable(Printable):
    method __init__ (line 544) | def __init__(self, seq: str, width: int, pretty: RepresentationPrinter...
    method output (line 552) | def output(self, stream: TextIOBase, output_width: int) -> int:
  class Group (line 563) | class Group(Printable):
    method __init__ (line 564) | def __init__(self, depth: int) -> None:
  class GroupQueue (line 570) | class GroupQueue:
    method __init__ (line 571) | def __init__(self, *groups: Group) -> None:
    method enq (line 576) | def enq(self, group: Group) -> None:
    method deq (line 582) | def deq(self) -> Group | None:
    method remove (line 594) | def remove(self, group: Group) -> None:
  function _seq_pprinter_factory (line 601) | def _seq_pprinter_factory(start: str, end: str, basetype: type) -> Prett...
  function get_class_name (line 635) | def get_class_name(cls: type[object]) -> str:
  function _set_pprinter_factory (line 641) | def _set_pprinter_factory(
  function _dict_pprinter_factory (line 686) | def _dict_pprinter_factory(
  function _super_pprint (line 724) | def _super_pprint(obj: Any, p: RepresentationPrinter, cycle: bool) -> None:
  function _re_pattern_pprint (line 733) | def _re_pattern_pprint(obj: re.Pattern, p: RepresentationPrinter, cycle:...
  function _type_pprint (line 766) | def _type_pprint(obj: type[object], p: RepresentationPrinter, cycle: boo...
  function _repr_pprint (line 791) | def _repr_pprint(obj: object, p: RepresentationPrinter, cycle: bool) -> ...
  function pprint_fields (line 801) | def pprint_fields(
  function _get_slice_comment (line 817) | def _get_slice_comment(
  function _tuple_pprinter (line 829) | def _tuple_pprinter(arg_labels: ArgLabelsT) -> PrettyPrintFunction:
  function _fixeddict_pprinter (line 855) | def _fixeddict_pprinter(
  function _function_pprint (line 888) | def _function_pprint(
  function _exception_pprint (line 899) | def _exception_pprint(
  function _repr_integer (line 915) | def _repr_integer(obj: int, p: RepresentationPrinter, cycle: bool) -> None:
  function _repr_float_counting_nans (line 927) | def _repr_float_counting_nans(
  function for_type_by_name (line 967) | def for_type_by_name(
  function _defaultdict_pprint (line 984) | def _defaultdict_pprint(
  function _ordereddict_pprint (line 998) | def _ordereddict_pprint(
  function _deque_pprint (line 1009) | def _deque_pprint(obj: deque[object], p: RepresentationPrinter, cycle: b...
  function _counter_pprint (line 1018) | def _counter_pprint(
  function _repr_dataframe (line 1029) | def _repr_dataframe(
  function _repr_enum (line 1038) | def _repr_enum(obj: Enum, p: RepresentationPrinter, cycle: bool) -> None:
  class _ReprDots (line 1049) | class _ReprDots:
    method __repr__ (line 1050) | def __repr__(self) -> str:
  function _repr_partial (line 1054) | def _repr_partial(obj: partial[Any], p: RepresentationPrinter, cycle: bo...

FILE: hypothesis-python/tests/array_api/common.py
  function installed_array_modules (line 37) | def installed_array_modules() -> dict[str, EntryPoint]:
  function flushes_to_zero (line 48) | def flushes_to_zero(xp, width: Literal[32, 64]) -> bool:

FILE: hypothesis-python/tests/array_api/conftest.py
  class InvalidArgumentWarning (line 44) | class InvalidArgumentWarning(UserWarning):
  function pytest_generate_tests (line 93) | def pytest_generate_tests(metafunc):
  function pytest_collection_modifyitems (line 108) | def pytest_collection_modifyitems(config, items):

FILE: hypothesis-python/tests/array_api/test_argument_validation.py
  function e (line 20) | def e(name, *, _min_version: NominalVersion | None = None, **kwargs):
  function test_raise_invalid_argument (line 222) | def test_raise_invalid_argument(xp, xps, strat_name, kwargs):
  function test_make_strategies_namespace_raise_invalid_argument (line 231) | def test_make_strategies_namespace_raise_invalid_argument(xp, api_version):

FILE: hypothesis-python/tests/array_api/test_arrays.py
  function skip_on_missing_unique_values (line 34) | def skip_on_missing_unique_values(xp):
  function xfail_on_indistinct_nans (line 39) | def xfail_on_indistinct_nans(xp):
  function test_draw_arrays_from_dtype (line 53) | def test_draw_arrays_from_dtype(xp, xps, dtype_name):
  function test_draw_arrays_from_scalar_names (line 60) | def test_draw_arrays_from_scalar_names(xp, xps, dtype_name):
  function test_draw_arrays_from_shapes (line 67) | def test_draw_arrays_from_shapes(xp, xps, data):
  function test_draw_arrays_from_int_shapes (line 76) | def test_draw_arrays_from_int_shapes(xp, xps, data):
  function test_draw_arrays_from_dtype_strategies (line 97) | def test_draw_arrays_from_dtype_strategies(xp, xps, strat_name):
  function test_draw_arrays_from_dtype_name_strategies (line 106) | def test_draw_arrays_from_dtype_name_strategies(xp, xps, data):
  function test_generate_arrays_from_shapes_strategy (line 117) | def test_generate_arrays_from_shapes_strategy(xp, xps):
  function test_generate_arrays_from_integers_strategy_as_shape (line 122) | def test_generate_arrays_from_integers_strategy_as_shape(xp, xps):
  function test_generate_arrays_from_zero_dimensions (line 127) | def test_generate_arrays_from_zero_dimensions(xp, xps):
  function test_generate_arrays_from_zero_sided_shapes (line 133) | def test_generate_arrays_from_zero_sided_shapes(xp, xps, data):
  function test_generate_arrays_from_unsigned_ints (line 140) | def test_generate_arrays_from_unsigned_ints(xp, xps):
  function test_generate_arrays_from_0d_arrays (line 148) | def test_generate_arrays_from_0d_arrays(xp, xps):
  function test_minimize_arrays_with_default_dtype_shape_strategies (line 162) | def test_minimize_arrays_with_default_dtype_shape_strategies(xp, xps):
  function test_minimize_arrays_with_0d_shape_strategy (line 171) | def test_minimize_arrays_with_0d_shape_strategy(xp, xps):
  function test_minimizes_numeric_arrays (line 179) | def test_minimizes_numeric_arrays(xp, xps, dtype):
  function test_minimize_large_uint_arrays (line 185) | def test_minimize_large_uint_arrays(xp, xps):
  function test_minimize_float_arrays (line 198) | def test_minimize_float_arrays(xp, xps):
  function test_minimizes_to_fill (line 214) | def test_minimizes_to_fill(xp, xps):
  function test_generate_unique_arrays (line 221) | def test_generate_unique_arrays(xp, xps):
  function test_cannot_draw_unique_arrays_with_too_small_elements (line 230) | def test_cannot_draw_unique_arrays_with_too_small_elements(xp, xps):
  function test_cannot_fill_arrays_with_non_castable_value (line 239) | def test_cannot_fill_arrays_with_non_castable_value(xp, xps):
  function test_generate_unique_arrays_with_high_collision_elements (line 247) | def test_generate_unique_arrays_with_high_collision_elements(xp, xps):
  function test_generate_unique_arrays_using_all_elements (line 266) | def test_generate_unique_arrays_using_all_elements(xp, xps):
  function test_may_fill_unique_arrays_with_nan (line 276) | def test_may_fill_unique_arrays_with_nan(xp, xps):
  function test_may_not_fill_unique_array_with_non_nan (line 290) | def test_may_not_fill_unique_array_with_non_nan(xp, xps):
  function test_floating_point_array (line 303) | def test_floating_point_array():
  function test_may_not_use_overflowing_integers (line 329) | def test_may_not_use_overflowing_integers(xp, xps, kwargs):
  function test_may_not_use_unrepresentable_elements (line 349) | def test_may_not_use_unrepresentable_elements(xp, xps, fill, dtype, strat):
  function test_floats_can_be_constrained (line 359) | def test_floats_can_be_constrained(xp, xps):
  function test_floats_can_be_constrained_excluding_endpoints (line 370) | def test_floats_can_be_constrained_excluding_endpoints(xp, xps):
  function test_is_still_unique_with_nan_fill (line 388) | def test_is_still_unique_with_nan_fill(xp, xps):
  function test_unique_array_with_fill_can_use_all_elements (line 404) | def test_unique_array_with_fill_can_use_all_elements(xp, xps):
  function test_generate_unique_arrays_without_fill (line 421) | def test_generate_unique_arrays_without_fill(xp, xps):
  function test_efficiently_generate_unique_arrays_using_all_elements (line 436) | def test_efficiently_generate_unique_arrays_using_all_elements(xp, xps):
  function test_array_element_rewriting (line 450) | def test_array_element_rewriting(xp, xps, data, start, size):
  function test_generate_0d_arrays_with_no_fill (line 465) | def test_generate_0d_arrays_with_no_fill(xp, xps):
  function test_excluded_min_in_float_arrays (line 476) | def test_excluded_min_in_float_arrays(xp, xps, dtype, low, data):
  function distinct_int64_integers (line 493) | def distinct_int64_integers(draw):
  function test_does_not_reuse_distinct_integers (line 500) | def test_does_not_reuse_distinct_integers(xp, xps):
  function test_may_reuse_distinct_integers_if_asked (line 510) | def test_may_reuse_distinct_integers_if_asked(xp, xps):
  function test_subnormal_elements_validation (line 525) | def test_subnormal_elements_validation(xp, xps):

FILE: hypothesis-python/tests/array_api/test_from_dtype.py
  function test_strategies_have_reusable_values (line 28) | def test_strategies_have_reusable_values(xp, xps, dtype_name):
  function test_produces_castable_instances_from_dtype (line 35) | def test_produces_castable_instances_from_dtype(xp, xps, dtype_name):
  function test_produces_castable_instances_from_name (line 44) | def test_produces_castable_instances_from_name(xp, xps, dtype_name):
  function test_passing_inferred_strategies_in_arrays (line 53) | def test_passing_inferred_strategies_in_arrays(xp, xps, dtype_name):
  function test_from_dtype_with_kwargs (line 77) | def test_from_dtype_with_kwargs(xp, xps, dtype, kwargs, predicate):
  function test_can_minimize_floats (line 83) | def test_can_minimize_floats(xp, xps):
  function test_subnormal_generation (line 102) | def test_subnormal_generation(xp, xps, kwargs):

FILE: hypothesis-python/tests/array_api/test_indices.py
  function test_generate_optional_indices (line 30) | def test_generate_optional_indices(xp, xps, condition):
  function test_cannot_generate_newaxis_when_disabled (line 40) | def test_cannot_generate_newaxis_when_disabled(xp, xps):
  function test_generate_indices_for_0d_shape (line 47) | def test_generate_indices_for_0d_shape(xp, xps):
  function test_generate_tuples_and_non_tuples_for_1d_shape (line 56) | def test_generate_tuples_and_non_tuples_for_1d_shape(xp, xps):
  function test_generate_long_ellipsis (line 63) | def test_generate_long_ellipsis(xp, xps):
  function test_indices_replaces_whole_axis_slices_with_ellipsis (line 77) | def test_indices_replaces_whole_axis_slices_with_ellipsis(xp, xps):
  function test_efficiently_generate_indexers (line 89) | def test_efficiently_generate_indexers(xp, xps):
  function test_generate_valid_indices (line 95) | def test_generate_valid_indices(xp, xps, allow_newaxis, allow_ellipsis, ...

FILE: hypothesis-python/tests/array_api/test_partial_adoptors.py
  class MockedArray (line 35) | class MockedArray:
    method __init__ (line 36) | def __init__(self, wrapped, *, exclude=()):
    method __getattr__ (line 40) | def __getattr__(self, name):
  function wrap_array (line 47) | def wrap_array(func: callable, exclude: tuple[str, ...] = ()) -> callable:
  function make_mock_xp (line 60) | def make_mock_xp(
  function test_warning_on_noncompliant_xp (line 99) | def test_warning_on_noncompliant_xp():
  function test_error_on_missing_attr (line 111) | def test_error_on_missing_attr(stratname, args, attr):
  function test_error_on_missing_dtypes (line 140) | def test_error_on_missing_dtypes(stratname):
  function test_warning_on_partial_dtypes (line 162) | def test_warning_on_partial_dtypes(stratname, keep_anys, data):
  function test_raises_on_inferring_with_no_dunder_version (line 184) | def test_raises_on_inferring_with_no_dunder_version():
  function test_raises_on_invalid_dunder_version (line 192) | def test_raises_on_invalid_dunder_version():

FILE: hypothesis-python/tests/array_api/test_pretty.py
  function test_namespaced_methods_meta (line 44) | def test_namespaced_methods_meta(xp, xps, name):
  function test_namespaced_strategies_repr (line 78) | def test_namespaced_strategies_repr(xp, xps, name, valid_args):
  function test_inferred_version_strategies_namespace_repr (line 88) | def test_inferred_version_strategies_namespace_repr(xp):
  function test_specified_version_strategies_namespace_repr (line 100) | def test_specified_version_strategies_namespace_repr(xp, monkeypatch):

FILE: hypothesis-python/tests/array_api/test_scalar_dtypes.py
  function test_all_generated_dtypes_are_of_group (line 41) | def test_all_generated_dtypes_are_of_group(xp, xps, strat_name, dtype_na...
  function test_all_generated_scalar_dtypes_are_scalar (line 48) | def test_all_generated_scalar_dtypes_are_scalar(xp, xps):
  function test_all_generated_numeric_dtypes_are_numeric (line 57) | def test_all_generated_numeric_dtypes_are_numeric(xp, xps):
  function skipif_unsupported_complex (line 66) | def skipif_unsupported_complex(strat_name, dtype_name):
  function test_strategy_can_generate_every_dtype (line 85) | def test_strategy_can_generate_every_dtype(xp, xps, strat_name, dtype_na...
  function test_minimise_scalar_dtypes (line 92) | def test_minimise_scalar_dtypes(xp, xps):
  function test_can_specify_sizes_as_an_int (line 108) | def test_can_specify_sizes_as_an_int(xp, xps, strat_name, sizes):

FILE: hypothesis-python/tests/array_api/test_strategies_namespace.py
  class HashableArrayModuleFactory (line 34) | class HashableArrayModuleFactory:
    method __getattr__ (line 40) | def __getattr__(self, name):
    method __hash__ (line 43) | def __hash__(self):
  function test_caching (line 48) | def test_caching(api_version, monkeypatch):
  function test_inferred_namespace_shares_cache (line 68) | def test_inferred_namespace_shares_cache(api_version1, api_version2, mon...
  function test_complex_dtypes_raises_on_2021_12 (line 85) | def test_complex_dtypes_raises_on_2021_12():

FILE: hypothesis-python/tests/attrs/test_attrs.py
  function a_converter (line 22) | def a_converter(x) -> int:
  class Inferrables (line 27) | class Inferrables:
  function test_attrs_inference_builds (line 32) | def test_attrs_inference_builds(c):
  function test_attrs_inference_from_type (line 36) | def test_attrs_inference_from_type():
  class AttrsClass (line 44) | class AttrsClass:
  function test_jsonable_attrs (line 48) | def test_jsonable_attrs():
  function test_hypothesis_is_not_the_first_to_import_attrs (line 53) | def test_hypothesis_is_not_the_first_to_import_attrs(testdir):

FILE: hypothesis-python/tests/attrs/test_inference.py
  class Inferrables (line 27) | class Inferrables:
  class Required (line 72) | class Required:
  class UnhelpfulConverter (line 77) | class UnhelpfulConverter:
  function test_attrs_inference_builds (line 82) | def test_attrs_inference_builds(c):
  function test_attrs_inference_from_type (line 87) | def test_attrs_inference_from_type(c):
  function test_cannot_infer (line 92) | def test_cannot_infer(c):
  function test_cannot_infer_takes_self (line 97) | def test_cannot_infer_takes_self():
  class HasPrivateAttribute (line 105) | class HasPrivateAttribute:
  function test_private_attribute (line 110) | def test_private_attribute(s):
  function test_private_attribute_underscore_fails (line 114) | def test_private_attribute_underscore_fails():
  function test_private_attribute_underscore_infer_fails (line 119) | def test_private_attribute_underscore_infer_fails():
  class HasAliasedAttribute (line 129) | class HasAliasedAttribute:
  function test_aliased_attribute (line 134) | def test_aliased_attribute(s):

FILE: hypothesis-python/tests/attrs/test_pretty.py
  class ReprDetector (line 16) | class ReprDetector:
    method _repr_pretty_ (line 17) | def _repr_pretty_(self, p, cycle):
    method __repr__ (line 21) | def __repr__(self):
  class SomeAttrsClass (line 26) | class SomeAttrsClass:
  function test_pretty_prints_attrs_classes (line 30) | def test_pretty_prints_attrs_classes():
  class SomeAttrsClassWithCustomPretty (line 35) | class SomeAttrsClassWithCustomPretty:
    method _repr_pretty_ (line 36) | def _repr_pretty_(self, p, cycle):
  function test_custom_pretty_print_method_overrides_field_printing (line 41) | def test_custom_pretty_print_method_overrides_field_printing():
  class SomeAttrsClassWithLotsOfFields (line 46) | class SomeAttrsClassWithLotsOfFields:
  function test_will_line_break_between_fields (line 68) | def test_will_line_break_between_fields():
  class SomeDataClassWithNoFields (line 79) | class SomeDataClassWithNoFields: ...
  function test_prints_empty_dataclass_correctly (line 82) | def test_prints_empty_dataclass_correctly():
  class AttrsClassWithNoInitField (line 87) | class AttrsClassWithNoInitField:
  function test_does_not_include_no_init_fields_in_attrs_printing (line 92) | def test_does_not_include_no_init_fields_in_attrs_printing():
  class Namespace (line 99) | class Namespace:
    class A (line 101) | class A:
  function test_includes_namespace_classes_in_pretty (line 105) | def test_includes_namespace_classes_in_pretty():

FILE: hypothesis-python/tests/codemods/test_codemod_cli.py
  function run (line 35) | def run(command, *, cwd=None, input=None):
  function test_codemod_single_file (line 47) | def test_codemod_single_file(tmp_path):
  function test_codemod_multiple_files (line 55) | def test_codemod_multiple_files(tmp_path):
  function test_codemod_from_stdin (line 66) | def test_codemod_from_stdin():

FILE: hypothesis-python/tests/codemods/test_codemods.py
  function test_refactor_function_is_idempotent (line 16) | def test_refactor_function_is_idempotent():
  class TestFixComplexMinMagnitude (line 26) | class TestFixComplexMinMagnitude(CodemodTest):
    method test_noop (line 29) | def test_noop(self) -> None:
    method test_substitution (line 43) | def test_substitution(self) -> None:
  class TestFixPositionalKeywonlyArgs (line 55) | class TestFixPositionalKeywonlyArgs(CodemodTest):
    method test_substitution (line 58) | def test_substitution(self) -> None:
    method test_noop_with_new_floats_kw (line 73) | def test_noop_with_new_floats_kw(self) -> None:
    method test_noop_if_unsure (line 81) | def test_noop_if_unsure(self) -> None:
    method test_stateful_rule_noop (line 103) | def test_stateful_rule_noop(self):
    method test_kwargs_noop (line 116) | def test_kwargs_noop(self):
    method test_noop_with_too_many_arguments_passed (line 125) | def test_noop_with_too_many_arguments_passed(self) -> None:
  class TestHealthCheckAll (line 136) | class TestHealthCheckAll(CodemodTest):
    method test_noop_other_attributes (line 139) | def test_noop_other_attributes(self):
    method test_substitution (line 144) | def test_substitution(self) -> None:
  class TestFixCharactersArguments (line 152) | class TestFixCharactersArguments(CodemodTest):
    method test_substitution (line 155) | def test_substitution(self) -> None:
    method test_remove_redundant_exclude_categories (line 163) | def test_remove_redundant_exclude_categories(self) -> None:

FILE: hypothesis-python/tests/common/__init__.py
  function abc (line 46) | def abc(x, y, z):

FILE: hypothesis-python/tests/common/arguments.py
  function e (line 17) | def e(a, *args, **kwargs):
  function e_to_str (line 21) | def e_to_str(elt):
  function argument_validation_test (line 28) | def argument_validation_test(bad_args):

FILE: hypothesis-python/tests/common/costbounds.py
  function find_integer_cost (line 16) | def find_integer_cost(n):

FILE: hypothesis-python/tests/common/debug.py
  class Found (line 29) | class Found(Exception):
  function minimal (line 33) | def minimal(
  function find_any (line 86) | def find_any(definition, condition=lambda _: True, settings=None):
  function assert_no_examples (line 104) | def assert_no_examples(strategy, condition=lambda _: True):
  function assert_all_examples (line 111) | def assert_all_examples(strategy, predicate, settings=None):
  function assert_simple_property (line 135) | def assert_simple_property(strategy, predicate, settings=None):
  function check_can_generate_examples (line 154) | def check_can_generate_examples(strategy, settings=None):

FILE: hypothesis-python/tests/common/setup.py
  function run (line 26) | def run():

FILE: hypothesis-python/tests/common/strategies.py
  class _Slow (line 16) | class _Slow(SearchStrategy):
    method do_draw (line 17) | def do_draw(self, data):
  class HardToShrink (line 25) | class HardToShrink(SearchStrategy):
    method __init__ (line 26) | def __init__(self):
    method do_draw (line 31) | def do_draw(self, data):

FILE: hypothesis-python/tests/common/utils.py
  function flaky (line 48) | def flaky(max_runs, min_passes):
  function capture_out (line 75) | def capture_out():
  class ExcInfo (line 89) | class ExcInfo:
  function fails_with (line 93) | def fails_with(e, *, match=None):
  class NotDeprecated (line 108) | class NotDeprecated(Exception):
  function validate_deprecation (line 113) | def validate_deprecation():
  function checks_deprecated_behaviour (line 135) | def checks_deprecated_behaviour(func):
  function all_values (line 146) | def all_values(db):
  function non_covering_examples (line 150) | def non_covering_examples(database):
  function counts_calls (line 156) | def counts_calls(func):
  function assert_output_contains_failure (line 171) | def assert_output_contains_failure(output, test, **kwargs):
  function assert_falsifying_output (line 177) | def assert_falsifying_output(
  function temp_registered (line 200) | def temp_registered(type_, strat_or_factory):
  function raises_warning (line 219) | def raises_warning(expected_warning, match=None):
  function capture_observations (line 227) | def capture_observations(*, choices=None):
  class Why (line 250) | class Why(enum.Enum):
  function xfail_on_crosshair (line 259) | def xfail_on_crosshair(why: Why, /, *, strict=True, as_marks=False):
  function skipif_threading (line 271) | def skipif_threading(f):
  function xfail_if_gil_disabled (line 277) | def xfail_if_gil_disabled(f):
  function restore_recursion_limit (line 296) | def restore_recursion_limit():
  function run_concurrently (line 305) | def run_concurrently(function, *, n: int) -> None:
  function wait_for (line 327) | def wait_for(condition, *, timeout=1, interval=0.01):

FILE: hypothesis-python/tests/conftest.py
  function pytest_configure (line 53) | def pytest_configure(config):
  function pytest_addoption (line 74) | def pytest_addoption(parser):
  function warns_or_raises (line 81) | def warns_or_raises(request):
  function _make_unknown_lambdas_fail (line 104) | def _make_unknown_lambdas_fail(monkeypatch):
  function allow_unknown_lambdas (line 121) | def allow_unknown_lambdas(monkeypatch):
  function _consistently_increment_time (line 137) | def _consistently_increment_time(monkeypatch):
  function pytest_runtest_call (line 214) | def pytest_runtest_call(item):
  function _worker_path (line 266) | def _worker_path(session: pytest.Session) -> Path:
  function _benchmark_shrinks (line 274) | def _benchmark_shrinks(item: pytest.Function) -> None:
  function pytest_sessionfinish (line 318) | def pytest_sessionfinish(session, exitstatus):

FILE: hypothesis-python/tests/conjecture/common.py
  function interesting_origin (line 39) | def interesting_origin(n: int | None = None) -> InterestingOrigin:
  function run_to_data (line 55) | def run_to_data(f):
  function run_to_nodes (line 69) | def run_to_nodes(f):
  function buffer_size_limit (line 77) | def buffer_size_limit(n):
  function shrinking_from (line 87) | def shrinking_from(start):
  function fresh_data (line 110) | def fresh_data(*, random=None, observer=None) -> ConjectureData:
  function clamped_shrink_towards (line 150) | def clamped_shrink_towards(constraints):
  function draw_value (line 159) | def draw_value(choice_type, constraints):
  function choices (line 165) | def choices(draw):
  function nodes (line 171) | def nodes(draw, *, was_forced=None, choice_types=None):
  function nodes_inline (line 187) | def nodes_inline(*values: list[ChoiceT]) -> list[ChoiceNode]:
  function float_constr (line 248) | def float_constr(
  function integer_constr (line 263) | def integer_constr(min_value=None, max_value=None, *, weights=None, shri...
  function string_constr (line 272) | def string_constr(intervals, *, min_size=0, max_size=COLLECTION_DEFAULT_...

FILE: hypothesis-python/tests/conjecture/test_choice.py
  function test_compute_max_children_is_positive (line 71) | def test_compute_max_children_is_positive(choice_type_and_constraints):
  function test_compute_max_children (line 171) | def test_compute_max_children(choice_type, constraints, count_children):
  function test_draw_string_single_interval_with_equal_bounds (line 176) | def test_draw_string_single_interval_with_equal_bounds(s, n):
  function test_compute_max_children_and_all_children_agree (line 208) | def test_compute_max_children_and_all_children_agree(choice_type_and_con...
  function test_compute_max_children_unbounded_integer_ranges (line 228) | def test_compute_max_children_unbounded_integer_ranges(constraints):
  function test_nodes (line 235) | def test_nodes(random):
  function test_copy_choice_node (line 288) | def test_copy_choice_node(node):
  function test_choice_node_equality (line 300) | def test_choice_node_equality(node):
  function test_cannot_modify_forced_nodes (line 307) | def test_cannot_modify_forced_nodes(node):
  function test_data_with_empty_choices_is_overrun (line 312) | def test_data_with_empty_choices_is_overrun():
  function test_data_with_changed_forced_value (line 321) | def test_data_with_changed_forced_value(node):
  function test_data_with_same_forced_value_is_valid (line 377) | def test_data_with_same_forced_value_is_valid(node):
  function test_all_children_are_permitted_values (line 392) | def test_all_children_are_permitted_values(choice_type_and_constraints):
  function test_choice_permitted (line 461) | def test_choice_permitted(value, constraints, permitted):
  function test_forced_nodes_are_trivial (line 466) | def test_forced_nodes_are_trivial(node):
  function test_trivial_nodes (line 587) | def test_trivial_nodes(node):
  function test_nontrivial_nodes (line 662) | def test_nontrivial_nodes(node):
  function test_conservative_nontrivial_nodes (line 709) | def test_conservative_nontrivial_nodes(node):
  function test_choice_node_is_hashable (line 723) | def test_choice_node_is_hashable(node):
  function test_choices_size_positive (line 728) | def test_choices_size_positive(nodes):
  function test_node_template_count (line 733) | def test_node_template_count(n):
  function test_node_template_to_overrun (line 738) | def test_node_template_to_overrun():
  function test_node_template_single_node_overruns (line 748) | def test_node_template_single_node_overruns():
  function test_node_template_simplest_is_actually_trivial (line 759) | def test_node_template_simplest_is_actually_trivial(node):
  function test_choice_indices_are_positive (line 771) | def test_choice_indices_are_positive(choice_type_and_constraints):
  function test_shrink_towards_has_index_0 (line 778) | def test_shrink_towards_has_index_0(constraints):
  function test_choice_to_index_injective (line 787) | def test_choice_to_index_injective(choice_type_and_constraints):
  function test_choice_from_value_injective (line 812) | def test_choice_from_value_injective(choice_type_and_constraints):
  function test_choice_index_and_value_are_inverses (line 825) | def test_choice_index_and_value_are_inverses(choice_type_and_constraints):
  function test_choice_index_and_value_are_inverses_explicit (line 856) | def test_choice_index_and_value_are_inverses_explicit(
  function test_integer_choice_index (line 887) | def test_integer_choice_index(constraints, choices):
  function test_drawing_directly_matches_for_choices (line 895) | def test_drawing_directly_matches_for_choices(nodes):
  function test_draw_directly_explicit (line 902) | def test_draw_directly_explicit():
  function test_choices_key_distinguishes_weird_cases (line 944) | def test_choices_key_distinguishes_weird_cases(choices1, choices2):
  function test_node_template_overrun (line 948) | def test_node_template_overrun():

FILE: hypothesis-python/tests/conjecture/test_choice_tree.py
  function select (line 21) | def select(*args):
  function exhaust (line 25) | def exhaust(f):
  function test_can_enumerate_a_shallow_set (line 40) | def test_can_enumerate_a_shallow_set(ls):
  function test_can_enumerate_a_nested_set (line 46) | def test_can_enumerate_a_nested_set():
  function test_can_enumerate_empty (line 56) | def test_can_enumerate_empty():
  function test_all_filtered_child (line 64) | def test_all_filtered_child():
  function test_skips_over_exhausted_children (line 72) | def test_skips_over_exhausted_children():
  function test_extends_prefix_from_right (line 92) | def test_extends_prefix_from_right():
  function test_starts_from_the_end (line 101) | def test_starts_from_the_end():
  function test_skips_over_exhausted_subtree (line 109) | def test_skips_over_exhausted_subtree():
  function test_exhausts_randomly (line 118) | def test_exhausts_randomly():
  function test_exhausts_randomly_when_filtering (line 135) | def test_exhausts_randomly_when_filtering():

FILE: hypothesis-python/tests/conjecture/test_data_tree.py
  function runner_for (line 47) | def runner_for(*examples):
  function test_can_lookup_cached_examples (line 65) | def test_can_lookup_cached_examples():
  function test_can_lookup_cached_examples_with_forced (line 72) | def test_can_lookup_cached_examples_with_forced():
  function test_can_detect_when_tree_is_exhausted (line 79) | def test_can_detect_when_tree_is_exhausted():
  function test_can_detect_when_tree_is_exhausted_variable_size (line 87) | def test_can_detect_when_tree_is_exhausted_variable_size():
  function test_one_dead_branch (line 96) | def test_one_dead_branch():
  function test_non_dead_root (line 107) | def test_non_dead_root():
  function test_can_reexecute_dead_examples (line 114) | def test_can_reexecute_dead_examples():
  function test_novel_prefixes_are_novel (line 121) | def test_novel_prefixes_are_novel():
  function test_overruns_if_prefix (line 138) | def test_overruns_if_prefix():
  function test_stores_the_tree_flat_until_needed (line 148) | def test_stores_the_tree_flat_until_needed():
  function test_split_in_the_middle (line 161) | def test_split_in_the_middle():
  function test_stores_forced_nodes (line 175) | def test_stores_forced_nodes():
  function test_correctly_relocates_forced_nodes (line 187) | def test_correctly_relocates_forced_nodes():
  function test_can_go_from_interesting_to_valid (line 199) | def test_can_go_from_interesting_to_valid():
  function test_going_from_interesting_to_invalid_is_flaky (line 210) | def test_going_from_interesting_to_invalid_is_flaky():
  function test_concluding_at_prefix_is_flaky (line 221) | def test_concluding_at_prefix_is_flaky():
  function test_concluding_with_overrun_at_prefix_is_not_flaky (line 233) | def test_concluding_with_overrun_at_prefix_is_not_flaky():
  function test_changing_n_bits_is_flaky_in_prefix (line 245) | def test_changing_n_bits_is_flaky_in_prefix():
  function test_changing_n_bits_is_flaky_in_branch (line 257) | def test_changing_n_bits_is_flaky_in_branch():
  function test_extending_past_conclusion_is_flaky (line 271) | def test_extending_past_conclusion_is_flaky():
  function test_changing_to_forced_is_flaky (line 285) | def test_changing_to_forced_is_flaky():
  function test_changing_value_of_forced_is_flaky (line 298) | def test_changing_value_of_forced_is_flaky():
  function test_does_not_truncate_if_unseen (line 311) | def test_does_not_truncate_if_unseen():
  function test_truncates_if_seen (line 317) | def test_truncates_if_seen():
  function test_child_becomes_exhausted_after_split (line 330) | def test_child_becomes_exhausted_after_split():
  function test_will_generate_novel_prefix_to_avoid_exhausted_branches (line 346) | def test_will_generate_novel_prefix_to_avoid_exhausted_branches():
  function test_will_mark_changes_in_discard_as_flaky (line 363) | def test_will_mark_changes_in_discard_as_flaky():
  function test_is_not_flaky_on_positive_zero_and_negative_zero (line 380) | def test_is_not_flaky_on_positive_zero_and_negative_zero():
  function test_low_probabilities_are_still_explored (line 404) | def test_low_probabilities_are_still_explored():
  function _test_observed_draws_are_recorded_in_tree (line 413) | def _test_observed_draws_are_recorded_in_tree(choice_type):
  function _test_non_observed_draws_are_not_recorded_in_tree (line 433) | def _test_non_observed_draws_are_not_recorded_in_tree(choice_type):
  function test_observed_choice_type_draw (line 453) | def test_observed_choice_type_draw(choice_type):
  function test_non_observed_choice_type_draw (line 460) | def test_non_observed_choice_type_draw(choice_type):
  function test_can_generate_hard_values (line 464) | def test_can_generate_hard_values():
  function test_can_generate_hard_floats (line 484) | def test_can_generate_hard_floats():
  function test_datatree_repr (line 524) | def test_datatree_repr(bool_constraints, int_constraints):
  function _draw (line 567) | def _draw(data, node, *, forced=None):
  function test_simulate_forced_floats (line 572) | def test_simulate_forced_floats(node):

FILE: hypothesis-python/tests/conjecture/test_engine.py
  function test_non_cloneable_intervals (line 69) | def test_non_cloneable_intervals():
  function test_deletable_draws (line 79) | def test_deletable_draws():
  function test_can_load_data_from_a_corpus (line 90) | def test_can_load_data_from_a_corpus():
  function slow_shrinker (line 107) | def slow_shrinker():
  function test_terminates_shrinks (line 118) | def test_terminates_shrinks(n, monkeypatch):
  function test_detects_flakiness (line 144) | def test_detects_flakiness():
  function recur (line 162) | def recur(i, data):
  function test_recursion_error_is_not_flaky (line 171) | def test_recursion_error_is_not_flaky():
  function test_variadic_draw (line 184) | def test_variadic_draw():
  function test_draw_to_overrun (line 205) | def test_draw_to_overrun():
  function test_can_navigate_to_a_valid_example (line 216) | def test_can_navigate_to_a_valid_example():
  function test_stops_after_max_examples_when_reading (line 228) | def test_stops_after_max_examples_when_reading():
  function test_stops_after_max_examples_when_generating (line 247) | def test_stops_after_max_examples_when_generating():
  function test_stops_after_max_examples_when_generating_more_bugs (line 259) | def test_stops_after_max_examples_when_generating_more_bugs(examples):
  function test_interleaving_engines (line 286) | def test_interleaving_engines():
  function test_phases_can_disable_shrinking (line 308) | def test_phases_can_disable_shrinking():
  function test_reuse_phase_runs_for_max_examples_if_generation_is_disabled (line 322) | def test_reuse_phase_runs_for_max_examples_if_generation_is_disabled():
  function test_erratic_draws (line 341) | def test_erratic_draws():
  function test_no_read_no_shrink (line 357) | def test_no_read_no_shrink():
  function test_one_dead_branch (line 370) | def test_one_dead_branch():
  function test_does_not_save_on_interrupt (line 385) | def test_does_not_save_on_interrupt():
  function test_saves_on_skip_exceptions_to_reraise (line 398) | def test_saves_on_skip_exceptions_to_reraise():
  function test_returns_forced (line 416) | def test_returns_forced():
  function fails_health_check (line 427) | def fails_health_check(label, **kwargs):
  function test_fails_health_check_for_all_invalid (line 444) | def test_fails_health_check_for_all_invalid():
  function test_fails_health_check_for_large_base (line 451) | def test_fails_health_check_for_large_base():
  function test_fails_health_check_for_large_non_base (line 457) | def test_fails_health_check_for_large_non_base():
  function test_fails_health_check_for_slow_draws (line 465) | def test_fails_health_check_for_slow_draws():
  function test_health_check_too_slow_with_invalid_examples (line 471) | def test_health_check_too_slow_with_invalid_examples():
  function test_health_check_too_slow_with_overrun_examples (line 492) | def test_health_check_too_slow_with_overrun_examples():
  function test_can_shrink_variable_draws (line 517) | def test_can_shrink_variable_draws(n_large):
  function test_can_shrink_variable_string_draws (line 530) | def test_can_shrink_variable_string_draws():
  function test_variable_size_string_increasing (line 547) | def test_variable_size_string_increasing():
  function test_run_nothing (line 563) | def test_run_nothing():
  class Foo (line 572) | class Foo:
    method __repr__ (line 573) | def __repr__(self):
  function test_debug_data (line 577) | def test_debug_data(capsys):
  function test_can_write_bytes_towards_the_end (line 605) | def test_can_write_bytes_towards_the_end():
  function test_uniqueness_is_preserved_when_writing_at_beginning (line 618) | def test_uniqueness_is_preserved_when_writing_at_beginning():
  function test_clears_out_its_database_on_shrinking (line 634) | def test_clears_out_its_database_on_shrinking(
  function test_shrinks_both_interesting_examples (line 668) | def test_shrinks_both_interesting_examples(monkeypatch):
  function test_discarding (line 686) | def test_discarding(monkeypatch):
  function test_can_remove_discarded_data (line 708) | def test_can_remove_discarded_data():
  function test_discarding_iterates_to_fixed_point (line 723) | def test_discarding_iterates_to_fixed_point():
  function test_discarding_is_not_fooled_by_empty_discards (line 737) | def test_discarding_is_not_fooled_by_empty_discards():
  function test_discarding_can_fail (line 750) | def test_discarding_can_fail():
  function test_shrinking_from_mostly_zero (line 762) | def test_shrinking_from_mostly_zero(monkeypatch):
  function test_handles_nesting_of_discard_correctly (line 778) | def test_handles_nesting_of_discard_correctly(monkeypatch):
  function test_database_clears_secondary_key (line 801) | def test_database_clears_secondary_key():
  function test_database_uses_values_from_secondary_key (line 834) | def test_database_uses_values_from_secondary_key():
  function test_exit_because_max_iterations (line 870) | def test_exit_because_max_iterations():
  function test_max_iterations_with_all_invalid (line 888) | def test_max_iterations_with_all_invalid():
  function test_max_iterations_with_some_valid (line 908) | def test_max_iterations_with_some_valid(n_valid):
  function test_exit_because_shrink_phase_timeout (line 934) | def test_exit_because_shrink_phase_timeout(monkeypatch):
  function test_dependent_block_pairs_can_lower_to_zero (line 953) | def test_dependent_block_pairs_can_lower_to_zero():
  function test_handle_size_too_large_during_dependent_lowering (line 968) | def test_handle_size_too_large_during_dependent_lowering():
  function test_block_may_grow_during_lexical_shrinking (line 980) | def test_block_may_grow_during_lexical_shrinking():
  function test_lower_common_node_offset_does_nothing_when_changed_blocks_are_zero (line 995) | def test_lower_common_node_offset_does_nothing_when_changed_blocks_are_z...
  function test_lower_common_node_offset_ignores_zeros (line 1010) | def test_lower_common_node_offset_ignores_zeros():
  function test_cached_test_function_returns_right_value (line 1025) | def test_cached_test_function_returns_right_value():
  function test_cached_test_function_does_not_reinvoke_on_prefix (line 1043) | def test_cached_test_function_does_not_reinvoke_on_prefix():
  function test_will_evict_entries_from_the_cache (line 1063) | def test_will_evict_entries_from_the_cache(monkeypatch):
  function test_branch_ending_in_write (line 1084) | def test_branch_ending_in_write():
  function test_exhaust_space (line 1111) | def test_exhaust_space():
  function test_discards_kill_branches (line 1123) | def test_discards_kill_branches():
  function test_number_of_examples_in_integer_range_is_bounded (line 1146) | def test_number_of_examples_in_integer_range_is_bounded(n):
  function test_prefix_cannot_exceed_buffer_size (line 1155) | def test_prefix_cannot_exceed_buffer_size(monkeypatch):
  function test_does_not_shrink_multiple_bugs_when_told_not_to (line 1170) | def test_does_not_shrink_multiple_bugs_when_told_not_to():
  function test_does_not_keep_generating_when_multiple_bugs (line 1192) | def test_does_not_keep_generating_when_multiple_bugs():
  function test_shrink_after_max_examples (line 1210) | def test_shrink_after_max_examples():
  function test_shrink_after_max_iterations (line 1265) | def test_shrink_after_max_iterations():
  function test_populates_the_pareto_front (line 1321) | def test_populates_the_pareto_front():
  function test_pareto_front_contains_smallest_valid (line 1340) | def test_pareto_front_contains_smallest_valid():
  function test_replaces_all_dominated (line 1360) | def test_replaces_all_dominated():
  function test_does_not_duplicate_elements (line 1385) | def test_does_not_duplicate_elements():
  function test_includes_right_hand_side_targets_in_dominance (line 1404) | def test_includes_right_hand_side_targets_in_dominance():
  function test_smaller_interesting_dominates_larger_valid (line 1421) | def test_smaller_interesting_dominates_larger_valid():
  function test_runs_full_set_of_examples (line 1437) | def test_runs_full_set_of_examples():
  function test_runs_optimisation_even_if_not_generating (line 1451) | def test_runs_optimisation_even_if_not_generating():
  function test_runs_optimisation_once_when_generating (line 1466) | def test_runs_optimisation_once_when_generating():
  function test_does_not_run_optimisation_when_max_examples_is_small (line 1482) | def test_does_not_run_optimisation_when_max_examples_is_small():
  function test_does_not_cache_extended_prefix (line 1498) | def test_does_not_cache_extended_prefix():
  function test_does_cache_if_extend_is_not_used (line 1512) | def test_does_cache_if_extend_is_not_used():
  function test_does_result_for_reuse (line 1529) | def test_does_result_for_reuse():
  function test_does_not_use_cached_overrun_if_extending (line 1546) | def test_does_not_use_cached_overrun_if_extending():
  function test_uses_cached_overrun_if_not_extending (line 1564) | def test_uses_cached_overrun_if_not_extending():
  function test_can_be_set_to_ignore_limits (line 1580) | def test_can_be_set_to_ignore_limits():
  function test_too_slow_report (line 1596) | def test_too_slow_report():
  function _draw (line 1623) | def _draw(cd, node):
  function test_overruns_with_extend_are_not_cached (line 1628) | def test_overruns_with_extend_are_not_cached(node):
  function test_simulate_to_evicted_data (line 1653) | def test_simulate_to_evicted_data(monkeypatch):
  function test_mildly_complicated_strategies (line 1688) | def test_mildly_complicated_strategies(strategy, condition):
  function test_does_not_shrink_if_replaying_from_database (line 1695) | def test_does_not_shrink_if_replaying_from_database():
  function test_does_shrink_if_replaying_inexact_from_database (line 1712) | def test_does_shrink_if_replaying_inexact_from_database():
  function test_stops_if_hits_interesting_early_and_only_want_one_bug (line 1727) | def test_stops_if_hits_interesting_early_and_only_want_one_bug():
  function test_skips_secondary_if_interesting_is_found (line 1744) | def test_skips_secondary_if_interesting_is_found():
  function test_discards_invalid_db_entries (line 1767) | def test_discards_invalid_db_entries(key_name):
  function test_discards_invalid_db_entries_pareto (line 1799) | def test_discards_invalid_db_entries_pareto():

FILE: hypothesis-python/tests/conjecture/test_float_encoding.py
  function assert_reordered_exponents (line 28) | def assert_reordered_exponents(res):
  function test_encode_permutes_elements (line 36) | def test_encode_permutes_elements():
  function test_decode_permutes_elements (line 40) | def test_decode_permutes_elements():
  function test_decode_encode (line 44) | def test_decode_encode():
  function test_encode_decode (line 49) | def test_encode_decode():
  function test_double_reverse_bounded (line 55) | def test_double_reverse_bounded(data):
  function test_double_reverse (line 63) | def test_double_reverse(i):
  function test_floats_round_trip (line 76) | def test_floats_round_trip(f):
  function test_floats_order_worse_than_their_integral_part (line 86) | def test_floats_order_worse_than_their_integral_part(n, g):
  function test_integral_floats_order_as_integers (line 105) | def test_integral_floats_order_as_integers(x, y):
  function test_fractional_floats_are_worse_than_one (line 112) | def test_fractional_floats_are_worse_than_one(f):
  function test_reverse_bits_table_reverses_bits (line 117) | def test_reverse_bits_table_reverses_bits():
  function test_reverse_bits_table_has_right_elements (line 122) | def test_reverse_bits_table_has_right_elements():
  function float_runner (line 126) | def float_runner(start, condition, *, constraints=None):
  function minimal_from (line 140) | def minimal_from(start, condition, *, constraints=None):
  function test_can_shrink_downwards (line 161) | def test_can_shrink_downwards(start, end):
  function test_shrinks_downwards_to_integers (line 169) | def test_shrinks_downwards_to_integers(f, mul):
  function test_shrink_to_integer_upper_bound (line 174) | def test_shrink_to_integer_upper_bound():
  function test_shrink_up_to_one (line 178) | def test_shrink_up_to_one():
  function test_shrink_down_to_half (line 182) | def test_shrink_down_to_half():
  function test_shrink_fractional_part (line 186) | def test_shrink_fractional_part():
  function test_does_not_shrink_across_one (line 190) | def test_does_not_shrink_across_one():
  function test_reject_out_of_bounds_floats_while_shrinking (line 201) | def test_reject_out_of_bounds_floats_while_shrinking():
  function test_shrinks_to_canonical_nan (line 209) | def test_shrinks_to_canonical_nan(nan):

FILE: hypothesis-python/tests/conjecture/test_forced.py
  function test_forced_many (line 30) | def test_forced_many(data):
  function test_forced_values (line 134) | def test_forced_values(choice_type_and_constraints):
  function test_forced_floats_with_nan (line 161) | def test_forced_floats_with_nan(random, sign, min_value, max_value):
  function test_forced_with_large_magnitude_integers (line 169) | def test_forced_with_large_magnitude_integers(data):

FILE: hypothesis-python/tests/conjecture/test_inquisitor.py
  function fails_with_output (line 20) | def fails_with_output(expected):
  function test_inquisitor_comments_basic_fail_if_either (line 55) | def test_inquisitor_comments_basic_fail_if_either(a, b, c, d, e):
  function test_inquisitor_comments_basic_fail_if_not_all (line 71) | def test_inquisitor_comments_basic_fail_if_not_all(a, b, c):
  function test_inquisitor_no_together_comment_if_single_argument (line 86) | def test_inquisitor_no_together_comment_if_single_argument(a, b):
  function ints_with_forced_draw (line 91) | def ints_with_forced_draw(draw):
  function test_inquisitor_doesnt_break_on_varying_forced_nodes (line 108) | def test_inquisitor_doesnt_break_on_varying_forced_nodes(n1, n2):
  function test_issue_3755_regression (line 115) | def test_issue_3755_regression(start_date, data):
  class MyClass (line 123) | class MyClass:
    method __init__ (line 124) | def __init__(self, x, y):
  function test_inquisitor_builds_subargs (line 141) | def test_inquisitor_builds_subargs(obj):
  function test_inquisitor_builds_kwargs_subargs (line 157) | def test_inquisitor_builds_kwargs_subargs(obj):
  function test_inquisitor_tuple_subargs (line 173) | def test_inquisitor_tuple_subargs(t):
  function test_inquisitor_fixeddict_subargs (line 189) | def test_inquisitor_fixeddict_subargs(d):
  function test_inquisitor_tuple_multiple_varying (line 206) | def test_inquisitor_tuple_multiple_varying(t):
  function test_inquisitor_skip_subset_slices (line 224) | def test_inquisitor_skip_subset_slices(obj):
  function test_inquisitor_duplicate_param_names (line 244) | def test_inquisitor_duplicate_param_names(kw, b):
  class Outer (line 252) | class Outer:
    method __init__ (line 253) | def __init__(self, inner, value):
  class Inner (line 258) | class Inner:
    method __init__ (line 259) | def __init__(self, x):
  function test_inquisitor_multi_level_nesting (line 281) | def test_inquisitor_multi_level_nesting(bare, outer):

FILE: hypothesis-python/tests/conjecture/test_intlist.py
  function test_intlist_is_equal_to_itself (line 20) | def test_intlist_is_equal_to_itself(ls):
  function test_distinct_int_lists_are_not_equal (line 25) | def test_distinct_int_lists_are_not_equal(x, y):
  function test_basic_equality (line 30) | def test_basic_equality():
  function test_error_on_invalid_value (line 41) | def test_error_on_invalid_value():
  function test_extend_by_too_large (line 46) | def test_extend_by_too_large():

FILE: hypothesis-python/tests/conjecture/test_junkdrawer.py
  function test_out_of_range (line 36) | def test_out_of_range():
  function test_pass_through (line 46) | def test_pass_through():
  function test_can_assign_without_changing_underlying (line 53) | def test_can_assign_without_changing_underlying():
  function test_pop (line 61) | def test_pop():
  function clamp_inputs (line 71) | def clamp_inputs(draw):
  function test_clamp (line 87) | def test_clamp(input):
  function test_pop_sequence_copy (line 107) | def test_pop_sequence_copy(lst, data, should_mask):
  function test_assignment (line 128) | def test_assignment():
  function test_replacement (line 137) | def test_replacement():
  function test_int_list_cannot_contain_negative (line 142) | def test_int_list_cannot_contain_negative():
  function test_int_list_can_contain_arbitrary_size (line 147) | def test_int_list_can_contain_arbitrary_size():
  function test_int_list_of_length (line 152) | def test_int_list_of_length():
  function test_int_list_equality (line 156) | def test_int_list_equality():
  function test_int_list_extend (line 168) | def test_int_list_extend():
  function test_int_list_slice (line 175) | def test_int_list_slice():
  function test_int_list_del (line 182) | def test_int_list_del():
  function test_int_list_insert (line 188) | def test_int_list_insert():
  function test_binary_search (line 195) | def test_binary_search(n):
  function recur (line 200) | def recur(i):
  function test_stack_size_detection (line 206) | def test_stack_size_detection():
  function test_startswith (line 211) | def test_startswith(b1, b2):
  function test_endswith (line 216) | def test_endswith(b1, b2):
  function test_stackframes_warns_when_recursion_limit_is_changed (line 220) | def test_stackframes_warns_when_recursion_limit_is_changed():
  function test_stackframes_cleans_up_on_werror (line 236) | def test_stackframes_cleans_up_on_werror():

FILE: hypothesis-python/tests/conjecture/test_local_constants.py
  function test_can_draw_local_constants_integers (line 30) | def test_can_draw_local_constants_integers(monkeypatch, value):
  function test_can_draw_local_constants_floats (line 42) | def test_can_draw_local_constants_floats(monkeypatch, value):
  function test_can_draw_local_constants_bytes (line 51) | def test_can_draw_local_constants_bytes(monkeypatch, value):
  function test_can_draw_local_constants_string (line 60) | def test_can_draw_local_constants_string(monkeypatch, value):
  function test_actual_collection (line 74) | def test_actual_collection(monkeypatch, tmp_path):
  function test_unhashable_sys_modules_entry (line 99) | def test_unhashable_sys_modules_entry(monkeypatch):

FILE: hypothesis-python/tests/conjecture/test_minimizer.py
  function test_shrink_to_zero (line 25) | def test_shrink_to_zero():
  function test_shrink_to_smallest (line 29) | def test_shrink_to_smallest():
  function test_can_sort_bytes_by_reordering (line 33) | def test_can_sort_bytes_by_reordering():
  function test_can_sort_bytes_by_reordering_partially (line 39) | def test_can_sort_bytes_by_reordering_partially():
  function test_can_sort_bytes_by_reordering_partially2 (line 45) | def test_can_sort_bytes_by_reordering_partially2():
  function test_can_sort_bytes_by_reordering_partially_not_cross_stationary_element (line 55) | def test_can_sort_bytes_by_reordering_partially_not_cross_stationary_ele...
  function test_shrink_strings (line 74) | def test_shrink_strings(initial, predicate, intervals, expected):
  function test_shrink_bytes (line 89) | def test_shrink_bytes(initial, predicate, expected):
  function test_collection_left_is_better (line 93) | def test_collection_left_is_better():

FILE: hypothesis-python/tests/conjecture/test_mutations.py
  function test_can_find_duplicated_subtree (line 18) | def test_can_find_duplicated_subtree():

FILE: hypothesis-python/tests/conjecture/test_optimiser.py
  function test_optimises_to_maximum (line 34) | def test_optimises_to_maximum():
  function test_optimises_multiple_targets (line 49) | def test_optimises_multiple_targets():
  function test_optimises_when_last_element_is_empty (line 73) | def test_optimises_when_last_element_is_empty():
  function test_can_optimise_last_with_following_empty (line 90) | def test_can_optimise_last_with_following_empty():
  function test_can_find_endpoints_of_a_range (line 110) | def test_can_find_endpoints_of_a_range(lower, upper, score_up):
  function test_targeting_can_drive_length_very_high (line 134) | def test_targeting_can_drive_length_very_high():
  function test_optimiser_when_test_grows_buffer_to_invalid (line 155) | def test_optimiser_when_test_grows_buffer_to_invalid():
  function test_can_patch_up_examples (line 174) | def test_can_patch_up_examples():
  function test_optimiser_when_test_grows_buffer_to_overflow (line 200) | def test_optimiser_when_test_grows_buffer_to_overflow():
  function test_optimising_all_nodes (line 247) | def test_optimising_all_nodes(node):

FILE: hypothesis-python/tests/conjecture/test_order_shrinking.py
  function test_shrinks_down_to_sorted_the_slow_way (line 19) | def test_shrinks_down_to_sorted_the_slow_way(ls):
  function test_can_partially_sort_a_list (line 29) | def test_can_partially_sort_a_list():
  function test_can_partially_sort_a_list_2 (line 34) | def test_can_partially_sort_a_list_2():
  function test_adaptively_shrinks_around_hole (line 39) | def test_adaptively_shrinks_around_hole():

FILE: hypothesis-python/tests/conjecture/test_pareto.py
  function test_pareto_front_contains_different_interesting_reasons (line 31) | def test_pareto_front_contains_different_interesting_reasons():
  function test_pareto_front_omits_invalid_examples (line 52) | def test_pareto_front_omits_invalid_examples():
  function test_database_contains_only_pareto_front (line 74) | def test_database_contains_only_pareto_front():
  function test_clears_defunct_pareto_front (line 111) | def test_clears_defunct_pareto_front():
  function test_down_samples_the_pareto_front (line 138) | def test_down_samples_the_pareto_front():
  function test_stops_loading_pareto_front_if_interesting (line 166) | def test_stops_loading_pareto_front_if_interesting():
  function test_uses_tags_in_calculating_pareto_front (line 193) | def test_uses_tags_in_calculating_pareto_front():
  function test_optimises_the_pareto_front (line 212) | def test_optimises_the_pareto_front():
  function test_does_not_optimise_the_pareto_front_if_interesting (line 233) | def test_does_not_optimise_the_pareto_front_if_interesting():
  function test_stops_optimising_once_interesting (line 253) | def test_stops_optimising_once_interesting():
  function test_pareto_contains (line 275) | def test_pareto_contains():

FILE: hypothesis-python/tests/conjecture/test_provider.py
  class PrngProvider (line 65) | class PrngProvider(PrimitiveProvider):
    method __init__ (line 70) | def __init__(self, conjecturedata: "ConjectureData | None", /) -> None:
    method draw_boolean (line 74) | def draw_boolean(
    method draw_integer (line 80) | def draw_integer(
    method draw_float (line 103) | def draw_float(
    method draw_string (line 146) | def draw_string(
    method draw_bytes (line 160) | def draw_bytes(
  function temp_register_backend (line 176) | def temp_register_backend(name, provider_cls):
  function test_find_with_backend_then_convert_to_buffer_shrink_and_replay (line 192) | def test_find_with_backend_then_convert_to_buffer_shrink_and_replay(stra...
  function test_backend_can_shrink_integers (line 214) | def test_backend_can_shrink_integers():
  function test_backend_can_shrink_bytes (line 225) | def test_backend_can_shrink_bytes():
  function test_backend_can_shrink_strings (line 239) | def test_backend_can_shrink_strings():
  function test_backend_can_shrink_booleans (line 250) | def test_backend_can_shrink_booleans():
  function test_backend_can_shrink_floats (line 259) | def test_backend_can_shrink_floats():
  function test_new_conjecture_data_with_backend (line 273) | def test_new_conjecture_data_with_backend(node):
  class TrivialProvider (line 283) | class TrivialProvider(PrimitiveProvider):
    method draw_integer (line 284) | def draw_integer(self, *args, **constraints):
    method draw_boolean (line 287) | def draw_boolean(self, *args, **constraints):
    method draw_float (line 290) | def draw_float(self, *args, **constraints):
    method draw_bytes (line 293) | def draw_bytes(self, *args, **constraints):
    method draw_string (line 296) | def draw_string(self, *args, **constraints):
  class InvalidLifetime (line 300) | class InvalidLifetime(TrivialProvider):
  function test_invalid_lifetime (line 305) | def test_invalid_lifetime():
  class LifetimeTestFunction (line 316) | class LifetimeTestFunction(TrivialProvider):
    method __init__ (line 319) | def __init__(self, conjecturedata):
  function test_function_lifetime (line 326) | def test_function_lifetime():
  class LifetimeTestCase (line 344) | class LifetimeTestCase(TrivialProvider):
    method __init__ (line 347) | def __init__(self, conjecturedata):
  function test_case_lifetime (line 353) | def test_case_lifetime():
  function test_flaky_with_backend (line 380) | def test_flaky_with_backend():
  class BadRealizeProvider (line 396) | class BadRealizeProvider(TrivialProvider):
    method realize (line 397) | def realize(self, value, *, for_failure=False):
  function test_bad_realize (line 401) | def test_bad_realize():
  class RealizeProvider (line 416) | class RealizeProvider(TrivialProvider):
    method realize (line 421) | def realize(self, value, *, for_failure=False):
  function test_realize (line 427) | def test_realize():
  function test_realize_dependent_draw (line 443) | def test_realize_dependent_draw():
  function test_realization_with_verbosity (line 457) | def test_realization_with_verbosity(verbosity):
  function test_realization_with_verbosity_draw (line 471) | def test_realization_with_verbosity_draw(verbosity):
  function test_realization_with_observability (line 484) | def test_realization_with_observability():
  class ObservableProvider (line 505) | class ObservableProvider(TrivialProvider):
    method observe_test_case (line 506) | def observe_test_case(self):
    method observe_information_messages (line 509) | def observe_information_messages(self, *, lifetime):
  function test_custom_observations_from_backend (line 518) | def test_custom_observations_from_backend():
  class NeverProceedsObservable (line 542) | class NeverProceedsObservable(ObservableProvider):
    method realize (line 543) | def realize(self, value, *, for_failure=False):
  function test_custom_observations_cannot_realize (line 547) | def test_custom_observations_cannot_realize():
  function test_backend_realize_cannot_proceed_increments_invalid (line 561) | def test_backend_realize_cannot_proceed_increments_invalid():
  function test_backend_realize_cannot_proceed_exception_increments_invalid (line 575) | def test_backend_realize_cannot_proceed_exception_increments_invalid():
  class FallibleProvider (line 592) | class FallibleProvider(TrivialProvider):
    method __init__ (line 593) | def __init__(self, conjecturedata: "ConjectureData", /) -> None:
    method draw_integer (line 597) | def draw_integer(self, *args, **constraints):
  function test_falls_back_to_default_backend (line 604) | def test_falls_back_to_default_backend():
  function test_can_raise_unsatisfiable_after_falling_back (line 618) | def test_can_raise_unsatisfiable_after_falling_back():
  class ExhaustibleProvider (line 635) | class ExhaustibleProvider(TrivialProvider):
    method __init__ (line 638) | def __init__(self, conjecturedata: "ConjectureData", /) -> None:
    method draw_integer (line 642) | def draw_integer(self, *args, **constraints):
  class UnsoundVerifierProvider (line 651) | class UnsoundVerifierProvider(ExhaustibleProvider):
  function test_notes_incorrect_verification (line 656) | def test_notes_incorrect_verification(provider):
  function test_invalid_provider_kw (line 670) | def test_invalid_provider_kw():
  function test_available_providers_deprecation (line 679) | def test_available_providers_deprecation():
  function test_can_generate_from_all_available_providers (line 691) | def test_can_generate_from_all_available_providers(backend, strategy):
  function test_saves_on_fatal_error_with_backend (line 712) | def test_saves_on_fatal_error_with_backend():
  class SoundnessTestProvider (line 727) | class SoundnessTestProvider(TrivialProvider):
    method __init__ (line 728) | def __init__(self, conjecturedata):
    method draw_integer (line 732) | def draw_integer(self, **constraints):
  function test_raising_verified_after_failure_is_sound (line 740) | def test_raising_verified_after_failure_is_sound():
  function test_replay_choices (line 757) | def test_replay_choices():
  class ObservationProvider (line 763) | class ObservationProvider(TrivialProvider):
    method __init__ (line 766) | def __init__(self, conjecturedata: "ConjectureData", /) -> None:
    method per_test_case_context_manager (line 773) | def per_test_case_context_manager(self):
    method on_observation (line 778) | def on_observation(self, observation: Observation) -> None:
  function test_on_observation_alternates (line 784) | def test_on_observation_alternates():
  function test_on_observation_alternates_on_failure (line 794) | def test_on_observation_alternates_on_failure():
  function test_on_observation_no_override (line 808) | def test_on_observation_no_override():
  function test_provider_conformance (line 818) | def test_provider_conformance(provider):
  function test_backend_deadline_exceeded_raised_as_flaky_backend_failure (line 832) | def test_backend_deadline_exceeded_raised_as_flaky_backend_failure():
  function test_backend_cannot_proceed_raises_on_invalid_scope (line 845) | def test_backend_cannot_proceed_raises_on_invalid_scope():

FILE: hypothesis-python/tests/conjecture/test_provider_contract.py
  function test_provider_contract_bytestring (line 52) | def test_provider_contract_bytestring(bytestring, choice_type_and_constr...
  function test_provider_contract (line 88) | def test_provider_contract(provider, nodes, random):

FILE: hypothesis-python/tests/conjecture/test_shrinker.py
  function test_can_shrink_variable_draws_with_just_deletion (line 37) | def test_can_shrink_variable_draws_with_just_deletion(n):
  function test_deletion_and_lowering_fails_to_shrink (line 49) | def test_deletion_and_lowering_fails_to_shrink(monkeypatch):
  function test_duplicate_nodes_that_go_away (line 72) | def test_duplicate_nodes_that_go_away():
  function test_accidental_duplication (line 87) | def test_accidental_duplication():
  function test_can_zero_subintervals (line 105) | def test_can_zero_subintervals():
  function test_can_pass_to_an_indirect_descendant (line 122) | def test_can_pass_to_an_indirect_descendant():
  function test_shrinking_blocks_from_common_offset (line 146) | def test_shrinking_blocks_from_common_offset():
  function test_handle_empty_draws (line 160) | def test_handle_empty_draws():
  function test_can_reorder_spans (line 176) | def test_can_reorder_spans():
  function test_permits_but_ignores_raising_order (line 193) | def test_permits_but_ignores_raising_order(monkeypatch):
  function test_node_deletion_can_delete_short_ranges (line 212) | def test_node_deletion_can_delete_short_ranges():
  function test_dependent_block_pairs_is_up_to_shrinking_integers (line 228) | def test_dependent_block_pairs_is_up_to_shrinking_integers():
  function test_finding_a_minimal_balanced_binary_tree (line 248) | def test_finding_a_minimal_balanced_binary_tree():
  function test_node_programs_are_adaptive (line 276) | def test_node_programs_are_adaptive():
  function test_zero_examples_with_variable_min_size (line 289) | def test_zero_examples_with_variable_min_size():
  function test_zero_contained_examples (line 303) | def test_zero_contained_examples():
  function test_zig_zags_quickly (line 320) | def test_zig_zags_quickly():
  function test_zig_zags_quickly_with_shrink_towards (line 351) | def test_zig_zags_quickly_with_shrink_towards(
  function test_zero_irregular_examples (line 372) | def test_zero_irregular_examples():
  function test_retain_end_of_buffer (line 391) | def test_retain_end_of_buffer():
  function test_can_expand_zeroed_region (line 408) | def test_can_expand_zeroed_region():
  function test_can_expand_deleted_region (line 424) | def test_can_expand_deleted_region():
  function test_will_terminate_stalled_shrinks (line 453) | def test_will_terminate_stalled_shrinks():
  function test_will_let_fixate_shrink_passes_do_a_full_run_through (line 474) | def test_will_let_fixate_shrink_passes_do_a_full_run_through():
  function test_can_simultaneously_lower_non_duplicated_nearby_integers (line 491) | def test_can_simultaneously_lower_non_duplicated_nearby_integers(n_gap):
  function test_redistribute_with_forced_node_integer (line 509) | def test_redistribute_with_forced_node_integer():
  function test_can_quickly_shrink_to_trivial_collection (line 525) | def test_can_quickly_shrink_to_trivial_collection(n):
  function test_alternative_shrinking_will_lower_to_alternate_value (line 537) | def test_alternative_shrinking_will_lower_to_alternate_value():
  class BadShrinker (line 564) | class BadShrinker(ShrinkerPass):
    method run_step (line 570) | def run_step(self):
  function test_silly_shrinker_subclass (line 574) | def test_silly_shrinker_subclass():
  function test_redistribute_numeric_pairs (line 598) | def test_redistribute_numeric_pairs(node1, node2, stop):
  function test_lower_duplicated_characters_across_choices (line 645) | def test_lower_duplicated_characters_across_choices(start, expected, gap):
  function test_shrinking_one_of_with_same_shape (line 664) | def test_shrinking_one_of_with_same_shape():
  function test_redistribute_numeric_pairs_shrink_towards_explicit_integer (line 695) | def test_redistribute_numeric_pairs_shrink_towards_explicit_integer(
  function test_redistribute_numeric_pairs_shrink_towards_explicit_float (line 730) | def test_redistribute_numeric_pairs_shrink_towards_explicit_float(start,...
  function test_redistribute_numeric_pairs_shrink_towards_explicit_combined (line 756) | def test_redistribute_numeric_pairs_shrink_towards_explicit_combined(
  function test_redistribute_numeric_pairs_shrink_towards_integer (line 775) | def test_redistribute_numeric_pairs_shrink_towards_integer(

FILE: hypothesis-python/tests/conjecture/test_shrinking_interface.py
  function test_debug_output (line 18) | def test_debug_output():
  function test_includes_name_in_repr_if_set (line 26) | def test_includes_name_in_repr_if_set():
  function test_normally_contains_no_space_for_name (line 33) | def test_normally_contains_no_space_for_name():

FILE: hypothesis-python/tests/conjecture/test_test_data.py
  function test_cannot_draw_after_freeze (line 31) | def test_cannot_draw_after_freeze():
  function test_can_double_freeze (line 39) | def test_can_double_freeze():
  function test_draw_past_end_sets_overflow (line 47) | def test_draw_past_end_sets_overflow():
  function test_notes_repr (line 59) | def test_notes_repr():
  function test_can_mark_interesting (line 65) | def test_can_mark_interesting():
  function test_can_mark_invalid (line 73) | def test_can_mark_invalid():
  function test_can_mark_invalid_with_why (line 81) | def test_can_mark_invalid_with_why():
  class BoomStrategy (line 90) | class BoomStrategy(SearchStrategy):
    method do_draw (line 91) | def do_draw(self, data):
  function test_closes_interval_on_error_in_strategy (line 96) | def test_closes_interval_on_error_in_strategy():
  class BigStrategy (line 104) | class BigStrategy(SearchStrategy):
    method do_draw (line 105) | def do_draw(self, data):
  function test_does_not_double_freeze_in_interval_close (line 109) | def test_does_not_double_freeze_in_interval_close():
  function test_triviality (line 117) | def test_triviality():
  function test_example_depth_marking (line 141) | def test_example_depth_marking():
  function test_has_examples_even_when_empty (line 164) | def test_has_examples_even_when_empty():
  function test_has_cached_examples_even_when_overrun (line 171) | def test_has_cached_examples_even_when_overrun():
  function test_can_observe_draws (line 185) | def test_can_observe_draws():
  function test_calls_concluded_implicitly (line 218) | def test_calls_concluded_implicitly():
  function test_examples_show_up_as_discarded (line 233) | def test_examples_show_up_as_discarded():
  function test_examples_support_negative_indexing (line 247) | def test_examples_support_negative_indexing():
  function test_examples_out_of_bounds_index (line 255) | def test_examples_out_of_bounds_index():
  function test_can_override_label (line 263) | def test_can_override_label():
  function test_will_mark_too_deep_examples_as_invalid (line 270) | def test_will_mark_too_deep_examples_as_invalid():
  function test_empty_strategy_is_invalid (line 282) | def test_empty_strategy_is_invalid():
  function test_can_note_non_str (line 289) | def test_can_note_non_str():
  function test_can_note_str_as_non_repr (line 296) | def test_can_note_str_as_non_repr():
  function test_result_is_overrun (line 302) | def test_result_is_overrun():
  function test_trivial_before_force_agrees_with_trivial_after (line 309) | def test_trivial_before_force_agrees_with_trivial_after():
  function test_events_are_noted (line 324) | def test_events_are_noted():
  function test_child_indices (line 330) | def test_child_indices():
  function test_example_equality (line 352) | def test_example_equality():
  function test_structural_coverage_is_cached (line 376) | def test_structural_coverage_is_cached():
  function test_examples_create_structural_coverage (line 380) | def test_examples_create_structural_coverage():
  function test_discarded_examples_do_not_create_structural_coverage (line 388) | def test_discarded_examples_do_not_create_structural_coverage():
  function test_children_of_discarded_examples_do_not_create_structural_coverage (line 396) | def test_children_of_discarded_examples_do_not_create_structural_coverag...
  function test_overruns_at_exactly_max_length (line 407) | def test_overruns_at_exactly_max_length():

FILE: hypothesis-python/tests/conjecture/test_utils.py
  function test_drawing_certain_coin_still_writes (line 35) | def test_drawing_certain_coin_still_writes():
  function test_drawing_impossible_coin_still_writes (line 41) | def test_drawing_impossible_coin_still_writes():
  function test_draws_extremely_small_p (line 47) | def test_draws_extremely_small_p():
  function test_sampler_distribution (line 64) | def test_sampler_distribution(weights):
  function test_sampler_does_not_draw_minimum_if_zero (line 86) | def test_sampler_does_not_draw_minimum_if_zero():
  function test_sampler_shrinks (line 91) | def test_sampler_shrinks():
  function test_can_force_sampler (line 96) | def test_can_force_sampler():
  function test_combine_labels_is_distinct (line 103) | def test_combine_labels_is_distinct():
  function test_combine_labels_is_identity_for_single_argument (line 110) | def test_combine_labels_is_identity_for_single_argument(n):
  function test_invalid_numpy_sample (line 115) | def test_invalid_numpy_sample():
  function test_valid_numpy_sample (line 121) | def test_valid_numpy_sample():
  function test_invalid_set_sample (line 125) | def test_invalid_set_sample():
  function test_valid_list_sample (line 130) | def test_valid_list_sample():
  function test_choice (line 134) | def test_choice():
  function test_fixed_size_draw_many (line 138) | def test_fixed_size_draw_many():
  function test_astronomically_unlikely_draw_many (line 148) | def test_astronomically_unlikely_draw_many():
  function test_rejection_eventually_terminates_many (line 156) | def test_rejection_eventually_terminates_many():
  function test_rejection_eventually_terminates_many_invalid_for_min_size (line 172) | def test_rejection_eventually_terminates_many_invalid_for_min_size():
  function test_many_with_min_size (line 183) | def test_many_with_min_size():
  function test_many_with_max_size (line 195) | def test_many_with_max_size():
  function test_samples_from_a_range_directly (line 204) | def test_samples_from_a_range_directly():
  function test_p_continue_to_average_saturates (line 209) | def test_p_continue_to_average_saturates():
  function test_unhashable_calc_label (line 213) | def test_unhashable_calc_label():

FILE: hypothesis-python/tests/cover/test_annotations.py
  function test_has_an_annotation (line 24) | def test_has_an_annotation(i: int):
  function universal_acceptor (line 28) | def universal_acceptor(*args, **kwargs):
  function has_annotation (line 32) | def has_annotation(a: int, *b, c=2) -> None:
  function test_copying_preserves_signature (line 37) | def test_copying_preserves_signature(f):
  function test_kwonly_lambda_formatting (line 54) | def test_kwonly_lambda_formatting(lam, source):
  function test_given_notices_missing_kwonly_args (line 59) | def test_given_notices_missing_kwonly_args():
  function test_converter_handles_kwonly_args (line 69) | def test_converter_handles_kwonly_args():
  function test_converter_notices_missing_kwonly_args (line 77) | def test_converter_notices_missing_kwonly_args():
  function to_wrap_with_composite (line 85) | def to_wrap_with_composite(draw: None, strat: float, nothing: list) -> int:
  function return_annot (line 89) | def return_annot() -> int:
  function first_annot (line 93) | def first_annot(draw: None):
  function test_composite_edits_annotations (line 97) | def test_composite_edits_annotations():
  function test_given_edits_annotations (line 105) | def test_given_edits_annotations(nargs):

FILE: hypothesis-python/tests/cover/test_arbitrary_data.py
  function test_conditional_draw (line 19) | def test_conditional_draw(x, data):
  function test_prints_on_failure (line 24) | def test_prints_on_failure():
  function test_prints_labels_if_given_on_failure (line 39) | def test_prints_labels_if_given_on_failure():
  function test_given_twice_is_same (line 54) | def test_given_twice_is_same():
  function test_data_supports_find (line 71) | def test_data_supports_find():
  function test_errors_when_normal_strategy_functions_are_used (line 77) | def test_errors_when_normal_strategy_functions_are_used(f):
  function test_nice_repr (line 82) | def test_nice_repr():

FILE: hypothesis-python/tests/cover/test_asyncio.py
  function coro_decorator (line 28) | def coro_decorator(f):
  class TestAsyncio (line 37) | class TestAsyncio(TestCase):
    method setUp (line 40) | def setUp(self):
    method tearDown (line 44) | def tearDown(self):
    method execute_example (line 47) | def execute_example(self, f):
    method test_foo (line 68) | def test_foo(self, x):
  class TestAsyncioRun (line 74) | class TestAsyncioRun(TestCase):
    method execute_example (line 79) | def execute_example(self, f):
    method test_foo_yield_from (line 85) | def test_foo_yield_from(self, x):
    method test_foo_await (line 92) | async def test_foo_await(self, x):

FILE: hypothesis-python/tests/cover/test_cache_implementation.py
  class LRUCacheAlternative (line 32) | class LRUCacheAlternative(GenericCache):
    method __init__ (line 35) | def __init__(self, max_size):
    method new_entry (line 39) | def new_entry(self, key, value):
    method on_access (line 42) | def on_access(self, key, value, score):
    method tick (line 45) | def tick(self):
  class LFUCache (line 50) | class LFUCache(GenericCache):
    method new_entry (line 51) | def new_entry(self, key, value):
    method on_access (line 54) | def on_access(self, key, value, score):
  function write_pattern (line 59) | def write_pattern(draw, min_distinct_keys=0):
  class ValueScored (line 73) | class ValueScored(GenericCache):
    method new_entry (line 74) | def new_entry(self, key, value):
  class RandomCache (line 78) | class RandomCache(GenericCache):
    method __init__ (line 79) | def __init__(self, max_size):
    method new_entry (line 83) | def new_entry(self, key, value):
    method on_access (line 86) | def on_access(self, key, value, score):
  function test_behaves_like_a_dict_with_losses (line 98) | def test_behaves_like_a_dict_with_losses(implementation, writes, size):
  function test_always_evicts_the_lowest_scoring_value (line 126) | def test_always_evicts_the_lowest_scoring_value(writes, data):
  function test_basic_access (line 182) | def test_basic_access():
  function test_can_clear_a_cache (line 193) | def test_can_clear_a_cache():
  function test_max_size_must_be_positive (line 201) | def test_max_size_must_be_positive():
  function test_pinning_prevents_eviction (line 206) | def test_pinning_prevents_eviction():
  function test_unpinning_allows_eviction (line 214) | def test_unpinning_allows_eviction():
  function test_unpins_must_match_pins (line 228) | def test_unpins_must_match_pins():
  function test_will_error_instead_of_evicting_pin (line 243) | def test_will_error_instead_of_evicting_pin():
  function test_will_error_for_bad_unpin (line 253) | def test_will_error_for_bad_unpin():
  function test_still_inserts_if_score_is_worse (line 260) | def test_still_inserts_if_score_is_worse():
  function test_does_insert_if_score_is_better (line 275) | def test_does_insert_if_score_is_better():
  function test_double_pinning_does_not_add_entry (line 290) | def test_double_pinning_does_not_add_entry():
  function test_can_add_new_keys_after_unpinning (line 298) | def test_can_add_new_keys_after_unpinning():
  function test_iterates_over_remaining_keys (line 307) | def test_iterates_over_remaining_keys():
  function test_lru_cache_is_actually_lru (line 314) | def test_lru_cache_is_actually_lru():
  function test_cache_is_threadsafe_issue_2433_regression (line 324) | def test_cache_is_threadsafe_issue_2433_regression():

FILE: hypothesis-python/tests/cover/test_caching.py
  function test_no_args (line 17) | def test_no_args():
  function test_tuple_lengths (line 21) | def test_tuple_lengths():
  function test_values (line 26) | def test_values():
  function test_alphabet_key (line 30) | def test_alphabet_key():
  function test_does_not_error_on_unhashable_posarg (line 34) | def test_does_not_error_on_unhashable_posarg():
  function test_does_not_error_on_unhashable_kwarg (line 38) | def test_does_not_error_on_unhashable_kwarg():
  function test_caches_floats_sensitively (line 43) | def test_caches_floats_sensitively():

FILE: hypothesis-python/tests/cover/test_cathetus.py
  function test_cathetus_subnormal_underflow (line 22) | def test_cathetus_subnormal_underflow():
  function test_cathetus_simple_underflow (line 29) | def test_cathetus_simple_underflow():
  function test_cathetus_huge_no_overflow (line 36) | def test_cathetus_huge_no_overflow():
  function test_cathetus_large_no_overflow (line 43) | def test_cathetus_large_no_overflow():
  function test_cathetus_nan (line 67) | def test_cathetus_nan(h, a):
  function test_cathetus_infinite (line 74) | def test_cathetus_infinite(h, a):
  function test_cathetus_signs (line 81) | def test_cathetus_signs(h, a, b):
  function test_cathetus_always_leq_hypot (line 90) | def test_cathetus_always_leq_hypot(h, a):
  function test_pythagorean_triples (line 148) | def test_pythagorean_triples(a, b, h):

FILE: hypothesis-python/tests/cover/test_charmap.py
  function test_charmap_contains_all_unicode (line 27) | def test_charmap_contains_all_unicode():
  function test_charmap_has_right_categories (line 35) | def test_charmap_has_right_categories():
  function assert_valid_range_list (line 43) | def assert_valid_range_list(ls):
  function test_query_matches_categories (line 52) | def test_query_matches_categories(cats):
  function test_query_matches_categories_codepoints (line 65) | def test_query_matches_categories_codepoints(cats, m1, m2):
  function test_reload_charmap (line 76) | def test_reload_charmap():
  function test_recreate_charmap (line 86) | def test_recreate_charmap():
  function test_uses_cached_charmap (line 114) | def test_uses_cached_charmap():
  function _union_intervals (line 130) | def _union_intervals(x, y):
  function test_union_empty (line 134) | def test_union_empty():
  function test_union_handles_totally_overlapped_gap (line 140) | def test_union_handles_totally_overlapped_gap():
  function test_union_handles_partially_overlapped_gap (line 147) | def test_union_handles_partially_overlapped_gap():
  function test_successive_union (line 154) | def test_successive_union():
  function test_can_handle_race_between_exist_and_create (line 162) | def test_can_handle_race_between_exist_and_create(monkeypatch):
  function test_exception_in_write_does_not_lead_to_broken_charmap (line 172) | def test_exception_in_write_does_not_lead_to_broken_charmap(monkeypatch):
  function test_regenerate_broken_charmap_file (line 185) | def test_regenerate_broken_charmap_file():
  function test_exclude_characters_are_included_in_key (line 194) | def test_exclude_characters_are_included_in_key():
  function test_error_writing_charmap_file_is_suppressed (line 199) | def test_error_writing_charmap_file_is_suppressed(monkeypatch):
  function test_categoryname_literal_is_correct (line 217) | def test_categoryname_literal_is_correct():

FILE: hypothesis-python/tests/cover/test_compat.py
  function test_our_floor_agrees_with_math_floor (line 42) | def test_our_floor_agrees_with_math_floor(value):
  function test_our_ceil_agrees_with_math_ceil (line 47) | def test_our_ceil_agrees_with_math_ceil(value):
  class WeirdSig (line 51) | class WeirdSig:
  function test_no_type_hints (line 57) | def test_no_type_hints():
  class Foo (line 62) | class Foo:
  class Bar (line 79) | class Bar:
  function test_resolve_fwd_refs (line 99) | def test_resolve_fwd_refs(obj, expected):
  function func (line 104) | def func(a, b: int, *c: str, d: int | None = None):
  function test_get_hints_through_partial (line 117) | def test_get_hints_through_partial(pf, names):
  class FilledWithStuff (line 122) | class FilledWithStuff:
  function test_dataclass_asdict (line 130) | def test_dataclass_asdict():
  function test_extract_bits_roundtrip (line 146) | def test_extract_bits_roundtrip(width, x):
  class ImmutableError (line 154) | class ImmutableError:
  function test_add_note_fails_gracefully_on_frozen_instance (line 158) | def test_add_note_fails_gracefully_on_frozen_instance():

FILE: hypothesis-python/tests/cover/test_complex_numbers.py
  function test_minimal (line 28) | def test_minimal():
  function test_minimal_nonzero_real (line 32) | def test_minimal_nonzero_real():
  function test_minimal_nonzero_imaginary (line 36) | def test_minimal_nonzero_imaginary():
  function test_minimal_quadrant1 (line 40) | def test_minimal_quadrant1():
  function test_minimal_quadrant2 (line 44) | def test_minimal_quadrant2():
  function test_minimal_quadrant3 (line 48) | def test_minimal_quadrant3():
  function test_minimal_quadrant4 (line 52) | def test_minimal_quadrant4():
  function test_max_magnitude_respected (line 57) | def test_max_magnitude_respected(data, mag):
  function test_max_magnitude_zero (line 66) | def test_max_magnitude_zero(val):
  function test_min_magnitude_respected (line 72) | def test_min_magnitude_respected(data, mag):
  function test_minimal_min_magnitude_zero (line 82) | def test_minimal_min_magnitude_zero():
  function test_minimal_min_magnitude_positive (line 86) | def test_minimal_min_magnitude_positive():
  function test_minimal_minmax_magnitude (line 90) | def test_minimal_minmax_magnitude():
  function test_minmax_magnitude_equal (line 95) | def test_minmax_magnitude_equal(data, mag):
  function _is_subnormal (line 105) | def _is_subnormal(x):
  function test_allow_subnormal (line 117) | def test_allow_subnormal(allow_subnormal, min_magnitude, max_magnitude):
  function test_allow_subnormal_validation (line 133) | def test_allow_subnormal_validation(allow_subnormal):

FILE: hypothesis-python/tests/cover/test_composite.py
  function badly_draw_lists (line 27) | def badly_draw_lists(draw, m=0):
  function test_simplify_draws (line 32) | def test_simplify_draws():
  function test_can_pass_through_arguments (line 36) | def test_can_pass_through_arguments():
  function draw_ordered_with_assume (line 42) | def draw_ordered_with_assume(draw):
  function test_can_assume_in_draw (line 51) | def test_can_assume_in_draw(xy):
  function test_uses_definitions_for_reprs (line 55) | def test_uses_definitions_for_reprs():
  function test_errors_given_default_for_draw (line 61) | def test_errors_given_default_for_draw():
  function test_errors_given_function_of_no_arguments (line 69) | def test_errors_given_function_of_no_arguments():
  function test_errors_given_kwargs_only (line 77) | def test_errors_given_kwargs_only():
  function test_warning_given_no_drawfn_call (line 85) | def test_warning_given_no_drawfn_call():
  function test_can_use_pure_args (line 93) | def test_can_use_pure_args():
  function test_composite_of_lists (line 101) | def test_composite_of_lists():
  function test_can_shrink_matrices_with_length_param (line 110) | def test_can_shrink_matrices_with_length_param():
  class MyList (line 131) | class MyList(list):
  function test_does_not_change_arguments (line 136) | def test_does_not_change_arguments(data, ls):
  class ClsWithStrategyMethods (line 147) | class ClsWithStrategyMethods:
    method st_classmethod_then_composite (line 150) | def st_classmethod_then_composite(draw, cls):
    method st_composite_then_classmethod (line 155) | def st_composite_then_classmethod(draw, cls):
    method st_staticmethod_then_composite (line 160) | def st_staticmethod_then_composite(draw):
    method st_composite_then_staticmethod (line 165) | def st_composite_then_staticmethod(draw):
    method st_composite_method (line 169) | def st_composite_method(draw, self):
  function test_applying_composite_decorator_to_methods (line 174) | def test_applying_composite_decorator_to_methods(data):
  function test_drawfn_cannot_be_instantiated (line 192) | def test_drawfn_cannot_be_instantiated():
  function test_warns_on_strategy_annotation (line 197) | def test_warns_on_strategy_annotation():
  function test_composite_allows_overload_without_draw (line 208) | def test_composite_allows_overload_without_draw():

FILE: hypothesis-python/tests/cover/test_composite_kwonlyargs.py
  function kwonlyargs_composites (line 19) | def kwonlyargs_composites(draw, *, kwarg1=None):
  function test_composite_with_keyword_only_args (line 28) | def test_composite_with_keyword_only_args(a):

FILE: hypothesis-python/tests/cover/test_constants_ast.py
  function constants_from_ast (line 49) | def constants_from_ast(tree):
  function test_constants_set_from_type_invalid (line 55) | def test_constants_set_from_type_invalid():
  function test_constants_contains (line 61) | def test_constants_contains(n):
  function test_constants_not_equal_to_set (line 66) | def test_constants_not_equal_to_set(constants):
  function test_constants_from_ast (line 123) | def test_constants_from_ast(source, expected):
  function test_parses_negatives (line 130) | def test_parses_negatives(n):
  function test_tuple_constants (line 135) | def test_tuple_constants(value):
  function test_frozenset_constants (line 141) | def test_frozenset_constants(value):
  function test_constants_from_running_file (line 153) | def test_constants_from_running_file(tmp_path):
  function test_constants_from_bad_module (line 210) | def test_constants_from_bad_module():
  function test_local_modules_ignores_test_modules (line 225) | def test_local_modules_ignores_test_modules(path):
  function test_ignores_ast_parse_error (line 231) | def test_ignores_ast_parse_error(tmp_path):
  function test_constant_visitor_roundtrips_string (line 261) | def test_constant_visitor_roundtrips_string(constants):
  function test_too_many_constants (line 273) | def test_too_many_constants():
  function test_module_too_large (line 295) | def test_module_too_large(tmp_path):

FILE: hypothesis-python/tests/cover/test_control.py
  function bc (line 39) | def bc():
  function test_cannot_cleanup_with_no_context (line 43) | def test_cannot_cleanup_with_no_context():
  function test_cannot_event_with_no_context (line 49) | def test_cannot_event_with_no_context():
  function test_cleanup_executes_on_leaving_build_context (line 55) | def test_cleanup_executes_on_leaving_build_context():
  function test_can_nest_build_context (line 64) | def test_can_nest_build_context():
  function test_does_not_suppress_exceptions (line 76) | def test_does_not_suppress_exceptions():
  function test_suppresses_exceptions_in_teardown (line 82) | def test_suppresses_exceptions_in_teardown():
  function test_runs_multiple_cleanup_with_teardown (line 95) | def test_runs_multiple_cleanup_with_teardown():
  function test_raises_error_if_cleanup_fails_but_block_does_not (line 114) | def test_raises_error_if_cleanup_fails_but_block_does_not():
  function test_raises_if_note_out_of_context (line 124) | def test_raises_if_note_out_of_context():
  function test_deprecation_warning_if_assume_out_of_context (line 129) | def test_deprecation_warning_if_assume_out_of_context():
  function test_deprecation_warning_if_reject_out_of_context (line 137) | def test_deprecation_warning_if_reject_out_of_context():
  function test_raises_if_current_build_context_out_of_context (line 148) | def test_raises_if_current_build_context_out_of_context():
  function test_current_build_context_is_current (line 153) | def test_current_build_context_is_current():
  function test_prints_all_notes_in_verbose_mode (line 158) | def test_prints_all_notes_in_verbose_mode():
  class CanBePrettyPrinted (line 182) | class CanBePrettyPrinted:
  function test_note_pretty_prints (line 186) | def test_note_pretty_prints():
  function test_not_currently_in_hypothesis (line 201) | def test_not_currently_in_hypothesis():
  function test_currently_in_hypothesis (line 206) | def test_currently_in_hypothesis(_):
  class ContextMachine (line 210) | class ContextMachine(RuleBasedStateMachine):
    method step (line 212) | def step(self):
  function test_can_convert_non_weakref_types_to_event_strings (line 219) | def test_can_convert_non_weakref_types_to_event_strings():

FILE: hypothesis-python/tests/cover/test_core.py
  function test_stops_after_max_examples_if_satisfying (line 21) | def test_stops_after_max_examples_if_satisfying():
  function test_stops_after_ten_times_max_examples_if_not_satisfying (line 37) | def test_stops_after_ten_times_max_examples_if_not_satisfying():
  function test_is_not_normally_default (line 58) | def test_is_not_normally_default():
  function test_settings_are_default_in_given (line 64) | def test_settings_are_default_in_given(x):
  function test_given_shrinks_pytest_helper_errors (line 68) | def test_given_shrinks_pytest_helper_errors():
  function test_pytest_skip_skips_shrinking (line 84) | def test_pytest_skip_skips_shrinking():
  function test_can_find_with_db_eq_none (line 101) | def test_can_find_with_db_eq_none():
  function test_no_such_example (line 105) | def test_no_such_example():
  function test_validates_strategies_for_test_method (line 110) | def test_validates_strategies_for_test_method():
  function no_phases (line 126) | def no_phases(_):
  function no_explicit (line 132) | def no_explicit(_):
  function empty_db (line 138) | def empty_db(_):
  function test_non_executed_tests_raise_skipped (line 147) | def test_non_executed_tests_raise_skipped(test_fn):
  function test_characters_codec (line 165) | def test_characters_codec(codec, max_codepoint, exclude_categories, cate...

FILE: hypothesis-python/tests/cover/test_custom_reprs.py
  function test_includes_non_default_args_in_repr (line 19) | def test_includes_non_default_args_in_repr():
  function test_sampled_repr_leaves_range_as_range (line 24) | def test_sampled_repr_leaves_range_as_range():
  function hi (line 29) | def hi(there, stuff):
  function test_supports_positional_and_keyword_args_in_builds (line 33) | def test_supports_positional_and_keyword_args_in_builds():
  function test_preserves_sequence_type_of_argument (line 40) | def test_preserves_sequence_type_of_argument():
  class IHaveABadRepr (line 45) | class IHaveABadRepr:
    method __repr__ (line 46) | def __repr__(self):
  function test_errors_are_deferred_until_repr_is_calculated (line 50) | def test_errors_are_deferred_until_repr_is_calculated():
  function test_iterables_repr_is_useful (line 67) | def test_iterables_repr_is_useful(it):
  class Foo (line 72) | class Foo:
    method __init__ (line 73) | def __init__(self, x: int) -> None:
  class Bar (line 77) | class Bar(Foo):
  function test_reprs_as_created (line 81) | def test_reprs_as_created():
  function test_reprs_as_created_interactive (line 100) | def test_reprs_as_created_interactive():
  function some_foo (line 121) | def some_foo(*_):
  function test_as_created_reprs_fallback_for_distinct_calls_same_obj (line 125) | def test_as_created_reprs_fallback_for_distinct_calls_same_obj():
  function test_reprs_as_created_consistent_calls_despite_indentation (line 145) | def test_reprs_as_created_consistent_calls_despite_indentation():
  function test_characters_repr (line 197) | def test_characters_repr(strategy, expected_repr):

FILE: hypothesis-python/tests/cover/test_database_backend.py
  function test_backend_returns_what_you_put_in (line 76) | def test_backend_returns_what_you_put_in(xs):
  function test_can_delete_keys (line 89) | def test_can_delete_keys():
  function test_default_database_is_in_memory (line 97) | def test_default_database_is_in_memory():
  function test_default_on_disk_database_is_dir (line 102) | def test_default_on_disk_database_is_dir(tmp_path):
  function test_does_not_error_when_fetching_when_not_exist (line 109) | def test_does_not_error_when_fetching_when_not_exist(tmp_path):
  function exampledatabase (line 115) | def exampledatabase(request, tmp_path):
  function test_can_delete_a_key_that_is_not_present (line 122) | def test_can_delete_a_key_that_is_not_present(exampledatabase):
  function test_can_fetch_a_key_that_is_not_present (line 126) | def test_can_fetch_a_key_that_is_not_present(exampledatabase):
  function test_saving_a_key_twice_fetches_it_once (line 130) | def test_saving_a_key_twice_fetches_it_once(exampledatabase):
  function test_can_close_a_database_after_saving (line 136) | def test_can_close_a_database_after_saving(exampledatabase):
  function test_class_name_is_in_repr (line 140) | def test_class_name_is_in_repr(exampledatabase):
  function test_an_absent_value_is_present_after_it_moves (line 144) | def test_an_absent_value_is_present_after_it_moves(exampledatabase):
  function test_an_absent_value_is_present_after_it_moves_to_self (line 149) | def test_an_absent_value_is_present_after_it_moves_to_self(exampledataba...
  function test_two_directory_databases_can_interact (line 155) | def test_two_directory_databases_can_interact(tmp_path):
  function test_can_handle_disappearing_files (line 165) | def test_can_handle_disappearing_files(tmp_path, monkeypatch):
  function test_readonly_db_is_not_writable (line 175) | def test_readonly_db_is_not_writable():
  function test_multiplexed_dbs_read_and_write_all (line 187) | def test_multiplexed_dbs_read_and_write_all():
  function test_ga_require_readonly_wrapping (line 206) | def test_ga_require_readonly_wrapping():
  function ga_empty_artifact (line 225) | def ga_empty_artifact(
  function test_ga_empty_read (line 252) | def test_ga_empty_read():
  function test_ga_initialize (line 259) | def test_ga_initialize():
  function test_ga_no_artifact (line 280) | def test_ga_no_artifact(tmp_path):
  function test_ga_corrupted_artifact (line 290) | def test_ga_corrupted_artifact():
  function test_ga_deletes_old_artifacts (line 304) | def test_ga_deletes_old_artifacts():
  function test_ga_triggers_fetching (line 322) | def test_ga_triggers_fetching(monkeypatch, tmp_path):
  function test_ga_fallback_expired (line 365) | def test_ga_fallback_expired(monkeypatch):
  class GitHubArtifactMocks (line 393) | class GitHubArtifactMocks(RuleBasedStateMachine):
    method __init__ (line 399) | def __init__(self):
    method _make_zip (line 420) | def _make_zip(self, tree_path: Path, zip_path: Path):
    method _archive_directory_db (line 428) | def _archive_directory_db(self):
    method k (line 439) | def k(self, k):
    method v (line 443) | def v(self, v):
    method save (line 447) | def save(self, k, v):
    method values_agree (line 454) | def values_agree(self, k):
    method teardown (line 460) | def teardown(self):
  function test_gadb_coverage (line 467) | def test_gadb_coverage():
  function test_database_directory_inaccessible (line 476) | def test_database_directory_inaccessible(dirs, tmp_path, monkeypatch):
  function test_background_write_database (line 496) | def test_background_write_database():
  function test_nodes_roundtrips (line 521) | def test_nodes_roundtrips(nodes1):
  function test_uleb_128_roundtrips (line 535) | def test_uleb_128_roundtrips(n1):
  function _database_conforms_to_listener_api (line 542) | def _database_conforms_to_listener_api(
  function test_database_listener_memory (line 683) | def test_database_listener_memory():
  function test_database_listener_background_write (line 694) | def test_database_listener_background_write():
  function test_can_remove_nonexistent_listener (line 702) | def test_can_remove_nonexistent_listener():
  class DoesNotSupportListening (line 707) | class DoesNotSupportListening(ExampleDatabase):
    method save (line 708) | def save(self, key: bytes, value: bytes) -> None: ...
    method fetch (line 709) | def fetch(self, key: bytes) -> Iterable[bytes]: ...
    method delete (line 710) | def delete(self, key: bytes, value: bytes) -> None: ...
  function test_warns_when_listening_not_supported (line 713) | def test_warns_when_listening_not_supported():
  function test_readonly_listener (line 728) | def test_readonly_listener():
  function test_metakeys_move_into_existing_key (line 742) | def test_metakeys_move_into_existing_key(tmp_path):
  function test_metakeys_move_into_nonexistent_key (line 754) | def test_metakeys_move_into_nonexistent_key(tmp_path):
  function test_metakeys (line 764) | def test_metakeys(tmp_path):
  class TracksListens (line 782) | class TracksListens(ExampleDatabase):
    method __init__ (line 783) | def __init__(self):
    method save (line 788) | def save(self, key: bytes, value: bytes) -> None: ...
    method fetch (line 789) | def fetch(self, key: bytes) -> Iterable[bytes]: ...
    method delete (line 790) | def delete(self, key: bytes, value: bytes) -> None: ...
    method _start_listening (line 792) | def _start_listening(self):
    method _stop_listening (line 795) | def _stop_listening(self):
  function test_start_end_listening (line 799) | def test_start_end_listening():
  function test_deprecated_example_database_path (line 825) | def test_deprecated_example_database_path(tmp_path):
  function test_deprecated_example_database_memory (line 830) | def test_deprecated_example_database_memory():
  function test_deprecated_example_database_no_args (line 835) | def test_deprecated_example_database_no_args():
  function test_database_equal (line 861) | def test_database_equal(db1, db2):
  function test_database_not_equal (line 882) | def test_database_not_equal(db1, db2):
  function test_directory_db_removes_empty_dirs (line 887) | def test_directory_db_removes_empty_dirs(tmp_path):

FILE: hypothesis-python/tests/cover/test_datetimes.py
  function test_can_find_positive_delta (line 21) | def test_can_find_positive_delta():
  function test_can_find_negative_delta (line 25) | def test_can_find_negative_delta():
  function test_can_find_on_the_second (line 31) | def test_can_find_on_the_second():
  function test_can_find_off_the_second (line 35) | def test_can_find_off_the_second():
  function test_simplifies_towards_zero_delta (line 39) | def test_simplifies_towards_zero_delta():
  function test_min_value_is_respected (line 44) | def test_min_value_is_respected():
  function test_max_value_is_respected (line 48) | def test_max_value_is_respected():
  function test_single_timedelta (line 54) | def test_single_timedelta(val):
  function test_simplifies_towards_millenium (line 58) | def test_simplifies_towards_millenium():
  function test_default_datetimes_are_naive (line 66) | def test_default_datetimes_are_naive(dt):
  function test_bordering_on_a_leap_year (line 70) | def test_bordering_on_a_leap_year():
  function test_can_find_after_the_year_2000 (line 81) | def test_can_find_after_the_year_2000():
  function test_can_find_before_the_year_2000 (line 85) | def test_can_find_before_the_year_2000():
  function test_can_find_each_month (line 90) | def test_can_find_each_month(month):
  function test_min_year_is_respected (line 94) | def test_min_year_is_respected():
  function test_max_year_is_respected (line 98) | def test_max_year_is_respected():
  function test_single_date (line 103) | def test_single_date(val):
  function test_can_find_midnight (line 107) | def test_can_find_midnight():
  function test_can_find_non_midnight (line 111) | def test_can_find_non_midnight():
  function test_can_find_on_the_minute (line 115) | def test_can_find_on_the_minute():
  function test_can_find_off_the_minute (line 119) | def test_can_find_off_the_minute():
  function test_simplifies_towards_midnight (line 123) | def test_simplifies_towards_midnight():
  function test_can_generate_naive_time (line 128) | def test_can_generate_naive_time():
  function test_naive_times_are_naive (line 133) | def test_naive_times_are_naive(dt):
  function test_can_generate_datetime_with_fold_1 (line 137) | def test_can_generate_datetime_with_fold_1():
  function test_can_generate_time_with_fold_1 (line 141) | def test_can_generate_time_with_fold_1():
  function test_allow_imaginary_is_not_an_error_for_naive_datetimes (line 146) | def test_allow_imaginary_is_not_an_error_for_naive_datetimes(d):

FILE: hypothesis-python/tests/cover/test_deadline.py
  function test_raises_deadline_on_slow_test (line 28) | def test_raises_deadline_on_slow_test():
  function test_slow_tests_are_errors_by_default (line 44) | def test_slow_tests_are_errors_by_default(i):
  function test_non_numeric_deadline_is_an_error (line 48) | def test_non_numeric_deadline_is_an_error():
  function test_slow_with_none_deadline (line 55) | def test_slow_with_none_deadline(i):
  function test_raises_flaky_if_a_test_becomes_fast_on_rerun (line 59) | def test_raises_flaky_if_a_test_becomes_fast_on_rerun():
  function test_deadlines_participate_in_shrinking (line 74) | def test_deadlines_participate_in_shrinking():
  function test_keeps_you_well_above_the_deadline (line 88) | def test_keeps_you_well_above_the_deadline():
  function test_gives_a_deadline_specific_flaky_error_message (line 114) | def test_gives_a_deadline_specific_flaky_error_message():
  function test_should_only_fail_a_deadline_if_the_test_is_slow (line 137) | def test_should_only_fail_a_deadline_if_the_test_is_slow(slow_strategy, ...
  function test_should_not_fail_deadline_due_to_gc (line 157) | def test_should_not_fail_deadline_due_to_gc():

FILE: hypothesis-python/tests/cover/test_debug_information.py
  function test_reports_passes (line 21) | def test_reports_passes():

FILE: hypothesis-python/tests/cover/test_deferred_strategies.py
  function test_binary_tree (line 19) | def test_binary_tree():
  function test_mutual_recursion (line 26) | def test_mutual_recursion():
  function test_errors_on_non_function_define (line 35) | def test_errors_on_non_function_define():
  function test_errors_if_define_does_not_return_search_strategy (line 41) | def test_errors_if_define_does_not_return_search_strategy():
  function test_errors_on_definition_as_self (line 47) | def test_errors_on_definition_as_self():
  function test_branches_pass_through_deferred (line 53) | def test_branches_pass_through_deferred():
  function test_can_draw_one_of_self (line 59) | def test_can_draw_one_of_self():
  function test_hidden_self_references_just_result_in_no_example (line 65) | def test_hidden_self_references_just_result_in_no_example():
  function test_self_recursive_flatmap (line 70) | def test_self_recursive_flatmap():
  function test_self_reference_through_one_of_can_detect_emptiness (line 75) | def test_self_reference_through_one_of_can_detect_emptiness():
  function test_self_tuple_draws_nothing (line 80) | def test_self_tuple_draws_nothing():
  function test_mutually_recursive_tuples_draw_nothing (line 85) | def test_mutually_recursive_tuples_draw_nothing():
  function test_literals_strategy_is_valid (line 93) | def test_literals_strategy_is_valid():
  function test_impossible_self_recursion (line 109) | def test_impossible_self_recursion():
  function test_very_deep_deferral (line 115) | def test_very_deep_deferral():
  function test_recursion_in_middle (line 135) | def test_recursion_in_middle():

FILE: hypothesis-python/tests/cover/test_detection.py
  function test_functions_default_to_not_tests (line 16) | def test_functions_default_to_not_tests():
  function test_methods_default_to_not_tests (line 23) | def test_methods_default_to_not_tests():
  function test_detection_of_functions (line 31) | def test_detection_of_functions():
  function test_detection_of_methods (line 39) | def test_detection_of_methods():
  function test_detection_of_stateful_tests (line 48) | def test_detection_of_stateful_tests():

FILE: hypothesis-python/tests/cover/test_direct_strategies.py
  function fn_test (line 34) | def fn_test(*fnkwargs):
  function fn_ktest (line 46) | def fn_ktest(*fnkwargs):
  function test_validates_keyword_arguments (line 226) | def test_validates_keyword_arguments(fn, kwargs):
  function test_produces_valid_examples_from_keyword (line 326) | def test_produces_valid_examples_from_keyword(fn, kwargs):
  function test_validates_args (line 335) | def test_validates_args(fn, args):
  function test_produces_valid_examples_from_args (line 347) | def test_produces_valid_examples_from_args(fn, args):
  function test_build_class_with_target_kwarg (line 351) | def test_build_class_with_target_kwarg():
  function test_builds_raises_with_no_target (line 358) | def test_builds_raises_with_no_target():
  function test_builds_raises_if_non_callable_as_target_kwarg (line 364) | def test_builds_raises_if_non_callable_as_target_kwarg(non_callable):
  function test_builds_raises_if_non_callable_as_first_arg (line 370) | def test_builds_raises_if_non_callable_as_first_arg(non_callable):
  function test_tuples_raise_error_on_bad_kwargs (line 377) | def test_tuples_raise_error_on_bad_kwargs():
  function test_has_specified_length (line 383) | def test_has_specified_length(xs):
  function test_has_upper_bound (line 389) | def test_has_upper_bound(x):
  function test_has_lower_bound (line 394) | def test_has_lower_bound(x):
  function test_is_in_bounds (line 399) | def test_is_in_bounds(x):
  function test_fraction_is_in_bounds (line 404) | def test_fraction_is_in_bounds(x):
  function test_fraction_gt_positive (line 410) | def test_fraction_gt_positive(x):
  function test_fraction_lt_negative (line 415) | def test_fraction_lt_negative(x):
  function test_decimal_is_in_bounds (line 420) | def test_decimal_is_in_bounds(x):
  function test_float_can_find_max_value_inf (line 424) | def test_float_can_find_max_value_inf():
  function test_float_can_find_min_value_inf (line 429) | def test_float_can_find_min_value_inf():
  function test_can_find_none_list (line 434) | def test_can_find_none_list():
  function test_fractions (line 438) | def test_fractions():
  function test_decimals (line 442) | def test_decimals():
  function test_non_float_decimal (line 449) | def test_non_float_decimal():
  function test_produces_dictionaries_of_at_least_minimum_size (line 453) | def test_produces_dictionaries_of_at_least_minimum_size():
  function test_dictionaries_respect_size (line 462) | def test_dictionaries_respect_size(d):
  function test_dictionaries_respect_zero_size (line 468) | def test_dictionaries_respect_zero_size(d):
  function test_none_lists_respect_max_size (line 473) | def test_none_lists_respect_max_size(ls):
  function test_none_lists_respect_max_and_min_size (line 478) | def test_none_lists_respect_max_and_min_size(ls):
  function test_iterables_are_exhaustible (line 483) | def test_iterables_are_exhaustible(it):
  function test_minimal_iterable (line 490) | def test_minimal_iterable():
  function test_no_infinity_for_min_max_values (line 496) | def test_no_infinity_for_min_max_values(value, parameter_name):
  function test_no_nan_for_min_max_values (line 508) | def test_no_nan_for_min_max_values(value, parameter_name):
  class Sneaky (line 518) | class Sneaky:
    method do_draw (line 525) | def do_draw(self, data):
    method validate (line 528) | def validate(self):
  function test_data_explicitly_rejects_non_strategies (line 535) | def test_data_explicitly_rejects_non_strategies(data, value, label):
  function test_chained_filter (line 541) | def test_chained_filter(x):
  function test_chained_filter_tracks_all_conditions (line 546) | def test_chained_filter_tracks_all_conditions():
  function test_ipaddress_from_network_is_always_correct_version (line 553) | def test_ipaddress_from_network_is_always_correct_version(data, version):
  function test_ipaddress_from_network_is_always_in_network (line 559) | def test_ipaddress_from_network_is_always_in_network(data, network):
  class AnEnum (line 565) | class AnEnum(enum.Enum):
  function requires_arg (line 569) | def requires_arg(value):
  function test_builds_error_messages (line 574) | def test_builds_error_messages(data):
  function test_incompatible_shared_strategies_warns (line 615) | def test_incompatible_shared_strategies_warns(strat_a, strat_b):
  function _composite1 (line 629) | def _composite1(draw):
  function _composite2 (line 634) | def _composite2(draw):
  function test_compatible_shared_strategies_do_not_warn (line 660) | def test_compatible_shared_strategies_do_not_warn(strat_a, strat_b):
  function test_compatible_nested_shared_strategies_do_not_warn (line 674) | def test_compatible_nested_shared_strategies_do_not_warn():

FILE: hypothesis-python/tests/cover/test_draw_example.py
  function test_single_example (line 20) | def test_single_example(spec):
  function test_list_example (line 25) | def test_list_example(spec):

FILE: hypothesis-python/tests/cover/test_error_in_draw.py
  function test_error_is_in_finally (line 20) | def test_error_is_in_finally():
  function test_warns_on_bool_strategy (line 35) | def test_warns_on_bool_strategy(data):
  function test_adds_note_showing_which_strategy (line 44) | def test_adds_note_showing_which_strategy():
  function test_adds_note_showing_which_strategy_stateful (line 58) | def test_adds_note_showing_which_strategy_stateful():

FILE: hypothesis-python/tests/cover/test_escalation.py
  function test_is_hypothesis_file_not_confused_by_prefix (line 21) | def test_is_hypothesis_file_not_confused_by_prefix(monkeypatch):
  function test_is_hypothesis_file_does_not_error_on_invalid_paths_issue_2319 (line 38) | def test_is_hypothesis_file_does_not_error_on_invalid_paths_issue_2319(f...
  function test_multiplefailures_deprecation (line 42) | def test_multiplefailures_deprecation():
  function test_errors_attribute_error (line 48) | def test_errors_attribute_error():
  function test_handles_null_traceback (line 53) | def test_handles_null_traceback():
  function test_handles_context (line 57) | def test_handles_context():
  function test_handles_groups (line 66) | def test_handles_groups():
  function make_exceptions_with_cycles (line 75) | def make_exceptions_with_cycles():
  function test_handles_cycles (line 94) | def test_handles_cycles(err):

FILE: hypothesis-python/tests/cover/test_example.py
  function test_ok_example_via (line 21) | def test_ok_example_via(x):
  function test_invalid_example_via (line 25) | def test_invalid_example_via():
  function test_invalid_example_xfail_arguments (line 46) | def test_invalid_example_xfail_arguments(kw):
  function test_many_xfail_example_decorators (line 58) | def test_many_xfail_example_decorators(fails):
  function test_xfail_reraises_non_specified_exception (line 66) | def test_xfail_reraises_non_specified_exception(x):
  function test_must_raise_a_failure_exception (line 77) | def test_must_raise_a_failure_exception(x):
  function test_error_on_unexpected_pass_base (line 88) | def test_error_on_unexpected_pass_base(x):
  function test_error_on_unexpected_pass_single (line 98) | def test_error_on_unexpected_pass_single(x):
  function test_error_on_unexpected_pass_single_elem_tuple (line 108) | def test_error_on_unexpected_pass_single_elem_tuple(x):
  function test_error_on_unexpected_pass_multi (line 118) | def test_error_on_unexpected_pass_multi(x):

FILE: hypothesis-python/tests/cover/test_exceptiongroup.py
  function test_discard_frozen (line 21) | def test_discard_frozen() -> None:
  function test_discard_multiple_frozen (line 35) | def test_discard_multiple_frozen() -> None:
  function test_user_error_and_frozen (line 44) | def test_user_error_and_frozen() -> None:
  function test_user_error_and_stoptest (line 58) | def test_user_error_and_stoptest() -> None:
  function test_lone_user_error (line 77) | def test_lone_user_error() -> None:
  function test_nested_stoptest (line 92) | def test_nested_stoptest() -> None:
  function test_frozen_and_stoptest (line 103) | def test_frozen_and_stoptest() -> None:
  function test_multiple_stoptest_1 (line 115) | def test_multiple_stoptest_1() -> None:
  function test_multiple_stoptest_2 (line 125) | def test_multiple_stoptest_2() -> None:
  function test_stoptest_and_hypothesisexception (line 137) | def test_stoptest_and_hypothesisexception() -> None:
  function test_multiple_hypothesisexception (line 148) | def test_multiple_hypothesisexception() -> None:
  function test_exceptiongroups_reconstruct_original_type (line 160) | def test_exceptiongroups_reconstruct_original_type(ExceptionClass):
  function test_derived_exception_group (line 173) | def test_derived_exception_group(ExceptionClass):

FILE: hypothesis-python/tests/cover/test_executors.py
  function test_must_use_result_of_test (line 20) | def test_must_use_result_of_test():
  class TestTryReallyHard (line 38) | class TestTryReallyHard(TestCase):
    method test_something (line 40) | def test_something(self, i):
    method execute_example (line 43) | def execute_example(self, f):
  class Valueless (line 48) | class Valueless:
    method execute_example (line 49) | def execute_example(self, f):
    method test_no_boom_on_example (line 57) | def test_no_boom_on_example(self, x):
    method test_no_boom (line 61) | def test_no_boom(self, x):
    method test_boom (line 65) | def test_boom(self, x):
  function test_boom (line 69) | def test_boom():
  function test_no_boom (line 74) | def test_no_boom():
  function test_no_boom_on_example (line 78) | def test_no_boom_on_example():

FILE: hypothesis-python/tests/cover/test_explicit_examples.py
  class TestInstanceMethods (line 38) | class TestInstanceMethods(TestCase):
    method test_hi_1 (line 41) | def test_hi_1(self, x):
    method test_hi_2 (line 46) | def test_hi_2(self, x):
    method test_hi_3 (line 51) | def test_hi_3(self, x):
  function test_kwarg_example_on_testcase (line 55) | def test_kwarg_example_on_testcase():
  function test_errors_when_run_with_not_enough_args (line 65) | def test_errors_when_run_with_not_enough_args():
  function test_errors_when_run_with_not_enough_kwargs (line 75) | def test_errors_when_run_with_not_enough_kwargs():
  function test_can_use_examples_after_given (line 85) | def test_can_use_examples_after_given():
  function test_can_use_examples_before_given (line 97) | def test_can_use_examples_before_given():
  function test_can_use_examples_around_given (line 109) | def test_can_use_examples_around_given():
  function test_is_a_thing (line 128) | def test_is_a_thing(x, y, z):
  function test_no_args_and_kwargs (line 132) | def test_no_args_and_kwargs():
  function test_no_empty_examples (line 137) | def test_no_empty_examples():
  function test_does_not_print_on_explicit_examples_if_no_failure (line 142) | def test_does_not_print_on_explicit_examples_if_no_failure():
  function test_prints_output_for_explicit_examples (line 158) | def test_prints_output_for_explicit_examples():
  function test_prints_verbose_output_for_explicit_examples (line 167) | def test_prints_verbose_output_for_explicit_examples():
  function test_captures_original_repr_of_example (line 182) | def test_captures_original_repr_of_example():
  function test_examples_are_tried_in_order (line 192) | def test_examples_are_tried_in_order():
  function test_prints_note_in_failing_example (line 207) | def test_prints_note_in_failing_example():
  function test_must_agree_with_number_of_arguments (line 221) | def test_must_agree_with_number_of_arguments():
  function test (line 236) | def test(x):
  function test_unsatisfied_assumption_during_explicit_example (line 243) | def test_unsatisfied_assumption_during_explicit_example(threshold, value):
  function test_multiple_example_reporting (line 250) | def test_multiple_example_reporting(exc):
  function test_simplifies_multiple_examples_with_same_error (line 263) | def test_simplifies_multiple_examples_with_same_error():
  function test_shows_all_examples_at_verbose (line 285) | def test_shows_all_examples_at_verbose():
  function test_different_errors_not_simplified (line 309) | def test_different_errors_not_simplified():
  function test_example_decorator_accepts_strategies (line 328) | def test_example_decorator_accepts_strategies(s):
  function test_helpful_message_when_example_fails_because_it_was_passed_a_strategy (line 332) | def test_helpful_message_when_example_fails_because_it_was_passed_a_stra...
  function test_stop_silently_dropping_examples_when_decorator_is_applied_to_itself (line 346) | def test_stop_silently_dropping_examples_when_decorator_is_applied_to_it...

FILE: hypothesis-python/tests/cover/test_falsifying_example_output.py
  function test_inserts_line_breaks_only_at_appropriate_lengths (line 24) | def test_inserts_line_breaks_only_at_appropriate_lengths(n):
  function generate_phase (line 37) | def generate_phase(*args, kw):
  function explicit_phase (line 44) | def explicit_phase(*args, kw):
  function test_vararg_output (line 53) | def test_vararg_output(fn):

FILE: hypothesis-python/tests/cover/test_feature_flags.py
  function test_can_all_be_enabled (line 19) | def test_can_all_be_enabled():
  function test_minimizes_open (line 23) | def test_minimizes_open():
  function test_minimizes_individual_features_to_open (line 31) | def test_minimizes_individual_features_to_open():
  function test_marks_unknown_features_as_enabled (line 42) | def test_marks_unknown_features_as_enabled():
  function test_by_default_all_enabled (line 48) | def test_by_default_all_enabled():
  function test_eval_featureflags_repr (line 54) | def test_eval_featureflags_repr():
  function test_repr_can_be_evalled (line 64) | def test_repr_can_be_evalled(data):
  function test_can_avoid_disabling_every_flag (line 84) | def test_can_avoid_disabling_every_flag(flags):

FILE: hypothesis-python/tests/cover/test_filestorage.py
  function setup_function (line 18) | def setup_function(function):
  function teardown_function (line 24) | def teardown_function(function):
  function test_defaults_to_the_default (line 30) | def test_defaults_to_the_default():
  function test_can_set_homedir (line 34) | def test_can_set_homedir(tmp_path):
  function test_will_pick_up_location_from_env (line 39) | def test_will_pick_up_location_from_env(monkeypatch, tmp_path):
  function test_storage_directories_are_not_created_automatically (line 44) | def test_storage_directories_are_not_created_automatically(tmp_path):

FILE: hypothesis-python/tests/cover/test_filter_rewriting.py
  function test_filter_rewriting_ints (line 95) | def test_filter_rewriting_ints(data, strategy, predicate, start, end):
  function test_filter_rewriting_floats (line 159) | def test_filter_rewriting_floats(data, strategy, predicate, min_value, m...
  function test_rewrite_unsatisfiable_filter (line 182) | def test_rewrite_unsatisfiable_filter(s, pred):
  function test_erroring_rewrite_unsatisfiable_filter (line 194) | def test_erroring_rewrite_unsatisfiable_filter(s, pred):
  function test_misc_sat_filter_rewrites (line 207) | def test_misc_sat_filter_rewrites(data, strategy, predicate):
  function test_misc_unsat_filter_rewrites (line 223) | def test_misc_unsat_filter_rewrites(data, strategy, predicate):
  function test_unhandled_operator (line 228) | def test_unhandled_operator(x):
  function test_rewriting_does_not_compare_decimal_snan (line 232) | def test_rewriting_does_not_compare_decimal_snan():
  function test_applying_noop_filter_returns_self (line 240) | def test_applying_noop_filter_returns_self(strategy):
  function mod2 (line 246) | def mod2(x):
  function test_rewrite_filter_chains_with_some_unhandled (line 269) | def test_rewrite_filter_chains_with_some_unhandled(data, predicates, s):
  class NotAFunction (line 287) | class NotAFunction:
    method __call__ (line 288) | def __call__(self, bar):
  function test_rewriting_partially_understood_filters (line 312) | def test_rewriting_partially_understood_filters(data, start, end, predic...
  function test_sequence_filter_rewriting (line 339) | def test_sequence_filter_rewriting(strategy, predicate):
  function test_warns_on_suspicious_string_methods (line 350) | def test_warns_on_suspicious_string_methods(method):
  function test_bumps_min_size_and_filters_for_content_str_methods (line 360) | def test_bumps_min_size_and_filters_for_content_str_methods(method):
  function test_isidentifier_filter_properly_rewritten (line 370) | def test_isidentifier_filter_properly_rewritten(al, data):
  function test_isidentifer_filter_unsatisfiable (line 379) | def test_isidentifer_filter_unsatisfiable():
  function test_filter_floats_can_skip_subnormals (line 396) | def test_filter_floats_can_skip_subnormals(op, attr, value, expected):
  function test_filter_rewriting_text_partial_len (line 420) | def test_filter_rewriting_text_partial_len(data, strategy, predicate, st...
  function test_can_rewrite_multiple_length_filters_if_not_lambdas (line 433) | def test_can_rewrite_multiple_length_filters_if_not_lambdas(data):
  function test_filter_rewriting_text_lambda_len (line 493) | def test_filter_rewriting_text_lambda_len(data, strategy, predicate, sta...
  function test_filter_rewriting_lambda_len_unique_elements (line 561) | def test_filter_rewriting_lambda_len_unique_elements(
  function test_does_not_rewrite_unsatisfiable_len_filter (line 585) | def test_does_not_rewrite_unsatisfiable_len_filter(predicate):
  function test_regex_filter_rewriting (line 612) | def test_regex_filter_rewriting(data, strategy, pattern, method):
  function test_error_on_method_which_requires_multiple_args (line 628) | def test_error_on_method_which_requires_multiple_args(_):
  function test_dates_filter_rewriting (line 632) | def test_dates_filter_rewriting():
  function test_partial_placeholder (line 652) | def test_partial_placeholder():

FILE: hypothesis-python/tests/cover/test_filtered_strategy.py
  function test_filter_iterations_are_marked_as_discarded (line 16) | def test_filter_iterations_are_marked_as_discarded():
  function test_filtered_branches_are_all_filtered (line 25) | def test_filtered_branches_are_all_filtered():
  function test_filter_conditions_may_be_empty (line 30) | def test_filter_conditions_may_be_empty():
  function test_nested_filteredstrategy_flattens_conditions (line 35) | def test_nested_filteredstrategy_flattens_conditions():

FILE: hypothesis-python/tests/cover/test_find.py
  function test_find_uses_provided_random (line 19) | def test_find_uses_provided_random():

FILE: hypothesis-python/tests/cover/test_flakiness.py
  class Nope (line 26) | class Nope(Exception):
  function test_fails_only_once_is_flaky (line 30) | def test_fails_only_once_is_flaky():
  function test_fails_differently_is_flaky (line 47) | def test_fails_differently_is_flaky():
  function test_exceptiongroup_wrapped_naked_exception_is_flaky (line 73) | def test_exceptiongroup_wrapped_naked_exception_is_flaky():
  function test_gives_flaky_error_if_assumption_is_flaky (line 97) | def test_gives_flaky_error_if_assumption_is_flaky():
  function test_flaky_with_context_when_fails_only_under_tracing (line 115) | def test_flaky_with_context_when_fails_only_under_tracing(monkeypatch):
  function test_does_not_attempt_to_shrink_flaky_errors (line 136) | def test_does_not_attempt_to_shrink_flaky_errors():
  class SatisfyMe (line 155) | class SatisfyMe(Exception):
  function single_bool_lists (line 160) | def single_bool_lists(draw):
  function test_failure_sequence_inducing (line 176) | def test_failure_sequence_inducing(building, testing, rnd):

FILE: hypothesis-python/tests/cover/test_float_nastiness.py
  function test_floats_are_in_range (line 45) | def test_floats_are_in_range(data, lower, upper):
  function test_can_generate_both_zeros (line 51) | def test_can_generate_both_zeros(sign):
  function test_can_generate_both_zeros_when_in_interval (line 60) | def test_can_generate_both_zeros_when_in_interval(l, r, sign):
  function test_does_not_generate_negative_if_right_boundary_is_positive (line 65) | def test_does_not_generate_negative_if_right_boundary_is_positive(x):
  function test_does_not_generate_positive_if_right_boundary_is_negative (line 70) | def test_does_not_generate_positive_if_right_boundary_is_negative(x):
  function test_half_bounded_generates_zero (line 74) | def test_half_bounded_generates_zero():
  function test_half_bounded_respects_sign_of_upper_bound (line 80) | def test_half_bounded_respects_sign_of_upper_bound(x):
  function test_half_bounded_respects_sign_of_lower_bound (line 85) | def test_half_bounded_respects_sign_of_lower_bound(x):
  function test_filter_nan (line 90) | def test_filter_nan(x):
  function test_filter_infinity (line 95) | def test_filter_infinity(x):
  function test_can_guard_against_draws_of_nan (line 99) | def test_can_guard_against_draws_of_nan():
  function test_very_narrow_interval (line 120) | def test_very_narrow_interval():
  function test_up_means_greater (line 133) | def test_up_means_greater(x):
  function test_down_means_lesser (line 144) | def test_down_means_lesser(x):
  function test_updown_roundtrip (line 155) | def test_updown_roundtrip(val):
  function test_float32_can_exclude_infinity (line 161) | def test_float32_can_exclude_infinity(x):
  function test_float16_can_exclude_infinity (line 166) | def test_float16_can_exclude_infinity(x):
  function test_out_of_range (line 183) | def test_out_of_range(kwargs):
  function test_disallowed_width (line 188) | def test_disallowed_width():
  function test_no_single_floats_in_range (line 193) | def test_no_single_floats_in_range():
  function test_finite_min_bound_does_not_overflow (line 207) | def test_finite_min_bound_does_not_overflow(x):
  function test_finite_max_bound_does_not_overflow (line 212) | def test_finite_max_bound_does_not_overflow(x):
  function test_can_exclude_endpoints (line 217) | def test_can_exclude_endpoints(x):
  function test_can_exclude_neg_infinite_endpoint (line 222) | def test_can_exclude_neg_infinite_endpoint(x):
  function test_can_exclude_pos_infinite_endpoint (line 227) | def test_can_exclude_pos_infinite_endpoint(x):
  function test_exclude_infinite_endpoint_is_invalid (line 231) | def test_exclude_infinite_endpoint_is_invalid():
  function test_exclude_entire_interval (line 240) | def test_exclude_entire_interval(lo, hi, bound):
  function test_zero_intervals_are_OK (line 245) | def test_zero_intervals_are_OK():
  function test_cannot_exclude_endpoint_with_zero_interval (line 254) | def test_cannot_exclude_endpoint_with_zero_interval(lo, hi, exmin, exmax):
  function test_fuzzing_floats_bounds (line 264) | def test_fuzzing_floats_bounds(data, width, nonfloat):

FILE: hypothesis-python/tests/cover/test_float_utils.py
  function test_can_handle_straddling_zero (line 30) | def test_can_handle_straddling_zero():
  function test_next_float_equal (line 45) | def test_next_float_equal(func, val):
  function test_float_clamper (line 77) | def test_float_clamper(constraints, input_value):

FILE: hypothesis-python/tests/cover/test_functions.py
  function func_a (line 23) | def func_a():
  function test_functions_no_args (line 28) | def test_functions_no_args(f):
  function func_b (line 34) | def func_b(a, b, c):
  function test_functions_with_args (line 39) | def test_functions_with_args(f):
  function func_c (line 47) | def func_c(**kwargs):
  function test_functions_kw_args (line 52) | def test_functions_kw_args(f):
  function test_functions_argless_lambda (line 61) | def test_functions_argless_lambda(f):
  function test_functions_lambda_with_arg (line 69) | def test_functions_lambda_with_arg(f):
  function test_invalid_arguments (line 84) | def test_invalid_arguments(like, returns, pure):
  function func_returns_str (line 89) | def func_returns_str() -> str:
  function test_functions_strategy_return_type_inference (line 94) | def test_functions_strategy_return_type_inference(f):
  function test_functions_valid_within_given_invalid_outside (line 100) | def test_functions_valid_within_given_invalid_outside():
  function test_can_call_default_like_arg (line 114) | def test_can_call_default_like_arg():
  function func (line 123) | def func(arg, *, kwonly_arg):
  function test_functions_strategy_with_kwonly_args (line 128) | def test_functions_strategy_with_kwonly_args(f):
  function pure_func (line 135) | def pure_func(arg1, arg2):
  function test_functions_pure_with_same_args (line 144) | def test_functions_pure_with_same_args(f, arg1, arg2):
  function test_functions_pure_with_different_args (line 158) | def test_functions_pure_with_different_args(f, arg1, arg2):
  function test_functions_pure_two_functions_different_args_different_result (line 169) | def test_functions_pure_two_functions_different_args_different_result(f1...
  function test_functions_pure_two_functions_same_args_different_result (line 182) | def test_functions_pure_two_functions_same_args_different_result(f1, f2,...
  function test_functions_note_all_calls_to_impure_functions (line 191) | def test_functions_note_all_calls_to_impure_functions(f):
  function test_functions_note_only_first_to_pure_functions (line 201) | def test_functions_note_only_first_to_pure_functions(f):
  function test_functions_supports_find (line 209) | def test_functions_supports_find():

FILE: hypothesis-python/tests/cover/test_fuzz_one_input.py
  function test_fuzz_one_input (line 29) | def test_fuzz_one_input(buffer_type):
  function test_can_fuzz_with_database_eq_None (line 73) | def test_can_fuzz_with_database_eq_None():
  function test_fuzzing_unsatisfiable_test_always_returns_None (line 85) | def test_fuzzing_unsatisfiable_test_always_returns_None():
  function test_autopruning_of_returned_buffer (line 100) | def test_autopruning_of_returned_buffer():
  function test_can_access_strategy_for_wrapped_test (line 111) | def test_can_access_strategy_for_wrapped_test():
  function test_fuzz_one_input_does_not_add_redundant_entries_to_database (line 135) | def test_fuzz_one_input_does_not_add_redundant_entries_to_database(buffe...
  function test_fuzzing_invalid_test_raises_error (line 155) | def test_fuzzing_invalid_test_raises_error():

FILE: hypothesis-python/tests/cover/test_given_error_conditions.py
  function test_raises_unsatisfiable_if_all_false_in_finite_set (line 23) | def test_raises_unsatisfiable_if_all_false_in_finite_set(x):
  function test_does_not_raise_unsatisfiable_if_some_false_in_finite_set (line 27) | def test_does_not_raise_unsatisfiable_if_some_false_in_finite_set():
  function test_raises_unsatisfiable_if_passed_explicit_nothing (line 35) | def test_raises_unsatisfiable_if_passed_explicit_nothing():
  function test_error_if_has_no_hints (line 47) | def test_error_if_has_no_hints():
  function test_error_if_infer_all_and_has_no_hints (line 56) | def test_error_if_infer_all_and_has_no_hints():
  function test_error_if_infer_is_posarg (line 65) | def test_error_if_infer_is_posarg():
  function test_error_if_infer_is_posarg_mixed_with_kwarg (line 74) | def test_error_if_infer_is_posarg_mixed_with_kwarg():
  function test_given_twice_is_an_error (line 83) | def test_given_twice_is_an_error():
  function test_given_is_not_a_class_decorator (line 95) | def test_given_is_not_a_class_decorator():
  function test_specific_error_for_coroutine_functions (line 102) | def test_specific_error_for_coroutine_functions():
  function test_suggests_at_settings_if_extra_kwarg_matches_setting_name (line 116) | def test_suggests_at_settings_if_extra_kwarg_matches_setting_name(settin...

FILE: hypothesis-python/tests/cover/test_health_checks.py
  function test_slow_generation_fails_a_health_check (line 36) | def test_slow_generation_fails_a_health_check():
  function test_slow_generation_inline_fails_a_health_check (line 46) | def test_slow_generation_inline_fails_a_health_check():
  function test_default_health_check_can_weaken_specific (line 56) | def test_default_health_check_can_weaken_specific():
  function test_suppressing_filtering_health_check (line 70) | def test_suppressing_filtering_health_check():
  function test_filtering_everything_fails_a_health_check (line 97) | def test_filtering_everything_fails_a_health_check():
  class fails_regularly (line 107) | class fails_regularly(SearchStrategy):
    method do_draw (line 108) | def do_draw(self, data):
  function test_filtering_most_things_fails_a_health_check (line 113) | def test_filtering_most_things_fails_a_health_check():
  function test_returning_non_none_is_forbidden (line 124) | def test_returning_non_none_is_forbidden():
  function test_the_slow_test_health_check_can_be_disabled (line 134) | def test_the_slow_test_health_check_can_be_disabled():
  function test_the_slow_test_health_only_runs_if_health_checks_are_on (line 144) | def test_the_slow_test_health_only_runs_if_health_checks_are_on():
  class sample_test_runner (line 153) | class sample_test_runner:
    method test (line 155) | def test(self, _):
  function test_differing_executors_fails_health_check (line 159) | def test_differing_executors_fails_health_check():
  function test_it_is_an_error_to_suppress_non_iterables (line 166) | def test_it_is_an_error_to_suppress_non_iterables():
  function test_it_is_an_error_to_suppress_non_healthchecks (line 171) | def test_it_is_an_error_to_suppress_non_healthchecks():
  class ReturningRuleMachine (line 176) | class ReturningRuleMachine(RuleBasedStateMachine):
    method r (line 178) | def r(self):
  class ReturningInitializeMachine (line 182) | class ReturningInitializeMachine(RuleBasedStateMachine):
    method r (line 186) | def r(self):
  class ReturningInvariantMachine (line 190) | class ReturningInvariantMachine(RuleBasedStateMachine):
    method r (line 194) | def r(self):
  function test_stateful_returnvalue_healthcheck (line 201) | def test_stateful_returnvalue_healthcheck(cls):
  function test_nested_given_raises_healthcheck (line 206) | def test_nested_given_raises_healthcheck():
  function test_triply_nested_given_raises_healthcheck (line 219) | def test_triply_nested_given_raises_healthcheck():
  function test_can_suppress_nested_given (line 242) | def test_can_suppress_nested_given():
  function test_cant_suppress_nested_given_on_inner (line 257) | def test_cant_suppress_nested_given_on_inner():
  function test_suppress_triply_nested_given (line 277) | def test_suppress_triply_nested_given():

FILE: hypothesis-python/tests/cover/test_interactive_example.py
  function _allow_noninteractive_example (line 51) | def _allow_noninteractive_example():
  function test_example_of_none_is_none (line 57) | def test_example_of_none_is_none():
  function test_exception_in_compare_can_still_have_example (line 61) | def test_exception_in_compare_can_still_have_example():
  function test_does_not_always_give_the_same_example (line 66) | def test_does_not_always_give_the_same_example():
  function test_raises_on_no_examples (line 71) | def test_raises_on_no_examples():
  function test_example_inside_given (line 79) | def test_example_inside_given(b):
  function test_example_inside_find (line 84) | def test_example_inside_find():
  function test_example_inside_strategy (line 89) | def test_example_inside_strategy():
  function test_raises_on_arbitrary_data (line 93) | def test_raises_on_arbitrary_data():
  function test_non_interactive_example_emits_warning (line 98) | def test_non_interactive_example_emits_warning():
  function test_selftests_exception_contains_note (line 115) | def test_selftests_exception_contains_note(pytester):
  function test_script_example_does_not_emit_warning (line 129) | def test_script_example_does_not_emit_warning(tmp_path):
  function test_interactive_example_does_not_emit_warning (line 144) | def test_interactive_example_does_not_emit_warning():

FILE: hypothesis-python/tests/cover/test_internal_helpers.py
  function test_is_negative_gives_good_type_error (line 16) | def test_is_negative_gives_good_type_error():

FILE: hypothesis-python/tests/cover/test_intervalset.py
  function test_intervals_are_equivalent_to_their_lists (line 26) | def test_intervals_are_equivalent_to_their_lists(intervals):
  function test_intervals_match_indexes (line 36) | def test_intervals_match_indexes(intervals):
  function test_error_for_index_of_not_present_value (line 45) | def test_error_for_index_of_not_present_value(intervals, v):
  function test_validates_index (line 51) | def test_validates_index():
  function test_index_above_is_index_if_present (line 62) | def test_index_above_is_index_if_present():
  function test_index_above_is_length_if_higher (line 67) | def test_index_above_is_length_if_higher():
  function intervals_to_set (line 71) | def intervals_to_set(ints):
  function test_subtraction_of_intervals (line 80) | def test_subtraction_of_intervals(x, y):
  function test_interval_intersection (line 92) | def test_interval_intersection(x, y):
  function test_char_in_shrink_order (line 97) | def test_char_in_shrink_order():
  function test_index_from_char_in_shrink_order (line 106) | def test_index_from_char_in_shrink_order():
  function test_intervalset_equal (line 112) | def test_intervalset_equal():

FILE: hypothesis-python/tests/cover/test_lambda_formatting.py
  function clear_lambda_caches (line 24) | def clear_lambda_caches(request, monkeypatch):
  function test_bracket_whitespace_is_stripped (line 34) | def test_bracket_whitespace_is_stripped():
  function test_can_have_unicode_in_lambda_sources (line 41) | def test_can_have_unicode_in_lambda_sources():
  function test_can_get_descriptions_of_nested_lambdas_with_different_names (line 49) | def test_can_get_descriptions_of_nested_lambdas_with_different_names():
  function test_does_not_error_on_unparsable_source (line 61) | def test_does_not_error_on_unparsable_source():
  function test_separate_line_map_filter (line 75) | def test_separate_line_map_filter():
  function test_source_of_lambda_is_pretty (line 92) | def test_source_of_lambda_is_pretty():
  function test_variable_names_are_not_pretty (line 96) | def test_variable_names_are_not_pretty():
  function test_does_not_error_on_dynamically_defined_functions (line 101) | def test_does_not_error_on_dynamically_defined_functions():
  function test_collapses_whitespace_nicely (line 106) | def test_collapses_whitespace_nicely():
  function test_is_not_confused_by_tuples (line 115) | def test_is_not_confused_by_tuples():
  function test_strips_comments_from_the_end (line 121) | def test_strips_comments_from_the_end():
  function test_does_not_strip_hashes_within_a_string (line 126) | def test_does_not_strip_hashes_within_a_string():
  function test_can_distinguish_between_two_lambdas_with_different_args (line 131) | def test_can_distinguish_between_two_lambdas_with_different_args():
  function test_can_distinguish_between_two_lambdas_with_different_constants (line 137) | def test_can_distinguish_between_two_lambdas_with_different_constants():
  function test_can_distinguish_between_two_lambdas_with_different_signatures (line 143) | def test_can_distinguish_between_two_lambdas_with_different_signatures():
  function test_can_distinguish_between_two_lambdas_where_one_fails_localparse (line 149) | def test_can_distinguish_between_two_lambdas_where_one_fails_localparse():
  function test_does_not_get_confused_by_identical_lambdas (line 161) | def test_does_not_get_confused_by_identical_lambdas():
  function test_lambda_capturing_globals (line 171) | def test_lambda_capturing_globals():
  function test_lambda_capturing_locals (line 176) | def test_lambda_capturing_locals():
  function test_can_distinguish_between_two_lambdas_with_different_captures (line 183) | def test_can_distinguish_between_two_lambdas_with_different_captures():
  function test_lambda_source_break_after_bracket (line 192) | def test_lambda_source_break_after_bracket():
  function test_lambda_source_break_after_def_with_brackets (line 205) | def test_lambda_source_break_after_def_with_brackets():
  function test_lambda_source_break_after_def_with_line_continuation (line 215) | def test_lambda_source_break_after_def_with_line_continuation():
  function arg_decorator (line 225) | def arg_decorator(*s):
  function plus_one (line 233) | def plus_one():
  function two_decorators (line 238) | def two_decorators():
  function test_can_extract_lambda_repr_in_a_decorator (line 242) | def test_can_extract_lambda_repr_in_a_decorator():
  function test_can_extract_two_lambdas_from_a_decorator_if_args_differ (line 246) | def test_can_extract_two_lambdas_from_a_decorator_if_args_differ():
  function to_brackets (line 253) | def to_brackets():
  function test_can_handle_brackets_in_decorator_argument (line 257) | def test_can_handle_brackets_in_decorator_argument():
  function decorator_with_wrapper (line 262) | def decorator_with_wrapper():
  function test_can_handle_nested_lambda_in_decorator_argument (line 266) | def test_can_handle_nested_lambda_in_decorator_argument():
  function test_modifying_lambda_source_code_returns_unknown (line 273) | def test_modifying_lambda_source_code_returns_unknown(tmp_path):
  function test_adding_other_lambda_does_not_confuse (line 289) | def test_adding_other_lambda_does_not_confuse(tmp_path):
  function test_changing_lambda_confuses (line 304) | def test_changing_lambda_confuses(tmp_path, allow_unknown_lambdas, clear...
  function test_that_test_harness_raises_on_unknown_lambda (line 318) | def test_that_test_harness_raises_on_unknown_lambda(tmp_path):
  function test_source_with_syntax_error (line 330) | def test_source_with_syntax_error(tmp_path, allow_unknown_lambdas, clear...
  function test_unknown_is_not_stuck (line 343) | def test_unknown_is_not_stuck(tmp_path, allow_unknown_lambdas, clear_lam...

FILE: hypothesis-python/tests/cover/test_lazy_import.py
  function test_hypothesis_does_not_import_test_runners (line 44) | def test_hypothesis_does_not_import_test_runners(tmp_path):

FILE: hypothesis-python/tests/cover/test_lookup.py
  function test_resolve_typing_module (line 88) | def test_resolve_typing_module(data, typ):
  function test_does_not_resolve_special_cases (line 102) | def test_does_not_resolve_special_cases(typ):
  function test_specialised_scalar_types (line 117) | def test_specialised_scalar_types(data, typ, instance_of):
  function test_typing_Type_int (line 122) | def test_typing_Type_int():
  function test_typing_Type_Union (line 128) | def test_typing_Type_Union(ex):
  function test_rare_types (line 147) | def test_rare_types(data, typ):
  class Elem (line 156) | class Elem:
  function test_specialised_collection_types (line 190) | def test_specialised_collection_types(data, typ, coll_type):
  class ElemValue (line 198) | class ElemValue:
  function test_specialised_mapping_types (line 212) | def test_specialised_mapping_types(data, typ, coll_type):
  function test_ItemsView (line 221) | def test_ItemsView(ex):
  function test_regex_types (line 231) | def test_regex_types(data, generic, typ):
  function test_Generator (line 237) | def test_Generator(x: typing.Generator[Elem, None, ElemValue]):
  function test_Optional_minimises_to_None (line 248) | def test_Optional_minimises_to_None():
  function test_variable_length_tuples (line 254) | def test_variable_length_tuples(t, n):
  function test_lookup_overrides_defaults (line 259) | def test_lookup_overrides_defaults():
  function test_register_generic_typing_strats (line 276) | def test_register_generic_typing_strats():
  function if_available (line 294) | def if_available(name):
  function test_resolves_weird_types (line 318) | def test_resolves_weird_types(typ):
  class Foo (line 322) | class Foo:
    method __init__ (line 323) | def __init__(self, x):
  class Bar (line 327) | class Bar(Foo):
  class Baz (line 331) | class Baz(Foo):
  function test_typevar_type_is_consistent (line 351) | def test_typevar_type_is_consistent(data, var, expected):
  function test_distinct_typevars_same_constraint (line 360) | def test_distinct_typevars_same_constraint():
  function test_distinct_typevars_distinct_type (line 369) | def test_distinct_typevars_distinct_type():
  function same_type_args (line 382) | def same_type_args(a: A, b: A):
  function test_same_typevars_same_type (line 387) | def test_same_typevars_same_type(_):
  function test_typevars_can_be_redefined (line 391) | def test_typevars_can_be_redefined():
  function test_typevars_can_be_redefine_with_factory (line 399) | def test_typevars_can_be_redefine_with_factory():
  function test_typevars_can_be_resolved_conditionally (line 407) | def test_typevars_can_be_resolved_conditionally():
  function annotated_func (line 426) | def annotated_func(a: int, b: int = 2, *, c: int, d: int = 4):
  function test_issue_946_regression (line 430) | def test_issue_946_regression():
  function test_can_get_type_hints (line 443) | def test_can_get_type_hints(thing):
  function test_force_builds_to_infer_strategies_for_default_args (line 447) | def test_force_builds_to_infer_strategies_for_default_args():
  function non_annotated_func (line 454) | def non_annotated_func(a, b=2, *, c, d=4):
  function test_cannot_pass_infer_as_posarg (line 458) | def test_cannot_pass_infer_as_posarg():
  function test_cannot_force_inference_for_unannotated_arg (line 463) | def test_cannot_force_inference_for_unannotated_arg():
  class UnknownType (line 470) | class UnknownType:
    method __init__ (line 471) | def __init__(self, arg):
  class UnknownAnnotatedType (line 475) | class UnknownAnnotatedType:
    method __init__ (line 476) | def __init__(self, arg: int):
  function test_builds_for_unknown_annotated_type (line 481) | def test_builds_for_unknown_annotated_type(ex):
  function unknown_annotated_func (line 485) | def unknown_annotated_func(a: UnknownType, b=2, *, c: UnknownType, d=4):
  function test_raises_for_arg_with_unresolvable_annotation (line 489) | def test_raises_for_arg_with_unresolvable_annotation():
  function test_can_use_type_hints (line 499) | def test_can_use_type_hints(a: int, b: float):
  function test_error_if_has_unresolvable_hints (line 504) | def test_error_if_has_unresolvable_hints():
  function test_resolves_NewType (line 513) | def test_resolves_NewType():
  function test_resolves_NewType_conditionally (line 525) | def test_resolves_NewType_conditionally(is_handled):
  function test_resolves_enum (line 546) | def test_resolves_enum(ex):
  function test_resolves_flag_enum (line 551) | def test_resolves_flag_enum(resolver):
  class AnnotatedTarget (line 564) | class AnnotatedTarget:
    method __init__ (line 565) | def __init__(self, a: int, b: int):
    method method (line 568) | def method(self, a: int, b: int):
  function test_required_args (line 584) | def test_required_args(target, args, kwargs):
  class AnnotatedNamedTuple (line 593) | class AnnotatedNamedTuple(typing.NamedTuple):
  function test_infers_args_for_namedtuple_builds (line 598) | def test_infers_args_for_namedtuple_builds(thing):
  function test_infers_args_for_namedtuple_from_type (line 603) | def test_infers_args_for_namedtuple_from_type(thing):
  function test_override_args_for_namedtuple (line 608) | def test_override_args_for_namedtuple(thing):
  function test_cannot_resolve_bare_forward_reference (line 613) | def test_cannot_resolve_bare_forward_reference(thing):
  class Tree (line 619) | class Tree:
    method __init__ (line 620) | def __init__(self, left: typing.Optional["Tree"], right: typing.Option...
    method __repr__ (line 624) | def __repr__(self):
  function test_resolving_recursive_type (line 633) | def test_resolving_recursive_type(tree):
  class TypedTree (line 637) | class TypedTree(typing.TypedDict):
  function test_resolving_recursive_typeddict (line 641) | def test_resolving_recursive_typeddict():
  class MyList (line 648) | class MyList:
    method __init__ (line 649) | def __init__(self, nxt: typing.Optional["MyList"] = None):
    method __repr__ (line 652) | def __repr__(self):
    method __eq__ (line 655) | def __eq__(self, other):
  function test_resolving_recursive_type_with_defaults (line 660) | def test_resolving_recursive_type_with_defaults(lst):
  function test_recursive_type_with_defaults_minimizes_to_defaults (line 664) | def test_recursive_type_with_defaults_minimizes_to_defaults():
  class MutualA (line 668) | class MutualA:
    method __init__ (line 669) | def __init__(self, nxt: typing.Optional["MutualB"]):
    method __repr__ (line 672) | def __repr__(self):
  class MutualB (line 676) | class MutualB:
    method __init__ (line 677) | def __init__(self, nxt: typing.Optional["MutualA"]):
    method __repr__ (line 680) | def __repr__(self):
  function test_resolving_mutually_recursive_types (line 685) | def test_resolving_mutually_recursive_types(nxt):
  function test_resolving_mutually_recursive_types_with_limited_stack (line 693) | def test_resolving_mutually_recursive_types_with_limited_stack():
  class A_with_default (line 709) | class A_with_default:
    method __init__ (line 710) | def __init__(self, nxt: typing.Optional["B_with_default"] = None):
    method __repr__ (line 713) | def __repr__(self):
  class B_with_default (line 717) | class B_with_default:
    method __init__ (line 718) | def __init__(self, nxt: typing.Optional["A_with_default"] = None):
    method __repr__ (line 721) | def __repr__(self):
  function test_resolving_mutually_recursive_types_with_defaults (line 726) | def test_resolving_mutually_recursive_types_with_defaults(nxt):
  class SomeClass (line 738) | class SomeClass:
    method __init__ (line 739) | def __init__(self, value: int, next_node: typing.Optional["SomeClass"]...
    method __repr__ (line 744) | def __repr__(self) -> str:
  function test_resolving_recursive_type_with_registered_constraint (line 748) | def test_resolving_recursive_type_with_registered_constraint():
  function test_resolving_recursive_type_with_registered_constraint_not_none (line 760) | def test_resolving_recursive_type_with_registered_constraint_not_none():
  function test_resolves_empty_Tuple_issue_1583_regression (line 770) | def test_resolves_empty_Tuple_issue_1583_regression(ex):
  function test_can_register_NewType (line 775) | def test_can_register_NewType():
  function test_resolves_bare_callable_to_function (line 782) | def test_resolves_bare_callable_to_function(f):
  function test_resolves_callable_with_arg_to_function (line 790) | def test_resolves_callable_with_arg_to_function(f):
  function test_resolves_ellipses_callable_to_function (line 796) | def test_resolves_ellipses_callable_to_function(f):
  class AbstractFoo (line 804) | class AbstractFoo(abc.ABC):
    method foo (line 806) | def foo(self):
  class ConcreteFoo (line 810) | class ConcreteFoo(AbstractFoo):
    method foo (line 811) | def foo(self):
  function test_can_resolve_abstract_class (line 816) | def test_can_resolve_abstract_class(instance):
  class AbstractBar (line 821) | class AbstractBar(abc.ABC):
    method bar (line 823) | def bar(self):
  function test_cannot_resolve_abstract_class_with_no_concrete_subclass (line 829) | def test_cannot_resolve_abstract_class_with_no_concrete_subclass(instance):
  function test_cannot_resolve_type_with_forwardref (line 835) | def test_cannot_resolve_type_with_forwardref(instance):
  function test_cannot_resolve_type_with_forwardref_old (line 841) | def test_cannot_resolve_type_with_forwardref_old(instance):
  function test_inference_on_generic_collections_abc_aliases (line 847) | def test_inference_on_generic_collections_abc_aliases(typ, data):
  function test_bytestring_not_treated_as_generic_sequence (line 857) | def test_bytestring_not_treated_as_generic_sequence(val):
  function test_bytestring_is_valid_sequence_of_int_and_parent_classes (line 869) | def test_bytestring_is_valid_sequence_of_int_and_parent_classes(type_):
  function test_supportsop_types_support_protocol (line 878) | def test_supportsop_types_support_protocol(protocol, data):
  function test_generic_aliases_can_be_conditionally_resolved_by_registered_function (line 888) | def test_generic_aliases_can_be_conditionally_resolved_by_registered_fun...
  function test_supportscast_types_support_protocol_or_are_castable (line 949) | def test_supportscast_types_support_protocol_or_are_castable(protocol, t...
  function test_can_cast (line 958) | def test_can_cast():
  function test_timezone_lookup (line 964) | def test_timezone_lookup(type_):
  function test_generic_collections_only_use_hashable_elements (line 982) | def test_generic_collections_only_use_hashable_elements(typ, data):
  function test_no_byteswarning (line 987) | def test_no_byteswarning(_):
  function test_hashable_type_unhashable_value (line 995) | def test_hashable_type_unhashable_value():
  function test_unhashable_type (line 1005) | def test_unhashable_type():
  class _EmptyClass (line 1017) | class _EmptyClass:
    method __init__ (line 1018) | def __init__(self, value=-1) -> None:
  function test_repr_passthrough (line 1037) | def test_repr_passthrough(typ, repr_):
  class TreeForwardRefs (line 1041) | class TreeForwardRefs(typing.NamedTuple):
  function test_resolves_forward_references_outside_annotations (line 1048) | def test_resolves_forward_references_outside_annotations(t):
  function constructor (line 1052) | def constructor(a: str = None):  # noqa  # deprecated implicit optional,...
  class WithOptionalInSignature (line 1056) | class WithOptionalInSignature:
    method __init__ (line 1060) | def __init__(self, **kwargs):
  function test_compat_get_type_hints_aware_of_None_default (line 1065) | def test_compat_get_type_hints_aware_of_None_default():
  class Wrapper (line 1082) | class Wrapper(typing.Generic[_ValueType]):
    method __init__ (line 1085) | def __init__(self, inner_value: _ValueType) -> None:
  function test_issue_2603_regression (line 1090) | def test_issue_2603_regression(built):
  class AnnotatedConstructor (line 1095) | class AnnotatedConstructor(typing.Generic[_ValueType]):
    method __init__ (line 1098) | def __init__(self, value: int) -> None:
  function test_constructor_is_more_important (line 1104) | def test_constructor_is_more_important(data):
  function use_signature (line 1109) | def use_signature(self, value: str) -> None: ...
  class AnnotatedConstructorWithSignature (line 1112) | class AnnotatedConstructorWithSignature(typing.Generic[_ValueType]):
    method __init__ (line 1117) | def __init__(self, value: int) -> None:
  function selfless_signature (line 1122) | def selfless_signature(value: str) -> None: ...
  class AnnotatedConstructorWithSelflessSignature (line 1125) | class AnnotatedConstructorWithSelflessSignature(AnnotatedConstructorWith...
  function really_takes_str (line 1129) | def really_takes_str(value: int) -> None:
  function test_signature_is_the_most_important_source (line 1145) | def test_signature_is_the_most_important_source(thing):
  class AnnotatedAndDefault (line 1150) | class AnnotatedAndDefault:
    method __init__ (line 1151) | def __init__(self, foo: bool | None = None):
  function test_from_type_can_be_default_or_annotation (line 1155) | def test_from_type_can_be_default_or_annotation():
  function test_resolves_builtin_types (line 1161) | def test_resolves_builtin_types(t):
  function test_resolves_forwardrefs_to_builtin_types (line 1170) | def test_resolves_forwardrefs_to_builtin_types(t, data):
  function test_resolves_type_of_builtin_types (line 1186) | def test_resolves_type_of_builtin_types(t):
  function test_resolves_type_of_union_of_forwardrefs_to_builtins (line 1194) | def test_resolves_type_of_union_of_forwardrefs_to_builtins(x):
  function test_builds_suggests_from_type (line 1211) | def test_builds_suggests_from_type(type_):
  function test_builds_suggests_from_type_on_construction (line 1226) | def test_builds_suggests_from_type_on_construction(type_):
  function test_builds_mentions_no_type_check (line 1238) | def test_builds_mentions_no_type_check():
  class TupleSubtype (line 1248) | class TupleSubtype(tuple):
  function test_tuple_subclasses_not_generic_sequences (line 1252) | def test_tuple_subclasses_not_generic_sequences():
  function test_custom_strategy_function_resolves_types_conditionally (line 1259) | def test_custom_strategy_function_resolves_types_conditionally():
  class CustomInteger (line 1287) | class CustomInteger(int):
    method __init__ (line 1288) | def __init__(self, value: int, /) -> None:
  function test_from_type_resolves_required_posonly_args (line 1294) | def test_from_type_resolves_required_posonly_args(n: CustomInteger):
  class MyProtocol (line 1300) | class MyProtocol(typing.Protocol):
  function test_issue_4194_regression (line 1304) | def test_issue_4194_regression():

FILE: hypothesis-python/tests/cover/test_lookup_py310.py
  function test_native_unions (line 16) | def test_native_unions():

FILE: hypothesis-python/tests/cover/test_lookup_py314.py
  class A (line 22) | class A:
    method __buffer__ (line 28) | def __buffer__(self, flags):
  function test_resolve_bufferlike_memoryview (line 35) | def test_resolve_bufferlike_memoryview(v):
  function test_errors_when___buffer___not_implemented (line 41) | def test_errors_when___buffer___not_implemented():
  function test_resolve_Buffer (line 55) | def test_resolve_Buffer():

FILE: hypothesis-python/tests/cover/test_lookup_py37.py
  class Elem (line 21) | class Elem:
  class Value (line 25) | class Value:
  function check (line 29) | def check(t, ex):
  function test_resolving_standard_tuple1_as_generic (line 36) | def test_resolving_standard_tuple1_as_generic(x: tuple[Elem]):
  function test_resolving_standard_tuple2_as_generic (line 41) | def test_resolving_standard_tuple2_as_generic(x: tuple[Elem, Elem]):
  function test_resolving_standard_tuple_variadic_as_generic (line 46) | def test_resolving_standard_tuple_variadic_as_generic(x: tuple[Elem, ...]):
  function test_resolving_standard_list_as_generic (line 51) | def test_resolving_standard_list_as_generic(x: list[Elem]):
  function test_resolving_standard_dict_as_generic (line 56) | def test_resolving_standard_dict_as_generic(x: dict[Elem, Value]):
  function test_resolving_standard_set_as_generic (line 62) | def test_resolving_standard_set_as_generic(x: set[Elem]):
  function test_resolving_standard_frozenset_as_generic (line 67) | def test_resolving_standard_frozenset_as_generic(x: frozenset[Elem]):
  function test_resolving_standard_deque_as_generic (line 72) | def test_resolving_standard_deque_as_generic(x: collections.deque[Elem]):
  function test_resolving_standard_defaultdict_as_generic (line 77) | def test_resolving_standard_defaultdict_as_generic(
  function test_resolving_standard_ordered_dict_as_generic (line 85) | def test_resolving_standard_ordered_dict_as_generic(
  function test_resolving_standard_counter_as_generic (line 93) | def test_resolving_standard_counter_as_generic(x: collections.Counter[El...
  function test_resolving_standard_chainmap_as_generic (line 99) | def test_resolving_standard_chainmap_as_generic(x: collections.ChainMap[...
  function test_resolving_standard_iterable_as_generic (line 105) | def test_resolving_standard_iterable_as_generic(x: collections.abc.Itera...
  function test_resolving_standard_iterator_as_generic (line 110) | def test_resolving_standard_iterator_as_generic(x: collections.abc.Itera...
  function test_resolving_standard_generator_as_generic (line 115) | def test_resolving_standard_generator_as_generic(
  function test_resolving_standard_reversible_as_generic (line 129) | def test_resolving_standard_reversible_as_generic(x: collections.abc.Rev...
  function test_resolving_standard_container_as_generic (line 134) | def test_resolving_standard_container_as_generic(x: collections.abc.Cont...
  function test_resolving_standard_collection_as_generic (line 139) | def test_resolving_standard_collection_as_generic(x: collections.abc.Col...
  function test_resolving_standard_callable_ellipsis (line 144) | def test_resolving_standard_callable_ellipsis(x: collections.abc.Callabl...
  function test_resolving_standard_callable_no_args (line 153) | def test_resolving_standard_callable_no_args(x: collections.abc.Callable...
  function test_resolving_standard_collections_set_as_generic (line 165) | def test_resolving_standard_collections_set_as_generic(x: collections.ab...
  function test_resolving_standard_collections_mutableset_as_generic (line 170) | def test_resolving_standard_collections_mutableset_as_generic(
  function test_resolving_standard_mapping_as_generic (line 177) | def test_resolving_standard_mapping_as_generic(x: collections.abc.Mappin...
  function test_resolving_standard_mutable_mapping_as_generic (line 183) | def test_resolving_standard_mutable_mapping_as_generic(
  function test_resolving_standard_sequence_as_generic (line 191) | def test_resolving_standard_sequence_as_generic(x: collections.abc.Seque...
  function test_resolving_standard_mutable_sequence_as_generic (line 196) | def test_resolving_standard_mutable_sequence_as_generic(
  function test_resolving_standard_keysview_as_generic (line 203) | def test_resolving_standard_keysview_as_generic(x: collections.abc.KeysV...
  function test_resolving_standard_itemsview_as_generic (line 208) | def test_resolving_standard_itemsview_as_generic(
  function test_resolving_standard_valuesview_as_generic (line 217) | def test_resolving_standard_valuesview_as_generic(x: collections.abc.Val...
  function test_resolving_standard_contextmanager_as_generic (line 228) | def test_resolving_standard_contextmanager_as_generic(
  function test_resolving_standard_re_match_bytes_as_generic (line 235) | def test_resolving_standard_re_match_bytes_as_generic(x: re.Match[bytes]):
  function test_resolving_standard_re_match_str_as_generic (line 241) | def test_resolving_standard_re_match_str_as_generic(x: re.Match[str]):
  function test_resolving_standard_re_pattern_bytes_as_generic (line 247) | def test_resolving_standard_re_pattern_bytes_as_generic(x: re.Pattern[by...
  function test_resolving_standard_re_pattern_str_as_generic (line 253) | def test_resolving_standard_re_pattern_str_as_generic(x: re.Pattern[str]):

FILE: hypothesis-python/tests/cover/test_lookup_py38.py
  function test_typing_Final (line 35) | def test_typing_Final(data):
  function test_typing_Literal (line 41) | def test_typing_Literal(value):
  function test_typing_Literal_nested (line 46) | def test_typing_Literal_nested(data):
  class A (line 60) | class A(typing.TypedDict):
  function test_simple_typeddict (line 65) | def test_simple_typeddict(value):
  class B (line 71) | class B(A, total=False):
  function test_typeddict_with_optional (line 77) | def test_typeddict_with_optional(value):
  function test_simple_optional_key_is_optional (line 85) | def test_simple_optional_key_is_optional():
  class C (line 91) | class C(B):
  function test_typeddict_with_optional_then_required_again (line 97) | def test_typeddict_with_optional_then_required_again(value):
  class NestedDict (line 106) | class NestedDict(typing.TypedDict):
  function test_typeddict_with_nested_value (line 111) | def test_typeddict_with_nested_value(value):
  function test_layered_optional_key_is_optional (line 117) | def test_layered_optional_key_is_optional():
  class Node (line 124) | class Node:
  function test_can_resolve_recursive_dataclass (line 134) | def test_can_resolve_recursive_dataclass(val):
  function test_can_register_new_type_for_typeddicts (line 138) | def test_can_register_new_type_for_typeddicts():
  function test_posonly_lambda_formatting (line 151) | def test_posonly_lambda_formatting(lam, source):
  function test_does_not_convert_posonly_to_keyword (line 156) | def test_does_not_convert_posonly_to_keyword():
  function test_given_works_with_keyword_only_params (line 163) | def test_given_works_with_keyword_only_params(*, x):
  function test_given_works_with_keyword_only_params_some_unbound (line 167) | def test_given_works_with_keyword_only_params_some_unbound():
  function test_given_works_with_positional_only_params (line 175) | def test_given_works_with_positional_only_params():
  function test_cannot_pass_strategies_by_position_if_there_are_posonly_args (line 183) | def test_cannot_pass_strategies_by_position_if_there_are_posonly_args():
  function test_cannot_pass_strategies_for_posonly_args (line 194) | def test_cannot_pass_strategies_for_posonly_args(x, /):
  function has_posonly_args (line 199) | def has_posonly_args(x, /, y):
  function test_example_argument_validation (line 211) | def test_example_argument_validation():
  class FooProtocol (line 233) | class FooProtocol(typing.Protocol):
    method frozzle (line 234) | def frozzle(self, x):
  class BarProtocol (line 238) | class BarProtocol(typing.Protocol):
    method bazzle (line 239) | def bazzle(self, y):
  function test_can_resolve_registered_protocol (line 244) | def test_can_resolve_registered_protocol(data):
  function test_cannot_resolve_un_registered_protocol (line 253) | def test_cannot_resolve_un_registered_protocol():

FILE: hypothesis-python/tests/cover/test_lookup_py39.py
  function test_typing_Annotated (line 46) | def test_typing_Annotated(annotated_type, expected_strategy_repr):
  function arg_positive (line 56) | def arg_positive(x: PositiveInt):
  function arg_more_than_ten (line 60) | def arg_more_than_ten(x: MoreThanTenInt):
  function test_annotated_positive_int (line 65) | def test_annotated_positive_int(data):
  function test_annotated_more_than_ten (line 70) | def test_annotated_more_than_ten(data):
  function test_annotated_with_two_strategies (line 75) | def test_annotated_with_two_strategies(data):
  function test_annotated_extra_metadata (line 80) | def test_annotated_extra_metadata(data):
  class User (line 85) | class User:
  function test_string_forward_ref_message (line 91) | def test_string_forward_ref_message():
  function test_issue_3080 (line 99) | def test_issue_3080(typ):
  class TypingTuple (line 107) | class TypingTuple:
  class BuiltinTuple (line 112) | class BuiltinTuple:
  function test_from_type_with_tuple_works (line 121) | def test_from_type_with_tuple_works(data, data_class: TestDataClass):
  function _shorter_lists (line 126) | def _shorter_lists(list_type):
  function test_can_register_builtin_list (line 130) | def test_can_register_builtin_list():
  class Fooable (line 143) | class Fooable(typing.Protocol[T]):
    method foo (line 144) | def foo(self): ...
  class FooableConcrete (line 147) | class FooableConcrete(tuple):
    method foo (line 148) | def foo(self):
  function test_only_tuple_subclasses_in_typing_type (line 152) | def test_only_tuple_subclasses_in_typing_type():
  function test_lookup_registered_tuple (line 162) | def test_lookup_registered_tuple():
  class LazyStrategyAnnotation (line 173) | class LazyStrategyAnnotation:
    method __iter__ (line 176) | def __iter__(self):
  function test_grouped_protocol_strategy (line 181) | def test_grouped_protocol_strategy(x: typing.Annotated[int, LazyStrategy...
  function test_collections_abc_callable_none (line 185) | def test_collections_abc_callable_none():

FILE: hypothesis-python/tests/cover/test_map.py
  function test_can_assume_in_map (line 18) | def test_can_assume_in_map(x):
  function test_assume_in_just_raises_immediately (line 22) | def test_assume_in_just_raises_immediately():
  function test_identity_map_is_noop (line 26) | def test_identity_map_is_noop():

FILE: hypothesis-python/tests/cover/test_mock.py
  function test_can_mock_inside_given_without_fixture (line 33) | def test_can_mock_inside_given_without_fixture(atan, thing):
  function test_can_mock_outside_given_with_fixture (line 40) | def test_can_mock_outside_given_with_fixture(atan, pytestconfig, thing):
  function test_can_mock_within_test_with_fixture (line 47) | def test_can_mock_within_test_with_fixture(pytestconfig, thing):

FILE: hypothesis-python/tests/cover/test_monitoring.py
  function using_tool_id (line 22) | def using_tool_id(tool_id, tool_name):
  function test_monitoring_warns_on_registered_tool_id (line 31) | def test_monitoring_warns_on_registered_tool_id(warns_or_raises):

FILE: hypothesis-python/tests/cover/test_nothing.py
  function test_resampling (line 19) | def test_resampling():
  function test_list_of_nothing (line 30) | def test_list_of_nothing(xs):
  function test_set_of_nothing (line 35) | def test_set_of_nothing(xs):
  function test_validates_min_size (line 39) | def test_validates_min_size():
  function test_function_composition (line 44) | def test_function_composition():
  function test_tuples_detect_empty_elements (line 50) | def test_tuples_detect_empty_elements():
  function test_fixed_dictionaries_detect_empty_values (line 54) | def test_fixed_dictionaries_detect_empty_values():
  function test_no_examples (line 58) | def test_no_examples():
  function test_empty (line 71) | def test_empty(s):

FILE: hypothesis-python/tests/cover/test_numerics.py
  function test_fuzz_floats_bounds (line 37) | def test_fuzz_floats_bounds(data):
  function test_fuzz_fractions_bounds (line 71) | def test_fuzz_fractions_bounds(data):
  function test_fuzz_decimals_bounds (line 90) | def test_fuzz_decimals_bounds(data):
  function test_all_decimals_can_be_exact_floats (line 115) | def test_all_decimals_can_be_exact_floats():
  function test_fraction_addition_is_well_behaved (line 122) | def test_fraction_addition_is_well_behaved(x, y, z):
  function test_decimals_include_nan (line 126) | def test_decimals_include_nan():
  function test_decimals_include_inf (line 130) | def test_decimals_include_inf():
  function test_decimals_can_disallow_nan (line 135) | def test_decimals_can_disallow_nan(x):
  function test_decimals_can_disallow_inf (line 140) | def test_decimals_can_disallow_inf(x):
  function test_decimals_have_correct_places (line 145) | def test_decimals_have_correct_places(places):
  function test_works_with_few_values (line 154) | def test_works_with_few_values(dec):
  function test_issue_725_regression (line 159) | def test_issue_725_regression(x):
  function test_issue_739_regression (line 164) | def test_issue_739_regression(x):
  function test_consistent_decimal_error (line 168) | def test_consistent_decimal_error():
  function test_floats_message (line 202) | def test_floats_message(s, msg):
  function test_minimal_nonfinite_decimal_is_inf (line 209) | def test_minimal_nonfinite_decimal_is_inf(s):
  function test_decimals_warns_for_inexact_numeric_bounds (line 214) | def test_decimals_warns_for_inexact_numeric_bounds():

FILE: hypothesis-python/tests/cover/test_observability.py
  function do_it_all (line 77) | def do_it_all(l, a, x, data):
  function test_observability (line 89) | def test_observability():
  function test_capture_unnamed_arguments (line 114) | def test_capture_unnamed_arguments():
  function test_failure_includes_explain_phase_comments (line 135) | def test_failure_includes_explain_phase_comments():
  function test_failure_includes_notes (line 162) | def test_failure_includes_notes():
  function test_normal_representation_includes_draws (line 186) | def test_normal_representation_includes_draws():
  function test_capture_named_arguments (line 218) | def test_capture_named_arguments():
  function test_assume_has_status_reason (line 236) | def test_assume_has_status_reason():
  function test_minimal_failing_observation (line 252) | def test_minimal_failing_observation():
  function test_all_failing_observations_have_reproduction_decorator (line 295) | def test_all_failing_observations_have_reproduction_decorator():
  class UltraSimpleMachine (line 313) | class UltraSimpleMachine(RuleBasedStateMachine):
    method inc (line 317) | def inc(self):
    method dec (line 321) | def dec(self):
    method limits (line 325) | def limits(self):
  function test_observability_captures_stateful_reprs (line 330) | def test_observability_captures_stateful_reprs():
  function test_fuzz_one_input_status (line 363) | def test_fuzz_one_input_status(buffer, expected_status):
  function _decode_choice (line 381) | def _decode_choice(value):
  function _decode_choices (line 401) | def _decode_choices(data):
  function _decode_nodes (line 405) | def _decode_nodes(data):
  function _decode_constraints (line 417) | def _decode_constraints(choice_type, data):
  function _has_surrogate (line 453) | def _has_surrogate(choice):
  function test_choices_json_roundtrips (line 471) | def test_choices_json_roundtrips(choices):
  function test_nodes_json_roundtrips (line 478) | def test_nodes_json_roundtrips(nodes):
  function test_choices_to_json_explicit (line 507) | def test_choices_to_json_explicit(choice, expected):
  function test_choice_nodes_to_json_explicit (line 530) | def test_choice_nodes_to_json_explicit(choice_node, expected):
  function test_metadata_to_json (line 534) | def test_metadata_to_json():
  function restore_callbacks (line 571) | def restore_callbacks():
  function with_collect_coverage (line 582) | def with_collect_coverage(*, value: bool):
  function _callbacks (line 593) | def _callbacks():
  function test_observability_callbacks (line 601) | def test_observability_callbacks():
  function test_observability_callbacks_all_threads (line 635) | def test_observability_callbacks_all_threads():
  function test_testcase_callbacks_deprecation_bool (line 666) | def test_testcase_callbacks_deprecation_bool():
  function test_testcase_callbacks_deprecation_append (line 671) | def test_testcase_callbacks_deprecation_append():
  function test_testcase_callbacks_deprecation_remove (line 677) | def test_testcase_callbacks_deprecation_remove():
  function test_testcase_callbacks (line 682) | def test_testcase_callbacks():
  function test_only_receives_callbacks_from_this_thread (line 714) | def test_only_receives_callbacks_from_this_thread():
  function test_all_threads_callback (line 752) | def test_all_threads_callback():

FILE: hypothesis-python/tests/cover/test_one_of.py
  function test_one_of_empty (line 22) | def test_one_of_empty():
  function test_one_of_filtered (line 29) | def test_one_of_filtered(i):
  function test_one_of_flatmapped (line 34) | def test_one_of_flatmapped(i):
  function test_one_of_single_strategy_is_noop (line 38) | def test_one_of_single_strategy_is_noop():
  function test_one_of_without_strategies_suggests_sampled_from (line 44) | def test_one_of_without_strategies_suggests_sampled_from():
  function test_one_of_unwrapping (line 63) | def test_one_of_unwrapping(strategy, count):

FILE: hypothesis-python/tests/cover/test_permutations.py
  function test_can_find_non_trivial_permutation (line 19) | def test_can_find_non_trivial_permutation():
  function test_permutation_values_are_permutations (line 26) | def test_permutation_values_are_permutations(perm):
  function test_empty_permutations_are_empty (line 32) | def test_empty_permutations_are_empty(xs):
  function test_cannot_permute_non_sequence_types (line 37) | def test_cannot_permute_non_sequence_types():

FILE: hypothesis-python/tests/cover/test_phases.py
  function test_only_runs_explicit_examples (line 23) | def test_only_runs_explicit_examples(i):
  function test_does_not_use_explicit_examples (line 30) | def test_does_not_use_explicit_examples(i):
  function test_this_would_fail_if_you_ran_it (line 37) | def test_this_would_fail_if_you_ran_it(b):
  function test_sorts_and_dedupes_phases (line 48) | def test_sorts_and_dedupes_phases(arg, expected):
  function test_phases_default_to_all (line 52) | def test_phases_default_to_all():
  function test_does_not_reuse_saved_examples_if_reuse_not_in_phases (line 56) | def test_does_not_reuse_saved_examples_if_reuse_not_in_phases():
  function test_will_save_when_reuse_not_in_phases (line 78) | def test_will_save_when_reuse_not_in_phases():
  function test_rejects_non_phases (line 95) | def test_rejects_non_phases():

FILE: hypothesis-python/tests/cover/test_posonly_args_py38.py
  function strat (line 17) | def strat(draw, x=0, /):
  function test_composite_with_posonly_args (line 22) | def test_composite_with_posonly_args(data, min_value):
  function test_preserves_signature (line 27) | def test_preserves_signature():
  function test_builds_real_pos_only (line 32) | def test_builds_real_pos_only():

FILE: hypothesis-python/tests/cover/test_pretty.py
  class MyList (line 69) | class MyList:
    method __init__ (line 70) | def __init__(self, content):
    method _repr_pretty_ (line 73) | def _repr_pretty_(self, p, cycle):
  class MyDict (line 87) | class MyDict(dict):
    method _repr_pretty_ (line 88) | def _repr_pretty_(self, p, cycle):
  class MyObj (line 92) | class MyObj:
    method somemethod (line 93) | def somemethod(self):
  class Dummy1 (line 97) | class Dummy1:
    method _repr_pretty_ (line 98) | def _repr_pretty_(self, p, cycle):
  class Dummy2 (line 102) | class Dummy2:
    method __repr__ (line 105) | def __repr__(self):
  class NoModule (line 109) | class NoModule:
  class Breaking (line 116) | class Breaking:
    method _repr_pretty_ (line 117) | def _repr_pretty_(self, p, cycle):
  class BreakingRepr (line 124) | class BreakingRepr:
    method __repr__ (line 125) | def __repr__(self):
  class BreakingReprParent (line 129) | class BreakingReprParent:
    method _repr_pretty_ (line 130) | def _repr_pretty_(self, p, cycle):
  class BadRepr (line 135) | class BadRepr:
    method __repr__ (line 136) | def __repr__(self):
  function test_list (line 140) | def test_list():
  function test_dict (line 145) | def test_dict():
  function test_tuple (line 157) | def test_tuple():
  class ReprDict (line 163) | class ReprDict(dict):
    method __repr__ (line 164) | def __repr__(self):
  function test_dict_with_custom_repr (line 168) | def test_dict_with_custom_repr():
  class ReprList (line 172) | class ReprList(list):
    method __repr__ (line 173) | def __repr__(self):
  class ReprSet (line 177) | class ReprSet(set):
    method __repr__ (line 178) | def __repr__(self):
  function test_set_with_custom_repr (line 182) | def test_set_with_custom_repr():
  function test_list_with_custom_repr (line 186) | def test_list_with_custom_repr():
  function test_indentation (line 190) | def test_indentation():
  function test_dispatch (line 199) | def test_dispatch():
  function test_callability_checking (line 208) | def test_callability_checking():
  function test_sets (line 217) | def test_sets():
  function test_unsortable_set (line 242) | def test_unsortable_set():
  function test_unsortable_dict (line 249) | def test_unsortable_dict():
  function test_pprint_nomod (line 256) | def test_pprint_nomod():
  function test_pprint_break (line 262) | def test_pprint_break():
  function test_pprint_break_repr (line 269) | def test_pprint_break_repr():
  function test_bad_repr (line 276) | def test_bad_repr():
  class BadException (line 282) | class BadException(Exception):
    method __str__ (line 283) | def __str__(self):
  class ReallyBadRepr (line 287) | class ReallyBadRepr:
    method __class__ (line 291) | def __class__(self):
    method __repr__ (line 294) | def __repr__(self):
  function test_really_bad_repr (line 298) | def test_really_bad_repr():
  class SA (line 303) | class SA:
  class SB (line 307) | class SB(SA):
  function test_super_repr (line 314) | def test_super_repr():
  function test_super_repr (line 324) | def test_super_repr():
  function test_long_list (line 330) | def test_long_list():
  function test_long_set (line 337) | def test_long_set():
  function test_long_tuple (line 344) | def test_long_tuple():
  function test_long_dict (line 351) | def test_long_dict():
  function test_unbound_method (line 358) | def test_unbound_method():
  class MetaClass (line 362) | class MetaClass(type):
    method __new__ (line 363) | def __new__(metacls, name):
    method __repr__ (line 366) | def __repr__(cls):
  function test_metaclass_repr (line 373) | def test_metaclass_repr():
  function test_unicode_repr (line 378) | def test_unicode_repr():
  function test_basic_class (line 392) | def test_basic_class():
  function test_collections_defaultdict (line 409) | def test_collections_defaultdict():
  function test_collections_ordereddict (line 433) | def test_collections_ordereddict():
  function test_collections_deque (line 459) | def test_collections_deque():
  function test_collections_counter (line 496) | def test_collections_counter():
  function test_cyclic_list (line 509) | def test_cyclic_list():
  function test_cyclic_dequeue (line 515) | def test_cyclic_dequeue():
  class HashItAnyway (line 521) | class HashItAnyway:
    method __init__ (line 522) | def __init__(self, value):
    method __hash__ (line 525) | def __hash__(self):
    method __eq__ (line 528) | def __eq__(self, other):
    method __ne__ (line 531) | def __ne__(self, other):
    method _repr_pretty_ (line 534) | def _repr_pretty_(self, pretty, cycle):
  function test_cyclic_counter (line 538) | def test_cyclic_counter():
  function test_cyclic_dict (line 545) | def test_cyclic_dict():
  function test_cyclic_set (line 552) | def test_cyclic_set():
  class BigList (line 558) | class BigList(list):
    method _repr_pretty_ (line 559) | def _repr_pretty_(self, printer, cycle):
  function test_print_with_indent (line 569) | def test_print_with_indent():
  class MyException (line 573) | class MyException(Exception):
  function test_exception (line 577) | def test_exception():
  function test_re_evals (line 583) | def test_re_evals():
  function test_print_builtin_function (line 595) | def test_print_builtin_function():
  function test_pretty_function (line 599) | def test_pretty_function():
  function test_breakable_at_group_boundary (line 603) | def test_breakable_at_group_boundary():
  function test_nan_reprs (line 616) | def test_nan_reprs(obj, rep):
  function _repr_call (line 623) | def _repr_call(*args, **kwargs):
  function test_repr_call (line 630) | def test_repr_call(func_name):
  class AnEnum (line 639) | class AnEnum(Enum):
  class Options (line 643) | class Options(Flag):
  class EvilReprOptions (line 649) | class EvilReprOptions(Flag):
    method __repr__ (line 653) | def __repr__(self):
  class LyingReprOptions (line 657) | class LyingReprOptions(Flag):
    method __repr__ (line 661) | def __repr__(self):
  function test_pretty_prints_enums_as_code (line 679) | def test_pretty_prints_enums_as_code(rep):
  class Obj (line 683) | class Obj:
    method _repr_pretty_ (line 684) | def _repr_pretty_(self, p, cycle):
  function test_supports_ipython_callback (line 695) | def test_supports_ipython_callback():
  function test_pretty_partial_with_cycle (line 699) | def test_pretty_partial_with_cycle():
  class InvalidSyntaxRepr (line 707) | class InvalidSyntaxRepr:
    method __init__ (line 708) | def __init__(self, val=None) -> None:
    method __repr__ (line 711) | def __repr__(self):
  class ValidSyntaxRepr (line 715) | class ValidSyntaxRepr:
    method __init__ (line 716) | def __init__(self, val=None) -> None:
    method __repr__ (line 719) | def __repr__(self):
  function test_pprint_with_call_or_repr_as_call (line 724) | def test_pprint_with_call_or_repr_as_call(data):
  function test_pprint_with_call_or_repr_as_repr (line 736) | def test_pprint_with_call_or_repr_as_repr(x):
  function test_pprint_map_with_cycle (line 743) | def test_pprint_map_with_cycle(data):
  function test_pprint_large_integers (line 752) | def test_pprint_large_integers():
  function test_pprint_extremely_large_integers (line 758) | def test_pprint_extremely_large_integers():
  class ReprDetector (line 767) | class ReprDetector:
    method _repr_pretty_ (line 768) | def _repr_pretty_(self, p, cycle):
    method __repr__ (line 772) | def __repr__(self):
  class SomeDataClass (line 777) | class SomeDataClass:
  function test_pretty_prints_data_classes (line 781) | def test_pretty_prints_data_classes():
  function test_handles_cycles_in_dataclass (line 785) | def test_handles_cycles_in_dataclass():
  class DataClassWithNoInitField (line 793) | class DataClassWithNoInitField:
  function test_does_not_include_no_init_fields_in_dataclass_printing (line 798) | def test_does_not_include_no_init_fields_in_dataclass_printing():
  class Namespace (line 805) | class Namespace:
    class DC (line 807) | class DC:
    class E (line 810) | class E(Enum):
  function test_includes_namespace_classes_in_pretty (line 821) | def test_includes_namespace_classes_in_pretty(obj):
  class Banana (line 825) | class Banana:
    method _repr_pretty_ (line 826) | def _repr_pretty_(self, p, cycle):
  class InheritsPretty (line 831) | class InheritsPretty(Banana):
  function test_uses_defined_pretty_printing_method (line 836) | def test_uses_defined_pretty_printing_method():
  function test_prefers_singleton_printing_to_repr_pretty (line 840) | def test_prefers_singleton_printing_to_repr_pretty():
  function test_tuple_pprinter_cycle (line 851) | def test_tuple_pprinter_cycle():
  function test_fixeddict_pprinter_cycle (line 868) | def test_fixeddict_pprinter_cycle():
  function test_get_slice_comment_skips_already_commented (line 886) | def test_get_slice_comment_skips_already_commented():

FILE: hypothesis-python/tests/cover/test_provisional_strategies.py
  function test_is_URL (line 29) | def test_is_URL(url):
  function test_invalid_domain_arguments (line 52) | def test_invalid_domain_arguments(max_length, max_element_length):
  function test_valid_domains_arguments (line 65) | def test_valid_domains_arguments(max_length, max_element_length):
  function test_find_any_non_empty (line 72) | def test_find_any_non_empty(strategy):
  function test_url_fragments_contain_legal_chars (line 81) | def test_url_fragments_contain_legal_chars(fragment):

FILE: hypothesis-python/tests/cover/test_random_module.py
  function gc_collect (line 34) | def gc_collect():
  function test_can_seed_random (line 44) | def test_can_seed_random():
  function test_seed_random_twice (line 56) | def test_seed_random_twice(r, r2):
  function test_does_not_fail_health_check_if_randomness_is_used (line 68) | def test_does_not_fail_health_check_if_randomness_is_used(r):
  function test_cannot_register_non_Random (line 72) | def test_cannot_register_non_Random():
  function test_registering_a_Random_is_idempotent (line 78) | def test_registering_a_Random_is_idempotent():
  function test_manages_registered_Random_instance (line 99) | def test_manages_registered_Random_instance():
  function test_registered_Random_is_seeded_by_random_module_strategy (line 117) | def test_registered_Random_is_seeded_by_random_module_strategy():
  function test_will_actually_use_the_random_seed (line 137) | def test_will_actually_use_the_random_seed(rnd):
  function test_given_does_not_pollute_state (line 145) | def test_given_does_not_pollute_state():
  function test_find_does_not_pollute_state (line 165) | def test_find_does_not_pollute_state():
  function test_evil_prng_registration_nonsense (line 180) | def test_evil_prng_registration_nonsense():
  function test_passing_unreferenced_instance_raises (line 227) | def test_passing_unreferenced_instance_raises():
  function test_passing_unreferenced_instance_within_function_scope_raises (line 236) | def test_passing_unreferenced_instance_within_function_scope_raises():
  function test_passing_referenced_instance_within_function_scope_raises (line 267) | def test_passing_referenced_instance_within_function_scope_raises():
  function test_register_random_within_nested_function_scope (line 283) | def test_register_random_within_nested_function_scope():

FILE: hypothesis-python/tests/cover/test_randoms.py
  function test_implements_all_random_methods (line 33) | def test_implements_all_random_methods():
  function define_method_strategy (line 50) | def define_method_strategy(name, **kwargs):
  function any_call_of_method (line 83) | def any_call_of_method(draw, method):
  function any_call (line 120) | def any_call(draw):
  function test_call_all_methods (line 127) | def test_call_all_methods(method, rnd, data):
  function test_rand_below (line 133) | def test_rand_below(rnd, n):
  function test_beta_in_range (line 138) | def test_beta_in_range(rnd, a, b):
  function test_multiple_randoms_are_unrelated (line 142) | def test_multiple_randoms_are_unrelated():
  function test_randoms_can_be_synced (line 153) | def test_randoms_can_be_synced(use_true_random, data):
  function test_seeding_to_same_value_synchronizes (line 162) | def test_seeding_to_same_value_synchronizes(use_true_random, data, metho...
  function test_copying_synchronizes (line 172) | def test_copying_synchronizes(r1, method_call):
  function test_seeding_to_different_values_does_not_synchronize (line 180) | def test_seeding_to_different_values_does_not_synchronize(use_true_random):
  function test_unrelated_calls_desynchronizes (line 196) | def test_unrelated_calls_desynchronizes(use_true_random):
  function test_state_is_consistent (line 213) | def test_state_is_consistent(r1, r2):
  function test_does_not_use_true_random_by_default (line 219) | def test_does_not_use_true_random_by_default(rnd):
  function test_handles_singleton_uniforms_correctly (line 224) | def test_handles_singleton_uniforms_correctly(rnd):
  function test_handles_singleton_regions_of_triangular_correctly (line 232) | def test_handles_singleton_regions_of_triangular_correctly(rnd):
  function test_triangular_with_mode (line 240) | def test_triangular_with_mode(rnd):
  function test_outputs_random_calls (line 246) | def test_outputs_random_calls(use_true_random):
  function test_converts_kwargs_correctly_in_output (line 262) | def test_converts_kwargs_correctly_in_output(use_true_random):
  function test_some_ranges_are_in_range (line 274) | def test_some_ranges_are_in_range(rnd):
  function test_invalid_range (line 281) | def test_invalid_range():
  function test_invalid_sample (line 290) | def test_invalid_sample():
  function test_triangular_modes (line 299) | def test_triangular_modes():
  function test_samples_have_right_length (line 312) | def test_samples_have_right_length(rnd, sample):
  function test_choices_have_right_length (line 318) | def test_choices_have_right_length(rnd, choices):
  function test_randbytes_have_right_length (line 327) | def test_randbytes_have_right_length(rnd, n):
  function test_can_manage_very_long_ranges_with_step (line 336) | def test_can_manage_very_long_ranges_with_step(rnd):
  function test_range_with_arbitrary_step_is_in_range (line 346) | def test_range_with_arbitrary_step_is_in_range(rnd, data):
  function test_range_with_only_stop (line 356) | def test_range_with_only_stop(rnd, n):
  function test_can_find_end_of_range (line 360) | def test_can_find_end_of_range():
  function test_can_sample_from_whole_range (line 372) | def test_can_sample_from_whole_range(rnd):
  function test_can_sample_from_large_subset (line 379) | def test_can_sample_from_large_subset(rnd):
  function test_can_draw_empty_from_empty_sequence (line 388) | def test_can_draw_empty_from_empty_sequence(rnd):
  function test_random_includes_zero_excludes_one (line 392) | def test_random_includes_zero_excludes_one():
  function test_betavariate_includes_zero_and_one (line 398) | def test_betavariate_includes_zero_and_one():
  function test_artificial_random_with_already_initialized_states_for_ids (line 410) | def test_artificial_random_with_already_initialized_states_for_ids():

FILE: hypothesis-python/tests/cover/test_recursive.py
  function test_respects_leaf_limit (line 27) | def test_respects_leaf_limit(xs):
  function test_can_find_nested (line 37) | def test_can_find_nested():
  function test_recursive_call_validates_expand_returns_strategies (line 46) | def test_recursive_call_validates_expand_returns_strategies():
  function test_recursive_call_validates_base_is_strategy (line 51) | def test_recursive_call_validates_base_is_strategy():
  function test_can_find_exactly_max_leaves (line 57) | def test_can_find_exactly_max_leaves():
  function test_can_exclude_branching_with_max_leaves (line 76) | def test_can_exclude_branching_with_max_leaves(t):
  function test_issue_1502_regression (line 81) | def test_issue_1502_regression(s):
  function test_recursive_can_generate_varied_structures (line 85) | def test_recursive_can_generate_varied_structures():
  function test_recursive_can_generate_varied_structures_without_using_leaves (line 96) | def test_recursive_can_generate_varied_structures_without_using_leaves():
  function test_invalid_args (line 122) | def test_invalid_args(s):
  function _count_leaves (line 127) | def _count_leaves(tree):
  function test_respects_min_leaves (line 135) | def test_respects_min_leaves(data):
  function test_can_set_exact_leaf_count (line 151) | def test_can_set_exact_leaf_count(tree):
  function test_identity_extend_warns (line 155) | def test_identity_extend_warns():

FILE: hypothesis-python/tests/cover/test_reflection.py
  function do_conversion_test (line 43) | def do_conversion_test(f, args, kwargs):
  function test_simple_conversion (line 53) | def test_simple_conversion():
  function test_leaves_unknown_kwargs_in_dict (line 67) | def test_leaves_unknown_kwargs_in_dict():
  function test_errors_on_bad_kwargs (line 80) | def test_errors_on_bad_kwargs():
  function test_passes_varargs_correctly (line 88) | def test_passes_varargs_correctly():
  function test_errors_if_keyword_precedes_positional (line 97) | def test_errors_if_keyword_precedes_positional():
  function test_errors_if_not_enough_args (line 105) | def test_errors_if_not_enough_args():
  function test_errors_on_extra_kwargs (line 113) | def test_errors_on_extra_kwargs():
  function test_positional_errors_if_too_many_args (line 124) | def test_positional_errors_if_too_many_args():
  function test_positional_errors_if_too_few_args (line 132) | def test_positional_errors_if_too_few_args():
  function test_positional_does_not_error_if_extra_args_are_kwargs (line 140) | def test_positional_does_not_error_if_extra_args_are_kwargs():
  function test_positional_errors_if_given_bad_kwargs (line 147) | def test_positional_errors_if_given_bad_kwargs():
  function test_positional_errors_if_given_duplicate_kwargs (line 155) | def test_positional_errors_if_given_duplicate_kwargs():
  function test_names_of_functions_are_pretty (line 163) | def test_names_of_functions_are_pretty():
  class Foo (line 170) | class Foo:
    method bar (line 172) | def bar(cls):
    method baz (line 175) | def baz(cls):
    method __repr__ (line 178) | def __repr__(self):
  function test_class_names_are_not_included_in_class_method_prettiness (line 182) | def test_class_names_are_not_included_in_class_method_prettiness():
  function test_repr_is_included_in_bound_method_prettiness (line 186) | def test_repr_is_included_in_bound_method_prettiness():
  function test_class_is_not_included_in_unbound_method (line 190) | def test_class_is_not_included_in_unbound_method():
  function test_does_not_error_on_confused_sources (line 194) | def test_does_not_error_on_confused_sources():
  function test_digests_are_reasonably_unique (line 207) | def test_digests_are_reasonably_unique():
  function test_digest_returns_the_same_value_for_two_calls (line 213) | def test_digest_returns_the_same_value_for_two_calls():
  function test_can_digest_a_built_in_function (line 219) | def test_can_digest_a_built_in_function():
  function test_can_digest_a_unicode_lambda (line 225) | def test_can_digest_a_unicode_lambda():
  function test_can_digest_a_function_with_no_name (line 229) | def test_can_digest_a_function_with_no_name():
  function test_arg_string_is_in_order (line 236) | def test_arg_string_is_in_order():
  function test_varkwargs_are_sorted_and_after_real_kwargs (line 247) | def test_varkwargs_are_sorted_and_after_real_kwargs():
  function test_varargs_come_without_equals (line 257) | def test_varargs_come_without_equals():
  function test_can_mix_varargs_and_varkwargs (line 264) | def test_can_mix_varargs_and_varkwargs():
  function test_arg_string_does_not_include_unprovided_defaults (line 271) | def test_arg_string_does_not_include_unprovided_defaults():
  function universal_acceptor (line 278) | def universal_acceptor(*args, **kwargs):
  function has_one_arg (line 282) | def has_one_arg(hello):
  function has_two_args (line 286) | def has_two_args(hello, world):
  function has_a_default (line 290) | def has_a_default(x, y, z=1):
  function has_varargs (line 294) | def has_varargs(*args):
  function has_kwargs (line 298) | def has_kwargs(**kwargs):
  function test_copying_preserves_signature (line 303) | def test_copying_preserves_signature(f):
  function test_name_does_not_clash_with_function_names (line 310) | def test_name_does_not_clash_with_function_names():
  function test_copying_sets_name (line 321) | def test_copying_sets_name():
  function test_copying_sets_docstring (line 328) | def test_copying_sets_docstring():
  function test_uses_defaults (line 335) | def test_uses_defaults():
  function test_uses_varargs (line 342) | def test_uses_varargs():
  function test_exec_as_module_execs (line 355) | def test_exec_as_module_execs():
  function test_exec_as_module_caches (line 360) | def test_exec_as_module_caches():
  function test_exec_leaves_sys_path_unchanged (line 366) | def test_exec_leaves_sys_path_unchanged():
  function test_define_function_signature_works_with_conflicts (line 372) | def test_define_function_signature_works_with_conflicts():
  function test_define_function_signature_validates_function_name (line 408) | def test_define_function_signature_validates_function_name():
  class Container (line 414) | class Container:
    method funcy (line 415) | def funcy(self):
  function test_can_proxy_functions_with_mixed_args_and_varargs (line 419) | def test_can_proxy_functions_with_mixed_args_and_varargs():
  function test_can_delegate_to_a_function_with_no_positional_args (line 430) | def test_can_delegate_to_a_function_with_no_positional_args():
  function test_can_proxy_lambdas (line 449) | def test_can_proxy_lambdas(func, args, expected):
  class Snowman (line 458) | class Snowman:
    method __repr__ (line 459) | def __repr__(self):
  class BittySnowman (line 463) | class BittySnowman:
    method __repr__ (line 464) | def __repr__(self):
  function test_can_handle_unicode_repr (line 468) | def test_can_handle_unicode_repr():
  class NoRepr (line 476) | class NoRepr:
  function test_can_handle_repr_on_type (line 480) | def test_can_handle_repr_on_type():
  function test_can_handle_repr_of_none (line 488) | def test_can_handle_repr_of_none():
  function test_kwargs_appear_in_arg_string (line 496) | def test_kwargs_appear_in_arg_string():
  function test_is_mock_with_negative_cases (line 503) | def test_is_mock_with_negative_cases():
  function test_is_mock_with_positive_cases (line 513) | def test_is_mock_with_positive_cases():
  class Target (line 520) | class Target:
    method __init__ (line 521) | def __init__(self, a, b):
    method method (line 524) | def method(self, a, b):
  function test_required_args (line 540) | def test_required_args(target, args, kwargs, expected):
  function test_can_handle_unicode_identifier_in_same_line_as_lambda_def (line 545) | def test_can_handle_unicode_identifier_in_same_line_as_lambda_def():
  function test_too_many_posargs_fails (line 552) | def test_too_many_posargs_fails():
  function test_overlapping_posarg_kwarg_fails (line 557) | def test_overlapping_posarg_kwarg_fails():
  function test_inline_given_handles_self (line 562) | def test_inline_given_handles_self():
  function logged (line 573) | def logged(f):
  class Bar (line 581) | class Bar:
    method __init__ (line 583) | def __init__(self, i: int):
  function test_issue_2495_regression (line 588) | def test_issue_2495_regression(_):
  function test_error_on_keyword_parameter_name (line 596) | def test_error_on_keyword_parameter_name():
  function test_param_is_called_within_func (line 609) | def test_param_is_called_within_func():
  function test_param_is_called_within_subfunc (line 616) | def test_param_is_called_within_subfunc():
  function test_param_is_not_called_within_func (line 624) | def test_param_is_not_called_within_func():
  function test_param_called_within_defaults_on_error (line 631) | def test_param_called_within_defaults_on_error():
  function _prep_source (line 637) | def _prep_source(*pairs):
  function test_clean_source (line 683) | def test_clean_source(src, clean):
  function test_overlong_repr_warns (line 687) | def test_overlong_repr_warns():
  function identity (line 692) | def identity(x):
  class Identity (line 696) | class Identity:
    method __call__ (line 697) | def __call__(self, x):
    method instance_identity (line 700) | def instance_identity(self, x):
    method instance_self (line 703) | def instance_self(self):
    method static_identity (line 707) | def static_identity(x):
    method class_identity (line 711) | def class_identity(cls, x):
  function test_is_identity (line 726) | def test_is_identity(f):
  function test_is_not_identity (line 734) | def test_is_not_identity(f):
  function test_is_unrecognized_identity (line 750) | def test_is_unrecognized_identity(f):
  function test_cache_key_size_is_bounded (line 754) | def test_cache_key_size_is_bounded():
  function test_function_key_distinguishes_alpha_renames (line 764) | def test_function_key_distinguishes_alpha_renames():
  function test_import (line 772) | def test_import():
  function test_code_normalization (line 780) | def test_code_normalization(nop_on_f):
  function test_lambda_mimicry_with_arg_defaults (line 812) | def test_lambda_mimicry_with_arg_defaults(f, source):

FILE: hypothesis-python/tests/cover/test_regex.py
  function is_ascii (line 38) | def is_ascii(s):
  function is_digit (line 42) | def is_digit(s):
  function is_space (line 46) | def is_space(s):
  function is_unicode_space (line 50) | def is_unicode_space(s):
  function is_word (line 57) | def is_word(s):
  function ascii_regex (line 63) | def ascii_regex(pattern):
  function unicode_regex (line 67) | def unicode_regex(pattern):
  function _test_matching_pattern (line 71) | def _test_matching_pattern(pattern, *, isvalidchar, is_unicode=False):
  function test_matching (line 91) | def test_matching(category, predicate, invert, is_unicode):
  function test_can_generate (line 146) | def test_can_generate(pattern, encode):
  function test_literals_with_ignorecase (line 166) | def test_literals_with_ignorecase(pattern):
  function test_not_literal_with_ignorecase (line 176) | def test_not_literal_with_ignorecase(pattern):
  function test_any_doesnt_generate_newline (line 183) | def test_any_doesnt_generate_newline():
  function test_any_with_dotall_generate_newline (line 188) | def test_any_with_dotall_generate_newline(pattern):
  function test_any_with_dotall_generate_newline_binary (line 193) | def test_any_with_dotall_generate_newline_binary(pattern):
  function test_groups (line 207) | def test_groups(pattern, is_unicode, invert):
  function test_caret_in_the_middle_does_not_generate_anything (line 235) | def test_caret_in_the_middle_does_not_generate_anything():
  function test_end_with_terminator_does_not_pad (line 241) | def test_end_with_terminator_does_not_pad():
  function test_end (line 245) | def test_end():
  function test_groupref_exists (line 252) | def test_groupref_exists():
  function test_impossible_negative_lookahead (line 261) | def test_impossible_negative_lookahead():
  function test_can_handle_boundaries_nested (line 266) | def test_can_handle_boundaries_nested(s):
  function test_groupref_not_shared_between_regex (line 270) | def test_groupref_not_shared_between_regex():
  function test_group_ref_is_not_shared_between_identical_regex (line 283) | def test_group_ref_is_not_shared_between_identical_regex(data):
  function test_does_not_leak_groups (line 293) | def test_does_not_leak_groups(data):
  function test_positive_lookbehind (line 302) | def test_positive_lookbehind():
  function test_positive_lookahead (line 306) | def test_positive_lookahead():
  function test_negative_lookbehind (line 310) | def test_negative_lookbehind():
  function test_negative_lookahead (line 318) | def test_negative_lookahead():
  function test_generates_only_the_provided_characters_given_boundaries (line 327) | def test_generates_only_the_provided_characters_given_boundaries(xs):
  function test_group_backref_may_not_be_present (line 332) | def test_group_backref_may_not_be_present(s):
  function test_subpattern_flags (line 337) | def test_subpattern_flags():
  function test_can_handle_binary_regex_which_is_not_ascii (line 349) | def test_can_handle_binary_regex_which_is_not_ascii():
  function test_regex_have_same_type_as_pattern (line 355) | def test_regex_have_same_type_as_pattern(pattern):
  function test_can_pad_strings_arbitrarily (line 363) | def test_can_pad_strings_arbitrarily():
  function test_can_pad_empty_strings (line 368) | def test_can_pad_empty_strings():
  function test_can_pad_strings_with_newlines (line 373) | def test_can_pad_strings_with_newlines():
  function test_given_multiline_regex_can_insert_after_dollar (line 378) | def test_given_multiline_regex_can_insert_after_dollar():
  function test_given_multiline_regex_can_insert_before_caret (line 385) | def test_given_multiline_regex_can_insert_before_caret():
  function test_does_not_left_pad_beginning_of_string_marker (line 392) | def test_does_not_left_pad_beginning_of_string_marker():
  function test_bare_caret_can_produce (line 396) | def test_bare_caret_can_produce():
  function test_bare_dollar_can_produce (line 400) | def test_bare_dollar_can_produce():
  function test_shared_union (line 404) | def test_shared_union():
  function test_issue_992_regression (line 412) | def test_issue_992_regression(data):
  function test_fullmatch_generates_example (line 436) | def test_fullmatch_generates_example(pattern, matching_str):
  function test_fullmatch_matches (line 459) | def test_fullmatch_matches(pattern, eqiv_pattern):
  function test_fullmatch_must_be_bool (line 465) | def test_fullmatch_must_be_bool():
  function test_issue_1786_regression (line 470) | def test_issue_1786_regression():
  function test_sets_allow_multichar_output_in_ignorecase_mode (line 474) | def test_sets_allow_multichar_output_in_ignorecase_mode():
  function test_internals_can_disable_newline_from_dollar_for_jsonschema (line 483) | def test_internals_can_disable_newline_from_dollar_for_jsonschema():
  function test_can_pass_union_for_alphabet (line 498) | def test_can_pass_union_for_alphabet(_):

FILE: hypothesis-python/tests/cover/test_regressions.py
  function strat (line 33) | def strat():
  function strat_one (line 38) | def strat_one(draw):
  function strat_two (line 43) | def strat_two(draw):
  function test_issue751 (line 48) | def test_issue751(v):
  function test_can_find_non_zero (line 52) | def test_can_find_non_zero():
  function test_mock_injection (line 67) | def test_mock_injection():
  function test_regression_issue_1230 (line 88) | def test_regression_issue_1230():
  function random_func (line 111) | def random_func(x):
  function test_prng_state_unpolluted_by_given_issue_1266 (line 116) | def test_prng_state_unpolluted_by_given_issue_1266():
  function test_exceptions_are_picklable (line 148) | def test_exceptions_are_picklable(exc):
  function test_no_missed_custom_init_exceptions (line 153) | def test_no_missed_custom_init_exceptions():

FILE: hypothesis-python/tests/cover/test_replay_logic.py
  function test_does_not_shrink_on_replay (line 18) | def test_does_not_shrink_on_replay():
  function test_does_not_shrink_on_replay_with_multiple_bugs (line 56) | def test_does_not_shrink_on_replay_with_multiple_bugs():
  function test_will_always_shrink_if_previous_example_does_not_replay (line 89) | def test_will_always_shrink_if_previous_example_does_not_replay():
  function test_will_shrink_if_the_previous_example_does_not_look_right (line 115) | def test_will_shrink_if_the_previous_example_does_not_look_right():

FILE: hypothesis-python/tests/cover/test_reporting.py
  function test_prints_output_by_default (line 24) | def test_prints_output_by_default():
  function test_does_not_print_debug_in_verbose (line 34) | def test_does_not_print_debug_in_verbose():
  function test_does_print_debug_in_debug (line 45) | def test_does_print_debug_in_debug():
  function test_does_print_verbose_in_debug (line 56) | def test_does_print_verbose_in_debug():
  function test_can_report_when_system_locale_is_ascii (line 67) | def test_can_report_when_system_locale_is_ascii(monkeypatch):

FILE: hypothesis-python/tests/cover/test_reproduce_failure.py
  function test_encoding_loop (line 37) | def test_encoding_loop(nodes):
  function test_decoding_may_fail (line 50) | def test_decoding_may_fail(t):
  function test_invalid_base_64_gives_invalid_argument (line 62) | def test_invalid_base_64_gives_invalid_argument():
  function test_reproduces_the_failure (line 68) | def test_reproduces_the_failure():
  function test_errors_if_provided_example_does_not_reproduce_failure (line 88) | def test_errors_if_provided_example_does_not_reproduce_failure():
  function test_errors_with_did_not_reproduce_if_the_shape_changes (line 101) | def test_errors_with_did_not_reproduce_if_the_shape_changes():
  function test_errors_with_did_not_reproduce_if_rejected (line 114) | def test_errors_with_did_not_reproduce_if_rejected():
  function test_prints_reproduction_if_requested (line 128) | def test_prints_reproduction_if_requested():
  function test_does_not_print_reproduction_for_simple_examples_by_default (line 153) | def test_does_not_print_reproduction_for_simple_examples_by_default():
  function test_does_not_print_reproduction_for_simple_data_examples_by_default (line 164) | def test_does_not_print_reproduction_for_simple_data_examples_by_default():
  function test_does_not_print_reproduction_for_large_data_examples_by_default (line 176) | def test_does_not_print_reproduction_for_large_data_examples_by_default():
  class Foo (line 189) | class Foo:
    method __repr__ (line 190) | def __repr__(self):
  function test_does_not_print_reproduction_if_told_not_to (line 194) | def test_does_not_print_reproduction_if_told_not_to():
  function test_raises_invalid_if_wrong_version (line 206) | def test_raises_invalid_if_wrong_version():
  function test_does_not_print_reproduction_if_verbosity_set_to_quiet (line 219) | def test_does_not_print_reproduction_if_verbosity_set_to_quiet():

FILE: hypothesis-python/tests/cover/test_runner_strategy.py
  function test_cannot_use_without_a_runner (line 20) | def test_cannot_use_without_a_runner():
  function test_cannot_use_in_find_without_default (line 29) | def test_cannot_use_in_find_without_default():
  function test_is_default_in_find (line 34) | def test_is_default_in_find():
  function test_is_default_without_self (line 40) | def test_is_default_without_self(runner):
  class TestStuff (line 44) | class TestStuff(TestCase):
    method test_runner_is_self (line 46) | def test_runner_is_self(self, runner):
    method test_runner_is_self_even_with_default (line 50) | def test_runner_is_self_even_with_default(self, runner):
  class RunnerStateMachine (line 54) | class RunnerStateMachine(RuleBasedStateMachine):
    method step (line 56) | def step(self, runner):

FILE: hypothesis-python/tests/cover/test_sampled_from.py
  function test_cannot_sample_sets (line 48) | def test_cannot_sample_sets():
  function test_can_sample_sequence_without_warning (line 52) | def test_can_sample_sequence_without_warning():
  function test_can_sample_ordereddict_without_warning (line 56) | def test_can_sample_ordereddict_without_warning():
  function test_can_sample_enums (line 61) | def test_can_sample_enums(enum_class):
  function test_unsat_filtered_sampling (line 68) | def test_unsat_filtered_sampling(x):
  function test_unsat_filtered_sampling_in_rejection_stage (line 75) | def test_unsat_filtered_sampling_in_rejection_stage(x):
  function test_easy_filtered_sampling (line 81) | def test_easy_filtered_sampling():
  function test_filtered_sampling_finds_rare_value (line 88) | def test_filtered_sampling_finds_rare_value(x):
  function test_efficient_sets_of_samples (line 93) | def test_efficient_sets_of_samples(x):
  function test_efficient_dicts_with_sampled_keys (line 98) | def test_efficient_dicts_with_sampled_keys(x):
  function test_efficient_lists_of_tuples_first_element_sampled_from (line 110) | def test_efficient_lists_of_tuples_first_element_sampled_from(fn, data):
  function test_does_not_include_duplicates_even_when_duplicated_in_collection (line 117) | def test_does_not_include_duplicates_even_when_duplicated_in_collection(...
  function test_efficient_sets_of_samples_with_chained_transformations (line 130) | def test_efficient_sets_of_samples_with_chained_transformations(x):
  function stupid_sampled_sets (line 135) | def stupid_sampled_sets(draw):
  function test_efficient_sets_of_samples_with_chained_transformations_slow_path (line 144) | def test_efficient_sets_of_samples_with_chained_transformations_slow_pat...
  function test_unsatisfiable_explicit_filteredstrategy_sampled (line 152) | def test_unsatisfiable_explicit_filteredstrategy_sampled(x):
  function test_unsatisfiable_explicit_filteredstrategy_just (line 158) | def test_unsatisfiable_explicit_filteredstrategy_just(x):
  function test_transformed_just_strategy (line 162) | def test_transformed_just_strategy():
  function test_max_size_is_respected_with_unique_sampled_from (line 174) | def test_max_size_is_respected_with_unique_sampled_from(ls):
  function test_issue_2247_regression (line 179) | def test_issue_2247_regression(ls):
  function test_mutability_1 (line 184) | def test_mutability_1(data):
  function test_mutability_2 (line 193) | def test_mutability_2(data):
  class AnnotationsInsteadOfElements (line 201) | class AnnotationsInsteadOfElements(enum.Enum):
  function test_suggests_elements_instead_of_annotations (line 205) | def test_suggests_elements_instead_of_annotations():
  class TestErrorNoteBehavior3819 (line 210) | class TestErrorNoteBehavior3819:
    method direct_without_error (line 215) | def direct_without_error(data):
    method direct_with_non_type_error (line 220) | def direct_with_non_type_error(data):
    method direct_with_type_error_without_substring (line 226) | def direct_with_type_error_without_substring(data):
    method direct_with_type_error_with_substring_but_not_all_strategies (line 232) | def direct_with_type_error_with_substring_but_not_all_strategies(data):
    method direct_all_strategies_with_type_error_with_substring (line 238) | def direct_all_strategies_with_type_error_with_substring(data):
    method indirect_without_error (line 244) | def indirect_without_error(_):
    method indirect_with_non_type_error (line 249) | def indirect_with_non_type_error(_):
    method indirect_with_type_error_without_substring (line 254) | def indirect_with_type_error_without_substring(_):
    method indirect_with_type_error_with_substring_but_not_all_strategies (line 259) | def indirect_with_type_error_with_substring_but_not_all_strategies(_):
    method indirect_all_strategies_with_type_error_with_substring (line 264) | def indirect_all_strategies_with_type_error_with_substring(objs):
    method test_error_appropriate_error_note_3819 (line 303) | def test_error_appropriate_error_note_3819(

FILE: hypothesis-python/tests/cover/test_searchstrategy.py
  function test_or_errors_when_given_non_strategy (line 31) | def test_or_errors_when_given_non_strategy():
  function last (line 40) | def last(xs):
  function test_just_strategy_uses_repr (line 47) | def test_just_strategy_uses_repr():
  function test_just_strategy_does_not_draw (line 55) | def test_just_strategy_does_not_draw():
  function test_none_strategy_does_not_draw (line 61) | def test_none_strategy_does_not_draw():
  function test_can_map (line 67) | def test_can_map():
  function test_example_raises_unsatisfiable_when_too_filtered (line 72) | def test_example_raises_unsatisfiable_when_too_filtered():
  function nameless_const (line 77) | def nameless_const(x):
  function test_can_map_nameless (line 84) | def test_can_map_nameless():
  function test_can_flatmap_nameless (line 89) | def test_can_flatmap_nameless():
  function test_flatmap_with_invalid_expand (line 94) | def test_flatmap_with_invalid_expand():
  function test_use_of_global_random_is_deprecated_in_given (line 103) | def test_use_of_global_random_is_deprecated_in_given():
  function test_use_of_global_random_is_deprecated_in_interactive_draws (line 108) | def test_use_of_global_random_is_deprecated_in_interactive_draws():
  function test_jsonable (line 116) | def test_jsonable():
  class HasDefaultDict (line 122) | class HasDefaultDict:
  function test_jsonable_defaultdict (line 126) | def test_jsonable_defaultdict():
  function test_jsonable_namedtuple (line 132) | def test_jsonable_namedtuple():
  function test_jsonable_small_ints_are_ints (line 138) | def test_jsonable_small_ints_are_ints():
  function test_jsonable_large_ints_are_floats (line 145) | def test_jsonable_large_ints_are_floats():
  function test_jsonable_very_large_ints (line 152) | def test_jsonable_very_large_ints():
  class HasCustomJsonFormat (line 160) | class HasCustomJsonFormat:
    method to_json (line 163) | def to_json(self):
  function test_jsonable_override (line 167) | def test_jsonable_override():
  class Inner (line 174) | class Inner:
    method to_json (line 177) | def to_json(self):
  class Outer (line 182) | class Outer:
  function test_jsonable_to_json_nested (line 186) | def test_jsonable_to_json_nested():
  class A (line 206) | class A:
  function test_to_jsonable_handles_reference_cycles (line 223) | def test_to_jsonable_handles_reference_cycles(obj, value):
  function test_deferred_strategy_draw (line 227) | def test_deferred_strategy_draw():

FILE: hypothesis-python/tests/cover/test_seed_printing.py
  function test_prints_seed_only_on_healthcheck (line 25) | def test_prints_seed_only_on_healthcheck(
  function test_uses_global_force (line 63) | def test_uses_global_force(monkeypatch):
  function test_does_print_on_reuse_from_database (line 81) | def test_does_print_on_reuse_from_database():

FILE: hypothesis-python/tests/cover/test_settings.py
  function temp_register_profile (line 54) | def temp_register_profile(name, parent, **kwargs):
  function restore_profile (line 67) | def restore_profile():
  function test_cannot_set_non_settings (line 78) | def test_cannot_set_non_settings():
  function test_settings_uses_defaults (line 84) | def test_settings_uses_defaults():
  function test_raises_attribute_error (line 89) | def test_raises_attribute_error():
  function test_respects_none_database (line 94) | def test_respects_none_database():
  function test_can_repeatedly_push_the_same_thing (line 98) | def test_can_repeatedly_push_the_same_thing():
  function test_can_set_verbosity (line 116) | def test_can_set_verbosity():
  function test_can_not_set_verbosity_to_non_verbosity (line 123) | def test_can_not_set_verbosity_to_non_verbosity():
  function test_inherits_an_empty_database (line 129) | def test_inherits_an_empty_database(db):
  function test_can_assign_database (line 140) | def test_can_assign_database(db):
  function test_will_reload_profile_when_default_is_absent (line 145) | def test_will_reload_profile_when_default_is_absent():
  function test_load_profile (line 151) | def test_load_profile():
  function test_profile_names_must_be_strings (line 171) | def test_profile_names_must_be_strings():
  function test_loading_profile_keeps_expected_behaviour (line 180) | def test_loading_profile_keeps_expected_behaviour():
  function test_load_non_existent_profile (line 190) | def test_load_non_existent_profile():
  function test_cannot_set_settings (line 195) | def test_cannot_set_settings():
  function test_can_have_none_database (line 205) | def test_can_have_none_database():
  function test_database_type_must_be_ExampleDatabase (line 211) | def test_database_type_must_be_ExampleDatabase(db, bad_db):
  function test_cannot_assign_default (line 219) | def test_cannot_assign_default():
  function test_settings_in_strategies_are_from_test_scope (line 227) | def test_settings_in_strategies_are_from_test_scope(s):
  function test_settings_alone (line 244) | def test_settings_alone(pytester):
  function test_settings_applied_twice_is_error (line 256) | def test_settings_applied_twice_is_error():
  function test_outer_ok (line 266) | def test_outer_ok(x):
  function test_inner_ok (line 272) | def test_inner_ok(x):
  function test_settings_as_decorator_must_be_on_callable (line 276) | def test_settings_as_decorator_must_be_on_callable():
  function test_puts_the_database_in_the_home_dir_by_default (line 300) | def test_puts_the_database_in_the_home_dir_by_default(tmp_path):
  function test_database_is_reference_preserved (line 306) | def test_database_is_reference_preserved():
  function test_settings_apply_for_explicit_examples (line 315) | def test_settings_apply_for_explicit_examples(x):
  class TestGivenExampleSettingsExplicitCalled (line 320) | class TestGivenExampleSettingsExplicitCalled(TestCase):
    method call_target (line 332) | def call_target(self):
    method test_example_explicit (line 340) | def test_example_explicit(self, x):
    method tearDown (line 343) | def tearDown(self):
  function test_setattr_on_settings_singleton_is_error (line 348) | def test_setattr_on_settings_singleton_is_error():
  function test_deadline_given_none (line 355) | def test_deadline_given_none():
  function test_deadline_given_valid_int (line 360) | def test_deadline_given_valid_int():
  function test_deadline_given_valid_float (line 368) | def test_deadline_given_valid_float():
  function test_deadline_given_valid_timedelta (line 376) | def test_deadline_given_valid_timedelta():
  function test_can_not_set_print_blob_to_non_print_settings (line 385) | def test_can_not_set_print_blob_to_non_print_settings(value):
  class StepCounter (line 394) | class StepCounter(RuleBasedStateMachine):
    method __init__ (line 395) | def __init__(self):
    method count_step (line 400) | def count_step(self):
    method teardown (line 403) | def teardown(self):
  function test_two_settings_decorators_applied_to_state_machine_class_raises_error (line 410) | def test_two_settings_decorators_applied_to_state_machine_class_raises_e...
  function test_settings_decorator_applied_to_non_state_machine_class_raises_error (line 419) | def test_settings_decorator_applied_to_non_state_machine_class_raises_er...
  function test_assigning_to_settings_attribute_on_state_machine_raises_error (line 427) | def test_assigning_to_settings_attribute_on_state_machine_raises_error():
  function test_derandomise_with_explicit_database_is_invalid (line 440) | def test_derandomise_with_explicit_database_is_invalid():
  function test_invalid_settings_are_errors (line 468) | def test_invalid_settings_are_errors(kwargs):
  function test_invalid_parent (line 473) | def test_invalid_parent():
  function test_default_settings_do_not_use_ci (line 484) | def test_default_settings_do_not_use_ci():
  function test_show_changed (line 488) | def test_show_changed():
  function test_note_deprecation_checks_date (line 493) | def test_note_deprecation_checks_date():
  function test_note_deprecation_checks_has_codemod (line 501) | def test_note_deprecation_checks_has_codemod():
  function test_deprecated_settings_warn_on_set_settings (line 509) | def test_deprecated_settings_warn_on_set_settings():
  function test_deprecated_settings_not_in_settings_all_list (line 517) | def test_deprecated_settings_not_in_settings_all_list():
  function test_check_defaults_to_derandomize_when_running_on_ci (line 526) | def test_check_defaults_to_derandomize_when_running_on_ci():
  function test_check_defaults_to_randomize_when_not_running_on_ci (line 546) | def test_check_defaults_to_randomize_when_not_running_on_ci():
  function test_reloads_the_loaded_profile_if_registered_again (line 567) | def test_reloads_the_loaded_profile_if_registered_again():
  function test_will_automatically_pick_up_changes_to_ci_profile_in_ci (line 589) | def test_will_automatically_pick_up_changes_to_ci_profile_in_ci():
  function test_register_profile_avoids_intermediate_profiles (line 600) | def test_register_profile_avoids_intermediate_profiles():
  function test_cannot_register_profile_from_inside_test (line 610) | def test_cannot_register_profile_from_inside_test(x):
  function test_can_set_verbosity_to_strings (line 614) | def test_can_set_verbosity_to_strings():
  function test_can_set_phase_to_strings (line 621) | def test_can_set_phase_to_strings():
  function test_can_set_suppressions_to_strings (line 629) | def test_can_set_suppressions_to_strings():
  function test_verbosity_is_comparable (line 638) | def test_verbosity_is_comparable():
  function test_can_set_verbosity_to_integers (line 657) | def test_can_set_verbosity_to_integers():
  function test_can_set_phase_to_integers (line 665) | def test_can_set_phase_to_integers():
  function test_can_set_suppressions_to_integers (line 673) | def test_can_set_suppressions_to_integers():
  function test_invalid_integer_phase_raises (line 679) | def test_invalid_integer_phase_raises():
  function test_invalid_integer_healthcheck_raises (line 684) | def test_invalid_integer_healthcheck_raises():

FILE: hypothesis-python/tests/cover/test_setup_teardown.py
  class HasSetup (line 17) | class HasSetup:
    method setup_example (line 18) | def setup_example(self):
  class HasTeardown (line 23) | class HasTeardown:
    method teardown_example (line 24) | def teardown_example(self, ex):
  class SomeGivens (line 29) | class SomeGivens:
    method give_me_an_int (line 32) | def give_me_an_int(self, x):
    method give_me_a_string (line 36) | def give_me_a_string(self, x):
    method give_me_a_positive_int (line 41) | def give_me_a_positive_int(self, x):
    method fail_in_reify (line 45) | def fail_in_reify(self, x):
    method assume_some_stuff (line 50) | def assume_some_stuff(self, x):
    method assume_in_reify (line 54) | def assume_in_reify(self, x):
  class HasSetupAndTeardown (line 58) | class HasSetupAndTeardown(HasSetup, HasTeardown, SomeGivens):
  function test_calls_setup_and_teardown_on_self_as_first_argument (line 62) | def test_calls_setup_and_teardown_on_self_as_first_argument():
  function test_calls_setup_and_teardown_on_self_unbound (line 70) | def test_calls_setup_and_teardown_on_self_unbound():
  function test_calls_setup_and_teardown_on_failure (line 77) | def test_calls_setup_and_teardown_on_failure():
  function test_still_tears_down_on_error_in_generation (line 85) | def test_still_tears_down_on_error_in_generation():
  function test_still_tears_down_on_failed_assume (line 93) | def test_still_tears_down_on_failed_assume():
  function test_still_tears_down_on_failed_assume_in_reify (line 100) | def test_still_tears_down_on_failed_assume_in_reify():
  function test_sets_up_without_teardown (line 107) | def test_sets_up_without_teardown():
  function test_tears_down_without_setup (line 117) | def test_tears_down_without_setup():

FILE: hypothesis-python/tests/cover/test_shrink_budgeting.py
  function test_meets_budgetary_requirements (line 28) | def test_meets_budgetary_requirements(Shrinker, value):

FILE: hypothesis-python/tests/cover/test_sideeffect_warnings.py
  function _extend_initialization (line 29) | def _extend_initialization(monkeypatch):
  function test_sideeffect_warning (line 45) | def test_sideeffect_warning(sideeffect, warning_text, _extend_initializa...
  function test_sideeffect_delayed_warning (line 50) | def test_sideeffect_delayed_warning(monkeypatch, _extend_initialization):

FILE: hypothesis-python/tests/cover/test_simple_characters.py
  function test_nonexistent_category_argument (line 28) | def test_nonexistent_category_argument():
  function test_bad_codepoint_arguments (line 32) | def test_bad_codepoint_arguments():
  function test_exclude_all_available_range (line 37) | def test_exclude_all_available_range():
  function test_when_nothing_could_be_produced (line 46) | def test_when_nothing_could_be_produced():
  function test_include_exclude_with_multiple_chars_is_invalid (line 55) | def test_include_exclude_with_multiple_chars_is_invalid():
  function test_characters_of_specific_groups (line 67) | def test_characters_of_specific_groups():
  function test_characters_of_major_categories (line 76) | def test_characters_of_major_categories():
  function test_exclude_characters_of_specific_groups (line 83) | def test_exclude_characters_of_specific_groups():
  function test_exclude_characters_of_major_categories (line 92) | def test_exclude_characters_of_major_categories():
  function test_find_one (line 99) | def test_find_one():
  function test_find_something_rare (line 104) | def test_find_something_rare():
  function test_whitelisted_characters_alone (line 112) | def test_whitelisted_characters_alone():
  function test_whitelisted_characters_overlap_blacklisted_characters (line 117) | def test_whitelisted_characters_overlap_blacklisted_characters():
  function test_whitelisted_characters_override (line 133) | def test_whitelisted_characters_override():
  function test_blacklisted_characters (line 147) | def test_blacklisted_characters():
  function test_whitelist_characters_disjoint_blacklist_characters (line 158) | def test_whitelist_characters_disjoint_blacklist_characters():

FILE: hypothesis-python/tests/cover/test_simple_collections.py
  function test_find_empty_collection_gives_empty (line 52) | def test_find_empty_collection_gives_empty(col, strat):
  function test_find_non_empty_collection_gives_single_zero (line 59) | def test_find_non_empty_collection_gives_single_zero(coltype, strat):
  function test_minimizes_to_empty (line 66) | def test_minimizes_to_empty(coltype, strat):
  function test_minimizes_list_of_lists (line 70) | def test_minimizes_list_of_lists():
  function test_sets_are_size_bounded (line 78) | def test_sets_are_size_bounded(xs):
  function test_ordered_dictionaries_preserve_keys (line 82) | def test_ordered_dictionaries_preserve_keys():
  function test_fixed_dictionaries_with_optional_and_empty_keys (line 93) | def test_fixed_dictionaries_with_optional_and_empty_keys(d):
  function test_lists_of_fixed_length (line 98) | def test_lists_of_fixed_length(n):
  function test_sets_of_fixed_length (line 103) | def test_sets_of_fixed_length(n):
  function test_dictionaries_of_fixed_length (line 114) | def test_dictionaries_of_fixed_length(n):
  function test_lists_of_lower_bounded_length (line 124) | def test_lists_of_lower_bounded_length(n):
  function test_can_find_unique_lists_of_non_set_order (line 130) | def test_can_find_unique_lists_of_non_set_order():
  function test_can_draw_empty_list_from_unsatisfiable_strategy (line 150) | def test_can_draw_empty_list_from_unsatisfiable_strategy():
  function test_can_draw_empty_set_from_unsatisfiable_strategy (line 154) | def test_can_draw_empty_set_from_unsatisfiable_strategy():
  function test_small_sized_sets (line 159) | def test_small_sized_sets(x):
  function test_minimize_dicts_with_incompatible_keys (line 163) | def test_minimize_dicts_with_incompatible_keys():
  function test_lists_unique_by_tuple_funcs (line 175) | def test_lists_unique_by_tuple_funcs(ls):

FILE: hypothesis-python/tests/cover/test_simple_strings.py
  function test_can_minimize_up_to_zero (line 17) | def test_can_minimize_up_to_zero():
  function test_minimizes_towards_ascii_zero (line 22) | def test_minimizes_towards_ascii_zero():
  function test_can_handle_large_codepoints (line 27) | def test_can_handle_large_codepoints():
  function test_can_find_mixed_ascii_and_non_ascii_strings (line 32) | def test_can_find_mixed_ascii_and_non_ascii_strings():
  function test_will_find_ascii_examples_given_the_chance (line 40) | def test_will_find_ascii_examples_given_the_chance():
  function test_minimisation_consistent_with_characters (line 48) | def test_minimisation_consistent_with_characters():
  function test_finds_single_element_strings (line 53) | def test_finds_single_element_strings():
  function test_binary_respects_max_size (line 58) | def test_binary_respects_max_size(x):
  function test_does_not_simplify_into_surrogates (line 62) | def test_does_not_simplify_into_surrogates():
  function test_respects_alphabet_if_list (line 73) | def test_respects_alphabet_if_list(xs):
  function test_respects_alphabet_if_string (line 78) | def test_respects_alphabet_if_string(xs):
  function test_can_encode_as_utf8 (line 83) | def test_can_encode_as_utf8(s):
  function test_can_blacklist_newlines (line 88) | def test_can_blacklist_newlines(s):
  function test_can_exclude_newlines_by_category (line 93) | def test_can_exclude_newlines_by_category(s):
  function test_can_restrict_to_ascii_only (line 98) | def test_can_restrict_to_ascii_only(s):
  function test_fixed_size_bytes_just_draw_bytes (line 102) | def test_fixed_size_bytes_just_draw_bytes():
  function test_can_set_max_size_large (line 110) | def test_can_set_max_size_large(s):

FILE: hypothesis-python/tests/cover/test_slices.py
  function test_stop_stays_within_bounds (line 21) | def test_stop_stays_within_bounds(size):
  function test_start_stay_within_bounds (line 29) | def test_start_stay_within_bounds(size):
  function test_step_stays_within_bounds (line 37) | def test_step_stays_within_bounds(size):
  function test_step_will_not_be_zero (line 53) | def test_step_will_not_be_zero(size):
  function test_slices_will_shrink (line 58) | def test_slices_will_shrink(size):
  function test_step_will_be_negative (line 67) | def test_step_will_be_negative(size):
  function test_step_will_be_positive (line 73) | def test_step_will_be_positive(size):
  function test_stop_will_equal_size (line 78) | def test_stop_will_equal_size(size):
  function test_start_will_equal_size (line 83) | def test_start_will_equal_size(size):
  function test_start_will_equal_0 (line 91) | def test_start_will_equal_0(size):
  function test_start_will_equal_stop (line 97) | def test_start_will_equal_stop(size):
  function test_size_is_equal_0 (line 101) | def test_size_is_equal_0():

FILE: hypothesis-python/tests/cover/test_slippage.py
  function capture_reports (line 28) | def capture_reports(test):
  function test_raises_multiple_failures_with_varying_type (line 39) | def test_raises_multiple_failures_with_varying_type():
  function test_shows_target_scores_with_multiple_failures (line 64) | def test_shows_target_scores_with_multiple_failures():
  function test_raises_multiple_failures_when_position_varies (line 76) | def test_raises_multiple_failures_when_position_varies():
  function test_replays_both_failing_values (line 98) | def test_replays_both_failing_values():
  function test_replays_slipped_examples_once_initial_bug_is_fixed (line 123) | def test_replays_slipped_examples_once_initial_bug_is_fixed(fix):
  function test_garbage_collects_the_secondary_key (line 157) | def test_garbage_collects_the_secondary_key():
  function test_shrinks_both_failures (line 195) | def test_shrinks_both_failures():
  function test_handles_flaky_tests_where_only_one_is_flaky (line 229) | def test_handles_flaky_tests_where_only_one_is_flaky():
  function test_can_disable_multiple_error_reporting (line 270) | def test_can_disable_multiple_error_reporting(allow_multi):
  function test_finds_multiple_failures_in_generation (line 291) | def test_finds_multiple_failures_in_generation():
  function test_stops_immediately_if_not_report_multiple_bugs (line 325) | def test_stops_immediately_if_not_report_multiple_bugs():
  function test_stops_immediately_on_replay (line 342) | def test_stops_immediately_on_replay():

FILE: hypothesis-python/tests/cover/test_stateful.py
  class MultipleRulesSameFuncMachine (line 64) | class MultipleRulesSameFuncMachine(RuleBasedStateMachine):
    method myfunc (line 65) | def myfunc(self, data):
  class PreconditionMachine (line 72) | class PreconditionMachine(RuleBasedStateMachine):
    method add_one (line 76) | def add_one(self):
    method set_to_zero (line 80) | def set_to_zero(self):
    method div_by_precondition_after (line 85) | def div_by_precondition_after(self, num):
    method div_by_precondition_before (line 90) | def div_by_precondition_before(self, num):
  function test_picks_up_settings_at_first_use_of_testcase (line 98) | def test_picks_up_settings_at_first_use_of_testcase():
  function test_multiple_rules_same_func (line 102) | def test_multiple_rules_same_func():
  function test_can_get_test_case_off_machine_instance (line 111) | def test_can_get_test_case_off_machine_instance():
  class FlakyDrawLessMachine (line 116) | class FlakyDrawLessMachine(RuleBasedStateMachine):
    method action (line 118) | def action(self, d):
  function test_flaky_draw_less_raises_flaky (line 126) | def test_flaky_draw_less_raises_flaky():
  function test_result_is_added_to_target (line 131) | def test_result_is_added_to_target():
  class FlakyStateMachine (line 150) | class FlakyStateMachine(RuleBasedStateMachine):
    method action (line 152) | def action(self):
  function test_flaky_raises_flaky (line 156) | def test_flaky_raises_flaky():
  class FlakyPreconditionMachine (line 161) | class FlakyPreconditionMachine(RuleBasedStateMachine):
    method action (line 164) | def action(self):
  function test_flaky_precondition_error_message (line 168) | def test_flaky_precondition_error_message():
  class FlakyDrawInRuleMachine (line 174) | class FlakyDrawInRuleMachine(RuleBasedStateMachine):
    method action (line 178) | def action(self, d):
  function test_flaky_draw_in_rule_no_precondition_note (line 185) | def test_flaky_draw_in_rule_no_precondition_note():
  function test_get_state_machine_test_is_importable (line 194) | def test_get_state_machine_test_is_importable():
  class FlakyRatchettingMachine (line 199) | class FlakyRatchettingMachine(RuleBasedStateMachine):
    method action (line 203) | def action(self, d):
  class MachineWithConsumingRule (line 215) | class MachineWithConsumingRule(RuleBasedStateMachine):
    method __init__ (line 219) | def __init__(self):
    method bundle_length (line 225) | def bundle_length(self):
    method populate_b1 (line 229) | def populate_b1(self):
    method depopulate_b1 (line 234) | def depopulate_b1(self, consumed):
    method depopulate_b1_multiple (line 239) | def depopulate_b1_multiple(self, consumed):
    method check (line 243) | def check(self, value1, value2):
  function test_multiple (line 250) | def test_multiple():
  class MachineUsingMultiple (line 258) | class MachineUsingMultiple(RuleBasedStateMachine):
    method __init__ (line 261) | def __init__(self):
    method bundle_length (line 266) | def bundle_length(self):
    method populate_bundle (line 270) | def populate_bundle(self, items):
    method do_not_populate (line 275) | def do_not_populate(self):
  function test_multiple_variables_printed (line 282) | def test_multiple_variables_printed():
  function test_multiple_variables_printed_single_element (line 313) | def test_multiple_variables_printed_single_element():
  function test_no_variables_printed (line 339) | def test_no_variables_printed():
  function test_consumes_typecheck (line 363) | def test_consumes_typecheck():
  function test_ratchetting_raises_flaky (line 368) | def test_ratchetting_raises_flaky():
  function test_empty_machine_is_invalid (line 373) | def test_empty_machine_is_invalid():
  function test_machine_with_no_terminals_is_invalid (line 381) | def test_machine_with_no_terminals_is_invalid():
  function test_minimizes_errors_in_teardown (line 391) | def test_minimizes_errors_in_teardown():
  class RequiresInit (line 423) | class RequiresInit(RuleBasedStateMachine):
    method __init__ (line 424) | def __init__(self, threshold):
    method action (line 429) | def action(self, value):
  function test_can_use_factory_for_tests (line 434) | def test_can_use_factory_for_tests():
  class FailsEventually (line 441) | class FailsEventually(RuleBasedStateMachine):
    method __init__ (line 442) | def __init__(self):
    method increment (line 447) | def increment(self):
  function test_can_explicitly_pass_settings (line 456) | def test_can_explicitly_pass_settings():
  function test_settings_argument_is_validated (line 471) | def test_settings_argument_is_validated():
  function test_runner_that_checks_factory_produced_a_machine (line 476) | def test_runner_that_checks_factory_produced_a_machine():
  function test_settings_attribute_is_validated (line 482) | def test_settings_attribute_is_validated():
  function test_saves_failing_example_in_database (line 492) | def test_saves_failing_example_in_database():
  function test_can_run_with_no_db (line 502) | def test_can_run_with_no_db():
  function test_stateful_double_rule_is_forbidden (line 509) | def test_stateful_double_rule_is_forbidden(recwarn):
  function test_can_explicitly_call_functions_when_precondition_not_satisfied (line 519) | def test_can_explicitly_call_functions_when_precondition_not_satisfied():
  function test_invariant (line 537) | def test_invariant():
  function test_no_double_invariant (line 556) | def test_no_double_invariant():
  function test_invariant_precondition (line 575) | def test_invariant_precondition():
  function test_invariant_and_rule_are_incompatible (line 616) | def test_invariant_and_rule_are_incompatible(decorators):
  function test_invalid_rule_argument (line 628) | def test_invalid_rule_argument():
  function test_invalid_initialize_argument (line 638) | def test_invalid_initialize_argument():
  function test_multiple_invariants (line 648) | def test_multiple_invariants():
  function test_explicit_invariant_call_with_precondition (line 673) | def test_explicit_invariant_call_with_precondition():
  function test_invariant_checks_initial_state_if_no_initialize_rules (line 694) | def test_invariant_checks_initial_state_if_no_initialize_rules():
  function test_invariant_failling_present_in_falsifying_example (line 715) | def test_invariant_failling_present_in_falsifying_example():
  function test_invariant_present_in_falsifying_example (line 746) | def test_invariant_present_in_falsifying_example():
  function test_always_runs_at_least_one_step (line 798) | def test_always_runs_at_least_one_step():
  function test_removes_needless_steps (line 814) | def test_removes_needless_steps():
  function test_prints_equal_values_with_correct_variable_name (line 865) | def test_prints_equal_values_with_correct_variable_name():
  function test_initialize_rule (line 894) | def test_initialize_rule():
  function test_initialize_rule_populate_bundle (line 931) | def test_initialize_rule_populate_bundle():
  function test_initialize_rule_dont_mix_with_precondition (line 960) | def test_initialize_rule_dont_mix_with_precondition():
  function test_initialize_rule_dont_mix_with_regular_rule (line 992) | def test_initialize_rule_dont_mix_with_regular_rule():
  function test_initialize_rule_cannot_be_double_applied (line 1019) | def test_initialize_rule_cannot_be_double_applied():
  function test_initialize_rule_in_state_machine_with_inheritance (line 1032) | def test_initialize_rule_in_state_machine_with_inheritance():
  function test_can_manually_call_initialize_rule (line 1061) | def test_can_manually_call_initialize_rule():
  function test_steps_printed_despite_pytest_fail (line 1092) | def test_steps_printed_despite_pytest_fail():
  function test_steps_not_printed_with_pytest_skip (line 1112) | def test_steps_not_printed_with_pytest_skip(capsys):
  function test_rule_deprecation_targets_and_target (line 1124) | def test_rule_deprecation_targets_and_target():
  function test_rule_deprecation_bundle_by_name (line 1130) | def test_rule_deprecation_bundle_by_name():
  function test_rule_non_bundle_target (line 1136) | def test_rule_non_bundle_target():
  function test_rule_non_bundle_target_oneof (line 1141) | def test_rule_non_bundle_target_oneof():
  function test_uses_seed (line 1148) | def test_uses_seed(capsys):
  function test_reproduce_failure_works (line 1161) | def test_reproduce_failure_works():
  function test_reproduce_failure_fails_if_no_error (line 1172) | def test_reproduce_failure_fails_if_no_error():
  function test_cannot_have_zero_steps (line 1183) | def test_cannot_have_zero_steps():
  function test_arguments_do_not_use_names_of_return_values (line 1188) | def test_arguments_do_not_use_names_of_return_values():
  class TrickyInitMachine (line 1207) | class TrickyInitMachine(RuleBasedStateMachine):
    method init_a (line 1209) | def init_a(self):
    method inc (line 1213) | def inc(self):
    method check_a_positive (line 1217) | def check_a_positive(self):
  function test_invariants_are_checked_after_init_steps (line 1223) | def test_invariants_are_checked_after_init_steps():
  function test_invariants_can_be_checked_during_init_steps (line 1227) | def test_invariants_can_be_checked_during_init_steps():
  function test_check_during_init_must_be_boolean (line 1238) | def test_check_during_init_must_be_boolean():
  function test_deprecated_target_consumes_bundle (line 1245) | def test_deprecated_target_consumes_bundle():
  class MinStepsMachine (line 1254) | class MinStepsMachine(RuleBasedStateMachine):
    method init_a (line 1256) | def init_a(self):
    method inc (line 1260) | def inc(self):
    method not_too_many_steps (line 1264) | def not_too_many_steps(self):
    method teardown (line 1267) | def teardown(self):
  function test_min_steps_argument (line 1273) | def test_min_steps_argument():
  class ErrorsOnClassAttributeSettings (line 1286) | class ErrorsOnClassAttributeSettings(RuleBasedStateMachine):
    method step (line 1290) | def step(self):
  function test_fails_on_settings_class_attribute (line 1294) | def test_fails_on_settings_class_attribute():
  function test_single_target_multiple (line 1302) | def test_single_target_multiple():
  function test_targets_repr (line 1354) | def test_targets_repr(bundle_names, initial, repr_):
  function test_multiple_targets (line 1383) | def test_multiple_targets():
  function test_multiple_common_targets (line 1421) | def test_multiple_common_targets():
  class LotsOfEntropyPerStepMachine (line 1463) | class LotsOfEntropyPerStepMachine(RuleBasedStateMachine):
    method rule1 (line 1466) | def rule1(self, data):
  function test_lots_of_entropy (line 1474) | def test_lots_of_entropy():
  function test_flatmap (line 1478) | def test_flatmap():
  function test_use_bundle_within_other_strategies (line 1499) | def test_use_bundle_within_other_strategies():
  function test_precondition_cannot_be_used_without_rule (line 1520) | def test_precondition_cannot_be_used_without_rule():

FILE: hypothesis-python/tests/cover/test_statistical_events.py
  function call_for_statistics (line 35) | def call_for_statistics(test_function):
  function unique_events (line 46) | def unique_events(stats):
  function test_notes_hard_to_satisfy (line 50) | def test_notes_hard_to_satisfy():
  function test_can_callback_with_a_string (line 60) | def test_can_callback_with_a_string():
  class Foo (line 73) | class Foo:
    method __eq__ (line 74) | def __eq__(self, other):
    method __ne__ (line 77) | def __ne__(self, other):
    method __hash__ (line 80) | def __hash__(self):
    method __str__ (line 83) | def __str__(self):
  function test_formats_are_evaluated_only_once (line 90) | def test_formats_are_evaluated_only_once():
  function test_does_not_report_on_examples (line 105) | def test_does_not_report_on_examples():
  function test_exact_timing (line 116) | def test_exact_timing():
  function test_apparently_instantaneous_tests (line 126) | def test_apparently_instantaneous_tests():
  function test_flaky_exit (line 138) | def test_flaky_exit():
  function test_draw_timing (line 156) | def test_draw_timing(draw_delay, test_delay):
  function test_has_lambdas_in_output (line 178) | def test_has_lambdas_in_output():
  function test_stops_after_x_shrinks (line 188) | def test_stops_after_x_shrinks(monkeypatch):
  function test_stateful_states_are_deduped (line 203) | def test_stateful_states_are_deduped():
  function test_stateful_with_one_of_bundles_states_are_deduped (line 221) | def test_stateful_with_one_of_bundles_states_are_deduped():
  function test_statistics_for_threshold_problem (line 245) | def test_statistics_for_threshold_problem():
  function test_statistics_with_events_and_target (line 260) | def test_statistics_with_events_and_target():
  function test_event_with_non_weakrefable_keys (line 272) | def test_event_with_non_weakrefable_keys(b):
  function test_assume_adds_event_with_function_origin (line 276) | def test_assume_adds_event_with_function_origin():
  function test_reject_adds_event_with_function_origin (line 288) | def test_reject_adds_event_with_function_origin():

FILE: hypothesis-python/tests/cover/test_subnormal_floats.py
  function kw (line 26) | def kw(marks=(), **kwargs):
  function test_subnormal_validation (line 42) | def test_subnormal_validation(kwargs):
  function test_allow_subnormal_defaults_correctly (line 77) | def test_allow_subnormal_defaults_correctly(kwargs):
  function test_next_float_normal (line 97) | def test_next_float_normal(func, val, expected):

FILE: hypothesis-python/tests/cover/test_targeting.py
  function test_allowed_inputs_to_target (line 25) | def test_allowed_inputs_to_target(observation, label):
  function test_allowed_inputs_to_target_fewer_labels (line 34) | def test_allowed_inputs_to_target_fewer_labels(observation, label):
  function test_target_without_label (line 39) | def test_target_without_label(observation):
  function test_multiple_target_calls (line 50) | def test_multiple_target_calls(args):
  function test_respects_max_pool_size (line 58) | def test_respects_max_pool_size(observations):
  function everything_except (line 66) | def everything_except(type_):
  function test_disallowed_inputs_to_target (line 84) | def test_disallowed_inputs_to_target(observation, label):
  function test_cannot_target_outside_test (line 89) | def test_cannot_target_outside_test():
  function test_cannot_target_same_label_twice (line 95) | def test_cannot_target_same_label_twice(_):
  function test_cannot_target_default_label_twice (line 104) | def test_cannot_target_default_label_twice(_):

FILE: hypothesis-python/tests/cover/test_testdecorators.py
  function test_int_addition_is_commutative (line 59) | def test_int_addition_is_commutative(x, y):
  function test_str_addition_is_commutative (line 65) | def test_str_addition_is_commutative(x, y):
  function test_bytes_addition_is_commutative (line 71) | def test_bytes_addition_is_commutative(x, y):
  function test_int_addition_is_associative (line 79) | def test_int_addition_is_associative(x, y, z):
  function test_float_addition_is_associative (line 86) | def test_float_addition_is_associative(x, y, z):
  function test_reversing_preserves_integer_addition (line 91) | def test_reversing_preserves_integer_addition(xs):
  function test_still_minimizes_on_non_assertion_failures (line 95) | def test_still_minimizes_on_non_assertion_failures():
  function test_integer_division_shrinks_positive_integers (line 107) | def test_integer_division_shrinks_positive_integers(n):
  class TestCases (line 112) | class TestCases:
    method test_abs_non_negative (line 114) | def test_abs_non_negative(self, x):
    method test_abs_non_negative_varargs (line 119) | def test_abs_non_negative_varargs(self, x, *args):
    method test_abs_non_negative_varargs_kwargs (line 124) | def test_abs_non_negative_varargs_kwargs(self, *args, **kw):
    method test_abs_non_negative_varargs_kwargs_only (line 129) | def test_abs_non_negative_varargs_kwargs_only(*args, **kw):
    method test_int_is_always_negative (line 135) | def test_int_is_always_negative(self, x):
    method test_float_addition_cancels (line 140) | def test_float_addition_cancels(self, x, y):
  function test_can_be_given_keyword_args (line 146) | def test_can_be_given_keyword_args(x, name):
  function test_one_of_produces_different_values (line 153) | def test_one_of_produces_different_values(x, y):
  function test_is_the_answer (line 158) | def test_is_the_answer(x):
  function test_integers_are_in_range (line 163) | def test_integers_are_in_range(x):
  function test_integers_from_are_from (line 168) | def test_integers_from_are_from(x):
  function test_does_not_catch_interrupt_during_falsify (line 172) | def test_does_not_catch_interrupt_during_falsify():
  function test_removing_an_element_from_a_unique_list (line 187) | def test_removing_an_element_from_a_unique_list(xs, y):
  function test_removing_an_element_from_a_non_unique_list (line 200) | def test_removing_an_element_from_a_non_unique_list(xs, data):
  function test_can_test_sets_sampled_from (line 207) | def test_can_test_sets_sampled_from(xs):
  function test_can_mix_sampling_with_generating (line 217) | def test_can_mix_sampling_with_generating(x, y):
  function test_can_find_large_sum_frozenset (line 223) | def test_can_find_large_sum_frozenset(xs):
  function test_prints_on_failure_by_default (line 227) | def test_prints_on_failure_by_default():
  function test_does_not_print_on_success (line 237) | def test_does_not_print_on_success():
  function test_can_sample_from_single_element (line 251) | def test_can_sample_from_single_element(x):
  function test_list_is_sorted (line 257) | def test_list_is_sorted(xs):
  function test_is_an_endpoint (line 263) | def test_is_an_endpoint(x):
  function test_breaks_bounds (line 267) | def test_breaks_bounds():
  function test_can_test_kwargs_only_methods (line 279) | def test_can_test_kwargs_only_methods(**kwargs):
  function test_is_ascii (line 286) | def test_is_ascii(x):
  function test_is_not_ascii (line 292) | def test_is_not_ascii(x):
  function test_can_find_string_with_duplicates (line 303) | def test_can_find_string_with_duplicates(s):
  function test_has_ascii (line 310) | def test_has_ascii(x):
  function test_can_derandomize (line 320) | def test_can_derandomize():
  function test_can_run_without_database (line 338) | def test_can_run_without_database():
  function test_can_run_with_database_in_thread (line 349) | def test_can_run_with_database_in_thread():
  function test_can_call_an_argument_f (line 373) | def test_can_call_an_argument_f(f):
  function test_named_tuples_are_of_right_type (line 383) | def test_named_tuples_are_of_right_type(litter):
  function test_fails_in_reify (line 390) | def test_fails_in_reify(x):
  function test_a_text (line 395) | def test_a_text(x):
  function test_empty_text (line 400) | def test_empty_text(x):
  function test_mixed_text (line 405) | def test_mixed_text(x):
  function test_when_set_to_no_simplifies_runs_failing_example_twice (line 410) | def test_when_set_to_no_simplifies_runs_failing_example_twice():
  function test_filtered_values_satisfy_condition (line 435) | def test_filtered_values_satisfy_condition(i):
  function nameless_const (line 439) | def nameless_const(x):
  function test_can_map_nameless (line 447) | def test_can_map_nameless(x):
  function test_can_flatmap_nameless (line 452) | def test_can_flatmap_nameless(x):
  function test_can_be_used_with_none_module (line 456) | def test_can_be_used_with_none_module():
  function test_does_not_print_notes_if_all_succeed (line 465) | def test_does_not_print_notes_if_all_succeed():
  function test_prints_notes_once_on_failure (line 476) | def test_prints_notes_once_on_failure():
  function test_empty_lists (line 490) | def test_empty_lists(xs):
  function test_given_usable_inline_on_lambdas (line 495) | def test_given_usable_inline_on_lambdas():
  function test_notes_high_filter_rates_in_unsatisfiable_error (line 502) | def test_notes_high_filter_rates_in_unsatisfiable_error():
  function test_notes_high_overrun_rates_in_unsatisfiable_error (line 523) | def test_notes_high_overrun_rates_in_unsatisfiable_error():

FILE: hypothesis-python/tests/cover/test_threading.py
  function test_threadlocal_setattr_and_getattr (line 21) | def test_threadlocal_setattr_and_getattr():
  function test_nonexistent_getattr_raises (line 43) | def test_nonexistent_getattr_raises():
  function test_nonexistent_setattr_raises (line 49) | def test_nonexistent_setattr_raises():
  function test_raises_if_not_passed_callable (line 55) | def test_raises_if_not_passed_callable():
  function test_run_given_concurrently (line 65) | def test_run_given_concurrently():
  class TestNoDifferingExecutorsHealthCheck (line 87) | class TestNoDifferingExecutorsHealthCheck:
    method test_a (line 90) | def test_a(self, x, i):

FILE: hypothesis-python/tests/cover/test_traceback_elision.py
  function test_tracebacks_omit_hypothesis_internals (line 20) | def test_tracebacks_omit_hypothesis_internals(monkeypatch, env_value, ve...

FILE: hypothesis-python/tests/cover/test_type_lookup.py
  function test_generic_sequence_of_integers_may_be_lists_or_bytes (line 53) | def test_generic_sequence_of_integers_may_be_lists_or_bytes():
  function test_resolve_core_strategies (line 60) | def test_resolve_core_strategies(typ):
  function test_lookup_knows_about_all_core_strategies (line 68) | def test_lookup_knows_about_all_core_strategies():
  function test_lookup_keys_are_types (line 112) | def test_lookup_keys_are_types():
  function test_lookup_values_are_strategies (line 127) | def test_lookup_values_are_strategies(typ, not_a_strategy):
  function test_lookup_overrides_defaults (line 134) | def test_lookup_overrides_defaults(typ):
  class ParentUnknownType (line 141) | class ParentUnknownType:
  class UnknownType (line 145) | class UnknownType(ParentUnknownType):
    method __init__ (line 146) | def __init__(self, arg):
  function test_custom_type_resolution_fails_without_registering (line 150) | def test_custom_type_resolution_fails_without_registering():
  function test_custom_type_resolution (line 156) | def test_custom_type_resolution():
  function test_custom_type_resolution_with_function (line 164) | def test_custom_type_resolution_with_function():
  function test_custom_type_resolution_with_function_non_strategy (line 171) | def test_custom_type_resolution_with_function_non_strategy():
  function test_conditional_type_resolution_with_function (line 180) | def test_conditional_type_resolution_with_function(strategy_returned):
  function test_errors_if_generic_resolves_empty (line 197) | def test_errors_if_generic_resolves_empty():
  function test_cannot_register_empty (line 208) | def test_cannot_register_empty():
  function test_pulic_interface_works (line 218) | def test_pulic_interface_works():
  function test_given_can_infer_from_manual_annotations (line 226) | def test_given_can_infer_from_manual_annotations(infer_token):
  class EmptyEnum (line 235) | class EmptyEnum(enum.Enum):
  function test_error_if_enum_is_empty (line 241) | def test_error_if_enum_is_empty(x):
  class BrokenClass (line 245) | class BrokenClass:
  function test_uninspectable_builds (line 249) | def test_uninspectable_builds():
  function test_uninspectable_from_type (line 254) | def test_uninspectable_from_type():
  function _check_instances (line 259) | def _check_instances(t):
  function maybe_mark (line 269) | def maybe_mark(x):
  function test_can_generate_from_all_registered_types (line 284) | def test_can_generate_from_all_registered_types(data, typ):
  class MyGeneric (line 292) | class MyGeneric(Generic[T]):
    method __init__ (line 293) | def __init__(self, arg: T) -> None:
  class Lines (line 297) | class Lines(Sequence[str]):
  class SpecificDict (line 305) | class SpecificDict(dict[int, int]):
  function using_generic (line 309) | def using_generic(instance: MyGeneric[T]) -> T:
  function using_concrete_generic (line 313) | def using_concrete_generic(instance: MyGeneric[int]) -> int:
  function test_generic_origin_empty (line 317) | def test_generic_origin_empty():
  function test_issue_2951_regression (line 322) | def test_issue_2951_regression():
  function test_issue_2951_regression_two_params (line 332) | def test_issue_2951_regression_two_params():
  function test_generic_origin_with_type_args (line 353) | def test_generic_origin_with_type_args(generic, strategy):
  function test_generic_origin_without_type_args (line 375) | def test_generic_origin_without_type_args(generic):
  function test_generic_origin_from_type (line 391) | def test_generic_origin_from_type(strat, type_):
  function test_generic_origin_concrete_builds (line 396) | def test_generic_origin_concrete_builds():
  class AbstractFoo (line 403) | class AbstractFoo(abc.ABC):
    method __init__ (line 404) | def __init__(self, x):  # noqa: B027
    method qux (line 408) | def qux(self):
  class ConcreteFoo1 (line 412) | class ConcreteFoo1(AbstractFoo):
    method qux (line 414) | def qux(self):
  class ConcreteFoo2 (line 418) | class ConcreteFoo2(AbstractFoo):
    method __init__ (line 419) | def __init__(self, x: int):
    method qux (line 422) | def qux(self):
  function test_gen_abstract (line 427) | def test_gen_abstract(foo):
  class AbstractBar (line 433) | class AbstractBar(abc.ABC):
    method __init__ (line 434) | def __init__(self, x):  # noqa: B027
    method qux (line 438) | def qux(self):
  class ConcreteBar (line 442) | class ConcreteBar(AbstractBar):
    method qux (line 443) | def qux(self):
  function test_abstract_resolver_fallback (line 447) | def test_abstract_resolver_fallback():
  function _one_arg (line 466) | def _one_arg(x: int):
  function _multi_arg (line 470) | def _multi_arg(x: int, y: str):
  function _kwd_only (line 475) | def _kwd_only(*, y: str):
  function _pos_and_kwd_only (line 479) | def _pos_and_kwd_only(x: int, *, y: str):
  function test_infer_all (line 485) | def test_infer_all(func):
  function test_does_not_add_param_empty_to_type_hints (line 490) | def test_does_not_add_param_empty_to_type_hints():

FILE: hypothesis-python/tests/cover/test_type_lookup_forward_ref.py
  function correct_fun (line 43) | def correct_fun(thing: _Correct) -> int:
  class CustomType (line 47) | class CustomType:
    method __init__ (line 48) | def __init__(self, arg: int) -> None:
  function test_bound_correct_forward_ref (line 53) | def test_bound_correct_forward_ref(built):
  function alias_fun (line 63) | def alias_fun(thing: _Alias) -> int:
  function test_bound_alias_forward_ref (line 71) | def test_bound_alias_forward_ref(built):
  function correct_dot_access_fun (line 83) | def correct_dot_access_fun(thing: _CorrectDotAccess) -> int:
  function wrong_dot_access_fun (line 87) | def wrong_dot_access_fun(thing: _WrongDotAccess) -> int:
  function missing_dot_access_fun (line 91) | def missing_dot_access_fun(thing: _MissingDotAccess) -> int:
  function test_bound_correct_dot_access_forward_ref (line 96) | def test_bound_correct_dot_access_forward_ref(built):
  function test_bound_missing_dot_access_forward_ref (line 102) | def test_bound_missing_dot_access_forward_ref(function):
  function missing_fun (line 113) | def missing_fun(thing: _Missing) -> int:
  function test_bound_missing_forward_ref (line 117) | def test_bound_missing_forward_ref():
  function typechecking_only_fun (line 128) | def typechecking_only_fun(thing: _TypeChecking) -> int:
  function test_bound_type_cheking_only_forward_ref (line 132) | def test_bound_type_cheking_only_forward_ref():
  function test_bound_type_checking_only_forward_ref_wrong_type (line 138) | def test_bound_type_checking_only_forward_ref_wrong_type():

FILE: hypothesis-python/tests/cover/test_typealias_py312.py
  function test_resolves_simple_typealias (line 24) | def test_resolves_simple_typealias():
  function test_resolves_nested (line 39) | def test_resolves_nested():
  function test_resolves_parametrized (line 47) | def test_resolves_parametrized():
  function test_mutually_recursive_fails (line 54) | def test_mutually_recursive_fails():
  function test_mutually_recursive_fails_parametrized (line 66) | def test_mutually_recursive_fails_parametrized():
  function test_can_register_typealias (line 75) | def test_can_register_typealias():
  function test_prefers_manually_registered_typealias (line 81) | def test_prefers_manually_registered_typealias():
  function test_resolves_parameterized_typealias (line 91) | def test_resolves_parameterized_typealias():
  function test_resolves_nested_parameterized_typealias (line 101) | def test_resolves_nested_parameterized_typealias():
  function test_resolves_parameterized_typealias_with_literal_types (line 111) | def test_resolves_parameterized_typealias_with_literal_types():
  function test_can_register_parameterized_typealias_with_unused_params (line 122) | def test_can_register_parameterized_typealias_with_unused_params():
  function test_typealias_evaluation (line 144) | def test_typealias_evaluation():

FILE: hypothesis-python/tests/cover/test_unicode_identifiers.py
  function test_can_copy_signature_of_unicode_args (line 15) | def test_can_copy_signature_of_unicode_args():
  function test_can_copy_signature_of_unicode_name (line 26) | def test_can_copy_signature_of_unicode_name():
  function test_can_handle_unicode_identifier_in_same_line_as_lambda_def (line 40) | def test_can_handle_unicode_identifier_in_same_line_as_lambda_def():
  function test_regression_issue_1700 (line 44) | def test_regression_issue_1700():

FILE: hypothesis-python/tests/cover/test_unittest.py
  class Thing_with_a_subThing (line 23) | class Thing_with_a_subThing(unittest.TestCase):
    method thing (line 27) | def thing(self, lst):
  function test_subTest (line 33) | def test_subTest():
  class test_given_on_setUp_fails_health_check (line 41) | class test_given_on_setUp_fails_health_check(unittest.TestCase):
    method setUp (line 44) | def setUp(self, i):
    method test (line 47) | def test(self):
  function test_subTest_no_self (line 69) | def test_subTest_no_self(testdir, err):

FILE: hypothesis-python/tests/cover/test_uuids.py
  function test_no_nil_uuid_by_default (line 21) | def test_no_nil_uuid_by_default():
  function test_can_generate_nil_uuid (line 25) | def test_can_generate_nil_uuid():
  function test_can_only_allow_nil_uuid_with_none_version (line 29) | def test_can_only_allow_nil_uuid_with_none_version():

FILE: hypothesis-python/tests/cover/test_validation.py
  function test_errors_when_given_varargs (line 40) | def test_errors_when_given_varargs():
  function test_varargs_without_positional_arguments_allowed (line 50) | def test_varargs_without_positional_arguments_allowed():
  function test_errors_when_given_varargs_and_kwargs_with_positional_arguments (line 56) | def test_errors_when_given_varargs_and_kwargs_with_positional_arguments():
  function test_varargs_and_kwargs_without_positional_arguments_allowed (line 66) | def test_varargs_and_kwargs_without_positional_arguments_allowed():
  function test_bare_given_errors (line 72) | def test_bare_given_errors():
  function test_errors_on_unwanted_kwargs (line 81) | def test_errors_on_unwanted_kwargs():
  function test_errors_on_too_many_positional_args (line 90) | def test_errors_on_too_many_positional_args():
  function test_errors_on_any_varargs (line 99) | def test_errors_on_any_varargs():
  function test_can_put_arguments_in_the_middle (line 108) | def test_can_put_arguments_in_the_middle():
  function test_float_ranges (line 116) | def test_float_ranges():
  function test_float_range_and_allow_nan_cannot_both_be_enabled (line 123) | def test_float_range_and_allow_nan_cannot_both_be_enabled():
  function test_float_finite_range_and_allow_infinity_cannot_both_be_enabled (line 130) | def test_float_finite_range_and_allow_infinity_cannot_both_be_enabled():
  function test_does_not_error_if_min_size_is_bigger_than_default_size (line 135) | def test_does_not_error_if_min_size_is_bigger_than_default_size():
  function test_list_unique_and_unique_by_cannot_both_be_enabled (line 142) | def test_list_unique_and_unique_by_cannot_both_be_enabled():
  function test_min_before_max (line 153) | def test_min_before_max():
  function test_filter_validates (line 158) | def test_filter_validates():
  function test_recursion_validates_base_case (line 163) | def test_recursion_validates_base_case():
  function test_recursion_validates_recursive_step (line 168) | def test_recursion_validates_recursive_step():
  function test_stuff_keyword (line 175) | def test_stuff_keyword(x=1):  # noqa: PT028
  function test_stuff_positional (line 181) | def test_stuff_positional(x=1):  # noqa: PT028
  function test_too_many_positional (line 187) | def test_too_many_positional(x):
  function test_given_warns_on_use_of_non_strategies (line 191) | def test_given_warns_on_use_of_non_strategies():
  function test_given_warns_when_mixing_positional_with_keyword (line 200) | def test_given_warns_when_mixing_positional_with_keyword():
  function test_cannot_find_non_strategies (line 209) | def test_cannot_find_non_strategies():
  function test_valid_sizes (line 224) | def test_valid_sizes(strategy, min_size, max_size):
  function test_check_type_with_tuple_of_length_two (line 233) | def test_check_type_with_tuple_of_length_two():
  function test_validation_happens_on_draw (line 243) | def test_validation_happens_on_draw():
  class SearchStrategy (line 252) | class SearchStrategy:
  function check_type_ (line 256) | def check_type_(*args):
  function test_check_type_suggests_check_strategy (line 260) | def test_check_type_suggests_check_strategy():
  function check_strategy_ (line 266) | def check_strategy_(*args):
  function test_check_strategy_might_suggest_sampled_from (line 270) | def test_check_strategy_might_suggest_sampled_from():
  function test_warn_on_strings_matching_common_codecs (line 282) | def test_warn_on_strings_matching_common_codecs(codec):

FILE: hypothesis-python/tests/cover/test_verbosity.py
  function capture_verbosity (line 23) | def capture_verbosity():
  function test_prints_intermediate_in_success (line 28) | def test_prints_intermediate_in_success():
  function test_does_not_log_in_quiet_mode (line 40) | def test_does_not_log_in_quiet_mode():
  function test_includes_progress_in_verbose_mode (line 53) | def test_includes_progress_in_verbose_mode():
  function test_prints_initial_attempts_on_find (line 66) | def test_prints_initial_attempts_on_find():
  function test_includes_intermediate_results_in_verbose_mode (line 89) | def test_includes_intermediate_results_in_verbose_mode():
  function test_no_indexerror_in_quiet_mode (line 112) | def test_no_indexerror_in_quiet_mode(x):
  function test_no_indexerror_in_quiet_mode_report_multiple (line 122) | def test_no_indexerror_in_quiet_mode_report_multiple(x):
  function test_no_indexerror_in_quiet_mode_report_one (line 130) | def test_no_indexerror_in_quiet_mode_report_one(x):

FILE: hypothesis-python/tests/crosshair/test_conformance.py
  function test_provider_conformance_crosshair (line 18) | def test_provider_conformance_crosshair():

FILE: hypothesis-python/tests/crosshair/test_crosshair.py
  function test_crosshair_works_for_all_verbosities (line 27) | def test_crosshair_works_for_all_verbosities(verbosity):
  function test_crosshair_works_for_all_verbosities_data (line 40) | def test_crosshair_works_for_all_verbosities_data(verbosity):
  function test_hypothesis_realizes_on_fatal_error (line 55) | def test_hypothesis_realizes_on_fatal_error():
  function count_choices_for (line 71) | def count_choices_for(choice_type, constraints):
  function test_no_path_constraints_are_added_to_symbolic_values (line 102) | def test_no_path_constraints_are_added_to_symbolic_values(strategy, expe...
  function test_observability_and_verbosity_dont_add_choices (line 144) | def test_observability_and_verbosity_dont_add_choices(strategy, extra_ob...
  function test_realizes_event (line 198) | def test_realizes_event():
  function test_event_with_realization (line 225) | def test_event_with_realization(value):

FILE: hypothesis-python/tests/datetime/test_dateutil_timezones.py
  function test_utc_is_minimal (line 34) | def test_utc_is_minimal():
  function test_can_generate_non_naive_time (line 38) | def test_can_generate_non_naive_time():
  function test_can_generate_non_naive_datetime (line 42) | def test_can_generate_non_naive_datetime():
  function test_timezone_aware_datetimes_are_timezone_aware (line 49) | def test_timezone_aware_datetimes_are_timezone_aware(dt):
  function test_datetime_bounds_must_be_naive (line 54) | def test_datetime_bounds_must_be_naive(name, val):
  function test_timezones_arg_to_datetimes_must_be_search_strategy (line 59) | def test_timezones_arg_to_datetimes_must_be_search_strategy():
  function test_timezone_aware_times_are_timezone_aware (line 66) | def test_timezone_aware_times_are_timezone_aware(dt):
  function test_can_generate_non_utc (line 70) | def test_can_generate_non_utc():
  function test_time_bounds_must_be_naive (line 77) | def test_time_bounds_must_be_naive(name, val):
  function test_should_have_correct_ordering (line 82) | def test_should_have_correct_ordering():
  function test_datetimes_stay_within_naive_bounds (line 91) | def test_datetimes_stay_within_naive_bounds(data, lo, hi):
  function test_dateutil_exists_our_not_exists_are_inverse (line 108) | def test_dateutil_exists_our_not_exists_are_inverse(value):
  function test_datetimes_can_exclude_imaginary (line 112) | def test_datetimes_can_exclude_imaginary():
  function test_non_imaginary_datetimes_at_boundary (line 132) | def test_non_imaginary_datetimes_at_boundary(val):

FILE: hypothesis-python/tests/datetime/test_pytz_timezones.py
  function test_utc_is_minimal (line 36) | def test_utc_is_minimal():
  function test_can_generate_non_naive_time (line 40) | def test_can_generate_non_naive_time():
  function test_can_generate_non_naive_datetime (line 44) | def test_can_generate_non_naive_datetime():
  function test_timezone_aware_datetimes_are_timezone_aware (line 51) | def test_timezone_aware_datetimes_are_timezone_aware(dt):
  function test_datetime_bounds_must_be_naive (line 56) | def test_datetime_bounds_must_be_naive(name, val):
  function test_underflow_in_simplify (line 61) | def test_underflow_in_simplify():
  function test_overflow_in_simplify (line 71) | def test_overflow_in_simplify():
  function test_timezones_arg_to_datetimes_must_be_search_strategy (line 81) | def test_timezones_arg_to_datetimes_must_be_search_strategy():
  function test_timezone_aware_times_are_timezone_aware (line 91) | def test_timezone_aware_times_are_timezone_aware(dt):
  function test_can_generate_non_utc (line 95) | def test_can_generate_non_utc():
  function test_time_bounds_must_be_naive (line 102) | def test_time_bounds_must_be_naive(name, val):
  function test_can_trigger_error_in_draw_near_boundary (line 114) | def test_can_trigger_error_in_draw_near_boundary(bound):
  function test_datetimes_stay_within_naive_bounds (line 138) | def test_datetimes_stay_within_naive_bounds(data, lo, hi):
  function test_datetimes_can_exclude_imaginary (line 167) | def test_datetimes_can_exclude_imaginary(kw):
  function test_really_weird_tzinfo_case (line 175) | def test_really_weird_tzinfo_case():

FILE: hypothesis-python/tests/datetime/test_zoneinfo_timezones.py
  function test_utc_is_minimal (line 22) | def test_utc_is_minimal():
  function test_can_generate_non_utc (line 26) | def test_can_generate_non_utc():
  function test_datetimes_stay_within_naive_bounds (line 33) | def test_datetimes_stay_within_naive_bounds(data, lo, hi):
  function test_timezones_argument_validation (line 41) | def test_timezones_argument_validation(kwargs):
  function test_timezone_keys_argument_validation (line 54) | def test_timezone_keys_argument_validation(kwargs):
  function test_can_generate_prefixes_if_allowed_and_available (line 61) | def test_can_generate_prefixes_if_allowed_and_available():
  function test_can_disallow_prefixes (line 78) | def test_can_disallow_prefixes():

FILE: hypothesis-python/tests/django/toystore/forms.py
  class ReprModelForm (line 36) | class ReprModelForm(forms.ModelForm):
    method __repr__ (line 37) | def __repr__(self):
  class ReprForm (line 42) | class ReprForm(forms.Form):
    method __repr__ (line 43) | def __repr__(self):
  class CouldBeCharmingForm (line 47) | class CouldBeCharmingForm(ReprModelForm):
    class Meta (line 48) | class Meta:
  class FileFieldsForm (line 53) | class FileFieldsForm(ReprModelForm):
    class Meta (line 54) | class Meta:
  class CustomerForm (line 59) | class CustomerForm(ReprModelForm):
    class Meta (line 60) | class Meta:
  class ManyNumericsForm (line 65) | class ManyNumericsForm(ReprModelForm):
    class Meta (line 66) | class Meta:
  class ManyTimesForm (line 71) | class ManyTimesForm(ReprModelForm):
    class Meta (line 72) | class Meta:
  class OddFieldsForm (line 77) | class OddFieldsForm(ReprModelForm):
    class Meta (line 78) | class Meta:
  class DynamicForm (line 83) | class DynamicForm(ReprForm):
    method __init__ (line 84) | def __init__(self, field_count=5, **kwargs):
  class BasicFieldForm (line 91) | class BasicFieldForm(ReprForm):
  class TemporalFieldForm (line 113) | class TemporalFieldForm(ReprForm):
  class WithValidatorsForm (line 121) | class WithValidatorsForm(ReprForm):
  class EmailFieldForm (line 130) | class EmailFieldForm(ReprForm):
  class SlugFieldForm (line 134) | class SlugFieldForm(ReprForm):
  class URLFieldForm (line 138) | class URLFieldForm(ReprForm):
  class RegexFieldForm (line 142) | class RegexFieldForm(ReprForm):
  class UUIDFieldForm (line 146) | class UUIDFieldForm(ReprForm):
  class ChoiceFieldForm (line 150) | class ChoiceFieldForm(ReprForm):
  class InternetProtocolForm (line 169) | class InternetProtocolForm(ReprForm):
  class BroadBooleanInput (line 175) | class BroadBooleanInput(widgets.CheckboxInput):
    method value_from_datadict (line 180) | def value_from_datadict(self, data, files, name):
  class MultiCheckboxWidget (line 191) | class MultiCheckboxWidget(widgets.MultiWidget):
    method __init__ (line 192) | def __init__(self, subfield_count=12, **kwargs):
    method decompress (line 196) | def decompress(self, value):
  class BroadBooleanField (line 206) | class BroadBooleanField(forms.BooleanField):
  class MultiBooleanField (line 210) | class MultiBooleanField(forms.MultiValueField):
    method __init__ (line 211) | def __init__(self, subfield_count=12, **kwargs):
    method compress (line 216) | def compress(self, values):
  class ManyMultiValueForm (line 220) | class ManyMultiValueForm(ReprForm):
    method __init__ (line 221) | def __init__(self, subfield_count=12, **kwargs):
  class ShortStringForm (line 226) | class ShortStringForm(ReprForm):
  class UsernameForm (line 232) | class UsernameForm(ReprForm):
  class ReadOnlyPasswordHashFieldForm (line 235) | class ReadOnlyPasswordHashFieldForm(ReprForm):
  class StoreForm (line 243) | class StoreForm(ReprModelForm):
    class Meta (line 246) | class Meta:
  class MultipleCompaniesForm (line 251) | class MultipleCompaniesForm(ReprForm):

FILE: hypothesis-python/tests/django/toystore/models.py
  class Company (line 17) | class Company(models.Model):
  class Store (line 21) | class Store(models.Model):
  class Car (line 26) | class Car(models.Model):
  class CharmField (line 31) | class CharmField(models.Field):
    method db_type (line 32) | def db_type(self, connection):
  class CustomishField (line 36) | class CustomishField(models.Field):
    method db_type (line 37) | def db_type(self, connection):
  class Customish (line 41) | class Customish(models.Model):
  class Customer (line 45) | class Customer(models.Model):
  class Charming (line 53) | class Charming(models.Model):
  class CouldBeCharming (line 57) | class CouldBeCharming(models.Model):
  class SelfLoop (line 61) | class SelfLoop(models.Model):
  class LoopA (line 65) | class LoopA(models.Model):
  class LoopB (line 69) | class LoopB(models.Model):
  class ManyNumerics (line 73) | class ManyNumerics(models.Model):
  class ManyTimes (line 84) | class ManyTimes(models.Model):
  class OddFields (line 90) | class OddFields(models.Model):
  class CustomishDefault (line 98) | class CustomishDefault(models.Model):
  class FileFields (line 102) | class FileFields(models.Model):
  class MandatoryComputed (line 106) | class MandatoryComputed(models.Model):
    method __init__ (line 110) | def __init__(self, **kw):
  function validate_even (line 118) | def validate_even(value):
  class RestrictedFields (line 123) | class RestrictedFields(models.Model):
  class SelfModifyingField (line 142) | class SelfModifyingField(models.IntegerField):
    method pre_save (line 143) | def pre_save(self, model_instance, add):
  class CompanyExtension (line 150) | class CompanyExtension(models.Model):
  class UserSpecifiedAutoId (line 156) | class UserSpecifiedAutoId(models.Model):
  class Pizza (line 163) | class Pizza(models.Model):

FILE: hypothesis-python/tests/django/toystore/test_basic_configuration.py
  class SomeStuff (line 26) | class SomeStuff:
    method test_is_blank_slate (line 31) | def test_is_blank_slate(self, unused):
    method test_normal_test_1 (line 34) | def test_normal_test_1(self):
    method test_normal_test_2 (line 37) | def test_normal_test_2(self):
  class TestConstraintsWithTransactions (line 41) | class TestConstraintsWithTransactions(SomeStuff, TestCase):
  class TestConstraintsWithoutTransactions (line 49) | class TestConstraintsWithoutTransactions(SomeStuff, TransactionTestCase):
  class TestWorkflow (line 53) | class TestWorkflow(VanillaTestCase):
    method test_does_not_break_later_tests (line 54) | def test_does_not_break_later_tests(self):
    method test_given_needs_hypothesis_test_case (line 77) | def test_given_needs_hypothesis_test_case(self):
  class TestSimple (line 87) | class TestSimple(SimpleTestCase):
    method test_that_doesnt_need_db (line 89) | def test_that_doesnt_need_db(self, z: int):

FILE: hypothesis-python/tests/django/toystore/test_given_forms.py
  class TestGetsBasicForms (line 58) | class TestGetsBasicForms(TestCase):
    method test_valid_customer (line 60) | def test_valid_customer(self, customer_form):
    method test_valid_numerics (line 64) | def test_valid_numerics(self, numerics_form):
    method test_valid_times (line 68) | def test_valid_times(self, times_form):
    method test_valid_odd_fields (line 72) | def test_valid_odd_fields(self, odd_form):
    method test_dynamic_form (line 75) | def test_dynamic_form(self):
    method test_basic_fields_form (line 85) | def test_basic_fields_form(self, basic_field_form):
    method test_temporal_fields_form (line 89) | def test_temporal_fields_form(self, time_field_form):
    method test_email_field_form (line 93) | def test_email_field_form(self, email_field_form):
    method test_slug_field_form (line 97) | def test_slug_field_form(self, slug_field_form):
    method test_url_field_form (line 101) | def test_url_field_form(self, url_field_form):
    method test_regex_field_form (line 105) | def test_regex_field_form(self, regex_field_form):
    method test_uuid_field_form (line 109) | def test_uuid_field_form(self, uuid_field_form):
    method test_choice_fields_form (line 113) | def test_choice_fields_form(self, choice_field_form):
    method test_ip_fields_form (line 117) | def test_ip_fields_form(self, ip_field_form):
    method test_many_values_in_multi_value_field (line 121) | def test_many_values_in_multi_value_field(self, many_multi_value_form):
    method test_excessive_values_in_multi_value_field (line 125) | def test_excessive_values_in_multi_value_field(self, excessive_form):
    method test_short_string_form (line 129) | def test_short_string_form(self, short_string_form):
    method test_tight_validators_form (line 133) | def test_tight_validators_form(self, x):
    method test_file_fields_form (line 140) | def test_file_fields_form(self, x):
    method test_username_form (line 149) | def test_username_form(self, username_form):
    method test_read_only_password_hash_field_form (line 154) | def test_read_only_password_hash_field_form(self, password_form):
  class TestFormsWithModelChoices (line 158) | class TestFormsWithModelChoices(TestCase):
    method setUpTestData (line 160) | def setUpTestData(cls):
    method test_from_model_choices_field (line 175) | def test_from_model_choices_field(self, choice):
    method test_from_model_choices_field_no_empty_choice (line 187) | def test_from_model_choices_field_no_empty_choice(self, choice):
    method test_from_model_choices_field_empty (line 191) | def test_from_model_choices_field_empty(self, choice):
    method test_store_form_valid (line 195) | def test_store_form_valid(self, form):
    method test_from_model_multiple_choices_field (line 204) | def test_from_model_multiple_choices_field(self, choice):
    method test_multiple_companies_form_valid (line 210) | def test_multiple_companies_form_valid(self, form):

FILE: hypothesis-python/tests/django/toystore/test_given_models.py
  class TestGetsBasicModels (line 57) | class TestGetsBasicModels(TestCase):
    method test_is_company (line 59) | def test_is_company(self, company):
    method test_can_get_a_store (line 64) | def test_can_get_a_store(self, store):
    method test_can_get_multiple_models_with_unique_field (line 68) | def test_can_get_multiple_models_with_unique_field(self, companies):
    method test_is_customer (line 78) | def test_is_customer(self, customer):
    method test_tz_presence (line 85) | def test_tz_presence(self, customer):
    method test_is_not_charming (line 92) | def test_is_not_charming(self, not_charming):
    method test_sl (line 98) | def test_sl(self, sl):
    method test_no_overflow_in_integer (line 102) | def test_no_overflow_in_integer(self, manyints):
    method test_custom_field (line 106) | def test_custom_field(self, x):
    method test_mandatory_fields_are_mandatory (line 109) | def test_mandatory_fields_are_mandatory(self):
    method test_mandatory_computed_fields_are_mandatory (line 113) | def test_mandatory_computed_fields_are_mandatory(self):
    method test_mandatory_computed_fields_may_not_be_provided (line 117) | def test_mandatory_computed_fields_may_not_be_provided(self):
    method test_customish_default_overridden_by_infer (line 124) | def test_customish_default_overridden_by_infer(self, x):
    method test_customish_infer_uses_registered_instead_of_default (line 128) | def test_customish_infer_uses_registered_instead_of_default(self, x):
    method test_odd_fields (line 132) | def test_odd_fields(self, x):
    method test_time_fields (line 143) | def test_time_fields(self, x):
    method test_no_null_in_charfield (line 149) | def test_no_null_in_charfield(self, x):
    method test_foreign_key_primary (line 154) | def test_foreign_key_primary(self, data):
  class TestsNeedingRollback (line 169) | class TestsNeedingRollback(TransactionTestCase):
    method test_can_get_examples (line 170) | def test_can_get_examples(self):
  class TestRestrictedFields (line 175) | class TestRestrictedFields(TestCase):
    method test_constructs_valid_instance (line 177) | def test_constructs_valid_instance(self, instance):
  class TestValidatorInference (line 193) | class TestValidatorInference(TestCase):
    method test_user_issue_1112_regression (line 195) | def test_user_issue_1112_regression(self, user):
  class TestPosOnlyArg (line 199) | class TestPosOnlyArg(TestCase):
    method test_user_issue_2369_regression (line 201) | def test_user_issue_2369_regression(self, val):
    method test_from_model_signature (line 204) | def test_from_model_signature(self):
  class TestUserSpecifiedAutoId (line 210) | class TestUserSpecifiedAutoId(TestCase):
    method test_user_specified_auto_id (line 212) | def test_user_specified_auto_id(self, user_specified_auto_id):
  class TestModelWithGeneratedField (line 220) | class TestModelWithGeneratedField(TestCase):
    method test_create_pizza (line 222) | def test_create_pizza(self, pizza):

FILE: hypothesis-python/tests/dpcontracts/test_contracts.py
  function invert (line 22) | def invert(n):
  function test_contract_filter_builds (line 27) | def test_contract_filter_builds(x):
  function test_contract_filter_inline (line 32) | def test_contract_filter_inline(n):
  function test_no_vacuous_fulfill (line 37) | def test_no_vacuous_fulfill(f):

FILE: hypothesis-python/tests/ghostwriter/example_code/future_annotations.py
  class CustomClass (line 16) | class CustomClass:
    method __init__ (line 17) | def __init__(self, number: int) -> None:
  function add_custom_classes (line 21) | def add_custom_classes(c1: CustomClass, c2: CustomClass | None = None) -...
  function merge_dicts (line 27) | def merge_dicts(
  function invalid_types (line 33) | def invalid_types(attr1: int, attr2: UnknownClass, attr3: str) -> None: ...

FILE: hypothesis-python/tests/ghostwriter/test_expected_output.py
  function update_recorded_outputs (line 52) | def update_recorded_outputs(request):
  function get_recorded (line 56) | def get_recorded(name, actual=""):
  function timsort (line 63) | def timsort(seq: Sequence[int]) -> Sequence[int]:
  function with_docstring (line 67) | def with_docstring(a, b, c, d=int, e=lambda x: f"xx{x}xx") -> None:
  class A_Class (line 80) | class A_Class:
    method a_classmethod (line 82) | def a_classmethod(cls, arg: int):
    method a_staticmethod (line 86) | def a_staticmethod(arg: int):
  function add (line 90) | def add(a: float, b: float) -> float:
  function divide (line 94) | def divide(a: int, b: int) -> float:
  function optional_parameter (line 102) | def optional_parameter(a: float, b: float | None) -> float:
  function optional_union_parameter (line 106) | def optional_union_parameter(a: float, b: float | int | None) -> float:
  function union_sequence_parameter (line 110) | def union_sequence_parameter(items: Sequence[float | int]) -> float:
  function sequence_from_collections (line 114) | def sequence_from_collections(items: collections.abc.Sequence[int]) -> int:
  function various_numpy_annotations (line 118) | def various_numpy_annotations(
  function test_ghostwriter_example_outputs (line 298) | def test_ghostwriter_example_outputs(update_recorded_outputs, data):
  function test_ghostwriter_on_hypothesis (line 308) | def test_ghostwriter_on_hypothesis(update_recorded_outputs):
  function test_ghostwriter_suggests_submodules_for_empty_toplevel (line 323) | def test_ghostwriter_suggests_submodules_for_empty_toplevel(

FILE: hypothesis-python/tests/ghostwriter/test_ghostwriter.py
  function get_test_function (line 47) | def get_test_function(source_code, settings_decorator=lambda fn: fn):
  function test_invalid_exceptions (line 69) | def test_invalid_exceptions(badness):
  function test_style_validation (line 74) | def test_style_validation():
  function test_strategies_with_invalid_syntax_repr_as_nothing (line 81) | def test_strategies_with_invalid_syntax_repr_as_nothing():
  class AnEnum (line 93) | class AnEnum(enum.Enum):
  function takes_enum (line 98) | def takes_enum(foo=AnEnum.a):
  function test_ghostwriter_exploits_arguments_with_enum_defaults (line 104) | def test_ghostwriter_exploits_arguments_with_enum_defaults():
  function timsort (line 111) | def timsort(seq: Sequence[int]) -> list[int]:
  function non_type_annotation (line 115) | def non_type_annotation(x: 3):  # type: ignore
  function annotated_any (line 119) | def annotated_any(x: Any):
  class NotResolvable (line 126) | class NotResolvable:
    method __init__ (line 127) | def __init__(self, unannotated_required):
  function non_resolvable_arg (line 131) | def non_resolvable_arg(x: NotResolvable):
  function test_flattens_one_of_repr (line 135) | def test_flattens_one_of_repr():
  function takes_keys (line 141) | def takes_keys(x: KeysView[int]) -> None:
  function takes_values (line 145) | def takes_values(x: ValuesView[int]) -> None:
  function takes_match (line 149) | def takes_match(x: re.Match[bytes]) -> None:
  function takes_pattern (line 153) | def takes_pattern(x: re.Pattern[str]) -> None:
  function takes_sized (line 157) | def takes_sized(x: Sized) -> None:
  function takes_frozensets (line 161) | def takes_frozensets(a: frozenset[int], b: frozenset[int]) -> None:
  class Foo (line 166) | class Foo:
  function takes_attrs_class (line 170) | def takes_attrs_class(x: Foo) -> None:
  function test_ghostwriter_fuzz (line 196) | def test_ghostwriter_fuzz(func, ex):
  function test_socket_module (line 201) | def test_socket_module():
  function test_binary_op_also_handles_frozensets (line 206) | def test_binary_op_also_handles_frozensets():
  function test_binary_op_with_numpy_arrays_includes_imports (line 213) | def test_binary_op_with_numpy_arrays_includes_imports():
  function test_ghostwriter_unittest_style (line 238) | def test_ghostwriter_unittest_style(func, ex):
  function no_annotations (line 243) | def no_annotations(foo=None, *, bar=False):
  function test_inference_from_defaults_and_none_booleans_reprs_not_just_and_sampled_from (line 247) | def test_inference_from_defaults_and_none_booleans_reprs_not_just_and_sa...
  function hopefully_hashable (line 252) | def hopefully_hashable(foo: set[Decimal]):
  function test_no_hashability_filter (line 256) | def test_no_hashability_filter():
  function test_invalid_func_inputs (line 278) | def test_invalid_func_inputs(gw, args):
  class A (line 283) | class A:
    method to_json (line 285) | def to_json(cls, obj: dict | list) -> str:
    method from_json (line 289) | def from_json(cls, obj: str) -> dict | list:
    method static_sorter (line 293) | def static_sorter(seq: Sequence[int]) -> list[int]:
  function test_class_methods_inputs (line 306) | def test_class_methods_inputs(gw, args):
  function test_run_ghostwriter_fuzz (line 311) | def test_run_ghostwriter_fuzz():
  class MyError (line 319) | class MyError(UnicodeDecodeError):
  function test_exception_deduplication (line 334) | def test_exception_deduplication(exceptions, output):
  function test_run_ghostwriter_roundtrip (line 346) | def test_run_ghostwriter_roundtrip():
  function test_ghostwriter_idempotent (line 377) | def test_ghostwriter_idempotent(func, ex):
  function test_overlapping_args_use_union_of_strategies (line 387) | def test_overlapping_args_use_union_of_strategies():
  function test_module_with_mock_does_not_break (line 398) | def test_module_with_mock_does_not_break():
  function compose_types (line 405) | def compose_types(x: type, y: type):
  function test_unrepr_identity_elem (line 409) | def test_unrepr_identity_elem():
  function test_get_imports_for_strategy (line 465) | def test_get_imports_for_strategy(strategy, imports):
  function temp_script_file (line 470) | def temp_script_file():
  function temp_script_file_with_py_function (line 491) | def temp_script_file_with_py_function():
  function test_obj_name (line 511) | def test_obj_name(temp_script_file, temp_script_file_with_py_function):
  function test_gets_public_location_not_impl_location (line 543) | def test_gets_public_location_not_impl_location():
  class ForwardRefA (line 547) | class ForwardRefA:
  function test_parameter_to_annotation (line 570) | def test_parameter_to_annotation(parameter, type_name):

FILE: hypothesis-python/tests/ghostwriter/test_ghostwriter_cli.py
  function run (line 39) | def run(cmd, *, cwd=None):
  function test_cli_python_equivalence (line 76) | def test_cli_python_equivalence(cli, code):
  function test_cli_too_many_functions (line 106) | def test_cli_too_many_functions(cli, err_msg):
  function test_can_import_from_scripts_in_working_dir (line 122) | def test_can_import_from_scripts_in_working_dir(tmp_path):
  function test_can_import_from_class (line 148) | def test_can_import_from_class(tmp_path, func):
  function test_error_import_from_class (line 163) | def test_error_import_from_class(tmp_path, classname, thing, kind):
  function test_magic_discovery_from_module (line 171) | def test_magic_discovery_from_module(tmp_path):
  function test_roundtrip_correct_pairs (line 212) | def test_roundtrip_correct_pairs(tmp_path):
  function test_empty_module_is_not_error (line 227) | def test_empty_module_is_not_error(tmp_path):

FILE: hypothesis-python/tests/ghostwriter/try-writing-for-installed.py
  function getmodules (line 34) | def getmodules():
  function write_for (line 48) | def write_for(mod):

FILE: hypothesis-python/tests/lark/test_grammar.py
  function test_generates_valid_json (line 52) | def test_generates_valid_json(string):
  function test_can_specify_start_rule (line 69) | def test_can_specify_start_rule(data, start, type_):
  function test_can_generate_ignored_tokens (line 75) | def test_can_generate_ignored_tokens():
  function test_generation_without_whitespace (line 88) | def test_generation_without_whitespace():
  function test_cannot_convert_EBNF_to_strategy_directly (line 92) | def test_cannot_convert_EBNF_to_strategy_directly():
  function test_required_undefined_terminals_require_explicit_strategies (line 106) | def test_required_undefined_terminals_require_explicit_strategies():
  function test_cannot_use_explicit_strategies_for_unknown_terminals (line 119) | def test_cannot_use_explicit_strategies_for_unknown_terminals():
  function test_non_string_explicit_strategies_are_invalid (line 128) | def test_non_string_explicit_strategies_are_invalid():
  function test_can_override_defined_terminal (line 138) | def test_can_override_defined_terminal(string):
  function test_can_generate_from_limited_alphabet (line 143) | def test_can_generate_from_limited_alphabet(string):
  function test_can_generate_from_limited_alphabet_no_comma (line 148) | def test_can_generate_from_limited_alphabet_no_comma(string):
  function test_can_generate_from_limited_alphabet_no_comma_json (line 158) | def test_can_generate_from_limited_alphabet_no_comma_json(string):
  function test_error_if_alphabet_bans_all_start_rules (line 162) | def test_error_if_alphabet_bans_all_start_rules():

FILE: hypothesis-python/tests/nocover/test_argument_validation.py
  function adjust (line 24) | def adjust(ex, **kwargs):
  function test_consistent_with_api_guide_on_kwonly_args (line 51) | def test_consistent_with_api_guide_on_kwonly_args(name):

FILE: hypothesis-python/tests/nocover/test_bad_repr.py
  class BadRepr (line 14) | class BadRepr:
    method __init__ (line 15) | def __init__(self, value):
    method __repr__ (line 18) | def __repr__(self):
  function test_just_frosty (line 25) | def test_just_frosty():
  function test_sampling_snowmen (line 29) | def test_sampling_snowmen():
  function varargs (line 33) | def varargs(*args, **kwargs):
  function test_sampled_from_bad_repr (line 63) | def test_sampled_from_bad_repr(c):

FILE: hypothesis-python/tests/nocover/test_baseexception.py
  function test_exception_propagates_fine (line 23) | def test_exception_propagates_fine(e):
  function test_exception_propagates_fine_from_strategy (line 35) | def test_exception_propagates_fine_from_strategy(e):
  function test_baseexception_no_rerun_no_flaky (line 53) | def test_baseexception_no_rerun_no_flaky(e):
  function test_baseexception_in_strategy_no_rerun_no_flaky (line 79) | def test_baseexception_in_strategy_no_rerun_no_flaky(e):
  function test_explanations (line 129) | def test_explanations(testdir, exc_name, use_composite):

FILE: hypothesis-python/tests/nocover/test_boundary_exploration.py
  function test_explore_arbitrary_function (line 23) | def test_explore_arbitrary_function(strat, data):

FILE: hypothesis-python/tests/nocover/test_build_signature.py
  function use_this_signature (line 19) | def use_this_signature(self, a: int, b: list | None = None, *, x: float,...
  class Model (line 23) | class Model:
    method __init__ (line 29) | def __init__(self, **kwargs):
  function test_builds_uses_signature_attribute (line 38) | def test_builds_uses_signature_attribute(val):
  class ModelForFromType (line 42) | class ModelForFromType(Model):
    method __init__ (line 43) | def __init__(self, **kwargs):
  function test_from_type_uses_signature_attribute (line 50) | def test_from_type_uses_signature_attribute(val):
  function test_from_type_can_be_default_or_annotation (line 54) | def test_from_type_can_be_default_or_annotation():
  function use_annotations (line 59) | def use_annotations(
  function use_signature (line 65) | def use_signature(
  class ModelWithAlias (line 71) | class ModelWithAlias:
    method __init__ (line 75) | def __init__(self, **kwargs):
  function test_build_using_different_signature_and_annotations (line 85) | def test_build_using_different_signature_and_annotations(val):
  function use_bad_signature (line 89) | def use_bad_signature(self, testA: 1, *, testX: float):
  class ModelWithBadAliasSignature (line 93) | class ModelWithBadAliasSignature:
    method __init__ (line 97) | def __init__(self, **kwargs):
  function test_build_with_non_types_in_signature (line 103) | def test_build_with_non_types_in_signature(val):
  class UnconventionalSignature (line 107) | class UnconventionalSignature:
    method __init__ (line 108) | def __init__(x: int = 0, self: bool = True):  # noqa
  function test_build_in_from_type_with_self_named_something_else (line 113) | def test_build_in_from_type_with_self_named_something_else():

FILE: hypothesis-python/tests/nocover/test_cache_implementation.py
  class CacheWithScores (line 24) | class CacheWithScores(GenericCache):
    method __init__ (line 25) | def __init__(self, max_size):
    method new_entry (line 29) | def new_entry(self, key, value):
  class CacheRules (line 33) | class CacheRules(RuleBasedStateMachine):
    method create_cache (line 37) | def create_cache(self, max_size):
    method new_key (line 61) | def new_key(self, key, score):
    method set_key (line 67) | def set_key(self, key):
    method check_values (line 75) | def check_values(self):
    method pin_key (line 81) | def pin_key(self, key):
    method unpin_key (line 89) | def unpin_key(self, key):

FILE: hypothesis-python/tests/nocover/test_cacheable.py
  function test_is_cacheable (line 30) | def test_is_cacheable(s):
  function test_is_not_cacheable (line 42) | def test_is_not_cacheable(s):
  function test_non_cacheable_things_are_not_cached (line 46) | def test_non_cacheable_things_are_not_cached():
  function test_cacheable_things_are_cached (line 51) | def test_cacheable_things_are_cached():
  function test_local_types_are_garbage_collected_issue_493 (line 57) | def test_local_types_are_garbage_collected_issue_493():

FILE: hypothesis-python/tests/nocover/test_characters.py
  function test_large_blacklist (line 24) | def test_large_blacklist(c):
  function test_arbitrary_blacklist (line 30) | def test_arbitrary_blacklist(data):
  function _enc (line 43) | def _enc(cdc):
  function test_can_constrain_characters_to_codec (line 61) | def test_can_constrain_characters_to_codec(data, codec):

FILE: hypothesis-python/tests/nocover/test_collective_minimization.py
  function test_can_collectively_minimize (line 22) | def test_can_collectively_minimize(spec):

FILE: hypothesis-python/tests/nocover/test_compat.py
  function test_convert_back (line 18) | def test_convert_back(bs):
  function test_to_int_in_big_endian_order (line 27) | def test_to_int_in_big_endian_order(x, y):
  function test_to_bytes_in_big_endian_order (line 36) | def test_to_bytes_in_big_endian_order(x, y):
  function test_ceil (line 42) | def test_ceil(x):
  function test_floor (line 49) | def test_floor(x):

FILE: hypothesis-python/tests/nocover/test_completion.py
  function test_never_draw_anything (line 15) | def test_never_draw_anything(data):

FILE: hypothesis-python/tests/nocover/test_complex_numbers.py
  function test_magnitude_validates (line 19) | def test_magnitude_validates(width, keyword, data):

FILE: hypothesis-python/tests/nocover/test_conjecture_engine.py
  function test_lot_of_dead_nodes (line 27) | def test_lot_of_dead_nodes():
  function test_saves_data_while_shrinking (line 38) | def test_saves_data_while_shrinking(monkeypatch):
  function test_can_discard (line 68) | def test_can_discard(monkeypatch):
  function test_cached_with_masked_byte_agrees_with_results (line 91) | def test_cached_with_masked_byte_agrees_with_results(a, b):
  function test_node_programs_fail_efficiently (line 108) | def test_node_programs_fail_efficiently(monkeypatch):

FILE: hypothesis-python/tests/nocover/test_conjecture_int_list.py
  function valid_index (line 19) | def valid_index(draw):
  class IntListRules (line 26) | class IntListRules(RuleBasedStateMachine):
    method starting_lists (line 28) | def starting_lists(self, ls):
    method lists_are_equivalent (line 33) | def lists_are_equivalent(self):
    method append (line 41) | def append(self, n):
    method delete (line 46) | def delete(self, i):
    method agree_on_values (line 51) | def agree_on_values(self, i):

FILE: hypothesis-python/tests/nocover/test_conjecture_utils.py
  function test_sampler_matches_distribution (line 24) | def test_sampler_matches_distribution(weights, random):
  function test_p_continue (line 57) | def test_p_continue(average_size, max_size):
  function test_p_continue_to_average (line 68) | def test_p_continue_to_average(p_continue, max_size):

FILE: hypothesis-python/tests/nocover/test_conventions.py
  function test_unique_identifier_repr (line 14) | def test_unique_identifier_repr():

FILE: hypothesis-python/tests/nocover/test_database_agreement.py
  class DatabaseComparison (line 26) | class DatabaseComparison(RuleBasedStateMachine):
    method __init__ (line 27) | def __init__(self):
    method k (line 42) | def k(self, k):
    method v (line 46) | def v(self, v):
    method save (line 50) | def save(self, k, v):
    method delete (line 55) | def delete(self, k, v):
    method move (line 60) | def move(self, k1, k2, v):
    method values_agree (line 65) | def values_agree(self, k):
    method teardown (line 75) | def teardown(self):
  function test_database_equivalence (line 82) | def test_database_equivalence():

FILE: hypothesis-python/tests/nocover/test_database_usage.py
  function has_a_non_zero_byte (line 31) | def has_a_non_zero_byte(x):
  function test_saves_incremental_steps_in_database (line 35) | def test_saves_incremental_steps_in_database():
  function test_clears_out_database_as_things_get_boring (line 48) | def test_clears_out_database_as_things_get_boring():
  function test_trashes_invalid_examples (line 81) | def test_trashes_invalid_examples():
  function test_respects_max_examples_in_database_usage (line 116) | def test_respects_max_examples_in_database_usage():
  function test_does_not_use_database_when_seed_is_forced (line 147) | def test_does_not_use_database_when_seed_is_forced(monkeypatch):
  function test_database_not_created_when_not_used (line 162) | def test_database_not_created_when_not_used(tmp_path_factory, key, value):
  function test_ga_database_not_created_when_not_used (line 174) | def test_ga_database_not_created_when_not_used(tmp_path_factory):

FILE: hypothesis-python/tests/nocover/test_deferred_errors.py
  function test_does_not_error_on_initial_calculation (line 20) | def test_does_not_error_on_initial_calculation():
  function test_errors_each_time (line 27) | def test_errors_each_time():
  function test_errors_on_test_invocation (line 35) | def test_errors_on_test_invocation():
  function test_errors_on_find (line 44) | def test_errors_on_find():
  function test_errors_on_example (line 50) | def test_errors_on_example():
  function test_does_not_recalculate_the_strategy (line 56) | def test_does_not_recalculate_the_strategy():

FILE: hypothesis-python/tests/nocover/test_drypython_returns.py
  class KindN (line 30) | class KindN(Generic[_InstanceType, _TypeArgType1]):
  class Lawful (line 34) | class Lawful(Generic[_LawType]):
  class MappableN (line 38) | class MappableN(Generic[_FirstType], Lawful["MappableN[_FirstType]"]):
  class MyFunctor (line 48) | class MyFunctor(KindN["MyFunctor", _ValueType], MappableN[_ValueType]):
    method __init__ (line 49) | def __init__(self, inner_value: _ValueType) -> None:
  function target_func (line 57) | def target_func(mappable: "MappableN[_FirstType]") -> bool:
  function test_my_mappable (line 62) | def test_my_mappable(source: st.DataObject) -> None:
  class _FirstBase (line 85) | class _FirstBase(Generic[A, B]):
  class _SecondBase (line 89) | class _SecondBase(Generic[C, D]):
  class TwoGenericBases1 (line 96) | class TwoGenericBases1(_FirstBase[A, B], _SecondBase[C, D]):
  class TwoGenericBases2 (line 100) | class TwoGenericBases2(_FirstBase[C, D], _SecondBase[A, B]):
  class OneGenericOneConrete1 (line 104) | class OneGenericOneConrete1(_FirstBase[int, str], _SecondBase[A, B]):
  class OneGenericOneConrete2 (line 108) | class OneGenericOneConrete2(_FirstBase[A, B], _SecondBase[float, bool]):
  class MixedGenerics1 (line 112) | class MixedGenerics1(_FirstBase[int, B], _SecondBase[C, bool]):
  class MixedGenerics2 (line 116) | class MixedGenerics2(_FirstBase[A, str], _SecondBase[float, D]):
  class AllConcrete (line 120) | class AllConcrete(_FirstBase[int, str], _SecondBase[float, bool]):
  function test_several_generic_bases (line 136) | def test_several_generic_bases(type_):
  function var_generic_func1 (line 144) | def var_generic_func1(obj: _FirstBase[A, B]):
  function var_generic_func2 (line 148) | def var_generic_func2(obj: _SecondBase[A, B]):
  function concrete_generic_func1 (line 152) | def concrete_generic_func1(obj: _FirstBase[int, str]):
  function concrete_generic_func2 (line 156) | def concrete_generic_func2(obj: _SecondBase[float, bool]):
  function mixed_generic_func1 (line 160) | def mixed_generic_func1(obj: _FirstBase[A, str]):
  function mixed_generic_func2 (line 164) | def mixed_generic_func2(obj: _SecondBase[float, D]):
  function test_several_generic_bases_functions (line 180) | def test_several_generic_bases_functions(type_, func):
  function wrong_generic_func1 (line 191) | def wrong_generic_func1(obj: _FirstBase[A, None]):
  function wrong_generic_func2 (line 195) | def wrong_generic_func2(obj: _SecondBase[None, bool]):
  function test_several_generic_bases_wrong_functions (line 200) | def test_several_generic_bases_wrong_functions(func):

FILE: hypothesis-python/tests/nocover/test_duplication.py
  class Blocks (line 21) | class Blocks(SearchStrategy):
    method __init__ (line 22) | def __init__(self, n):
    method do_draw (line 26) | def do_draw(self, data):
  function test_does_not_duplicate_blocks (line 32) | def test_does_not_duplicate_blocks(n):
  function test_mostly_does_not_duplicate_blocks_even_when_failing (line 46) | def test_mostly_does_not_duplicate_blocks_even_when_failing(n):

FILE: hypothesis-python/tests/nocover/test_dynamic_variable.py
  function test_can_assign (line 14) | def test_can_assign():
  function test_can_nest (line 22) | def test_can_nest():

FILE: hypothesis-python/tests/nocover/test_emails.py
  function test_is_valid_email (line 23) | def test_is_valid_email(address: str):
  function test_can_restrict_email_domains (line 33) | def test_can_restrict_email_domains(address: str):

FILE: hypothesis-python/tests/nocover/test_eval_as_source.py
  function test_can_eval_as_source (line 14) | def test_can_eval_as_source():
  function test_caches (line 18) | def test_caches():
  function test_can_call_self_recursively (line 33) | def test_can_call_self_recursively():

FILE: hypothesis-python/tests/nocover/test_exceptiongroup.py
  function test_exceptiongroup_discard_frozen (line 27) | def test_exceptiongroup_discard_frozen():
  function test_exceptiongroup_nested (line 47) | def test_exceptiongroup_nested() -> None:
  function test_exceptiongroup_user_originated (line 64) | def test_exceptiongroup_user_originated() -> None:
  function test_exceptiongroup_multiple_stop (line 90) | def test_exceptiongroup_multiple_stop() -> None:
  function test_exceptiongroup_stop_and_hypothesisexception (line 108) | def test_exceptiongroup_stop_and_hypothesisexception() -> None:
  function test_exceptiongroup_multiple_hypothesisexception (line 131) | def test_exceptiongroup_multiple_hypothesisexception() -> None:
  function test_exceptiongroup_multiple_InvalidArgument (line 150) | def test_exceptiongroup_multiple_InvalidArgument() -> None:

FILE: hypothesis-python/tests/nocover/test_explore_arbitrary_languages.py
  class Write (line 35) | class Write:
  class Branch (line 41) | class Branch:
  class Terminal (line 47) | class Terminal:
  function run_language_test_for (line 70) | def run_language_test_for(root, data, seed):
  function test_explore_an_arbitrary_language (line 123) | def test_explore_an_arbitrary_language(data):
  function test_run_specific_example (line 130) | def test_run_specific_example(seed, language):

FILE: hypothesis-python/tests/nocover/test_fancy_repr.py
  function test_floats_is_floats (line 14) | def test_floats_is_floats():
  function test_includes_non_default_values (line 18) | def test_includes_non_default_values():
  function foo (line 22) | def foo(*args, **kwargs):
  function test_builds_repr (line 31) | def test_builds_repr():
  function test_map_repr (line 36) | def test_map_repr():
  function test_filter_repr (line 42) | def test_filter_repr():
  function test_flatmap_repr (line 47) | def test_flatmap_repr():

FILE: hypothesis-python/tests/nocover/test_filtering.py
  function test_filter_correctly (line 21) | def test_filter_correctly(specifier, condition):
  function test_chained_filters_agree (line 44) | def test_chained_filters_agree(data, forbidden_values, base):
  function test_chained_filters_repr (line 59) | def test_chained_filters_repr(base):

FILE: hypothesis-python/tests/nocover/test_find.py
  function test_can_find_an_int (line 22) | def test_can_find_an_int():
  function test_can_find_list (line 27) | def test_can_find_list():
  function test_can_find_nan (line 32) | def test_can_find_nan():
  function test_can_find_nans (line 36) | def test_can_find_nans():
  function test_condition_is_name (line 44) | def test_condition_is_name():
  function test_find_dictionary (line 62) | def test_find_dictionary():

FILE: hypothesis-python/tests/nocover/test_fixtures.py
  function test_time_consistently_increments_in_tests (line 18) | def test_time_consistently_increments_in_tests():

FILE: hypothesis-python/tests/nocover/test_flatmap.py
  function test_constant_lists_are_constant (line 40) | def test_constant_lists_are_constant(x):
  function test_in_order (line 47) | def test_in_order(x):
  function test_flatmap_retrieve_from_db (line 54) | def test_flatmap_retrieve_from_db():
  function test_flatmap_does_not_reuse_strategies (line 77) | def test_flatmap_does_not_reuse_strategies():
  function test_flatmap_has_original_strategy_repr (line 82) | def test_flatmap_has_original_strategy_repr():
  function test_mixed_list_flatmap (line 92) | def test_mixed_list_flatmap():
  function test_can_shrink_through_a_binding (line 106) | def test_can_shrink_through_a_binding(n):
  function test_can_delete_in_middle_of_a_binding (line 115) | def test_can_delete_in_middle_of_a_binding(n):

FILE: hypothesis-python/tests/nocover/test_floating.py
  function test_is_float (line 32) | def test_is_float(x):
  function test_inversion_is_imperfect (line 39) | def test_inversion_is_imperfect(x):
  function test_largest_range (line 46) | def test_largest_range(x):
  function test_negation_is_self_inverse (line 52) | def test_negation_is_self_inverse(x):
  function test_is_not_nan (line 61) | def test_is_not_nan(xs):
  function test_is_not_positive_infinite (line 68) | def test_is_not_positive_infinite(x):
  function test_is_not_negative_infinite (line 76) | def test_is_not_negative_infinite(x):
  function test_is_int (line 84) | def test_is_int(x):
  function test_is_not_int (line 92) | def test_is_not_int(x):
  function test_is_in_exact_int_range (line 100) | def test_is_in_exact_int_range(x):
  function test_can_find_floats_that_do_not_round_trip_through_strings (line 108) | def test_can_find_floats_that_do_not_round_trip_through_strings(x):
  function test_can_find_floats_that_do_not_round_trip_through_reprs (line 115) | def test_can_find_floats_that_do_not_round_trip_through_reprs(x):
  function test_floats_are_in_range (line 124) | def test_floats_are_in_range(x, y, data):
  function test_can_find_negative_and_signaling_nans (line 134) | def test_can_find_negative_and_signaling_nans(neg, snan):

FILE: hypothesis-python/tests/nocover/test_from_type_recipe.py
  function everything_except (line 26) | def everything_except(excluded_types):
  function test_recipe_for_everything_except (line 41) | def test_recipe_for_everything_except(excluded_types, data):
  function test_issue_4144_regression (line 46) | def test_issue_4144_regression():

FILE: hypothesis-python/tests/nocover/test_given_error_conditions.py
  function test_raises_unsatisfiable_if_all_false (line 21) | def test_raises_unsatisfiable_if_all_false(x):

FILE: hypothesis-python/tests/nocover/test_given_reuse.py
  function test_has_an_arg_named_x (line 19) | def test_has_an_arg_named_x(x):
  function test_has_an_arg_named_y (line 24) | def test_has_an_arg_named_y(y):
  function test_fail_independently (line 31) | def test_fail_independently():

FILE: hypothesis-python/tests/nocover/test_health_checks.py
  function test_large_data_will_fail_a_health_check (line 31) | def test_large_data_will_fail_a_health_check():
  function test_large_base_example_fails_health_check (line 42) | def test_large_base_example_fails_health_check():
  function test_example_that_shrinks_to_overrun_fails_health_check (line 53) | def test_example_that_shrinks_to_overrun_fails_health_check():
  function slow_init_integers (line 67) | def slow_init_integers(*args, **kwargs):
  function test_lazy_slow_initialization_issue_2108_regression (line 78) | def test_lazy_slow_initialization_issue_2108_regression(data):
  function test_does_not_trigger_health_check_on_simple_strategies (line 85) | def test_does_not_trigger_health_check_on_simple_strategies(monkeypatch):
  function test_does_not_trigger_health_check_when_most_examples_are_small (line 109) | def test_does_not_trigger_health_check_when_most_examples_are_small():

FILE: hypothesis-python/tests/nocover/test_imports.py
  function test_can_star_import_from_hypothesis (line 15) | def test_can_star_import_from_hypothesis():

FILE: hypothesis-python/tests/nocover/test_integer_ranges.py
  function test_bounded_integers_distribution_of_bit_width_issue_1387_regression (line 18) | def test_bounded_integers_distribution_of_bit_width_issue_1387_regressio...

FILE: hypothesis-python/tests/nocover/test_interesting_origin.py
  function go_wrong_naive (line 19) | def go_wrong_naive(a, b):
  function go_wrong_with_cause (line 29) | def go_wrong_with_cause(a, b):
  function go_wrong_coverup (line 38) | def go_wrong_coverup(a, b):
  function test_can_generate_specified_version (line 54) | def test_can_generate_specified_version(function):

FILE: hypothesis-python/tests/nocover/test_labels.py
  function test_labels_are_cached (line 18) | def test_labels_are_cached():
  function test_labels_are_distinct (line 23) | def test_labels_are_distinct():
  function foo (line 28) | def foo(draw):
  function bar (line 33) | def bar(draw):
  function baz (line 38) | def baz(draw):
  function test_equivalent_composites_have_same_label (line 42) | def test_equivalent_composites_have_same_label():
  function test_different_composites_have_different_labels (line 46) | def test_different_composites_have_different_labels():
  function test_one_of_label_is_distinct (line 50) | def test_one_of_label_is_distinct():
  function test_lists_label_by_element (line 56) | def test_lists_label_by_element():
  function test_label_of_deferred_strategy_is_well_defined (line 60) | def test_label_of_deferred_strategy_is_well_defined():
  function test_sampled_from_label_with_strategies_does_not_change (line 74) | def test_sampled_from_label_with_strategies_does_not_change(strategy):
  function test_label_of_enormous_sampled_range (line 80) | def test_label_of_enormous_sampled_range():
  function test_draw_uses_wrapped_label (line 92) | def test_draw_uses_wrapped_label(strategy):
  function test_deferred_label (line 102) | def test_deferred_label():

FILE: hypothesis-python/tests/nocover/test_large_examples.py
  function test_can_generate_large_lists_with_min_size (line 16) | def test_can_generate_large_lists_with_min_size():

FILE: hypothesis-python/tests/nocover/test_limits.py
  function test_max_examples_are_respected (line 17) | def test_max_examples_are_respected():

FILE: hypothesis-python/tests/nocover/test_modify_inner_test.py
  function always_passes (line 19) | def always_passes(*args, **kwargs):
  function test_can_replace_inner_test (line 28) | def test_can_replace_inner_test(x):
  function decorator (line 35) | def decorator(func):
  function test_can_replace_when_decorated (line 47) | def test_can_replace_when_decorated(x):
  function test_can_replace_when_parametrized (line 56) | def test_can_replace_when_parametrized(x, y):
  function test_can_replace_when_original_is_invalid (line 63) | def test_can_replace_when_original_is_invalid():
  function test_inner_is_original_even_when_invalid (line 77) | def test_inner_is_original_even_when_invalid():
  function test_invokes_inner_function_with_args_by_name (line 96) | def test_invokes_inner_function_with_args_by_name():

FILE: hypothesis-python/tests/nocover/test_nesting.py
  function test_nesting_1 (line 19) | def test_nesting_1():

FILE: hypothesis-python/tests/nocover/test_precise_shrinking.py
  function safe_draw (line 77) | def safe_draw(data, strategy):
  function precisely_shrink (line 87) | def precisely_shrink(
  function minimal_for_strategy (line 151) | def minimal_for_strategy(s):
  function minimal_nodes_for_strategy (line 155) | def minimal_nodes_for_strategy(s):
  function test_strategy_list_is_in_sorted_order (line 159) | def test_strategy_list_is_in_sorted_order():
  function test_can_precisely_shrink_values (line 167) | def test_can_precisely_shrink_values(typ, strat, require_truthy):
  function test_can_precisely_shrink_alternatives (line 191) | def test_can_precisely_shrink_alternatives(i, j, a, seed):
  function test_precise_shrink_with_blocker (line 208) | def test_precise_shrink_with_blocker(a, seed):
  function find_random (line 227) | def find_random(
  function shrinks (line 243) | def shrinks(strategy, nodes, *, allow_sloppy=True, seed=0):
  function test_always_shrinks_to_none (line 301) | def test_always_shrinks_to_none(a, seed, block_falsey, allow_sloppy):
  function test_can_shrink_to_every_smaller_alternative (line 316) | def test_can_shrink_to_every_smaller_alternative(i, alts, seed, force_sm...

FILE: hypothesis-python/tests/nocover/test_pretty_repr.py
  function foo (line 20) | def foo(x):
  function bar (line 24) | def bar(x):
  function baz (line 28) | def baz(x):
  function builds_ignoring_invalid (line 35) | def builds_ignoring_invalid(target, *args, **kwargs):
  function test_repr_evals_to_thing_with_same_repr (line 100) | def test_repr_evals_to_thing_with_same_repr(strategy):
  function test_sampled_transform_reprs (line 115) | def test_sampled_transform_reprs(r):

FILE: hypothesis-python/tests/nocover/test_randomization.py
  function test_seeds_off_internal_random (line 31) | def test_seeds_off_internal_random():
  function test_nesting_with_control_passes_health_check (line 54) | def test_nesting_with_control_passes_health_check():

FILE: hypothesis-python/tests/nocover/test_recursive.py
  function test_can_generate_with_large_branching (line 22) | def test_can_generate_with_large_branching():
  function test_can_generate_some_depth_with_large_branching (line 42) | def test_can_generate_some_depth_with_large_branching():
  function test_can_find_quite_broad_lists (line 56) | def test_can_find_quite_broad_lists():
  function test_drawing_many_near_boundary (line 73) | def test_drawing_many_near_boundary():
  function test_can_use_recursive_data_in_sets (line 85) | def test_can_use_recursive_data_in_sets():
  function test_can_form_sets_of_recursive_data (line 109) | def test_can_form_sets_of_recursive_data():
  function test_drawing_from_recursive_strategy_is_thread_safe (line 126) | def test_drawing_from_recursive_strategy_is_thread_safe():
  function test_self_ref_regression (line 167) | def test_self_ref_regression(_):
  function test_gc_hooks_do_not_cause_unraisable_recursionerror (line 175) | def test_gc_hooks_do_not_cause_unraisable_recursionerror(testdir):

FILE: hypothesis-python/tests/nocover/test_regex.py
  function charset (line 26) | def charset(draw):
  function conservative_regex (line 39) | def conservative_regex(draw):
  function test_conservative_regex_are_correct_by_construction (line 67) | def test_conservative_regex_are_correct_by_construction(data):
  function test_fuzz_stuff (line 77) | def test_fuzz_stuff(data):
  function test_regex_atomic_group (line 107) | def test_regex_atomic_group(data):
  function test_regex_possessive (line 115) | def test_regex_possessive(data):
  function test_case_insensitive_not_literal_never_constructs_multichar_match (line 128) | def test_case_insensitive_not_literal_never_constructs_multichar_match(d...
  function test_no_error_converting_negated_sets_to_strategy (line 141) | def test_no_error_converting_negated_sets_to_strategy(s):

FILE: hypothesis-python/tests/nocover/test_regressions.py
  function test_note_deprecation_blames_right_code_issue_652 (line 20) | def test_note_deprecation_blames_right_code_issue_652():
  function test_performance_issue_2027 (line 47) | def test_performance_issue_2027(x, y):
  function test_unique_floats_with_nan_is_not_flaky_3926 (line 57) | def test_unique_floats_with_nan_is_not_flaky_3926(ls):
  function test_overrun_during_datatree_simulation_3874 (line 66) | def test_overrun_during_datatree_simulation_3874(n):
  function test_explain_phase_label_assertion_4339 (line 70) | def test_explain_phase_label_assertion_4339():

FILE: hypothesis-python/tests/nocover/test_reusable_values.py
  function reusable (line 45) | def reusable():
  function is_valid (line 68) | def is_valid(s):
  function many_examples (line 81) | def many_examples(examples):
  function test_reusable_strategies_are_all_reusable (line 96) | def test_reusable_strategies_are_all_reusable(s):
  function test_filter_breaks_reusability (line 102) | def test_filter_breaks_reusability(s):
  function test_map_breaks_reusability (line 116) | def test_map_breaks_reusability(s):
  function test_flatmap_breaks_reusability (line 133) | def test_flatmap_breaks_reusability(s):
  function test_mutable_collections_do_not_have_reusable_values (line 156) | def test_mutable_collections_do_not_have_reusable_values(strat):
  function test_recursion_does_not_break_reusability (line 160) | def test_recursion_does_not_break_reusability():

FILE: hypothesis-python/tests/nocover/test_sampled_from.py
  function test_filter_large_lists (line 29) | def test_filter_large_lists(data, size):
  function rare_value_strategy (line 43) | def rare_value_strategy(n, target):
  function test_chained_filters_find_rare_value (line 57) | def test_chained_filters_find_rare_value(x):
  function test_unsat_sets_of_samples (line 63) | def test_unsat_sets_of_samples(x):
  function test_efficient_sets_of_samples (line 68) | def test_efficient_sets_of_samples(x):
  class AnEnum (line 72) | class AnEnum(enum.Enum):
  function test_enum_repr_uses_class_not_a_list (line 77) | def test_enum_repr_uses_class_not_a_list():
  function test_repr_truncates_with_many_elements (line 84) | def test_repr_truncates_with_many_elements():
  class AFlag (line 90) | class AFlag(enum.Flag):
  class UnnamedFlag (line 99) | class UnnamedFlag(enum.Flag):
  function test_flag_enum_repr_uses_class_not_a_list (line 105) | def test_flag_enum_repr_uses_class_not_a_list():
  function test_exhaustive_flags (line 110) | def test_exhaustive_flags():
  function test_flags_minimize_to_first_named_flag (line 128) | def test_flags_minimize_to_first_named_flag():
  function test_flags_minimizes_bit_count (line 132) | def test_flags_minimizes_bit_count():
  function test_flags_finds_all_bits_set (line 143) | def test_flags_finds_all_bits_set():
  function test_sample_unnamed_alias (line 147) | def test_sample_unnamed_alias():
  function test_shrink_to_named_empty (line 151) | def test_shrink_to_named_empty():

FILE: hypothesis-python/tests/nocover/test_scrutineer.py
  function get_reports (line 56) | def get_reports(file_contents, *, testdir):
  function test_explanations (line 81) | def test_explanations(code, testdir):
  function test_no_explanations_if_deadline_exceeded (line 90) | def test_no_explanations_if_deadline_exceeded(code, testdir):
  function test_skips_uninformative_locations (line 114) | def test_skips_uninformative_locations(testdir):
  function test_report_sort (line 121) | def test_report_sort(random):

FILE: hypothesis-python/tests/nocover/test_sets.py
  function test_can_draw_sets_of_hard_to_find_elements (line 17) | def test_can_draw_sets_of_hard_to_find_elements():
  function test_empty_sets (line 23) | def test_empty_sets(x):
  function test_bounded_size_sets (line 28) | def test_bounded_size_sets(x):

FILE: hypothesis-python/tests/nocover/test_sharing.py
  function test_sharing_is_by_instance_by_default (line 19) | def test_sharing_is_by_instance_by_default(a, b):
  function test_different_instances_with_the_same_key_are_shared (line 24) | def test_different_instances_with_the_same_key_are_shared(a, b):
  function test_different_instances_are_not_shared (line 28) | def test_different_instances_are_not_shared():
  function test_different_keys_are_not_shared (line 35) | def test_different_keys_are_not_shared():
  function test_keys_and_default_are_not_shared (line 42) | def test_keys_and_default_are_not_shared():
  function test_can_simplify_shared_lists (line 49) | def test_can_simplify_shared_lists():
  function test_simplify_shared_linked_to_size (line 56) | def test_simplify_shared_linked_to_size():

FILE: hypothesis-python/tests/nocover/test_simple_numbers.py
  function test_minimize_negative_int (line 23) | def test_minimize_negative_int():
  function test_positive_negative_int (line 28) | def test_positive_negative_int():
  function test_minimizes_int_down_to_boundary (line 45) | def test_minimizes_int_down_to_boundary(boundary):
  function test_minimizes_int_up_to_boundary (line 50) | def test_minimizes_int_up_to_boundary(boundary):
  function test_minimizes_ints_from_down_to_boundary (line 55) | def test_minimizes_ints_from_down_to_boundary(boundary):
  function test_minimizes_negative_integer_range_upwards (line 65) | def test_minimizes_negative_integer_range_upwards():
  function test_minimizes_integer_range_to_boundary (line 70) | def test_minimizes_integer_range_to_boundary(boundary):
  function test_single_integer_range_is_range (line 74) | def test_single_integer_range_is_range():
  function test_minimal_small_number_in_large_range (line 78) | def test_minimal_small_number_in_large_range():
  function test_minimal_small_sum_float_list (line 82) | def test_minimal_small_sum_float_list():
  function test_minimals_boundary_floats (line 87) | def test_minimals_boundary_floats():
  function test_minimal_non_boundary_float (line 95) | def test_minimal_non_boundary_float():
  function test_minimal_float_is_zero (line 100) | def test_minimal_float_is_zero():
  function test_minimal_asymetric_bounded_float (line 104) | def test_minimal_asymetric_bounded_float():
  function test_negative_floats_simplify_to_zero (line 108) | def test_negative_floats_simplify_to_zero():
  function test_minimal_infinite_float_is_positive (line 112) | def test_minimal_infinite_float_is_positive():
  function test_can_minimal_infinite_negative_float (line 116) | def test_can_minimal_infinite_negative_float():
  function test_can_minimal_float_on_boundary_of_representable (line 122) | def test_can_minimal_float_on_boundary_of_representable():
  function test_minimize_nan (line 126) | def test_minimize_nan():
  function test_minimize_very_large_float (line 130) | def test_minimize_very_large_float():
  function is_integral (line 135) | def is_integral(value):
  function test_can_minimal_float_far_from_integral (line 142) | def test_can_minimal_float_far_from_integral():
  function test_list_of_fractional_float (line 146) | def test_list_of_fractional_float():
  function test_minimal_fractional_float (line 155) | def test_minimal_fractional_float():
  function test_minimizes_lists_of_negative_ints_up_to_boundary (line 160) | def test_minimizes_lists_of_negative_ints_up_to_boundary():
  function test_floats_in_constrained_range (line 172) | def test_floats_in_constrained_range(left, right):
  function test_bounds_are_respected (line 180) | def test_bounds_are_respected():
  function test_floats_from_zero_have_reasonable_range (line 186) | def test_floats_from_zero_have_reasonable_range(k):
  function test_explicit_allow_nan (line 192) | def test_explicit_allow_nan():
  function test_one_sided_contains_infinity (line 196) | def test_one_sided_contains_infinity():
  function test_no_allow_infinity_upper (line 202) | def test_no_allow_infinity_upper(x):
  function test_no_allow_infinity_lower (line 207) | def test_no_allow_infinity_lower(x):
  class TestFloatsAreFloats (line 211) | class TestFloatsAreFloats:
    method test_unbounded (line 213) | def test_unbounded(self, arg):
    method test_int_float (line 217) | def test_int_float(self, arg):
    method test_float_float (line 221) | def test_float_float(self, arg):

FILE: hypothesis-python/tests/nocover/test_simple_strings.py
  function test_does_not_generate_surrogates (line 25) | def test_does_not_generate_surrogates(t):

FILE: hypothesis-python/tests/nocover/test_skipping.py
  function test_no_falsifying_example_if_unittest_skip (line 25) | def test_no_falsifying_example_if_unittest_skip(skip_exception):
  function test_skip_exceptions_save_database_entries (line 45) | def test_skip_exceptions_save_database_entries():

FILE: hypothesis-python/tests/nocover/test_stateful.py
  function run_to_notes (line 29) | def run_to_notes(TestClass):
  function assert_runs_to_output (line 41) | def assert_runs_to_output(TestClass, output):
  class BalancedTrees (line 51) | class BalancedTrees(RuleBasedStateMachine):
    method leaf (line 55) | def leaf(self, x):
    method split (line 59) | def split(self, left, right):
    method test_is_balanced (line 63) | def test_is_balanced(self, tree):
    method size (line 71) | def size(self, tree):
  class DepthCharge (line 78) | class DepthCharge:
    method __init__ (line 79) | def __init__(self, value):
  class DepthMachine (line 86) | class DepthMachine(RuleBasedStateMachine):
    method charge (line 90) | def charge(self, child):
    method none_charge (line 94) | def none_charge(self):
    method is_not_too_deep (line 98) | def is_not_too_deep(self, check):
  class RoseTreeStateMachine (line 102) | class RoseTreeStateMachine(RuleBasedStateMachine):
    method bunch (line 106) | def bunch(self, source):
    method shallow (line 110) | def shallow(self, source):
  class NotTheLastMachine (line 117) | class NotTheLastMachine(RuleBasedStateMachine):
    method __init__ (line 120) | def __init__(self):
    method hi (line 126) | def hi(self):
    method bye (line 133) | def bye(self, v):
  class PopulateMultipleTargets (line 138) | class PopulateMultipleTargets(RuleBasedStateMachine):
    method populate (line 143) | def populate(self):
    method fail (line 147) | def fail(self, x, y):
  class CanSwarm (line 151) | class CanSwarm(RuleBasedStateMachine):
    method __init__ (line 162) | def __init__(self):
    method ladder (line 167) | def ladder(self, move):
    method snake (line 172) | def snake(self):
  function test_bad_machines_fail (line 197) | def test_bad_machines_fail(machine):
  class MyStatefulMachine (line 209) | class MyStatefulMachine(RuleBasedStateMachine):
    method __init__ (line 210) | def __init__(self):
    method step (line 215) | def step(self):
  class TestMyStatefulMachine (line 220) | class TestMyStatefulMachine(MyStatefulMachine.TestCase):
  function test_multiple_precondition_bug (line 224) | def test_multiple_precondition_bug():
  class UnrelatedCall (line 282) | class UnrelatedCall(RuleBasedStateMachine):
    method __init__ (line 285) | def __init__(self):
    method add_a (line 290) | def add_a(self, a):
    method f (line 295) | def f(self, v):
    method unrelated (line 300) | def unrelated(self, value):
    method invariant (line 304) | def invariant(self):
  function test_unrelated_rule_does_not_use_var_reference_repr (line 310) | def test_unrelated_rule_does_not_use_var_reference_repr():
  class SourceSameAsTarget (line 328) | class SourceSameAsTarget(RuleBasedStateMachine):
    method f (line 332) | def f(self, value):
  class SourceSameAsTargetUnclearOrigin (line 337) | class SourceSameAsTargetUnclearOrigin(RuleBasedStateMachine):
    method __init__ (line 340) | def __init__(self):
    method f (line 345) | def f(self, value):
  function test_replaces_when_same_id (line 353) | def test_replaces_when_same_id():
  function test_doesnt_replace_when_different_id (line 365) | def test_doesnt_replace_when_different_id():

FILE: hypothesis-python/tests/nocover/test_strategy_state.py
  class HypothesisSpec (line 38) | class HypothesisSpec(RuleBasedStateMachine):
    method __init__ (line 39) | def __init__(self):
    method teardown (line 49) | def teardown(self):
    method clear_database (line 53) | def clear_database(self):
    method set_database (line 58) | def set_database(self):
    method strategy (line 79) | def strategy(self, spec):
    method sampled_from_strategy (line 83) | def sampled_from_strategy(self, values):
    method strategy_for_tupes (line 87) | def strategy_for_tupes(self, spec):
    method filtered_strategy (line 91) | def filtered_strategy(self, source, level, mixer):
    method list_strategy (line 99) | def list_strategy(self, elements):
    method or_strategy (line 103) | def or_strategy(self, left, right):
    method float (line 107) | def float(self, source):
    method adjust_float (line 111) | def adjust_float(self, source, offset):
    method float_range (line 115) | def float_range(self, left, right):
    method flatmapped_strategy (line 131) | def flatmapped_strategy(self, source, result1, result2, mixer, p):
    method just_strategy (line 145) | def just_strategy(self, value):
    method single_tuple (line 149) | def single_tuple(self, source):
    method cat_tuples (line 153) | def cat_tuples(self, left, right):
    method get_example (line 157) | def get_example(self, strat, data):
    method integer_range (line 161) | def integer_range(self, left, right):
    method repr_is_good (line 166) | def repr_is_good(self, strat):

FILE: hypothesis-python/tests/nocover/test_subnormal_floats.py
  function test_python_compiled_with_sane_math_options (line 23) | def test_python_compiled_with_sane_math_options():
  function test_can_generate_subnormals (line 37) | def test_can_generate_subnormals():
  function test_does_not_generate_subnormals_when_disallowed (line 47) | def test_does_not_generate_subnormals_when_disallowed(width, min_value, ...

FILE: hypothesis-python/tests/nocover/test_targeting.py
  function test_reports_target_results (line 32) | def test_reports_target_results(testdir, multiple):
  function test_targeting_increases_max_length (line 42) | def test_targeting_increases_max_length():
  function test_target_returns_value (line 56) | def test_target_returns_value(a, b):
  function test_targeting_can_be_disabled (line 63) | def test_targeting_can_be_disabled():
  function test_issue_2395_regression (line 93) | def test_issue_2395_regression():

FILE: hypothesis-python/tests/nocover/test_testdecorators.py
  function test_contains_the_test_function_name_in_the_exception_string (line 19) | def test_contains_the_test_function_name_in_the_exception_string():
  function test_signature_mismatch_error_message (line 45) | def test_signature_mismatch_error_message():
  function test_fixed_dict_preserves_iteration_order (line 62) | def test_fixed_dict_preserves_iteration_order(data, keys):

FILE: hypothesis-python/tests/nocover/test_threading.py
  function test_can_run_given_in_thread (line 32) | def test_can_run_given_in_thread():
  function test_run_stateful_test_concurrently (line 46) | def test_run_stateful_test_concurrently():
  function do_work (line 63) | def do_work(*, multiplier=1):
  function test_run_different_tests_in_threads (line 69) | def test_run_different_tests_in_threads():
  function test_run_given_concurrently (line 87) | def test_run_given_concurrently():
  function test_stackframes_restores_original_recursion_limit (line 96) | def test_stackframes_restores_original_recursion_limit():
  function test_handles_invalid_args_cleanly (line 130) | def test_handles_invalid_args_cleanly(strategy):
  function test_single_thread_can_raise_deadline_exceeded (line 146) | def test_single_thread_can_raise_deadline_exceeded():
  function test_deadline_exceeded_not_raised_under_concurrent_threads (line 164) | def test_deadline_exceeded_not_raised_under_concurrent_threads():
  function test_deadline_exceeded_can_be_raised_after_threads (line 182) | def test_deadline_exceeded_can_be_raised_after_threads():
  function test_one_of_branches_lock (line 203) | def test_one_of_branches_lock():

FILE: hypothesis-python/tests/nocover/test_type_lookup.py
  function test_non_runtime_type_cannot_be_resolved (line 38) | def test_non_runtime_type_cannot_be_resolved(non_runtime_type):
  function test_non_runtime_type_cannot_be_registered (line 47) | def test_non_runtime_type_cannot_be_registered(non_runtime_type):
  function test_callable_with_concatenate (line 55) | def test_callable_with_concatenate():
  function test_callable_with_paramspec (line 70) | def test_callable_with_paramspec():
  function test_callable_return_typegard_type (line 85) | def test_callable_return_typegard_type(typ):
  function test_binary_type_resolution (line 101) | def test_binary_type_resolution():

FILE: hypothesis-python/tests/nocover/test_type_lookup_forward_ref.py
  function test_mutually_recursive_types_with_typevar (line 35) | def test_mutually_recursive_types_with_typevar(data):
  function test_mutually_recursive_types_with_typevar_alternate (line 55) | def test_mutually_recursive_types_with_typevar_alternate(data):

FILE: hypothesis-python/tests/nocover/test_type_lookup_future_annotations.py
  class A (line 25) | class A(TypedDict):
  class B (line 29) | class B(TypedDict):
  function test_complex_forward_ref_in_typed_dict (line 35) | def test_complex_forward_ref_in_typed_dict(d):
  function test_complex_forward_ref_in_typed_dict_local (line 41) | def test_complex_forward_ref_in_typed_dict_local():

FILE: hypothesis-python/tests/nocover/test_unusual_settings_configs.py
  function test_single_example (line 16) | def test_single_example(n):
  function test_hard_to_find_single_example (line 27) | def test_hard_to_find_single_example(n):

FILE: hypothesis-python/tests/nocover/test_uuids.py
  function test_are_unique (line 19) | def test_are_unique(ls):
  function test_retains_uniqueness_in_simplify (line 23) | def test_retains_uniqueness_in_simplify():
  function test_can_generate_specified_version (line 29) | def test_can_generate_specified_version(version):

FILE: hypothesis-python/tests/numpy/test_argument_validation.py
  function e (line 22) | def e(a, **kwargs):
  function test_raise_invalid_argument (line 276) | def test_raise_invalid_argument(function, kwargs):
  function test_raise_invalid_argument_deprecated (line 289) | def test_raise_invalid_argument_deprecated(function, kwargs):

FILE: hypothesis-python/tests/numpy/test_deprecation.py
  function test_basic_indices_bad_min_dims_warns (line 21) | def test_basic_indices_bad_min_dims_warns():
  function test_basic_indices_bad_max_dims_warns (line 26) | def test_basic_indices_bad_max_dims_warns():
  function test_basic_indices_default_max_dims_does_not_warn (line 31) | def test_basic_indices_default_max_dims_does_not_warn():

FILE: hypothesis-python/tests/numpy/test_fill_values.py
  function test_generated_lists_are_distinct (line 18) | def test_generated_lists_are_distinct(ls):
  function distinct_integers (line 23) | def distinct_integers(draw):
  function test_does_not_reuse_distinct_integers (line 31) | def test_does_not_reuse_distinct_integers(arr):
  function test_may_reuse_distinct_integers_if_asked (line 35) | def test_may_reuse_distinct_integers_if_asked():
  function test_minimizes_to_fill (line 42) | def test_minimizes_to_fill():
  function test_fills_everything (line 55) | def test_fills_everything(x):

FILE: hypothesis-python/tests/numpy/test_floor_ceil.py
  function test_our_floor_and_ceil_avoid_numpy_rounding (line 34) | def test_our_floor_and_ceil_avoid_numpy_rounding(value):

FILE: hypothesis-python/tests/numpy/test_from_dtype.py
  function test_strategies_for_standard_dtypes_have_reusable_values (line 58) | def test_strategies_for_standard_dtypes_have_reusable_values(dtype):
  function test_produces_instances (line 63) | def test_produces_instances(t):
  function test_infer_strategy_from_dtype (line 74) | def test_infer_strategy_from_dtype(dtype, data):
  function test_can_cast_for_scalars (line 85) | def test_can_cast_for_scalars(data):
  function test_unicode_string_dtypes_generate_unicode_strings (line 100) | def test_unicode_string_dtypes_generate_unicode_strings(data):
  function test_can_unicode_strings_without_decode_error (line 107) | def test_can_unicode_strings_without_decode_error(arr):
  function test_unicode_string_dtypes_need_not_be_utf8 (line 113) | def test_unicode_string_dtypes_need_not_be_utf8():
  function test_byte_string_dtypes_generate_unicode_strings (line 125) | def test_byte_string_dtypes_generate_unicode_strings(data):
  function test_unsized_strings_length_gt_one (line 138) | def test_unsized_strings_length_gt_one(dtype):
  function test_inferring_from_time_dtypes_gives_same_dtype (line 151) | def test_inferring_from_time_dtypes_gives_same_dtype(data, dtype):
  function test_inferred_string_strategies_roundtrip (line 157) | def test_inferred_string_strategies_roundtrip(data, dtype):
  function test_all_inferred_scalar_strategies_roundtrip (line 167) | def test_all_inferred_scalar_strategies_roundtrip(data, dtype):
  function test_from_dtype_works_without_time_unit (line 180) | def test_from_dtype_works_without_time_unit(data, dtype_str):
  function test_arrays_selects_consistent_time_unit (line 187) | def test_arrays_selects_consistent_time_unit(data, dtype_str):
  function test_from_dtype_can_include_or_exclude_nat (line 193) | def test_from_dtype_can_include_or_exclude_nat(dtype):
  function test_arrays_gives_useful_error_on_inconsistent_time_unit (line 199) | def test_arrays_gives_useful_error_on_inconsistent_time_unit():
  function test_from_dtype_with_kwargs (line 257) | def test_from_dtype_with_kwargs(data, dtype, kwargs, pred):
  function test_customize_structured_dtypes (line 263) | def test_customize_structured_dtypes(x):
  function test_float_subnormal_generation (line 272) | def test_float_subnormal_generation(allow_subnormal, width):
  function test_complex_subnormal_generation (line 286) | def test_complex_subnormal_generation(allow_subnormal, width):

FILE: hypothesis-python/tests/numpy/test_from_type.py
  function test_resolves_dtype_type (line 31) | def test_resolves_dtype_type(dtype):
  function test_does_not_resolve_nonscalar_types (line 35) | def test_does_not_resolve_nonscalar_types():
  function test_resolves_and_varies_numpy_scalar_type (line 51) | def test_resolves_and_varies_numpy_scalar_type(typ):
  function test_resolves_unspecified_array_type (line 58) | def test_resolves_unspecified_array_type(atype):
  function workaround (line 63) | def workaround(dtype):
  function test_resolves_specified_ndarray_type (line 75) | def test_resolves_specified_ndarray_type(typ):
  function test_resolves_specified_NDArray_type (line 89) | def test_resolves_specified_NDArray_type(typ):
  function test_resolves_NDArray_with_dtype_union (line 97) | def test_resolves_NDArray_with_dtype_union():
  function test_resolves_ArrayLike_type (line 105) | def test_resolves_ArrayLike_type(arr_like):
  function test_resolves_specified_NestedSequence (line 114) | def test_resolves_specified_NestedSequence():
  function test_resolves_unspecified_NestedSequence (line 133) | def test_resolves_unspecified_NestedSequence(seq):
  function test_resolves_unspecified_SupportsArray (line 139) | def test_resolves_unspecified_SupportsArray(arr):
  function test_resolves_SupportsArray (line 144) | def test_resolves_SupportsArray():
  function test_resolve_ArrayLike_equivalent (line 156) | def test_resolve_ArrayLike_equivalent():

FILE: hypothesis-python/tests/numpy/test_gen_data.py
  function test_empty_dimensions_are_arrays (line 45) | def test_empty_dimensions_are_arrays(x):
  function test_can_handle_zero_dimensions (line 51) | def test_can_handle_zero_dimensions(x):
  function test_generates_unsigned_ints (line 56) | def test_generates_unsigned_ints(x):
  function test_assert_fits_in_machine_size (line 61) | def test_assert_fits_in_machine_size(x):
  function test_generates_and_minimizes (line 65) | def test_generates_and_minimizes():
  function test_can_minimize_large_arrays (line 69) | def test_can_minimize_large_arrays():
  function test_can_minimize_float_arrays (line 76) | def test_can_minimize_float_arrays():
  class Foo (line 82) | class Foo:
  function test_can_create_arrays_of_composite_types (line 89) | def test_can_create_arrays_of_composite_types():
  function test_can_create_zero_dim_arrays_of_lists (line 96) | def test_can_create_zero_dim_arrays_of_lists(x, data):
  function test_can_create_arrays_of_tuples (line 103) | def test_can_create_arrays_of_tuples():
  function test_does_not_flatten_arrays_of_tuples (line 112) | def test_does_not_flatten_arrays_of_tuples(arr):
  function test_does_not_flatten_arrays_of_lists (line 119) | def test_does_not_flatten_arrays_of_lists(arr):
  function test_can_generate_array_shapes (line 124) | def test_can_generate_array_shapes(shape):
  function test_minimise_array_shapes (line 133) | def test_minimise_array_shapes(min_dims, dim_range, min_side, side_range):
  function test_interesting_array_shapes_argument (line 149) | def test_interesting_array_shapes_argument(kwargs):
  function test_can_generate_scalar_dtypes (line 154) | def test_can_generate_scalar_dtypes(dtype):
  function test_can_generate_compound_dtypes (line 166) | def test_can_generate_compound_dtypes(dtype):
  function test_can_generate_data_compound_dtypes (line 178) | def test_can_generate_data_compound_dtypes(arr):
  function test_np_dtype_is_idempotent (line 184) | def test_np_dtype_is_idempotent(dtype):
  function test_minimise_scalar_dtypes (line 188) | def test_minimise_scalar_dtypes():
  function test_minimise_nested_types (line 192) | def test_minimise_nested_types():
  function test_minimise_array_strategy (line 196) | def test_minimise_array_strategy():
  function test_can_turn_off_subarrays (line 208) | def test_can_turn_off_subarrays(dt):
  function test_array_dtypes_may_have_field_titles (line 213) | def test_array_dtypes_may_have_field_titles():
  function test_can_restrict_endianness (line 219) | def test_can_restrict_endianness(data, byteorder):
  function test_can_specify_size_as_an_int (line 228) | def test_can_specify_size_as_an_int(dt):
  function test_can_draw_arrays_from_scalars (line 233) | def test_can_draw_arrays_from_scalars(data):
  function test_can_cast_for_arrays (line 241) | def test_can_cast_for_arrays(data):
  function test_array_values_are_unique (line 258) | def test_array_values_are_unique(arr):
  function test_cannot_generate_unique_array_of_too_many_elements (line 262) | def test_cannot_generate_unique_array_of_too_many_elements():
  function test_array_values_are_unique_high_collision (line 277) | def test_array_values_are_unique_high_collision(arr):
  function test_generates_all_values_for_unique_array (line 282) | def test_generates_all_values_for_unique_array(arr):
  function test_efficiently_generates_all_unique_array (line 288) | def test_efficiently_generates_all_unique_array(arr):
  function test_array_element_rewriting (line 294) | def test_array_element_rewriting(data, start, size):
  function test_may_fill_with_nan_when_unique_is_set (line 304) | def test_may_fill_with_nan_when_unique_is_set():
  function test_is_still_unique_with_nan_fill (line 326) | def test_is_still_unique_with_nan_fill(xs):
  function test_may_not_fill_with_non_nan_when_unique_is_set (line 340) | def test_may_not_fill_with_non_nan_when_unique_is_set(arr):
  function test_may_not_fill_with_non_nan_when_unique_is_set_and_type_is_not_number (line 346) | def test_may_not_fill_with_non_nan_when_unique_is_set_and_type_is_not_nu...
  function test_overflowing_integers_are_deprecated (line 361) | def test_overflowing_integers_are_deprecated(fill, data):
  function test_unrepresentable_elements_are_deprecated (line 385) | def test_unrepresentable_elements_are_deprecated(fill, dtype, strat, data):
  function test_inferred_floats_do_not_overflow (line 408) | def test_inferred_floats_do_not_overflow(arr):
  function test_inferred_floats_can_be_constrained_at_low_width (line 413) | def test_inferred_floats_can_be_constrained_at_low_width(arr):
  function test_inferred_floats_can_be_constrained_at_low_width_excluding_endpoints (line 430) | def test_inferred_floats_can_be_constrained_at_low_width_excluding_endpo...
  function test_unique_array_with_fill_can_use_all_elements (line 444) | def test_unique_array_with_fill_can_use_all_elements(arr):
  function test_unique_array_without_fill (line 449) | def test_unique_array_without_fill(arr):
  function test_mapped_positive_axes_are_unique (line 457) | def test_mapped_positive_axes_are_unique(ndim, data):
  function test_length_bounds_are_satisfied (line 467) | def test_length_bounds_are_satisfied(ndim, data):
  function test_axes_are_valid_inputs_to_sum (line 477) | def test_axes_are_valid_inputs_to_sum(shape, data):
  function test_minimize_tuple_axes (line 487) | def test_minimize_tuple_axes(ndim, data):
  function test_minimize_negative_tuple_axes (line 499) | def test_minimize_negative_tuple_axes(ndim, data):
  function test_broadcastable_empty_shape (line 510) | def test_broadcastable_empty_shape(shape):
  function test_broadcastable_shape_bounds_are_satisfied (line 516) | def test_broadcastable_shape_bounds_are_satisfied(shape, data):
  function test_mutually_broadcastable_shape_bounds_are_satisfied (line 549) | def test_mutually_broadcastable_shape_bounds_are_satisfied(
  function _draw_valid_bounds (line 592) | def _draw_valid_bounds(data, shape, max_dims, *, permit_none=True):
  function _broadcast_two_shapes (line 612) | def _broadcast_two_shapes(shape_a: nps.Shape, shape_b: nps.Shape) -> nps...
  function _broadcast_shapes (line 623) | def _broadcast_shapes(*shapes):
  function test_broadcastable_shape_util (line 638) | def test_broadcastable_shape_util(shapes):
  function test_broadcastable_shape_has_good_default_values (line 660) | def test_broadcastable_shape_has_good_default_values(shape, data):
  function test_mutually_broadcastableshapes_has_good_default_values (line 671) | def test_mutually_broadcastableshapes_has_good_default_values(
  function test_broadcastable_shape_can_broadcast (line 686) | def test_broadcastable_shape_can_broadcast(min_dims, shape, data):
  function test_mutually_broadcastable_shape_can_broadcast (line 710) | def test_mutually_broadcastable_shape_can_broadcast(
  function test_minimize_mutually_broadcastable_shape (line 740) | def test_minimize_mutually_broadcastable_shape(num_shapes, min_dims, bas...
  function test_broadcastable_shape_adjusts_max_dim_with_explicit_bounds (line 780) | def test_broadcastable_shape_adjusts_max_dim_with_explicit_bounds(max_di...
  function test_mutually_broadcastable_shape_adjusts_max_dim_with_default_bounds (line 802) | def test_mutually_broadcastable_shape_adjusts_max_dim_with_default_bounds(
  function test_broadcastable_shape_shrinking_with_singleton_out_of_bounds (line 842) | def test_broadcastable_shape_shrinking_with_singleton_out_of_bounds(
  function test_mutually_broadcastable_shapes_shrinking_with_singleton_out_of_bounds (line 869) | def test_mutually_broadcastable_shapes_shrinking_with_singleton_out_of_b...
  function test_mutually_broadcastable_shapes_only_singleton_is_valid (line 904) | def test_mutually_broadcastable_shapes_only_singleton_is_valid(
  function test_broadcastable_shape_can_generate_arbitrary_ndims (line 937) | def test_broadcastable_shape_can_generate_arbitrary_ndims(shape, max_dim...
  function test_mutually_broadcastable_shapes_can_generate_arbitrary_ndims (line 959) | def test_mutually_broadcastable_shapes_can_generate_arbitrary_ndims(
  function test_mutually_broadcastable_shapes_can_generate_interesting_singletons (line 990) | def test_mutually_broadcastable_shapes_can_generate_interesting_singletons(
  function test_mutually_broadcastable_shapes_can_generate_mirrored_singletons (line 1005) | def test_mutually_broadcastable_shapes_can_generate_mirrored_singletons(...
  function test_advanced_integer_index_is_valid_with_default_result_shape (line 1029) | def test_advanced_integer_index_is_valid_with_default_result_shape(shape...
  function test_advanced_integer_index_is_valid_and_satisfies_bounds (line 1045) | def test_advanced_integer_index_is_valid_and_satisfies_bounds(
  function test_advanced_integer_index_minimizes_as_documented (line 1078) | def test_advanced_integer_index_minimizes_as_documented(
  function test_advanced_integer_index_can_generate_any_pattern (line 1102) | def test_advanced_integer_index_can_generate_any_pattern(shape, data):
  function test_basic_indices_options (line 1139) | def test_basic_indices_options(condition):
  function test_basic_indices_can_generate_empty_tuple (line 1146) | def test_basic_indices_can_generate_empty_tuple():
  function test_basic_indices_can_generate_non_tuples (line 1150) | def test_basic_indices_can_generate_non_tuples():
  function test_basic_indices_can_generate_long_ellipsis (line 1157) | def test_basic_indices_can_generate_long_ellipsis():
  function test_basic_indices_replaces_whole_axis_slices_with_ellipsis (line 1170) | def test_basic_indices_replaces_whole_axis_slices_with_ellipsis(idx):
  function test_basic_indices_can_generate_indices_not_covering_all_dims (line 1177) | def test_basic_indices_can_generate_indices_not_covering_all_dims():
  function test_basic_indices_generate_valid_indexers (line 1197) | def test_basic_indices_generate_valid_indexers(
  function test_array_owns_memory (line 1251) | def test_array_owns_memory(x: np.ndarray):
  function test_no_recursion_in_multi_line_reprs_issue_3560 (line 1257) | def test_no_recursion_in_multi_line_reprs_issue_3560(data):
  function test_infers_elements_and_fill (line 1267) | def test_infers_elements_and_fill():
  function test_object_arrays_are_of_type_object (line 1284) | def test_object_arrays_are_of_type_object(obj_array):
  function test_class_instances_not_allowed_in_scalar_array (line 1288) | def test_class_instances_not_allowed_in_scalar_array():
  function test_object_arrays_with_mixed_elements_has_object_dtype (line 1304) | def test_object_arrays_with_mixed_elements_has_object_dtype():
  function test_object_array_can_hold_arbitrary_class_instances (line 1319) | def test_object_array_can_hold_arbitrary_class_instances(data):
  function test_object_array_can_hold_incomparable_elements (line 1327) | def test_object_array_can_hold_incomparable_elements():
  function test_can_generate_nested_object_arrays (line 1341) | def test_can_generate_nested_object_arrays():

FILE: hypothesis-python/tests/numpy/test_gufunc.py
  function use_signature_examples (line 22) | def use_signature_examples(func):
  function hy_sig_2_np_sig (line 37) | def hy_sig_2_np_sig(hy_sig):
  function test_frozen_dims_signature (line 44) | def test_frozen_dims_signature():
  function gufunc_arrays (line 49) | def gufunc_arrays(draw, shape_strat, **kwargs):
  function test_matmul_gufunc_shapes (line 63) | def test_matmul_gufunc_shapes(everything):
  function test_matmul_signature_can_exercise_all_combination_of_optional_dims (line 75) | def test_matmul_signature_can_exercise_all_combination_of_optional_dims(
  function test_matmul_sig_shrinks_as_documented (line 98) | def test_matmul_sig_shrinks_as_documented(min_dims, min_side, n_fixed, d...
  function gufunc_sig_to_einsum_sig (line 134) | def gufunc_sig_to_einsum_sig(gufunc_sig):
  function test_einsum_gufunc_shapes (line 170) | def test_einsum_gufunc_shapes(gufunc_sig, data):

FILE: hypothesis-python/tests/numpy/test_import.py
  function test_hypothesis_is_not_the_first_to_import_numpy (line 21) | def test_hypothesis_is_not_the_first_to_import_numpy(testdir):
  function test_wildcard_import (line 37) | def test_wildcard_import():

FILE: hypothesis-python/tests/numpy/test_narrow_floats.py
  function test_bad_float_exclude_min_in_array (line 22) | def test_bad_float_exclude_min_in_array(dtype, low, data):
  function test_float32_exactly_representable (line 31) | def test_float32_exactly_representable(x):
  function test_float16_exactly_representable (line 40) | def test_float16_exactly_representable(x):
  function test_floor_ceil_lossless (line 49) | def test_floor_ceil_lossless(data, dtype):

FILE: hypothesis-python/tests/numpy/test_randomness.py
  function test_numpy_prng_is_seeded (line 17) | def test_numpy_prng_is_seeded():

FILE: hypothesis-python/tests/numpy/test_sampled_from.py
  function test_can_sample_1D_numpy_array_without_warning (line 22) | def test_can_sample_1D_numpy_array_without_warning(data, arr):
  function test_sampling_multi_dimensional_arrays_is_deprecated (line 33) | def test_sampling_multi_dimensional_arrays_is_deprecated(data, arr):

FILE: hypothesis-python/tests/pandas/helpers.py
  function supported_by_pandas (line 16) | def supported_by_pandas(dtype):

FILE: hypothesis-python/tests/pandas/test_argument_validation.py
  function test_timestamp_as_datetime_bounds (line 110) | def test_timestamp_as_datetime_bounds(dt):
  function test_confusing_object_dtype_aliases (line 118) | def test_confusing_object_dtype_aliases():
  function test_pandas_nullable_types_class (line 127) | def test_pandas_nullable_types_class():
  function test_invalid_datetime_or_timedelta_dtype_raises_error (line 144) | def test_invalid_datetime_or_timedelta_dtype_raises_error(dtype_, expect...

FILE: hypothesis-python/tests/pandas/test_data_frame.py
  function test_can_have_columns_of_distinct_types (line 29) | def test_can_have_columns_of_distinct_types(df):
  function test_respects_size_bounds (line 39) | def test_respects_size_bounds(df):
  function test_can_specify_just_column_names (line 44) | def test_can_specify_just_column_names(df):
  function test_can_specify_just_column_count (line 50) | def test_can_specify_just_column_count(df):
  function test_gets_the_correct_data_shape_for_just_rows (line 60) | def test_gets_the_correct_data_shape_for_just_rows(table):
  function test_can_specify_both_rows_and_columns_list (line 71) | def test_can_specify_both_rows_and_columns_list(d):
  function test_can_specify_both_rows_and_columns_tuple (line 86) | def test_can_specify_both_rows_and_columns_tuple(d):
  function test_can_specify_both_rows_and_columns_dict (line 101) | def test_can_specify_both_rows_and_columns_dict(d):
  function test_can_fill_in_missing_elements_from_dict (line 121) | def test_can_fill_in_missing_elements_from_dict(df):
  function column_strategy (line 126) | def column_strategy(draw):
  function test_data_frames_with_timestamp_columns (line 148) | def test_data_frames_with_timestamp_columns(df):
  function test_unique_column_with_fill (line 157) | def test_unique_column_with_fill(df):
  function test_arbitrary_data_frames (line 163) | def test_arbitrary_data_frames(data):
  function test_can_specify_unique_with_rows (line 213) | def test_can_specify_unique_with_rows(df):
  function test_uniqueness_does_not_affect_other_rows_1 (line 218) | def test_uniqueness_does_not_affect_other_rows_1():
  function test_uniqueness_does_not_affect_other_rows_2 (line 230) | def test_uniqueness_does_not_affect_other_rows_2():
  function test_will_fill_missing_columns_in_tuple_row (line 245) | def test_will_fill_missing_columns_in_tuple_row(df):
  function test_can_generate_unique_columns (line 257) | def test_can_generate_unique_columns(df):
  function test_expected_failure_from_omitted_object_dtype (line 263) | def test_expected_failure_from_omitted_object_dtype(dtype):
  function test_pandas_nullable_types (line 282) | def test_pandas_nullable_types():
  function test_object_columns_are_of_type_object (line 290) | def test_object_columns_are_of_type_object(df):
  function test_class_instances_not_allowed_in_scalar_columns (line 294) | def test_class_instances_not_allowed_in_scalar_columns():
  function test_can_generate_object_arrays_with_mixed_dtype_elements (line 312) | def test_can_generate_object_arrays_with_mixed_dtype_elements():
  function test_object_dataframe_can_hold_arbitrary_class_instances (line 330) | def test_object_dataframe_can_hold_arbitrary_class_instances(data):

FILE: hypothesis-python/tests/pandas/test_indexes.py
  function test_gets_right_dtype_for_empty_indices (line 27) | def test_gets_right_dtype_for_empty_indices(ix):
  function test_gets_right_dtype_for_empty_indices_with_elements (line 40) | def test_gets_right_dtype_for_empty_indices_with_elements(ix):
  function test_does_not_generate_impossible_conditions (line 44) | def test_does_not_generate_impossible_conditions():
  function test_unique_indexes_of_small_values (line 50) | def test_unique_indexes_of_small_values(ix):
  function test_unique_indexes_of_many_small_values (line 56) | def test_unique_indexes_of_many_small_values(ix):
  function test_name_passed_on_indexes (line 62) | def test_name_passed_on_indexes(s):
  function test_arbitrary_range_index (line 71) | def test_arbitrary_range_index(i, j, data):
  function test_name_passed_on_range_indexes (line 78) | def test_name_passed_on_range_indexes(s):
  function test_basic_range_indexes (line 83) | def test_basic_range_indexes(ix):
  function test_generate_arbitrary_indices (line 89) | def test_generate_arbitrary_indices(data):

FILE: hypothesis-python/tests/pandas/test_series.py
  function test_can_create_a_series_of_any_dtype (line 30) | def test_can_create_a_series_of_any_dtype(data):
  function test_can_create_a_series_of_object_python_type (line 39) | def test_can_create_a_series_of_object_python_type(series):
  function test_object_series_are_of_type_object (line 53) | def test_object_series_are_of_type_object(series):
  function test_class_instances_not_allowed_in_scalar_series (line 57) | def test_class_instances_not_allowed_in_scalar_series():
  function test_object_series_with_mixed_elements_still_has_object_dtype (line 67) | def test_object_series_with_mixed_elements_still_has_object_dtype():
  function test_series_can_hold_arbitrary_class_instances (line 83) | def test_series_can_hold_arbitrary_class_instances(data):
  function test_series_respects_size_bounds (line 92) | def test_series_respects_size_bounds(s):
  function test_can_fill_series (line 96) | def test_can_fill_series():
  function test_can_generate_integral_series (line 102) | def test_can_generate_integral_series(s):
  function test_will_use_dtype_of_elements (line 107) | def test_will_use_dtype_of_elements(s):
  function test_will_use_a_provided_elements_strategy (line 112) | def test_will_use_a_provided_elements_strategy(s):
  function test_unique_series_are_unique (line 117) | def test_unique_series_are_unique(s):
  function test_name_passed_on (line 122) | def test_name_passed_on(s):
  function test_pandas_nullable_types (line 132) | def test_pandas_nullable_types(dtype):

FILE: hypothesis-python/tests/patching/callables.py
  function fn (line 24) | def fn(x):
  class Cases (line 28) | class Cases:
    method mth (line 31) | def mth(self, n, label):
  function covered (line 38) | def covered(x):
  function undef_name (line 43) | def undef_name(array):

FILE: hypothesis-python/tests/patching/test_patching.py
  function strip_trailing_whitespace (line 63) | def strip_trailing_whitespace(s):
  function test_adds_simple_patch (line 75) | def test_adds_simple_patch(tst, example, expected):
  function test_make_full_patch (line 156) | def test_make_full_patch(tst, example, expected, body, remove):
  function test_invalid_syntax_cases_dropped (line 170) | def test_invalid_syntax_cases_dropped(n):
  function test_no_example_for_data_strategy (line 185) | def test_no_example_for_data_strategy():
  function test_patch_order_preserved (line 193) | def test_patch_order_preserved():
  function test_deduplicates_examples (line 209) | def test_deduplicates_examples():
  function test_irretrievable_callable (line 216) | def test_irretrievable_callable():
  function test_pytest_reports_patch_file_location (line 245) | def test_pytest_reports_patch_file_location(pytester):

FILE: hypothesis-python/tests/patching/toplevel.py
  function fn_top (line 22) | def fn_top(x):

FILE: hypothesis-python/tests/pytest/test__pytest.py
  function test_import_just_private_pytest_works (line 28) | def test_import_just_private_pytest_works(testdir):

FILE: hypothesis-python/tests/pytest/test_capture.py
  function test_output_without_capture (line 31) | def test_output_without_capture(testdir, capture, expected):
  function test_output_emitting_unicode (line 61) | def test_output_emitting_unicode(testdir, monkeypatch):
  function get_line_num (line 74) | def get_line_num(token, lines, skip_n=0):
  function test_healthcheck_traceback_is_hidden (line 97) | def test_healthcheck_traceback_is_hidden(testdir, monkeypatch):
  function test_deprecation_of_strategies_as_tests (line 120) | def test_deprecation_of_strategies_as_tests(testdir):

FILE: hypothesis-python/tests/pytest/test_checks.py
  function test_decorators_without_given_should_fail (line 34) | def test_decorators_without_given_should_fail(testdir):

FILE: hypothesis-python/tests/pytest/test_collection_warning.py
  function test_collection_warning (line 30) | def test_collection_warning(pytester):

FILE: hypothesis-python/tests/pytest/test_compat.py
  function test_parametrize_after_given (line 19) | def test_parametrize_after_given(hi, i):

FILE: hypothesis-python/tests/pytest/test_constant_collection_timing.py
  function test_constant_collection_timing (line 53) | def test_constant_collection_timing(testdir, plugin_disabled):

FILE: hypothesis-python/tests/pytest/test_doctest.py
  function test_can_run_doctests (line 23) | def test_can_run_doctests(testdir):

FILE: hypothesis-python/tests/pytest/test_fixtures.py
  function infinity (line 24) | def infinity():
  function mock_fixture (line 29) | def mock_fixture():
  function spec_fixture (line 34) | def spec_fixture():
  function test_can_mix_fixture_and_positional_strategy (line 46) | def test_can_mix_fixture_and_positional_strategy(infinity, xs):
  function test_can_mix_fixture_and_keyword_strategy (line 53) | def test_can_mix_fixture_and_keyword_strategy(xs, infinity):
  function test_can_mix_fixture_example_and_keyword_strategy (line 59) | def test_can_mix_fixture_example_and_keyword_strategy(xs, infinity):
  function test_can_inject_mock_via_fixture (line 65) | def test_can_inject_mock_via_fixture(mock_fixture, xs):
  function test_can_inject_autospecced_mock_via_fixture (line 75) | def test_can_inject_autospecced_mock_via_fixture(spec_fixture, xs):
  function test_given_plus_function_scoped_non_autouse_fixtures_are_deprecated (line 109) | def test_given_plus_function_scoped_non_autouse_fixtures_are_deprecated(...
  function test_suppress_fixture_health_check_via_profile (line 125) | def test_suppress_fixture_health_check_via_profile(testdir):
  function test_suppress_health_check_function_scoped_fixture (line 153) | def test_suppress_health_check_function_scoped_fixture(testdir):
  function test_given_plus_overridden_fixture (line 176) | def test_given_plus_overridden_fixture(testdir):
  function assert_outcomes (line 194) | def assert_outcomes(result, *, errors=0, failed=0):
  function test_given_fails_if_already_decorated_with_fixture (line 199) | def test_given_fails_if_already_decorated_with_fixture(testdir):
  function test_fixture_errors_if_already_decorated_with_given (line 219) | def test_fixture_errors_if_already_decorated_with_given(testdir):

FILE: hypothesis-python/tests/pytest/test_junit.py
  function _run_and_get_junit (line 31) | def _run_and_get_junit(testdir, *args):
  function _findall_from_root (line 37) | def _findall_from_root(junit_xml, path):
  function suite_properties_ok (line 45) | def suite_properties_ok(junit_xml):
  function test_outputs_valid_xunit2 (line 57) | def test_outputs_valid_xunit2(testdir):
  function test_outputs_valid_xunit2_with_xdist (line 67) | def test_outputs_valid_xunit2_with_xdist(testdir):

FILE: hypothesis-python/tests/pytest/test_mark.py
  function test_can_select_mark (line 27) | def test_can_select_mark(testdir):
  function test_can_select_mark_on_unittest (line 51) | def test_can_select_mark_on_unittest(testdir):

FILE: hypothesis-python/tests/pytest/test_parametrized_db_keys.py
  function test_db_keys_for_parametrized_tests_are_unique (line 37) | def test_db_keys_for_parametrized_tests_are_unique(testdir):
  function fixt (line 43) | def fixt(request):
  class TestNoDifferingExecutorsHealthCheck (line 47) | class TestNoDifferingExecutorsHealthCheck:
    method test_method (line 52) | def test_method(self, x, i):
    method test_method_fixture (line 57) | def test_method_fixture(self, x, fixt):

FILE: hypothesis-python/tests/pytest/test_profiles.py
  function test_does_not_run_reporting_hook_by_default (line 34) | def test_does_not_run_reporting_hook_by_default(testdir):
  function test_runs_reporting_hook_in_any_verbose_mode (line 48) | def test_runs_reporting_hook_in_any_verbose_mode(testdir, option):

FILE: hypothesis-python/tests/pytest/test_pytest_detection.py
  function test_is_running_under_pytest (line 17) | def test_is_running_under_pytest():
  function test_is_not_running_under_pytest (line 27) | def test_is_not_running_under_pytest(tmp_path):
  function test_plugin_does_not_import_pytest (line 41) | def test_plugin_does_not_import_pytest(testdir):

FILE: hypothesis-python/tests/pytest/test_reporting.py
  function test_runs_reporting_hook (line 30) | def test_runs_reporting_hook(testdir):
  function test_no_missing_reports (line 50) | def test_no_missing_reports(testdir, tb):

FILE: hypothesis-python/tests/pytest/test_runs.py
  function test_ints_are_ints (line 18) | def test_ints_are_ints(x):
  function test_ints_are_floats (line 24) | def test_ints_are_floats(x):

FILE: hypothesis-python/tests/pytest/test_seeding.py
  function test_runs_repeatably_when_seed_is_set (line 46) | def test_runs_repeatably_when_seed_is_set(seed, testdir):
  function test_repeats_healthcheck_when_following_seed_instruction (line 92) | def test_repeats_healthcheck_when_following_seed_instruction(

FILE: hypothesis-python/tests/pytest/test_sideeffect_warnings.py
  function test_sideeffect_warning (line 35) | def test_sideeffect_warning(testdir):
  function test_conftest_sideeffect_pinpoint_error (line 43) | def test_conftest_sideeffect_pinpoint_error(testdir, monkeypatch):
  function test_plugin_sideeffect_pinpoint_error (line 58) | def test_plugin_sideeffect_pinpoint_error(testdir, monkeypatch):

FILE: hypothesis-python/tests/pytest/test_skipping.py
  function test_no_falsifying_example_if_pytest_skip (line 32) | def test_no_falsifying_example_if_pytest_skip(testdir):
  function test_issue_3453_regression (line 44) | def test_issue_3453_regression(testdir):

FILE: hypothesis-python/tests/pytest/test_statistics.py
  function get_output (line 19) | def get_output(testdir, suite, *args):
  function test_does_not_run_statistics_by_default (line 47) | def test_does_not_run_statistics_by_default(testdir):
  function test_prints_statistics_given_option (line 52) | def test_prints_statistics_given_option(testdir):
  function test_prints_statistics_given_option_under_xdist (line 59) | def test_prints_statistics_given_option_under_xdist(testdir):
  function test_prints_statistics_given_option_with_junitxml (line 66) | def test_prints_statistics_given_option_with_junitxml(testdir):
  function test_prints_statistics_given_option_under_xdist_with_junitxml (line 77) | def test_prints_statistics_given_option_under_xdist_with_junitxml(testdir):
  function test_prints_statistics_for_unittest_tests (line 100) | def test_prints_statistics_for_unittest_tests(testdir):
  function test_prints_statistics_for_stateful_tests (line 121) | def test_prints_statistics_for_stateful_tests(testdir):

FILE: hypothesis-python/tests/quality/test_deferred_strategies.py
  function test_large_branching_tree (line 16) | def test_large_branching_tree():
  function test_non_trivial_json (line 22) | def test_non_trivial_json():
  function test_self_recursive_lists (line 35) | def test_self_recursive_lists():

FILE: hypothesis-python/tests/quality/test_discovery_ability.py
  class HypothesisFalsified (line 48) | class HypothesisFalsified(AssertionError):
  function define_test (line 52) | def define_test(specifier, predicate, condition=None, p=0.5, suppress_he...
  function is_factorial (line 130) | def is_factorial(n):
  function distorted_value (line 188) | def distorted_value(x):
  function double (line 274) | def double(x):

FILE: hypothesis-python/tests/quality/test_float_shrinking.py
  function test_shrinks_to_simple_floats (line 19) | def test_shrinks_to_simple_floats():
  function test_can_shrink_in_variable_sized_context (line 25) | def test_can_shrink_in_variable_sized_context(n):
  function test_shrinks_downwards_to_integers (line 36) | def test_shrinks_downwards_to_integers(f):
  function test_shrinks_downwards_to_integers_when_fractional (line 43) | def test_shrinks_downwards_to_integers_when_fractional(b):

FILE: hypothesis-python/tests/quality/test_integers.py
  function test_biases_towards_boundary_values (line 14) | def test_biases_towards_boundary_values():

FILE: hypothesis-python/tests/quality/test_poisoned_lists.py
  class Poisoned (line 25) | class Poisoned(SearchStrategy):
    method __init__ (line 26) | def __init__(self, poison_chance):
    method do_draw (line 31) | def do_draw(self, data):
  class LinearLists (line 38) | class LinearLists(SearchStrategy):
    method __init__ (line 39) | def __init__(self, elements, size):
    method do_draw (line 44) | def do_draw(self, data):
  class Matrices (line 48) | class Matrices(SearchStrategy):
    method __init__ (line 49) | def __init__(self, elements, size):
    method do_draw (line 54) | def do_draw(self, data):
  function test_minimal_poisoned_containers (line 72) | def test_minimal_poisoned_containers(seed, size, p, strategy_class):

FILE: hypothesis-python/tests/quality/test_poisoned_trees.py
  class PoisonedTree (line 25) | class PoisonedTree(SearchStrategy):
    method __init__ (line 32) | def __init__(self, p):
    method do_draw (line 36) | def do_draw(self, data):
  function test_can_reduce_poison_from_any_subtree (line 63) | def test_can_reduce_poison_from_any_subtree(size, seed):

FILE: hypothesis-python/tests/quality/test_shrink_quality.py
  function test_integers_from_minimizes_leftwards (line 40) | def test_integers_from_minimizes_leftwards():
  function test_minimize_bounded_integers_to_zero (line 44) | def test_minimize_bounded_integers_to_zero():
  function test_minimize_bounded_integers_to_positive (line 48) | def test_minimize_bounded_integers_to_positive():
  function test_minimal_fractions_1 (line 57) | def test_minimal_fractions_1():
  function test_minimal_fractions_2 (line 61) | def test_minimal_fractions_2():
  function test_minimal_fractions_3 (line 65) | def test_minimal_fractions_3():
  function test_minimize_string_to_empty (line 69) | def test_minimize_string_to_empty():
  function test_minimize_one_of (line 73) | def test_minimize_one_of():
  function test_minimize_mixed_list (line 78) | def test_minimize_mixed_list():
  function test_minimize_longer_string (line 83) | def test_minimize_longer_string():
  function test_minimize_longer_list_of_strings (line 87) | def test_minimize_longer_list_of_strings():
  function test_minimize_3_set (line 91) | def test_minimize_3_set():
  function test_minimize_3_set_of_tuples (line 95) | def test_minimize_3_set_of_tuples():
  function test_minimize_sets_of_sets (line 99) | def test_minimize_sets_of_sets():
  function test_minimize_sets_sampled_from (line 110) | def test_minimize_sets_sampled_from():
  function test_can_simplify_flatmap_with_bounded_left_hand_size (line 114) | def test_can_simplify_flatmap_with_bounded_left_hand_size():
  function test_can_simplify_across_flatmap_of_just (line 121) | def test_can_simplify_across_flatmap_of_just():
  function test_can_simplify_on_right_hand_strategy_of_flatmap (line 125) | def test_can_simplify_on_right_hand_strategy_of_flatmap():
  function test_can_ignore_left_hand_side_of_flatmap (line 130) | def test_can_ignore_left_hand_side_of_flatmap():
  function test_can_simplify_on_both_sides_of_flatmap (line 137) | def test_can_simplify_on_both_sides_of_flatmap():
  function test_flatmap_rectangles (line 144) | def test_flatmap_rectangles():
  function test_dictionary (line 160) | def test_dictionary(dict_class):
  function test_minimize_single_element_in_silly_large_int_range (line 179) | def test_minimize_single_element_in_silly_large_int_range():
  function test_minimize_multiple_elements_in_silly_large_int_range (line 183) | def test_minimize_multiple_elements_in_silly_large_int_range():
  function test_minimize_multiple_elements_in_silly_large_int_range_min_is_not_dupe (line 192) | def test_minimize_multiple_elements_in_silly_large_int_range_min_is_not_...
  function test_find_large_union_list (line 202) | def test_find_large_union_list():
  function test_containment (line 223) | def test_containment(n, seed):
  function test_duplicate_containment (line 231) | def test_duplicate_containment():
  function test_reordering_bytes (line 241) | def test_reordering_bytes(seed):
  function test_minimize_long_list (line 246) | def test_minimize_long_list():
  function test_minimize_list_of_longish_lists (line 252) | def test_minimize_list_of_longish_lists():
  function test_minimize_list_of_fairly_non_unique_ints (line 263) | def test_minimize_list_of_fairly_non_unique_ints():
  function test_list_with_complex_sorting_structure (line 268) | def test_list_with_complex_sorting_structure():
  function test_list_with_wide_gap (line 276) | def test_list_with_wide_gap():
  function test_minimize_namedtuple (line 283) | def test_minimize_namedtuple():
  function test_minimize_dict (line 289) | def test_minimize_dict():
  function test_minimize_list_of_sets (line 297) | def test_minimize_list_of_sets():
  function test_minimize_list_of_lists (line 303) | def test_minimize_list_of_lists():
  function test_minimize_list_of_tuples (line 309) | def test_minimize_list_of_tuples():
  function test_minimize_multi_key_dicts (line 314) | def test_minimize_multi_key_dicts():
  function test_multiple_empty_lists_are_independent (line 320) | def test_multiple_empty_lists_are_independent():
  function test_can_find_sets_unique_by_incomplete_data (line 326) | def test_can_find_sets_unique_by_incomplete_data():
  function test_lists_forced_near_top (line 339) | def test_lists_forced_near_top(n):
  function test_sum_of_pair_int (line 345) | def test_sum_of_pair_int():
  function test_sum_of_pair_float (line 351) | def test_sum_of_pair_float():
  function test_sum_of_pair_mixed (line 357) | def test_sum_of_pair_mixed():
  function test_sum_of_pair_separated_int (line 367) | def test_sum_of_pair_separated_int():
  function test_sum_of_pair_separated_float (line 380) | def test_sum_of_pair_separated_float():
  function test_calculator_benchmark (line 393) | def test_calculator_benchmark():
  function test_one_of_slip (line 438) | def test_one_of_slip():
  function test_perfectly_shrinks_integers (line 446) | def test_perfectly_shrinks_integers(n):
  function test_lowering_together_positive (line 455) | def test_lowering_together_positive(gap):
  function test_lowering_together_negative (line 462) | def test_lowering_together_negative(gap):
  function test_lowering_together_mixed (line 469) | def test_lowering_together_mixed(gap):
  function test_lowering_together_with_gap (line 476) | def test_lowering_together_with_gap(gap):
  function test_run_length_encoding (line 481) | def test_run_length_encoding():
  function test_minimize_duplicated_characters_within_a_choice (line 517) | def test_minimize_duplicated_characters_within_a_choice():
  function test_nasty_string_shrinks (line 534) | def test_nasty_string_shrinks():
  function test_bound5 (line 542) | def test_bound5():

FILE: hypothesis-python/tests/quality/test_zig_zagging.py
  function problems (line 32) | def problems(draw):
  function test_avoids_zig_zag_trap (line 73) | def test_avoids_zig_zag_trap(p):

FILE: hypothesis-python/tests/redis/test_redis_exampledatabase.py
  function test_invalid_args_raise (line 34) | def test_invalid_args_raise(kw):
  function test_all_methods (line 39) | def test_all_methods():
  class DatabaseComparison (line 51) | class DatabaseComparison(RuleBasedStateMachine):
    method __init__ (line 52) | def __init__(self):
    method k (line 61) | def k(self, k):
    method v (line 65) | def v(self, v):
    method save (line 69) | def save(self, k, v):
    method delete (line 74) | def delete(self, k, v):
    method move (line 79) | def move(self, k1, k2, v):
    method values_agree (line 84) | def values_agree(self, k):
  function flush_messages (line 98) | def flush_messages(db):
  function test_redis_listener (line 108) | def test_redis_listener():
  function test_redis_listener_explicit (line 119) | def test_redis_listener_explicit():
  function test_redis_move_from_key_without_value (line 151) | def test_redis_move_from_key_without_value():
  function test_redis_move_into_key_with_value (line 161) | def test_redis_move_into_key_with_value():
  function test_redis_move_to_same_key (line 171) | def test_redis_move_to_same_key():
  function test_redis_equality (line 180) | def test_redis_equality():

FILE: hypothesis-python/tests/test_annotated_types.py
  function test_strategy_priority_over_constraints (line 31) | def test_strategy_priority_over_constraints():
  function test_invalid_annotated_type (line 38) | def test_invalid_annotated_type():
  function test_unsupported_constraints (line 57) | def test_unsupported_constraints(unsupported_constraints, message):
  function test_annotated_type_int (line 78) | def test_annotated_type_int(annotated_type, expected_strategy_repr):
  function test_predicate_constraint (line 83) | def test_predicate_constraint():
  class MyCollection (line 92) | class MyCollection:
    method __init__ (line 93) | def __init__(self, values: list[int]) -> None:
    method __len__ (line 96) | def __len__(self) -> int:
  function test_collection_sizes (line 104) | def test_collection_sizes(data, lo, hi, type_):
  function test_collection_size_from_slice (line 115) | def test_collection_size_from_slice(data):
  function test_unhashable_annotated_metadata (line 121) | def test_unhashable_annotated_metadata():
  class GroupedStuff (line 126) | class GroupedStuff:
    method __init__ (line 129) | def __init__(self, *args) -> None:
    method __iter__ (line 132) | def __iter__(self):
    method __repr__ (line 135) | def __repr__(self) -> str:
  function test_flattens_grouped_metadata (line 139) | def test_flattens_grouped_metadata():
  class TypedDictWithAnnotations (line 152) | class TypedDictWithAnnotations(TypedDict):
  function test_typeddict_with_annotated_constraints (line 158) | def test_typeddict_with_annotated_constraints(value):

FILE: hypothesis-python/tests/typing_extensions/test_backported_types.py
  function test_typing_extensions_Literal (line 46) | def test_typing_extensions_Literal(value):
  function test_typing_extensions_Literal_nested (line 53) | def test_typing_extensions_Literal_nested(data):
  class A (line 70) | class A(TypedDict):
  function test_simple_typeddict (line 75) | def test_simple_typeddict(value):
  function test_typing_extensions_Type_int (line 81) | def test_typing_extensions_Type_int():
  function test_typing_extensions_Type_Union (line 86) | def test_typing_extensions_Type_Union(ex):
  function test_resolves_NewType (line 90) | def test_resolves_NewType():
  function test_defaultdict (line 106) | def test_defaultdict(ex):
  function test_non_runtime_type_cannot_be_resolved (line 114) | def test_non_runtime_type_cannot_be_resolved(non_runtime_type):
  function test_non_runtime_type_cannot_be_registered (line 123) | def test_non_runtime_type_cannot_be_registered(non_runtime_type):
  function test_callable_with_concatenate (line 130) | def test_callable_with_concatenate():
  function test_callable_with_paramspec (line 144) | def test_callable_with_paramspec():
  function test_callable_return_typegard_type (line 159) | def test_callable_return_typegard_type(typ):
  class Movie (line 172) | class Movie(TypedDict):  # implicitly total=True
  function test_typeddict_not_required (line 178) | def test_typeddict_not_required(value):
  function test_typeddict_not_required_can_skip (line 186) | def test_typeddict_not_required_can_skip():
  class OtherMovie (line 190) | class OtherMovie(TypedDict, total=False):
  function test_typeddict_required (line 196) | def test_typeddict_required(value):
  function test_typeddict_required_must_have (line 204) | def test_typeddict_required_must_have():
  class Story (line 208) | class Story(TypedDict, total=True):
  class Book (line 212) | class Book(Story, total=False):
  class Novel (line 216) | class Novel(Book):
  function test_required_and_not_required_keys (line 246) | def test_required_and_not_required_keys(check, condition):
  class DeeplyNestedQualifiers (line 250) | class DeeplyNestedQualifiers(TypedDict):
  function test_required_and_not_required_keys_deeply_nested (line 270) | def test_required_and_not_required_keys_deeply_nested(check, condition):
  function test_typeddict_error_msg (line 274) | def test_typeddict_error_msg():
  function test_literal_string_is_just_a_string (line 291) | def test_literal_string_is_just_a_string():
  class Foo (line 295) | class Foo:
    method __init__ (line 296) | def __init__(self, x):
  class Bar (line 300) | class Bar(Foo):
  class Baz (line 304) | class Baz(Foo):
  function test_typevar_type_is_consistent (line 342) | def test_typevar_type_is_consistent(data, var, expected):

FILE: hypothesis-python/tests/watchdog/test_database.py
  function test_database_listener_directory (line 44) | def test_database_listener_directory():
  function test_database_listener_multiplexed (line 64) | def test_database_listener_multiplexed(tmp_path):
  function test_database_listener_directory_explicit (line 107) | def test_database_listener_directory_explicit(tmp_path):
  function test_database_listener_directory_move (line 186) | def test_database_listener_directory_move(tmp_path):
  function test_still_listens_if_directory_did_not_exist (line 215) | def test_still_listens_if_directory_did_not_exist(tmp_path):

FILE: hypothesis-python/tests/watchdog/test_database_cover.py
  function test_start_stop_multiplexed_listener (line 24) | def test_start_stop_multiplexed_listener(tmp_path):
  function test_start_stop_directory_listener (line 34) | def test_start_stop_directory_listener(tmp_path):

FILE: tooling/setup.py
  function local_file (line 16) | def local_file(name):

FILE: tooling/src/hypothesistooling/__init__.py
  function current_branch (line 17) | def current_branch():
  function tags (line 25) | def tags():
  function hash_for_name (line 43) | def hash_for_name(name):
  function is_ancestor (line 47) | def is_ancestor(a, b):
  function merge_base (line 53) | def merge_base(a, b):
  function point_of_divergence (line 57) | def point_of_divergence():
  function has_changes (line 61) | def has_changes(files):
  function has_uncommitted_changes (line 75) | def has_uncommitted_changes(filename):
  function last_committer (line 79) | def last_committer():
  function git (line 88) | def git(*args):
  function configure_git (line 95) | def configure_git():
  function create_tag (line 100) | def create_tag(tagname):
  function push_tag (line 105) | def push_tag(tagname):
  function assert_can_release (line 111) | def assert_can_release():
  function modified_files (line 115) | def modified_files():
  function all_files (line 136) | def all_files() -> list[Path]:
  function changed_files_from_master (line 146) | def changed_files_from_master():
  function all_projects (line 161) | def all_projects():

FILE: tooling/src/hypothesistooling/__main__.py
  function task (line 36) | def task(if_changed=()):
  function check_installed (line 59) | def check_installed():
  function codespell (line 64) | def codespell(*files):
  function lint (line 80) | def lint():
  function do_release (line 113) | def do_release(package):
  function deploy (line 142) | def deploy():
  function remove_consecutive_newlines_in_rst (line 194) | def remove_consecutive_newlines_in_rst(path: Path):
  function format (line 206) | def format():
  function check_format (line 275) | def check_format():
  function check_not_changed (line 315) | def check_not_changed():
  function compile_requirements (line 320) | def compile_requirements(*, upgrade=False):
  function update_python_versions (line 352) | def update_python_versions():
  function update_django_versions (line 413) | def update_django_versions():
  function update_pyodide_versions (line 454) | def update_pyodide_versions():
  function update_vendored_files (line 519) | def update_vendored_files():
  function has_diff (line 542) | def has_diff(file_or_directory):
  function upgrade_requirements (line 548) | def upgrade_requirements():
  function check_requirements (line 563) | def check_requirements():
  function documentation (line 568) | def documentation():
  function website (line 581) | def website():
  function live_website (line 586) | def live_website():
  function live_docs (line 594) | def live_docs():
  function run_tox (line 606) | def run_tox(task, version, *args):
  function check_py310_pyjion (line 689) | def check_py310_pyjion(*args):
  function tox (line 694) | def tox(*args):
  function standard_tox_task (line 701) | def standard_tox_task(name, py=ci_version):
  function check_quality (line 745) | def check_quality(*args):
  function check_examples3 (line 750) | def check_examples3(*args):
  function check_whole_repo_tests (line 755) | def check_whole_repo_tests(*args):
  function check_documentation (line 767) | def check_documentation(*args):
  function check_types (line 779) | def check_types(*args):
  function check_types_api (line 791) | def check_types_api(*args):
  function check_types_hypothesis (line 804) | def check_types_hypothesis(*args):
  function shell (line 817) | def shell():
  function python (line 824) | def python(*args):
  function tasks (line 829) | def tasks():

FILE: tooling/src/hypothesistooling/installers.py
  function __python_executable (line 28) | def __python_executable(version):
  function python_executable (line 32) | def python_executable(version):
  function ensure_python (line 40) | def ensure_python(version):
  function ensure_stack (line 55) | def ensure_stack():
  function update_stack (line 71) | def update_stack():
  function ensure_shellcheck (line 77) | def ensure_shellcheck():

FILE: tooling/src/hypothesistooling/junkdrawer.py
  function in_dir (line 22) | def in_dir(d):
  function once (line 31) | def once(fn):
  function unlink_if_present (line 43) | def unlink_if_present(path):
  function unquote_string (line 50) | def unquote_string(s):

FILE: tooling/src/hypothesistooling/projects/hypothesispython.py
  function has_release (line 54) | def has_release():
  function has_release_sample (line 58) | def has_release_sample():
  function parse_release_file (line 62) | def parse_release_file():
  function has_source_changes (line 66) | def has_source_changes():
  function build_docs (line 70) | def build_docs(*, builder="html", only=(), to=None):
  function update_changelog_and_version (line 93) | def update_changelog_and_version():
  function update_pyproject_toml (line 164) | def update_pyproject_toml():
  function changelog (line 196) | def changelog():
  function build_distribution (line 200) | def build_distribution():
  function upload_distribution (line 206) | def upload_distribution():
  function current_version (line 263) | def current_version():
  function latest_version (line 267) | def latest_version():
  function tag_name (line 286) | def tag_name():
  function get_autoupdate_message (line 290) | def get_autoupdate_message(domainlist_changed):

FILE: tooling/src/hypothesistooling/releasemanagement.py
  function release_date_string (line 27) | def release_date_string():
  function assignment_matcher (line 37) | def assignment_matcher(name):
  function extract_assignment_from_string (line 49) | def extract_assignment_from_string(contents, name):
  function extract_assignment (line 62) | def extract_assignment(filename, name):
  function replace_assignment_in_string (line 67) | def replace_assignment_in_string(contents, name, value):
  function replace_assignment (line 88) | def replace_assignment(filename, name, value):
  function parse_release_file (line 114) | def parse_release_file(filename):
  function parse_release_file_contents (line 119) | def parse_release_file_contents(release_contents, filename):
  function bump_version_info (line 141) | def bump_version_info(version_info, release_type):
  function update_markdown_changelog (line 152) | def update_markdown_changelog(changelog, name, version, entry):
  function parse_version (line 165) | def parse_version(version):
  function commit_pending_release (line 169) | def commit_pending_release(project):

FILE: tooling/src/hypothesistooling/scripts.py
  function print_command (line 20) | def print_command(command, args):
  function run_script (line 38) | def run_script(script, *args, **kwargs):
  function __calc_script_variables (line 47) | def __calc_script_variables():
  function tool_path (line 62) | def tool_path(name):
  function pip_tool (line 66) | def pip_tool(name, *args, **kwargs):

FILE: website/theme/static/prism.js
  function u (line 3) | function u(e){s.highlightedCode=e,a.hooks.run("before-insert",s),s.eleme...
  function i (line 3) | function i(e,n,t,r){this.type=e,this.content=n,this.alias=t,this.length=...
  function l (line 3) | function l(e,n,t,r){e.lastIndex=n;var a=e.exec(t);if(a&&r&&a[1]){var i=a...
  function o (line 3) | function o(e,n,t,r,s,g){for(var f in t)if(t.hasOwnProperty(f)&&t[f]){var...
  function s (line 3) | function s(){var e={value:null,prev:null,next:null},n={value:null,prev:e...
  function u (line 3) | function u(e,n,t){var r=n.next,a={value:t,prev:n,next:r};return n.next=a...
  function c (line 3) | function c(e,n,t){for(var r=n.next,a=0;a<t&&r!==e.tail;a++)r=r.next;n.ne...
  function f (line 3) | function f(){a.manual||a.highlightAll()}

FILE: whole_repo_tests/documentation/test_documentation.py
  function test_documentation (line 23) | def test_documentation():
  function get_all_exported_names (line 27) | def get_all_exported_names():
  function test_documents_all_exported_strategies (line 61) | def test_documents_all_exported_strategies():

FILE: whole_repo_tests/types/revealed_types.py
  class DifferingRevealedTypes (line 68) | class DifferingRevealedTypes(NamedTuple):

FILE: whole_repo_tests/types/test_hypothesis.py
  function test_mypy_passes_on_hypothesis (line 15) | def test_mypy_passes_on_hypothesis():

FILE: whole_repo_tests/types/test_mypy.py
  function test_mypy_passes_on_hypothesis_strict (line 34) | def test_mypy_passes_on_hypothesis_strict():
  function get_mypy_output (line 38) | def get_mypy_output(fname, *extra_args):
  function get_mypy_analysed_type (line 60) | def get_mypy_analysed_type(fname):
  function assert_mypy_errors (line 99) | def assert_mypy_errors(fname, expected, python_version=None):
  function test_revealed_types (line 132) | def test_revealed_types(tmp_path, val, expect):
  function test_assume_revealed_types (line 147) | def test_assume_revealed_types(tmp_path, val, expect):
  function test_numpy_revealed_types (line 165) | def test_numpy_revealed_types(tmp_path, val, expect):
  function test_pandas_column (line 189) | def test_pandas_column(tmp_path, val, expect):
  function test_data_object_type_tracing (line 205) | def test_data_object_type_tracing(tmp_path):
  function test_drawfn_type_tracing (line 218) | def test_drawfn_type_tracing(tmp_path):
  function test_composite_type_tracing (line 232) | def test_composite_type_tracing(tmp_path):
  function test_functions_type_tracing (line 255) | def test_functions_type_tracing(tmp_path, source, expected):
  function test_settings_preserves_type (line 268) | def test_settings_preserves_type(tmp_path):
  function test_stateful_bundle_generic_type (line 282) | def test_stateful_bundle_generic_type(tmp_path):
  function test_stateful_rule_targets (line 305) | def test_stateful_rule_targets(tmp_path, decorator, target_args, returns):
  function test_stateful_rule_no_targets (line 320) | def test_stateful_rule_no_targets(tmp_path, decorator):
  function test_stateful_target_params_mutually_exclusive (line 333) | def test_stateful_target_params_mutually_exclusive(tmp_path, decorator):
  function test_stateful_target_params_return_type (line 354) | def test_stateful_target_params_return_type(tmp_path, decorator, target_...
  function test_stateful_no_target_params_return_type (line 369) | def test_stateful_no_target_params_return_type(tmp_path, decorator):
  function test_stateful_bundle_variance (line 383) | def test_stateful_bundle_variance(tmp_path, decorator, use_multi):
  function test_stateful_multiple_return (line 407) | def test_stateful_multiple_return(tmp_path, decorator):
  function test_stateful_multiple_return_invalid (line 421) | def test_stateful_multiple_return_invalid(tmp_path, decorator):
  function test_stateful_consumes_type_tracing (line 441) | def test_stateful_consumes_type_tracing(tmp_path, wrapper, expected):
  function test_stateful_consumed_bundle_cannot_be_target (line 456) | def test_stateful_consumed_bundle_cannot_be_target(tmp_path):
  function test_stateful_precondition_requires_predicate (line 474) | def test_stateful_precondition_requires_predicate(tmp_path, return_val, ...
  function test_stateful_precondition_lambda (line 485) | def test_stateful_precondition_lambda(tmp_path):
  function test_stateful_precondition_instance_method (line 501) | def test_stateful_precondition_instance_method(tmp_path):
  function test_stateful_precondition_precond_requires_one_arg (line 517) | def test_stateful_precondition_precond_requires_one_arg(tmp_path):
  function test_pos_only_args (line 532) | def test_pos_only_args(tmp_path):
  function test_mypy_passes_on_basic_test (line 558) | def test_mypy_passes_on_basic_test(tmp_path, python_version):
  function test_given_only_allows_strategies (line 582) | def test_given_only_allows_strategies(tmp_path, python_version):
  function test_raises_for_mixed_pos_kwargs_in_given (line 598) | def test_raises_for_mixed_pos_kwargs_in_given(tmp_path, python_version):
  function test_register_random_interface (line 614) | def test_register_random_interface(tmp_path):
  function test_register_type_strategy_type_alias_type (line 636) | def test_register_type_strategy_type_alias_type(tmp_path):

FILE: whole_repo_tests/types/test_pyright.py
  function test_pyright_passes_on_hypothesis (line 40) | def test_pyright_passes_on_hypothesis():
  function test_pyright_passes_on_basic_test (line 45) | def test_pyright_passes_on_basic_test(tmp_path: Path, python_version: str):
  function test_given_only_allows_strategies (line 81) | def test_given_only_allows_strategies(tmp_path: Path, python_version: str):
  function test_pyright_issue_3296 (line 103) | def test_pyright_issue_3296(tmp_path: Path):
  function test_pyright_raises_for_mixed_pos_kwargs_in_given (line 119) | def test_pyright_raises_for_mixed_pos_kwargs_in_given(tmp_path: Path):
  function test_pyright_issue_3348 (line 146) | def test_pyright_issue_3348(tmp_path: Path):
  function test_numpy_arrays_strategy (line 165) | def test_numpy_arrays_strategy(tmp_path: Path):
  function test_revealed_types (line 188) | def test_revealed_types(tmp_path, val, expect):
  function test_assume_revealed_types (line 206) | def test_assume_revealed_types(tmp_path, val, expect):
  function test_numpy_revealed_types (line 228) | def test_numpy_revealed_types(tmp_path, val, expect):
  function test_pandas_column (line 255) | def test_pandas_column(tmp_path, val, expect):
  function test_pyright_tuples_pos_args_only (line 277) | def test_pyright_tuples_pos_args_only(tmp_path: Path):
  function test_pyright_one_of_pos_args_only (line 302) | def test_pyright_one_of_pos_args_only(tmp_path: Path):
  function test_register_random_protocol (line 327) | def test_register_random_protocol(tmp_path: Path):
  function _get_pyright_output (line 355) | def _get_pyright_output(file: Path) -> dict[str, Any]:
  function _get_pyright_errors (line 370) | def _get_pyright_errors(file: Path) -> list[dict[str, Any]]:
  function get_pyright_analysed_type (line 374) | def get_pyright_analysed_type(fname):
  function _write_config (line 391) | def _write_config(config_dir: Path, data: dict[str, Any] | None = None):

FILE: whole_repo_tests/whole_repo/test_ci_config.py
  function test_python_versions_are_tested_in_ci (line 28) | def test_python_versions_are_tested_in_ci(version):
  function test_python_versions_are_in_trove_classifiers (line 34) | def test_python_versions_are_in_trove_classifiers():

FILE: whole_repo_tests/whole_repo/test_deploy.py
  function test_release_file_exists_and_is_valid (line 22) | def test_release_file_exists_and_is_valid(project, monkeypatch):

FILE: whole_repo_tests/whole_repo/test_release_files.py
  function test_release_file_exists_and_is_valid (line 19) | def test_release_file_exists_and_is_valid(project):
  function test_release_file_has_no_merge_conflicts (line 34) | def test_release_file_has_no_merge_conflicts():

FILE: whole_repo_tests/whole_repo/test_release_management.py
  function parse_release (line 22) | def parse_release(contents):
  function test_update_single_line (line 26) | def test_update_single_line():
  function test_update_without_spaces (line 30) | def test_update_without_spaces():
  function test_update_in_middle (line 34) | def test_update_in_middle():
  function test_quotes_string_to_assign (line 38) | def test_quotes_string_to_assign():
  function test_duplicates_are_errors (line 44) | def test_duplicates_are_errors():
  function test_missing_is_error (line 49) | def test_missing_is_error():
  function test_bump_minor_version (line 54) | def test_bump_minor_version():
  function test_parse_release_file (line 58) | def test_parse_release_file():
  function test_invalid_release (line 64) | def test_invalid_release():
  function test_update_changelog (line 81) | def test_update_changelog(tmp_path):
  function test_changelog_parsing_strips_trailing_whitespace (line 90) | def test_changelog_parsing_strips_trailing_whitespace():

FILE: whole_repo_tests/whole_repo/test_requirements.py
  function test_requirements (line 14) | def test_requirements():

FILE: whole_repo_tests/whole_repo/test_rst_is_valid.py
  function is_sphinx (line 20) | def is_sphinx(f):
  function test_passes_rst_lint (line 32) | def test_passes_rst_lint():
  function test_rst_code_blocks (line 36) | def test_rst_code_blocks():
  function disabled_test_passes_flake8 (line 47) | def disabled_test_passes_flake8():

FILE: whole_repo_tests/whole_repo/test_shellcheck.py
  function test_all_shell_scripts_are_valid (line 19) | def test_all_shell_scripts_are_valid():

FILE: whole_repo_tests/whole_repo/test_validate_branch_check.py
  function write_entries (line 22) | def write_entries(tmp_path, entries):
  function run_validate_branch_check (line 27) | def run_validate_branch_check(tmp_path, *, check, **kwargs):
  function test_validates_branches (line 38) | def test_validates_branches(tmp_path):
  function test_validates_one_branch (line 52) | def test_validates_one_branch(tmp_path):
  function test_fails_on_zero_branches (line 61) | def test_fails_on_zero_branches(tmp_path):
  function test_reports_uncovered_branches (line 69) | def test_reports_uncovered_branches(tmp_path):