Separate ber/ber_encoded attributes

[pyderasn.git] / tests / test_pyderasn.py

diff --git a/tests/test_pyderasn.py b/tests/test_pyderasn.py
index 0ce2b31bd0433a2b6cacbabf80542cef1b57dd27..dd3506b88c3216a221fe15096ccdc1d8c8fbf9ff 100644 (file)
--- a/tests/test_pyderasn.py
+++ b/tests/test_pyderasn.py
@@ -608,8 +608,9 @@ class TestBoolean(CommonMixin, TestCase):
             ctx={"bered": True},
         )
         self.assertTrue(bool(obj))
-        self.assertTrue(obj.bered)
+        self.assertTrue(obj.ber_encoded)
         self.assertFalse(obj.lenindef)
+        self.assertTrue(obj.bered)
 
     @given(
         integers(min_value=1).map(tag_ctxc),
@@ -624,6 +625,9 @@ class TestBoolean(CommonMixin, TestCase):
             ctx={"bered": True},
         )
         self.assertTrue(obj.expl_lenindef)
+        self.assertFalse(obj.lenindef)
+        self.assertFalse(obj.ber_encoded)
+        self.assertTrue(obj.bered)
         self.assertSequenceEqual(tail, junk)
 
     @given(
@@ -657,9 +661,10 @@ class TestBoolean(CommonMixin, TestCase):
                     v.expl_tlvlen,
                     v.expl_tlen,
                     v.expl_llen,
-                    v.bered,
+                    v.ber_encoded,
                     v.lenindef,
                     v.expl_lenindef,
+                    v.bered,
                 ) for v in seqof
             ),
             set(((
@@ -670,6 +675,7 @@ class TestBoolean(CommonMixin, TestCase):
                 False,
                 False,
                 True,
+                True,
             ),)),
         )
 
@@ -1538,8 +1544,9 @@ class TestBitString(CommonMixin, TestCase):
             self.assertSequenceEqual(tail, junk)
             self.assertEqual(obj.bit_len, bit_len_expected)
             self.assertSequenceEqual(bytes(obj), payload_expected)
-            self.assertTrue(obj.bered)
+            self.assertTrue(obj.ber_encoded)
             self.assertEqual(obj.lenindef, lenindef_expected)
+            self.assertTrue(obj.bered)
             self.assertEqual(len(encoded), obj.tlvlen)
 
     @given(
@@ -1669,8 +1676,9 @@ class TestBitString(CommonMixin, TestCase):
         )
         self.assertSequenceEqual(tail, b"")
         self.assertEqual(obj, vector)
-        self.assertTrue(obj.bered)
+        self.assertTrue(obj.ber_encoded)
         self.assertTrue(obj.lenindef)
+        self.assertTrue(obj.bered)
 
 
 @composite
@@ -2047,8 +2055,9 @@ class TestOctetString(CommonMixin, TestCase):
             )
             self.assertSequenceEqual(tail, junk)
             self.assertSequenceEqual(bytes(obj), payload_expected)
-            self.assertTrue(obj.bered)
+            self.assertTrue(obj.ber_encoded)
             self.assertEqual(obj.lenindef, lenindef_expected)
+            self.assertTrue(obj.bered)
             self.assertEqual(len(encoded), obj.tlvlen)
 
     @given(
@@ -3322,8 +3331,9 @@ class TestVisibleString(
         obj, tail = VisibleString().decode(hexdec("1A054A6F6E6573"))
         self.assertSequenceEqual(tail, b"")
         self.assertEqual(str(obj), "Jones")
-        self.assertFalse(obj.bered)
+        self.assertFalse(obj.ber_encoded)
         self.assertFalse(obj.lenindef)
+        self.assertFalse(obj.bered)
 
         obj, tail = VisibleString().decode(
             hexdec("3A0904034A6F6E04026573"),
@@ -3331,8 +3341,9 @@ class TestVisibleString(
         )
         self.assertSequenceEqual(tail, b"")
         self.assertEqual(str(obj), "Jones")
-        self.assertTrue(obj.bered)
+        self.assertTrue(obj.ber_encoded)
         self.assertFalse(obj.lenindef)
+        self.assertTrue(obj.bered)
 
         obj, tail = VisibleString().decode(
             hexdec("3A8004034A6F6E040265730000"),
@@ -3340,8 +3351,9 @@ class TestVisibleString(
         )
         self.assertSequenceEqual(tail, b"")
         self.assertEqual(str(obj), "Jones")
-        self.assertTrue(obj.bered)
+        self.assertTrue(obj.ber_encoded)
         self.assertTrue(obj.lenindef)
+        self.assertTrue(obj.bered)
 
 
 class TestGeneralString(
@@ -4009,6 +4021,9 @@ class TestAny(CommonMixin, TestCase):
         self.assertSequenceEqual(tail, junk)
         self.assertEqual(obj.offset, offset)
         self.assertEqual(obj.tlvlen, len(encoded))
+        self.assertTrue(obj.lenindef)
+        self.assertFalse(obj.ber_encoded)
+        self.assertTrue(obj.bered)
         with self.assertRaises(NotEnoughData) as err:
             Any().decode(
                 encoded[:-1],
@@ -4749,6 +4764,7 @@ class SeqMixing(object):
         seq_encoded = seq.encode()
         seq_decoded, tail = seq.decode(seq_encoded + tail_junk)
         self.assertFalse(seq_decoded.lenindef)
+        self.assertFalse(seq_decoded.ber_encoded)
         self.assertFalse(seq_decoded.bered)
 
         t, _, lv = tag_strip(seq_encoded)
@@ -4759,6 +4775,7 @@ class SeqMixing(object):
             ctx={"bered": True},
         )
         self.assertTrue(seq_decoded_lenindef.lenindef)
+        self.assertTrue(seq_decoded_lenindef.bered)
         with self.assertRaises(DecodeError):
             seq.decode(seq_encoded_lenindef[:-1], ctx={"bered": True})
         with self.assertRaises(DecodeError):
@@ -4873,6 +4890,7 @@ class SeqMixing(object):
             seq_with_default.decode(seq_encoded)
         for ctx in ({"bered": True}, {"allow_default_values": True}):
             seq_decoded, _ = seq_with_default.decode(seq_encoded, ctx=ctx)
+            self.assertTrue(seq_decoded.ber_encoded)
             self.assertTrue(seq_decoded.bered)
             for name, value in _schema:
                 self.assertEqual(seq_decoded[name], seq_with_default[name])
@@ -4902,6 +4920,31 @@ class SeqMixing(object):
         with self.assertRaises(TagMismatch):
             seq_missing.decode(seq_encoded)
 
+    @given(data_strategy())
+    def test_bered(self, d):
+        class Seq(self.base_klass):
+            schema = (("underlying", Boolean()),)
+        encoded = Boolean.tag_default + len_encode(1) + b"\x01"
+        encoded = Seq.tag_default + len_encode(len(encoded)) + encoded
+        decoded, _ = Seq().decode(encoded, ctx={"bered": True})
+        self.assertFalse(decoded.ber_encoded)
+        self.assertFalse(decoded.lenindef)
+        self.assertTrue(decoded.bered)
+
+        class Seq(self.base_klass):
+            schema = (("underlying", OctetString()),)
+        encoded = (
+            tag_encode(form=TagFormConstructed, num=4) +
+            LENINDEF +
+            OctetString(b"whatever").encode() +
+            EOC
+        )
+        encoded = Seq.tag_default + len_encode(len(encoded)) + encoded
+        decoded, _ = Seq().decode(encoded, ctx={"bered": True})
+        self.assertFalse(decoded.ber_encoded)
+        self.assertFalse(decoded.lenindef)
+        self.assertTrue(decoded.bered)
+
 
 class TestSequence(SeqMixing, CommonMixin, TestCase):
     base_klass = Sequence
@@ -4995,6 +5038,7 @@ class TestSet(SeqMixing, CommonMixin, TestCase):
             seq.decode(seq_encoded)
         for ctx in ({"bered": True}, {"allow_unordered_set": True}):
             seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
+            self.assertTrue(seq_decoded.ber_encoded)
             self.assertTrue(seq_decoded.bered)
             self.assertSequenceEqual(
                 [bytes(seq_decoded[str(i)]) for i, t in enumerate(tags)],
@@ -5412,6 +5456,7 @@ class SeqOfMixing(object):
             ctx={"bered": True},
         )
         self.assertTrue(obj_decoded_lenindef.lenindef)
+        self.assertTrue(obj_decoded_lenindef.bered)
         repr(obj_decoded_lenindef)
         pprint(obj_decoded_lenindef)
         self.assertEqual(obj_decoded_lenindef.tlvlen, len(obj_encoded_lenindef))
@@ -5420,6 +5465,33 @@ class SeqOfMixing(object):
         with self.assertRaises(DecodeError):
             obj.decode(obj_encoded_lenindef[:-2], ctx={"bered": True})
 
+    @given(data_strategy())
+    def test_bered(self, d):
+        class SeqOf(self.base_klass):
+            schema = Boolean()
+        encoded = Boolean(False).encode()
+        encoded += Boolean.tag_default + len_encode(1) + b"\x01"
+        encoded = SeqOf.tag_default + len_encode(len(encoded)) + encoded
+        decoded, _ = SeqOf().decode(encoded, ctx={"bered": True})
+        self.assertFalse(decoded.ber_encoded)
+        self.assertFalse(decoded.lenindef)
+        self.assertTrue(decoded.bered)
+
+        class SeqOf(self.base_klass):
+            schema = OctetString()
+        encoded = OctetString(b"whatever").encode()
+        encoded += (
+            tag_encode(form=TagFormConstructed, num=4) +
+            LENINDEF +
+            OctetString(b"whatever").encode() +
+            EOC
+        )
+        encoded = SeqOf.tag_default + len_encode(len(encoded)) + encoded
+        decoded, _ = SeqOf().decode(encoded, ctx={"bered": True})
+        self.assertFalse(decoded.ber_encoded)
+        self.assertFalse(decoded.lenindef)
+        self.assertTrue(decoded.bered)
+
 
 class TestSequenceOf(SeqOfMixing, CommonMixin, TestCase):
     class SeqOf(SequenceOf):
@@ -5482,6 +5554,7 @@ class TestSetOf(SeqOfMixing, CommonMixin, TestCase):
 
         for ctx in ({"bered": True}, {"allow_unordered_set": True}):
             seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
+            self.assertTrue(seq_decoded.ber_encoded)
             self.assertTrue(seq_decoded.bered)
             self.assertSequenceEqual(
                 [obj.encode() for obj in seq_decoded],
@@ -5948,8 +6021,10 @@ class TestStrictDefaultExistence(TestCase):
             with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
                 seq.decode(raw)
             decoded, _ = seq.decode(raw, ctx={"allow_default_values": True})
+            self.assertTrue(decoded.ber_encoded)
             self.assertTrue(decoded.bered)
             decoded, _ = seq.decode(raw, ctx={"bered": True})
+            self.assertTrue(decoded.ber_encoded)
             self.assertTrue(decoded.bered)