def test_keys_and_default_are_not_shared():
find_any(
st.tuples(
st.shared(st.integers(), key=1),
st.shared(st.integers())),
lambda x: x[0] != x[1]
)
def test_different_keys_are_not_shared():
find_any(
st.tuples(
st.shared(st.integers(), key=1),
st.shared(st.integers(), key=2)),
lambda x: x[0] != x[1]
)
def interleaved_strategy_factory():
'''
Generate interleaved fastq that guarantees ids are same for pairs
*_kwargs are supplied to gen seq_rec_strategy_factory
to customize forward and reverse reads
'''
strategy = st.uuids().map(str).flatmap(
lambda id:
st.tuples(
seq_rec_strategy_factory(5, 20, idstrat=st.shared(st.just(id), key=id)),
seq_rec_strategy_factory(5, 20, idstrat=st.shared(st.just(id), key=id))))
return strategy
def valid_key_string(draw):
"""
A strategy that generates valid serialized OpaqueKeys.
"""
key_type = draw(strategies.shared(strategies.sampled_from(KEY_TYPES), key="key_type"))
key = draw(keys_of_type(key_type))
return text_type(key)
def test_simplify_shared_linked_to_size():
xs = minimal(
st.lists(st.shared(st.integers())),
lambda t: sum(t) >= 1000
)
assert sum(xs[:-1]) < 1000
assert (xs[0] - 1) * len(xs) < 1000
def distinct_integers(draw):
used = draw(st.shared(st.builds(set), key="distinct_integers.used"))
i = draw(st.integers(0, 2**64 - 1).filter(lambda x: x not in used))
used.add(i)
return i
def test_parity_depends(from_, to, must_match):
"""The failfast paths are themselves made of two parts,
and they may need to differ or agree in parity depending
on whether the successful test case is even or odd"""
assert (even(from_) is even(to) if even(must_match) else
(even(from_) is not even(to)))
##
# Run various processes in the emulator
WORD_START = dev.start_of_forth_word_space
## Setup for next1 tests
vticks_next1 = shared(
integers(min_value=next.cost_of_failed_test + 1 // 2, max_value=127))
cost_of_word_success = vticks_next1.flatmap(lambda ticks: integers(
min_value=0, max_value=(ticks - (next.cost_of_failfast + 1) // 2)))
cost_of_word_failure = vticks_next1.flatmap(lambda ticks: integers(
min_value=(ticks - (next.cost_of_failfast + 1) // 2), max_value=127))
@given(vticks=vticks_next1, word_cost=cost_of_word_success)
def test_next1_successful_test(emulator, vticks, word_cost):
"""A successful test should result in us being in the right place"""
# Arrange
emulator.next_instruction = "forth.next1"
emulator.AC = 20 # Time remaining is 20 ticks - 40 cycles
set_W(WORD_START)
ROM[WORD_START] = [0xA0, word_cost]
# Act
class TestParameter(TestCase):
def test_no_name(self):
with self.assertRaises(TypeError):
Parameter()
def test_default_attributes(self):
# Test the default attributes, providing only a name
name = 'repetitions'
p = GettableParam(name, vals=vals.Numbers())
self.assertEqual(p.name, name)
self.assertEqual(p.label, name)
self.assertEqual(p.unit, '')
self.assertEqual(str(p), name)
# default validator is all numbers
p.validate(-1000)
with self.assertRaises(TypeError):
p.validate('not a number')
# docstring exists, even without providing one explicitly
self.assertIn(name, p.__doc__)
# test snapshot_get by looking at _get_count
self.assertEqual(p._get_count, 0)
snap = p.snapshot(update=True)
self.assertEqual(p._get_count, 1)
snap_expected = {
'name': name,
'label': name,
'unit': '',
'value': 42,
'vals': repr(vals.Numbers())
}
for k, v in snap_expected.items():
self.assertEqual(snap[k], v)
def test_explicit_attributes(self):
# Test the explicit attributes, providing everything we can
name = 'volt'
label = 'Voltage'
unit = 'V'
docstring = 'DOCS!'
metadata = {'gain': 100}
p = GettableParam(name,
label=label,
unit=unit,
vals=vals.Numbers(5, 10),
docstring=docstring,
snapshot_get=False,
metadata=metadata)
self.assertEqual(p.name, name)
self.assertEqual(p.label, label)
self.assertEqual(p.unit, unit)
self.assertEqual(str(p), name)
with self.assertRaises(ValueError):
p.validate(-1000)
p.validate(6)
with self.assertRaises(TypeError):
p.validate('not a number')
self.assertIn(name, p.__doc__)
self.assertIn(docstring, p.__doc__)
# test snapshot_get by looking at _get_count
self.assertEqual(p._get_count, 0)
# Snapshot should not perform get since snapshot_get is False
snap = p.snapshot(update=True)
self.assertEqual(p._get_count, 0)
snap_expected = {
'name': name,
'label': label,
'unit': unit,
'vals': repr(vals.Numbers(5, 10)),
'metadata': metadata
}
for k, v in snap_expected.items():
self.assertEqual(snap[k], v)
# attributes only available in MultiParameter
for attr in [
'names', 'labels', 'setpoints', 'setpoint_names',
'setpoint_labels', 'full_names'
]:
self.assertFalse(hasattr(p, attr), attr)
def test_number_of_validations(self):
p = Parameter('p',
set_cmd=None,
initial_value=0,
vals=BookkeepingValidator())
self.assertEqual(p.vals.values_validated, [0])
p.step = 1
p.set(10)
self.assertEqual(p.vals.values_validated,
[0, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9])
def test_snapshot_value(self):
p_snapshot = Parameter('no_snapshot',
set_cmd=None,
get_cmd=None,
snapshot_value=True)
p_snapshot(42)
snap = p_snapshot.snapshot()
self.assertIn('value', snap)
p_no_snapshot = Parameter('no_snapshot',
set_cmd=None,
get_cmd=None,
snapshot_value=False)
p_no_snapshot(42)
snap = p_no_snapshot.snapshot()
self.assertNotIn('value', snap)
def test_has_set_get(self):
# Create parameter that has no set_cmd, and get_cmd returns last value
gettable_parameter = Parameter('1', set_cmd=False, get_cmd=None)
self.assertTrue(hasattr(gettable_parameter, 'get'))
self.assertFalse(hasattr(gettable_parameter, 'set'))
with self.assertRaises(NotImplementedError):
gettable_parameter(1)
# Initial value is None if not explicitly set
self.assertIsNone(gettable_parameter())
# Create parameter that saves value during set, and has no get_cmd
settable_parameter = Parameter('2', set_cmd=None, get_cmd=False)
self.assertFalse(hasattr(settable_parameter, 'get'))
self.assertTrue(hasattr(settable_parameter, 'set'))
with self.assertRaises(NotImplementedError):
settable_parameter()
settable_parameter(42)
settable_gettable_parameter = Parameter('3',
set_cmd=None,
get_cmd=None)
self.assertTrue(hasattr(settable_gettable_parameter, 'set'))
self.assertTrue(hasattr(settable_gettable_parameter, 'get'))
self.assertIsNone(settable_gettable_parameter())
settable_gettable_parameter(22)
self.assertEqual(settable_gettable_parameter(), 22)
def test_str_representation(self):
# three cases where only name gets used for full_name
for instrument in blank_instruments:
p = Parameter(name='fred')
p._instrument = instrument
self.assertEqual(str(p), 'fred')
# and finally an instrument that really has a name
p = Parameter(name='wilma')
p._instrument = named_instrument
self.assertEqual(str(p), 'astro_wilma')
def test_bad_validator(self):
with self.assertRaises(TypeError):
Parameter('p', vals=[1, 2, 3])
def test_step_ramp(self):
p = MemoryParameter(name='test_step')
p(42)
self.assertListEqual(p.set_values, [42])
p.step = 1
self.assertListEqual(p.get_ramp_values(44.5, 1), [43, 44, 44.5])
p(44.5)
self.assertListEqual(p.set_values, [42, 43, 44, 44.5])
def test_scale_raw_value(self):
p = Parameter(name='test_scale_raw_value', set_cmd=None)
p(42)
self.assertEqual(p.raw_value, 42)
p.scale = 2
self.assertEqual(p.raw_value, 42) # No set/get cmd performed
self.assertEqual(p(), 21)
p(10)
self.assertEqual(p.raw_value, 20)
self.assertEqual(p(), 10)
# There are a number different scenarios for testing a parameter with scale
# and offset. Therefore a custom strategy for generating test parameters
# is implemented here. The possible cases are:
# for getting and setting a parameter: values can be
# scalar:
# offset and scale can be scalars
# for getting only:
# array:
# offset and scale can be scalars or arrays(of same legnth as values)
# independently
# define shorthands for strategies
TestFloats = hst.floats(min_value=-1e40,
max_value=1e40).filter(lambda x: x != 0)
SharedSize = hst.shared(hst.integers(min_value=1, max_value=100),
key='shared_size')
ValuesScalar = hst.shared(hst.booleans(), key='values_scalar')
# the following test stra
@hst.composite
def iterable_or_number(draw, values, size, values_scalar, is_values):
if draw(values_scalar):
# if parameter values are scalar, return scalar for values and scale/offset
return draw(values)
elif is_values:
# if parameter values are not scalar and parameter values are requested
# return a list of values of the given size
return draw(
hst.lists(values, min_size=draw(size), max_size=draw(size)))
else:
# if parameter values are not scalar and scale/offset are requested
# make a random choice whether to return a list of the same size as the values
# or a simple scalar
if draw(hst.booleans()):
return draw(
hst.lists(values, min_size=draw(size),
max_size=draw(size)))
else:
return draw(values)
@settings(max_examples=500) # default:100 increased
@given(values=iterable_or_number(TestFloats, SharedSize, ValuesScalar,
True),
offsets=iterable_or_number(TestFloats, SharedSize, ValuesScalar,
False),
scales=iterable_or_number(TestFloats, SharedSize, ValuesScalar,
False))
def test_scale_and_offset_raw_value_iterable(self, values, offsets,
scales):
p = Parameter(name='test_scale_and_offset_raw_value', set_cmd=None)
# test that scale and offset does not change the default behaviour
p(values)
self.assertEqual(p.raw_value, values)
# test setting scale and offset does not change anything
p.scale = scales
p.offset = offsets
self.assertEqual(p.raw_value, values)
np_values = np.array(values)
np_offsets = np.array(offsets)
np_scales = np.array(scales)
np_get_values = np.array(p())
np.testing.assert_allclose(np_get_values, (np_values - np_offsets) /
np_scales) # No set/get cmd performed
# test set, only for scalar values
if not isinstance(values, Iterable):
p(values)
np.testing.assert_allclose(np.array(p.raw_value),
np_values * np_scales +
np_offsets) # No set/get cmd performed
# testing conversion back and forth
p(values)
np_get_values = np.array(p())
np.testing.assert_allclose(np_get_values,
np_values) # No set/get cmd performed
# adding statistics
if isinstance(offsets, Iterable):
event('Offset is array')
if isinstance(scales, Iterable):
event('Scale is array')
if isinstance(values, Iterable):
event('Value is array')
if isinstance(scales, Iterable) and isinstance(offsets, Iterable):
event('Scale is array and also offset')
if isinstance(scales, Iterable) and not isinstance(offsets, Iterable):
event('Scale is array but not offset')
@given(scale=hst.integers(1, 100),
value=hst.floats(min_value=1e-9, max_value=10))
def test_ramp_scaled(self, scale, value):
start_point = 0.0
p = MemoryParameter(name='p', scale=scale, initial_value=start_point)
assert p() == start_point
# first set a step size
p.step = 0.1
# and a wait time
p.inter_delay = 1e-9 # in seconds
first_step = 1.0
second_step = 10.0
# do a step to start from a non zero starting point where
# scale matters
p.set(first_step)
np.testing.assert_allclose(np.array([p.get()]), np.array([first_step]))
expected_raw_steps = np.linspace(start_point * scale,
first_step * scale, 11)
# getting the raw values that are actually send to the instrument.
# these are scaled in the set_wrapper
np.testing.assert_allclose(np.array(p.set_values), expected_raw_steps)
assert p.raw_value == first_step * scale
# then check the generated steps. They should not be scaled as the
# scaling happens when setting them
expected_steps = np.linspace(first_step + p.step, second_step, 90)
np.testing.assert_allclose(p.get_ramp_values(second_step, p.step),
expected_steps)
p.set(10)
np.testing.assert_allclose(np.array(p.set_values),
np.linspace(0.0 * scale, 10 * scale, 101))
p.set(value)
np.testing.assert_allclose(p.get(), value)
assert p.raw_value == value * scale
@given(value=hst.floats(min_value=1e-9, max_value=10))
def test_ramp_parser(self, value):
start_point = 0.0
p = MemoryParameter(name='p',
set_parser=lambda x: -x,
get_parser=lambda x: -x,
initial_value=start_point)
assert p() == start_point
# first set a step size
p.step = 0.1
# and a wait time
p.inter_delay = 1e-9 # in seconds
first_step = 1.0
second_step = 10.0
# do a step to start from a non zero starting point where
# scale matters
p.set(first_step)
assert p.get() == first_step
assert p.raw_value == -first_step
np.testing.assert_allclose(np.array([p.get()]), np.array([first_step]))
expected_raw_steps = np.linspace(-start_point, -first_step, 11)
# getting the raw values that are actually send to the instrument.
# these are parsed in the set_wrapper
np.testing.assert_allclose(np.array(p.set_values), expected_raw_steps)
assert p.raw_value == -first_step
# then check the generated steps. They should not be parsed as the
# scaling happens when setting them
expected_steps = np.linspace((first_step + p.step), second_step, 90)
np.testing.assert_allclose(p.get_ramp_values(second_step, p.step),
expected_steps)
p.set(second_step)
np.testing.assert_allclose(
np.array(p.set_values), np.linspace(-start_point, -second_step,
101))
p.set(value)
np.testing.assert_allclose(p.get(), value)
assert p.raw_value == -value
@given(scale=hst.integers(1, 100),
value=hst.floats(min_value=1e-9, max_value=10))
def test_ramp_parsed_scaled(self, scale, value):
start_point = 0.0
p = MemoryParameter(name='p',
scale=scale,
set_parser=lambda x: -x,
get_parser=lambda x: -x,
initial_value=start_point)
assert p() == start_point
# first set a step size
p.step = 0.1
# and a wait time
p.inter_delay = 1e-9 # in seconds
first_step = 1.0
second_step = 10.0
p.set(first_step)
assert p.get() == first_step
assert p.raw_value == -first_step * scale
expected_raw_steps = np.linspace(-start_point * scale,
-first_step * scale, 11)
# getting the raw values that are actually send to the instrument.
# these are parsed in the set_wrapper
np.testing.assert_allclose(np.array(p.set_values), expected_raw_steps)
assert p.raw_value == -scale * first_step
expected_steps = np.linspace(first_step + p.step, second_step, 90)
np.testing.assert_allclose(p.get_ramp_values(10, p.step),
expected_steps)
p.set(second_step)
np.testing.assert_allclose(
np.array(p.set_values),
np.linspace(-start_point * scale, -second_step * scale, 101))
p.set(value)
np.testing.assert_allclose(p.get(), value)
assert p.raw_value == -scale * value
def dtype_for_elements_strategy(s):
return st.shared(
s.map(lambda x: pandas.Series([x]).dtype),
key=('hypothesis.extra.pandas.dtype_for_elements_strategy', s),
)
meta.extend([dsp.iloc[i, :].tolist()] * n)
meta = pd.DataFrame(meta, columns=dsp.columns)
p = sum(nreps)
n = draw(nobs)
observation = st.lists(observations, min_size=p, max_size=p)
time = draw(st.lists(time, min_size=n, max_size=n, unique=True))
data = draw(st.lists(observation, min_size=n, max_size=n))
data = pd.DataFrame([[t] + d for t, d in zip(time, data)])
return popmachine.DataSet(data, meta)
sharedDesignSpace = st.shared(designSpace(), key='incomplete-designspace')
@st.composite
def compendia(draw,designspace=sharedDesignSpace,
nrep=st.integers(min_value=0,max_value=3),\
nobs=st.integers(min_value=1,max_value=50), observations=st.floats(),\
time=st.floats(allow_infinity=False, allow_nan=False)):
"""Create a list of datasets all created from a shared design space."""
n = draw(st.integers(min_value=2, max_value=5))
ds = dataset(designspace, nrep, nobs, observations, time)
datasets = draw(st.lists(ds, min_size=n, max_size=n))
names = draw(st.lists(charstring, min_size=n, max_size=n, unique=True))
return names, datasets
def test_different_instances_are_not_shared():
find_any(
st.tuples(st.shared(st.integers()), st.shared(st.integers())),
lambda x: x[0] != x[1]
)
# 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 __future__ import absolute_import, division, print_function
import hypothesis.strategies as st
from hypothesis import given
from tests.common.debug import find_any, minimal
x = st.shared(st.integers())
@given(x, x)
def test_sharing_is_by_instance_by_default(a, b):
assert a == b
@given(st.shared(st.integers(), key="hi"), st.shared(st.integers(), key="hi"))
def test_different_instances_with_the_same_key_are_shared(a, b):
assert a == b
def test_different_instances_are_not_shared():
find_any(
st.tuples(st.shared(st.integers()), st.shared(st.integers())),
class TestParseLine:
@given(
st.shared(
st.text(min_size=1).map(lambda tkn: tkn.encode("utf8")),
key="parse-line-token",
),
(st.shared(
st.text(min_size=1).map(lambda tkn: tkn.encode("utf8")),
key="parse-line-token",
).flatmap(lambda tkn: st.binary().filter(lambda ln: b"\n" not in ln and
not ln.startswith(tkn)))),
)
def test_invalid_token_skips(self, token, line):
assert parse_line(line, token=token) is None
@given(
st.none() | st.text(min_size=1).map(lambda tkn: tkn.encode("utf8")),
st.binary().filter(lambda ln: b"\n" not in ln),
)
def test_unparseable_syslog(self, caplog, token, line):
if token is not None:
line = token + line
caplog.clear()
assert parse_line(line, token=token) is None
assert caplog.record_tuples == [("linehaul.server", logging.ERROR, ANY)
]
assert caplog.record_tuples[0][2].startswith(
"Unparseable syslog message")
@given(
st.none() | st.text(min_size=1).map(lambda tkn: tkn.encode("utf8")),
st.binary().filter(lambda ln: b"\n" not in ln).map(
lambda d:
b"<134>2018-07-20T02:19:20Z cache-itm18828 linehaul[411617]: " + d
),
)
def test_unparseable_event(self, caplog, token, line):
if token is not None:
line = token + line
caplog.clear()
assert parse_line(line, token=token) is None
assert caplog.record_tuples == [("linehaul.server", logging.ERROR, ANY)
]
assert caplog.record_tuples[0][2].startswith("Unparseable event:")
@pytest.mark.parametrize(
("event", "exception"),
[(
("2@Fri, 20 Jul 2018 02:19:19 GMT|JP|/packages/ba/c8/"
"a928c55457441c87366eb2423efca9aa0f46380994fd8a476153493c319a/"
"cfn_flip-1.0.3.tar.gz|TLSv1.2|ECDHE-RSA-AES128-GCM-SHA256|"
"(null)|1.0.3|sdist|bandersnatch/2.2.1 "
"(cpython 3.7.0-final0, Darwin x86_64)"),
TypeError,
)],
)
def test_parsing_raises(self, caplog, event, exception):
line = "<134>2018-07-20T02:19:20Z cache-itm18828 linehaul[411617]: " + event
assert parse_line(line.encode("utf8")) is None
assert caplog.record_tuples == [("linehaul.server", logging.ERROR,
"Unhandled error:")]
def test_returns_download_event(self):
event = (
"2@Fri, 20 Jul 2018 02:19:19 GMT|JP|/packages/ba/c8/"
"a928c55457441c87366eb2423efca9aa0f46380994fd8a476153493c319a/"
"cfn_flip-1.0.3.tar.gz|TLSv1.2|ECDHE-RSA-AES128-GCM-SHA256|"
"cfn-flip|1.0.3|sdist|"
"bandersnatch/2.2.1 (cpython 3.7.0-final0, Darwin x86_64)")
line = "<134>2018-07-20T02:19:20Z cache-itm18828 linehaul[411617]: " + event
expected = _cattr.structure(
{
"country_code":
"JP",
"details": {
"installer": {
"name": "bandersnatch",
"version": "2.2.1"
}
},
"file": {
"filename": "cfn_flip-1.0.3.tar.gz",
"project": "cfn-flip",
"type": "sdist",
"version": "1.0.3",
},
"timestamp":
"Fri, 20 Jul 2018 02:19:19 GMT",
"tls_cipher":
"ECDHE-RSA-AES128-GCM-SHA256",
"tls_protocol":
"TLSv1.2",
"url":
("/packages/ba/c8/a928c55457441c87366eb2423efca9aa0f4638099"
"4fd8a476153493c319a/cfn_flip-1.0.3.tar.gz"),
},
Download,
)
assert parse_line(line.encode("utf8")) == expected
"TLSv1.2",
"url":
("/packages/ba/c8/a928c55457441c87366eb2423efca9aa0f4638099"
"4fd8a476153493c319a/cfn_flip-1.0.3.tar.gz"),
},
Download,
)
assert parse_line(line.encode("utf8")) == expected
@given(
st.builds(
Download,
timestamp=st.shared(
st.dates(),
key="extract-item-data").map(lambda i: arrow.Arrow.fromdate(i)),
),
st.shared(st.dates(), key="extract-item-data").map(
lambda i: f"{i.year:04}{i.month:02}{i.day:02}"),
)
def test_extract_item_data(download, expected):
assert extract_item_date(download) == expected
@given(
st.lists(
st.builds(Download,
timestamp=st.dates().map(lambda i: arrow.Arrow.fromdate(i))))
)
def test_compute_batches(events):
BYTES_LOOKUP = {
sre.CATEGORY_DIGIT: BYTES_DIGIT,
sre.CATEGORY_SPACE: BYTES_SPACE,
sre.CATEGORY_WORD: BYTES_WORD,
sre.CATEGORY_NOT_DIGIT: BYTES_ALL - BYTES_DIGIT,
sre.CATEGORY_NOT_SPACE: BYTES_ALL - BYTES_SPACE,
sre.CATEGORY_NOT_WORD: BYTES_ALL - BYTES_WORD,
}
# On Python < 3.4 (including 2.7), the following unicode chars are weird.
# They are matched by the \W, meaning 'not word', but unicodedata.category(c)
# returns one of the word categories above. There's special handling below.
HAS_WEIRD_WORD_CHARS = sys.version_info[:2] < (3, 4)
UNICODE_WEIRD_NONWORD_CHARS = set(u'\U00012432\U00012433\U00012456\U00012457')
GROUP_CACHE_STRATEGY = st.shared(st.builds(dict),
key='hypothesis.regex.group_cache')
@st.composite
def update_group(draw, group_name, strategy):
cache = draw(GROUP_CACHE_STRATEGY)
result = draw(strategy)
cache[group_name] = result
return result
@st.composite
def reuse_group(draw, group_name):
cache = draw(GROUP_CACHE_STRATEGY)
try:
return cache[group_name]
def mutate(self, draw: Draw) -> Schema:
# On the top level, Schemathesis creates "object" schemas for all parameter "in" values except "body", which is
# taken as-is. Therefore we can only apply mutations that won't change the Open API semantics of the schema.
mutations: List[Mutation]
if self.location in ("header", "cookie", "query"):
# These objects follow this pattern:
# {
# "properties": properties,
# "additionalProperties": False,
# "type": "object",
# "required": required
# }
# Open API semantics expect mapping; therefore, they should have the "object" type.
# We can:
# - remove required parameters
# - negate constraints (only `additionalProperties` in this case)
# - mutate individual properties
mutations = draw(
ordered((remove_required_property, negate_constraints,
change_properties)))
elif self.is_path_location:
# The same as above, but we can only mutate individual properties as their names are predefined in the
# path template, and all of them are required.
mutations = [change_properties]
else:
# Body can be of any type and does not have any specific type semantic.
mutations = draw(ordered(get_mutations(draw, self.keywords)))
# Deep copy all keywords to avoid modifying the original schema
new_schema = deepcopy(self.keywords)
enabled_mutations = draw(st.shared(FeatureStrategy(),
key="mutations")) # type: ignore
result = MutationResult.FAILURE
for mutation in mutations:
if enabled_mutations.is_enabled(mutation.__name__):
result |= mutation(self, draw, new_schema)
if result == MutationResult.FAILURE:
# If we failed to apply anything, then reject the whole case
reject() # type: ignore
new_schema.update(self.non_keywords)
if self.is_header_location:
# All headers should have names that can be sent over network
new_schema["propertyNames"] = {
"type": "string",
"format": "_header_name"
}
for sub_schema in new_schema.get("properties", {}).values():
sub_schema["type"] = "string"
if len(sub_schema) == 1:
sub_schema["format"] = "_header_value"
if draw(st.booleans()):
# In headers, `additionalProperties` are False by default, which means that Schemathesis won't generate
# any headers that are not defined. This change adds the possibility of generating valid extra headers
new_schema["additionalProperties"] = {
"type": "string",
"format": "_header_value"
}
# Empty array or objects may match the original schema
if "array" in get_type(new_schema) and new_schema.get(
"items") and "minItems" not in new_schema.get("not", {}):
new_schema.setdefault("minItems", 1)
if ("object" in get_type(new_schema) and new_schema.get("properties")
and "minProperties" not in new_schema.get("not", {})):
new_schema.setdefault("minProperties", 1)
return new_schema
BYTES_WORD = {b for b in BYTES_ALL if re.match(b"\\w", b)}
BYTES_LOOKUP = {
sre.CATEGORY_DIGIT: BYTES_DIGIT,
sre.CATEGORY_SPACE: BYTES_SPACE,
sre.CATEGORY_WORD: BYTES_WORD,
sre.CATEGORY_NOT_DIGIT: BYTES_ALL - BYTES_DIGIT,
sre.CATEGORY_NOT_SPACE: BYTES_ALL - BYTES_SPACE,
sre.CATEGORY_NOT_WORD: BYTES_ALL - BYTES_WORD,
}
# On Python 2, these unicode chars are matched by \W, meaning 'not word',
# but unicodedata.category(c) returns one of the word categories above.
UNICODE_WEIRD_NONWORD_CHARS = set(u"\U00012432\U00012433\U00012456\U00012457")
GROUP_CACHE_STRATEGY = st.shared(st.builds(dict), key="hypothesis.regex.group_cache")
@st.composite
def update_group(draw, group_name, strategy):
cache = draw(GROUP_CACHE_STRATEGY)
result = draw(strategy)
cache[group_name] = result
return result
@st.composite
def reuse_group(draw, group_name):
cache = draw(GROUP_CACHE_STRATEGY)
try:
return cache[group_name]
def test_different_instances_are_not_shared():
find(
st.tuples(st.shared(st.integers()), st.shared(st.integers())),
lambda x: x[0] != x[1]
)
).map(join_tuple)
malformed_type_strs = st.one_of(
malformed_non_tuple_type_strs,
malformed_tuple_type_strs,
)
#################################
# Type string w/data strategies #
#################################
MIN_LIST_SIZE = 1
MAX_LIST_SIZE = 8
uint_total_bits = st.shared(total_bits, key='uint_total_bits')
uint_strs = uint_total_bits.map('uint{}'.format)
uint_values = uint_total_bits.flatmap(lambda n: st.integers(
min_value=0,
max_value=2 ** n - 1,
))
int_total_bits = st.shared(total_bits, key='int_total_bits')
int_strs = int_total_bits.map('int{}'.format)
int_values = int_total_bits.flatmap(lambda n: st.integers(
min_value=-2 ** (n - 1),
max_value=2 ** (n - 1) - 1,
))
def scale_places(places):
def test_simplify_shared_linked_to_size():
xs = find(st.lists(st.shared(st.integers())), lambda t: sum(t) >= 1000)
assert sum(xs[:-1]) < 1000
assert (xs[0] - 1) * len(xs) < 1000
embedding = embedding_object.embedding
labels = embedding_object.labels
neighbors = embed.get_neighbors(embedding, labels, n_neighbors=self.n_neighbors, algorithm='brute', metric=metric)
self.neighbors = neighbors
## add to existing metadata
metadata = embedding_object.metadata
metadata["k-nn Metric"] = metric
metadata["Number of Neighbors"] = str(self.n_neighbors)
metadata["Other Neighbors Information"] = other_info
self.metadata = metadata
EmbeddingStrategy = st.builds(Embedding,
st.data(),
st.shared(st.lists(elements=st.text(average_size=10, min_size=1), min_size=7, max_size=200, unique=True), key='shared_labels'),
st.text(average_size=10),
st.text(average_size=10),
st.text(average_size=10),
st.integers(min_value=0, max_value=1000))
NeighborsStrategy = st.builds(Neighbors,
EmbeddingStrategy,
st.data(),
st.text(max_size=20),
st.sampled_from(KNN_METRICS))
def comparison_equality(comparison1, comparison2):
"""
Equality test for the outputs of compare_neighbors.
output_string = output_string[:range_start] + substitution + output_string[range_end:]
return output_string
@_strategies.cacheable
def perturbed_strings(string_strategy):
"""
A strategy that constructs a string using the supplied ``string_strategy``,
and then perturbs it.
"""
return perturbed_by_character(string_strategy) | perturbed_by_subsection(string_strategy)
@given(
key_type=strategies.shared(strategies.sampled_from(KEY_TYPES), key="key_type"),
serialized=strategies.shared(valid_key_string(), key="diff_serial_diff_key"),
perturbed=perturbed_strings(strategies.shared(valid_key_string(), key="diff_serial_diff_key")),
)
@example(
key_type=DefinitionKey,
serialized='def-v1:000000000000000000000000+type@-',
perturbed='def-v1:00000000000000000000000+type@-',
)
@example(
key_type=CourseKey,
serialized=u'library-v1:-+-+branch@-+version@000000000000000000000000',
perturbed=u'library-v1:-+-+branch@-+versIon@000000000000000000000000',
)
@example(
key_type=DefinitionKey,
# 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 __future__ import absolute_import, division, print_function
import hypothesis.strategies as st
from hypothesis import given
from tests.common.debug import find_any, minimal
x = st.shared(st.integers())
@given(x, x)
def test_sharing_is_by_instance_by_default(a, b):
assert a == b
@given(st.shared(st.integers(), key="hi"), st.shared(st.integers(), key="hi"))
def test_different_instances_with_the_same_key_are_shared(a, b):
assert a == b
def test_different_instances_are_not_shared():
find_any(
st.tuples(st.shared(st.integers()), st.shared(st.integers())),
data_stack_depth=data_stack_depths(with_room_for_values=2), tos=numbers, nos=numbers
)
def test_minus(emulator, data_stack, data_stack_depth, tos, nos):
# Arrange
data_stack.set_depth_in_bytes(data_stack_depth)
data_stack.push_word(nos)
data_stack.push_word(tos)
# Act
_do_test_thread(emulator, "forth.core.-")
# Assert
(nos - tos) & 0xFFFF == data_stack.pop_u16()
assert data_stack_depth == len(data_stack)
# Strategies that might generate equal values (if I understand correctly)
values = shared(numbers)
maybe_equal = values.flatmap(lambda value: one_of(just(value), numbers))
@given(
data_stack_depth=data_stack_depths(with_room_for_values=2),
tos=values,
nos=maybe_equal,
)
def test_equals(emulator, data_stack, data_stack_depth, tos, nos):
# Arrange
data_stack.set_depth_in_bytes(data_stack_depth)
data_stack.push_word(nos)
data_stack.push_word(tos)
# Act
_do_test_thread(emulator, "forth.core.=")
max_leaves=5,
).map(join_tuple)
malformed_type_strs = st.one_of(
malformed_non_tuple_type_strs,
malformed_tuple_type_strs,
)
#################################
# Type string w/data strategies #
#################################
MIN_LIST_SIZE = 1
MAX_LIST_SIZE = 8
uint_total_bits = st.shared(total_bits, key='uint_total_bits')
uint_strs = uint_total_bits.map('uint{}'.format)
uint_values = uint_total_bits.flatmap(lambda n: st.integers(
min_value=0,
max_value=2**n - 1,
))
int_total_bits = st.shared(total_bits, key='int_total_bits')
int_strs = int_total_bits.map('int{}'.format)
int_values = int_total_bits.flatmap(lambda n: st.integers(
min_value=-2**(n - 1),
max_value=2**(n - 1) - 1,
))
def scale_places(places):
def from_typing_type(thing):
# We start with special-case support for Union and Tuple - the latter
# isn't actually a generic type. Support for Callable may be added to
# this section later.
# We then explicitly error on non-Generic types, which don't carry enough
# information to sensibly resolve to strategies at runtime.
# Finally, we run a variation of the subclass lookup in st.from_type
# among generic types in the lookup.
import typing
# Under 3.6 Union is handled directly in st.from_type, as the argument is
# not an instance of `type`. However, under Python 3.5 Union *is* a type
# and we have to handle it here, including failing if it has no parameters.
if hasattr(thing, '__union_params__'): # pragma: no cover
args = sorted(thing.__union_params__ or (), key=type_sorting_key)
if not args:
raise ResolutionFailed('Cannot resolve Union of no types.')
return st.one_of([st.from_type(t) for t in args])
if getattr(thing, '__origin__', None) == tuple or \
isinstance(thing, getattr(typing, 'TupleMeta', ())):
elem_types = getattr(thing, '__tuple_params__', None) or ()
elem_types += getattr(thing, '__args__', None) or ()
if getattr(thing, '__tuple_use_ellipsis__', False) or \
len(elem_types) == 2 and elem_types[-1] is Ellipsis:
return st.lists(st.from_type(elem_types[0])).map(tuple)
elif len(elem_types) == 1 and elem_types[0] == ():
return st.tuples() # Empty tuple; see issue #1583
return st.tuples(*map(st.from_type, elem_types))
if isinstance(thing, typing.TypeVar):
if getattr(thing, '__bound__', None) is not None:
return st.from_type(thing.__bound__)
if getattr(thing, '__constraints__', None):
return st.shared(st.sampled_from(thing.__constraints__),
key='typevar-with-constraint').flatmap(
st.from_type)
# Constraints may be None or () on various Python versions.
return st.text() # An arbitrary type for the typevar
# Now, confirm that we're dealing with a generic type as we expected
if not isinstance(thing, typing_root_type): # pragma: no cover
raise ResolutionFailed('Cannot resolve %s to a strategy' % (thing, ))
# Parametrised generic types have their __origin__ attribute set to the
# un-parametrised version, which we need to use in the subclass checks.
# e.g.: typing.List[int].__origin__ == typing.List
mapping = {
k: v
for k, v in _global_type_lookup.items()
if isinstance(k, typing_root_type) and try_issubclass(k, thing)
}
if typing.Dict in mapping:
# The subtype relationships between generic and concrete View types
# are sometimes inconsistent under Python 3.5, so we pop them out to
# preserve our invariant that all examples of from_type(T) are
# instances of type T - and simplify the strategy for abstract types
# such as Container
for t in (typing.KeysView, typing.ValuesView, typing.ItemsView):
mapping.pop(t, None)
strategies = [
v if isinstance(v, st.SearchStrategy) else v(thing)
for k, v in mapping.items() if sum(
try_issubclass(k, T) for T in mapping) == 1
]
empty = ', '.join(repr(s) for s in strategies if s.is_empty)
if empty or not strategies: # pragma: no cover
raise ResolutionFailed(
'Could not resolve %s to a strategy; consider using '
'register_type_strategy' % (empty or thing, ))
return st.one_of(strategies)
def chromeReqResp ():
# XXX: will this gnerated the same url for all testcases?
reqid = st.shared (st.text (), 'reqresp')
url = st.shared (urlsStr (), 'reqresp')
return st.tuples (chromeRequestWillBeSent (reqid, url),
chromeResponseReceived (reqid, url))
def dtype_for_elements_strategy(s):
return st.shared(
s.map(lambda x: pandas.Series([x]).dtype),
key=("hypothesis.extra.pandas.dtype_for_elements_strategy", s),
)
types = [None, "a", "b", "c"]
@composite
def fakefiles_(draw, *, files=None, minfiles=0, maxfiles=40):
if files is None:
files = lists(tuples(kind_floats(min_value=-5, max_value=5),
sampled_from(types)),
max_size=maxfiles,
min_size=minfiles)
info = draw(files, label="file values and types")
res = FakeFiles(draw, info)
return res
fakefiles = lambda *a, **kw: shared(fakefiles_(*a, **kw), key="files")
@composite
def make_stats_(draw, *, minholdout=0, **kwargs):
# TODO: reuse ratio? more realistic distribution
stats = state.Stats()
kwargs["minfiles"] = kwargs.get("minfiles", 0) + minholdout
kwargs["maxfiles"] = kwargs.get("minfiles", 40) + minholdout
files = draw(fakefiles(**kwargs))
comparisons_per_file = draw(integers(min_value=0, max_value=7),
label="comparisons per file")
assert len(files.af) - minholdout >= 0
compared_files = draw(integers(min_value=0,
max_value=len(files.af) - minholdout),
label="files to use")
def generate_tuples_of_arrays(
draw,
dtype_strategy=ints_floats_datetimes_and_timedeltas(),
max_tuple_length=30,
max_array_size=200,
all_same_width=False,
all_same_height=False,
):
shape_type = draw(integers(
min_value=0,
max_value=4)) # 0: (1,1), 1: (x,), 2: (x,1), 3: (1,x), 4: (x,y)
if shape_type == 1 and all_same_height:
shape_type = 3
dtype = shared(dtype_strategy)
# NOTE: shape=(height, width) or shape=(width,)
starting_size = (
draw(integers(min_value=2, max_value=max_array_size)),
draw(integers(min_value=2, max_value=max_array_size)),
)
arr_list = []
arr_length = draw(shared(integers(min_value=1,
max_value=max_tuple_length)))
if shape_type == 0: # (1,1)
for i in range(arr_length):
arr_list.append(draw(arrays(dtype=dtype, shape=(1, 1))))
elif shape_type == 1: # (x,)
if all_same_width:
for i in range(arr_length):
arr_list.append(
draw(arrays(dtype=dtype, shape=(starting_size[1], ))))
else:
for i in range(arr_length):
x = draw(integers(min_value=1, max_value=max_array_size))
arr_list.append(draw(arrays(dtype=dtype, shape=(x, ))))
elif shape_type == 2: # (x,1)
if all_same_height:
for i in range(arr_length):
arr_list.append(
draw(arrays(dtype=dtype, shape=(starting_size[0], 1))))
else:
for i in range(arr_length):
x = draw(integers(min_value=1, max_value=max_array_size))
arr_list.append(draw(arrays(dtype=dtype, shape=(x, 1))))
elif shape_type == 3: # (1,x)
if all_same_width:
for i in range(arr_length):
arr_list.append(
draw(arrays(dtype=dtype, shape=(1, starting_size[1]))))
else:
for i in range(arr_length):
x = draw(integers(min_value=1, max_value=max_array_size))
arr_list.append(draw(arrays(dtype=dtype, shape=(1, x))))
elif shape_type == 4: # (x,y)
if all_same_width and all_same_height:
for i in range(arr_length):
arr_list.append(
draw(
arrays(dtype=dtype,
shape=(starting_size[0], starting_size[1]))))
elif all_same_height:
for i in range(arr_length):
x = draw(integers(min_value=1, max_value=max_array_size))
arr_list.append(
draw(arrays(dtype=dtype, shape=(starting_size[0], x))))
elif all_same_width:
for i in range(arr_length):
x = draw(integers(min_value=1, max_value=max_array_size))
arr_list.append(
draw(arrays(dtype=dtype, shape=(x, starting_size[1]))))
else:
for i in range(arr_length):
x = draw(integers(min_value=1, max_value=max_array_size))
y = draw(integers(min_value=1, max_value=max_array_size))
arr_list.append(draw(arrays(dtype=dtype, shape=(x, y))))
return tuple(arr_list)
from functools import reduce
from hypothesis import given
import hypothesis.strategies as st
import hypothesis.extra.numpy as hnp
import numpy as np
import pytest
import qsim.gate
# -- Strategies for generating values --
n_qubits = st.shared(st.integers(min_value=1, max_value=6))
# Choose which qubits from 'n_qubits' to operate on with a gate that
# operates on 'gate_size' qubits
def select_n_qubits(gate_size):
def _strat(n_qubits):
assert n_qubits >= gate_size
possible_qubits = st.integers(0, n_qubits - 1)
return st.lists(possible_qubits, gate_size, gate_size,
unique=True).map(tuple)
return _strat
valid_complex = st.complex_numbers(allow_infinity=False, allow_nan=False)
phases = st.floats(min_value=0,
max_value=2 * np.pi,
allow_nan=False,
def generate_ndarrays(draw):
shape = draw(shared(one_darray_shape_strategy(max_shape_size=10)))
dtype = draw(one_of_supported_dtypes())
arr1 = draw(arrays(shape=shape, dtype=dtype, unique=True))
arr2 = draw(arrays(shape=shape, dtype=dtype, unique=True))
return (arr1, arr2)
def _handle_state(self, state):
opcode, value = state
if opcode == re.sre_parse.LITERAL:
return strats.just(hunichr(value))
elif opcode == re.sre_parse.NOT_LITERAL:
return strats.characters(blacklist_characters=hunichr(value))
elif opcode == re.sre_parse.AT:
return strats.just('')
elif opcode == re.sre_parse.IN:
if value[0][0] == re.sre_parse.NEGATE:
candidates = []
for v in value[1:]:
candidates.extend(chain(*(self._handle_character_sets(v))))
return strats.characters(blacklist_characters=candidates)
else:
candidates = []
for v in value:
candidates.extend(chain(*(self._handle_character_sets(v))))
return strats.sampled_from(candidates)
elif opcode == re.sre_parse.ANY:
return strats.characters()
elif opcode == re.sre_parse.BRANCH:
branches = []
for val in value[1]:
branch = [self._handle_state(v) for v in val]
branches.append(strategy_concat(branch))
return strats.one_of(branches)
elif opcode == re.sre_parse.SUBPATTERN:
parts = []
for part in value[1]:
parts.append(self._handle_state(part))
result = strategy_concat(parts)
if value[0]:
self.cache[value[0]] = result
result = strats.shared(result, key=value[0])
return result
elif opcode == re.sre_parse.ASSERT:
result = []
for part in value[1]:
result.append(self._handle_state(part))
return strategy_concat(result)
elif opcode == re.sre_parse.ASSERT_NOT:
return strats.just('')
elif opcode == re.sre_parse.GROUPREF:
return strats.shared(self.cache[value], key=value)
elif opcode == re.sre_parse.MIN_REPEAT:
start_range, end_range, val = value
result = []
for v in val:
part = strats.lists(
self._handle_state(v),
min_size=start_range,
max_size=end_range).map(lambda x: u"".join(x))
result.append(part)
return strategy_concat(result)
elif opcode == re.sre_parse.MAX_REPEAT:
start_range, end_range, val = value
result = []
for v in val:
part = strats.lists(
self._handle_state(v),
min_size=start_range,
max_size=end_range).map(lambda x: u"".join(x))
result.append(part)
return strats.tuples(*result).map(lambda x: u"".join(x))
else:
import ipdb
ipdb.set_trace()
raise NotImplementedError(opcode)
unsized_list_raw_strats = [
(type_str + "[]", st.lists(type_strat, min_size=0, max_size=MAX_LIST_SIZE).map(tuple))
for type_str, type_strat in all_basic_raw_strats
]
unsized_list_strats = [
st.tuples(st.just(type_str), type_strat)
for type_str, type_strat in unsized_list_raw_strats
]
sized_list_strats = [
st.tuples(
st.shared(
st.integers(min_value=MIN_LIST_SIZE, max_value=MAX_LIST_SIZE),
key="n",
).map(lambda n: type_str + "[{0}]".format(n)),
st.shared(
st.integers(min_value=MIN_LIST_SIZE, max_value=MAX_LIST_SIZE),
key="n",
).flatmap(lambda n: st.lists(type_strat, min_size=n, max_size=n).map(tuple))
) for type_str, type_strat in all_basic_raw_strats
]
def zip_types_and_values(types_and_values):
types, values = zip(*types_and_values)
return tuple(types), tuple(values)
single_abi_strats = st.one_of(itertools.chain(
# 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 http://mozilla.org/MPL/2.0/.
#
# END HEADER
from __future__ import division, print_function, absolute_import
import hypothesis.strategies as st
from hypothesis import find, given
x = st.shared(st.integers())
@given(x, x)
def test_sharing_is_by_instance_by_default(a, b):
assert a == b
@given(
st.shared(st.integers(), key='hi'), st.shared(st.integers(), key='hi'))
def test_different_instances_with_the_same_key_are_shared(a, b):
assert a == b
def test_different_instances_are_not_shared():
find(
def from_typing_type(thing):
# We start with special-case support for Union and Tuple - the latter
# isn't actually a generic type. Then we handle Literal since it doesn't
# support `isinstance`. Support for Callable may be added to this section
# later.
# We then explicitly error on non-Generic types, which don't carry enough
# information to sensibly resolve to strategies at runtime.
# Finally, we run a variation of the subclass lookup in st.from_type
# among generic types in the lookup.
import typing
# Under 3.6 Union is handled directly in st.from_type, as the argument is
# not an instance of `type`. However, under Python 3.5 Union *is* a type
# and we have to handle it here, including failing if it has no parameters.
if hasattr(thing, "__union_params__"): # pragma: no cover
args = sorted(thing.__union_params__ or (), key=type_sorting_key)
if not args:
raise ResolutionFailed("Cannot resolve Union of no types.")
return st.one_of([st.from_type(t) for t in args])
if getattr(thing, "__origin__", None) == tuple or isinstance(
thing, getattr(typing, "TupleMeta", ())
):
elem_types = getattr(thing, "__tuple_params__", None) or ()
elem_types += getattr(thing, "__args__", None) or ()
if (
getattr(thing, "__tuple_use_ellipsis__", False)
or len(elem_types) == 2
and elem_types[-1] is Ellipsis
):
return st.lists(st.from_type(elem_types[0])).map(tuple)
elif len(elem_types) == 1 and elem_types[0] == ():
return st.tuples() # Empty tuple; see issue #1583
return st.tuples(*map(st.from_type, elem_types))
if (
hasattr(typing, "Final") and getattr(thing, "__origin__", None) == typing.Final
): # pragma: no cover # new in Python 3.8
return st.one_of([st.from_type(t) for t in thing.__args__])
if is_typing_literal(thing): # pragma: no cover # new in Python 3.8
args_dfs_stack = list(thing.__args__)
literals = []
while args_dfs_stack:
arg = args_dfs_stack.pop()
if is_typing_literal(arg):
args_dfs_stack.extend(reversed(arg.__args__))
else:
literals.append(arg)
return st.sampled_from(literals)
if isinstance(thing, typing.TypeVar):
if getattr(thing, "__bound__", None) is not None:
strat = unwrap_strategies(st.from_type(thing.__bound__))
if not isinstance(strat, OneOfStrategy):
return strat
# The bound was a union, or we resolved it as a union of subtypes,
# so we need to unpack the strategy to ensure consistency across uses.
# This incantation runs a sampled_from over the strategies inferred for
# each part of the union, wraps that in shared so that we only generate
# from one type per testcase, and flatmaps that back to instances.
return st.shared(
st.sampled_from(strat.original_strategies), key="typevar=%r" % (thing,)
).flatmap(lambda s: s)
if getattr(thing, "__constraints__", None):
return st.shared(
st.sampled_from(thing.__constraints__), key="typevar=%r" % (thing,)
).flatmap(st.from_type)
# Constraints may be None or () on various Python versions.
return st.text() # An arbitrary type for the typevar
# Now, confirm that we're dealing with a generic type as we expected
if not isinstance(thing, typing_root_type): # pragma: no cover
raise ResolutionFailed("Cannot resolve %s to a strategy" % (thing,))
# Parametrised generic types have their __origin__ attribute set to the
# un-parametrised version, which we need to use in the subclass checks.
# e.g.: typing.List[int].__origin__ == typing.List
mapping = {
k: v
for k, v in _global_type_lookup.items()
if isinstance(k, typing_root_type) and try_issubclass(k, thing)
}
if typing.Dict in mapping:
# The subtype relationships between generic and concrete View types
# are sometimes inconsistent under Python 3.5, so we pop them out to
# preserve our invariant that all examples of from_type(T) are
# instances of type T - and simplify the strategy for abstract types
# such as Container
for t in (typing.KeysView, typing.ValuesView, typing.ItemsView):
mapping.pop(t, None)
strategies = [
v if isinstance(v, st.SearchStrategy) else v(thing)
for k, v in mapping.items()
if sum(try_issubclass(k, T) for T in mapping) == 1
]
empty = ", ".join(repr(s) for s in strategies if s.is_empty)
if empty or not strategies: # pragma: no cover
raise ResolutionFailed(
"Could not resolve %s to a strategy; consider using "
"register_type_strategy" % (empty or thing,)
)
return st.one_of(strategies)
def from_typing_type(thing):
# We start with special-case support for Union and Tuple - the latter
# isn't actually a generic type. Support for Callable may be added to
# this section later.
# We then explicitly error on non-Generic types, which don't carry enough
# information to sensibly resolve to strategies at runtime.
# Finally, we run a variation of the subclass lookup in st.from_type
# among generic types in the lookup.
import typing
# Under 3.6 Union is handled directly in st.from_type, as the argument is
# not an instance of `type`. However, under Python 3.5 Union *is* a type
# and we have to handle it here, including failing if it has no parameters.
if hasattr(thing, '__union_params__'): # pragma: no cover
args = sorted(thing.__union_params__ or (), key=type_sorting_key)
if not args:
raise ResolutionFailed('Cannot resolve Union of no types.')
return st.one_of([st.from_type(t) for t in args])
if getattr(thing, '__origin__', None) == tuple or \
isinstance(thing, getattr(typing, 'TupleMeta', ())):
elem_types = getattr(thing, '__tuple_params__', None) or ()
elem_types += getattr(thing, '__args__', None) or ()
if getattr(thing, '__tuple_use_ellipsis__', False) or \
len(elem_types) == 2 and elem_types[-1] is Ellipsis:
return st.lists(st.from_type(elem_types[0])).map(tuple)
elif len(elem_types) == 1 and elem_types[0] == ():
return st.tuples() # Empty tuple; see issue #1583
return st.tuples(*map(st.from_type, elem_types))
if isinstance(thing, typing.TypeVar):
if getattr(thing, '__bound__', None) is not None:
return st.from_type(thing.__bound__)
if getattr(thing, '__constraints__', None):
return st.shared(
st.sampled_from(thing.__constraints__),
key='typevar-with-constraint'
).flatmap(st.from_type)
# Constraints may be None or () on various Python versions.
return st.text() # An arbitrary type for the typevar
# Now, confirm that we're dealing with a generic type as we expected
if not isinstance(thing, typing_root_type): # pragma: no cover
raise ResolutionFailed('Cannot resolve %s to a strategy' % (thing,))
# Parametrised generic types have their __origin__ attribute set to the
# un-parametrised version, which we need to use in the subclass checks.
# e.g.: typing.List[int].__origin__ == typing.List
mapping = {k: v for k, v in _global_type_lookup.items()
if isinstance(k, typing_root_type) and try_issubclass(k, thing)}
if typing.Dict in mapping:
# The subtype relationships between generic and concrete View types
# are sometimes inconsistent under Python 3.5, so we pop them out to
# preserve our invariant that all examples of from_type(T) are
# instances of type T - and simplify the strategy for abstract types
# such as Container
for t in (typing.KeysView, typing.ValuesView, typing.ItemsView):
mapping.pop(t, None)
strategies = [v if isinstance(v, st.SearchStrategy) else v(thing)
for k, v in mapping.items()
if sum(try_issubclass(k, T) for T in mapping) == 1]
empty = ', '.join(repr(s) for s in strategies if s.is_empty)
if empty or not strategies: # pragma: no cover
raise ResolutionFailed(
'Could not resolve %s to a strategy; consider using '
'register_type_strategy' % (empty or thing,))
return st.one_of(strategies)
def collect_symbols(cls_name, cls_dict):
domain_range = cls_dict["domain_range"]
domain_strategy = cls_dict["domain_strategy"] = hyp_st.shared(
ndarray_shape_st(domain_range), key=cls_name)
generation_strategy_factories = cls_dict[
"generation_strategy_factories"] = dict()
implementation_strategy_factories = cls_dict[
"implementation_strategy_factories"] = dict()
global_boundaries = cls_dict["global_boundaries"] = dict()
constants = cls_dict["constants"] = dict()
singletons = cls_dict["singletons"] = dict()
cls_dict["field_params"] = field_params = {}
max_boundary = ((0, 0), (0, 0), (0, 0))
for symbol in cls_dict["symbols"].values():
if symbol.kind == SymbolKind.FIELD:
max_boundary = tuple(
(max(m[0], b[0]), max(m[1], b[1]))
for m, b in zip(max_boundary, symbol.boundary))
cls_dict["max_boundary"] = max_boundary
for name, symbol in cls_dict["symbols"].items():
if symbol.kind == SymbolKind.GLOBAL_STRATEGY:
generation_strategy_factories[name] = symbol.value_st_factory
elif symbol.kind == SymbolKind.GLOBAL_SET:
constants[name] = symbol.values
elif symbol.kind == SymbolKind.SINGLETON:
singletons[name] = symbol.values[0]
elif symbol.kind == SymbolKind.FIELD:
if symbol.axes:
axes = symbol.axes
extra_shape = tuple(b[0] +
b[1] if ax in symbol.axes else None
for b, ax in zip(max_boundary, "IJK"))
else:
axes = "IJK"
extra_shape = tuple(b[0] + b[1] for b in max_boundary)
if symbol.data_dims:
data_dims = symbol.data_dims
extra_shape = (*extra_shape, *symbol.data_dims)
else:
data_dims = tuple()
field_params[name] = (axes, data_dims)
global_boundaries[name] = symbol.boundary
shape_strategy = derived_shape_st(domain_strategy, extra_shape)
# Use default arguments to pass values avoiding late binding problems
def implementation_strategy_factory(
dt,
shape=shape_strategy,
value_st_factory=symbol.value_st_factory):
return ndarray_st(dt, shape, value_st_factory)
implementation_strategy_factories[
name] = implementation_strategy_factory
elif symbol.kind == SymbolKind.PARAMETER:
implementation_strategy_factories[
name] = symbol.value_st_factory
elif symbol.kind == SymbolKind.NONE:
implementation_strategy_factories[
name] = symbol.value_st_factory
else:
raise AssertionError
cls_dict["origin"] = tuple(o[0] for o in max_boundary)
# 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 http://mozilla.org/MPL/2.0/.
#
# END HEADER
from __future__ import division, print_function, absolute_import
import hypothesis.strategies as st
from hypothesis import given
from tests.common.debug import minimal, find_any
x = st.shared(st.integers())
@given(x, x)
def test_sharing_is_by_instance_by_default(a, b):
assert a == b
@given(
st.shared(st.integers(), key='hi'), st.shared(st.integers(), key='hi'))
def test_different_instances_with_the_same_key_are_shared(a, b):
assert a == b
def test_different_instances_are_not_shared():
find_any(
# 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 http://mozilla.org/MPL/2.0/.
#
# END HEADER
from __future__ import division, print_function, absolute_import
import hypothesis.strategies as st
from hypothesis import find, given
x = st.shared(st.integers())
@given(x, x)
def test_sharing_is_by_instance_by_default(a, b):
assert a == b
@given(st.shared(st.integers(), key='hi'), st.shared(st.integers(), key='hi'))
def test_different_instances_with_the_same_key_are_shared(a, b):
assert a == b
def test_different_instances_are_not_shared():
find(st.tuples(st.shared(st.integers()), st.shared(st.integers())),
lambda x: x[0] != x[1])
def test_different_keys_are_not_shared():
find(
st.tuples(st.shared(st.integers(), key=1),
st.shared(st.integers(), key=2)), lambda x: x[0] != x[1])
def test_keys_and_default_are_not_shared():
find(st.tuples(st.shared(st.integers(), key=1), st.shared(st.integers())),
lambda x: x[0] != x[1])
def test_can_simplify_shared_lists():
xs = minimal(
st.lists(st.shared(st.integers())),
lambda x: len(x) >= 10 and x[0] != 0
)
assert xs == [1] * 10
def test_can_simplify_shared_lists():
xs = find(st.lists(st.shared(st.integers())),
lambda x: len(x) >= 10 and x[0] != 0)
assert xs == [1] * 10
def distinct_integers(draw):
used = draw(st.shared(st.builds(set), key='distinct_integers.used'))
i = draw(st.integers(0, 2 ** 64 - 1).filter(lambda x: x not in used))
used.add(i)
return i
import kernel_fca_oo as krn
@pytest.fixture(scope='function')
def kernel_classes():
return [krn.KernelSystemNP, krn.KernelSystemDF, krn.FCASystemDF]
arr_shape_strat = st.tuples(st.integers(min_value=2, max_value=10),
st.integers(min_value=2, max_value=10))
bin_int_strat = st.integers(min_value=0, max_value=1)
arr_strat = arr_shape_strat.flatmap(lambda t: st_np.arrays(np.int8, (t[0], t[1]),
elements=bin_int_strat))
intent_strat = st.shared(arr_strat, key=1).flatmap(lambda a: st.sets(st.integers(0, a.shape[1]-1)))
@given(st.shared(arr_strat, key=1), intent_strat)
def test_ei(kernel_classes, arr, gen_intent):
#print(arr)
#print(arr2)
#print('_______')
df = pd.DataFrame(arr)
for K in kernel_classes:
if K == krn.KernelSystemNP:
ks = K(arr)
else:
ks = K(df)
extent = ks.extent(gen_intent)
intent = set(ks.intent(extent))
