BER Boolean support

[pyderasn.git] / tests / test_pyderasn.py

diff --git a/tests/test_pyderasn.py b/tests/test_pyderasn.py
index 723020c4820802e2970d87712bbb879a36146ece..a44906838ea9af54a14729fc75409a8ae1e92854 100644 (file)
--- a/tests/test_pyderasn.py
+++ b/tests/test_pyderasn.py
@@ -285,7 +285,7 @@ class CommonMixin(object):
         with self.assertRaises(ValueError):
             self.base_klass(impl=b"whatever", expl=b"whenever")
 
-    @given(binary(), integers(), integers(), integers())
+    @given(binary(min_size=1), integers(), integers(), integers())
     def test_decoded(self, impl, offset, llen, vlen):
         obj = self.base_klass(impl=impl, _decoded=(offset, llen, vlen))
         self.assertEqual(obj.offset, offset)
@@ -294,7 +294,7 @@ class CommonMixin(object):
         self.assertEqual(obj.tlen, len(impl))
         self.assertEqual(obj.tlvlen, obj.tlen + obj.llen + obj.vlen)
 
-    @given(binary())
+    @given(binary(min_size=1))
     def test_impl_inherited(self, impl_tag):
         class Inherited(self.base_klass):
             impl = impl_tag
@@ -587,13 +587,23 @@ class TestBoolean(CommonMixin, TestCase):
             )))
 
     @given(integers(min_value=0 + 1, max_value=255 - 1))
-    def test_invalid_value(self, value):
+    def test_ber_value(self, value):
         with assertRaisesRegex(self, DecodeError, "unacceptable Boolean value"):
             Boolean().decode(b"".join((
                 Boolean.tag_default,
                 len_encode(1),
                 int2byte(value),
             )))
+        obj, _ = Boolean().decode(
+            b"".join((
+                Boolean.tag_default,
+                len_encode(1),
+                int2byte(value),
+            )),
+            ctx={"bered": True},
+        )
+        self.assertTrue(bool(obj))
+        self.assertTrue(obj.bered)
 
 
 @composite
@@ -1138,8 +1148,8 @@ class TestBitString(CommonMixin, TestCase):
     @given(
         tuples(integers(min_value=0), binary()),
         tuples(integers(min_value=0), binary()),
-        binary(),
-        binary(),
+        binary(min_size=1),
+        binary(min_size=1),
     )
     def test_comparison(self, value1, value2, tag1, tag2):
         for klass in (BitString, BitStringInherited):
@@ -1451,7 +1461,7 @@ class TestOctetString(CommonMixin, TestCase):
         repr(obj)
         pprint(obj)
 
-    @given(binary(), binary(), binary(), binary())
+    @given(binary(), binary(), binary(min_size=1), binary(min_size=1))
     def test_comparison(self, value1, value2, tag1, tag2):
         for klass in (OctetString, OctetStringInherited):
             obj1 = klass(value1)
@@ -2240,6 +2250,12 @@ class TestObjectIdentifier(CommonMixin, TestCase):
                 data,
             )))
 
+    def test_x690_vector(self):
+        self.assertEqual(
+            ObjectIdentifier().decode(hexdec("0603883703"))[0],
+            ObjectIdentifier((2, 999, 3)),
+        )
+
 
 @composite
 def enumerated_values_strategy(draw, schema=None, do_expl=False):
@@ -2555,8 +2571,8 @@ class StringMixin(object):
     def test_comparison(self, d):
         value1 = d.draw(text(alphabet=self.text_alphabet()))
         value2 = d.draw(text(alphabet=self.text_alphabet()))
-        tag1 = d.draw(binary())
-        tag2 = d.draw(binary())
+        tag1 = d.draw(binary(min_size=1))
+        tag2 = d.draw(binary(min_size=1))
         obj1 = self.base_klass(value1)
         obj2 = self.base_klass(value2)
         self.assertEqual(obj1 == obj2, value1 == value2)
@@ -2901,6 +2917,26 @@ 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",
+        )
+        self.assertEqual(
+            str(VisibleString().decode(
+                hexdec("3A8004034A6F6E040265730000"),
+                ctx={"bered": True},
+            )[0]),
+            "Jones",
+        )
+
 
 class TestGeneralString(
         UnicodeDecodeErrorMixin,
@@ -2993,8 +3029,8 @@ class TimeMixin(object):
             min_value=self.min_datetime,
             max_value=self.max_datetime,
         ))
-        tag1 = d.draw(binary())
-        tag2 = d.draw(binary())
+        tag1 = d.draw(binary(min_size=1))
+        tag2 = d.draw(binary(min_size=1))
         if self.omit_ms:
             value1 = value1.replace(microsecond=0)
             value2 = value2.replace(microsecond=0)
@@ -3967,7 +4003,7 @@ def sequences_strategy(draw, seq_klass):
 class SeqMixing(object):
     def test_invalid_value_type(self):
         with self.assertRaises(InvalidValueType) as err:
-            self.base_klass((1, 2, 3))
+            self.base_klass(123)
         repr(err.exception)
 
     def test_invalid_value_type_set(self):
@@ -4369,6 +4405,16 @@ class TestSequence(SeqMixing, CommonMixin, TestCase):
             seq[missing] = Boolean()
         repr(err.exception)
 
+    def test_x690_vector(self):
+        class Seq(Sequence):
+            schema = (
+                ("name", IA5String()),
+                ("ok", Boolean()),
+            )
+        seq = Seq().decode(hexdec("300A1605536d6974680101FF"))[0]
+        self.assertEqual(seq["name"], "Smith")
+        self.assertEqual(seq["ok"], True)
+
 
 class TestSet(SeqMixing, CommonMixin, TestCase):
     base_klass = Set
@@ -5285,3 +5331,42 @@ class TestStrictDefaultExistence(TestCase):
         seq.decode(raw)
         with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
             seq.decode(raw, ctx={"strict_default_existence": True})
+
+
+class TestX690PrefixedType(TestCase):
+    def runTest(self):
+        self.assertSequenceEqual(
+            VisibleString("Jones").encode(),
+            hexdec("1A054A6F6E6573"),
+        )
+        self.assertSequenceEqual(
+            VisibleString(
+                "Jones",
+                impl=tag_encode(3, klass=TagClassApplication),
+            ).encode(),
+            hexdec("43054A6F6E6573"),
+        )
+        self.assertSequenceEqual(
+            Any(
+                VisibleString(
+                    "Jones",
+                    impl=tag_encode(3, klass=TagClassApplication),
+                ),
+                expl=tag_ctxc(2),
+            ).encode(),
+            hexdec("A20743054A6F6E6573"),
+        )
+        self.assertSequenceEqual(
+            OctetString(
+                VisibleString(
+                    "Jones",
+                    impl=tag_encode(3, klass=TagClassApplication),
+                ).encode(),
+                impl=tag_encode(7, form=TagFormConstructed, klass=TagClassApplication),
+            ).encode(),
+            hexdec("670743054A6F6E6573"),
+        )
+        self.assertSequenceEqual(
+            VisibleString("Jones", impl=tag_ctxp(2)).encode(),
+            hexdec("82054A6F6E6573"),
+        )