ctx={"bered": True},
)
self.assertTrue(bool(obj))
- self.assertTrue(obj.bered)
+ self.assertTrue(obj.ber_encoded)
self.assertFalse(obj.lenindef)
+ self.assertTrue(obj.bered)
@given(
integers(min_value=1).map(tag_ctxc),
ctx={"bered": True},
)
self.assertTrue(obj.expl_lenindef)
+ self.assertFalse(obj.lenindef)
+ self.assertFalse(obj.ber_encoded)
+ self.assertTrue(obj.bered)
self.assertSequenceEqual(tail, junk)
@given(
v.expl_tlvlen,
v.expl_tlen,
v.expl_llen,
- v.bered,
+ v.ber_encoded,
v.lenindef,
v.expl_lenindef,
+ v.bered,
) for v in seqof
),
set(((
False,
False,
True,
+ True,
),)),
)
self.assertSequenceEqual(tail, junk)
self.assertEqual(obj.bit_len, bit_len_expected)
self.assertSequenceEqual(bytes(obj), payload_expected)
- self.assertTrue(obj.bered)
+ self.assertTrue(obj.ber_encoded)
self.assertEqual(obj.lenindef, lenindef_expected)
+ self.assertTrue(obj.bered)
self.assertEqual(len(encoded), obj.tlvlen)
@given(
)
self.assertSequenceEqual(tail, b"")
self.assertEqual(obj, vector)
- self.assertTrue(obj.bered)
+ self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.lenindef)
+ self.assertTrue(obj.bered)
@composite
)
self.assertSequenceEqual(tail, junk)
self.assertSequenceEqual(bytes(obj), payload_expected)
- self.assertTrue(obj.bered)
+ self.assertTrue(obj.ber_encoded)
self.assertEqual(obj.lenindef, lenindef_expected)
+ self.assertTrue(obj.bered)
self.assertEqual(len(encoded), obj.tlvlen)
@given(
obj, tail = VisibleString().decode(hexdec("1A054A6F6E6573"))
self.assertSequenceEqual(tail, b"")
self.assertEqual(str(obj), "Jones")
- self.assertFalse(obj.bered)
+ self.assertFalse(obj.ber_encoded)
self.assertFalse(obj.lenindef)
+ self.assertFalse(obj.bered)
obj, tail = VisibleString().decode(
hexdec("3A0904034A6F6E04026573"),
)
self.assertSequenceEqual(tail, b"")
self.assertEqual(str(obj), "Jones")
- self.assertTrue(obj.bered)
+ self.assertTrue(obj.ber_encoded)
self.assertFalse(obj.lenindef)
+ self.assertTrue(obj.bered)
obj, tail = VisibleString().decode(
hexdec("3A8004034A6F6E040265730000"),
)
self.assertSequenceEqual(tail, b"")
self.assertEqual(str(obj), "Jones")
- self.assertTrue(obj.bered)
+ self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.lenindef)
+ self.assertTrue(obj.bered)
class TestGeneralString(
self.assertSequenceEqual(tail, junk)
self.assertEqual(obj.offset, offset)
self.assertEqual(obj.tlvlen, len(encoded))
+ self.assertTrue(obj.lenindef)
+ self.assertFalse(obj.ber_encoded)
+ self.assertTrue(obj.bered)
with self.assertRaises(NotEnoughData) as err:
Any().decode(
encoded[:-1],
seq_encoded = seq.encode()
seq_decoded, tail = seq.decode(seq_encoded + tail_junk)
self.assertFalse(seq_decoded.lenindef)
+ self.assertFalse(seq_decoded.ber_encoded)
self.assertFalse(seq_decoded.bered)
t, _, lv = tag_strip(seq_encoded)
ctx={"bered": True},
)
self.assertTrue(seq_decoded_lenindef.lenindef)
+ self.assertTrue(seq_decoded_lenindef.bered)
with self.assertRaises(DecodeError):
seq.decode(seq_encoded_lenindef[:-1], ctx={"bered": True})
with self.assertRaises(DecodeError):
seq_with_default.decode(seq_encoded)
for ctx in ({"bered": True}, {"allow_default_values": True}):
seq_decoded, _ = seq_with_default.decode(seq_encoded, ctx=ctx)
+ self.assertTrue(seq_decoded.ber_encoded)
self.assertTrue(seq_decoded.bered)
for name, value in _schema:
self.assertEqual(seq_decoded[name], seq_with_default[name])
with self.assertRaises(TagMismatch):
seq_missing.decode(seq_encoded)
+ @given(data_strategy())
+ def test_bered(self, d):
+ class Seq(self.base_klass):
+ schema = (("underlying", Boolean()),)
+ encoded = Boolean.tag_default + len_encode(1) + b"\x01"
+ encoded = Seq.tag_default + len_encode(len(encoded)) + encoded
+ decoded, _ = Seq().decode(encoded, ctx={"bered": True})
+ self.assertFalse(decoded.ber_encoded)
+ self.assertFalse(decoded.lenindef)
+ self.assertTrue(decoded.bered)
+
+ class Seq(self.base_klass):
+ schema = (("underlying", OctetString()),)
+ encoded = (
+ tag_encode(form=TagFormConstructed, num=4) +
+ LENINDEF +
+ OctetString(b"whatever").encode() +
+ EOC
+ )
+ encoded = Seq.tag_default + len_encode(len(encoded)) + encoded
+ decoded, _ = Seq().decode(encoded, ctx={"bered": True})
+ self.assertFalse(decoded.ber_encoded)
+ self.assertFalse(decoded.lenindef)
+ self.assertTrue(decoded.bered)
+
class TestSequence(SeqMixing, CommonMixin, TestCase):
base_klass = Sequence
seq.decode(seq_encoded)
for ctx in ({"bered": True}, {"allow_unordered_set": True}):
seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
+ self.assertTrue(seq_decoded.ber_encoded)
self.assertTrue(seq_decoded.bered)
self.assertSequenceEqual(
[bytes(seq_decoded[str(i)]) for i, t in enumerate(tags)],
ctx={"bered": True},
)
self.assertTrue(obj_decoded_lenindef.lenindef)
+ self.assertTrue(obj_decoded_lenindef.bered)
repr(obj_decoded_lenindef)
pprint(obj_decoded_lenindef)
self.assertEqual(obj_decoded_lenindef.tlvlen, len(obj_encoded_lenindef))
with self.assertRaises(DecodeError):
obj.decode(obj_encoded_lenindef[:-2], ctx={"bered": True})
+ @given(data_strategy())
+ def test_bered(self, d):
+ class SeqOf(self.base_klass):
+ schema = Boolean()
+ encoded = Boolean(False).encode()
+ encoded += Boolean.tag_default + len_encode(1) + b"\x01"
+ encoded = SeqOf.tag_default + len_encode(len(encoded)) + encoded
+ decoded, _ = SeqOf().decode(encoded, ctx={"bered": True})
+ self.assertFalse(decoded.ber_encoded)
+ self.assertFalse(decoded.lenindef)
+ self.assertTrue(decoded.bered)
+
+ class SeqOf(self.base_klass):
+ schema = OctetString()
+ encoded = OctetString(b"whatever").encode()
+ encoded += (
+ tag_encode(form=TagFormConstructed, num=4) +
+ LENINDEF +
+ OctetString(b"whatever").encode() +
+ EOC
+ )
+ encoded = SeqOf.tag_default + len_encode(len(encoded)) + encoded
+ decoded, _ = SeqOf().decode(encoded, ctx={"bered": True})
+ self.assertFalse(decoded.ber_encoded)
+ self.assertFalse(decoded.lenindef)
+ self.assertTrue(decoded.bered)
+
class TestSequenceOf(SeqOfMixing, CommonMixin, TestCase):
class SeqOf(SequenceOf):
for ctx in ({"bered": True}, {"allow_unordered_set": True}):
seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
+ self.assertTrue(seq_decoded.ber_encoded)
self.assertTrue(seq_decoded.bered)
self.assertSequenceEqual(
[obj.encode() for obj in seq_decoded],
with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
seq.decode(raw)
decoded, _ = seq.decode(raw, ctx={"allow_default_values": True})
+ self.assertTrue(decoded.ber_encoded)
self.assertTrue(decoded.bered)
decoded, _ = seq.decode(raw, ctx={"bered": True})
+ self.assertTrue(decoded.ber_encoded)
self.assertTrue(decoded.bered)