X-Git-Url: http://www.git.cypherpunks.ru/?a=blobdiff_plain;f=tests%2Ftest_pyderasn.py;h=13aeff48e1ead5dda07499b252214dc294934527;hb=afc0f9f65430bed928619c783373ae3c6a82be1b;hp=dd3506b88c3216a221fe15096ccdc1d8c8fbf9ff;hpb=529183bf80e4796b3970d18e0fac490cd5865781;p=pyderasn.git

diff --git a/tests/test_pyderasn.py b/tests/test_pyderasn.py
index dd3506b..13aeff4 100644
--- a/tests/test_pyderasn.py
+++ b/tests/test_pyderasn.py
@@ -1,6 +1,6 @@
 # coding: utf-8
 # PyDERASN -- Python ASN.1 DER/BER codec with abstract structures
-# Copyright (C) 2017-2018 Sergey Matveev <stargrave@stargrave.org>
+# Copyright (C) 2017-2019 Sergey Matveev <stargrave@stargrave.org>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser General Public License as
@@ -16,6 +16,7 @@
 # License along with this program.  If not, see
 # <http://www.gnu.org/licenses/>.
 
+from copy import deepcopy
 from datetime import datetime
 from string import ascii_letters
 from string import digits
@@ -81,6 +82,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
@@ -131,6 +133,7 @@ tag_forms = sampled_from((TagFormConstructed, TagFormPrimitive))
 decode_path_strat = lists(integers(), max_size=3).map(
     lambda decode_path: tuple(str(dp) for dp in decode_path)
 )
+ctx_dummy = dictionaries(integers(), integers(), min_size=2, max_size=4).example()
 
 
 class TestHex(TestCase):
@@ -371,14 +374,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 +553,26 @@ 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()
+            ctx_copied = deepcopy(ctx_dummy)
             obj_decoded, tail = obj_expled.decode(
                 obj_expled_encoded + tail_junk,
                 offset=offset,
+                ctx=ctx_copied,
             )
+            self.assertDictEqual(ctx_copied, ctx_dummy)
             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)
@@ -611,6 +622,10 @@ class TestBoolean(CommonMixin, TestCase):
         self.assertTrue(obj.ber_encoded)
         self.assertFalse(obj.lenindef)
         self.assertTrue(obj.bered)
+        obj = obj.copy()
+        self.assertTrue(obj.ber_encoded)
+        self.assertFalse(obj.lenindef)
+        self.assertTrue(obj.bered)
 
     @given(
         integers(min_value=1).map(tag_ctxc),
@@ -618,6 +633,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(
@@ -628,7 +645,15 @@ class TestBoolean(CommonMixin, TestCase):
         self.assertFalse(obj.lenindef)
         self.assertFalse(obj.ber_encoded)
         self.assertTrue(obj.bered)
+        obj = obj.copy()
+        self.assertTrue(obj.expl_lenindef)
+        self.assertFalse(obj.lenindef)
+        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 +676,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 +705,9 @@ class TestBoolean(CommonMixin, TestCase):
                 True,
             ),)),
         )
+        repr(seqof)
+        list(seqof.pps())
+        pprint(seqof, big_blobs=True, with_decode_path=True)
 
 
 @composite
@@ -756,14 +786,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 +1045,26 @@ 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()
+            ctx_copied = deepcopy(ctx_dummy)
             obj_decoded, tail = obj_expled.decode(
                 obj_expled_encoded + tail_junk,
                 offset=offset,
+                ctx=ctx_copied,
             )
+            self.assertDictEqual(ctx_copied, ctx_dummy)
             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 +1255,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 +1431,26 @@ 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()
+            ctx_copied = deepcopy(ctx_dummy)
             obj_decoded, tail = obj_expled.decode(
                 obj_expled_encoded + tail_junk,
                 offset=offset,
+                ctx=ctx_copied,
             )
+            self.assertDictEqual(ctx_copied, ctx_dummy)
             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)
@@ -1547,6 +1593,10 @@ class TestBitString(CommonMixin, TestCase):
             self.assertTrue(obj.ber_encoded)
             self.assertEqual(obj.lenindef, lenindef_expected)
             self.assertTrue(obj.bered)
+            obj = obj.copy()
+            self.assertTrue(obj.ber_encoded)
+            self.assertEqual(obj.lenindef, lenindef_expected)
+            self.assertTrue(obj.bered)
             self.assertEqual(len(encoded), obj.tlvlen)
 
     @given(
@@ -1679,6 +1729,10 @@ class TestBitString(CommonMixin, TestCase):
         self.assertTrue(obj.ber_encoded)
         self.assertTrue(obj.lenindef)
         self.assertTrue(obj.bered)
+        obj = obj.copy()
+        self.assertTrue(obj.ber_encoded)
+        self.assertTrue(obj.lenindef)
+        self.assertTrue(obj.bered)
 
 
 @composite
@@ -1736,14 +1790,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 +2020,26 @@ 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()
+            ctx_copied = deepcopy(ctx_dummy)
             obj_decoded, tail = obj_expled.decode(
                 obj_expled_encoded + tail_junk,
                 offset=offset,
+                ctx=ctx_copied,
             )
+            self.assertDictEqual(ctx_copied, ctx_dummy)
             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)
@@ -2058,6 +2120,10 @@ class TestOctetString(CommonMixin, TestCase):
             self.assertTrue(obj.ber_encoded)
             self.assertEqual(obj.lenindef, lenindef_expected)
             self.assertTrue(obj.bered)
+            obj = obj.copy()
+            self.assertTrue(obj.ber_encoded)
+            self.assertEqual(obj.lenindef, lenindef_expected)
+            self.assertTrue(obj.bered)
             self.assertEqual(len(encoded), obj.tlvlen)
 
     @given(
@@ -2144,7 +2210,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 +2324,26 @@ 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()
+            ctx_copied = deepcopy(ctx_dummy)
             obj_decoded, tail = obj_expled.decode(
                 obj_expled_encoded + tail_junk,
                 offset=offset,
+                ctx=ctx_copied,
             )
+            self.assertDictEqual(ctx_copied, ctx_dummy)
             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 +2424,17 @@ 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)
+        self.assertFalse(obj.ber_encoded)
         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 +2640,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 +2660,26 @@ 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()
+            ctx_copied = deepcopy(ctx_dummy)
             obj_decoded, tail = obj_expled.decode(
                 obj_expled_encoded + tail_junk,
                 offset=offset,
+                ctx=ctx_copied,
             )
+            self.assertDictEqual(ctx_copied, ctx_dummy)
             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)
@@ -2660,6 +2742,56 @@ class TestObjectIdentifier(CommonMixin, TestCase):
             ObjectIdentifier((2, 999, 3)),
         )
 
+    @given(data_strategy())
+    def test_nonnormalized_first_arc(self, d):
+        tampered = (
+            ObjectIdentifier.tag_default +
+            len_encode(2) +
+            b'\x80' +
+            ObjectIdentifier((1, 0)).encode()[-1:]
+        )
+        obj, _ = ObjectIdentifier().decode(tampered, ctx={"bered": True})
+        self.assertTrue(obj.ber_encoded)
+        self.assertTrue(obj.bered)
+        obj = obj.copy()
+        self.assertTrue(obj.ber_encoded)
+        self.assertTrue(obj.bered)
+        with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
+            ObjectIdentifier().decode(tampered)
+
+    @given(data_strategy())
+    def test_nonnormalized_arcs(self, d):
+        arcs = d.draw(lists(
+            integers(min_value=0, max_value=100),
+            min_size=1,
+            max_size=5,
+        ))
+        dered = ObjectIdentifier((1, 0) + tuple(arcs)).encode()
+        _, tlen, lv = tag_strip(dered)
+        _, llen, v = len_decode(lv)
+        v_no_first_arc = v[1:]
+        idx_for_tamper = d.draw(integers(
+            min_value=0,
+            max_value=len(v_no_first_arc) - 1,
+        ))
+        tampered = list(bytearray(v_no_first_arc))
+        for _ in range(d.draw(integers(min_value=1, max_value=3))):
+            tampered.insert(idx_for_tamper, 0x80)
+        tampered = bytes(bytearray(tampered))
+        tampered = (
+            ObjectIdentifier.tag_default +
+            len_encode(len(tampered)) +
+            tampered
+        )
+        obj, _ = ObjectIdentifier().decode(tampered, ctx={"bered": True})
+        self.assertTrue(obj.ber_encoded)
+        self.assertTrue(obj.bered)
+        obj = obj.copy()
+        self.assertTrue(obj.ber_encoded)
+        self.assertTrue(obj.bered)
+        with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
+            ObjectIdentifier().decode(tampered)
+
 
 @composite
 def enumerated_values_strategy(draw, schema=None, do_expl=False):
@@ -2737,14 +2869,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 +3004,26 @@ 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()
+        ctx_copied = deepcopy(ctx_dummy)
         obj_decoded, tail = obj_expled.decode(
             obj_expled_encoded + tail_junk,
             offset=offset,
+            ctx=ctx_copied,
         )
+        self.assertDictEqual(ctx_copied, ctx_dummy)
         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 +3099,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 +3109,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 +3332,26 @@ 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()
+        ctx_copied = deepcopy(ctx_dummy)
         obj_decoded, tail = obj_expled.decode(
             obj_expled_encoded + tail_junk,
             offset=offset,
+            ctx=ctx_copied,
         )
+        self.assertDictEqual(ctx_copied, ctx_dummy)
         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)
@@ -3231,12 +3379,15 @@ class TestUTF8String(StringMixin, CommonMixin, TestCase):
     base_klass = UTF8String
 
 
+cyrillic_letters = text(
+    alphabet="".join(six_unichr(i) for i in list(range(0x0410, 0x044f + 1))),
+    min_size=1,
+    max_size=5,
+)
+
+
 class UnicodeDecodeErrorMixin(object):
-    @given(text(
-        alphabet="".join(six_unichr(i) for i in list(range(0x0410, 0x044f + 1))),
-        min_size=1,
-        max_size=5,
-    ))
+    @given(cyrillic_letters)
     def test_unicode_decode_error(self, cyrillic_text):
         with self.assertRaises(DecodeError):
             self.base_klass(cyrillic_text)
@@ -3246,12 +3397,12 @@ class TestNumericString(StringMixin, CommonMixin, TestCase):
     base_klass = NumericString
 
     def text_alphabet(self):
-        return digits
+        return digits + " "
 
     @given(text(alphabet=ascii_letters, min_size=1, max_size=5))
-    def test_non_numeric(self, cyrillic_text):
+    def test_non_numeric(self, non_numeric_text):
         with assertRaisesRegex(self, DecodeError, "non-numeric"):
-            self.base_klass(cyrillic_text)
+            self.base_klass(non_numeric_text)
 
     @given(
         sets(integers(min_value=0, max_value=10), min_size=2, max_size=2),
@@ -3282,6 +3433,34 @@ class TestPrintableString(
 ):
     base_klass = PrintableString
 
+    def text_alphabet(self):
+        return ascii_letters + digits + " '()+,-./:=?"
+
+    @given(text(alphabet=sorted(set(whitespace) - set(" ")), min_size=1, max_size=5))
+    def test_non_printable(self, non_printable_text):
+        with assertRaisesRegex(self, DecodeError, "non-printable"):
+            self.base_klass(non_printable_text)
+
+    @given(
+        sets(integers(min_value=0, max_value=10), min_size=2, max_size=2),
+        integers(min_value=0),
+        decode_path_strat,
+    )
+    def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
+        value, bound_min = list(sorted(ints))
+
+        class String(self.base_klass):
+            bounds = (bound_min, bound_min)
+        with self.assertRaises(DecodeError) as err:
+            String().decode(
+                self.base_klass(b"1" * value).encode(),
+                offset=offset,
+                decode_path=decode_path,
+            )
+        repr(err.exception)
+        self.assertEqual(err.exception.offset, offset)
+        self.assertEqual(err.exception.decode_path, decode_path)
+
 
 class TestTeletexString(
         UnicodeDecodeErrorMixin,
@@ -3344,6 +3523,10 @@ class TestVisibleString(
         self.assertTrue(obj.ber_encoded)
         self.assertFalse(obj.lenindef)
         self.assertTrue(obj.bered)
+        obj = obj.copy()
+        self.assertTrue(obj.ber_encoded)
+        self.assertFalse(obj.lenindef)
+        self.assertTrue(obj.bered)
 
         obj, tail = VisibleString().decode(
             hexdec("3A8004034A6F6E040265730000"),
@@ -3354,6 +3537,10 @@ class TestVisibleString(
         self.assertTrue(obj.ber_encoded)
         self.assertTrue(obj.lenindef)
         self.assertTrue(obj.bered)
+        obj = obj.copy()
+        self.assertTrue(obj.ber_encoded)
+        self.assertTrue(obj.lenindef)
+        self.assertTrue(obj.bered)
 
 
 class TestGeneralString(
@@ -3427,7 +3614,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 +3623,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 +3769,26 @@ 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()
+        ctx_copied = deepcopy(ctx_dummy)
         obj_decoded, tail = obj_expled.decode(
             obj_expled_encoded + tail_junk,
             offset=offset,
+            ctx=ctx_copied,
         )
+        self.assertDictEqual(ctx_copied, ctx_dummy)
         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 +4014,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 +4039,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 +4159,26 @@ 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()
+            ctx_copied = deepcopy(ctx_dummy)
             obj_decoded, tail = obj_expled.decode(
                 obj_expled_encoded + tail_junk,
                 offset=offset,
+                ctx=ctx_copied,
             )
+            self.assertDictEqual(ctx_copied, ctx_dummy)
             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 +4216,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 +4234,13 @@ class TestAny(CommonMixin, TestCase):
         self.assertTrue(obj.lenindef)
         self.assertFalse(obj.ber_encoded)
         self.assertTrue(obj.bered)
+        obj = obj.copy()
+        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 +4251,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 +4372,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 +4381,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 +4517,26 @@ 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()
+        ctx_copied = deepcopy(ctx_dummy)
         obj_decoded, tail = obj_expled.decode(
             obj_expled_encoded + tail_junk,
             offset=offset,
+            ctx=ctx_copied,
         )
+        self.assertDictEqual(ctx_copied, ctx_dummy)
         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 +4838,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 +4853,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 +5029,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)
@@ -4770,10 +5041,17 @@ class SeqMixing(object):
         t, _, lv = tag_strip(seq_encoded)
         _, _, v = len_decode(lv)
         seq_encoded_lenindef = t + LENINDEF + v + EOC
+        ctx_copied = deepcopy(ctx_dummy)
+        ctx_copied["bered"] = True
         seq_decoded_lenindef, tail_lenindef = seq.decode(
             seq_encoded_lenindef + tail_junk,
-            ctx={"bered": True},
+            ctx=ctx_copied,
         )
+        del ctx_copied["bered"]
+        self.assertDictEqual(ctx_copied, ctx_dummy)
+        self.assertTrue(seq_decoded_lenindef.lenindef)
+        self.assertTrue(seq_decoded_lenindef.bered)
+        seq_decoded_lenindef = seq_decoded_lenindef.copy()
         self.assertTrue(seq_decoded_lenindef.lenindef)
         self.assertTrue(seq_decoded_lenindef.bered)
         with self.assertRaises(DecodeError):
@@ -4781,7 +5059,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 (
@@ -4892,6 +5171,9 @@ class SeqMixing(object):
             seq_decoded, _ = seq_with_default.decode(seq_encoded, ctx=ctx)
             self.assertTrue(seq_decoded.ber_encoded)
             self.assertTrue(seq_decoded.bered)
+            seq_decoded = seq_decoded.copy()
+            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])
                 self.assertEqual(seq_decoded[name], value)
@@ -4930,6 +5212,10 @@ class SeqMixing(object):
         self.assertFalse(decoded.ber_encoded)
         self.assertFalse(decoded.lenindef)
         self.assertTrue(decoded.bered)
+        decoded = decoded.copy()
+        self.assertFalse(decoded.ber_encoded)
+        self.assertFalse(decoded.lenindef)
+        self.assertTrue(decoded.bered)
 
         class Seq(self.base_klass):
             schema = (("underlying", OctetString()),)
@@ -4940,10 +5226,16 @@ 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)
         self.assertTrue(decoded.bered)
+        decoded = decoded.copy()
+        self.assertFalse(decoded.ber_encoded)
+        self.assertFalse(decoded.lenindef)
+        self.assertTrue(decoded.bered)
 
 
 class TestSequence(SeqMixing, CommonMixin, TestCase):
@@ -5040,6 +5332,9 @@ class TestSet(SeqMixing, CommonMixin, TestCase):
             seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
             self.assertTrue(seq_decoded.ber_encoded)
             self.assertTrue(seq_decoded.bered)
+            seq_decoded = seq_decoded.copy()
+            self.assertTrue(seq_decoded.ber_encoded)
+            self.assertTrue(seq_decoded.bered)
             self.assertSequenceEqual(
                 [bytes(seq_decoded[str(i)]) for i, t in enumerate(tags)],
                 [t for t in tags],
@@ -5151,7 +5446,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 +5457,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 +5705,26 @@ 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()
+        ctx_copied = deepcopy(ctx_dummy)
         obj_decoded, tail = obj_expled.decode(
             obj_expled_encoded + tail_junk,
             offset=offset,
+            ctx=ctx_copied,
         )
+        self.assertDictEqual(ctx_copied, ctx_dummy)
         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)
@@ -5457,8 +5760,12 @@ class SeqOfMixing(object):
         )
         self.assertTrue(obj_decoded_lenindef.lenindef)
         self.assertTrue(obj_decoded_lenindef.bered)
+        obj_decoded_lenindef = obj_decoded_lenindef.copy()
+        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,10 +5779,16 @@ 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)
         self.assertTrue(decoded.bered)
+        decoded = decoded.copy()
+        self.assertFalse(decoded.ber_encoded)
+        self.assertFalse(decoded.lenindef)
+        self.assertTrue(decoded.bered)
 
         class SeqOf(self.base_klass):
             schema = OctetString()
@@ -5487,10 +5800,16 @@ 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)
         self.assertTrue(decoded.bered)
+        decoded = decoded.copy()
+        self.assertFalse(decoded.ber_encoded)
+        self.assertFalse(decoded.lenindef)
+        self.assertTrue(decoded.bered)
 
 
 class TestSequenceOf(SeqOfMixing, CommonMixin, TestCase):
@@ -5556,6 +5875,9 @@ class TestSetOf(SeqOfMixing, CommonMixin, TestCase):
             seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
             self.assertTrue(seq_decoded.ber_encoded)
             self.assertTrue(seq_decoded.bered)
+            seq_decoded = seq_decoded.copy()
+            self.assertTrue(seq_decoded.ber_encoded)
+            self.assertTrue(seq_decoded.bered)
             self.assertSequenceEqual(
                 [obj.encode() for obj in seq_decoded],
                 values,
@@ -5703,8 +6025,11 @@ class TestGoMarshalVectors(TestCase):
         seq = Seq()
         seq["erste"] = PrintableString("test")
         self.assertSequenceEqual(seq.encode(), hexdec("3006130474657374"))
+        # Asterisk is actually not allowable
+        PrintableString._allowable_chars |= set(b"*")
         seq["erste"] = PrintableString("test*")
         self.assertSequenceEqual(seq.encode(), hexdec("30071305746573742a"))
+        PrintableString._allowable_chars -= set(b"*")
 
         class Seq(Sequence):
             schema = (
@@ -5807,6 +6132,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,9 +6196,17 @@ 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)
+        ctx_copied = deepcopy(ctx_dummy)
+        seq_integered, _ = Seq().decode(
+            seq_integered_raw,
+            ctx=ctx_copied,
+        )
+        self.assertDictEqual(ctx_copied, ctx_dummy)
         self.assertIsNone(seq_integered["value"].defined)
         defines_by_path.append(
             (("type",), ((("value",), {
@@ -5878,34 +6214,49 @@ class TestDefinesByPath(TestCase):
                 type_sequenced: SeqInner(),
             }),))
         )
+        ctx_copied["defines_by_path"] = defines_by_path
         seq_integered, _ = Seq().decode(
             seq_integered_raw,
-            ctx={"defines_by_path": defines_by_path},
+            ctx=ctx_copied,
         )
+        del ctx_copied["defines_by_path"]
+        self.assertDictEqual(ctx_copied, ctx_dummy)
         self.assertIsNotNone(seq_integered["value"].defined)
         self.assertEqual(seq_integered["value"].defined[0], type_integered)
         self.assertEqual(seq_integered["value"].defined[1], Integer(123))
         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)
 
+        ctx_copied["defines_by_path"] = defines_by_path
         seq_sequenced, _ = Seq().decode(
             seq_sequenced_raw,
-            ctx={"defines_by_path": defines_by_path},
+            ctx=ctx_copied,
         )
+        del ctx_copied["defines_by_path"]
+        self.assertDictEqual(ctx_copied, ctx_dummy)
         self.assertIsNotNone(seq_sequenced["value"].defined)
         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"),
             ((("valueInner",), {type_innered: Pairs()}),),
         ))
+        ctx_copied["defines_by_path"] = defines_by_path
         seq_sequenced, _ = Seq().decode(
             seq_sequenced_raw,
-            ctx={"defines_by_path": defines_by_path},
+            ctx=ctx_copied,
         )
+        del ctx_copied["defines_by_path"]
+        self.assertDictEqual(ctx_copied, ctx_dummy)
         self.assertIsNotNone(seq_sequenced["value"].defined)
         self.assertEqual(seq_sequenced["value"].defined[0], type_sequenced)
         seq_inner = seq_sequenced["value"].defined[1]
@@ -5914,6 +6265,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((
             (
@@ -5929,10 +6283,13 @@ class TestDefinesByPath(TestCase):
                 type_octet_stringed: OctetString(),
             }),),
         ))
+        ctx_copied["defines_by_path"] = defines_by_path
         seq_sequenced, _ = Seq().decode(
             seq_sequenced_raw,
-            ctx={"defines_by_path": defines_by_path},
+            ctx=ctx_copied,
         )
+        del ctx_copied["defines_by_path"]
+        self.assertDictEqual(ctx_copied, ctx_dummy)
         self.assertIsNotNone(seq_sequenced["value"].defined)
         self.assertEqual(seq_sequenced["value"].defined[0], type_sequenced)
         seq_inner = seq_sequenced["value"].defined[1]
@@ -5942,6 +6299,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):
@@ -6023,9 +6383,15 @@ class TestStrictDefaultExistence(TestCase):
             decoded, _ = seq.decode(raw, ctx={"allow_default_values": True})
             self.assertTrue(decoded.ber_encoded)
             self.assertTrue(decoded.bered)
+            decoded = decoded.copy()
+            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)
+            decoded = decoded.copy()
+            self.assertTrue(decoded.ber_encoded)
+            self.assertTrue(decoded.bered)
 
 
 class TestX690PrefixedType(TestCase):