From a441b706391d96088555054663cafa5aa244c592 Mon Sep 17 00:00:00 2001 From: Sergey Matveev Date: Fri, 14 Sep 2018 14:52:45 +0300 Subject: [PATCH] More test coverage --- pyderasn.py | 18 +-- tests/test_pyderasn.py | 288 +++++++++++++++++++++++++++++++---------- 2 files changed, 229 insertions(+), 77 deletions(-) diff --git a/pyderasn.py b/pyderasn.py index 9006462..2e63b5a 100755 --- a/pyderasn.py +++ b/pyderasn.py @@ -559,7 +559,7 @@ from six.moves import xrange as six_xrange try: from termcolor import colored -except ImportError: +except ImportError: # pragma: no cover def colored(what, *args): return what @@ -1084,7 +1084,7 @@ class Obj(object): ctx=ctx, tag_only=tag_only, ) - if tag_only: + if tag_only: # pragma: no cover return obj, tail = result eoc_expected, tail = tail[:EOC_LEN], tail[EOC_LEN:] @@ -1119,7 +1119,7 @@ class Obj(object): ctx=ctx, tag_only=tag_only, ) - if tag_only: + if tag_only: # pragma: no cover return obj, tail = result if obj.tlvlen < l and not ctx.get("allow_expl_oob", False): @@ -2317,7 +2317,7 @@ class BitString(Obj): offset=offset, ) if t == self.tag: - if tag_only: + if tag_only: # pragma: no cover return return self._decode_chunk(lv, offset, decode_path, ctx) if t == self.tag_constructed: @@ -2328,7 +2328,7 @@ class BitString(Obj): decode_path=decode_path, offset=offset, ) - if tag_only: + if tag_only: # pragma: no cover return lenindef = False try: @@ -2910,7 +2910,7 @@ class Null(Obj): decode_path=decode_path, offset=offset, ) - if tag_only: + if tag_only: # pragma: no cover return try: l, _, v = len_decode(lv) @@ -3161,7 +3161,7 @@ class ObjectIdentifier(Obj): decode_path=decode_path, offset=offset, ) - if tag_only: + if tag_only: # pragma: no cover return try: l, llen, v = len_decode(lv) @@ -3984,7 +3984,7 @@ class Choice(Obj): decode_path=decode_path, offset=offset, ) - if tag_only: + if tag_only: # pragma: no cover return value, tail = spec.decode( tlv, @@ -4558,7 +4558,7 @@ class Sequence(Obj): decode_path=decode_path, offset=offset, ) - if tag_only: + if tag_only: # pragma: no cover return lenindef = False ctx_bered = ctx.get("bered", False) diff --git a/tests/test_pyderasn.py b/tests/test_pyderasn.py index dd3506b..0a439f8 100644 --- a/tests/test_pyderasn.py +++ b/tests/test_pyderasn.py @@ -81,6 +81,7 @@ from pyderasn import LEN_YYMMDDHHMMSSZ from pyderasn import LEN_YYYYMMDDHHMMSSDMZ from pyderasn import LEN_YYYYMMDDHHMMSSZ from pyderasn import LENINDEF +from pyderasn import LenIndefForm from pyderasn import NotEnoughData from pyderasn import Null from pyderasn import NumericString @@ -371,14 +372,16 @@ class TestBoolean(CommonMixin, TestCase): obj = Boolean() self.assertFalse(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) with self.assertRaises(ObjNotReady) as err: obj.encode() repr(err.exception) obj = Boolean(value) self.assertTrue(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) @given(booleans(), booleans(), binary(), binary()) def test_comparison(self, value1, value2, tag1, tag2): @@ -548,20 +551,23 @@ class TestBoolean(CommonMixin, TestCase): _decoded=_decoded, ) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) self.assertFalse(obj.expled) obj_encoded = obj.encode() obj_expled = obj(value, expl=tag_expl) self.assertTrue(obj_expled.expled) repr(obj_expled) - pprint(obj_expled) + list(obj_expled.pps()) + pprint(obj_expled, big_blobs=True, with_decode_path=True) obj_expled_encoded = obj_expled.encode() obj_decoded, tail = obj_expled.decode( obj_expled_encoded + tail_junk, offset=offset, ) repr(obj_decoded) - pprint(obj_decoded) + list(obj_decoded.pps()) + pprint(obj_decoded, big_blobs=True, with_decode_path=True) self.assertEqual(tail, tail_junk) self.assertEqual(obj_decoded, obj_expled) self.assertNotEqual(obj_decoded, obj) @@ -618,6 +624,8 @@ class TestBoolean(CommonMixin, TestCase): ) def test_ber_expl_no_eoc(self, expl, junk): encoded = expl + LENINDEF + Boolean(False).encode() + with self.assertRaises(LenIndefForm): + Boolean(expl=expl).decode(encoded + junk) with assertRaisesRegex(self, DecodeError, "no EOC"): Boolean(expl=expl).decode(encoded + junk, ctx={"bered": True}) obj, tail = Boolean(expl=expl).decode( @@ -629,6 +637,9 @@ class TestBoolean(CommonMixin, TestCase): self.assertFalse(obj.ber_encoded) self.assertTrue(obj.bered) self.assertSequenceEqual(tail, junk) + repr(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) @given( integers(min_value=1).map(tag_ctxc), @@ -651,6 +662,8 @@ class TestBoolean(CommonMixin, TestCase): class SeqOf(SequenceOf): schema = Boolean(expl=expl) + with self.assertRaises(LenIndefForm): + SeqOf().decode(encoded) seqof, tail = SeqOf().decode(encoded, ctx={"bered": True}) self.assertSequenceEqual(tail, b"") self.assertSequenceEqual([bool(v) for v in seqof], values) @@ -678,6 +691,9 @@ class TestBoolean(CommonMixin, TestCase): True, ),)), ) + repr(seqof) + list(seqof.pps()) + pprint(seqof, big_blobs=True, with_decode_path=True) @composite @@ -756,14 +772,16 @@ class TestInteger(CommonMixin, TestCase): obj = Integer() self.assertFalse(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) with self.assertRaises(ObjNotReady) as err: obj.encode() repr(err.exception) obj = Integer(value) self.assertTrue(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) hash(obj) @given(integers(), integers(), binary(), binary()) @@ -1013,20 +1031,23 @@ class TestInteger(CommonMixin, TestCase): _decoded=_decoded, ) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) self.assertFalse(obj.expled) obj_encoded = obj.encode() obj_expled = obj(value, expl=tag_expl) self.assertTrue(obj_expled.expled) repr(obj_expled) - pprint(obj_expled) + list(obj_expled.pps()) + pprint(obj_expled, big_blobs=True, with_decode_path=True) obj_expled_encoded = obj_expled.encode() obj_decoded, tail = obj_expled.decode( obj_expled_encoded + tail_junk, offset=offset, ) repr(obj_decoded) - pprint(obj_decoded) + list(obj_decoded.pps()) + pprint(obj_decoded, big_blobs=True, with_decode_path=True) self.assertEqual(tail, tail_junk) self.assertEqual(obj_decoded, obj_expled) self.assertNotEqual(obj_decoded, obj) @@ -1217,14 +1238,16 @@ class TestBitString(CommonMixin, TestCase): obj = BitString() self.assertFalse(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) with self.assertRaises(ObjNotReady) as err: obj.encode() repr(err.exception) obj = BitString(value) self.assertTrue(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) @given( tuples(integers(min_value=0), binary()), @@ -1391,20 +1414,23 @@ class TestBitString(CommonMixin, TestCase): _decoded=_decoded, ) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) self.assertFalse(obj.expled) obj_encoded = obj.encode() obj_expled = obj(value, expl=tag_expl) self.assertTrue(obj_expled.expled) repr(obj_expled) - pprint(obj_expled) + list(obj_expled.pps()) + pprint(obj_expled, big_blobs=True, with_decode_path=True) obj_expled_encoded = obj_expled.encode() obj_decoded, tail = obj_expled.decode( obj_expled_encoded + tail_junk, offset=offset, ) repr(obj_decoded) - pprint(obj_decoded) + list(obj_decoded.pps()) + pprint(obj_decoded, big_blobs=True, with_decode_path=True) self.assertEqual(tail, tail_junk) self.assertEqual(obj_decoded, obj_expled) self.assertNotEqual(obj_decoded, obj) @@ -1736,14 +1762,16 @@ class TestOctetString(CommonMixin, TestCase): obj = OctetString() self.assertFalse(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) with self.assertRaises(ObjNotReady) as err: obj.encode() repr(err.exception) obj = OctetString(value) self.assertTrue(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) @given(binary(), binary(), binary(min_size=1), binary(min_size=1)) def test_comparison(self, value1, value2, tag1, tag2): @@ -1964,20 +1992,23 @@ class TestOctetString(CommonMixin, TestCase): _decoded=_decoded, ) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) self.assertFalse(obj.expled) obj_encoded = obj.encode() obj_expled = obj(value, expl=tag_expl) self.assertTrue(obj_expled.expled) repr(obj_expled) - pprint(obj_expled) + list(obj_expled.pps()) + pprint(obj_expled, big_blobs=True, with_decode_path=True) obj_expled_encoded = obj_expled.encode() obj_decoded, tail = obj_expled.decode( obj_expled_encoded + tail_junk, offset=offset, ) repr(obj_decoded) - pprint(obj_decoded) + list(obj_decoded.pps()) + pprint(obj_decoded, big_blobs=True, with_decode_path=True) self.assertEqual(tail, tail_junk) self.assertEqual(obj_decoded, obj_expled) self.assertNotEqual(obj_decoded, obj) @@ -2144,7 +2175,8 @@ class TestNull(CommonMixin, TestCase): obj = Null() self.assertTrue(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) @given(binary(), binary()) def test_comparison(self, tag1, tag2): @@ -2257,20 +2289,23 @@ class TestNull(CommonMixin, TestCase): _, _, optional, _decoded = values obj = klass(optional=optional, _decoded=_decoded) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) self.assertFalse(obj.expled) obj_encoded = obj.encode() obj_expled = obj(expl=tag_expl) self.assertTrue(obj_expled.expled) repr(obj_expled) - pprint(obj_expled) + list(obj_expled.pps()) + pprint(obj_expled, big_blobs=True, with_decode_path=True) obj_expled_encoded = obj_expled.encode() obj_decoded, tail = obj_expled.decode( obj_expled_encoded + tail_junk, offset=offset, ) repr(obj_decoded) - pprint(obj_decoded) + list(obj_decoded.pps()) + pprint(obj_decoded, big_blobs=True, with_decode_path=True) self.assertEqual(tail, tail_junk) self.assertEqual(obj_decoded, obj_expled) self.assertNotEqual(obj_decoded, obj) @@ -2351,14 +2386,16 @@ class TestObjectIdentifier(CommonMixin, TestCase): obj = ObjectIdentifier() self.assertFalse(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) with self.assertRaises(ObjNotReady) as err: obj.encode() repr(err.exception) obj = ObjectIdentifier(value) self.assertTrue(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) hash(obj) @given(oid_strategy(), oid_strategy(), binary(), binary()) @@ -2564,7 +2601,7 @@ class TestObjectIdentifier(CommonMixin, TestCase): self.assertEqual(obj, ObjectIdentifier(".".join(str(arc) for arc in oid))) str(obj) repr(obj) - pprint(obj) + pprint(obj, big_blobs=True, with_decode_path=True) @settings(max_examples=LONG_TEST_MAX_EXAMPLES) @given( @@ -2584,20 +2621,23 @@ class TestObjectIdentifier(CommonMixin, TestCase): _decoded=_decoded, ) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) self.assertFalse(obj.expled) obj_encoded = obj.encode() obj_expled = obj(value, expl=tag_expl) self.assertTrue(obj_expled.expled) repr(obj_expled) - pprint(obj_expled) + list(obj_expled.pps()) + pprint(obj_expled, big_blobs=True, with_decode_path=True) obj_expled_encoded = obj_expled.encode() obj_decoded, tail = obj_expled.decode( obj_expled_encoded + tail_junk, offset=offset, ) repr(obj_decoded) - pprint(obj_decoded) + list(obj_decoded.pps()) + pprint(obj_decoded, big_blobs=True, with_decode_path=True) self.assertEqual(tail, tail_junk) self.assertEqual(obj_decoded, obj_expled) self.assertNotEqual(obj_decoded, obj) @@ -2737,14 +2777,16 @@ class TestEnumerated(CommonMixin, TestCase): obj = self.base_klass() self.assertFalse(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) with self.assertRaises(ObjNotReady) as err: obj.encode() repr(err.exception) obj = self.base_klass("whatever") self.assertTrue(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) @given(integers(), integers(), binary(), binary()) def test_comparison(self, value1, value2, tag1, tag2): @@ -2870,20 +2912,23 @@ class TestEnumerated(CommonMixin, TestCase): _decoded=_decoded, ) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) self.assertFalse(obj.expled) obj_encoded = obj.encode() obj_expled = obj(value, expl=tag_expl) self.assertTrue(obj_expled.expled) repr(obj_expled) - pprint(obj_expled) + list(obj_expled.pps()) + pprint(obj_expled, big_blobs=True, with_decode_path=True) obj_expled_encoded = obj_expled.encode() obj_decoded, tail = obj_expled.decode( obj_expled_encoded + tail_junk, offset=offset, ) repr(obj_decoded) - pprint(obj_decoded) + list(obj_decoded.pps()) + pprint(obj_decoded, big_blobs=True, with_decode_path=True) self.assertEqual(tail, tail_junk) self.assertEqual(obj_decoded, obj_expled) self.assertNotEqual(obj_decoded, obj) @@ -2959,7 +3004,8 @@ class StringMixin(object): obj = self.base_klass() self.assertFalse(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) text_type(obj) with self.assertRaises(ObjNotReady) as err: obj.encode() @@ -2968,7 +3014,8 @@ class StringMixin(object): obj = self.base_klass(value) self.assertTrue(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) text_type(obj) @given(data_strategy()) @@ -3190,20 +3237,23 @@ class StringMixin(object): _decoded=_decoded, ) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) self.assertFalse(obj.expled) obj_encoded = obj.encode() obj_expled = obj(value, expl=tag_expl) self.assertTrue(obj_expled.expled) repr(obj_expled) - pprint(obj_expled) + list(obj_expled.pps()) + pprint(obj_expled, big_blobs=True, with_decode_path=True) obj_expled_encoded = obj_expled.encode() obj_decoded, tail = obj_expled.decode( obj_expled_encoded + tail_junk, offset=offset, ) repr(obj_decoded) - pprint(obj_decoded) + list(obj_decoded.pps()) + pprint(obj_decoded, big_blobs=True, with_decode_path=True) self.assertEqual(tail, tail_junk) self.assertEqual(obj_decoded, obj_expled) self.assertNotEqual(obj_decoded, obj) @@ -3427,7 +3477,8 @@ class TimeMixin(object): obj = self.base_klass() self.assertFalse(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) with self.assertRaises(ObjNotReady) as err: obj.encode() repr(err.exception) @@ -3435,7 +3486,8 @@ class TimeMixin(object): obj = self.base_klass(value) self.assertTrue(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) @given(data_strategy()) def test_comparison(self, d): @@ -3580,20 +3632,23 @@ class TimeMixin(object): _decoded=_decoded, ) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) self.assertFalse(obj.expled) obj_encoded = obj.encode() obj_expled = obj(value, expl=tag_expl) self.assertTrue(obj_expled.expled) repr(obj_expled) - pprint(obj_expled) + list(obj_expled.pps()) + pprint(obj_expled, big_blobs=True, with_decode_path=True) obj_expled_encoded = obj_expled.encode() obj_decoded, tail = obj_expled.decode( obj_expled_encoded + tail_junk, offset=offset, ) repr(obj_decoded) - pprint(obj_decoded) + list(obj_decoded.pps()) + pprint(obj_decoded, big_blobs=True, with_decode_path=True) self.assertEqual(tail, tail_junk) self.assertEqual(obj_decoded, obj_expled) self.assertEqual(obj_decoded.todatetime(), obj_expled.todatetime()) @@ -3819,14 +3874,16 @@ class TestAny(CommonMixin, TestCase): obj = Any() self.assertFalse(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) with self.assertRaises(ObjNotReady) as err: obj.encode() repr(err.exception) obj = Any(value) self.assertTrue(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) @given(integers()) def test_basic(self, value): @@ -3842,7 +3899,8 @@ class TestAny(CommonMixin, TestCase): len(integer_encoded), ) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) self.assertSequenceEqual(obj.encode(), integer_encoded) @given(binary(), binary()) @@ -3961,20 +4019,23 @@ class TestAny(CommonMixin, TestCase): _, _, optional, _decoded = values obj = klass(value=value, optional=optional, _decoded=_decoded) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) self.assertFalse(obj.expled) obj_encoded = obj.encode() obj_expled = obj(value, expl=tag_expl) self.assertTrue(obj_expled.expled) repr(obj_expled) - pprint(obj_expled) + list(obj_expled.pps()) + pprint(obj_expled, big_blobs=True, with_decode_path=True) obj_expled_encoded = obj_expled.encode() obj_decoded, tail = obj_expled.decode( obj_expled_encoded + tail_junk, offset=offset, ) repr(obj_decoded) - pprint(obj_decoded) + list(obj_decoded.pps()) + pprint(obj_decoded, big_blobs=True, with_decode_path=True) self.assertEqual(tail, tail_junk) self.assertEqual(obj_decoded, obj_expled) self.assertEqual(bytes(obj_decoded), bytes(obj_expled)) @@ -4012,6 +4073,12 @@ class TestAny(CommonMixin, TestCase): b"".join([chunk] * chunks) + EOC ) + with self.assertRaises(LenIndefForm): + Any().decode( + encoded + junk, + offset=offset, + decode_path=decode_path, + ) obj, tail = Any().decode( encoded + junk, offset=offset, @@ -4024,6 +4091,9 @@ class TestAny(CommonMixin, TestCase): self.assertTrue(obj.lenindef) self.assertFalse(obj.ber_encoded) self.assertTrue(obj.bered) + repr(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) with self.assertRaises(NotEnoughData) as err: Any().decode( encoded[:-1], @@ -4034,6 +4104,47 @@ class TestAny(CommonMixin, TestCase): self.assertEqual(err.exception.offset, offset + 1 + 1 + len(chunk) * chunks) self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),)) + class SeqOf(SequenceOf): + schema = Boolean(expl=expl) + + class Seq(Sequence): + schema = ( + ("type", ObjectIdentifier(defines=((("value",), { + ObjectIdentifier("1.2.3"): SeqOf(impl=OctetString.tag_default), + }),))), + ("value", Any()), + ) + seq = Seq(( + ("type", ObjectIdentifier("1.2.3")), + ("value", Any(encoded)), + )) + seq_encoded = seq.encode() + seq_decoded, _ = Seq().decode(seq_encoded, ctx={"bered": True}) + self.assertIsNotNone(seq_decoded["value"].defined) + repr(seq_decoded) + list(seq_decoded.pps()) + pprint(seq_decoded, big_blobs=True, with_decode_path=True) + self.assertTrue(seq_decoded.bered) + self.assertFalse(seq_decoded["type"].bered) + self.assertTrue(seq_decoded["value"].bered) + + chunk = chunk[:-1] + b"\x01" + chunks = b"".join([chunk] * (chunks + 1)) + encoded = OctetString.tag_default + len_encode(len(chunks)) + chunks + seq = Seq(( + ("type", ObjectIdentifier("1.2.3")), + ("value", Any(encoded)), + )) + seq_encoded = seq.encode() + seq_decoded, _ = Seq().decode(seq_encoded, ctx={"bered": True}) + self.assertIsNotNone(seq_decoded["value"].defined) + repr(seq_decoded) + list(seq_decoded.pps()) + pprint(seq_decoded, big_blobs=True, with_decode_path=True) + self.assertTrue(seq_decoded.bered) + self.assertFalse(seq_decoded["type"].bered) + self.assertTrue(seq_decoded["value"].bered) + @composite def choice_values_strategy(draw, value_required=False, schema=None, do_expl=False): @@ -4114,7 +4225,8 @@ class TestChoice(CommonMixin, TestCase): obj = self.base_klass() self.assertFalse(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) self.assertIsNone(obj["whatever"]) with self.assertRaises(ObjNotReady) as err: obj.encode() @@ -4122,11 +4234,13 @@ class TestChoice(CommonMixin, TestCase): obj["whatever"] = Boolean() self.assertFalse(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) obj["whatever"] = Boolean(value) self.assertTrue(obj.ready) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) @given(booleans(), booleans()) def test_comparison(self, value1, value2): @@ -4256,20 +4370,23 @@ class TestChoice(CommonMixin, TestCase): _decoded=_decoded, ) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) self.assertFalse(obj.expled) obj_encoded = obj.encode() obj_expled = obj(value, expl=tag_expl) self.assertTrue(obj_expled.expled) repr(obj_expled) - pprint(obj_expled) + list(obj_expled.pps()) + pprint(obj_expled, big_blobs=True, with_decode_path=True) obj_expled_encoded = obj_expled.encode() obj_decoded, tail = obj_expled.decode( obj_expled_encoded + tail_junk, offset=offset, ) repr(obj_decoded) - pprint(obj_decoded) + list(obj_decoded.pps()) + pprint(obj_decoded, big_blobs=True, with_decode_path=True) self.assertEqual(tail, tail_junk) self.assertEqual(obj_decoded, obj_expled) self.assertEqual(obj_decoded.choice, obj_expled.choice) @@ -4571,12 +4688,14 @@ class SeqMixing(object): seq[name] = Boolean() self.assertFalse(seq.ready) repr(seq) - pprint(seq) + list(seq.pps()) + pprint(seq, big_blobs=True, with_decode_path=True) for name, value in ready.items(): seq[name] = Boolean(value) self.assertFalse(seq.ready) repr(seq) - pprint(seq) + list(seq.pps()) + pprint(seq, big_blobs=True, with_decode_path=True) with self.assertRaises(ObjNotReady) as err: seq.encode() repr(err.exception) @@ -4584,7 +4703,8 @@ class SeqMixing(object): seq[name] = Boolean(value) self.assertTrue(seq.ready) repr(seq) - pprint(seq) + list(seq.pps()) + pprint(seq, big_blobs=True, with_decode_path=True) @given(data_strategy()) def test_call(self, d): @@ -4759,7 +4879,8 @@ class SeqMixing(object): self.assertFalse(seq.decoded) self._assert_expects(seq, expects) repr(seq) - pprint(seq) + list(seq.pps()) + pprint(seq, big_blobs=True, with_decode_path=True) self.assertTrue(seq.ready) seq_encoded = seq.encode() seq_decoded, tail = seq.decode(seq_encoded + tail_junk) @@ -4781,7 +4902,8 @@ class SeqMixing(object): with self.assertRaises(DecodeError): seq.decode(seq_encoded_lenindef[:-2], ctx={"bered": True}) repr(seq_decoded_lenindef) - pprint(seq_decoded_lenindef) + list(seq_decoded_lenindef.pps()) + pprint(seq_decoded_lenindef, big_blobs=True, with_decode_path=True) self.assertTrue(seq_decoded_lenindef.ready) for decoded, decoded_tail, encoded in ( @@ -4940,6 +5062,8 @@ class SeqMixing(object): EOC ) encoded = Seq.tag_default + len_encode(len(encoded)) + encoded + with self.assertRaises(DecodeError): + Seq().decode(encoded) decoded, _ = Seq().decode(encoded, ctx={"bered": True}) self.assertFalse(decoded.ber_encoded) self.assertFalse(decoded.lenindef) @@ -5151,7 +5275,8 @@ class SeqOfMixing(object): seqof.append(value) self.assertFalse(seqof.ready) repr(seqof) - pprint(seqof) + list(seqof.pps()) + pprint(seqof, big_blobs=True, with_decode_path=True) with self.assertRaises(ObjNotReady) as err: seqof.encode() repr(err.exception) @@ -5161,7 +5286,8 @@ class SeqOfMixing(object): seqof[i] = Integer(i) self.assertTrue(seqof.ready) repr(seqof) - pprint(seqof) + list(seqof.pps()) + pprint(seqof, big_blobs=True, with_decode_path=True) def test_spec_mismatch(self): class SeqOf(self.base_klass): @@ -5408,20 +5534,23 @@ class SeqOfMixing(object): _decoded=_decoded, ) repr(obj) - pprint(obj) + list(obj.pps()) + pprint(obj, big_blobs=True, with_decode_path=True) self.assertFalse(obj.expled) obj_encoded = obj.encode() obj_expled = obj(value, expl=tag_expl) self.assertTrue(obj_expled.expled) repr(obj_expled) - pprint(obj_expled) + list(obj_expled.pps()) + pprint(obj_expled, big_blobs=True, with_decode_path=True) obj_expled_encoded = obj_expled.encode() obj_decoded, tail = obj_expled.decode( obj_expled_encoded + tail_junk, offset=offset, ) repr(obj_decoded) - pprint(obj_decoded) + list(obj_decoded.pps()) + pprint(obj_decoded, big_blobs=True, with_decode_path=True) self.assertEqual(tail, tail_junk) self._test_symmetric_compare_objs(obj_decoded, obj_expled) self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded) @@ -5458,7 +5587,8 @@ class SeqOfMixing(object): self.assertTrue(obj_decoded_lenindef.lenindef) self.assertTrue(obj_decoded_lenindef.bered) repr(obj_decoded_lenindef) - pprint(obj_decoded_lenindef) + list(obj_decoded_lenindef.pps()) + pprint(obj_decoded_lenindef, big_blobs=True, with_decode_path=True) self.assertEqual(obj_decoded_lenindef.tlvlen, len(obj_encoded_lenindef)) with self.assertRaises(DecodeError): obj.decode(obj_encoded_lenindef[:-1], ctx={"bered": True}) @@ -5472,6 +5602,8 @@ class SeqOfMixing(object): encoded = Boolean(False).encode() encoded += Boolean.tag_default + len_encode(1) + b"\x01" encoded = SeqOf.tag_default + len_encode(len(encoded)) + encoded + with self.assertRaises(DecodeError): + SeqOf().decode(encoded) decoded, _ = SeqOf().decode(encoded, ctx={"bered": True}) self.assertFalse(decoded.ber_encoded) self.assertFalse(decoded.lenindef) @@ -5487,6 +5619,8 @@ class SeqOfMixing(object): EOC ) encoded = SeqOf.tag_default + len_encode(len(encoded)) + encoded + with self.assertRaises(DecodeError): + SeqOf().decode(encoded) decoded, _ = SeqOf().decode(encoded, ctx={"bered": True}) self.assertFalse(decoded.ber_encoded) self.assertFalse(decoded.lenindef) @@ -5807,6 +5941,9 @@ class TestOIDDefines(TestCase): self.assertIsNotNone(seq[value_name_chosen].defined) self.assertEqual(seq[value_name_chosen].defined[0], oid_chosen) self.assertIsInstance(seq[value_name_chosen].defined[1], Integer) + repr(seq) + list(seq.pps()) + pprint(seq, big_blobs=True, with_decode_path=True) class TestDefinesByPath(TestCase): @@ -5868,6 +6005,9 @@ class TestDefinesByPath(TestCase): seq_sequenced["type"] = type_sequenced seq_sequenced["value"] = OctetString(seq_inner.encode()) seq_sequenced_raw = seq_sequenced.encode() + repr(seq_sequenced) + list(seq_sequenced.pps()) + pprint(seq_sequenced, big_blobs=True, with_decode_path=True) defines_by_path = [] seq_integered, _ = Seq().decode(seq_integered_raw) @@ -5888,6 +6028,9 @@ class TestDefinesByPath(TestCase): self.assertTrue(seq_integered_raw[ seq_integered["value"].defined[1].offset: ].startswith(Integer(123).encode())) + repr(seq_integered) + list(seq_integered.pps()) + pprint(seq_integered, big_blobs=True, with_decode_path=True) seq_sequenced, _ = Seq().decode( seq_sequenced_raw, @@ -5897,6 +6040,9 @@ class TestDefinesByPath(TestCase): self.assertEqual(seq_sequenced["value"].defined[0], type_sequenced) seq_inner = seq_sequenced["value"].defined[1] self.assertIsNone(seq_inner["valueInner"].defined) + repr(seq_sequenced) + list(seq_sequenced.pps()) + pprint(seq_sequenced, big_blobs=True, with_decode_path=True) defines_by_path.append(( ("value", DecodePathDefBy(type_sequenced), "typeInner"), @@ -5914,6 +6060,9 @@ class TestDefinesByPath(TestCase): pairs = seq_inner["valueInner"].defined[1] for pair in pairs: self.assertIsNone(pair["value"][0].defined) + repr(seq_sequenced) + list(seq_sequenced.pps()) + pprint(seq_sequenced, big_blobs=True, with_decode_path=True) defines_by_path.append(( ( @@ -5942,6 +6091,9 @@ class TestDefinesByPath(TestCase): for pair_input, pair_got in zip(pairs_input, pairs_got): self.assertEqual(pair_got["value"][0].defined[0], pair_input[0]) self.assertEqual(pair_got["value"][0].defined[1], pair_input[1]) + repr(seq_sequenced) + list(seq_sequenced.pps()) + pprint(seq_sequenced, big_blobs=True, with_decode_path=True) @given(oid_strategy(), integers()) def test_simple(self, oid, tgt): -- 2.44.0