@composite
-def boolean_values_strat(draw, do_expl=False):
+def boolean_values_strategy(draw, do_expl=False):
value = draw(one_of(none(), booleans()))
impl = None
expl = None
default_initial,
optional_initial,
_decoded_initial,
- ) = d.draw(boolean_values_strat())
+ ) = d.draw(boolean_values_strategy())
obj_initial = klass(
value_initial,
impl_initial,
default,
optional,
_decoded,
- ) = d.draw(boolean_values_strat(do_expl=impl_initial is None))
+ ) = d.draw(boolean_values_strategy(do_expl=impl_initial is None))
obj = obj_initial(value, impl, expl, default, optional)
if obj.ready:
value_expected = default if value is None else value
optional = True
self.assertEqual(obj.optional, optional)
- @given(boolean_values_strat())
+ @given(boolean_values_strategy())
def test_copy(self, values):
for klass in (Boolean, BooleanInherited):
obj = klass(*values)
@settings(max_examples=LONG_TEST_MAX_EXAMPLES)
@given(
- boolean_values_strat(),
+ boolean_values_strategy(),
booleans(),
integers(min_value=1).map(tag_ctxc),
integers(min_value=0),
@composite
-def integer_values_strat(draw, do_expl=False):
+def integer_values_strategy(draw, do_expl=False):
bound_min, value, default, bound_max = sorted(draw(sets(
integers(),
min_size=4,
optional_initial,
_specs_initial,
_decoded_initial,
- ) = d.draw(integer_values_strat())
+ ) = d.draw(integer_values_strategy())
obj_initial = klass(
value_initial,
bounds_initial,
optional,
_,
_decoded,
- ) = d.draw(integer_values_strat(do_expl=impl_initial is None))
+ ) = d.draw(integer_values_strategy(do_expl=impl_initial is None))
if (default is None) and (obj_initial.default is not None):
bounds = None
if (
{} if _specs_initial is None else dict(_specs_initial),
)
- @given(integer_values_strat())
+ @given(integer_values_strategy())
def test_copy(self, values):
for klass in (Integer, IntegerInherited):
obj = klass(*values)
@settings(max_examples=LONG_TEST_MAX_EXAMPLES)
@given(
- integer_values_strat(),
+ integer_values_strategy(),
integers(),
integers(min_value=1).map(tag_ctxc),
integers(min_value=0),
@composite
-def bit_string_values_strat(draw, schema=None, value_required=False, do_expl=False):
+def bit_string_values_strategy(draw, schema=None, value_required=False, do_expl=False):
if schema is None:
schema = ()
if draw(booleans()):
default_initial,
optional_initial,
_decoded_initial,
- ) = d.draw(bit_string_values_strat())
+ ) = d.draw(bit_string_values_strategy())
class BS(klass):
schema = schema_initial
default,
optional,
_decoded,
- ) = d.draw(bit_string_values_strat(
+ ) = d.draw(bit_string_values_strategy(
schema=schema_initial,
do_expl=impl_initial is None,
))
self.assertEqual(obj.optional, optional)
self.assertEqual(obj.specs, obj_initial.specs)
- @given(bit_string_values_strat())
+ @given(bit_string_values_strategy())
def test_copy(self, values):
for klass in (BitString, BitStringInherited):
_schema, value, impl, expl, default, optional, _decoded = values
default,
optional,
_decoded,
- ) = d.draw(bit_string_values_strat(value_required=True))
+ ) = d.draw(bit_string_values_strategy(value_required=True))
tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
offset = d.draw(integers(min_value=0))
for klass in (BitString, BitStringInherited):
@composite
-def octet_string_values_strat(draw, do_expl=False):
+def octet_string_values_strategy(draw, do_expl=False):
bound_min, bound_max = sorted(draw(sets(
integers(min_value=0, max_value=1 << 7),
min_size=2,
default_initial,
optional_initial,
_decoded_initial,
- ) = d.draw(octet_string_values_strat())
+ ) = d.draw(octet_string_values_strategy())
obj_initial = klass(
value_initial,
bounds_initial,
default,
optional,
_decoded,
- ) = d.draw(octet_string_values_strat(do_expl=impl_initial is None))
+ ) = d.draw(octet_string_values_strategy(do_expl=impl_initial is None))
if (default is None) and (obj_initial.default is not None):
bounds = None
if (
bounds or bounds_initial or (0, float("+inf")),
)
- @given(octet_string_values_strat())
+ @given(octet_string_values_strategy())
def test_copy(self, values):
for klass in (OctetString, OctetStringInherited):
obj = klass(*values)
@settings(max_examples=LONG_TEST_MAX_EXAMPLES)
@given(
- octet_string_values_strat(),
+ octet_string_values_strategy(),
binary(),
integers(min_value=1).map(tag_ctxc),
integers(min_value=0),
@composite
-def null_values_strat(draw, do_expl=False):
+def null_values_strategy(draw, do_expl=False):
impl = None
expl = None
if do_expl:
expl_initial,
optional_initial,
_decoded_initial,
- ) = d.draw(null_values_strat())
+ ) = d.draw(null_values_strategy())
obj_initial = klass(
impl=impl_initial,
expl=expl_initial,
expl,
optional,
_decoded,
- ) = d.draw(null_values_strat(do_expl=impl_initial is None))
+ ) = d.draw(null_values_strategy(do_expl=impl_initial is None))
obj = obj_initial(impl=impl, expl=expl, optional=optional)
self.assertEqual(obj.tag, impl or impl_initial or obj.tag_default)
self.assertEqual(obj.expl_tag, expl or expl_initial)
optional = False if optional is None else optional
self.assertEqual(obj.optional, optional)
- @given(null_values_strat())
+ @given(null_values_strategy())
def test_copy(self, values):
for klass in (Null, NullInherited):
impl, expl, optional, _decoded = values
Null(impl=impl).decode(Null().encode())
@given(
- null_values_strat(),
+ null_values_strategy(),
integers(min_value=1).map(tag_ctxc),
integers(min_value=0),
)
@composite
-def oid_values_strat(draw, do_expl=False):
+def oid_values_strategy(draw, do_expl=False):
value = draw(one_of(none(), oid_strategy()))
impl = None
expl = None
default_initial,
optional_initial,
_decoded_initial,
- ) = d.draw(oid_values_strat())
+ ) = d.draw(oid_values_strategy())
obj_initial = klass(
value_initial,
impl_initial,
default,
optional,
_decoded,
- ) = d.draw(oid_values_strat(do_expl=impl_initial is None))
+ ) = d.draw(oid_values_strategy(do_expl=impl_initial is None))
obj = obj_initial(value, impl, expl, default, optional)
if obj.ready:
value_expected = default if value is None else value
optional = True
self.assertEqual(obj.optional, optional)
- @given(oid_values_strat())
+ @given(oid_values_strategy())
def test_copy(self, values):
for klass in (ObjectIdentifier, ObjectIdentifierInherited):
obj = klass(*values)
@settings(max_examples=LONG_TEST_MAX_EXAMPLES)
@given(
- oid_values_strat(),
+ oid_values_strategy(),
oid_strategy(),
integers(min_value=1).map(tag_ctxc),
integers(min_value=0),
@composite
-def enumerated_values_strat(draw, schema=None, do_expl=False):
+def enumerated_values_strategy(draw, schema=None, do_expl=False):
if schema is None:
schema = list(draw(sets(text_printable, min_size=1, max_size=3)))
values = list(draw(sets(
default_initial,
optional_initial,
_decoded_initial,
- ) = d.draw(enumerated_values_strat())
+ ) = d.draw(enumerated_values_strategy())
class E(Enumerated):
schema = schema_initial
default,
optional,
_decoded,
- ) = d.draw(enumerated_values_strat(
+ ) = d.draw(enumerated_values_strategy(
schema=schema_initial,
do_expl=impl_initial is None,
))
self.assertEqual(obj.optional, optional)
self.assertEqual(obj.specs, dict(schema_initial))
- @given(enumerated_values_strat())
+ @given(enumerated_values_strategy())
def test_copy(self, values):
schema_input, value, impl, expl, default, optional, _decoded = values
@given(data_strategy())
def test_symmetric(self, d):
schema_input, _, _, _, default, optional, _decoded = d.draw(
- enumerated_values_strat(),
+ enumerated_values_strategy(),
)
tag_expl = d.draw(integers(min_value=1).map(tag_ctxc))
offset = d.draw(integers(min_value=0))
@composite
-def string_values_strat(draw, alphabet, do_expl=False):
+def string_values_strategy(draw, alphabet, do_expl=False):
bound_min, bound_max = sorted(draw(sets(
integers(min_value=0, max_value=1 << 7),
min_size=2,
default_initial,
optional_initial,
_decoded_initial,
- ) = d.draw(string_values_strat(self.text_alphabet()))
+ ) = d.draw(string_values_strategy(self.text_alphabet()))
obj_initial = self.base_klass(
value_initial,
bounds_initial,
default,
optional,
_decoded,
- ) = d.draw(string_values_strat(
+ ) = d.draw(string_values_strategy(
self.text_alphabet(),
do_expl=impl_initial is None,
))
@given(data_strategy())
def test_copy(self, d):
- values = d.draw(string_values_strat(self.text_alphabet()))
+ values = d.draw(string_values_strategy(self.text_alphabet()))
obj = self.base_klass(*values)
obj_copied = obj.copy()
self.assert_copied_basic_fields(obj, obj_copied)
@given(data_strategy())
def test_symmetric(self, d):
- values = d.draw(string_values_strat(self.text_alphabet()))
+ values = d.draw(string_values_strategy(self.text_alphabet()))
value = d.draw(text(alphabet=self.text_alphabet()))
tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
offset = d.draw(integers(min_value=0))
@composite
-def generalized_time_values_strat(
+def generalized_time_values_strategy(
draw,
min_datetime,
max_datetime,
default_initial,
optional_initial,
_decoded_initial,
- ) = d.draw(generalized_time_values_strat(
+ ) = d.draw(generalized_time_values_strategy(
min_datetime=self.min_datetime,
max_datetime=self.max_datetime,
omit_ms=self.omit_ms,
default,
optional,
_decoded,
- ) = d.draw(generalized_time_values_strat(
+ ) = d.draw(generalized_time_values_strategy(
min_datetime=self.min_datetime,
max_datetime=self.max_datetime,
omit_ms=self.omit_ms,
@given(data_strategy())
def test_copy(self, d):
- values = d.draw(generalized_time_values_strat(
+ values = d.draw(generalized_time_values_strategy(
min_datetime=self.min_datetime,
max_datetime=self.max_datetime,
))
@settings(max_examples=LONG_TEST_MAX_EXAMPLES)
@given(data_strategy())
def test_symmetric(self, d):
- values = d.draw(generalized_time_values_strat(
+ values = d.draw(generalized_time_values_strategy(
min_datetime=self.min_datetime,
max_datetime=self.max_datetime,
))
@composite
-def any_values_strat(draw, do_expl=False):
+def any_values_strategy(draw, do_expl=False):
value = draw(one_of(none(), binary()))
expl = None
if do_expl:
expl_initial,
optional_initial,
_decoded_initial,
- ) = d.draw(any_values_strat())
+ ) = d.draw(any_values_strategy())
obj_initial = klass(
value_initial,
expl_initial,
expl,
optional,
_decoded,
- ) = d.draw(any_values_strat(do_expl=True))
+ ) = d.draw(any_values_strategy(do_expl=True))
obj = obj_initial(value, expl, optional)
if obj.ready:
value_expected = None if value is None else value
# override it, as Any does not have implicit tag
pass
- @given(any_values_strat())
+ @given(any_values_strategy())
def test_copy(self, values):
for klass in (Any, AnyInherited):
obj = klass(*values)
@settings(max_examples=LONG_TEST_MAX_EXAMPLES)
@given(
- any_values_strat(),
+ any_values_strategy(),
integers().map(lambda x: Integer(x).encode()),
integers(min_value=1).map(tag_ctxc),
integers(min_value=0),
@composite
-def choice_values_strat(draw, value_required=False, schema=None, do_expl=False):
+def choice_values_strategy(draw, value_required=False, schema=None, do_expl=False):
if schema is None:
names = list(draw(sets(text_letters(), min_size=1, max_size=5)))
tags = [tag_encode(tag) for tag in draw(sets(
default_initial,
optional_initial,
_decoded_initial,
- ) = d.draw(choice_values_strat())
+ ) = d.draw(choice_values_strategy())
class Wahl(klass):
schema = schema_initial
default,
optional,
_decoded,
- ) = d.draw(choice_values_strat(schema=schema_initial, do_expl=True))
+ ) = d.draw(choice_values_strategy(schema=schema_initial, do_expl=True))
obj = obj_initial(value, expl, default, optional)
if obj.ready:
value_expected = default if value is None else value
# override it, as Any does not have implicit tag
pass
- @given(choice_values_strat())
+ @given(choice_values_strategy())
def test_copy(self, values):
_schema, value, expl, default, optional, _decoded = values
@given(data_strategy())
def test_symmetric(self, d):
_schema, value, _, default, optional, _decoded = d.draw(
- choice_values_strat(value_required=True)
+ choice_values_strategy(value_required=True)
)
tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
offset = d.draw(integers(min_value=0))
@composite
-def seq_values_strat(draw, seq_klass, do_expl=False):
+def seq_values_strategy(draw, seq_klass, do_expl=False):
value = None
if draw(booleans()):
value = seq_klass()
@composite
-def sequence_strat(draw, seq_klass):
+def sequence_strategy(draw, seq_klass):
inputs = draw(lists(
one_of(
tuples(just(Boolean), booleans(), one_of(none(), booleans())),
@composite
-def sequences_strat(draw, seq_klass):
+def sequences_strategy(draw, seq_klass):
tags = draw(sets(integers(min_value=1), min_size=0, max_size=5))
inits = [
({"expl": tag_ctxc(tag)} if expled else {"impl": tag_encode(tag)})
max_size=len(tags),
)))
seq_expectses = draw(lists(
- sequence_strat(seq_klass=seq_klass),
+ sequence_strategy(seq_klass=seq_klass),
min_size=len(tags),
max_size=len(tags),
))
default_initial,
optional_initial,
_decoded_initial,
- ) = d.draw(seq_values_strat(seq_klass=klass))
+ ) = d.draw(seq_values_strategy(seq_klass=klass))
obj_initial = klass(
value_initial,
schema_initial,
default,
optional,
_decoded,
- ) = d.draw(seq_values_strat(
+ ) = d.draw(seq_values_strategy(
seq_klass=klass,
do_expl=impl_initial is None,
))
class SeqInherited(self.base_klass):
pass
for klass in (self.base_klass, SeqInherited):
- values = d.draw(seq_values_strat(seq_klass=klass))
+ values = d.draw(seq_values_strategy(seq_klass=klass))
obj = klass(*values)
obj_copied = obj.copy()
self.assert_copied_basic_fields(obj, obj_copied)
@settings(max_examples=LONG_TEST_MAX_EXAMPLES)
@given(data_strategy())
def test_symmetric(self, d):
- seq, expects = d.draw(sequence_strat(seq_klass=self.base_klass))
+ seq, expects = d.draw(sequence_strategy(seq_klass=self.base_klass))
self.assertTrue(seq.ready)
self.assertFalse(seq.decoded)
self._assert_expects(seq, expects)
@settings(max_examples=LONG_TEST_MAX_EXAMPLES)
@given(data_strategy())
def test_symmetric_with_seq(self, d):
- seq, expect_outers = d.draw(sequences_strat(seq_klass=self.base_klass))
+ seq, expect_outers = d.draw(sequences_strategy(seq_klass=self.base_klass))
self.assertTrue(seq.ready)
seq_encoded = seq.encode()
seq_decoded, tail = seq.decode(seq_encoded)
@composite
-def seqof_values_strat(draw, schema=None, do_expl=False):
+def seqof_values_strategy(draw, schema=None, do_expl=False):
if schema is None:
schema = draw(sampled_from((Boolean(), Integer())))
bound_min, bound_max = sorted(draw(sets(
default_initial,
optional_initial,
_decoded_initial,
- ) = d.draw(seqof_values_strat())
+ ) = d.draw(seqof_values_strategy())
class SeqOf(self.base_klass):
schema = schema_initial
default,
optional,
_decoded,
- ) = d.draw(seqof_values_strat(
+ ) = d.draw(seqof_values_strategy(
schema=schema_initial,
do_expl=impl_initial is None,
))
bounds or bounds_initial or (0, float("+inf")),
)
- @given(seqof_values_strat())
+ @given(seqof_values_strategy())
def test_copy(self, values):
_schema, value, bounds, impl, expl, default, optional, _decoded = values
@settings(max_examples=LONG_TEST_MAX_EXAMPLES)
@given(
- seqof_values_strat(schema=Integer()),
+ seqof_values_strategy(schema=Integer()),
lists(integers().map(Integer)),
integers(min_value=1).map(tag_ctxc),
integers(min_value=0),