X-Git-Url: http://www.git.cypherpunks.ru/?a=blobdiff_plain;f=tests%2Ftest_pyderasn.py;h=125244f4aad58d351ab590f57a5551f071541143;hb=be964cef343716ff80679f2bc828427bc07c5f02;hp=faa85699fd2d628058d3c9cf5d2ce83d8fbcc218;hpb=d8f05bb5f06096c6e061c82d40aeb9f43bbb1a21;p=pyderasn.git

diff --git a/tests/test_pyderasn.py b/tests/test_pyderasn.py
index faa8569..125244f 100644
--- a/tests/test_pyderasn.py
+++ b/tests/test_pyderasn.py
@@ -1,5 +1,5 @@
 # coding: utf-8
-# PyDERASN -- Python ASN.1 DER codec with abstract structures
+# PyDERASN -- Python ASN.1 DER/BER codec with abstract structures
 # Copyright (C) 2017-2018 Sergey Matveev <stargrave@stargrave.org>
 #
 # This program is free software: you can redistribute it and/or modify
@@ -77,6 +77,7 @@ from pyderasn import InvalidOID
 from pyderasn import InvalidValueType
 from pyderasn import len_decode
 from pyderasn import len_encode
+from pyderasn import LENINDEF
 from pyderasn import NotEnoughData
 from pyderasn import Null
 from pyderasn import NumericString
@@ -125,6 +126,9 @@ tag_classes = sampled_from((
     TagClassUniversal,
 ))
 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)
+)
 
 
 class TestHex(TestCase):
@@ -463,10 +467,9 @@ class TestBoolean(CommonMixin, TestCase):
     @given(
         integers(min_value=31),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_tag(self, tag, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             Boolean().decode(
                 tag_encode(tag)[:-1],
@@ -480,10 +483,9 @@ class TestBoolean(CommonMixin, TestCase):
     @given(
         integers(min_value=31),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_expl_tag(self, tag, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             Boolean(expl=Boolean.tag_default).decode(
                 tag_encode(tag)[:-1],
@@ -497,10 +499,9 @@ class TestBoolean(CommonMixin, TestCase):
     @given(
         integers(min_value=128),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_len(self, l, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             Boolean().decode(
                 Boolean.tag_default + len_encode(l)[:-1],
@@ -514,10 +515,9 @@ class TestBoolean(CommonMixin, TestCase):
     @given(
         integers(min_value=128),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_expl_len(self, l, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             Boolean(expl=Boolean.tag_default).decode(
                 Boolean.tag_default + len_encode(l)[:-1],
@@ -607,6 +607,22 @@ class TestBoolean(CommonMixin, TestCase):
         )
         self.assertTrue(bool(obj))
         self.assertTrue(obj.bered)
+        self.assertFalse(obj.lenindef)
+
+    @given(
+        integers(min_value=1).map(tag_ctxc),
+        binary().filter(lambda x: not x.startswith(EOC)),
+    )
+    def test_ber_expl_no_eoc(self, expl, junk):
+        encoded = expl + LENINDEF + Boolean(False).encode()
+        with assertRaisesRegex(self, DecodeError, "no EOC"):
+            Boolean(expl=expl).decode(encoded + junk, ctx={"bered": True})
+        obj, tail = Boolean(expl=expl).decode(
+            encoded + EOC + junk,
+            ctx={"bered": True},
+        )
+        self.assertTrue(obj.expl_lenindef)
+        self.assertSequenceEqual(tail, junk)
 
     @given(
         integers(min_value=1).map(tag_ctxc),
@@ -621,7 +637,7 @@ class TestBoolean(CommonMixin, TestCase):
         for value in values:
             encoded += (
                 expl +
-                b"\x80" +
+                LENINDEF +
                 Boolean(value).encode() +
                 EOC
             )
@@ -633,8 +649,26 @@ class TestBoolean(CommonMixin, TestCase):
         self.assertSequenceEqual(tail, b"")
         self.assertSequenceEqual([bool(v) for v in seqof], values)
         self.assertSetEqual(
-            set((v.tlvlen, v.expl_tlvlen, v.expl_tlen, v.expl_llen) for v in seqof),
-            set(((3 + EOC_LEN, len(expl) + 1 + 3 + EOC_LEN, len(expl), 1),)),
+            set(
+                (
+                    v.tlvlen,
+                    v.expl_tlvlen,
+                    v.expl_tlen,
+                    v.expl_llen,
+                    v.bered,
+                    v.lenindef,
+                    v.expl_lenindef,
+                ) for v in seqof
+            ),
+            set(((
+                3 + EOC_LEN,
+                len(expl) + 1 + 3 + EOC_LEN,
+                len(expl),
+                1,
+                False,
+                False,
+                True,
+            ),)),
         )
 
 
@@ -894,10 +928,9 @@ class TestInteger(CommonMixin, TestCase):
     @given(
         integers(min_value=31),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_tag(self, tag, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             Integer().decode(
                 tag_encode(tag)[:-1],
@@ -911,10 +944,9 @@ class TestInteger(CommonMixin, TestCase):
     @given(
         integers(min_value=128),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_len(self, l, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             Integer().decode(
                 Integer.tag_default + len_encode(l)[:-1],
@@ -928,10 +960,9 @@ class TestInteger(CommonMixin, TestCase):
     @given(
         sets(integers(), min_size=2, max_size=2),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         value, bound_min = list(sorted(ints))
 
         class Int(Integer):
@@ -1288,10 +1319,9 @@ class TestBitString(CommonMixin, TestCase):
     @given(
         integers(min_value=31),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_tag(self, tag, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             BitString().decode(
                 tag_encode(tag)[:-1],
@@ -1305,10 +1335,9 @@ class TestBitString(CommonMixin, TestCase):
     @given(
         integers(min_value=128),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_len(self, l, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             BitString().decode(
                 BitString.tag_default + len_encode(l)[:-1],
@@ -1443,12 +1472,13 @@ class TestBitString(CommonMixin, TestCase):
             max_size=3,
         ),
         lists(booleans(), min_size=1),
+        binary(),
     )
-    def test_constructed(self, impl, chunk_inputs, chunk_last_bits):
+    def test_constructed(self, impl, chunk_inputs, chunk_last_bits, junk):
         def chunk_constructed(contents):
             return (
                 tag_encode(form=TagFormConstructed, num=3) +
-                b"\x80" +
+                LENINDEF +
                 b"".join(BitString(content).encode() for content in contents) +
                 EOC
             )
@@ -1472,7 +1502,7 @@ class TestBitString(CommonMixin, TestCase):
         bit_len_expected += chunk_last.bit_len
         encoded_indefinite = (
             tag_encode(form=TagFormConstructed, num=impl) +
-            b"\x80" +
+            LENINDEF +
             b"".join(chunks) +
             chunk_last.encode() +
             EOC
@@ -1485,19 +1515,139 @@ class TestBitString(CommonMixin, TestCase):
         )
         with assertRaisesRegex(self, DecodeError, "unallowed BER"):
             BitString(impl=tag_encode(impl)).decode(encoded_indefinite)
-        for encoded in (encoded_indefinite, encoded_definite):
+        for lenindef_expected, encoded in (
+                (True, encoded_indefinite),
+                (False, encoded_definite),
+        ):
             obj, tail = BitString(impl=tag_encode(impl)).decode(
-                encoded, ctx={"bered": True}
+                encoded + junk,
+                ctx={"bered": True},
             )
-            self.assertSequenceEqual(tail, b"")
+            self.assertSequenceEqual(tail, junk)
             self.assertEqual(obj.bit_len, bit_len_expected)
             self.assertSequenceEqual(bytes(obj), payload_expected)
             self.assertTrue(obj.bered)
+            self.assertEqual(obj.lenindef, lenindef_expected)
             self.assertEqual(len(encoded), obj.tlvlen)
 
+    @given(
+        integers(min_value=0),
+        decode_path_strat,
+    )
+    def test_ber_definite_too_short(self, offset, decode_path):
+        with assertRaisesRegex(self, DecodeError, "longer than data") as err:
+            BitString().decode(
+                tag_encode(3, form=TagFormConstructed) + len_encode(1),
+                offset=offset,
+                decode_path=decode_path,
+                ctx={"bered": True},
+            )
+        self.assertEqual(err.exception.decode_path, decode_path)
+        self.assertEqual(err.exception.offset, offset)
+
+    @given(
+        integers(min_value=0),
+        decode_path_strat,
+    )
+    def test_ber_definite_no_data(self, offset, decode_path):
+        with assertRaisesRegex(self, DecodeError, "zero length") as err:
+            BitString().decode(
+                tag_encode(3, form=TagFormConstructed) + len_encode(0),
+                offset=offset,
+                decode_path=decode_path,
+                ctx={"bered": True},
+            )
+        self.assertEqual(err.exception.decode_path, decode_path)
+        self.assertEqual(err.exception.offset, offset)
+
+    @given(
+        integers(min_value=0),
+        decode_path_strat,
+        integers(min_value=1, max_value=3),
+    )
+    def test_ber_indefinite_no_eoc(self, offset, decode_path, chunks):
+        bs = BitString(b"data").encode()
+        with self.assertRaises(NotEnoughData) as err:
+            BitString().decode(
+                tag_encode(3, form=TagFormConstructed) + LENINDEF + chunks * bs,
+                offset=offset,
+                decode_path=decode_path,
+                ctx={"bered": True},
+            )
+        self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),))
+        self.assertEqual(err.exception.offset, offset + 1 + 1 + chunks * len(bs))
+
+    @given(
+        integers(min_value=0),
+        decode_path_strat,
+        integers(min_value=1, max_value=3),
+    )
+    def test_ber_definite_chunk_out_of_bounds(self, offset, decode_path, chunks):
+        bs = BitString(b"data").encode()
+        bs_longer = BitString(b"data-longer").encode()
+        with assertRaisesRegex(self, DecodeError, "chunk out of bounds") as err:
+            BitString().decode(
+                (
+                    tag_encode(3, form=TagFormConstructed) +
+                    len_encode((chunks + 1) * len(bs)) +
+                    chunks * bs +
+                    bs_longer
+                ),
+                offset=offset,
+                decode_path=decode_path,
+                ctx={"bered": True},
+            )
+        self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),))
+        self.assertEqual(err.exception.offset, offset + 1 + 1 + chunks * len(bs))
+
+    @given(
+        integers(min_value=0),
+        decode_path_strat,
+    )
+    def test_ber_indefinite_no_chunks(self, offset, decode_path):
+        with assertRaisesRegex(self, DecodeError, "no chunks") as err:
+            BitString().decode(
+                tag_encode(3, form=TagFormConstructed) + LENINDEF + EOC,
+                offset=offset,
+                decode_path=decode_path,
+                ctx={"bered": True},
+            )
+        self.assertEqual(err.exception.decode_path, decode_path)
+        self.assertEqual(err.exception.offset, offset)
+
+    @given(data_strategy())
+    def test_ber_indefinite_not_multiple(self, d):
+        bs_short = BitString("'A'H").encode()
+        bs_full = BitString("'AA'H").encode()
+        chunks = [bs_full for _ in range(d.draw(integers(min_value=0, max_value=3)))]
+        chunks.append(bs_short)
+        d.draw(permutations(chunks))
+        chunks.append(bs_short)
+        offset = d.draw(integers(min_value=0))
+        decode_path = d.draw(decode_path_strat)
+        with assertRaisesRegex(self, DecodeError, "multiple of 8 bits") as err:
+            BitString().decode(
+                (
+                    tag_encode(3, form=TagFormConstructed) +
+                    LENINDEF +
+                    b"".join(chunks) +
+                    EOC
+                ),
+                offset=offset,
+                decode_path=decode_path,
+                ctx={"bered": True},
+            )
+        self.assertEqual(
+            err.exception.decode_path,
+            decode_path + (str(chunks.index(bs_short)),),
+        )
+        self.assertEqual(
+            err.exception.offset,
+            offset + 1 + 1 + chunks.index(bs_short) * len(bs_full),
+        )
+
     def test_x690_vector(self):
-        vector_payload = hexdec("0A3B5F291CD0")
-        vector = BitString((len(vector_payload) * 8 - 4, vector_payload))
+        vector = BitString("'0A3B5F291CD'H")
         obj, tail = BitString().decode(hexdec("0307040A3B5F291CD0"))
         self.assertSequenceEqual(tail, b"")
         self.assertEqual(obj, vector)
@@ -1507,6 +1657,8 @@ class TestBitString(CommonMixin, TestCase):
         )
         self.assertSequenceEqual(tail, b"")
         self.assertEqual(obj, vector)
+        self.assertTrue(obj.bered)
+        self.assertTrue(obj.lenindef)
 
 
 @composite
@@ -1715,10 +1867,9 @@ class TestOctetString(CommonMixin, TestCase):
     @given(
         integers(min_value=31),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_tag(self, tag, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             OctetString().decode(
                 tag_encode(tag)[:-1],
@@ -1732,10 +1883,9 @@ class TestOctetString(CommonMixin, TestCase):
     @given(
         integers(min_value=128),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_len(self, l, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             OctetString().decode(
                 OctetString.tag_default + len_encode(l)[:-1],
@@ -1749,10 +1899,9 @@ class TestOctetString(CommonMixin, TestCase):
     @given(
         sets(integers(min_value=0, max_value=10), min_size=2, max_size=2),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         value, bound_min = list(sorted(ints))
 
         class String(OctetString):
@@ -1833,12 +1982,13 @@ class TestOctetString(CommonMixin, TestCase):
             min_size=1,
             max_size=3,
         ),
+        binary(),
     )
-    def test_constructed(self, impl, chunk_inputs):
+    def test_constructed(self, impl, chunk_inputs, junk):
         def chunk_constructed(contents):
             return (
                 tag_encode(form=TagFormConstructed, num=4) +
-                b"\x80" +
+                LENINDEF +
                 b"".join(OctetString(content).encode() for content in contents) +
                 EOC
             )
@@ -1854,7 +2004,7 @@ class TestOctetString(CommonMixin, TestCase):
                 payload_expected += payload
         encoded_indefinite = (
             tag_encode(form=TagFormConstructed, num=impl) +
-            b"\x80" +
+            LENINDEF +
             b"".join(chunks) +
             EOC
         )
@@ -1865,15 +2015,75 @@ class TestOctetString(CommonMixin, TestCase):
         )
         with assertRaisesRegex(self, DecodeError, "unallowed BER"):
             OctetString(impl=tag_encode(impl)).decode(encoded_indefinite)
-        for encoded in (encoded_indefinite, encoded_definite):
+        for lenindef_expected, encoded in (
+                (True, encoded_indefinite),
+                (False, encoded_definite),
+        ):
             obj, tail = OctetString(impl=tag_encode(impl)).decode(
-                encoded, ctx={"bered": True}
+                encoded + junk,
+                ctx={"bered": True},
             )
-            self.assertSequenceEqual(tail, b"")
+            self.assertSequenceEqual(tail, junk)
             self.assertSequenceEqual(bytes(obj), payload_expected)
             self.assertTrue(obj.bered)
+            self.assertEqual(obj.lenindef, lenindef_expected)
             self.assertEqual(len(encoded), obj.tlvlen)
 
+    @given(
+        integers(min_value=0),
+        decode_path_strat,
+    )
+    def test_ber_definite_too_short(self, offset, decode_path):
+        with assertRaisesRegex(self, DecodeError, "longer than data") as err:
+            OctetString().decode(
+                tag_encode(4, form=TagFormConstructed) + len_encode(1),
+                offset=offset,
+                decode_path=decode_path,
+                ctx={"bered": True},
+            )
+        self.assertEqual(err.exception.decode_path, decode_path)
+        self.assertEqual(err.exception.offset, offset)
+
+    @given(
+        integers(min_value=0),
+        decode_path_strat,
+        integers(min_value=1, max_value=3),
+    )
+    def test_ber_indefinite_no_eoc(self, offset, decode_path, chunks):
+        bs = OctetString(b"data").encode()
+        with self.assertRaises(NotEnoughData) as err:
+            OctetString().decode(
+                tag_encode(4, form=TagFormConstructed) + LENINDEF + chunks * bs,
+                offset=offset,
+                decode_path=decode_path,
+                ctx={"bered": True},
+            )
+        self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),))
+        self.assertEqual(err.exception.offset, offset + 1 + 1 + chunks * len(bs))
+
+    @given(
+        integers(min_value=0),
+        decode_path_strat,
+        integers(min_value=1, max_value=3),
+    )
+    def test_ber_definite_chunk_out_of_bounds(self, offset, decode_path, chunks):
+        bs = OctetString(b"data").encode()
+        bs_longer = OctetString(b"data-longer").encode()
+        with assertRaisesRegex(self, DecodeError, "chunk out of bounds") as err:
+            OctetString().decode(
+                (
+                    tag_encode(4, form=TagFormConstructed) +
+                    len_encode((chunks + 1) * len(bs)) +
+                    chunks * bs +
+                    bs_longer
+                ),
+                offset=offset,
+                decode_path=decode_path,
+                ctx={"bered": True},
+            )
+        self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),))
+        self.assertEqual(err.exception.offset, offset + 1 + 1 + chunks * len(bs))
+
 
 @composite
 def null_values_strategy(draw, do_expl=False):
@@ -1970,10 +2180,9 @@ class TestNull(CommonMixin, TestCase):
     @given(
         integers(min_value=31),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_tag(self, tag, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             Null().decode(
                 tag_encode(tag)[:-1],
@@ -1987,10 +2196,9 @@ class TestNull(CommonMixin, TestCase):
     @given(
         integers(min_value=128),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_len(self, l, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             Null().decode(
                 Null.tag_default + len_encode(l)[:-1],
@@ -2242,10 +2450,9 @@ class TestObjectIdentifier(CommonMixin, TestCase):
     @given(
         integers(min_value=31),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_tag(self, tag, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             ObjectIdentifier().decode(
                 tag_encode(tag)[:-1],
@@ -2259,10 +2466,9 @@ class TestObjectIdentifier(CommonMixin, TestCase):
     @given(
         integers(min_value=128),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_len(self, l, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             ObjectIdentifier().decode(
                 ObjectIdentifier.tag_default + len_encode(l)[:-1],
@@ -2877,10 +3083,9 @@ class StringMixin(object):
     @given(
         integers(min_value=31),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_tag(self, tag, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             self.base_klass().decode(
                 tag_encode(tag)[:-1],
@@ -2894,10 +3099,9 @@ class StringMixin(object):
     @given(
         integers(min_value=128),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_len(self, l, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             self.base_klass().decode(
                 self.base_klass.tag_default + len_encode(l)[:-1],
@@ -2911,10 +3115,9 @@ class StringMixin(object):
     @given(
         sets(integers(min_value=0, max_value=10), min_size=2, max_size=2),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         value, bound_min = list(sorted(ints))
 
         class String(self.base_klass):
@@ -3012,10 +3215,9 @@ class TestNumericString(StringMixin, CommonMixin, TestCase):
     @given(
         sets(integers(min_value=0, max_value=10), min_size=2, max_size=2),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         value, bound_min = list(sorted(ints))
 
         class String(self.base_klass):
@@ -3085,24 +3287,29 @@ class TestVisibleString(
     base_klass = VisibleString
 
     def test_x690_vector(self):
-        self.assertEqual(
-            str(VisibleString().decode(hexdec("1A054A6F6E6573"))[0]),
-            "Jones",
-        )
-        self.assertEqual(
-            str(VisibleString().decode(
-                hexdec("3A0904034A6F6E04026573"),
-                ctx={"bered": True},
-            )[0]),
-            "Jones",
+        obj, tail = VisibleString().decode(hexdec("1A054A6F6E6573"))
+        self.assertSequenceEqual(tail, b"")
+        self.assertEqual(str(obj), "Jones")
+        self.assertFalse(obj.bered)
+        self.assertFalse(obj.lenindef)
+
+        obj, tail = VisibleString().decode(
+            hexdec("3A0904034A6F6E04026573"),
+            ctx={"bered": True},
         )
-        self.assertEqual(
-            str(VisibleString().decode(
-                hexdec("3A8004034A6F6E040265730000"),
-                ctx={"bered": True},
-            )[0]),
-            "Jones",
+        self.assertSequenceEqual(tail, b"")
+        self.assertEqual(str(obj), "Jones")
+        self.assertTrue(obj.bered)
+        self.assertFalse(obj.lenindef)
+
+        obj, tail = VisibleString().decode(
+            hexdec("3A8004034A6F6E040265730000"),
+            ctx={"bered": True},
         )
+        self.assertSequenceEqual(tail, b"")
+        self.assertEqual(str(obj), "Jones")
+        self.assertTrue(obj.bered)
+        self.assertTrue(obj.lenindef)
 
 
 class TestGeneralString(
@@ -3605,10 +3812,9 @@ class TestAny(CommonMixin, TestCase):
     @given(
         integers(min_value=31),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_tag(self, tag, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             Any().decode(
                 tag_encode(tag)[:-1],
@@ -3622,10 +3828,9 @@ class TestAny(CommonMixin, TestCase):
     @given(
         integers(min_value=128),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_len(self, l, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             Any().decode(
                 Any.tag_default + len_encode(l)[:-1],
@@ -3685,6 +3890,40 @@ class TestAny(CommonMixin, TestCase):
             self.assertEqual(obj_decoded.llen, 0)
             self.assertEqual(obj_decoded.vlen, len(value))
 
+    @given(
+        integers(min_value=1).map(tag_ctxc),
+        integers(min_value=0, max_value=3),
+        integers(min_value=0),
+        decode_path_strat,
+        binary(),
+    )
+    def test_indefinite(self, expl, chunks, offset, decode_path, junk):
+        chunk = Boolean(False, expl=expl).encode()
+        encoded = (
+            OctetString.tag_default +
+            LENINDEF +
+            b"".join([chunk] * chunks) +
+            EOC
+        )
+        obj, tail = Any().decode(
+            encoded + junk,
+            offset=offset,
+            decode_path=decode_path,
+            ctx={"bered": True},
+        )
+        self.assertSequenceEqual(tail, junk)
+        self.assertEqual(obj.offset, offset)
+        self.assertEqual(obj.tlvlen, len(encoded))
+        with self.assertRaises(NotEnoughData) as err:
+            Any().decode(
+                encoded[:-1],
+                offset=offset,
+                decode_path=decode_path,
+                ctx={"bered": True},
+            )
+        self.assertEqual(err.exception.offset, offset + 1 + 1 + len(chunk) * chunks)
+        self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),))
+
 
 @composite
 def choice_values_strategy(draw, value_required=False, schema=None, do_expl=False):
@@ -4351,10 +4590,9 @@ class SeqMixing(object):
     @given(
         integers(min_value=31),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_tag(self, tag, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             self.base_klass().decode(
                 tag_encode(tag)[:-1],
@@ -4368,10 +4606,9 @@ class SeqMixing(object):
     @given(
         integers(min_value=128),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_len(self, l, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             self.base_klass().decode(
                 self.base_klass.tag_default + len_encode(l)[:-1],
@@ -4407,26 +4644,49 @@ class SeqMixing(object):
         self._assert_expects(seq, expects)
         repr(seq)
         pprint(seq)
+        self.assertTrue(seq.ready)
         seq_encoded = seq.encode()
         seq_decoded, tail = seq.decode(seq_encoded + tail_junk)
-        self.assertEqual(tail, tail_junk)
-        self.assertTrue(seq.ready)
-        self._assert_expects(seq_decoded, expects)
-        self.assertEqual(seq, seq_decoded)
-        self.assertEqual(seq_decoded.encode(), seq_encoded)
-        for expect in expects:
-            if not expect["presented"]:
-                self.assertNotIn(expect["name"], seq_decoded)
-                continue
-            self.assertIn(expect["name"], seq_decoded)
-            obj = seq_decoded[expect["name"]]
-            self.assertTrue(obj.decoded)
-            offset = obj.expl_offset if obj.expled else obj.offset
-            tlvlen = obj.expl_tlvlen if obj.expled else obj.tlvlen
-            self.assertSequenceEqual(
-                seq_encoded[offset:offset + tlvlen],
-                obj.encode(),
-            )
+        self.assertFalse(seq_decoded.lenindef)
+
+        t, _, lv = tag_strip(seq_encoded)
+        _, _, v = len_decode(lv)
+        seq_encoded_lenindef = t + LENINDEF + v + EOC
+        seq_decoded_lenindef, tail_lenindef = seq.decode(
+            seq_encoded_lenindef + tail_junk,
+            ctx={"bered": True},
+        )
+        self.assertTrue(seq_decoded_lenindef.lenindef)
+        with self.assertRaises(DecodeError):
+            seq.decode(seq_encoded_lenindef[:-1], ctx={"bered": True})
+        with self.assertRaises(DecodeError):
+            seq.decode(seq_encoded_lenindef[:-2], ctx={"bered": True})
+        repr(seq_decoded_lenindef)
+        pprint(seq_decoded_lenindef)
+        self.assertTrue(seq_decoded_lenindef.ready)
+
+        for decoded, decoded_tail, encoded in (
+                (seq_decoded, tail, seq_encoded),
+                (seq_decoded_lenindef, tail_lenindef, seq_encoded_lenindef),
+        ):
+            self.assertEqual(decoded_tail, tail_junk)
+            self._assert_expects(decoded, expects)
+            self.assertEqual(seq, decoded)
+            self.assertEqual(decoded.encode(), seq_encoded)
+            self.assertEqual(decoded.tlvlen, len(encoded))
+            for expect in expects:
+                if not expect["presented"]:
+                    self.assertNotIn(expect["name"], decoded)
+                    continue
+                self.assertIn(expect["name"], decoded)
+                obj = decoded[expect["name"]]
+                self.assertTrue(obj.decoded)
+                offset = obj.expl_offset if obj.expled else obj.offset
+                tlvlen = obj.expl_tlvlen if obj.expled else obj.tlvlen
+                self.assertSequenceEqual(
+                    seq_encoded[offset:offset + tlvlen],
+                    obj.encode(),
+                )
 
     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
     @given(data_strategy())
@@ -4904,10 +5164,9 @@ class SeqOfMixing(object):
     @given(
         integers(min_value=31),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_tag(self, tag, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             self.base_klass().decode(
                 tag_encode(tag)[:-1],
@@ -4921,10 +5180,9 @@ class SeqOfMixing(object):
     @given(
         integers(min_value=128),
         integers(min_value=0),
-        lists(integers()),
+        decode_path_strat,
     )
     def test_bad_len(self, l, offset, decode_path):
-        decode_path = tuple(str(i) for i in decode_path)
         with self.assertRaises(DecodeError) as err:
             self.base_klass().decode(
                 self.base_klass.tag_default + len_encode(l)[:-1],
@@ -5001,6 +5259,22 @@ class SeqOfMixing(object):
                 ],
             )
 
+        t, _, lv = tag_strip(obj_encoded)
+        _, _, v = len_decode(lv)
+        obj_encoded_lenindef = t + LENINDEF + v + EOC
+        obj_decoded_lenindef, tail_lenindef = obj.decode(
+            obj_encoded_lenindef + tail_junk,
+            ctx={"bered": True},
+        )
+        self.assertTrue(obj_decoded_lenindef.lenindef)
+        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[:-1], ctx={"bered": True})
+        with self.assertRaises(DecodeError):
+            obj.decode(obj_encoded_lenindef[:-2], ctx={"bered": True})
+
 
 class TestSequenceOf(SeqOfMixing, CommonMixin, TestCase):
     class SeqOf(SequenceOf):