def rule_label(self, name):
try:
return self.__rule_labels[name]
except KeyError:
return self.__rule_labels.setdefault(
name, calc_label_from_name("LARK:%s" % (name,))
)
def rule_label(self, name):
try:
return self.__rule_labels[name]
except KeyError:
return self.__rule_labels.setdefault(
name, calc_label_from_name("LARK:%s" % (name,))
)
#
# END HEADER
from __future__ import division, print_function, absolute_import
from enum import IntEnum
import attr
from hypothesis.errors import Frozen, StopTest, InvalidArgument
from hypothesis.internal.compat import hbytes, hrange, text_type, \
bit_length, benchmark_time, int_from_bytes, unicode_safe_repr
from hypothesis.internal.escalation import mark_for_escalation
from hypothesis.internal.conjecture.utils import calc_label_from_name
TOP_LABEL = calc_label_from_name('top')
DRAW_BYTES_LABEL = calc_label_from_name('draw_bytes() in ConjectureData')
class Status(IntEnum):
OVERRUN = 0
INVALID = 1
VALID = 2
INTERESTING = 3
def __repr__(self):
return 'Status.%s' % (self.name,)
@attr.s(slots=True)
class Example(object):
1.7976931348623157e308,
3.402823466e38,
9007199254740992,
1 - 10e-6,
2 + 10e-6,
1.192092896e-07,
2.2204460492503131e-016,
]
+ [float("inf"), float("nan")] * 5,
key=flt.float_to_lex,
)
NASTY_FLOATS = list(map(float, NASTY_FLOATS))
NASTY_FLOATS.extend([-x for x in NASTY_FLOATS])
FLOAT_STRATEGY_DO_DRAW_LABEL = calc_label_from_name(
"getting another float in FloatStrategy"
)
class FloatStrategy(SearchStrategy):
"""Generic superclass for strategies which produce floats."""
def __init__(self, allow_infinity, allow_nan):
SearchStrategy.__init__(self)
assert isinstance(allow_infinity, bool)
assert isinstance(allow_nan, bool)
self.allow_infinity = allow_infinity
self.allow_nan = allow_nan
self.nasty_floats = [f for f in NASTY_FLOATS if self.permitted(f)]
weights = [0.2 * len(self.nasty_floats)] + [0.8] * len(self.nasty_floats)
from hypothesis._settings import Verbosity
from hypothesis._settings import settings as Settings
from hypothesis._settings import note_deprecation
from hypothesis.reporting import report, verbose_report, current_verbosity
from hypothesis.strategies import just, one_of, runner, tuples, \
fixed_dictionaries
from hypothesis.vendor.pretty import CUnicodeIO, RepresentationPrinter
from hypothesis.internal.compat import int_to_bytes, string_types
from hypothesis.internal.reflection import proxies, nicerepr
from hypothesis.internal.conjecture.data import StopTest
from hypothesis.internal.conjecture.utils import integer_range, \
calc_label_from_name
from hypothesis.searchstrategy.strategies import OneOfStrategy, \
SearchStrategy
STATE_MACHINE_RUN_LABEL = calc_label_from_name('another state machine step')
if False:
from typing import Any, Dict, List, Text # noqa
class TestCaseProperty(object): # pragma: no cover
def __get__(self, obj, typ=None):
if obj is not None:
typ = type(obj)
return typ._to_test_case()
def __set__(self, obj, value):
raise AttributeError(u'Cannot set TestCase')
3. If the unbiased exponent is in the range [1, 51] then we reverse the
low k bits, where k is 52 - unbiased exponen.
The low bits correspond to the fractional part of the floating point number.
Reversing it bitwise means that we try to minimize the low bits, which kills
off the higher powers of 2 in the fraction first.
"""
MAX_EXPONENT = 0x7ff
SPECIAL_EXPONENTS = (0, MAX_EXPONENT)
BIAS = 1023
MAX_POSITIVE_EXPONENT = (MAX_EXPONENT - 1 - BIAS)
DRAW_FLOAT_LABEL = calc_label_from_name('drawing a float')
def exponent_key(e):
if e == MAX_EXPONENT:
return float('inf')
unbiased = e - BIAS
if unbiased < 0:
return 10000 - unbiased
else:
return unbiased
ENCODING_TABLE = array('H', sorted(hrange(MAX_EXPONENT + 1), key=exponent_key))
DECODING_TABLE = array('H', [0]) * len(ENCODING_TABLE)
try:
from typing import Any, List, Callable, TypeVar, Generic, Optional # noqa
Ex = TypeVar("Ex", covariant=True)
T = TypeVar("T")
from hypothesis._settings import UniqueIdentifier # noqa
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
type.
Except where noted otherwise, methods on this class are not part of
Status,
)
from hypothesis.internal.conjecture.engine import (
MIN_TEST_CALLS,
ConjectureRunner,
ExitReason,
TargetSelector,
)
from hypothesis.internal.conjecture.shrinker import Shrinker, block_program
from hypothesis.internal.conjecture.shrinking import Float
from hypothesis.internal.conjecture.utils import Sampler, calc_label_from_name
from hypothesis.internal.entropy import deterministic_PRNG
from tests.common.strategies import SLOW, HardToShrink
from tests.common.utils import no_shrink
SOME_LABEL = calc_label_from_name("some label")
TEST_SETTINGS = settings(
max_examples=5000,
buffer_size=1024,
database=None,
suppress_health_check=HealthCheck.all(),
)
def run_to_data(f):
with deterministic_PRNG():
runner = ConjectureRunner(f, settings=TEST_SETTINGS)
runner.run()
assert runner.interesting_examples
last_data, = runner.interesting_examples.values()
# Most of this work is copyright (C) 2013-2020 David R. MacIver # ([email protected]), but it contains contributions by others. See # CONTRIBUTING.rst for a full list of people who may hold copyright, and # consult the git log if you need to determine who owns an individual # contribution. # # This Source Code Form is subject to the terms of the Mozilla Public License, # v. 2.0. If a copy of the MPL was not distributed with this file, You can # obtain one at https://mozilla.org/MPL/2.0/. # # END HEADER from hypothesis.internal.conjecture import utils as cu from hypothesis.strategies._internal.strategies import SearchStrategy FEATURE_LABEL = cu.calc_label_from_name("feature flag") class FeatureFlags: """Object that can be used to control a number of feature flags for a given test run. This enables an approach to data generation called swarm testing ( see Groce, Alex, et al. "Swarm testing." Proceedings of the 2012 International Symposium on Software Testing and Analysis. ACM, 2012), in which generation is biased by selectively turning some features off for each test case generated. When there are many interacting features this can find bugs that a pure generation strategy would otherwise have missed. FeatureFlags are designed to "shrink open", so that during shrinking they become less restrictive. This allows us to potentially shrink to smaller
from random import Random
import random
import base64
import json
from contextlib import contextmanager
import signal
import hashlib
import traceback
import click
from hypothesis.internal.conjecture.shrinker import block_program
import time
import re
NUMERALS = re.compile("[0-9]+")
STEP_LABEL = calc_label_from_name("TSTL STEP")
DRAW_STEP = calc_label_from_name("TSTL STEP SELECTION")
class TimeoutExpired(Exception):
pass
@contextmanager
def timeout(seconds):
def raiseexc(signum, frame):
raise TimeoutExpired()
start = time.monotonic()
prev = None
try:
next_up,
next_up_normal,
width_smallest_normals,
)
from hypothesis.internal.validation import (
check_type,
check_valid_bound,
check_valid_interval,
)
from hypothesis.strategies._internal.misc import just, nothing
from hypothesis.strategies._internal.strategies import SearchStrategy
from hypothesis.strategies._internal.utils import cacheable, defines_strategy
# See https://github.com/python/mypy/issues/3186 - numbers.Real is wrong!
Real = Union[int, float, Fraction, Decimal]
ONE_BOUND_INTEGERS_LABEL = d.calc_label_from_name(
"trying a one-bound int allowing 0")
class IntegersStrategy(SearchStrategy):
def __init__(self, start, end):
assert isinstance(start, int) or start is None
assert isinstance(end, int) or end is None
assert start is None or end is None or start <= end
self.start = start
self.end = end
def __repr__(self):
if self.start is None and self.end is None:
return "integers()"
if self.end is None:
return f"integers(min_value={self.start})"
Status,
)
from hypothesis.internal.conjecture.engine import (
MIN_TEST_CALLS,
ConjectureRunner,
ExitReason,
TargetSelector,
)
from hypothesis.internal.conjecture.shrinker import Shrinker, block_program
from hypothesis.internal.conjecture.shrinking import Float
from hypothesis.internal.conjecture.utils import Sampler, calc_label_from_name
from hypothesis.internal.entropy import deterministic_PRNG
from tests.common.strategies import SLOW, HardToShrink
from tests.common.utils import no_shrink
SOME_LABEL = calc_label_from_name("some label")
TEST_SETTINGS = settings(
max_examples=5000,
buffer_size=1024,
database=None,
suppress_health_check=HealthCheck.all(),
)
def run_to_data(f):
with deterministic_PRNG():
runner = ConjectureRunner(f, settings=TEST_SETTINGS)
runner.run()
assert runner.interesting_examples
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
type.
Except where noted otherwise, methods on this class are not part of
from hypothesis.errors import Flaky, NoSuchExample, InvalidDefinition, \
HypothesisException
from hypothesis.control import BuildContext
from hypothesis._settings import Verbosity
from hypothesis._settings import settings as Settings
from hypothesis.reporting import report, verbose_report, current_verbosity
from hypothesis.strategies import just, one_of, runner, tuples, \
fixed_dictionaries
from hypothesis.vendor.pretty import CUnicodeIO, RepresentationPrinter
from hypothesis.internal.reflection import proxies, nicerepr
from hypothesis.internal.conjecture.data import StopTest
from hypothesis.internal.conjecture.utils import integer_range, \
calc_label_from_name
from hypothesis.searchstrategy.strategies import SearchStrategy
STATE_MACHINE_RUN_LABEL = calc_label_from_name('another state machine step')
if False:
from typing import Any, Dict, List, Text # noqa
class TestCaseProperty(object): # pragma: no cover
def __get__(self, obj, typ=None):
if obj is not None:
typ = type(obj)
return typ._to_test_case()
def __set__(self, obj, value):
raise AttributeError(u'Cannot set TestCase')
def __delete__(self, obj):
low k bits, where k is 52 - unbiased exponent.
The low bits correspond to the fractional part of the floating point number.
Reversing it bitwise means that we try to minimize the low bits, which kills
off the higher powers of 2 in the fraction first.
"""
MAX_EXPONENT = 0x7FF
SPECIAL_EXPONENTS = (0, MAX_EXPONENT)
BIAS = 1023
MAX_POSITIVE_EXPONENT = MAX_EXPONENT - 1 - BIAS
DRAW_FLOAT_LABEL = calc_label_from_name("drawing a float")
def exponent_key(e):
if e == MAX_EXPONENT:
return float("inf")
unbiased = e - BIAS
if unbiased < 0:
return 10000 - unbiased
else:
return unbiased
ENCODING_TABLE = array("H", sorted(hrange(MAX_EXPONENT + 1), key=exponent_key))
DECODING_TABLE = array("H", [0]) * len(ENCODING_TABLE)
1.175494351e-38,
2.2250738585072014e-308,
1.7976931348623157e308,
3.402823466e38,
9007199254740992,
1 - 10e-6,
2 + 10e-6,
1.192092896e-07,
2.2204460492503131e-016,
] + [math.inf, math.nan] * 5,
key=flt.float_to_lex,
)
NASTY_FLOATS = list(map(float, NASTY_FLOATS))
NASTY_FLOATS.extend([-x for x in NASTY_FLOATS])
FLOAT_STRATEGY_DO_DRAW_LABEL = calc_label_from_name(
"getting another float in FloatStrategy")
class FloatStrategy(SearchStrategy):
"""Generic superclass for strategies which produce floats."""
def __init__(self, allow_infinity, allow_nan, width):
SearchStrategy.__init__(self)
assert isinstance(allow_infinity, bool)
assert isinstance(allow_nan, bool)
assert width in (16, 32, 64)
self.allow_infinity = allow_infinity
self.allow_nan = allow_nan
self.width = width
self.nasty_floats = [
float_of(f, self.width) for f in NASTY_FLOATS if self.permitted(f)
Verbosity,
note_deprecation,
settings as Settings,
)
from hypothesis.control import current_build_context
from hypothesis.core import given
from hypothesis.errors import InvalidArgument, InvalidDefinition
from hypothesis.internal.compat import hrange, quiet_raise, string_types
from hypothesis.internal.reflection import function_digest, nicerepr, proxies, qualname
from hypothesis.internal.validation import check_type
from hypothesis.reporting import current_verbosity, report
from hypothesis.searchstrategy.featureflags import FeatureStrategy
from hypothesis.searchstrategy.strategies import OneOfStrategy, SearchStrategy
from hypothesis.vendor.pretty import CUnicodeIO, RepresentationPrinter
STATE_MACHINE_RUN_LABEL = cu.calc_label_from_name("another state machine step")
if False:
from typing import Any, Dict, List, Text # noqa
class TestCaseProperty(object): # pragma: no cover
def __get__(self, obj, typ=None):
if obj is not None:
typ = type(obj)
return typ._to_test_case()
def __set__(self, obj, value):
raise AttributeError(u"Cannot set TestCase")
def __delete__(self, obj):
from hypothesis.errors import Frozen, InvalidArgument, StopTest
from hypothesis.internal.compat import (
benchmark_time,
bit_length,
hbytes,
hrange,
int_from_bytes,
int_to_bytes,
text_type,
unicode_safe_repr,
)
from hypothesis.internal.conjecture.junkdrawer import IntList
from hypothesis.internal.conjecture.utils import calc_label_from_name
from hypothesis.internal.escalation import mark_for_escalation
TOP_LABEL = calc_label_from_name("top")
DRAW_BYTES_LABEL = calc_label_from_name("draw_bytes() in ConjectureData")
class ExtraInformation(object):
"""A class for holding shared state on a ``ConjectureData`` that should
be added to the final ``ConjectureResult``."""
def __repr__(self):
return "ExtraInformation(%s)" % (", ".join(
["%s=%r" % (k, v) for k, v in self.__dict__.items()]), )
def has_information(self):
return bool(self.__dict__)
class Status(IntEnum):
combine_labels,
)
from hypothesis.internal.coverage import check_function
from hypothesis.internal.lazyformat import lazyformat
from hypothesis.internal.reflection import get_pretty_function_description
from hypothesis.utils.conventions import UniqueIdentifier
Ex = TypeVar("Ex", covariant=True)
T = TypeVar("T")
T3 = TypeVar("T3")
T4 = TypeVar("T4")
T5 = TypeVar("T5")
calculating = UniqueIdentifier("calculating")
MAPPED_SEARCH_STRATEGY_DO_DRAW_LABEL = calc_label_from_name(
"another attempted draw in MappedSearchStrategy")
FILTERED_SEARCH_STRATEGY_DO_DRAW_LABEL = calc_label_from_name(
"single loop iteration in FilteredStrategy")
def recursive_property(name, default):
"""Handle properties which may be mutually recursive among a set of
strategies.
These are essentially lazily cached properties, with the ability to set
an override: If the property has not been explicitly set, we calculate
it on first access and memoize the result for later.
The problem is that for properties that depend on each other, a naive
calculation strategy may hit infinite recursion. Consider for example
from hypothesis import Phase, Verbosity, HealthCheck, settings, unlimited
from hypothesis.errors import FailedHealthCheck
from tests.common.utils import no_shrink, checks_deprecated_behaviour
from hypothesis.database import ExampleDatabase, InMemoryExampleDatabase
from tests.common.strategies import SLOW, HardToShrink
from hypothesis.internal.compat import hbytes, hrange, int_from_bytes
from hypothesis.internal.entropy import deterministic_PRNG
from hypothesis.internal.conjecture.data import MAX_DEPTH, Status, \
ConjectureData
from hypothesis.internal.conjecture.utils import Sampler, \
calc_label_from_name
from hypothesis.internal.conjecture.engine import Shrinker, ExitReason, \
RunIsComplete, TargetSelector, ConjectureRunner, PassClassification, \
sort_key, block_program
SOME_LABEL = calc_label_from_name('some label')
def run_to_buffer(f):
with deterministic_PRNG():
runner = ConjectureRunner(f, settings=settings(
max_examples=5000, buffer_size=1024,
database=None, suppress_health_check=HealthCheck.all(),
))
runner.run()
assert runner.interesting_examples
last_data, = runner.interesting_examples.values()
return hbytes(last_data.buffer)
def test_can_index_results():
from __future__ import division, print_function, absolute_import
import sys
from enum import IntEnum
import attr
from hypothesis.errors import Frozen, StopTest, InvalidArgument
from hypothesis.internal.compat import hbytes, hrange, text_type, \
bit_length, benchmark_time, int_from_bytes, unicode_safe_repr
from hypothesis.internal.coverage import IN_COVERAGE_TESTS
from hypothesis.internal.escalation import mark_for_escalation
from hypothesis.internal.conjecture.utils import calc_label_from_name
TOP_LABEL = calc_label_from_name('top')
DRAW_BYTES_LABEL = calc_label_from_name('draw_bytes() in ConjectureData')
class Status(IntEnum):
OVERRUN = 0
INVALID = 1
VALID = 2
INTERESTING = 3
def __repr__(self):
return 'Status.%s' % (self.name,)
@attr.s(slots=True)
class Example(object):
function_digest,
nicerepr,
proxies,
qualname,
)
from hypothesis.internal.validation import check_type
from hypothesis.reporting import current_verbosity, report
from hypothesis.strategies._internal.featureflags import FeatureStrategy
from hypothesis.strategies._internal.strategies import (
OneOfStrategy,
SearchStrategy,
check_strategy,
)
from hypothesis.vendor.pretty import RepresentationPrinter
STATE_MACHINE_RUN_LABEL = cu.calc_label_from_name("another state machine step")
SHOULD_CONTINUE_LABEL = cu.calc_label_from_name("should we continue drawing")
class TestCaseProperty: # pragma: no cover
def __get__(self, obj, typ=None):
if obj is not None:
typ = type(obj)
return typ._to_test_case()
def __set__(self, obj, value):
raise AttributeError("Cannot set TestCase")
def __delete__(self, obj):
raise AttributeError("Cannot delete TestCase")
from hypothesis.errors import Frozen, InvalidArgument, StopTest
from hypothesis.internal.compat import (
benchmark_time,
bit_length,
hbytes,
hrange,
int_from_bytes,
int_to_bytes,
text_type,
unicode_safe_repr,
)
from hypothesis.internal.conjecture.junkdrawer import IntList
from hypothesis.internal.conjecture.utils import calc_label_from_name
from hypothesis.internal.escalation import mark_for_escalation
TOP_LABEL = calc_label_from_name("top")
DRAW_BYTES_LABEL = calc_label_from_name("draw_bytes() in ConjectureData")
class ExtraInformation(object):
"""A class for holding shared state on a ``ConjectureData`` that should
be added to the final ``ConjectureResult``."""
def __repr__(self):
return "ExtraInformation(%s)" % (
", ".join(["%s=%r" % (k, v) for k, v in self.__dict__.items()]),
)
def has_information(self):
return bool(self.__dict__)
