import threading from enum import Enum, IntEnum, unique import attr from hypothesis.errors import InvalidArgument, HypothesisDeprecationWarning from hypothesis.configuration import hypothesis_home_dir from hypothesis.internal.compat import PYPY from hypothesis.utils.conventions import UniqueIdentifier, not_set from hypothesis.utils.dynamicvariables import DynamicVariable __all__ = [ 'settings', ] unlimited = UniqueIdentifier('unlimited') all_settings = {} _db_cache = {} class settingsProperty(object): def __init__(self, name, show_default): self.name = name self.show_default = show_default def __get__(self, obj, type=None): if obj is None: return self else:
import hashlib from collections import defaultdict import hypothesis.internal.conjecture.utils as cu from hypothesis.errors import NoExamples, NoSuchExample, Unsatisfiable, \ UnsatisfiedAssumption from hypothesis.control import assume, reject, _current_build_context from hypothesis._settings import note_deprecation from hypothesis.internal.compat import hrange, qualname, bit_length, \ str_to_bytes, int_from_bytes from hypothesis.utils.conventions import UniqueIdentifier from hypothesis.internal.lazyformat import lazyformat from hypothesis.internal.reflection import get_pretty_function_description calculating = UniqueIdentifier('calculating') LABEL_MASK = 2**64 - 1 def calc_label(cls): name = str_to_bytes(qualname(cls)) hashed = hashlib.md5(name).digest() return int_from_bytes(hashed[:8]) def combine_labels(*labels): label = 0 for l in labels: label = (label << 1) & LABEL_MASK label ^= l
from hypothesis.utils.conventions import UniqueIdentifier try: from random import Random # noqa from typing import List, Callable, TypeVar, Generic, Optional # noqa Ex = TypeVar("Ex", covariant=True) T = TypeVar("T") from hypothesis.internal.conjecture.data import ConjectureData # noqa except ImportError: # pragma: no cover Ex = "key" # type: ignore Generic = {Ex: object} # type: ignore calculating = UniqueIdentifier("calculating") MAPPED_SEARCH_STRATEGY_DO_DRAW_LABEL = calc_label_from_name( "another attempted draw in MappedSearchStrategy" ) def one_of_strategies(xs): """Helper function for unioning multiple strategies.""" xs = tuple(xs) if not xs: raise ValueError("Cannot join an empty list of strategies") return OneOfStrategy(xs) class SearchStrategy(Generic[Ex]):
from hypothesis.utils.conventions import UniqueIdentifier try: from random import Random # noqa from typing import List, Callable, TypeVar, Generic, Optional # noqa Ex = TypeVar("Ex", covariant=True) T = TypeVar("T") from hypothesis.internal.conjecture.data import ConjectureData # noqa except ImportError: # pragma: no cover Ex = "key" # type: ignore Generic = {Ex: object} # type: ignore calculating = UniqueIdentifier("calculating") MAPPED_SEARCH_STRATEGY_DO_DRAW_LABEL = calc_label_from_name( "another attempted draw in MappedSearchStrategy") def one_of_strategies(xs): """Helper function for unioning multiple strategies.""" xs = tuple(xs) if not xs: raise ValueError("Cannot join an empty list of strategies") return OneOfStrategy(xs) class SearchStrategy(Generic[Ex]): """A SearchStrategy is an object that knows how to explore data of a given
def __attrs_post_init__(self): self.index = len(self.buffer) @property def examples(self): if self.__examples is None: self.__examples = calc_examples(self) self.example_boundaries = None assert self.example_boundaries is None return self.__examples # Special "labels" used to indicate the end of example boundaries Stop = UniqueIdentifier("Stop") StopDiscard = UniqueIdentifier("StopDiscard") class ConjectureData(object): @classmethod def for_buffer(self, buffer): buffer = hbytes(buffer) return ConjectureData( max_length=len(buffer), draw_bytes=lambda data, n: hbytes(buffer[data.index:data.index + n] ), ) def __init__(self, max_length, draw_bytes): self.max_length = max_length
sqlite_delta = timedelta(microseconds=2**47 - 1) __default_field_mappings.update({ dm.TimeField: st.times(), dm.DurationField: st.timedeltas(-sqlite_delta, sqlite_delta), }) return __default_field_mappings def add_default_field_mapping(field_type, strategy): field_mappings()[field_type] = strategy default_value = UniqueIdentifier(u'default_value') def validator_to_filter(f): """Converts the field run_validators method to something suitable for use in filter.""" def validate(value): try: f.run_validators(value) return True except ValidationError: return False return validate
HypothesisDeprecationWarning, InvalidArgument, InvalidState, ) from hypothesis.internal.compat import integer_types, quiet_raise, string_types from hypothesis.internal.reflection import get_pretty_function_description from hypothesis.internal.validation import check_type, try_convert from hypothesis.utils.conventions import UniqueIdentifier, not_set from hypothesis.utils.dynamicvariables import DynamicVariable if False: from typing import Any, Dict, List # noqa __all__ = ["settings"] unlimited = UniqueIdentifier("unlimited") all_settings = {} # type: Dict[str, Setting] class settingsProperty(object): def __init__(self, name, show_default): self.name = name self.show_default = show_default def __get__(self, obj, type=None): if obj is None: return self else: try: result = obj.__dict__[self.name]
def test_unique_identifier_repr(): assert repr(UniqueIdentifier(u'hello_world')) == u'hello_world'
def test_unique_identifier_repr(): assert repr(UniqueIdentifier("hello_world")) == "hello_world"
self.tag = tag NEGATED_CACHE = {} def negated(tag): try: return NEGATED_CACHE[tag] except KeyError: result = Negated(tag) NEGATED_CACHE[tag] = result return result universal = UniqueIdentifier('universal') class TargetSelector(object): """Data structure for selecting targets to use for mutation. The goal is to do a good job of exploiting novelty in examples without getting too obsessed with any particular novel factor. Roughly speaking what we want to do is give each distinct coverage target equal amounts of time. However some coverage targets may be harder to fuzz than others, or may only appear in a very small minority of examples, so we don't want to let those dominate the testing. Targets are selected according to the following rules: