def _value(value_required):
if not value_required and draw(booleans()):
- return
+ return None
generation_choice = 0
if value_required:
generation_choice = draw(sampled_from((1, 2, 3)))
sampled_from(("0", "1")),
max_size=len(schema),
)))
- elif generation_choice == 2 or draw(booleans()):
+ if generation_choice == 2 or draw(booleans()):
return draw(binary(max_size=len(schema) // 8))
- elif generation_choice == 3 or draw(booleans()):
+ if generation_choice == 3 or draw(booleans()):
return tuple(draw(lists(sampled_from([name for name, _ in schema]))))
return None
value = _value(value_required)
ObjectIdentifier((2, 999, 3)),
)
- @given(data_strategy())
- def test_nonnormalized_first_arc(self, d):
+ def test_nonnormalized_first_arc(self):
tampered = (
ObjectIdentifier.tag_default +
len_encode(2) +
max_size=5,
))
dered = ObjectIdentifier((1, 0) + tuple(arcs)).encode()
- _, tlen, lv = tag_strip(dered)
- _, llen, v = len_decode(lv)
+ _, _, lv = tag_strip(dered)
+ _, _, v = len_decode(lv)
v_no_first_arc = v[1:]
idx_for_tamper = d.draw(integers(
min_value=0,
value = None
if draw(booleans()):
value = seq_klass()
- value._value = {
- k: v for k, v in draw(dictionaries(
- integers(),
- one_of(
- booleans().map(Boolean),
- integers().map(Integer),
- ),
- )).items()
- }
+ value._value = draw(dictionaries(
+ integers(),
+ one_of(
+ booleans().map(Boolean),
+ integers().map(Integer),
+ ),
+ ))
schema = None
if draw(booleans()):
schema = list(draw(dictionaries(
default = None
if draw(booleans()):
default = seq_klass()
- default._value = {
- k: v for k, v in draw(dictionaries(
- integers(),
- one_of(
- booleans().map(Boolean),
- integers().map(Integer),
- ),
- )).items()
- }
+ default._value = draw(dictionaries(
+ integers(),
+ one_of(
+ booleans().map(Boolean),
+ integers().map(Integer),
+ ),
+ ))
optional = draw(one_of(none(), booleans()))
_decoded = (
draw(integers(min_value=0)),
with self.assertRaises(TagMismatch):
seq_missing.decode(seq_encoded)
- @given(data_strategy())
- def test_bered(self, d):
+ def test_bered(self):
class Seq(self.base_klass):
schema = (("underlying", Boolean()),)
encoded = Boolean.tag_default + len_encode(1) + b"\x01"
self.assertTrue(seq_decoded.bered)
self.assertSequenceEqual(
[bytes(seq_decoded[str(i)]) for i, t in enumerate(tags)],
- [t for t in tags],
+ tags,
)
with self.assertRaises(DecodeError):
obj.decode(obj_encoded_lenindef[:-2], ctx={"bered": True})
- @given(data_strategy())
- def test_bered(self, d):
+ def test_bered(self):
class SeqOf(self.base_klass):
schema = Boolean()
encoded = Boolean(False).encode()