2 # PyDERASN -- Python ASN.1 DER/BER codec with abstract structures
3 # Copyright (C) 2017-2020 Sergey Matveev <stargrave@stargrave.org>
5 # This program is free software: you can redistribute it and/or modify
6 # it under the terms of the GNU Lesser General Public License as
7 # published by the Free Software Foundation, version 3 of the License.
9 # This program is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 # GNU Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this program. If not, see
16 # <http://www.gnu.org/licenses/>.
19 from copy import deepcopy
20 from datetime import datetime
21 from datetime import timedelta
22 from importlib import import_module
23 from random import random
24 from string import ascii_letters
25 from string import digits
26 from string import printable
27 from string import whitespace
28 from time import mktime
30 from unittest import TestCase
32 from hypothesis import assume
33 from hypothesis import given
34 from hypothesis import settings
35 from hypothesis.strategies import binary
36 from hypothesis.strategies import booleans
37 from hypothesis.strategies import composite
38 from hypothesis.strategies import data as data_strategy
39 from hypothesis.strategies import datetimes
40 from hypothesis.strategies import dictionaries
41 from hypothesis.strategies import integers
42 from hypothesis.strategies import just
43 from hypothesis.strategies import lists
44 from hypothesis.strategies import none
45 from hypothesis.strategies import one_of
46 from hypothesis.strategies import permutations
47 from hypothesis.strategies import sampled_from
48 from hypothesis.strategies import sets
49 from hypothesis.strategies import text
50 from hypothesis.strategies import tuples
51 from six import assertRaisesRegex
52 from six import binary_type
53 from six import byte2int
54 from six import indexbytes
55 from six import int2byte
56 from six import iterbytes
58 from six import text_type
59 from six import unichr as six_unichr
60 from six.moves.cPickle import dumps as pickle_dumps
61 from six.moves.cPickle import HIGHEST_PROTOCOL as pickle_proto
62 from six.moves.cPickle import loads as pickle_loads
64 from pyderasn import _pp
65 from pyderasn import abs_decode_path
66 from pyderasn import Any
67 from pyderasn import BitString
68 from pyderasn import BMPString
69 from pyderasn import Boolean
70 from pyderasn import BoundsError
71 from pyderasn import Choice
72 from pyderasn import DecodeError
73 from pyderasn import DecodePathDefBy
74 from pyderasn import Enumerated
75 from pyderasn import EOC
76 from pyderasn import EOC_LEN
77 from pyderasn import ExceedingData
78 from pyderasn import GeneralizedTime
79 from pyderasn import GeneralString
80 from pyderasn import GraphicString
81 from pyderasn import hexdec
82 from pyderasn import hexenc
83 from pyderasn import IA5String
84 from pyderasn import Integer
85 from pyderasn import InvalidLength
86 from pyderasn import InvalidOID
87 from pyderasn import InvalidValueType
88 from pyderasn import len_decode
89 from pyderasn import len_encode
90 from pyderasn import LEN_YYMMDDHHMMSSZ
91 from pyderasn import LEN_YYYYMMDDHHMMSSDMZ
92 from pyderasn import LEN_YYYYMMDDHHMMSSZ
93 from pyderasn import LENINDEF
94 from pyderasn import LenIndefForm
95 from pyderasn import NotEnoughData
96 from pyderasn import Null
97 from pyderasn import NumericString
98 from pyderasn import ObjectIdentifier
99 from pyderasn import ObjNotReady
100 from pyderasn import ObjUnknown
101 from pyderasn import OctetString
102 from pyderasn import pp_console_row
103 from pyderasn import pprint
104 from pyderasn import PrintableString
105 from pyderasn import Sequence
106 from pyderasn import SequenceOf
107 from pyderasn import Set
108 from pyderasn import SetOf
109 from pyderasn import tag_ctxc
110 from pyderasn import tag_ctxp
111 from pyderasn import tag_decode
112 from pyderasn import tag_encode
113 from pyderasn import tag_strip
114 from pyderasn import TagClassApplication
115 from pyderasn import TagClassContext
116 from pyderasn import TagClassPrivate
117 from pyderasn import TagClassUniversal
118 from pyderasn import TagFormConstructed
119 from pyderasn import TagFormPrimitive
120 from pyderasn import TagMismatch
121 from pyderasn import TeletexString
122 from pyderasn import UniversalString
123 from pyderasn import UTCTime
124 from pyderasn import UTF8String
125 from pyderasn import VideotexString
126 from pyderasn import VisibleString
129 settings.register_profile("local", settings(
132 settings.load_profile("local")
133 LONG_TEST_MAX_EXAMPLES = settings().max_examples * 4
135 tag_classes = sampled_from((
141 tag_forms = sampled_from((TagFormConstructed, TagFormPrimitive))
142 decode_path_strat = lists(integers(), max_size=3).map(
143 lambda decode_path: tuple(str(dp) for dp in decode_path)
145 ctx_dummy = dictionaries(integers(), integers(), min_size=2, max_size=4).example()
148 lambda obj: pickle_loads(pickle_dumps(obj, pickle_proto)),
150 self_module = import_module(__name__)
153 def register_class(klass):
154 klassname = klass.__name__ + str(time()).replace(".", "")
155 klass.__name__ = klassname
156 klass.__qualname__ = klassname
157 setattr(self_module, klassname, klass)
160 def assert_exceeding_data(self, call, junk):
163 with assertRaisesRegex(self, ExceedingData, "%d trailing bytes" % len(junk)) as err:
168 class TestHex(TestCase):
170 def test_symmetric(self, data):
171 self.assertEqual(hexdec(hexenc(data)), data)
174 class TestTagCoder(TestCase):
175 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
179 integers(min_value=0, max_value=30),
182 def test_short(self, klass, form, num, junk):
183 raw = tag_encode(klass=klass, form=form, num=num)
184 self.assertEqual(tag_decode(raw), (klass, form, num))
185 self.assertEqual(len(raw), 1)
187 byte2int(tag_encode(klass=klass, form=form, num=0)),
188 byte2int(raw) & (1 << 7 | 1 << 6 | 1 << 5),
190 stripped, tlen, tail = tag_strip(memoryview(raw + junk))
191 self.assertSequenceEqual(stripped.tobytes(), raw)
192 self.assertEqual(tlen, len(raw))
193 self.assertSequenceEqual(tail, junk)
195 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
199 integers(min_value=31),
202 def test_long(self, klass, form, num, junk):
203 raw = tag_encode(klass=klass, form=form, num=num)
204 self.assertEqual(tag_decode(raw), (klass, form, num))
205 self.assertGreater(len(raw), 1)
207 byte2int(tag_encode(klass=klass, form=form, num=0)) | 31,
210 self.assertEqual(byte2int(raw[-1:]) & 0x80, 0)
211 self.assertTrue(all(b & 0x80 > 0 for b in iterbytes(raw[1:-1])))
212 stripped, tlen, tail = tag_strip(memoryview(raw + junk))
213 self.assertSequenceEqual(stripped.tobytes(), raw)
214 self.assertEqual(tlen, len(raw))
215 self.assertSequenceEqual(tail, junk)
217 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
218 @given(integers(min_value=31))
219 def test_unfinished_tag(self, num):
220 raw = bytearray(tag_encode(num=num))
221 for i in range(1, len(raw)):
223 with assertRaisesRegex(self, DecodeError, "unfinished tag"):
224 tag_strip(bytes(raw))
226 def test_go_vectors_valid(self):
227 for data, (eklass, etag, elen, eform) in (
228 (b"\x80\x01", (TagClassContext, 0, 1, TagFormPrimitive)),
229 (b"\xa0\x01", (TagClassContext, 0, 1, TagFormConstructed)),
230 (b"\x02\x00", (TagClassUniversal, 2, 0, TagFormPrimitive)),
231 (b"\xfe\x00", (TagClassPrivate, 30, 0, TagFormConstructed)),
232 (b"\x1f\x1f\x00", (TagClassUniversal, 31, 0, TagFormPrimitive)),
233 (b"\x1f\x81\x00\x00", (TagClassUniversal, 128, 0, TagFormPrimitive)),
234 (b"\x1f\x81\x80\x01\x00", (TagClassUniversal, 0x4001, 0, TagFormPrimitive)),
235 (b"\x00\x81\x80", (TagClassUniversal, 0, 128, TagFormPrimitive)),
236 (b"\x00\x82\x01\x00", (TagClassUniversal, 0, 256, TagFormPrimitive)),
237 (b"\xa0\x84\x7f\xff\xff\xff", (TagClassContext, 0, 0x7fffffff, TagFormConstructed)),
239 tag, _, len_encoded = tag_strip(memoryview(data))
240 klass, form, num = tag_decode(tag)
241 _len, _, tail = len_decode(len_encoded)
242 self.assertSequenceEqual(tail, b"")
243 self.assertEqual(klass, eklass)
244 self.assertEqual(num, etag)
245 self.assertEqual(_len, elen)
246 self.assertEqual(form, eform)
248 def test_go_vectors_invalid(self):
256 with self.assertRaises(DecodeError):
257 _, _, len_encoded = tag_strip(memoryview(data))
258 len_decode(len_encoded)
261 integers(min_value=0, max_value=127),
262 integers(min_value=0, max_value=2),
264 def test_long_instead_of_short(self, l, dummy_num):
265 octets = (b"\x00" * dummy_num) + int2byte(l)
266 octets = int2byte((dummy_num + 1) | 0x80) + octets
267 with self.assertRaises(DecodeError):
271 class TestLenCoder(TestCase):
272 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
274 integers(min_value=0, max_value=127),
277 def test_short(self, l, junk):
278 raw = len_encode(l) + junk
279 decoded, llen, tail = len_decode(memoryview(raw))
280 self.assertEqual(decoded, l)
281 self.assertEqual(llen, 1)
282 self.assertEqual(len(raw), 1 + len(junk))
283 self.assertEqual(tail.tobytes(), junk)
285 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
287 integers(min_value=128),
290 def test_long(self, l, junk):
291 raw = len_encode(l) + junk
292 decoded, llen, tail = len_decode(memoryview(raw))
293 self.assertEqual(decoded, l)
294 self.assertEqual((llen - 1) | 0x80, byte2int(raw))
295 self.assertEqual(llen, len(raw) - len(junk))
296 self.assertNotEqual(indexbytes(raw, 1), 0)
297 self.assertSequenceEqual(tail.tobytes(), junk)
299 def test_empty(self):
300 with self.assertRaises(NotEnoughData):
303 @given(integers(min_value=128))
304 def test_stripped(self, _len):
305 with self.assertRaises(NotEnoughData):
306 len_decode(len_encode(_len)[:-1])
309 text_printable = text(alphabet=printable, min_size=1)
313 def text_letters(draw):
314 result = draw(text(alphabet=ascii_letters, min_size=1))
316 result = result.encode("ascii")
320 class CommonMixin(object):
321 def test_tag_default(self):
322 obj = self.base_klass()
323 self.assertEqual(obj.tag, obj.tag_default)
325 def test_simultaneous_impl_expl(self):
326 with self.assertRaises(ValueError):
327 self.base_klass(impl=b"whatever", expl=b"whenever")
329 @given(binary(min_size=1), integers(), integers(), integers())
330 def test_decoded(self, impl, offset, llen, vlen):
331 obj = self.base_klass(impl=impl, _decoded=(offset, llen, vlen))
332 self.assertEqual(obj.offset, offset)
333 self.assertEqual(obj.llen, llen)
334 self.assertEqual(obj.vlen, vlen)
335 self.assertEqual(obj.tlen, len(impl))
336 self.assertEqual(obj.tlvlen, obj.tlen + obj.llen + obj.vlen)
338 @given(binary(min_size=1))
339 def test_impl_inherited(self, impl_tag):
340 class Inherited(self.base_klass):
343 self.assertSequenceEqual(obj.impl, impl_tag)
344 self.assertFalse(obj.expled)
347 def test_expl_inherited(self, expl_tag):
348 class Inherited(self.base_klass):
351 self.assertSequenceEqual(obj.expl, expl_tag)
352 self.assertTrue(obj.expled)
354 def assert_copied_basic_fields(self, obj, obj_copied):
355 self.assertEqual(obj, obj_copied)
356 self.assertSequenceEqual(obj.tag, obj_copied.tag)
357 self.assertEqual(obj.expl_tag, obj_copied.expl_tag)
358 self.assertEqual(obj.default, obj_copied.default)
359 self.assertEqual(obj.optional, obj_copied.optional)
360 self.assertEqual(obj.offset, obj_copied.offset)
361 self.assertEqual(obj.llen, obj_copied.llen)
362 self.assertEqual(obj.vlen, obj_copied.vlen)
366 def boolean_values_strategy(draw, do_expl=False):
367 value = draw(one_of(none(), booleans()))
371 expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
373 impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
374 default = draw(one_of(none(), booleans()))
375 optional = draw(one_of(none(), booleans()))
377 draw(integers(min_value=0)),
378 draw(integers(min_value=0)),
379 draw(integers(min_value=0)),
381 return (value, impl, expl, default, optional, _decoded)
384 class BooleanInherited(Boolean):
388 class TestBoolean(CommonMixin, TestCase):
391 def test_invalid_value_type(self):
392 with self.assertRaises(InvalidValueType) as err:
397 def test_optional(self, optional):
398 obj = Boolean(default=Boolean(False), optional=optional)
399 self.assertTrue(obj.optional)
402 def test_ready(self, value):
404 self.assertFalse(obj.ready)
407 pprint(obj, big_blobs=True, with_decode_path=True)
408 with self.assertRaises(ObjNotReady) as err:
412 self.assertTrue(obj.ready)
415 pprint(obj, big_blobs=True, with_decode_path=True)
417 @given(booleans(), booleans(), binary(), binary())
418 def test_comparison(self, value1, value2, tag1, tag2):
419 for klass in (Boolean, BooleanInherited):
422 self.assertEqual(obj1 == obj2, value1 == value2)
423 self.assertEqual(obj1 != obj2, value1 != value2)
424 self.assertEqual(obj1 == bool(obj2), value1 == value2)
425 obj1 = klass(value1, impl=tag1)
426 obj2 = klass(value1, impl=tag2)
427 self.assertEqual(obj1 == obj2, tag1 == tag2)
428 self.assertEqual(obj1 != obj2, tag1 != tag2)
430 @given(data_strategy())
431 def test_call(self, d):
432 for klass in (Boolean, BooleanInherited):
440 ) = d.draw(boolean_values_strategy())
446 optional_initial or False,
456 ) = d.draw(boolean_values_strategy(do_expl=impl_initial is None))
457 obj = obj_initial(value, impl, expl, default, optional)
459 value_expected = default if value is None else value
461 default_initial if value_expected is None
464 self.assertEqual(obj, value_expected)
465 self.assertEqual(obj.tag, impl or impl_initial or obj.tag_default)
466 self.assertEqual(obj.expl_tag, expl or expl_initial)
469 default_initial if default is None else default,
471 if obj.default is None:
472 optional = optional_initial if optional is None else optional
473 optional = False if optional is None else optional
476 self.assertEqual(obj.optional, optional)
478 @given(boolean_values_strategy())
479 def test_copy(self, values):
480 for klass in (Boolean, BooleanInherited):
482 for copy_func in copy_funcs:
483 obj_copied = copy_func(obj)
484 self.assert_copied_basic_fields(obj, obj_copied)
488 integers(min_value=1).map(tag_encode),
490 def test_stripped(self, value, tag_impl):
491 obj = Boolean(value, impl=tag_impl)
492 with self.assertRaises(NotEnoughData):
493 obj.decode(obj.encode()[:-1])
497 integers(min_value=1).map(tag_ctxc),
499 def test_stripped_expl(self, value, tag_expl):
500 obj = Boolean(value, expl=tag_expl)
501 with self.assertRaises(NotEnoughData):
502 obj.decode(obj.encode()[:-1])
505 integers(min_value=31),
506 integers(min_value=0),
509 def test_bad_tag(self, tag, offset, decode_path):
510 with self.assertRaises(DecodeError) as err:
512 tag_encode(tag)[:-1],
514 decode_path=decode_path,
517 self.assertEqual(err.exception.offset, offset)
518 self.assertEqual(err.exception.decode_path, decode_path)
521 integers(min_value=31),
522 integers(min_value=0),
525 def test_bad_expl_tag(self, tag, offset, decode_path):
526 with self.assertRaises(DecodeError) as err:
527 Boolean(expl=Boolean.tag_default).decode(
528 tag_encode(tag)[:-1],
530 decode_path=decode_path,
533 self.assertEqual(err.exception.offset, offset)
534 self.assertEqual(err.exception.decode_path, decode_path)
537 integers(min_value=128),
538 integers(min_value=0),
541 def test_bad_len(self, l, offset, decode_path):
542 with self.assertRaises(DecodeError) as err:
544 Boolean.tag_default + len_encode(l)[:-1],
546 decode_path=decode_path,
549 self.assertEqual(err.exception.offset, offset)
550 self.assertEqual(err.exception.decode_path, decode_path)
553 integers(min_value=128),
554 integers(min_value=0),
557 def test_bad_expl_len(self, l, offset, decode_path):
558 with self.assertRaises(DecodeError) as err:
559 Boolean(expl=Boolean.tag_default).decode(
560 Boolean.tag_default + len_encode(l)[:-1],
562 decode_path=decode_path,
565 self.assertEqual(err.exception.offset, offset)
566 self.assertEqual(err.exception.decode_path, decode_path)
568 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
570 boolean_values_strategy(),
572 integers(min_value=1).map(tag_ctxc),
573 integers(min_value=0),
576 def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
577 for klass in (Boolean, BooleanInherited):
578 _, _, _, default, optional, _decoded = values
587 pprint(obj, big_blobs=True, with_decode_path=True)
588 self.assertFalse(obj.expled)
589 obj_encoded = obj.encode()
590 obj_expled = obj(value, expl=tag_expl)
591 self.assertTrue(obj_expled.expled)
593 list(obj_expled.pps())
594 pprint(obj_expled, big_blobs=True, with_decode_path=True)
595 obj_expled_hex_encoded = obj_expled.hexencode()
596 ctx_copied = deepcopy(ctx_dummy)
597 obj_decoded, tail = obj_expled.hexdecode(
598 obj_expled_hex_encoded + hexenc(tail_junk),
602 self.assertDictEqual(ctx_copied, ctx_dummy)
604 list(obj_decoded.pps())
605 pprint(obj_decoded, big_blobs=True, with_decode_path=True)
606 self.assertEqual(tail, tail_junk)
607 self.assertEqual(obj_decoded, obj_expled)
608 self.assertNotEqual(obj_decoded, obj)
609 self.assertEqual(bool(obj_decoded), bool(obj_expled))
610 self.assertEqual(bool(obj_decoded), bool(obj))
611 self.assertSequenceEqual(obj_decoded.hexencode(), obj_expled_hex_encoded)
612 self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
613 self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
615 obj_decoded.expl_llen,
616 len(len_encode(len(obj_encoded))),
618 self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
619 self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
622 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
624 self.assertEqual(obj_decoded.expl_offset, offset)
625 assert_exceeding_data(
627 lambda: obj_expled.hexdecod(obj_expled_hex_encoded + hexenc(tail_junk)),
631 @given(integers(min_value=2))
632 def test_invalid_len(self, l):
633 with self.assertRaises(InvalidLength):
634 Boolean().decode(b"".join((
640 @given(integers(min_value=0 + 1, max_value=255 - 1))
641 def test_ber_value(self, value):
642 with assertRaisesRegex(self, DecodeError, "unacceptable Boolean value"):
643 Boolean().decode(b"".join((
648 obj, _ = Boolean().decode(
656 self.assertTrue(bool(obj))
657 self.assertTrue(obj.ber_encoded)
658 self.assertFalse(obj.lenindef)
659 self.assertTrue(obj.bered)
661 self.assertTrue(obj.ber_encoded)
662 self.assertFalse(obj.lenindef)
663 self.assertTrue(obj.bered)
666 integers(min_value=1).map(tag_ctxc),
667 binary().filter(lambda x: not x.startswith(EOC)),
669 def test_ber_expl_no_eoc(self, expl, junk):
670 encoded = expl + LENINDEF + Boolean(False).encode()
671 with self.assertRaises(LenIndefForm):
672 Boolean(expl=expl).decode(encoded + junk)
673 with assertRaisesRegex(self, DecodeError, "no EOC"):
674 Boolean(expl=expl).decode(encoded + junk, ctx={"bered": True})
675 obj, tail = Boolean(expl=expl).decode(
676 encoded + EOC + junk,
679 self.assertTrue(obj.expl_lenindef)
680 self.assertFalse(obj.lenindef)
681 self.assertFalse(obj.ber_encoded)
682 self.assertTrue(obj.bered)
684 self.assertTrue(obj.expl_lenindef)
685 self.assertFalse(obj.lenindef)
686 self.assertFalse(obj.ber_encoded)
687 self.assertTrue(obj.bered)
688 self.assertSequenceEqual(tail, junk)
691 pprint(obj, big_blobs=True, with_decode_path=True)
694 integers(min_value=1).map(tag_ctxc),
701 def test_ber_expl(self, expl, values):
707 Boolean(value).encode() +
710 encoded = SequenceOf.tag_default + len_encode(len(encoded)) + encoded
712 class SeqOf(SequenceOf):
713 schema = Boolean(expl=expl)
714 with self.assertRaises(LenIndefForm):
715 SeqOf().decode(encoded)
716 seqof, tail = SeqOf().decode(encoded, ctx={"bered": True})
717 self.assertSequenceEqual(tail, b"")
718 self.assertSequenceEqual([bool(v) for v in seqof], values)
734 len(expl) + 1 + 3 + EOC_LEN,
745 pprint(seqof, big_blobs=True, with_decode_path=True)
749 def integer_values_strategy(draw, do_expl=False):
750 bound_min, value, default, bound_max = sorted(draw(sets(
759 _specs = draw(sets(text_letters()))
762 min_size=len(_specs),
763 max_size=len(_specs),
765 _specs = list(zip(_specs, values))
768 bounds = (bound_min, bound_max)
772 expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
774 impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
777 optional = draw(one_of(none(), booleans()))
779 draw(integers(min_value=0)),
780 draw(integers(min_value=0)),
781 draw(integers(min_value=0)),
783 return (value, bounds, impl, expl, default, optional, _specs, _decoded)
786 class IntegerInherited(Integer):
790 class TestInteger(CommonMixin, TestCase):
793 def test_invalid_value_type(self):
794 with self.assertRaises(InvalidValueType) as err:
798 @given(sets(text_letters(), min_size=2))
799 def test_unknown_name(self, names_input):
800 missing = names_input.pop()
803 schema = [(n, 123) for n in names_input]
804 with self.assertRaises(ObjUnknown) as err:
808 @given(sets(text_letters(), min_size=2))
809 def test_known_name(self, names_input):
811 schema = [(n, 123) for n in names_input]
812 Int(names_input.pop())
815 def test_optional(self, optional):
816 obj = Integer(default=Integer(0), optional=optional)
817 self.assertTrue(obj.optional)
820 def test_ready(self, value):
822 self.assertFalse(obj.ready)
825 pprint(obj, big_blobs=True, with_decode_path=True)
826 with self.assertRaises(ObjNotReady) as err:
830 self.assertTrue(obj.ready)
833 pprint(obj, big_blobs=True, with_decode_path=True)
836 @given(integers(), integers(), binary(), binary())
837 def test_comparison(self, value1, value2, tag1, tag2):
838 for klass in (Integer, IntegerInherited):
841 self.assertEqual(obj1 == obj2, value1 == value2)
842 self.assertEqual(obj1 != obj2, value1 != value2)
843 self.assertEqual(obj1 == int(obj2), value1 == value2)
844 obj1 = klass(value1, impl=tag1)
845 obj2 = klass(value1, impl=tag2)
846 self.assertEqual(obj1 == obj2, tag1 == tag2)
847 self.assertEqual(obj1 != obj2, tag1 != tag2)
849 @given(lists(integers()))
850 def test_sorted_works(self, values):
851 self.assertSequenceEqual(
852 [int(v) for v in sorted(Integer(v) for v in values)],
856 @given(data_strategy())
857 def test_named(self, d):
858 names_input = list(d.draw(sets(text_letters(), min_size=1)))
859 values_input = list(d.draw(sets(
861 min_size=len(names_input),
862 max_size=len(names_input),
864 chosen_name = d.draw(sampled_from(names_input))
865 names_input = dict(zip(names_input, values_input))
869 _int = Int(chosen_name)
870 self.assertEqual(_int.named, chosen_name)
871 self.assertEqual(int(_int), names_input[chosen_name])
873 @given(integers(), integers(min_value=0), integers(min_value=0))
874 def test_bounds_satisfied(self, bound_min, bound_delta, value_delta):
875 value = bound_min + value_delta
876 bound_max = value + bound_delta
877 Integer(value=value, bounds=(bound_min, bound_max))
879 @given(sets(integers(), min_size=3, max_size=3))
880 def test_bounds_unsatisfied(self, values):
881 values = sorted(values)
882 with self.assertRaises(BoundsError) as err:
883 Integer(value=values[0], bounds=(values[1], values[2]))
885 with assertRaisesRegex(self, DecodeError, "bounds") as err:
886 Integer(bounds=(values[1], values[2])).decode(
887 Integer(values[0]).encode()
890 with self.assertRaises(BoundsError) as err:
891 Integer(value=values[2], bounds=(values[0], values[1]))
893 with assertRaisesRegex(self, DecodeError, "bounds") as err:
894 Integer(bounds=(values[0], values[1])).decode(
895 Integer(values[2]).encode()
899 @given(data_strategy())
900 def test_call(self, d):
901 for klass in (Integer, IntegerInherited):
911 ) = d.draw(integer_values_strategy())
918 optional_initial or False,
931 ) = d.draw(integer_values_strategy(do_expl=impl_initial is None))
932 if (default is None) and (obj_initial.default is not None):
936 (value is not None) and
937 (bounds_initial is not None) and
938 not (bounds_initial[0] <= value <= bounds_initial[1])
943 (default is not None) and
944 (bounds_initial is not None) and
945 not (bounds_initial[0] <= default <= bounds_initial[1])
948 obj = obj_initial(value, bounds, impl, expl, default, optional)
950 value_expected = default if value is None else value
952 default_initial if value_expected is None
955 self.assertEqual(obj, value_expected)
956 self.assertEqual(obj.tag, impl or impl_initial or obj.tag_default)
957 self.assertEqual(obj.expl_tag, expl or expl_initial)
960 default_initial if default is None else default,
962 if obj.default is None:
963 optional = optional_initial if optional is None else optional
964 optional = False if optional is None else optional
967 self.assertEqual(obj.optional, optional)
969 (obj._bound_min, obj._bound_max),
970 bounds or bounds_initial or (float("-inf"), float("+inf")),
974 {} if _specs_initial is None else dict(_specs_initial),
977 @given(integer_values_strategy())
978 def test_copy(self, values):
979 for klass in (Integer, IntegerInherited):
981 for copy_func in copy_funcs:
982 obj_copied = copy_func(obj)
983 self.assert_copied_basic_fields(obj, obj_copied)
984 self.assertEqual(obj.specs, obj_copied.specs)
985 self.assertEqual(obj._bound_min, obj_copied._bound_min)
986 self.assertEqual(obj._bound_max, obj_copied._bound_max)
987 self.assertEqual(obj._value, obj_copied._value)
991 integers(min_value=1).map(tag_encode),
993 def test_stripped(self, value, tag_impl):
994 obj = Integer(value, impl=tag_impl)
995 with self.assertRaises(NotEnoughData):
996 obj.decode(obj.encode()[:-1])
1000 integers(min_value=1).map(tag_ctxc),
1002 def test_stripped_expl(self, value, tag_expl):
1003 obj = Integer(value, expl=tag_expl)
1004 with self.assertRaises(NotEnoughData):
1005 obj.decode(obj.encode()[:-1])
1007 def test_zero_len(self):
1008 with self.assertRaises(NotEnoughData):
1009 Integer().decode(b"".join((
1010 Integer.tag_default,
1015 integers(min_value=31),
1016 integers(min_value=0),
1019 def test_bad_tag(self, tag, offset, decode_path):
1020 with self.assertRaises(DecodeError) as err:
1022 tag_encode(tag)[:-1],
1024 decode_path=decode_path,
1027 self.assertEqual(err.exception.offset, offset)
1028 self.assertEqual(err.exception.decode_path, decode_path)
1031 integers(min_value=128),
1032 integers(min_value=0),
1035 def test_bad_len(self, l, offset, decode_path):
1036 with self.assertRaises(DecodeError) as err:
1038 Integer.tag_default + len_encode(l)[:-1],
1040 decode_path=decode_path,
1043 self.assertEqual(err.exception.offset, offset)
1044 self.assertEqual(err.exception.decode_path, decode_path)
1047 sets(integers(), min_size=2, max_size=2),
1048 integers(min_value=0),
1051 def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
1052 value, bound_min = list(sorted(ints))
1055 bounds = (bound_min, bound_min)
1056 with self.assertRaises(DecodeError) as err:
1058 Integer(value).encode(),
1060 decode_path=decode_path,
1063 self.assertEqual(err.exception.offset, offset)
1064 self.assertEqual(err.exception.decode_path, decode_path)
1066 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
1068 integer_values_strategy(),
1070 integers(min_value=1).map(tag_ctxc),
1071 integers(min_value=0),
1074 def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
1075 for klass in (Integer, IntegerInherited):
1076 _, _, _, _, default, optional, _, _decoded = values
1085 pprint(obj, big_blobs=True, with_decode_path=True)
1086 self.assertFalse(obj.expled)
1087 obj_encoded = obj.encode()
1088 obj_expled = obj(value, expl=tag_expl)
1089 self.assertTrue(obj_expled.expled)
1091 list(obj_expled.pps())
1092 pprint(obj_expled, big_blobs=True, with_decode_path=True)
1093 obj_expled_encoded = obj_expled.encode()
1094 ctx_copied = deepcopy(ctx_dummy)
1095 obj_decoded, tail = obj_expled.decode(
1096 obj_expled_encoded + tail_junk,
1100 self.assertDictEqual(ctx_copied, ctx_dummy)
1102 list(obj_decoded.pps())
1103 pprint(obj_decoded, big_blobs=True, with_decode_path=True)
1104 self.assertEqual(tail, tail_junk)
1105 self.assertEqual(obj_decoded, obj_expled)
1106 self.assertNotEqual(obj_decoded, obj)
1107 self.assertEqual(int(obj_decoded), int(obj_expled))
1108 self.assertEqual(int(obj_decoded), int(obj))
1109 self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
1110 self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
1111 self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
1113 obj_decoded.expl_llen,
1114 len(len_encode(len(obj_encoded))),
1116 self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
1117 self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
1120 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
1122 self.assertEqual(obj_decoded.expl_offset, offset)
1123 assert_exceeding_data(
1125 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
1129 def test_go_vectors_valid(self):
1130 for data, expect in ((
1134 (b"\xff\x7f", -129),
1138 (b"\xff\x00", -256),
1142 (b"\x80\x00\x00\x00\x00\x00\x00\x00", -9223372036854775808),
1143 (b"\x80\x00\x00\x00", -2147483648),
1146 Integer().decode(b"".join((
1147 Integer.tag_default,
1148 len_encode(len(data)),
1154 def test_go_vectors_invalid(self):
1159 with self.assertRaises(DecodeError):
1160 Integer().decode(b"".join((
1161 Integer.tag_default,
1162 len_encode(len(data)),
1168 def bit_string_values_strategy(draw, schema=None, value_required=False, do_expl=False):
1171 if draw(booleans()):
1172 schema = draw(sets(text_letters(), min_size=1, max_size=256))
1174 integers(min_value=0, max_value=255),
1175 min_size=len(schema),
1176 max_size=len(schema),
1178 schema = list(zip(schema, bits))
1180 def _value(value_required):
1181 if not value_required and draw(booleans()):
1183 generation_choice = 0
1185 generation_choice = draw(sampled_from((1, 2, 3)))
1186 if generation_choice == 1 or draw(booleans()):
1187 return "'%s'B" % "".join(draw(lists(
1188 sampled_from(("0", "1")),
1189 max_size=len(schema),
1191 if generation_choice == 2 or draw(booleans()):
1192 return draw(binary(max_size=len(schema) // 8))
1193 if generation_choice == 3 or draw(booleans()):
1194 return tuple(draw(lists(sampled_from([name for name, _ in schema]))))
1196 value = _value(value_required)
1197 default = _value(value_required=False)
1201 expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
1203 impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
1204 optional = draw(one_of(none(), booleans()))
1206 draw(integers(min_value=0)),
1207 draw(integers(min_value=0)),
1208 draw(integers(min_value=0)),
1210 return (schema, value, impl, expl, default, optional, _decoded)
1213 class BitStringInherited(BitString):
1217 class TestBitString(CommonMixin, TestCase):
1218 base_klass = BitString
1220 @given(lists(booleans()))
1221 def test_b_encoding(self, bits):
1222 obj = BitString("'%s'B" % "".join("1" if bit else "0" for bit in bits))
1223 self.assertEqual(obj.bit_len, len(bits))
1224 self.assertSequenceEqual(list(obj), bits)
1225 for i, bit in enumerate(bits):
1226 self.assertEqual(obj[i], bit)
1228 @given(lists(booleans()))
1229 def test_out_of_bounds_bits(self, bits):
1230 obj = BitString("'%s'B" % "".join("1" if bit else "0" for bit in bits))
1231 for i in range(len(bits), len(bits) * 2):
1232 self.assertFalse(obj[i])
1234 def test_bad_b_encoding(self):
1235 with self.assertRaises(ValueError):
1236 BitString("'010120101'B")
1239 integers(min_value=1, max_value=255),
1240 integers(min_value=1, max_value=255),
1242 def test_named_are_stripped(self, leading_zeros, trailing_zeros):
1243 obj = BitString("'%s1%s'B" % (("0" * leading_zeros), ("0" * trailing_zeros)))
1244 self.assertEqual(obj.bit_len, leading_zeros + 1 + trailing_zeros)
1245 self.assertGreater(len(obj.encode()), (leading_zeros + 1 + trailing_zeros) // 8)
1247 class BS(BitString):
1248 schema = (("whatever", 0),)
1249 obj = BS("'%s1%s'B" % (("0" * leading_zeros), ("0" * trailing_zeros)))
1250 self.assertEqual(obj.bit_len, leading_zeros + 1)
1251 self.assertGreater(len(obj.encode()), (leading_zeros + 1) // 8)
1253 def test_zero_len(self):
1254 with self.assertRaises(NotEnoughData):
1255 BitString().decode(b"".join((
1256 BitString.tag_default,
1260 def test_invalid_value_type(self):
1261 with self.assertRaises(InvalidValueType) as err:
1264 with self.assertRaises(InvalidValueType) as err:
1268 def test_obj_unknown(self):
1269 with self.assertRaises(ObjUnknown) as err:
1270 BitString(b"whatever")["whenever"]
1273 def test_get_invalid_type(self):
1274 with self.assertRaises(InvalidValueType) as err:
1275 BitString(b"whatever")[(1, 2, 3)]
1278 @given(data_strategy())
1279 def test_unknown_name(self, d):
1280 _schema = d.draw(sets(text_letters(), min_size=2, max_size=5))
1281 missing = _schema.pop()
1283 class BS(BitString):
1284 schema = [(n, i) for i, n in enumerate(_schema)]
1285 with self.assertRaises(ObjUnknown) as err:
1290 def test_optional(self, optional):
1291 obj = BitString(default=BitString(b""), optional=optional)
1292 self.assertTrue(obj.optional)
1295 def test_ready(self, value):
1297 self.assertFalse(obj.ready)
1300 pprint(obj, big_blobs=True, with_decode_path=True)
1301 with self.assertRaises(ObjNotReady) as err:
1304 obj = BitString(value)
1305 self.assertTrue(obj.ready)
1308 pprint(obj, big_blobs=True, with_decode_path=True)
1311 tuples(integers(min_value=0), binary()),
1312 tuples(integers(min_value=0), binary()),
1316 def test_comparison(self, value1, value2, tag1, tag2):
1317 for klass in (BitString, BitStringInherited):
1318 obj1 = klass(value1)
1319 obj2 = klass(value2)
1320 self.assertEqual(obj1 == obj2, value1 == value2)
1321 self.assertEqual(obj1 != obj2, value1 != value2)
1322 self.assertEqual(obj1 == bytes(obj2), value1[1] == value2[1])
1323 obj1 = klass(value1, impl=tag1)
1324 obj2 = klass(value1, impl=tag2)
1325 self.assertEqual(obj1 == obj2, tag1 == tag2)
1326 self.assertEqual(obj1 != obj2, tag1 != tag2)
1328 @given(data_strategy())
1329 def test_call(self, d):
1330 for klass in (BitString, BitStringInherited):
1339 ) = d.draw(bit_string_values_strategy())
1342 schema = schema_initial
1344 value=value_initial,
1347 default=default_initial,
1348 optional=optional_initial or False,
1349 _decoded=_decoded_initial,
1359 ) = d.draw(bit_string_values_strategy(
1360 schema=schema_initial,
1361 do_expl=impl_initial is None,
1370 self.assertEqual(obj.tag, impl or impl_initial or obj.tag_default)
1371 self.assertEqual(obj.expl_tag, expl or expl_initial)
1372 if obj.default is None:
1373 optional = optional_initial if optional is None else optional
1374 optional = False if optional is None else optional
1377 self.assertEqual(obj.optional, optional)
1378 self.assertEqual(obj.specs, obj_initial.specs)
1380 @given(bit_string_values_strategy())
1381 def test_copy(self, values):
1382 for klass in (BitString, BitStringInherited):
1383 _schema, value, impl, expl, default, optional, _decoded = values
1393 optional=optional or False,
1396 for copy_func in copy_funcs:
1397 obj_copied = copy_func(obj)
1398 self.assert_copied_basic_fields(obj, obj_copied)
1399 self.assertEqual(obj.specs, obj_copied.specs)
1400 self.assertEqual(obj._value, obj_copied._value)
1404 integers(min_value=1).map(tag_encode),
1406 def test_stripped(self, value, tag_impl):
1407 obj = BitString(value, impl=tag_impl)
1408 with self.assertRaises(NotEnoughData):
1409 obj.decode(obj.encode()[:-1])
1413 integers(min_value=1).map(tag_ctxc),
1415 def test_stripped_expl(self, value, tag_expl):
1416 obj = BitString(value, expl=tag_expl)
1417 with self.assertRaises(NotEnoughData):
1418 obj.decode(obj.encode()[:-1])
1421 integers(min_value=31),
1422 integers(min_value=0),
1425 def test_bad_tag(self, tag, offset, decode_path):
1426 with self.assertRaises(DecodeError) as err:
1428 tag_encode(tag)[:-1],
1430 decode_path=decode_path,
1433 self.assertEqual(err.exception.offset, offset)
1434 self.assertEqual(err.exception.decode_path, decode_path)
1437 integers(min_value=128),
1438 integers(min_value=0),
1441 def test_bad_len(self, l, offset, decode_path):
1442 with self.assertRaises(DecodeError) as err:
1444 BitString.tag_default + len_encode(l)[:-1],
1446 decode_path=decode_path,
1449 self.assertEqual(err.exception.offset, offset)
1450 self.assertEqual(err.exception.decode_path, decode_path)
1452 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
1453 @given(data_strategy())
1454 def test_symmetric(self, d):
1463 ) = d.draw(bit_string_values_strategy(value_required=True))
1464 tail_junk = d.draw(binary(max_size=5))
1465 tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
1466 offset = d.draw(integers(min_value=0))
1467 for klass in (BitString, BitStringInherited):
1478 pprint(obj, big_blobs=True, with_decode_path=True)
1479 self.assertFalse(obj.expled)
1480 obj_encoded = obj.encode()
1481 obj_expled = obj(value, expl=tag_expl)
1482 self.assertTrue(obj_expled.expled)
1484 list(obj_expled.pps())
1485 pprint(obj_expled, big_blobs=True, with_decode_path=True)
1486 obj_expled_encoded = obj_expled.encode()
1487 ctx_copied = deepcopy(ctx_dummy)
1488 obj_decoded, tail = obj_expled.decode(
1489 obj_expled_encoded + tail_junk,
1493 self.assertDictEqual(ctx_copied, ctx_dummy)
1495 list(obj_decoded.pps())
1496 pprint(obj_decoded, big_blobs=True, with_decode_path=True)
1497 self.assertEqual(tail, tail_junk)
1498 self.assertEqual(obj_decoded, obj_expled)
1499 self.assertNotEqual(obj_decoded, obj)
1500 self.assertEqual(bytes(obj_decoded), bytes(obj_expled))
1501 self.assertEqual(bytes(obj_decoded), bytes(obj))
1502 self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
1503 self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
1504 self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
1506 obj_decoded.expl_llen,
1507 len(len_encode(len(obj_encoded))),
1509 self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
1510 self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
1513 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
1515 self.assertEqual(obj_decoded.expl_offset, offset)
1516 if isinstance(value, tuple):
1517 self.assertSetEqual(set(value), set(obj_decoded.named))
1520 assert_exceeding_data(
1522 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
1526 @given(integers(min_value=1, max_value=255))
1527 def test_bad_zero_value(self, pad_size):
1528 with self.assertRaises(DecodeError):
1529 BitString().decode(b"".join((
1530 BitString.tag_default,
1535 def test_go_vectors_invalid(self):
1541 with self.assertRaises(DecodeError):
1542 BitString().decode(b"".join((
1543 BitString.tag_default,
1548 def test_go_vectors_valid(self):
1549 obj, _ = BitString().decode(b"".join((
1550 BitString.tag_default,
1554 self.assertEqual(bytes(obj), b"")
1555 self.assertEqual(obj.bit_len, 0)
1557 obj, _ = BitString().decode(b"".join((
1558 BitString.tag_default,
1562 self.assertEqual(bytes(obj), b"\x00")
1563 self.assertEqual(obj.bit_len, 1)
1565 obj = BitString((16, b"\x82\x40"))
1566 self.assertTrue(obj[0])
1567 self.assertFalse(obj[1])
1568 self.assertTrue(obj[6])
1569 self.assertTrue(obj[9])
1570 self.assertFalse(obj[17])
1573 integers(min_value=1, max_value=30),
1576 binary(min_size=1, max_size=5),
1578 binary(min_size=1, max_size=5),
1586 lists(booleans(), min_size=1),
1589 def test_constructed(self, impl, chunk_inputs, chunk_last_bits, junk):
1590 def chunk_constructed(contents):
1592 tag_encode(form=TagFormConstructed, num=3) +
1594 b"".join(BitString(content).encode() for content in contents) +
1598 payload_expected = b""
1599 bit_len_expected = 0
1600 for chunk_input in chunk_inputs:
1601 if isinstance(chunk_input, binary_type):
1602 chunks.append(BitString(chunk_input).encode())
1603 payload_expected += chunk_input
1604 bit_len_expected += len(chunk_input) * 8
1606 chunks.append(chunk_constructed(chunk_input))
1607 payload = b"".join(chunk_input)
1608 payload_expected += payload
1609 bit_len_expected += len(payload) * 8
1610 chunk_last = BitString("'%s'B" % "".join(
1611 "1" if bit else "0" for bit in chunk_last_bits
1613 payload_expected += bytes(chunk_last)
1614 bit_len_expected += chunk_last.bit_len
1615 encoded_indefinite = (
1616 tag_encode(form=TagFormConstructed, num=impl) +
1619 chunk_last.encode() +
1622 encoded_definite = (
1623 tag_encode(form=TagFormConstructed, num=impl) +
1624 len_encode(len(b"".join(chunks) + chunk_last.encode())) +
1628 with assertRaisesRegex(self, DecodeError, "unallowed BER"):
1629 BitString(impl=tag_encode(impl)).decode(encoded_indefinite)
1630 for lenindef_expected, encoded in (
1631 (True, encoded_indefinite),
1632 (False, encoded_definite),
1634 obj, tail = BitString(impl=tag_encode(impl)).decode(
1636 ctx={"bered": True},
1638 self.assertSequenceEqual(tail, junk)
1639 self.assertEqual(obj.bit_len, bit_len_expected)
1640 self.assertSequenceEqual(bytes(obj), payload_expected)
1641 self.assertTrue(obj.ber_encoded)
1642 self.assertEqual(obj.lenindef, lenindef_expected)
1643 self.assertTrue(obj.bered)
1645 self.assertTrue(obj.ber_encoded)
1646 self.assertEqual(obj.lenindef, lenindef_expected)
1647 self.assertTrue(obj.bered)
1648 self.assertEqual(len(encoded), obj.tlvlen)
1651 pprint(obj, big_blobs=True, with_decode_path=True)
1654 integers(min_value=0),
1657 def test_ber_definite_too_short(self, offset, decode_path):
1658 with assertRaisesRegex(self, DecodeError, "longer than data") as err:
1660 tag_encode(3, form=TagFormConstructed) + len_encode(1),
1662 decode_path=decode_path,
1663 ctx={"bered": True},
1665 self.assertEqual(err.exception.decode_path, decode_path)
1666 self.assertEqual(err.exception.offset, offset)
1669 integers(min_value=0),
1672 def test_ber_definite_no_data(self, offset, decode_path):
1673 with assertRaisesRegex(self, DecodeError, "zero length") as err:
1675 tag_encode(3, form=TagFormConstructed) + len_encode(0),
1677 decode_path=decode_path,
1678 ctx={"bered": True},
1680 self.assertEqual(err.exception.decode_path, decode_path)
1681 self.assertEqual(err.exception.offset, offset)
1684 integers(min_value=0),
1686 integers(min_value=1, max_value=3),
1688 def test_ber_indefinite_no_eoc(self, offset, decode_path, chunks):
1689 bs = BitString(b"data").encode()
1690 with self.assertRaises(NotEnoughData) as err:
1692 tag_encode(3, form=TagFormConstructed) + LENINDEF + chunks * bs,
1694 decode_path=decode_path,
1695 ctx={"bered": True},
1697 self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),))
1698 self.assertEqual(err.exception.offset, offset + 1 + 1 + chunks * len(bs))
1701 integers(min_value=0),
1703 integers(min_value=1, max_value=3),
1705 def test_ber_definite_chunk_out_of_bounds(self, offset, decode_path, chunks):
1706 bs = BitString(b"data").encode()
1707 bs_longer = BitString(b"data-longer").encode()
1708 with assertRaisesRegex(self, DecodeError, "chunk out of bounds") as err:
1711 tag_encode(3, form=TagFormConstructed) +
1712 len_encode((chunks + 1) * len(bs)) +
1717 decode_path=decode_path,
1718 ctx={"bered": True},
1720 self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),))
1721 self.assertEqual(err.exception.offset, offset + 1 + 1 + chunks * len(bs))
1724 integers(min_value=0),
1727 def test_ber_indefinite_no_chunks(self, offset, decode_path):
1728 with assertRaisesRegex(self, DecodeError, "no chunks") as err:
1730 tag_encode(3, form=TagFormConstructed) + LENINDEF + EOC,
1732 decode_path=decode_path,
1733 ctx={"bered": True},
1735 self.assertEqual(err.exception.decode_path, decode_path)
1736 self.assertEqual(err.exception.offset, offset)
1738 @given(data_strategy())
1739 def test_ber_indefinite_not_multiple(self, d):
1740 bs_short = BitString("'A'H").encode()
1741 bs_full = BitString("'AA'H").encode()
1742 chunks = [bs_full for _ in range(d.draw(integers(min_value=0, max_value=3)))]
1743 chunks.append(bs_short)
1744 d.draw(permutations(chunks))
1745 chunks.append(bs_short)
1746 offset = d.draw(integers(min_value=0))
1747 decode_path = d.draw(decode_path_strat)
1748 with assertRaisesRegex(self, DecodeError, "multiple of 8 bits") as err:
1751 tag_encode(3, form=TagFormConstructed) +
1757 decode_path=decode_path,
1758 ctx={"bered": True},
1761 err.exception.decode_path,
1762 decode_path + (str(chunks.index(bs_short)),),
1765 err.exception.offset,
1766 offset + 1 + 1 + chunks.index(bs_short) * len(bs_full),
1769 def test_x690_vector(self):
1770 vector = BitString("'0A3B5F291CD'H")
1771 obj, tail = BitString().decode(hexdec("0307040A3B5F291CD0"))
1772 self.assertSequenceEqual(tail, b"")
1773 self.assertEqual(obj, vector)
1774 obj, tail = BitString().decode(
1775 hexdec("23800303000A3B0305045F291CD00000"),
1776 ctx={"bered": True},
1778 self.assertSequenceEqual(tail, b"")
1779 self.assertEqual(obj, vector)
1780 self.assertTrue(obj.ber_encoded)
1781 self.assertTrue(obj.lenindef)
1782 self.assertTrue(obj.bered)
1784 self.assertTrue(obj.ber_encoded)
1785 self.assertTrue(obj.lenindef)
1786 self.assertTrue(obj.bered)
1790 def octet_string_values_strategy(draw, do_expl=False):
1791 bound_min, bound_max = sorted(draw(sets(
1792 integers(min_value=0, max_value=1 << 7),
1796 value = draw(one_of(
1798 binary(min_size=bound_min, max_size=bound_max),
1800 default = draw(one_of(
1802 binary(min_size=bound_min, max_size=bound_max),
1805 if draw(booleans()):
1806 bounds = (bound_min, bound_max)
1810 expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
1812 impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
1813 optional = draw(one_of(none(), booleans()))
1815 draw(integers(min_value=0)),
1816 draw(integers(min_value=0)),
1817 draw(integers(min_value=0)),
1819 return (value, bounds, impl, expl, default, optional, _decoded)
1822 class OctetStringInherited(OctetString):
1826 class TestOctetString(CommonMixin, TestCase):
1827 base_klass = OctetString
1829 def test_invalid_value_type(self):
1830 with self.assertRaises(InvalidValueType) as err:
1831 OctetString(text_type(123))
1835 def test_optional(self, optional):
1836 obj = OctetString(default=OctetString(b""), optional=optional)
1837 self.assertTrue(obj.optional)
1840 def test_ready(self, value):
1842 self.assertFalse(obj.ready)
1845 pprint(obj, big_blobs=True, with_decode_path=True)
1846 with self.assertRaises(ObjNotReady) as err:
1849 obj = OctetString(value)
1850 self.assertTrue(obj.ready)
1853 pprint(obj, big_blobs=True, with_decode_path=True)
1855 @given(binary(), binary(), binary(min_size=1), binary(min_size=1))
1856 def test_comparison(self, value1, value2, tag1, tag2):
1857 for klass in (OctetString, OctetStringInherited):
1858 obj1 = klass(value1)
1859 obj2 = klass(value2)
1860 self.assertEqual(obj1 == obj2, value1 == value2)
1861 self.assertEqual(obj1 != obj2, value1 != value2)
1862 self.assertEqual(obj1 == bytes(obj2), value1 == value2)
1863 obj1 = klass(value1, impl=tag1)
1864 obj2 = klass(value1, impl=tag2)
1865 self.assertEqual(obj1 == obj2, tag1 == tag2)
1866 self.assertEqual(obj1 != obj2, tag1 != tag2)
1868 @given(lists(binary()))
1869 def test_sorted_works(self, values):
1870 self.assertSequenceEqual(
1871 [bytes(v) for v in sorted(OctetString(v) for v in values)],
1875 @given(data_strategy())
1876 def test_bounds_satisfied(self, d):
1877 bound_min = d.draw(integers(min_value=0, max_value=1 << 7))
1878 bound_max = d.draw(integers(min_value=bound_min, max_value=1 << 7))
1879 value = d.draw(binary(min_size=bound_min, max_size=bound_max))
1880 OctetString(value=value, bounds=(bound_min, bound_max))
1882 @given(data_strategy())
1883 def test_bounds_unsatisfied(self, d):
1884 bound_min = d.draw(integers(min_value=1, max_value=1 << 7))
1885 bound_max = d.draw(integers(min_value=bound_min, max_value=1 << 7))
1886 value = d.draw(binary(max_size=bound_min - 1))
1887 with self.assertRaises(BoundsError) as err:
1888 OctetString(value=value, bounds=(bound_min, bound_max))
1890 with assertRaisesRegex(self, DecodeError, "bounds") as err:
1891 OctetString(bounds=(bound_min, bound_max)).decode(
1892 OctetString(value).encode()
1895 value = d.draw(binary(min_size=bound_max + 1))
1896 with self.assertRaises(BoundsError) as err:
1897 OctetString(value=value, bounds=(bound_min, bound_max))
1899 with assertRaisesRegex(self, DecodeError, "bounds") as err:
1900 OctetString(bounds=(bound_min, bound_max)).decode(
1901 OctetString(value).encode()
1905 @given(data_strategy())
1906 def test_call(self, d):
1907 for klass in (OctetString, OctetStringInherited):
1916 ) = d.draw(octet_string_values_strategy())
1917 obj_initial = klass(
1923 optional_initial or False,
1934 ) = d.draw(octet_string_values_strategy(do_expl=impl_initial is None))
1935 if (default is None) and (obj_initial.default is not None):
1938 (bounds is None) and
1939 (value is not None) and
1940 (bounds_initial is not None) and
1941 not (bounds_initial[0] <= len(value) <= bounds_initial[1])
1945 (bounds is None) and
1946 (default is not None) and
1947 (bounds_initial is not None) and
1948 not (bounds_initial[0] <= len(default) <= bounds_initial[1])
1951 obj = obj_initial(value, bounds, impl, expl, default, optional)
1953 value_expected = default if value is None else value
1955 default_initial if value_expected is None
1958 self.assertEqual(obj, value_expected)
1959 self.assertEqual(obj.tag, impl or impl_initial or obj.tag_default)
1960 self.assertEqual(obj.expl_tag, expl or expl_initial)
1963 default_initial if default is None else default,
1965 if obj.default is None:
1966 optional = optional_initial if optional is None else optional
1967 optional = False if optional is None else optional
1970 self.assertEqual(obj.optional, optional)
1972 (obj._bound_min, obj._bound_max),
1973 bounds or bounds_initial or (0, float("+inf")),
1976 @given(octet_string_values_strategy())
1977 def test_copy(self, values):
1978 for klass in (OctetString, OctetStringInherited):
1979 obj = klass(*values)
1980 for copy_func in copy_funcs:
1981 obj_copied = copy_func(obj)
1982 self.assert_copied_basic_fields(obj, obj_copied)
1983 self.assertEqual(obj._bound_min, obj_copied._bound_min)
1984 self.assertEqual(obj._bound_max, obj_copied._bound_max)
1985 self.assertEqual(obj._value, obj_copied._value)
1989 integers(min_value=1).map(tag_encode),
1991 def test_stripped(self, value, tag_impl):
1992 obj = OctetString(value, impl=tag_impl)
1993 with self.assertRaises(NotEnoughData):
1994 obj.decode(obj.encode()[:-1])
1998 integers(min_value=1).map(tag_ctxc),
2000 def test_stripped_expl(self, value, tag_expl):
2001 obj = OctetString(value, expl=tag_expl)
2002 with self.assertRaises(NotEnoughData):
2003 obj.decode(obj.encode()[:-1])
2006 integers(min_value=31),
2007 integers(min_value=0),
2010 def test_bad_tag(self, tag, offset, decode_path):
2011 with self.assertRaises(DecodeError) as err:
2012 OctetString().decode(
2013 tag_encode(tag)[:-1],
2015 decode_path=decode_path,
2018 self.assertEqual(err.exception.offset, offset)
2019 self.assertEqual(err.exception.decode_path, decode_path)
2022 integers(min_value=128),
2023 integers(min_value=0),
2026 def test_bad_len(self, l, offset, decode_path):
2027 with self.assertRaises(DecodeError) as err:
2028 OctetString().decode(
2029 OctetString.tag_default + len_encode(l)[:-1],
2031 decode_path=decode_path,
2034 self.assertEqual(err.exception.offset, offset)
2035 self.assertEqual(err.exception.decode_path, decode_path)
2038 sets(integers(min_value=0, max_value=10), min_size=2, max_size=2),
2039 integers(min_value=0),
2042 def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
2043 value, bound_min = list(sorted(ints))
2045 class String(OctetString):
2046 bounds = (bound_min, bound_min)
2047 with self.assertRaises(DecodeError) as err:
2049 OctetString(b"\x00" * value).encode(),
2051 decode_path=decode_path,
2054 self.assertEqual(err.exception.offset, offset)
2055 self.assertEqual(err.exception.decode_path, decode_path)
2057 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
2059 octet_string_values_strategy(),
2061 integers(min_value=1).map(tag_ctxc),
2062 integers(min_value=0),
2065 def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
2066 for klass in (OctetString, OctetStringInherited):
2067 _, _, _, _, default, optional, _decoded = values
2076 pprint(obj, big_blobs=True, with_decode_path=True)
2077 self.assertFalse(obj.expled)
2078 obj_encoded = obj.encode()
2079 obj_expled = obj(value, expl=tag_expl)
2080 self.assertTrue(obj_expled.expled)
2082 list(obj_expled.pps())
2083 pprint(obj_expled, big_blobs=True, with_decode_path=True)
2084 obj_expled_encoded = obj_expled.encode()
2085 ctx_copied = deepcopy(ctx_dummy)
2086 obj_decoded, tail = obj_expled.decode(
2087 obj_expled_encoded + tail_junk,
2091 self.assertDictEqual(ctx_copied, ctx_dummy)
2093 list(obj_decoded.pps())
2094 pprint(obj_decoded, big_blobs=True, with_decode_path=True)
2095 self.assertEqual(tail, tail_junk)
2096 self.assertEqual(obj_decoded, obj_expled)
2097 self.assertNotEqual(obj_decoded, obj)
2098 self.assertEqual(bytes(obj_decoded), bytes(obj_expled))
2099 self.assertEqual(bytes(obj_decoded), bytes(obj))
2100 self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
2101 self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
2102 self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
2104 obj_decoded.expl_llen,
2105 len(len_encode(len(obj_encoded))),
2107 self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
2108 self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
2111 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
2113 self.assertEqual(obj_decoded.expl_offset, offset)
2114 assert_exceeding_data(
2116 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
2121 integers(min_value=1, max_value=30),
2124 binary(min_size=1, max_size=5),
2126 binary(min_size=1, max_size=5),
2136 def test_constructed(self, impl, chunk_inputs, junk):
2137 def chunk_constructed(contents):
2139 tag_encode(form=TagFormConstructed, num=4) +
2141 b"".join(OctetString(content).encode() for content in contents) +
2145 payload_expected = b""
2146 for chunk_input in chunk_inputs:
2147 if isinstance(chunk_input, binary_type):
2148 chunks.append(OctetString(chunk_input).encode())
2149 payload_expected += chunk_input
2151 chunks.append(chunk_constructed(chunk_input))
2152 payload = b"".join(chunk_input)
2153 payload_expected += payload
2154 encoded_indefinite = (
2155 tag_encode(form=TagFormConstructed, num=impl) +
2160 encoded_definite = (
2161 tag_encode(form=TagFormConstructed, num=impl) +
2162 len_encode(len(b"".join(chunks))) +
2165 with assertRaisesRegex(self, DecodeError, "unallowed BER"):
2166 OctetString(impl=tag_encode(impl)).decode(encoded_indefinite)
2167 for lenindef_expected, encoded in (
2168 (True, encoded_indefinite),
2169 (False, encoded_definite),
2171 obj, tail = OctetString(impl=tag_encode(impl)).decode(
2173 ctx={"bered": True},
2175 self.assertSequenceEqual(tail, junk)
2176 self.assertSequenceEqual(bytes(obj), payload_expected)
2177 self.assertTrue(obj.ber_encoded)
2178 self.assertEqual(obj.lenindef, lenindef_expected)
2179 self.assertTrue(obj.bered)
2181 self.assertTrue(obj.ber_encoded)
2182 self.assertEqual(obj.lenindef, lenindef_expected)
2183 self.assertTrue(obj.bered)
2184 self.assertEqual(len(encoded), obj.tlvlen)
2187 pprint(obj, big_blobs=True, with_decode_path=True)
2190 integers(min_value=0),
2193 def test_ber_definite_too_short(self, offset, decode_path):
2194 with assertRaisesRegex(self, DecodeError, "longer than data") as err:
2195 OctetString().decode(
2196 tag_encode(4, form=TagFormConstructed) + len_encode(1),
2198 decode_path=decode_path,
2199 ctx={"bered": True},
2201 self.assertEqual(err.exception.decode_path, decode_path)
2202 self.assertEqual(err.exception.offset, offset)
2205 integers(min_value=0),
2207 integers(min_value=1, max_value=3),
2209 def test_ber_indefinite_no_eoc(self, offset, decode_path, chunks):
2210 bs = OctetString(b"data").encode()
2211 with self.assertRaises(NotEnoughData) as err:
2212 OctetString().decode(
2213 tag_encode(4, form=TagFormConstructed) + LENINDEF + chunks * bs,
2215 decode_path=decode_path,
2216 ctx={"bered": True},
2218 self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),))
2219 self.assertEqual(err.exception.offset, offset + 1 + 1 + chunks * len(bs))
2222 integers(min_value=0),
2224 integers(min_value=1, max_value=3),
2226 def test_ber_definite_chunk_out_of_bounds(self, offset, decode_path, chunks):
2227 bs = OctetString(b"data").encode()
2228 bs_longer = OctetString(b"data-longer").encode()
2229 with assertRaisesRegex(self, DecodeError, "chunk out of bounds") as err:
2230 OctetString().decode(
2232 tag_encode(4, form=TagFormConstructed) +
2233 len_encode((chunks + 1) * len(bs)) +
2238 decode_path=decode_path,
2239 ctx={"bered": True},
2241 self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),))
2242 self.assertEqual(err.exception.offset, offset + 1 + 1 + chunks * len(bs))
2246 def null_values_strategy(draw, do_expl=False):
2250 expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
2252 impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
2253 optional = draw(one_of(none(), booleans()))
2255 draw(integers(min_value=0)),
2256 draw(integers(min_value=0)),
2257 draw(integers(min_value=0)),
2259 return (impl, expl, optional, _decoded)
2262 class NullInherited(Null):
2266 class TestNull(CommonMixin, TestCase):
2269 def test_ready(self):
2271 self.assertTrue(obj.ready)
2274 pprint(obj, big_blobs=True, with_decode_path=True)
2276 @given(binary(), binary())
2277 def test_comparison(self, tag1, tag2):
2278 for klass in (Null, NullInherited):
2279 obj1 = klass(impl=tag1)
2280 obj2 = klass(impl=tag2)
2281 self.assertEqual(obj1 == obj2, tag1 == tag2)
2282 self.assertEqual(obj1 != obj2, tag1 != tag2)
2283 self.assertNotEqual(obj1, tag2)
2285 @given(data_strategy())
2286 def test_call(self, d):
2287 for klass in (Null, NullInherited):
2293 ) = d.draw(null_values_strategy())
2294 obj_initial = klass(
2297 optional=optional_initial or False,
2298 _decoded=_decoded_initial,
2305 ) = d.draw(null_values_strategy(do_expl=impl_initial is None))
2306 obj = obj_initial(impl=impl, expl=expl, optional=optional)
2307 self.assertEqual(obj.tag, impl or impl_initial or obj.tag_default)
2308 self.assertEqual(obj.expl_tag, expl or expl_initial)
2309 optional = optional_initial if optional is None else optional
2310 optional = False if optional is None else optional
2311 self.assertEqual(obj.optional, optional)
2313 @given(null_values_strategy())
2314 def test_copy(self, values):
2315 for klass in (Null, NullInherited):
2316 impl, expl, optional, _decoded = values
2320 optional=optional or False,
2323 for copy_func in copy_funcs:
2324 obj_copied = copy_func(obj)
2325 self.assert_copied_basic_fields(obj, obj_copied)
2327 @given(integers(min_value=1).map(tag_encode))
2328 def test_stripped(self, tag_impl):
2329 obj = Null(impl=tag_impl)
2330 with self.assertRaises(NotEnoughData):
2331 obj.decode(obj.encode()[:-1])
2333 @given(integers(min_value=1).map(tag_ctxc))
2334 def test_stripped_expl(self, tag_expl):
2335 obj = Null(expl=tag_expl)
2336 with self.assertRaises(NotEnoughData):
2337 obj.decode(obj.encode()[:-1])
2340 integers(min_value=31),
2341 integers(min_value=0),
2344 def test_bad_tag(self, tag, offset, decode_path):
2345 with self.assertRaises(DecodeError) as err:
2347 tag_encode(tag)[:-1],
2349 decode_path=decode_path,
2352 self.assertEqual(err.exception.offset, offset)
2353 self.assertEqual(err.exception.decode_path, decode_path)
2356 integers(min_value=128),
2357 integers(min_value=0),
2360 def test_bad_len(self, l, offset, decode_path):
2361 with self.assertRaises(DecodeError) as err:
2363 Null.tag_default + len_encode(l)[:-1],
2365 decode_path=decode_path,
2368 self.assertEqual(err.exception.offset, offset)
2369 self.assertEqual(err.exception.decode_path, decode_path)
2371 @given(binary(min_size=1))
2372 def test_tag_mismatch(self, impl):
2373 assume(impl != Null.tag_default)
2374 with self.assertRaises(TagMismatch):
2375 Null(impl=impl).decode(Null().encode())
2378 null_values_strategy(),
2379 integers(min_value=1).map(tag_ctxc),
2380 integers(min_value=0),
2383 def test_symmetric(self, values, tag_expl, offset, tail_junk):
2384 for klass in (Null, NullInherited):
2385 _, _, optional, _decoded = values
2386 obj = klass(optional=optional, _decoded=_decoded)
2389 pprint(obj, big_blobs=True, with_decode_path=True)
2390 self.assertFalse(obj.expled)
2391 obj_encoded = obj.encode()
2392 obj_expled = obj(expl=tag_expl)
2393 self.assertTrue(obj_expled.expled)
2395 list(obj_expled.pps())
2396 pprint(obj_expled, big_blobs=True, with_decode_path=True)
2397 obj_expled_encoded = obj_expled.encode()
2398 ctx_copied = deepcopy(ctx_dummy)
2399 obj_decoded, tail = obj_expled.decode(
2400 obj_expled_encoded + tail_junk,
2404 self.assertDictEqual(ctx_copied, ctx_dummy)
2406 list(obj_decoded.pps())
2407 pprint(obj_decoded, big_blobs=True, with_decode_path=True)
2408 self.assertEqual(tail, tail_junk)
2409 self.assertEqual(obj_decoded, obj_expled)
2410 self.assertNotEqual(obj_decoded, obj)
2411 self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
2412 self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
2413 self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
2415 obj_decoded.expl_llen,
2416 len(len_encode(len(obj_encoded))),
2418 self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
2419 self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
2422 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
2424 self.assertEqual(obj_decoded.expl_offset, offset)
2425 assert_exceeding_data(
2427 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
2431 @given(integers(min_value=1))
2432 def test_invalid_len(self, l):
2433 with self.assertRaises(InvalidLength):
2434 Null().decode(b"".join((
2441 def oid_strategy(draw):
2442 first_arc = draw(integers(min_value=0, max_value=2))
2444 if first_arc in (0, 1):
2445 second_arc = draw(integers(min_value=0, max_value=39))
2447 second_arc = draw(integers(min_value=0))
2448 other_arcs = draw(lists(integers(min_value=0)))
2449 return tuple([first_arc, second_arc] + other_arcs)
2453 def oid_values_strategy(draw, do_expl=False):
2454 value = draw(one_of(none(), oid_strategy()))
2458 expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
2460 impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
2461 default = draw(one_of(none(), oid_strategy()))
2462 optional = draw(one_of(none(), booleans()))
2464 draw(integers(min_value=0)),
2465 draw(integers(min_value=0)),
2466 draw(integers(min_value=0)),
2468 return (value, impl, expl, default, optional, _decoded)
2471 class ObjectIdentifierInherited(ObjectIdentifier):
2475 class TestObjectIdentifier(CommonMixin, TestCase):
2476 base_klass = ObjectIdentifier
2478 def test_invalid_value_type(self):
2479 with self.assertRaises(InvalidValueType) as err:
2480 ObjectIdentifier(123)
2484 def test_optional(self, optional):
2485 obj = ObjectIdentifier(default=ObjectIdentifier("1.2.3"), optional=optional)
2486 self.assertTrue(obj.optional)
2488 @given(oid_strategy())
2489 def test_ready(self, value):
2490 obj = ObjectIdentifier()
2491 self.assertFalse(obj.ready)
2494 pprint(obj, big_blobs=True, with_decode_path=True)
2495 with self.assertRaises(ObjNotReady) as err:
2498 obj = ObjectIdentifier(value)
2499 self.assertTrue(obj.ready)
2500 self.assertFalse(obj.ber_encoded)
2503 pprint(obj, big_blobs=True, with_decode_path=True)
2506 @given(oid_strategy(), oid_strategy(), binary(), binary())
2507 def test_comparison(self, value1, value2, tag1, tag2):
2508 for klass in (ObjectIdentifier, ObjectIdentifierInherited):
2509 obj1 = klass(value1)
2510 obj2 = klass(value2)
2511 self.assertEqual(obj1 == obj2, value1 == value2)
2512 self.assertEqual(obj1 != obj2, value1 != value2)
2513 self.assertEqual(obj1 == tuple(obj2), value1 == value2)
2514 self.assertEqual(str(obj1) == str(obj2), value1 == value2)
2515 obj1 = klass(value1, impl=tag1)
2516 obj2 = klass(value1, impl=tag2)
2517 self.assertEqual(obj1 == obj2, tag1 == tag2)
2518 self.assertEqual(obj1 != obj2, tag1 != tag2)
2520 @given(lists(oid_strategy()))
2521 def test_sorted_works(self, values):
2522 self.assertSequenceEqual(
2523 [tuple(v) for v in sorted(ObjectIdentifier(v) for v in values)],
2527 @given(data_strategy())
2528 def test_call(self, d):
2529 for klass in (ObjectIdentifier, ObjectIdentifierInherited):
2537 ) = d.draw(oid_values_strategy())
2538 obj_initial = klass(
2539 value=value_initial,
2542 default=default_initial,
2543 optional=optional_initial or False,
2544 _decoded=_decoded_initial,
2553 ) = d.draw(oid_values_strategy(do_expl=impl_initial is None))
2562 value_expected = default if value is None else value
2564 default_initial if value_expected is None
2567 self.assertEqual(obj, value_expected)
2568 self.assertEqual(obj.tag, impl or impl_initial or obj.tag_default)
2569 self.assertEqual(obj.expl_tag, expl or expl_initial)
2572 default_initial if default is None else default,
2574 if obj.default is None:
2575 optional = optional_initial if optional is None else optional
2576 optional = False if optional is None else optional
2579 self.assertEqual(obj.optional, optional)
2581 @given(oid_values_strategy())
2582 def test_copy(self, values):
2583 for klass in (ObjectIdentifier, ObjectIdentifierInherited):
2600 for copy_func in copy_funcs:
2601 obj_copied = copy_func(obj)
2602 self.assert_copied_basic_fields(obj, obj_copied)
2603 self.assertEqual(obj._value, obj_copied._value)
2605 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
2608 integers(min_value=1).map(tag_encode),
2610 def test_stripped(self, value, tag_impl):
2611 obj = ObjectIdentifier(value, impl=tag_impl)
2612 with self.assertRaises(NotEnoughData):
2613 obj.decode(obj.encode()[:-1])
2617 integers(min_value=1).map(tag_ctxc),
2619 def test_stripped_expl(self, value, tag_expl):
2620 obj = ObjectIdentifier(value, expl=tag_expl)
2621 with self.assertRaises(NotEnoughData):
2622 obj.decode(obj.encode()[:-1])
2625 integers(min_value=31),
2626 integers(min_value=0),
2629 def test_bad_tag(self, tag, offset, decode_path):
2630 with self.assertRaises(DecodeError) as err:
2631 ObjectIdentifier().decode(
2632 tag_encode(tag)[:-1],
2634 decode_path=decode_path,
2637 self.assertEqual(err.exception.offset, offset)
2638 self.assertEqual(err.exception.decode_path, decode_path)
2641 integers(min_value=128),
2642 integers(min_value=0),
2645 def test_bad_len(self, l, offset, decode_path):
2646 with self.assertRaises(DecodeError) as err:
2647 ObjectIdentifier().decode(
2648 ObjectIdentifier.tag_default + len_encode(l)[:-1],
2650 decode_path=decode_path,
2653 self.assertEqual(err.exception.offset, offset)
2654 self.assertEqual(err.exception.decode_path, decode_path)
2656 def test_zero_oid(self):
2657 with self.assertRaises(NotEnoughData):
2658 ObjectIdentifier().decode(
2659 b"".join((ObjectIdentifier.tag_default, len_encode(0)))
2662 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
2663 @given(oid_strategy())
2664 def test_unfinished_oid(self, value):
2665 assume(list(value)[-1] > 255)
2666 obj_encoded = ObjectIdentifier(value).encode()
2667 obj, _ = ObjectIdentifier().decode(obj_encoded)
2668 data = obj_encoded[obj.tlen + obj.llen:-1]
2670 ObjectIdentifier.tag_default,
2671 len_encode(len(data)),
2674 with assertRaisesRegex(self, DecodeError, "unfinished OID"):
2677 @given(integers(min_value=0))
2678 def test_invalid_short(self, value):
2679 with self.assertRaises(InvalidOID):
2680 ObjectIdentifier((value,))
2681 with self.assertRaises(InvalidOID):
2682 ObjectIdentifier("%d" % value)
2684 @given(integers(min_value=3), integers(min_value=0))
2685 def test_invalid_first_arc(self, first_arc, second_arc):
2686 with self.assertRaises(InvalidOID):
2687 ObjectIdentifier((first_arc, second_arc))
2688 with self.assertRaises(InvalidOID):
2689 ObjectIdentifier("%d.%d" % (first_arc, second_arc))
2691 @given(integers(min_value=0, max_value=1), integers(min_value=40))
2692 def test_invalid_second_arc(self, first_arc, second_arc):
2693 with self.assertRaises(InvalidOID):
2694 ObjectIdentifier((first_arc, second_arc))
2695 with self.assertRaises(InvalidOID):
2696 ObjectIdentifier("%d.%d" % (first_arc, second_arc))
2698 @given(text(alphabet=ascii_letters + ".", min_size=1))
2699 def test_junk(self, oid):
2700 with self.assertRaises(InvalidOID):
2701 ObjectIdentifier(oid)
2703 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
2704 @given(oid_strategy())
2705 def test_validness(self, oid):
2706 obj = ObjectIdentifier(oid)
2707 self.assertEqual(obj, ObjectIdentifier(".".join(str(arc) for arc in oid)))
2710 pprint(obj, big_blobs=True, with_decode_path=True)
2712 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
2714 oid_values_strategy(),
2716 integers(min_value=1).map(tag_ctxc),
2717 integers(min_value=0),
2720 def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
2721 for klass in (ObjectIdentifier, ObjectIdentifierInherited):
2722 _, _, _, default, optional, _decoded = values
2731 pprint(obj, big_blobs=True, with_decode_path=True)
2732 self.assertFalse(obj.expled)
2733 obj_encoded = obj.encode()
2734 obj_expled = obj(value, expl=tag_expl)
2735 self.assertTrue(obj_expled.expled)
2737 list(obj_expled.pps())
2738 pprint(obj_expled, big_blobs=True, with_decode_path=True)
2739 obj_expled_encoded = obj_expled.encode()
2740 ctx_copied = deepcopy(ctx_dummy)
2741 obj_decoded, tail = obj_expled.decode(
2742 obj_expled_encoded + tail_junk,
2746 self.assertDictEqual(ctx_copied, ctx_dummy)
2748 list(obj_decoded.pps())
2749 pprint(obj_decoded, big_blobs=True, with_decode_path=True)
2750 self.assertEqual(tail, tail_junk)
2751 self.assertEqual(obj_decoded, obj_expled)
2752 self.assertNotEqual(obj_decoded, obj)
2753 self.assertEqual(tuple(obj_decoded), tuple(obj_expled))
2754 self.assertEqual(tuple(obj_decoded), tuple(obj))
2755 self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
2756 self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
2757 self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
2759 obj_decoded.expl_llen,
2760 len(len_encode(len(obj_encoded))),
2762 self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
2763 self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
2766 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
2768 self.assertEqual(obj_decoded.expl_offset, offset)
2769 assert_exceeding_data(
2771 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
2776 oid_strategy().map(ObjectIdentifier),
2777 oid_strategy().map(ObjectIdentifier),
2779 def test_add(self, oid1, oid2):
2780 oid_expect = ObjectIdentifier(str(oid1) + "." + str(oid2))
2781 for oid_to_add in (oid2, tuple(oid2)):
2782 self.assertEqual(oid1 + oid_to_add, oid_expect)
2783 with self.assertRaises(InvalidValueType):
2786 def test_go_vectors_valid(self):
2787 for data, expect in (
2789 (b"\x55\x02", (2, 5, 2)),
2790 (b"\x55\x02\xc0\x00", (2, 5, 2, 8192)),
2791 (b"\x81\x34\x03", (2, 100, 3)),
2794 ObjectIdentifier().decode(b"".join((
2795 ObjectIdentifier.tag_default,
2796 len_encode(len(data)),
2802 def test_go_vectors_invalid(self):
2803 data = b"\x55\x02\xc0\x80\x80\x80\x80"
2804 with self.assertRaises(DecodeError):
2805 ObjectIdentifier().decode(b"".join((
2806 Integer.tag_default,
2807 len_encode(len(data)),
2811 def test_x690_vector(self):
2813 ObjectIdentifier().decode(hexdec("0603883703"))[0],
2814 ObjectIdentifier((2, 999, 3)),
2817 def test_nonnormalized_first_arc(self):
2819 ObjectIdentifier.tag_default +
2822 ObjectIdentifier((1, 0)).encode()[-1:]
2824 obj, _ = ObjectIdentifier().decode(tampered, ctx={"bered": True})
2825 self.assertTrue(obj.ber_encoded)
2826 self.assertTrue(obj.bered)
2828 self.assertTrue(obj.ber_encoded)
2829 self.assertTrue(obj.bered)
2830 with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
2831 ObjectIdentifier().decode(tampered)
2833 @given(data_strategy())
2834 def test_negative_arcs(self, d):
2835 oid = list(d.draw(oid_strategy()))
2838 idx = d.draw(integers(min_value=3, max_value=len(oid)))
2840 if oid[idx - 1] == 0:
2842 with self.assertRaises(InvalidOID):
2843 ObjectIdentifier(tuple(oid))
2844 with self.assertRaises(InvalidOID):
2845 ObjectIdentifier(".".join(str(i) for i in oid))
2847 @given(data_strategy())
2848 def test_plused_arcs(self, d):
2849 oid = [str(arc) for arc in d.draw(oid_strategy())]
2850 idx = d.draw(integers(min_value=0, max_value=len(oid)))
2851 oid[idx - 1] = "+" + oid[idx - 1]
2852 with self.assertRaises(InvalidOID):
2853 ObjectIdentifier(".".join(str(i) for i in oid))
2855 @given(data_strategy())
2856 def test_nonnormalized_arcs(self, d):
2857 arcs = d.draw(lists(
2858 integers(min_value=0, max_value=100),
2862 dered = ObjectIdentifier((1, 0) + tuple(arcs)).encode()
2863 _, _, lv = tag_strip(dered)
2864 _, _, v = len_decode(lv)
2865 v_no_first_arc = v[1:]
2866 idx_for_tamper = d.draw(integers(
2868 max_value=len(v_no_first_arc) - 1,
2870 tampered = list(bytearray(v_no_first_arc))
2871 for _ in range(d.draw(integers(min_value=1, max_value=3))):
2872 tampered.insert(idx_for_tamper, 0x80)
2873 tampered = bytes(bytearray(tampered))
2875 ObjectIdentifier.tag_default +
2876 len_encode(len(tampered)) +
2879 obj, _ = ObjectIdentifier().decode(tampered, ctx={"bered": True})
2880 self.assertTrue(obj.ber_encoded)
2881 self.assertTrue(obj.bered)
2883 self.assertTrue(obj.ber_encoded)
2884 self.assertTrue(obj.bered)
2885 with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
2886 ObjectIdentifier().decode(tampered)
2890 def enumerated_values_strategy(draw, schema=None, do_expl=False):
2892 schema = list(draw(sets(text_printable, min_size=1, max_size=3)))
2893 values = list(draw(sets(
2895 min_size=len(schema),
2896 max_size=len(schema),
2898 schema = list(zip(schema, values))
2899 value = draw(one_of(none(), sampled_from([k for k, v in schema])))
2903 expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
2905 impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
2906 default = draw(one_of(none(), sampled_from([v for k, v in schema])))
2907 optional = draw(one_of(none(), booleans()))
2909 draw(integers(min_value=0)),
2910 draw(integers(min_value=0)),
2911 draw(integers(min_value=0)),
2913 return (schema, value, impl, expl, default, optional, _decoded)
2916 class TestEnumerated(CommonMixin, TestCase):
2917 class EWhatever(Enumerated):
2918 schema = (("whatever", 0),)
2920 base_klass = EWhatever
2922 def test_schema_required(self):
2923 with assertRaisesRegex(self, ValueError, "schema must be specified"):
2926 def test_invalid_value_type(self):
2927 with self.assertRaises(InvalidValueType) as err:
2928 self.base_klass((1, 2))
2931 @given(sets(text_letters(), min_size=2))
2932 def test_unknown_name(self, schema_input):
2933 missing = schema_input.pop()
2935 class E(Enumerated):
2936 schema = [(n, 123) for n in schema_input]
2937 with self.assertRaises(ObjUnknown) as err:
2942 sets(text_letters(), min_size=2),
2943 sets(integers(), min_size=2),
2945 def test_unknown_value(self, schema_input, values_input):
2947 missing_value = values_input.pop()
2948 _input = list(zip(schema_input, values_input))
2950 class E(Enumerated):
2952 with self.assertRaises(DecodeError) as err:
2957 def test_optional(self, optional):
2958 obj = self.base_klass(default="whatever", optional=optional)
2959 self.assertTrue(obj.optional)
2961 def test_ready(self):
2962 obj = self.base_klass()
2963 self.assertFalse(obj.ready)
2966 pprint(obj, big_blobs=True, with_decode_path=True)
2967 with self.assertRaises(ObjNotReady) as err:
2970 obj = self.base_klass("whatever")
2971 self.assertTrue(obj.ready)
2974 pprint(obj, big_blobs=True, with_decode_path=True)
2976 @given(integers(), integers(), binary(), binary())
2977 def test_comparison(self, value1, value2, tag1, tag2):
2978 class E(Enumerated):
2980 ("whatever0", value1),
2981 ("whatever1", value2),
2984 class EInherited(E):
2986 for klass in (E, EInherited):
2987 obj1 = klass(value1)
2988 obj2 = klass(value2)
2989 self.assertEqual(obj1 == obj2, value1 == value2)
2990 self.assertEqual(obj1 != obj2, value1 != value2)
2991 self.assertEqual(obj1 == int(obj2), value1 == value2)
2992 obj1 = klass(value1, impl=tag1)
2993 obj2 = klass(value1, impl=tag2)
2994 self.assertEqual(obj1 == obj2, tag1 == tag2)
2995 self.assertEqual(obj1 != obj2, tag1 != tag2)
2997 @given(data_strategy())
2998 def test_call(self, d):
3007 ) = d.draw(enumerated_values_strategy())
3009 class E(Enumerated):
3010 schema = schema_initial
3012 value=value_initial,
3015 default=default_initial,
3016 optional=optional_initial or False,
3017 _decoded=_decoded_initial,
3027 ) = d.draw(enumerated_values_strategy(
3028 schema=schema_initial,
3029 do_expl=impl_initial is None,
3039 value_expected = default if value is None else value
3041 default_initial if value_expected is None
3046 dict(schema_initial).get(value_expected, value_expected),
3048 self.assertEqual(obj.tag, impl or impl_initial or obj.tag_default)
3049 self.assertEqual(obj.expl_tag, expl or expl_initial)
3052 default_initial if default is None else default,
3054 if obj.default is None:
3055 optional = optional_initial if optional is None else optional
3056 optional = False if optional is None else optional
3059 self.assertEqual(obj.optional, optional)
3060 self.assertEqual(obj.specs, dict(schema_initial))
3062 @given(enumerated_values_strategy())
3063 def test_copy(self, values):
3064 schema_input, value, impl, expl, default, optional, _decoded = values
3066 class E(Enumerated):
3067 schema = schema_input
3077 for copy_func in copy_funcs:
3078 obj_copied = copy_func(obj)
3079 self.assert_copied_basic_fields(obj, obj_copied)
3080 self.assertEqual(obj.specs, obj_copied.specs)
3082 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
3083 @given(data_strategy())
3084 def test_symmetric(self, d):
3085 schema_input, _, _, _, default, optional, _decoded = d.draw(
3086 enumerated_values_strategy(),
3088 tag_expl = d.draw(integers(min_value=1).map(tag_ctxc))
3089 offset = d.draw(integers(min_value=0))
3090 value = d.draw(sampled_from(sorted([v for _, v in schema_input])))
3091 tail_junk = d.draw(binary(max_size=5))
3093 class E(Enumerated):
3094 schema = schema_input
3103 pprint(obj, big_blobs=True, with_decode_path=True)
3104 self.assertFalse(obj.expled)
3105 obj_encoded = obj.encode()
3106 obj_expled = obj(value, expl=tag_expl)
3107 self.assertTrue(obj_expled.expled)
3109 list(obj_expled.pps())
3110 pprint(obj_expled, big_blobs=True, with_decode_path=True)
3111 obj_expled_encoded = obj_expled.encode()
3112 ctx_copied = deepcopy(ctx_dummy)
3113 obj_decoded, tail = obj_expled.decode(
3114 obj_expled_encoded + tail_junk,
3118 self.assertDictEqual(ctx_copied, ctx_dummy)
3120 list(obj_decoded.pps())
3121 pprint(obj_decoded, big_blobs=True, with_decode_path=True)
3122 self.assertEqual(tail, tail_junk)
3123 self.assertEqual(obj_decoded, obj_expled)
3124 self.assertNotEqual(obj_decoded, obj)
3125 self.assertEqual(int(obj_decoded), int(obj_expled))
3126 self.assertEqual(int(obj_decoded), int(obj))
3127 self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
3128 self.assertEqual(obj_decoded.expl_tag, tag_expl)
3129 self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
3131 obj_decoded.expl_llen,
3132 len(len_encode(len(obj_encoded))),
3134 self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
3135 self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
3138 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
3140 self.assertEqual(obj_decoded.expl_offset, offset)
3141 assert_exceeding_data(
3143 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
3149 def string_values_strategy(draw, alphabet, do_expl=False):
3150 bound_min, bound_max = sorted(draw(sets(
3151 integers(min_value=0, max_value=1 << 7),
3155 value = draw(one_of(
3157 text(alphabet=alphabet, min_size=bound_min, max_size=bound_max),
3159 default = draw(one_of(
3161 text(alphabet=alphabet, min_size=bound_min, max_size=bound_max),
3164 if draw(booleans()):
3165 bounds = (bound_min, bound_max)
3169 expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
3171 impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
3172 optional = draw(one_of(none(), booleans()))
3174 draw(integers(min_value=0)),
3175 draw(integers(min_value=0)),
3176 draw(integers(min_value=0)),
3178 return (value, bounds, impl, expl, default, optional, _decoded)
3181 class StringMixin(object):
3182 def test_invalid_value_type(self):
3183 with self.assertRaises(InvalidValueType) as err:
3184 self.base_klass((1, 2))
3187 def text_alphabet(self):
3188 if self.base_klass.encoding in ("ascii", "iso-8859-1"):
3189 return printable + whitespace
3193 def test_optional(self, optional):
3194 obj = self.base_klass(default=self.base_klass(""), optional=optional)
3195 self.assertTrue(obj.optional)
3197 @given(data_strategy())
3198 def test_ready(self, d):
3199 obj = self.base_klass()
3200 self.assertFalse(obj.ready)
3203 pprint(obj, big_blobs=True, with_decode_path=True)
3205 with self.assertRaises(ObjNotReady) as err:
3208 value = d.draw(text(alphabet=self.text_alphabet()))
3209 obj = self.base_klass(value)
3210 self.assertTrue(obj.ready)
3213 pprint(obj, big_blobs=True, with_decode_path=True)
3216 @given(data_strategy())
3217 def test_comparison(self, d):
3218 value1 = d.draw(text(alphabet=self.text_alphabet()))
3219 value2 = d.draw(text(alphabet=self.text_alphabet()))
3220 tag1 = d.draw(binary(min_size=1))
3221 tag2 = d.draw(binary(min_size=1))
3222 obj1 = self.base_klass(value1)
3223 obj2 = self.base_klass(value2)
3224 self.assertEqual(obj1 == obj2, value1 == value2)
3225 self.assertEqual(obj1 != obj2, value1 != value2)
3226 self.assertEqual(obj1 == bytes(obj2), value1 == value2)
3227 self.assertEqual(obj1 == text_type(obj2), value1 == value2)
3228 obj1 = self.base_klass(value1, impl=tag1)
3229 obj2 = self.base_klass(value1, impl=tag2)
3230 self.assertEqual(obj1 == obj2, tag1 == tag2)
3231 self.assertEqual(obj1 != obj2, tag1 != tag2)
3233 @given(data_strategy())
3234 def test_bounds_satisfied(self, d):
3235 bound_min = d.draw(integers(min_value=0, max_value=1 << 7))
3236 bound_max = d.draw(integers(min_value=bound_min, max_value=1 << 7))
3237 value = d.draw(text(
3238 alphabet=self.text_alphabet(),
3242 self.base_klass(value=value, bounds=(bound_min, bound_max))
3244 @given(data_strategy())
3245 def test_bounds_unsatisfied(self, d):
3246 bound_min = d.draw(integers(min_value=1, max_value=1 << 7))
3247 bound_max = d.draw(integers(min_value=bound_min, max_value=1 << 7))
3248 value = d.draw(text(alphabet=self.text_alphabet(), max_size=bound_min - 1))
3249 with self.assertRaises(BoundsError) as err:
3250 self.base_klass(value=value, bounds=(bound_min, bound_max))
3252 with assertRaisesRegex(self, DecodeError, "bounds") as err:
3253 self.base_klass(bounds=(bound_min, bound_max)).decode(
3254 self.base_klass(value).encode()
3257 value = d.draw(text(alphabet=self.text_alphabet(), min_size=bound_max + 1))
3258 with self.assertRaises(BoundsError) as err:
3259 self.base_klass(value=value, bounds=(bound_min, bound_max))
3261 with assertRaisesRegex(self, DecodeError, "bounds") as err:
3262 self.base_klass(bounds=(bound_min, bound_max)).decode(
3263 self.base_klass(value).encode()
3267 @given(data_strategy())
3268 def test_call(self, d):
3277 ) = d.draw(string_values_strategy(self.text_alphabet()))
3278 obj_initial = self.base_klass(
3284 optional_initial or False,
3295 ) = d.draw(string_values_strategy(
3296 self.text_alphabet(),
3297 do_expl=impl_initial is None,
3299 if (default is None) and (obj_initial.default is not None):
3302 (bounds is None) and
3303 (value is not None) and
3304 (bounds_initial is not None) and
3305 not (bounds_initial[0] <= len(value) <= bounds_initial[1])
3309 (bounds is None) and
3310 (default is not None) and
3311 (bounds_initial is not None) and
3312 not (bounds_initial[0] <= len(default) <= bounds_initial[1])
3315 obj = obj_initial(value, bounds, impl, expl, default, optional)
3317 value_expected = default if value is None else value
3319 default_initial if value_expected is None
3322 self.assertEqual(obj, value_expected)
3323 self.assertEqual(obj.tag, impl or impl_initial or obj.tag_default)
3324 self.assertEqual(obj.expl_tag, expl or expl_initial)
3327 default_initial if default is None else default,
3329 if obj.default is None:
3330 optional = optional_initial if optional is None else optional
3331 optional = False if optional is None else optional
3334 self.assertEqual(obj.optional, optional)
3336 (obj._bound_min, obj._bound_max),
3337 bounds or bounds_initial or (0, float("+inf")),
3340 @given(data_strategy())
3341 def test_copy(self, d):
3342 values = d.draw(string_values_strategy(self.text_alphabet()))
3343 obj = self.base_klass(*values)
3344 for copy_func in copy_funcs:
3345 obj_copied = copy_func(obj)
3346 self.assert_copied_basic_fields(obj, obj_copied)
3347 self.assertEqual(obj._bound_min, obj_copied._bound_min)
3348 self.assertEqual(obj._bound_max, obj_copied._bound_max)
3349 self.assertEqual(obj._value, obj_copied._value)
3351 @given(data_strategy())
3352 def test_stripped(self, d):
3353 value = d.draw(text(alphabet=self.text_alphabet()))
3354 tag_impl = tag_encode(d.draw(integers(min_value=1)))
3355 obj = self.base_klass(value, impl=tag_impl)
3356 with self.assertRaises(NotEnoughData):
3357 obj.decode(obj.encode()[:-1])
3359 @given(data_strategy())
3360 def test_stripped_expl(self, d):
3361 value = d.draw(text(alphabet=self.text_alphabet()))
3362 tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
3363 obj = self.base_klass(value, expl=tag_expl)
3364 with self.assertRaises(NotEnoughData):
3365 obj.decode(obj.encode()[:-1])
3368 integers(min_value=31),
3369 integers(min_value=0),
3372 def test_bad_tag(self, tag, offset, decode_path):
3373 with self.assertRaises(DecodeError) as err:
3374 self.base_klass().decode(
3375 tag_encode(tag)[:-1],
3377 decode_path=decode_path,
3380 self.assertEqual(err.exception.offset, offset)
3381 self.assertEqual(err.exception.decode_path, decode_path)
3384 integers(min_value=128),
3385 integers(min_value=0),
3388 def test_bad_len(self, l, offset, decode_path):
3389 with self.assertRaises(DecodeError) as err:
3390 self.base_klass().decode(
3391 self.base_klass.tag_default + len_encode(l)[:-1],
3393 decode_path=decode_path,
3396 self.assertEqual(err.exception.offset, offset)
3397 self.assertEqual(err.exception.decode_path, decode_path)
3400 sets(integers(min_value=0, max_value=10), min_size=2, max_size=2),
3401 integers(min_value=0),
3404 def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
3405 value, bound_min = list(sorted(ints))
3407 class String(self.base_klass):
3408 # Multiply this value by four, to satisfy UTF-32 bounds
3409 # (4 bytes per character) validation
3410 bounds = (bound_min * 4, bound_min * 4)
3411 with self.assertRaises(DecodeError) as err:
3413 self.base_klass(b"\x00\x00\x00\x00" * value).encode(),
3415 decode_path=decode_path,
3418 self.assertEqual(err.exception.offset, offset)
3419 self.assertEqual(err.exception.decode_path, decode_path)
3421 @given(data_strategy())
3422 def test_symmetric(self, d):
3423 values = d.draw(string_values_strategy(self.text_alphabet()))
3424 value = d.draw(text(alphabet=self.text_alphabet()))
3425 tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
3426 offset = d.draw(integers(min_value=0))
3427 tail_junk = d.draw(binary(max_size=5))
3428 _, _, _, _, default, optional, _decoded = values
3429 obj = self.base_klass(
3437 pprint(obj, big_blobs=True, with_decode_path=True)
3438 self.assertFalse(obj.expled)
3439 obj_encoded = obj.encode()
3440 obj_expled = obj(value, expl=tag_expl)
3441 self.assertTrue(obj_expled.expled)
3443 list(obj_expled.pps())
3444 pprint(obj_expled, big_blobs=True, with_decode_path=True)
3445 obj_expled_encoded = obj_expled.encode()
3446 ctx_copied = deepcopy(ctx_dummy)
3447 obj_decoded, tail = obj_expled.decode(
3448 obj_expled_encoded + tail_junk,
3452 self.assertDictEqual(ctx_copied, ctx_dummy)
3454 list(obj_decoded.pps())
3455 pprint(obj_decoded, big_blobs=True, with_decode_path=True)
3456 self.assertEqual(tail, tail_junk)
3457 self.assertEqual(obj_decoded, obj_expled)
3458 self.assertNotEqual(obj_decoded, obj)
3459 self.assertEqual(bytes(obj_decoded), bytes(obj_expled))
3460 self.assertEqual(bytes(obj_decoded), bytes(obj))
3461 self.assertEqual(text_type(obj_decoded), text_type(obj_expled))
3462 self.assertEqual(text_type(obj_decoded), text_type(obj))
3463 self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
3464 self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
3465 self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
3467 obj_decoded.expl_llen,
3468 len(len_encode(len(obj_encoded))),
3470 self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
3471 self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
3474 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
3476 self.assertEqual(obj_decoded.expl_offset, offset)
3477 assert_exceeding_data(
3479 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
3484 class TestUTF8String(StringMixin, CommonMixin, TestCase):
3485 base_klass = UTF8String
3488 cyrillic_letters = text(
3489 alphabet="".join(six_unichr(i) for i in list(range(0x0410, 0x044f + 1))),
3495 class UnicodeDecodeErrorMixin(object):
3496 @given(cyrillic_letters)
3497 def test_unicode_decode_error(self, cyrillic_text):
3498 with self.assertRaises(DecodeError):
3499 self.base_klass(cyrillic_text)
3502 class TestNumericString(StringMixin, CommonMixin, TestCase):
3503 base_klass = NumericString
3505 def text_alphabet(self):
3508 @given(text(alphabet=ascii_letters, min_size=1, max_size=5))
3509 def test_non_numeric(self, non_numeric_text):
3510 with assertRaisesRegex(self, DecodeError, "non-numeric"):
3511 self.base_klass(non_numeric_text)
3514 sets(integers(min_value=0, max_value=10), min_size=2, max_size=2),
3515 integers(min_value=0),
3518 def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
3519 value, bound_min = list(sorted(ints))
3521 class String(self.base_klass):
3522 bounds = (bound_min, bound_min)
3523 with self.assertRaises(DecodeError) as err:
3525 self.base_klass(b"1" * value).encode(),
3527 decode_path=decode_path,
3530 self.assertEqual(err.exception.offset, offset)
3531 self.assertEqual(err.exception.decode_path, decode_path)
3534 class TestPrintableString(
3535 UnicodeDecodeErrorMixin,
3540 base_klass = PrintableString
3542 def text_alphabet(self):
3543 return ascii_letters + digits + " '()+,-./:=?"
3545 @given(text(alphabet=sorted(set(whitespace) - set(" ")), min_size=1, max_size=5))
3546 def test_non_printable(self, non_printable_text):
3547 with assertRaisesRegex(self, DecodeError, "non-printable"):
3548 self.base_klass(non_printable_text)
3551 sets(integers(min_value=0, max_value=10), min_size=2, max_size=2),
3552 integers(min_value=0),
3555 def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
3556 value, bound_min = list(sorted(ints))
3558 class String(self.base_klass):
3559 bounds = (bound_min, bound_min)
3560 with self.assertRaises(DecodeError) as err:
3562 self.base_klass(b"1" * value).encode(),
3564 decode_path=decode_path,
3567 self.assertEqual(err.exception.offset, offset)
3568 self.assertEqual(err.exception.decode_path, decode_path)
3570 def test_allowable_invalid_chars(self):
3572 ("*", {"allow_asterisk": True}),
3573 ("&", {"allow_ampersand": True}),
3574 ("&*", {"allow_asterisk": True, "allow_ampersand": True}),
3577 obj = self.base_klass(s)
3578 for prop in kwargs.keys():
3579 self.assertFalse(getattr(obj, prop))
3581 with assertRaisesRegex(self, DecodeError, "non-printable"):
3583 self.base_klass(s, **kwargs)
3584 klass = self.base_klass(**kwargs)
3586 for prop in kwargs.keys():
3587 self.assertTrue(getattr(obj, prop))
3590 for prop in kwargs.keys():
3591 self.assertTrue(getattr(obj, prop))
3594 class TestTeletexString(
3595 UnicodeDecodeErrorMixin,
3600 base_klass = TeletexString
3603 class TestVideotexString(
3604 UnicodeDecodeErrorMixin,
3609 base_klass = VideotexString
3612 class TestIA5String(
3613 UnicodeDecodeErrorMixin,
3618 base_klass = IA5String
3621 class TestGraphicString(
3622 UnicodeDecodeErrorMixin,
3627 base_klass = GraphicString
3630 class TestVisibleString(
3631 UnicodeDecodeErrorMixin,
3636 base_klass = VisibleString
3638 def test_x690_vector(self):
3639 obj, tail = VisibleString().decode(hexdec("1A054A6F6E6573"))
3640 self.assertSequenceEqual(tail, b"")
3641 self.assertEqual(str(obj), "Jones")
3642 self.assertFalse(obj.ber_encoded)
3643 self.assertFalse(obj.lenindef)
3644 self.assertFalse(obj.bered)
3646 obj, tail = VisibleString().decode(
3647 hexdec("3A0904034A6F6E04026573"),
3648 ctx={"bered": True},
3650 self.assertSequenceEqual(tail, b"")
3651 self.assertEqual(str(obj), "Jones")
3652 self.assertTrue(obj.ber_encoded)
3653 self.assertFalse(obj.lenindef)
3654 self.assertTrue(obj.bered)
3656 self.assertTrue(obj.ber_encoded)
3657 self.assertFalse(obj.lenindef)
3658 self.assertTrue(obj.bered)
3660 obj, tail = VisibleString().decode(
3661 hexdec("3A8004034A6F6E040265730000"),
3662 ctx={"bered": True},
3664 self.assertSequenceEqual(tail, b"")
3665 self.assertEqual(str(obj), "Jones")
3666 self.assertTrue(obj.ber_encoded)
3667 self.assertTrue(obj.lenindef)
3668 self.assertTrue(obj.bered)
3670 self.assertTrue(obj.ber_encoded)
3671 self.assertTrue(obj.lenindef)
3672 self.assertTrue(obj.bered)
3675 class TestGeneralString(
3676 UnicodeDecodeErrorMixin,
3681 base_klass = GeneralString
3684 class TestUniversalString(StringMixin, CommonMixin, TestCase):
3685 base_klass = UniversalString
3688 class TestBMPString(StringMixin, CommonMixin, TestCase):
3689 base_klass = BMPString
3693 def generalized_time_values_strategy(
3701 if draw(booleans()):
3702 value = draw(datetimes(min_value=min_datetime, max_value=max_datetime))
3704 value = value.replace(microsecond=0)
3706 if draw(booleans()):
3707 default = draw(datetimes(min_value=min_datetime, max_value=max_datetime))
3709 default = default.replace(microsecond=0)
3713 expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
3715 impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
3716 optional = draw(one_of(none(), booleans()))
3718 draw(integers(min_value=0)),
3719 draw(integers(min_value=0)),
3720 draw(integers(min_value=0)),
3722 return (value, impl, expl, default, optional, _decoded)
3725 class TimeMixin(object):
3726 def test_invalid_value_type(self):
3727 with self.assertRaises(InvalidValueType) as err:
3728 self.base_klass(datetime.now().timetuple())
3731 @given(data_strategy())
3732 def test_optional(self, d):
3733 default = d.draw(datetimes(
3734 min_value=self.min_datetime,
3735 max_value=self.max_datetime,
3737 optional = d.draw(booleans())
3738 obj = self.base_klass(default=default, optional=optional)
3739 self.assertTrue(obj.optional)
3741 @given(data_strategy())
3742 def test_ready(self, d):
3743 obj = self.base_klass()
3744 self.assertFalse(obj.ready)
3747 pprint(obj, big_blobs=True, with_decode_path=True)
3748 with self.assertRaises(ObjNotReady) as err:
3751 value = d.draw(datetimes(
3752 min_value=self.min_datetime,
3753 max_value=self.max_datetime,
3755 obj = self.base_klass(value)
3756 self.assertTrue(obj.ready)
3759 pprint(obj, big_blobs=True, with_decode_path=True)
3761 @given(data_strategy())
3762 def test_comparison(self, d):
3763 value1 = d.draw(datetimes(
3764 min_value=self.min_datetime,
3765 max_value=self.max_datetime,
3767 value2 = d.draw(datetimes(
3768 min_value=self.min_datetime,
3769 max_value=self.max_datetime,
3771 tag1 = d.draw(binary(min_size=1))
3772 tag2 = d.draw(binary(min_size=1))
3774 value1 = value1.replace(microsecond=0)
3775 value2 = value2.replace(microsecond=0)
3776 obj1 = self.base_klass(value1)
3777 obj2 = self.base_klass(value2)
3778 self.assertEqual(obj1 == obj2, value1 == value2)
3779 self.assertEqual(obj1 != obj2, value1 != value2)
3780 self.assertEqual(obj1 == obj2.todatetime(), value1 == value2)
3781 self.assertEqual(obj1 == bytes(obj2), value1 == value2)
3782 obj1 = self.base_klass(value1, impl=tag1)
3783 obj2 = self.base_klass(value1, impl=tag2)
3784 self.assertEqual(obj1 == obj2, tag1 == tag2)
3785 self.assertEqual(obj1 != obj2, tag1 != tag2)
3787 @given(data_strategy())
3788 def test_call(self, d):
3796 ) = d.draw(generalized_time_values_strategy(
3797 min_datetime=self.min_datetime,
3798 max_datetime=self.max_datetime,
3799 omit_ms=self.omit_ms,
3801 obj_initial = self.base_klass(
3802 value=value_initial,
3805 default=default_initial,
3806 optional=optional_initial or False,
3807 _decoded=_decoded_initial,
3816 ) = d.draw(generalized_time_values_strategy(
3817 min_datetime=self.min_datetime,
3818 max_datetime=self.max_datetime,
3819 omit_ms=self.omit_ms,
3820 do_expl=impl_initial is None,
3830 value_expected = default if value is None else value
3832 default_initial if value_expected is None
3835 self.assertEqual(obj, value_expected)
3836 self.assertEqual(obj.tag, impl or impl_initial or obj.tag_default)
3837 self.assertEqual(obj.expl_tag, expl or expl_initial)
3840 default_initial if default is None else default,
3842 if obj.default is None:
3843 optional = optional_initial if optional is None else optional
3844 optional = False if optional is None else optional
3847 self.assertEqual(obj.optional, optional)
3849 @given(data_strategy())
3850 def test_copy(self, d):
3851 values = d.draw(generalized_time_values_strategy(
3852 min_datetime=self.min_datetime,
3853 max_datetime=self.max_datetime,
3855 obj = self.base_klass(*values)
3856 for copy_func in copy_funcs:
3857 obj_copied = copy_func(obj)
3858 self.assert_copied_basic_fields(obj, obj_copied)
3859 self.assertEqual(obj._value, obj_copied._value)
3861 @given(data_strategy())
3862 def test_stripped(self, d):
3863 value = d.draw(datetimes(
3864 min_value=self.min_datetime,
3865 max_value=self.max_datetime,
3867 tag_impl = tag_encode(d.draw(integers(min_value=1)))
3868 obj = self.base_klass(value, impl=tag_impl)
3869 with self.assertRaises(NotEnoughData):
3870 obj.decode(obj.encode()[:-1])
3872 @given(data_strategy())
3873 def test_stripped_expl(self, d):
3874 value = d.draw(datetimes(
3875 min_value=self.min_datetime,
3876 max_value=self.max_datetime,
3878 tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
3879 obj = self.base_klass(value, expl=tag_expl)
3880 with self.assertRaises(NotEnoughData):
3881 obj.decode(obj.encode()[:-1])
3883 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
3884 @given(data_strategy())
3885 def test_symmetric(self, d):
3886 values = d.draw(generalized_time_values_strategy(
3887 min_datetime=self.min_datetime,
3888 max_datetime=self.max_datetime,
3890 value = d.draw(datetimes(
3891 min_value=self.min_datetime,
3892 max_value=self.max_datetime,
3894 tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
3895 offset = d.draw(integers(min_value=0))
3896 tail_junk = d.draw(binary(max_size=5))
3897 _, _, _, default, optional, _decoded = values
3898 obj = self.base_klass(
3906 pprint(obj, big_blobs=True, with_decode_path=True)
3907 self.assertFalse(obj.expled)
3908 obj_encoded = obj.encode()
3909 self.additional_symmetric_check(value, obj_encoded)
3910 obj_expled = obj(value, expl=tag_expl)
3911 self.assertTrue(obj_expled.expled)
3913 list(obj_expled.pps())
3914 pprint(obj_expled, big_blobs=True, with_decode_path=True)
3915 obj_expled_encoded = obj_expled.encode()
3916 ctx_copied = deepcopy(ctx_dummy)
3917 obj_decoded, tail = obj_expled.decode(
3918 obj_expled_encoded + tail_junk,
3922 self.assertDictEqual(ctx_copied, ctx_dummy)
3924 list(obj_decoded.pps())
3925 pprint(obj_decoded, big_blobs=True, with_decode_path=True)
3926 self.assertEqual(tail, tail_junk)
3927 self.assertEqual(obj_decoded, obj_expled)
3928 self.assertEqual(obj_decoded.todatetime(), obj_expled.todatetime())
3929 self.assertEqual(obj_decoded.todatetime(), obj.todatetime())
3930 self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
3931 self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
3932 self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
3934 obj_decoded.expl_llen,
3935 len(len_encode(len(obj_encoded))),
3937 self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
3938 self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
3941 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
3943 self.assertEqual(obj_decoded.expl_offset, offset)
3944 assert_exceeding_data(
3946 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
3951 class TestGeneralizedTime(TimeMixin, CommonMixin, TestCase):
3952 base_klass = GeneralizedTime
3954 min_datetime = datetime(1900, 1, 1)
3955 max_datetime = datetime(9999, 12, 31)
3957 def additional_symmetric_check(self, value, obj_encoded):
3958 if value.microsecond > 0:
3959 self.assertFalse(obj_encoded.endswith(b"0Z"))
3961 def test_repr_not_ready(self):
3962 unicode(GeneralizedTime()) if PY2 else str(GeneralizedTime())
3963 repr(GeneralizedTime())
3965 def test_x690_vector_valid(self):
3969 b"19920722132100.3Z",
3971 GeneralizedTime(data)
3973 def test_x690_vector_invalid(self):
3976 b"19920622123421.0Z",
3977 b"19920722132100.30Z",
3979 with self.assertRaises(DecodeError) as err:
3980 GeneralizedTime(data)
3983 def test_go_vectors_invalid(self):
3995 b"-20100102030410Z",
3996 b"2010-0102030410Z",
3997 b"2010-0002030410Z",
3998 b"201001-02030410Z",
3999 b"20100102-030410Z",
4000 b"2010010203-0410Z",
4001 b"201001020304-10Z",
4002 # These ones are INVALID in *DER*, but accepted
4003 # by Go's encoding/asn1
4004 b"20100102030405+0607",
4005 b"20100102030405-0607",
4007 with self.assertRaises(DecodeError) as err:
4008 GeneralizedTime(data)
4011 def test_go_vectors_valid(self):
4013 GeneralizedTime(b"20100102030405Z").todatetime(),
4014 datetime(2010, 1, 2, 3, 4, 5, 0),
4017 def test_go_vectors_valid_ber(self):
4019 b"20100102030405+0607",
4020 b"20100102030405-0607",
4022 GeneralizedTime(data, ctx={"bered": True})
4024 def test_utc_offsets(self):
4025 """Some know equal UTC offsets
4028 GeneralizedTime(data.encode("ascii"), ctx={"bered": True})
4032 "200101011130-0700",
4033 "200101011500-03:30",
4036 self.assertEqual(dts[0], dts[1])
4037 self.assertEqual(dts[0], dts[2])
4038 self.assertEqual(dts[0], dts[3])
4040 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
4041 @given(data_strategy())
4042 def test_valid_ber(self, d):
4043 min_year = 1901 if PY2 else 2
4044 year = d.draw(integers(min_value=min_year, max_value=9999))
4045 month = d.draw(integers(min_value=1, max_value=12))
4046 day = d.draw(integers(min_value=1, max_value=28))
4047 hours = d.draw(integers(min_value=0, max_value=23))
4048 data = "%04d%02d%02d%02d" % (year, month, day, hours)
4049 dt = datetime(year, month, day, hours)
4050 fractions_sign = d.draw(sampled_from(" ,."))
4052 if fractions_sign != " ":
4053 fractions = random()
4054 if d.draw(booleans()):
4055 minutes = d.draw(integers(min_value=0, max_value=59))
4056 data += "%02d" % minutes
4057 dt += timedelta(seconds=60 * minutes)
4058 if d.draw(booleans()):
4059 seconds = d.draw(integers(min_value=0, max_value=59))
4060 data += "%02d" % seconds
4061 dt += timedelta(seconds=seconds)
4062 if fractions is not None:
4063 dt += timedelta(microseconds=10**6 * fractions)
4064 elif fractions is not None:
4065 dt += timedelta(seconds=60 * fractions)
4066 elif fractions is not None:
4067 dt += timedelta(seconds=3600 * fractions)
4068 if fractions is not None:
4069 data += fractions_sign + str(fractions)[2:]
4070 if d.draw(booleans()):
4072 elif d.draw(booleans()):
4073 offset_hour = d.draw(integers(min_value=0, max_value=13))
4075 if d.draw(booleans()):
4080 dt -= timedelta(seconds=sign * 3600 * offset_hour)
4081 data += "%02d" % offset_hour
4082 minutes_separator = d.draw(sampled_from((None, "", ":")))
4083 if minutes_separator is not None:
4084 offset_minute = d.draw(integers(min_value=0, max_value=59))
4085 dt -= timedelta(seconds=sign * 60 * offset_minute)
4086 data += "%s%02d" % (minutes_separator, offset_minute)
4087 data = data.encode("ascii")
4088 data = GeneralizedTime.tag_default + len_encode(len(data)) + data
4090 GeneralizedTime().decod(data)
4095 obj = GeneralizedTime().decod(data, ctx={"bered": True})
4098 mktime(obj.todatetime().timetuple()),
4099 mktime(dt.timetuple()),
4102 self.assertEqual(obj.todatetime().timestamp(), dt.timestamp())
4103 self.assertEqual(obj.ber_encoded, not dered)
4104 self.assertEqual(obj.bered, not dered)
4105 self.assertEqual(obj.encode() == data, dered)
4110 def test_invalid_ber(self):
4112 # "00010203040506.07",
4113 "-0010203040506.07",
4114 "0001-203040506.07",
4115 "000102-3040506.07",
4116 "00010203-40506.07",
4117 "0001020304-506.07",
4118 "000102030405-6.07",
4119 "00010203040506.-7",
4120 "+0010203040506.07",
4121 "0001+203040506.07",
4122 "000102+3040506.07",
4123 "00010203+40506.07",
4124 "0001020304+506.07",
4125 "000102030405+6.07",
4126 "00010203040506.+7",
4127 " 0010203040506.07",
4128 "0001 203040506.07",
4129 "000102 3040506.07",
4130 "00010203 40506.07",
4131 "0001020304 506.07",
4132 "000102030405 6.07",
4133 "00010203040506. 7",
4134 "001 0203040506.07",
4135 "00012 03040506.07",
4136 "0001023 040506.07",
4137 "000102034 0506.07",
4138 "00010203045 06.07",
4139 "0001020304056 .07",
4140 "00010203040506.7 ",
4220 "00010203040506.07+15",
4221 "00010203040506.07-15",
4222 "00010203040506.07+14:60",
4223 "00010203040506.07+1460",
4224 "00010203040506.07-1460",
4225 "00010203040506.07+00:60",
4226 "00010203040506.07-00:60",
4228 "00010203040506+15",
4229 "00010203040506-15",
4230 "00010203040506+14:60",
4231 "00010203040506+1460",
4232 "00010203040506-1460",
4233 "00010203040506+00:60",
4234 "00010203040506-00:60",
4243 with self.assertRaises(DecodeError):
4244 GeneralizedTime(data.encode("ascii"), ctx={"bered": True})
4245 data = data.replace(".", ",")
4246 with self.assertRaises(DecodeError):
4247 GeneralizedTime(data.encode("ascii"), ctx={"bered": True})
4251 min_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
4252 max_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
4254 binary(min_size=1, max_size=1),
4256 min_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
4257 max_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
4260 def test_junk(self, part0, part1, part2):
4261 junk = part0 + part1 + part2
4262 assume(not (set(junk) <= set(digits.encode("ascii"))))
4263 with self.assertRaises(DecodeError):
4264 GeneralizedTime().decode(
4265 GeneralizedTime.tag_default +
4266 len_encode(len(junk)) +
4272 min_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
4273 max_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
4275 binary(min_size=1, max_size=1),
4277 min_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
4278 max_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
4281 def test_junk_dm(self, part0, part1, part2):
4282 junk = part0 + part1 + part2
4283 assume(not (set(junk) <= set(digits.encode("ascii"))))
4284 with self.assertRaises(DecodeError):
4285 GeneralizedTime().decode(
4286 GeneralizedTime.tag_default +
4287 len_encode(len(junk)) +
4291 def test_ns_fractions(self):
4292 GeneralizedTime(b"20010101000000.000001Z")
4293 with assertRaisesRegex(self, DecodeError, "only microsecond fractions"):
4294 GeneralizedTime(b"20010101000000.0000001Z")
4296 def test_non_pure_integers(self):
4298 # b"20000102030405Z,
4305 b"20000102030405.+6Z",
4306 b"20000102030405.-6Z",
4313 b"20000102030405. 6Z",
4320 b"20000102030405.6 Z",
4322 with self.assertRaises(DecodeError):
4323 GeneralizedTime(data)
4326 class TestUTCTime(TimeMixin, CommonMixin, TestCase):
4327 base_klass = UTCTime
4329 min_datetime = datetime(2000, 1, 1)
4330 max_datetime = datetime(2049, 12, 31)
4332 def additional_symmetric_check(self, value, obj_encoded):
4335 def test_repr_not_ready(self):
4336 unicode(GeneralizedTime()) if PY2 else str(GeneralizedTime())
4339 def test_x690_vector_valid(self):
4347 def test_x690_vector_invalid(self):
4352 with self.assertRaises(DecodeError) as err:
4356 def test_go_vectors_invalid(self):
4382 # These ones are INVALID in *DER*, but accepted
4383 # by Go's encoding/asn1
4384 b"910506164540-0700",
4385 b"910506164540+0730",
4389 with self.assertRaises(DecodeError) as err:
4393 def test_go_vectors_valid(self):
4395 UTCTime(b"910506234540Z").todatetime(),
4396 datetime(1991, 5, 6, 23, 45, 40, 0),
4399 def test_non_pure_integers(self):
4421 with self.assertRaises(DecodeError):
4424 def test_x680_vector_valid_ber(self):
4426 (b"8201021200Z", datetime(1982, 1, 2, 12)),
4427 (b"8201020700-0500", datetime(1982, 1, 2, 12)),
4428 (b"0101021200Z", datetime(2001, 1, 2, 12)),
4429 (b"0101020700-0500", datetime(2001, 1, 2, 12)),
4431 data = UTCTime.tag_default + len_encode(len(data)) + data
4432 obj = UTCTime().decod(data, ctx={"bered": True})
4433 self.assertEqual(obj, dt)
4434 self.assertEqual(obj.todatetime(), dt)
4435 self.assertTrue(obj.ber_encoded)
4436 self.assertTrue(obj.bered)
4437 self.assertNotEqual(obj.encode(), data)
4440 def test_go_vectors_valid_ber(self):
4442 b"910506164540-0700",
4443 b"910506164540+0730",
4447 data = UTCTime.tag_default + len_encode(len(data)) + data
4448 obj = UTCTime().decod(data, ctx={"bered": True})
4449 self.assertTrue(obj.ber_encoded)
4450 self.assertTrue(obj.bered)
4451 self.assertNotEqual(obj.encode(), data)
4454 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
4455 @given(data_strategy())
4456 def test_valid_ber(self, d):
4457 year = d.draw(integers(min_value=0, max_value=99))
4458 month = d.draw(integers(min_value=1, max_value=12))
4459 day = d.draw(integers(min_value=1, max_value=28))
4460 hours = d.draw(integers(min_value=0, max_value=23))
4461 minute = d.draw(integers(min_value=0, max_value=59))
4462 data = "%02d%02d%02d%02d%02d" % (year, month, day, hours, minute)
4464 year + (2000 if year < 50 else 1900),
4471 if d.draw(booleans()):
4473 seconds = d.draw(integers(min_value=0, max_value=59))
4474 data += "%02d" % seconds
4475 dt += timedelta(seconds=seconds)
4476 if d.draw(booleans()):
4480 offset_hour = d.draw(integers(min_value=0, max_value=13))
4481 offset_minute = d.draw(integers(min_value=0, max_value=59))
4482 offset = timedelta(seconds=offset_hour * 3600 + offset_minute * 60)
4483 if d.draw(booleans()):
4489 data += "%02d%02d" % (offset_hour, offset_minute)
4490 data = data.encode("ascii")
4491 data = UTCTime.tag_default + len_encode(len(data)) + data
4492 obj = UTCTime().decod(data, ctx={"bered": True})
4493 self.assertEqual(obj, dt)
4494 self.assertEqual(obj.todatetime(), dt)
4495 self.assertEqual(obj.ber_encoded, not dered)
4496 self.assertEqual(obj.bered, not dered)
4497 self.assertEqual(obj.encode() == data, dered)
4502 def test_invalid_ber(self):
4543 b"0001020304+0000Z",
4552 with self.assertRaises(DecodeError):
4553 UTCTime(data, ctx={"bered": True})
4554 data = data[:8] + data[8+2:]
4555 with self.assertRaises(DecodeError):
4556 UTCTime(data, ctx={"bered": True})
4601 b"000102030405+000",
4602 b"000102030405+000Z",
4603 b"000102030405+0000Z",
4604 b"000102030405+-101",
4605 b"000102030405+01-1",
4606 b"000102030405+0060",
4607 b"000102030405+1401",
4608 b"500101000002+0003",
4610 with self.assertRaises(DecodeError):
4611 UTCTime(data, ctx={"bered": True})
4613 @given(integers(min_value=0, max_value=49))
4614 def test_pre50(self, year):
4616 UTCTime(("%02d1231235959Z" % year).encode("ascii")).todatetime().year,
4620 @given(integers(min_value=50, max_value=99))
4621 def test_post50(self, year):
4623 UTCTime(("%02d1231235959Z" % year).encode("ascii")).todatetime().year,
4629 min_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
4630 max_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
4632 binary(min_size=1, max_size=1),
4634 min_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
4635 max_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
4638 def test_junk(self, part0, part1, part2):
4639 junk = part0 + part1 + part2
4640 assume(not (set(junk) <= set(digits.encode("ascii"))))
4641 with self.assertRaises(DecodeError):
4643 UTCTime.tag_default +
4644 len_encode(len(junk)) +
4650 def any_values_strategy(draw, do_expl=False):
4651 value = draw(one_of(none(), binary()))
4654 expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
4655 optional = draw(one_of(none(), booleans()))
4657 draw(integers(min_value=0)),
4658 draw(integers(min_value=0)),
4659 draw(integers(min_value=0)),
4661 return (value, expl, optional, _decoded)
4664 class AnyInherited(Any):
4668 class TestAny(CommonMixin, TestCase):
4671 def test_invalid_value_type(self):
4672 with self.assertRaises(InvalidValueType) as err:
4677 def test_optional(self, optional):
4678 obj = Any(optional=optional)
4679 self.assertEqual(obj.optional, optional)
4682 def test_ready(self, value):
4684 self.assertFalse(obj.ready)
4687 pprint(obj, big_blobs=True, with_decode_path=True)
4688 with self.assertRaises(ObjNotReady) as err:
4692 self.assertTrue(obj.ready)
4695 pprint(obj, big_blobs=True, with_decode_path=True)
4698 def test_basic(self, value):
4699 integer_encoded = Integer(value).encode()
4701 Any(integer_encoded),
4702 Any(Integer(value)),
4703 Any(Any(Integer(value))),
4705 self.assertSequenceEqual(bytes(obj), integer_encoded)
4707 obj.decode(obj.encode())[0].vlen,
4708 len(integer_encoded),
4712 pprint(obj, big_blobs=True, with_decode_path=True)
4713 self.assertSequenceEqual(obj.encode(), integer_encoded)
4715 @given(binary(), binary())
4716 def test_comparison(self, value1, value2):
4717 for klass in (Any, AnyInherited):
4718 obj1 = klass(value1)
4719 obj2 = klass(value2)
4720 self.assertEqual(obj1 == obj2, value1 == value2)
4721 self.assertEqual(obj1 != obj2, value1 != value2)
4722 self.assertEqual(obj1 == bytes(obj2), value1 == value2)
4724 @given(data_strategy())
4725 def test_call(self, d):
4726 for klass in (Any, AnyInherited):
4732 ) = d.draw(any_values_strategy())
4733 obj_initial = klass(
4736 optional_initial or False,
4744 ) = d.draw(any_values_strategy(do_expl=True))
4745 obj = obj_initial(value, expl, optional)
4747 value_expected = None if value is None else value
4748 self.assertEqual(obj, value_expected)
4749 self.assertEqual(obj.expl_tag, expl or expl_initial)
4750 if obj.default is None:
4751 optional = optional_initial if optional is None else optional
4752 optional = False if optional is None else optional
4753 self.assertEqual(obj.optional, optional)
4755 def test_simultaneous_impl_expl(self):
4756 # override it, as Any does not have implicit tag
4759 def test_decoded(self):
4760 # override it, as Any does not have implicit tag
4763 @given(any_values_strategy())
4764 def test_copy(self, values):
4765 for klass in (Any, AnyInherited):
4766 obj = klass(*values)
4767 for copy_func in copy_funcs:
4768 obj_copied = copy_func(obj)
4769 self.assert_copied_basic_fields(obj, obj_copied)
4770 self.assertEqual(obj._value, obj_copied._value)
4772 @given(binary().map(OctetString))
4773 def test_stripped(self, value):
4775 with self.assertRaises(NotEnoughData):
4776 obj.decode(obj.encode()[:-1])
4780 integers(min_value=1).map(tag_ctxc),
4782 def test_stripped_expl(self, value, tag_expl):
4783 obj = Any(value, expl=tag_expl)
4784 with self.assertRaises(NotEnoughData):
4785 obj.decode(obj.encode()[:-1])
4788 integers(min_value=31),
4789 integers(min_value=0),
4792 def test_bad_tag(self, tag, offset, decode_path):
4793 with self.assertRaises(DecodeError) as err:
4795 tag_encode(tag)[:-1],
4797 decode_path=decode_path,
4800 self.assertEqual(err.exception.offset, offset)
4801 self.assertEqual(err.exception.decode_path, decode_path)
4804 integers(min_value=128),
4805 integers(min_value=0),
4808 def test_bad_len(self, l, offset, decode_path):
4809 with self.assertRaises(DecodeError) as err:
4811 Any.tag_default + len_encode(l)[:-1],
4813 decode_path=decode_path,
4816 self.assertEqual(err.exception.offset, offset)
4817 self.assertEqual(err.exception.decode_path, decode_path)
4819 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
4821 any_values_strategy(),
4822 integers().map(lambda x: Integer(x).encode()),
4823 integers(min_value=1).map(tag_ctxc),
4824 integers(min_value=0),
4827 def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
4828 for klass in (Any, AnyInherited):
4829 _, _, optional, _decoded = values
4830 obj = klass(value=value, optional=optional, _decoded=_decoded)
4833 pprint(obj, big_blobs=True, with_decode_path=True)
4834 self.assertFalse(obj.expled)
4835 obj_encoded = obj.encode()
4836 obj_expled = obj(value, expl=tag_expl)
4837 self.assertTrue(obj_expled.expled)
4839 list(obj_expled.pps())
4840 pprint(obj_expled, big_blobs=True, with_decode_path=True)
4841 obj_expled_encoded = obj_expled.encode()
4842 ctx_copied = deepcopy(ctx_dummy)
4843 obj_decoded, tail = obj_expled.decode(
4844 obj_expled_encoded + tail_junk,
4848 self.assertDictEqual(ctx_copied, ctx_dummy)
4850 list(obj_decoded.pps())
4851 pprint(obj_decoded, big_blobs=True, with_decode_path=True)
4852 self.assertEqual(tail, tail_junk)
4853 self.assertEqual(obj_decoded, obj_expled)
4854 self.assertEqual(bytes(obj_decoded), bytes(obj_expled))
4855 self.assertEqual(bytes(obj_decoded), bytes(obj))
4856 self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
4857 self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
4858 self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
4860 obj_decoded.expl_llen,
4861 len(len_encode(len(obj_encoded))),
4863 self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
4864 self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
4867 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
4869 self.assertEqual(obj_decoded.expl_offset, offset)
4870 self.assertEqual(obj_decoded.tlen, 0)
4871 self.assertEqual(obj_decoded.llen, 0)
4872 self.assertEqual(obj_decoded.vlen, len(value))
4873 assert_exceeding_data(
4875 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
4880 integers(min_value=1).map(tag_ctxc),
4881 integers(min_value=0, max_value=3),
4882 integers(min_value=0),
4886 def test_indefinite(self, expl, chunks, offset, decode_path, junk):
4887 chunk = Boolean(False, expl=expl).encode()
4889 OctetString.tag_default +
4891 b"".join([chunk] * chunks) +
4894 with self.assertRaises(LenIndefForm):
4898 decode_path=decode_path,
4900 obj, tail = Any().decode(
4903 decode_path=decode_path,
4904 ctx={"bered": True},
4906 self.assertSequenceEqual(tail, junk)
4907 self.assertEqual(obj.offset, offset)
4908 self.assertEqual(obj.tlvlen, len(encoded))
4909 self.assertTrue(obj.lenindef)
4910 self.assertFalse(obj.ber_encoded)
4911 self.assertTrue(obj.bered)
4913 self.assertTrue(obj.lenindef)
4914 self.assertFalse(obj.ber_encoded)
4915 self.assertTrue(obj.bered)
4918 pprint(obj, big_blobs=True, with_decode_path=True)
4919 with self.assertRaises(NotEnoughData) as err:
4923 decode_path=decode_path,
4924 ctx={"bered": True},
4926 self.assertEqual(err.exception.offset, offset + 1 + 1 + len(chunk) * chunks)
4927 self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),))
4929 class SeqOf(SequenceOf):
4930 schema = Boolean(expl=expl)
4932 class Seq(Sequence):
4934 ("type", ObjectIdentifier(defines=((("value",), {
4935 ObjectIdentifier("1.2.3"): SeqOf(impl=OctetString.tag_default),
4940 ("type", ObjectIdentifier("1.2.3")),
4941 ("value", Any(encoded)),
4943 seq_encoded = seq.encode()
4944 seq_decoded, _ = Seq().decode(seq_encoded, ctx={"bered": True})
4945 self.assertIsNotNone(seq_decoded["value"].defined)
4947 list(seq_decoded.pps())
4948 pprint(seq_decoded, big_blobs=True, with_decode_path=True)
4949 self.assertTrue(seq_decoded.bered)
4950 self.assertFalse(seq_decoded["type"].bered)
4951 self.assertTrue(seq_decoded["value"].bered)
4953 chunk = chunk[:-1] + b"\x01"
4954 chunks = b"".join([chunk] * (chunks + 1))
4955 encoded = OctetString.tag_default + len_encode(len(chunks)) + chunks
4957 ("type", ObjectIdentifier("1.2.3")),
4958 ("value", Any(encoded)),
4960 seq_encoded = seq.encode()
4961 seq_decoded, _ = Seq().decode(seq_encoded, ctx={"bered": True})
4962 self.assertIsNotNone(seq_decoded["value"].defined)
4964 list(seq_decoded.pps())
4965 pprint(seq_decoded, big_blobs=True, with_decode_path=True)
4966 self.assertTrue(seq_decoded.bered)
4967 self.assertFalse(seq_decoded["type"].bered)
4968 self.assertTrue(seq_decoded["value"].bered)
4972 def choice_values_strategy(draw, value_required=False, schema=None, do_expl=False):
4974 names = list(draw(sets(text_letters(), min_size=1, max_size=5)))
4975 tags = [{tag_type: tag_value} for tag_type, tag_value in draw(sets(
4977 tuples(just("impl"), integers(min_value=0).map(tag_encode)),
4978 tuples(just("expl"), integers(min_value=0).map(tag_ctxp)),
4980 min_size=len(names),
4981 max_size=len(names),
4984 (name, Integer(**tag_kwargs))
4985 for name, tag_kwargs in zip(names, tags)
4988 if value_required or draw(booleans()):
4989 value = draw(tuples(
4990 sampled_from([name for name, _ in schema]),
4991 integers().map(Integer),
4995 expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
4996 default = draw(one_of(
4998 tuples(sampled_from([name for name, _ in schema]), integers().map(Integer)),
5000 optional = draw(one_of(none(), booleans()))
5002 draw(integers(min_value=0)),
5003 draw(integers(min_value=0)),
5004 draw(integers(min_value=0)),
5006 return (schema, value, expl, default, optional, _decoded)
5009 class ChoiceInherited(Choice):
5013 class TestChoice(CommonMixin, TestCase):
5015 schema = (("whatever", Boolean()),)
5018 def test_schema_required(self):
5019 with assertRaisesRegex(self, ValueError, "schema must be specified"):
5022 def test_impl_forbidden(self):
5023 with assertRaisesRegex(self, ValueError, "no implicit tag allowed"):
5024 Choice(impl=b"whatever")
5026 def test_invalid_value_type(self):
5027 with self.assertRaises(InvalidValueType) as err:
5028 self.base_klass(123)
5030 with self.assertRaises(ObjUnknown) as err:
5031 self.base_klass(("whenever", Boolean(False)))
5033 with self.assertRaises(InvalidValueType) as err:
5034 self.base_klass(("whatever", Integer(123)))
5038 def test_optional(self, optional):
5039 obj = self.base_klass(
5040 default=self.base_klass(("whatever", Boolean(False))),
5043 self.assertTrue(obj.optional)
5046 def test_ready(self, value):
5047 obj = self.base_klass()
5048 self.assertFalse(obj.ready)
5051 pprint(obj, big_blobs=True, with_decode_path=True)
5052 self.assertIsNone(obj["whatever"])
5053 with self.assertRaises(ObjNotReady) as err:
5056 obj["whatever"] = Boolean()
5057 self.assertFalse(obj.ready)
5060 pprint(obj, big_blobs=True, with_decode_path=True)
5061 obj["whatever"] = Boolean(value)
5062 self.assertTrue(obj.ready)
5065 pprint(obj, big_blobs=True, with_decode_path=True)
5067 @given(booleans(), booleans())
5068 def test_comparison(self, value1, value2):
5069 class WahlInherited(self.base_klass):
5071 for klass in (self.base_klass, WahlInherited):
5072 obj1 = klass(("whatever", Boolean(value1)))
5073 obj2 = klass(("whatever", Boolean(value2)))
5074 self.assertEqual(obj1 == obj2, value1 == value2)
5075 self.assertEqual(obj1 != obj2, value1 != value2)
5076 self.assertEqual(obj1 == obj2._value, value1 == value2)
5077 self.assertFalse(obj1 == obj2._value[1])
5079 @given(data_strategy())
5080 def test_call(self, d):
5081 for klass in (Choice, ChoiceInherited):
5089 ) = d.draw(choice_values_strategy())
5092 schema = schema_initial
5094 value=value_initial,
5096 default=default_initial,
5097 optional=optional_initial or False,
5098 _decoded=_decoded_initial,
5107 ) = d.draw(choice_values_strategy(schema=schema_initial, do_expl=True))
5108 obj = obj_initial(value, expl, default, optional)
5110 value_expected = default if value is None else value
5112 default_initial if value_expected is None
5115 self.assertEqual(obj.choice, value_expected[0])
5116 self.assertEqual(obj.value, int(value_expected[1]))
5117 self.assertEqual(obj.expl_tag, expl or expl_initial)
5118 default_expect = default_initial if default is None else default
5119 if default_expect is not None:
5120 self.assertEqual(obj.default.choice, default_expect[0])
5121 self.assertEqual(obj.default.value, int(default_expect[1]))
5122 if obj.default is None:
5123 optional = optional_initial if optional is None else optional
5124 optional = False if optional is None else optional
5127 self.assertEqual(obj.optional, optional)
5128 self.assertEqual(obj.specs, obj_initial.specs)
5130 def test_simultaneous_impl_expl(self):
5131 # override it, as Any does not have implicit tag
5134 def test_decoded(self):
5135 # override it, as Any does not have implicit tag
5138 @given(choice_values_strategy())
5139 def test_copy(self, values):
5140 _schema, value, expl, default, optional, _decoded = values
5142 class Wahl(self.base_klass):
5144 register_class(Wahl)
5149 optional=optional or False,
5152 for copy_func in copy_funcs:
5153 obj_copied = copy_func(obj)
5154 self.assertIsNone(obj.tag)
5155 self.assertIsNone(obj_copied.tag)
5156 # hack for assert_copied_basic_fields
5157 obj.tag = "whatever"
5158 obj_copied.tag = "whatever"
5159 self.assert_copied_basic_fields(obj, obj_copied)
5161 self.assertEqual(obj._value, obj_copied._value)
5162 self.assertEqual(obj.specs, obj_copied.specs)
5165 def test_stripped(self, value):
5166 obj = self.base_klass(("whatever", Boolean(value)))
5167 with self.assertRaises(NotEnoughData):
5168 obj.decode(obj.encode()[:-1])
5172 integers(min_value=1).map(tag_ctxc),
5174 def test_stripped_expl(self, value, tag_expl):
5175 obj = self.base_klass(("whatever", Boolean(value)), expl=tag_expl)
5176 with self.assertRaises(NotEnoughData):
5177 obj.decode(obj.encode()[:-1])
5179 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
5180 @given(data_strategy())
5181 def test_symmetric(self, d):
5182 _schema, value, _, default, optional, _decoded = d.draw(
5183 choice_values_strategy(value_required=True)
5185 tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
5186 offset = d.draw(integers(min_value=0))
5187 tail_junk = d.draw(binary(max_size=5))
5189 class Wahl(self.base_klass):
5199 pprint(obj, big_blobs=True, with_decode_path=True)
5200 self.assertFalse(obj.expled)
5201 obj_encoded = obj.encode()
5202 obj_expled = obj(value, expl=tag_expl)
5203 self.assertTrue(obj_expled.expled)
5205 list(obj_expled.pps())
5206 pprint(obj_expled, big_blobs=True, with_decode_path=True)
5207 obj_expled_encoded = obj_expled.encode()
5208 ctx_copied = deepcopy(ctx_dummy)
5209 obj_decoded, tail = obj_expled.decode(
5210 obj_expled_encoded + tail_junk,
5214 self.assertDictEqual(ctx_copied, ctx_dummy)
5216 list(obj_decoded.pps())
5217 pprint(obj_decoded, big_blobs=True, with_decode_path=True)
5218 self.assertEqual(tail, tail_junk)
5219 self.assertEqual(obj_decoded, obj_expled)
5220 self.assertEqual(obj_decoded.choice, obj_expled.choice)
5221 self.assertEqual(obj_decoded.value, obj_expled.value)
5222 self.assertEqual(obj_decoded.choice, obj.choice)
5223 self.assertEqual(obj_decoded.value, obj.value)
5224 self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
5225 self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
5226 self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
5228 obj_decoded.expl_llen,
5229 len(len_encode(len(obj_encoded))),
5231 self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
5232 self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
5235 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
5237 self.assertEqual(obj_decoded.expl_offset, offset)
5238 self.assertSequenceEqual(
5240 obj_decoded.value.fulloffset - offset:
5241 obj_decoded.value.fulloffset + obj_decoded.value.fulllen - offset
5245 assert_exceeding_data(
5247 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
5252 def test_set_get(self, value):
5255 ("erste", Boolean()),
5256 ("zweite", Integer()),
5259 with self.assertRaises(ObjUnknown) as err:
5260 obj["whatever"] = "whenever"
5261 with self.assertRaises(InvalidValueType) as err:
5262 obj["zweite"] = Boolean(False)
5263 obj["zweite"] = Integer(value)
5265 with self.assertRaises(ObjUnknown) as err:
5268 self.assertIsNone(obj["erste"])
5269 self.assertEqual(obj["zweite"], Integer(value))
5271 def test_tag_mismatch(self):
5274 ("erste", Boolean()),
5276 int_encoded = Integer(123).encode()
5277 bool_encoded = Boolean(False).encode()
5279 obj.decode(bool_encoded)
5280 with self.assertRaises(TagMismatch):
5281 obj.decode(int_encoded)
5283 def test_tag_mismatch_underlying(self):
5284 class SeqOfBoolean(SequenceOf):
5287 class SeqOfInteger(SequenceOf):
5292 ("erste", SeqOfBoolean()),
5295 int_encoded = SeqOfInteger((Integer(123),)).encode()
5296 bool_encoded = SeqOfBoolean((Boolean(False),)).encode()
5298 obj.decode(bool_encoded)
5299 with self.assertRaises(TagMismatch) as err:
5300 obj.decode(int_encoded)
5301 self.assertEqual(err.exception.decode_path, ("erste", "0"))
5305 def seq_values_strategy(draw, seq_klass, do_expl=False):
5307 if draw(booleans()):
5309 value._value = draw(dictionaries(
5312 booleans().map(Boolean),
5313 integers().map(Integer),
5317 if draw(booleans()):
5318 schema = list(draw(dictionaries(
5321 booleans().map(Boolean),
5322 integers().map(Integer),
5328 expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
5330 impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
5332 if draw(booleans()):
5333 default = seq_klass()
5334 default._value = draw(dictionaries(
5337 booleans().map(Boolean),
5338 integers().map(Integer),
5341 optional = draw(one_of(none(), booleans()))
5343 draw(integers(min_value=0)),
5344 draw(integers(min_value=0)),
5345 draw(integers(min_value=0)),
5347 return (value, schema, impl, expl, default, optional, _decoded)
5351 def sequence_strategy(draw, seq_klass):
5352 inputs = draw(lists(
5354 tuples(just(Boolean), booleans(), one_of(none(), booleans())),
5355 tuples(just(Integer), integers(), one_of(none(), integers())),
5360 integers(min_value=1),
5361 min_size=len(inputs),
5362 max_size=len(inputs),
5365 ({"expl": tag_ctxc(tag)} if expled else {"impl": tag_encode(tag)})
5366 for tag, expled in zip(tags, draw(lists(
5368 min_size=len(inputs),
5369 max_size=len(inputs),
5373 for i, optional in enumerate(draw(lists(
5374 sampled_from(("required", "optional", "empty")),
5375 min_size=len(inputs),
5376 max_size=len(inputs),
5378 if optional in ("optional", "empty"):
5379 inits[i]["optional"] = True
5380 if optional == "empty":
5382 empties = set(empties)
5383 names = list(draw(sets(
5385 min_size=len(inputs),
5386 max_size=len(inputs),
5389 for i, (klass, value, default) in enumerate(inputs):
5390 schema.append((names[i], klass(default=default, **inits[i])))
5391 seq_name = draw(text_letters())
5392 Seq = type(seq_name, (seq_klass,), {"schema": tuple(schema)})
5395 for i, (klass, value, default) in enumerate(inputs):
5402 "default_value": None if spec.default is None else default,
5406 expect["optional"] = True
5408 expect["presented"] = True
5409 expect["value"] = value
5411 expect["optional"] = True
5412 if default is not None and default == value:
5413 expect["presented"] = False
5414 seq[name] = klass(value)
5415 expects.append(expect)
5420 def sequences_strategy(draw, seq_klass):
5421 tags = draw(sets(integers(min_value=1), min_size=0, max_size=5))
5423 ({"expl": tag_ctxc(tag)} if expled else {"impl": tag_encode(tag)})
5424 for tag, expled in zip(tags, draw(lists(
5431 i for i, is_default in enumerate(draw(lists(
5437 names = list(draw(sets(
5442 seq_expectses = draw(lists(
5443 sequence_strategy(seq_klass=seq_klass),
5447 seqs = [seq for seq, _ in seq_expectses]
5449 for i, (name, seq) in enumerate(zip(names, seqs)):
5452 seq(default=(seq if i in defaulted else None), **inits[i]),
5454 seq_name = draw(text_letters())
5455 Seq = type(seq_name, (seq_klass,), {"schema": tuple(schema)})
5458 for name, (seq_inner, expects_inner) in zip(names, seq_expectses):
5461 "expects": expects_inner,
5464 seq_outer[name] = seq_inner
5465 if seq_outer.specs[name].default is None:
5466 expect["presented"] = True
5467 expect_outers.append(expect)
5468 return seq_outer, expect_outers
5471 class SeqMixing(object):
5472 def test_invalid_value_type(self):
5473 with self.assertRaises(InvalidValueType) as err:
5474 self.base_klass(123)
5477 def test_invalid_value_type_set(self):
5478 class Seq(self.base_klass):
5479 schema = (("whatever", Boolean()),)
5481 with self.assertRaises(InvalidValueType) as err:
5482 seq["whatever"] = Integer(123)
5486 def test_optional(self, optional):
5487 obj = self.base_klass(default=self.base_klass(), optional=optional)
5488 self.assertTrue(obj.optional)
5490 @given(data_strategy())
5491 def test_ready(self, d):
5493 str(i): v for i, v in enumerate(d.draw(lists(
5500 str(i + len(ready)): v for i, v in enumerate(d.draw(lists(
5507 for name in d.draw(permutations(
5508 list(ready.keys()) + list(non_ready.keys()),
5510 schema_input.append((name, Boolean()))
5512 class Seq(self.base_klass):
5513 schema = tuple(schema_input)
5515 for name in ready.keys():
5517 seq[name] = Boolean()
5518 self.assertFalse(seq.ready)
5521 pprint(seq, big_blobs=True, with_decode_path=True)
5522 for name, value in ready.items():
5523 seq[name] = Boolean(value)
5524 self.assertFalse(seq.ready)
5527 pprint(seq, big_blobs=True, with_decode_path=True)
5528 with self.assertRaises(ObjNotReady) as err:
5531 for name, value in non_ready.items():
5532 seq[name] = Boolean(value)
5533 self.assertTrue(seq.ready)
5536 pprint(seq, big_blobs=True, with_decode_path=True)
5538 @given(data_strategy())
5539 def test_call(self, d):
5540 class SeqInherited(self.base_klass):
5542 for klass in (self.base_klass, SeqInherited):
5551 ) = d.draw(seq_values_strategy(seq_klass=klass))
5552 obj_initial = klass(
5558 optional_initial or False,
5569 ) = d.draw(seq_values_strategy(
5571 do_expl=impl_initial is None,
5573 obj = obj_initial(value, impl, expl, default, optional)
5574 value_expected = default if value is None else value
5576 default_initial if value_expected is None
5579 self.assertEqual(obj._value, getattr(value_expected, "_value", {}))
5580 self.assertEqual(obj.tag, impl or impl_initial or obj.tag_default)
5581 self.assertEqual(obj.expl_tag, expl or expl_initial)
5583 {} if obj.default is None else obj.default._value,
5584 getattr(default_initial if default is None else default, "_value", {}),
5586 if obj.default is None:
5587 optional = optional_initial if optional is None else optional
5588 optional = False if optional is None else optional
5591 self.assertEqual(list(obj.specs.items()), schema_initial or [])
5592 self.assertEqual(obj.optional, optional)
5594 @given(data_strategy())
5595 def test_copy(self, d):
5596 class SeqInherited(self.base_klass):
5598 register_class(SeqInherited)
5599 for klass in (self.base_klass, SeqInherited):
5600 values = d.draw(seq_values_strategy(seq_klass=klass))
5601 obj = klass(*values)
5602 for copy_func in copy_funcs:
5603 obj_copied = copy_func(obj)
5604 self.assert_copied_basic_fields(obj, obj_copied)
5605 self.assertEqual(obj.specs, obj_copied.specs)
5606 self.assertEqual(obj._value, obj_copied._value)
5608 @given(data_strategy())
5609 def test_stripped(self, d):
5610 value = d.draw(integers())
5611 tag_impl = tag_encode(d.draw(integers(min_value=1)))
5613 class Seq(self.base_klass):
5615 schema = (("whatever", Integer()),)
5617 seq["whatever"] = Integer(value)
5618 with self.assertRaises(NotEnoughData):
5619 seq.decode(seq.encode()[:-1])
5621 @given(data_strategy())
5622 def test_stripped_expl(self, d):
5623 value = d.draw(integers())
5624 tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
5626 class Seq(self.base_klass):
5628 schema = (("whatever", Integer()),)
5630 seq["whatever"] = Integer(value)
5631 with self.assertRaises(NotEnoughData):
5632 seq.decode(seq.encode()[:-1])
5634 @given(binary(min_size=2))
5635 def test_non_tag_mismatch_raised(self, junk):
5637 _, _, len_encoded = tag_strip(memoryview(junk))
5638 len_decode(len_encoded)
5644 class Seq(self.base_klass):
5646 ("whatever", Integer()),
5648 ("whenever", Integer()),
5651 seq["whatever"] = Integer(123)
5652 seq["junk"] = Any(junk)
5653 seq["whenever"] = Integer(123)
5654 with self.assertRaises(DecodeError):
5655 seq.decode(seq.encode())
5658 integers(min_value=31),
5659 integers(min_value=0),
5662 def test_bad_tag(self, tag, offset, decode_path):
5663 with self.assertRaises(DecodeError) as err:
5664 self.base_klass().decode(
5665 tag_encode(tag)[:-1],
5667 decode_path=decode_path,
5670 self.assertEqual(err.exception.offset, offset)
5671 self.assertEqual(err.exception.decode_path, decode_path)
5674 integers(min_value=128),
5675 integers(min_value=0),
5678 def test_bad_len(self, l, offset, decode_path):
5679 with self.assertRaises(DecodeError) as err:
5680 self.base_klass().decode(
5681 self.base_klass.tag_default + len_encode(l)[:-1],
5683 decode_path=decode_path,
5686 self.assertEqual(err.exception.offset, offset)
5687 self.assertEqual(err.exception.decode_path, decode_path)
5689 def _assert_expects(self, seq, expects):
5690 for expect in expects:
5692 seq.specs[expect["name"]].optional,
5695 if expect["default_value"] is not None:
5697 seq.specs[expect["name"]].default,
5698 expect["default_value"],
5700 if expect["presented"]:
5701 self.assertIn(expect["name"], seq)
5702 self.assertEqual(seq[expect["name"]], expect["value"])
5704 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
5705 @given(data_strategy())
5706 def test_symmetric(self, d):
5707 seq, expects = d.draw(sequence_strategy(seq_klass=self.base_klass))
5708 tail_junk = d.draw(binary(max_size=5))
5709 self.assertTrue(seq.ready)
5710 self.assertFalse(seq.decoded)
5711 self._assert_expects(seq, expects)
5714 pprint(seq, big_blobs=True, with_decode_path=True)
5715 self.assertTrue(seq.ready)
5716 seq_encoded = seq.encode()
5717 seq_decoded, tail = seq.decode(seq_encoded + tail_junk)
5718 self.assertFalse(seq_decoded.lenindef)
5719 self.assertFalse(seq_decoded.ber_encoded)
5720 self.assertFalse(seq_decoded.bered)
5722 t, _, lv = tag_strip(seq_encoded)
5723 _, _, v = len_decode(lv)
5724 seq_encoded_lenindef = t + LENINDEF + v + EOC
5725 with self.assertRaises(DecodeError):
5726 seq.decode(seq_encoded_lenindef)
5727 ctx_copied = deepcopy(ctx_dummy)
5728 ctx_copied["bered"] = True
5729 seq_decoded_lenindef, tail_lenindef = seq.decode(
5730 seq_encoded_lenindef + tail_junk,
5733 del ctx_copied["bered"]
5734 self.assertDictEqual(ctx_copied, ctx_dummy)
5735 self.assertTrue(seq_decoded_lenindef.lenindef)
5736 self.assertTrue(seq_decoded_lenindef.bered)
5737 seq_decoded_lenindef = copy(seq_decoded_lenindef)
5738 self.assertTrue(seq_decoded_lenindef.lenindef)
5739 self.assertTrue(seq_decoded_lenindef.bered)
5740 with self.assertRaises(DecodeError):
5741 seq.decode(seq_encoded_lenindef[:-1], ctx={"bered": True})
5742 with self.assertRaises(DecodeError):
5743 seq.decode(seq_encoded_lenindef[:-2], ctx={"bered": True})
5744 repr(seq_decoded_lenindef)
5745 list(seq_decoded_lenindef.pps())
5746 pprint(seq_decoded_lenindef, big_blobs=True, with_decode_path=True)
5747 self.assertTrue(seq_decoded_lenindef.ready)
5749 for decoded, decoded_tail, encoded in (
5750 (seq_decoded, tail, seq_encoded),
5751 (seq_decoded_lenindef, tail_lenindef, seq_encoded_lenindef),
5753 self.assertEqual(decoded_tail, tail_junk)
5754 self._assert_expects(decoded, expects)
5755 self.assertEqual(seq, decoded)
5756 self.assertEqual(decoded.encode(), seq_encoded)
5757 self.assertEqual(decoded.tlvlen, len(encoded))
5758 for expect in expects:
5759 if not expect["presented"]:
5760 self.assertNotIn(expect["name"], decoded)
5762 self.assertIn(expect["name"], decoded)
5763 obj = decoded[expect["name"]]
5764 self.assertTrue(obj.decoded)
5765 offset = obj.expl_offset if obj.expled else obj.offset
5766 tlvlen = obj.expl_tlvlen if obj.expled else obj.tlvlen
5767 self.assertSequenceEqual(
5768 seq_encoded[offset:offset + tlvlen],
5772 assert_exceeding_data(
5774 lambda: seq.decod(seq_encoded_lenindef + tail_junk, ctx={"bered": True}),
5778 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
5779 @given(data_strategy())
5780 def test_symmetric_with_seq(self, d):
5781 seq, expect_outers = d.draw(sequences_strategy(seq_klass=self.base_klass))
5782 self.assertTrue(seq.ready)
5783 seq_encoded = seq.encode()
5784 seq_decoded, tail = seq.decode(seq_encoded)
5785 self.assertEqual(tail, b"")
5786 self.assertTrue(seq.ready)
5787 self.assertEqual(seq, seq_decoded)
5788 self.assertEqual(seq_decoded.encode(), seq_encoded)
5789 for expect_outer in expect_outers:
5790 if not expect_outer["presented"]:
5791 self.assertNotIn(expect_outer["name"], seq_decoded)
5793 self.assertIn(expect_outer["name"], seq_decoded)
5794 obj = seq_decoded[expect_outer["name"]]
5795 self.assertTrue(obj.decoded)
5796 offset = obj.expl_offset if obj.expled else obj.offset
5797 tlvlen = obj.expl_tlvlen if obj.expled else obj.tlvlen
5798 self.assertSequenceEqual(
5799 seq_encoded[offset:offset + tlvlen],
5802 self._assert_expects(obj, expect_outer["expects"])
5804 @given(data_strategy())
5805 def test_default_disappears(self, d):
5806 _schema = list(d.draw(dictionaries(
5808 sets(integers(), min_size=2, max_size=2),
5812 class Seq(self.base_klass):
5814 (n, Integer(default=d))
5815 for n, (_, d) in _schema
5818 for name, (value, _) in _schema:
5819 seq[name] = Integer(value)
5820 self.assertEqual(len(seq._value), len(_schema))
5821 empty_seq = b"".join((self.base_klass.tag_default, len_encode(0)))
5822 self.assertGreater(len(seq.encode()), len(empty_seq))
5823 for name, (_, default) in _schema:
5824 seq[name] = Integer(default)
5825 self.assertEqual(len(seq._value), 0)
5826 self.assertSequenceEqual(seq.encode(), empty_seq)
5828 @given(data_strategy())
5829 def test_encoded_default_not_accepted(self, d):
5830 _schema = list(d.draw(dictionaries(
5835 tags = [tag_encode(tag) for tag in d.draw(sets(
5836 integers(min_value=0),
5837 min_size=len(_schema),
5838 max_size=len(_schema),
5841 class SeqWithoutDefault(self.base_klass):
5843 (n, Integer(impl=t))
5844 for (n, _), t in zip(_schema, tags)
5846 seq_without_default = SeqWithoutDefault()
5847 for name, value in _schema:
5848 seq_without_default[name] = Integer(value)
5849 seq_encoded = seq_without_default.encode()
5851 class SeqWithDefault(self.base_klass):
5853 (n, Integer(default=v, impl=t))
5854 for (n, v), t in zip(_schema, tags)
5856 seq_with_default = SeqWithDefault()
5857 with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
5858 seq_with_default.decode(seq_encoded)
5859 for ctx in ({"bered": True}, {"allow_default_values": True}):
5860 seq_decoded, _ = seq_with_default.decode(seq_encoded, ctx=ctx)
5861 self.assertTrue(seq_decoded.ber_encoded)
5862 self.assertTrue(seq_decoded.bered)
5863 seq_decoded = copy(seq_decoded)
5864 self.assertTrue(seq_decoded.ber_encoded)
5865 self.assertTrue(seq_decoded.bered)
5866 for name, value in _schema:
5867 self.assertEqual(seq_decoded[name], seq_with_default[name])
5868 self.assertEqual(seq_decoded[name], value)
5870 @given(data_strategy())
5871 def test_missing_from_spec(self, d):
5872 names = list(d.draw(sets(text_letters(), min_size=2)))
5873 tags = [tag_encode(tag) for tag in d.draw(sets(
5874 integers(min_value=0),
5875 min_size=len(names),
5876 max_size=len(names),
5878 names_tags = [(name, tag) for tag, name in sorted(zip(tags, names))]
5880 class SeqFull(self.base_klass):
5881 schema = [(n, Integer(impl=t)) for n, t in names_tags]
5882 seq_full = SeqFull()
5883 for i, name in enumerate(names):
5884 seq_full[name] = Integer(i)
5885 seq_encoded = seq_full.encode()
5886 altered = names_tags[:-2] + names_tags[-1:]
5888 class SeqMissing(self.base_klass):
5889 schema = [(n, Integer(impl=t)) for n, t in altered]
5890 seq_missing = SeqMissing()
5891 with self.assertRaises(TagMismatch):
5892 seq_missing.decode(seq_encoded)
5894 def test_bered(self):
5895 class Seq(self.base_klass):
5896 schema = (("underlying", Boolean()),)
5897 encoded = Boolean.tag_default + len_encode(1) + b"\x01"
5898 encoded = Seq.tag_default + len_encode(len(encoded)) + encoded
5899 decoded, _ = Seq().decode(encoded, ctx={"bered": True})
5900 self.assertFalse(decoded.ber_encoded)
5901 self.assertFalse(decoded.lenindef)
5902 self.assertTrue(decoded.bered)
5903 decoded = copy(decoded)
5904 self.assertFalse(decoded.ber_encoded)
5905 self.assertFalse(decoded.lenindef)
5906 self.assertTrue(decoded.bered)
5908 class Seq(self.base_klass):
5909 schema = (("underlying", OctetString()),)
5911 tag_encode(form=TagFormConstructed, num=4) +
5913 OctetString(b"whatever").encode() +
5916 encoded = Seq.tag_default + len_encode(len(encoded)) + encoded
5917 with self.assertRaises(DecodeError):
5918 Seq().decode(encoded)
5919 decoded, _ = Seq().decode(encoded, ctx={"bered": True})
5920 self.assertFalse(decoded.ber_encoded)
5921 self.assertFalse(decoded.lenindef)
5922 self.assertTrue(decoded.bered)
5923 decoded = copy(decoded)
5924 self.assertFalse(decoded.ber_encoded)
5925 self.assertFalse(decoded.lenindef)
5926 self.assertTrue(decoded.bered)
5929 class TestSequence(SeqMixing, CommonMixin, TestCase):
5930 base_klass = Sequence
5936 def test_remaining(self, value, junk):
5937 class Seq(Sequence):
5939 ("whatever", Integer()),
5941 int_encoded = Integer(value).encode()
5943 Sequence.tag_default,
5944 len_encode(len(int_encoded + junk)),
5947 with assertRaisesRegex(self, DecodeError, "remaining"):
5948 Seq().decode(junked)
5950 @given(sets(text_letters(), min_size=2))
5951 def test_obj_unknown(self, names):
5952 missing = names.pop()
5954 class Seq(Sequence):
5955 schema = [(n, Boolean()) for n in names]
5957 with self.assertRaises(ObjUnknown) as err:
5960 with self.assertRaises(ObjUnknown) as err:
5961 seq[missing] = Boolean()
5964 def test_x690_vector(self):
5965 class Seq(Sequence):
5967 ("name", IA5String()),
5970 seq = Seq().decode(hexdec("300A1605536d6974680101FF"))[0]
5971 self.assertEqual(seq["name"], "Smith")
5972 self.assertEqual(seq["ok"], True)
5975 class TestSet(SeqMixing, CommonMixin, TestCase):
5978 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
5979 @given(data_strategy())
5980 def test_sorted(self, d):
5982 tag_encode(tag) for tag in
5983 d.draw(sets(integers(min_value=1), min_size=1, max_size=10))
5987 schema = [(str(i), OctetString(impl=t)) for i, t in enumerate(tags)]
5989 for name, _ in Seq.schema:
5990 seq[name] = OctetString(b"")
5991 seq_encoded = seq.encode()
5992 seq_decoded, _ = seq.decode(seq_encoded)
5993 self.assertSequenceEqual(
5994 seq_encoded[seq_decoded.tlen + seq_decoded.llen:],
5995 b"".join(sorted([seq[name].encode() for name, _ in Seq.schema])),
5998 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
5999 @given(data_strategy())
6000 def test_unsorted(self, d):
6002 tag_encode(tag) for tag in
6003 d.draw(sets(integers(min_value=1), min_size=2, max_size=5))
6005 tags = d.draw(permutations(tags))
6006 assume(tags != sorted(tags))
6007 encoded = b"".join(OctetString(t, impl=t).encode() for t in tags)
6008 seq_encoded = b"".join((
6010 len_encode(len(encoded)),
6015 schema = [(str(i), OctetString(impl=t)) for i, t in enumerate(tags)]
6017 with assertRaisesRegex(self, DecodeError, "unordered SET"):
6018 seq.decode(seq_encoded)
6019 for ctx in ({"bered": True}, {"allow_unordered_set": True}):
6020 seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
6021 self.assertTrue(seq_decoded.ber_encoded)
6022 self.assertTrue(seq_decoded.bered)
6023 seq_decoded = copy(seq_decoded)
6024 self.assertTrue(seq_decoded.ber_encoded)
6025 self.assertTrue(seq_decoded.bered)
6026 self.assertSequenceEqual(
6027 [bytes(seq_decoded[str(i)]) for i, t in enumerate(tags)],
6033 def seqof_values_strategy(draw, schema=None, do_expl=False):
6035 schema = draw(sampled_from((Boolean(), Integer())))
6036 bound_min, bound_max = sorted(draw(sets(
6037 integers(min_value=0, max_value=10),
6041 if isinstance(schema, Boolean):
6042 values_generator = booleans().map(Boolean)
6043 elif isinstance(schema, Integer):
6044 values_generator = integers().map(Integer)
6045 values_generator = lists(
6050 values = draw(one_of(none(), values_generator))
6054 expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
6056 impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
6057 default = draw(one_of(none(), values_generator))
6058 optional = draw(one_of(none(), booleans()))
6060 draw(integers(min_value=0)),
6061 draw(integers(min_value=0)),
6062 draw(integers(min_value=0)),
6067 (bound_min, bound_max),
6076 class SeqOfMixing(object):
6077 def test_invalid_value_type(self):
6078 with self.assertRaises(InvalidValueType) as err:
6079 self.base_klass(123)
6082 def test_invalid_values_type(self):
6083 class SeqOf(self.base_klass):
6085 with self.assertRaises(InvalidValueType) as err:
6086 SeqOf([Integer(123), Boolean(False), Integer(234)])
6089 def test_schema_required(self):
6090 with assertRaisesRegex(self, ValueError, "schema must be specified"):
6091 self.base_klass.__mro__[1]()
6093 @given(booleans(), booleans(), binary(), binary())
6094 def test_comparison(self, value1, value2, tag1, tag2):
6095 class SeqOf(self.base_klass):
6097 obj1 = SeqOf([Boolean(value1)])
6098 obj2 = SeqOf([Boolean(value2)])
6099 self.assertEqual(obj1 == obj2, value1 == value2)
6100 self.assertEqual(obj1 != obj2, value1 != value2)
6101 self.assertEqual(obj1 == list(obj2), value1 == value2)
6102 self.assertEqual(obj1 == tuple(obj2), value1 == value2)
6103 obj1 = SeqOf([Boolean(value1)], impl=tag1)
6104 obj2 = SeqOf([Boolean(value1)], impl=tag2)
6105 self.assertEqual(obj1 == obj2, tag1 == tag2)
6106 self.assertEqual(obj1 != obj2, tag1 != tag2)
6108 @given(lists(booleans()))
6109 def test_iter(self, values):
6110 class SeqOf(self.base_klass):
6112 obj = SeqOf([Boolean(value) for value in values])
6113 self.assertEqual(len(obj), len(values))
6114 for i, value in enumerate(obj):
6115 self.assertEqual(value, values[i])
6117 @given(data_strategy())
6118 def test_ready(self, d):
6119 ready = [Integer(v) for v in d.draw(lists(
6126 range(d.draw(integers(min_value=1, max_value=5)))
6129 class SeqOf(self.base_klass):
6131 values = d.draw(permutations(ready + non_ready))
6133 for value in values:
6135 self.assertFalse(seqof.ready)
6138 pprint(seqof, big_blobs=True, with_decode_path=True)
6139 with self.assertRaises(ObjNotReady) as err:
6142 for i, value in enumerate(values):
6143 self.assertEqual(seqof[i], value)
6144 if not seqof[i].ready:
6145 seqof[i] = Integer(i)
6146 self.assertTrue(seqof.ready)
6149 pprint(seqof, big_blobs=True, with_decode_path=True)
6151 def test_spec_mismatch(self):
6152 class SeqOf(self.base_klass):
6155 seqof.append(Integer(123))
6156 with self.assertRaises(ValueError):
6157 seqof.append(Boolean(False))
6158 with self.assertRaises(ValueError):
6159 seqof[0] = Boolean(False)
6161 @given(data_strategy())
6162 def test_bounds_satisfied(self, d):
6163 class SeqOf(self.base_klass):
6165 bound_min = d.draw(integers(min_value=0, max_value=1 << 7))
6166 bound_max = d.draw(integers(min_value=bound_min, max_value=1 << 7))
6167 value = [Boolean()] * d.draw(integers(min_value=bound_min, max_value=bound_max))
6168 SeqOf(value=value, bounds=(bound_min, bound_max))
6170 @given(data_strategy())
6171 def test_bounds_unsatisfied(self, d):
6172 class SeqOf(self.base_klass):
6174 bound_min = d.draw(integers(min_value=1, max_value=1 << 7))
6175 bound_max = d.draw(integers(min_value=bound_min, max_value=1 << 7))
6176 value = [Boolean(False)] * d.draw(integers(max_value=bound_min - 1))
6177 with self.assertRaises(BoundsError) as err:
6178 SeqOf(value=value, bounds=(bound_min, bound_max))
6180 with assertRaisesRegex(self, DecodeError, "bounds") as err:
6181 SeqOf(bounds=(bound_min, bound_max)).decode(
6182 SeqOf(value).encode()
6185 value = [Boolean(True)] * d.draw(integers(
6186 min_value=bound_max + 1,
6187 max_value=bound_max + 10,
6189 with self.assertRaises(BoundsError) as err:
6190 SeqOf(value=value, bounds=(bound_min, bound_max))
6192 with assertRaisesRegex(self, DecodeError, "bounds") as err:
6193 SeqOf(bounds=(bound_min, bound_max)).decode(
6194 SeqOf(value).encode()
6198 @given(integers(min_value=1, max_value=10))
6199 def test_out_of_bounds(self, bound_max):
6200 class SeqOf(self.base_klass):
6202 bounds = (0, bound_max)
6204 for _ in range(bound_max):
6205 seqof.append(Integer(123))
6206 with self.assertRaises(BoundsError):
6207 seqof.append(Integer(123))
6209 @given(data_strategy())
6210 def test_call(self, d):
6220 ) = d.draw(seqof_values_strategy())
6222 class SeqOf(self.base_klass):
6223 schema = schema_initial
6224 obj_initial = SeqOf(
6225 value=value_initial,
6226 bounds=bounds_initial,
6229 default=default_initial,
6230 optional=optional_initial or False,
6231 _decoded=_decoded_initial,
6242 ) = d.draw(seqof_values_strategy(
6243 schema=schema_initial,
6244 do_expl=impl_initial is None,
6246 if (default is None) and (obj_initial.default is not None):
6249 (bounds is None) and
6250 (value is not None) and
6251 (bounds_initial is not None) and
6252 not (bounds_initial[0] <= len(value) <= bounds_initial[1])
6256 (bounds is None) and
6257 (default is not None) and
6258 (bounds_initial is not None) and
6259 not (bounds_initial[0] <= len(default) <= bounds_initial[1])
6271 value_expected = default if value is None else value
6273 default_initial if value_expected is None
6276 value_expected = () if value_expected is None else value_expected
6277 self.assertEqual(obj, value_expected)
6278 self.assertEqual(obj.tag, impl or impl_initial or obj.tag_default)
6279 self.assertEqual(obj.expl_tag, expl or expl_initial)
6282 default_initial if default is None else default,
6284 if obj.default is None:
6285 optional = optional_initial if optional is None else optional
6286 optional = False if optional is None else optional
6289 self.assertEqual(obj.optional, optional)
6291 (obj._bound_min, obj._bound_max),
6292 bounds or bounds_initial or (0, float("+inf")),
6295 @given(seqof_values_strategy())
6296 def test_copy(self, values):
6297 _schema, value, bounds, impl, expl, default, optional, _decoded = values
6299 class SeqOf(self.base_klass):
6301 register_class(SeqOf)
6308 optional=optional or False,
6311 for copy_func in copy_funcs:
6312 obj_copied = copy_func(obj)
6313 self.assert_copied_basic_fields(obj, obj_copied)
6314 self.assertEqual(obj._bound_min, obj_copied._bound_min)
6315 self.assertEqual(obj._bound_max, obj_copied._bound_max)
6316 self.assertEqual(obj._value, obj_copied._value)
6320 integers(min_value=1).map(tag_encode),
6322 def test_stripped(self, values, tag_impl):
6323 class SeqOf(self.base_klass):
6324 schema = OctetString()
6325 obj = SeqOf([OctetString(v) for v in values], impl=tag_impl)
6326 with self.assertRaises(NotEnoughData):
6327 obj.decode(obj.encode()[:-1])
6331 integers(min_value=1).map(tag_ctxc),
6333 def test_stripped_expl(self, values, tag_expl):
6334 class SeqOf(self.base_klass):
6335 schema = OctetString()
6336 obj = SeqOf([OctetString(v) for v in values], expl=tag_expl)
6337 with self.assertRaises(NotEnoughData):
6338 obj.decode(obj.encode()[:-1])
6341 integers(min_value=31),
6342 integers(min_value=0),
6345 def test_bad_tag(self, tag, offset, decode_path):
6346 with self.assertRaises(DecodeError) as err:
6347 self.base_klass().decode(
6348 tag_encode(tag)[:-1],
6350 decode_path=decode_path,
6353 self.assertEqual(err.exception.offset, offset)
6354 self.assertEqual(err.exception.decode_path, decode_path)
6357 integers(min_value=128),
6358 integers(min_value=0),
6361 def test_bad_len(self, l, offset, decode_path):
6362 with self.assertRaises(DecodeError) as err:
6363 self.base_klass().decode(
6364 self.base_klass.tag_default + len_encode(l)[:-1],
6366 decode_path=decode_path,
6369 self.assertEqual(err.exception.offset, offset)
6370 self.assertEqual(err.exception.decode_path, decode_path)
6372 @given(binary(min_size=1))
6373 def test_tag_mismatch(self, impl):
6374 assume(impl != self.base_klass.tag_default)
6375 with self.assertRaises(TagMismatch):
6376 self.base_klass(impl=impl).decode(self.base_klass().encode())
6378 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
6380 seqof_values_strategy(schema=Integer()),
6381 lists(integers().map(Integer)),
6382 integers(min_value=1).map(tag_ctxc),
6383 integers(min_value=0),
6386 def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
6387 _, _, _, _, _, default, optional, _decoded = values
6389 class SeqOf(self.base_klass):
6399 pprint(obj, big_blobs=True, with_decode_path=True)
6400 self.assertFalse(obj.expled)
6401 obj_encoded = obj.encode()
6402 obj_expled = obj(value, expl=tag_expl)
6403 self.assertTrue(obj_expled.expled)
6405 list(obj_expled.pps())
6406 pprint(obj_expled, big_blobs=True, with_decode_path=True)
6407 obj_expled_encoded = obj_expled.encode()
6408 ctx_copied = deepcopy(ctx_dummy)
6409 obj_decoded, tail = obj_expled.decode(
6410 obj_expled_encoded + tail_junk,
6414 self.assertDictEqual(ctx_copied, ctx_dummy)
6416 list(obj_decoded.pps())
6417 pprint(obj_decoded, big_blobs=True, with_decode_path=True)
6418 self.assertEqual(tail, tail_junk)
6419 self._test_symmetric_compare_objs(obj_decoded, obj_expled)
6420 self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
6421 self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
6422 self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
6424 obj_decoded.expl_llen,
6425 len(len_encode(len(obj_encoded))),
6427 self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
6428 self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
6431 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
6433 self.assertEqual(obj_decoded.expl_offset, offset)
6434 for obj_inner in obj_decoded:
6435 self.assertIn(obj_inner, obj_decoded)
6436 self.assertSequenceEqual(
6439 obj_inner.offset - offset:
6440 obj_inner.offset + obj_inner.tlvlen - offset
6444 t, _, lv = tag_strip(obj_encoded)
6445 _, _, v = len_decode(lv)
6446 obj_encoded_lenindef = t + LENINDEF + v + EOC
6447 with self.assertRaises(DecodeError):
6448 obj.decode(obj_encoded_lenindef)
6449 obj_decoded_lenindef, tail_lenindef = obj.decode(
6450 obj_encoded_lenindef + tail_junk,
6451 ctx={"bered": True},
6453 self.assertTrue(obj_decoded_lenindef.lenindef)
6454 self.assertTrue(obj_decoded_lenindef.bered)
6455 obj_decoded_lenindef = copy(obj_decoded_lenindef)
6456 self.assertTrue(obj_decoded_lenindef.lenindef)
6457 self.assertTrue(obj_decoded_lenindef.bered)
6458 repr(obj_decoded_lenindef)
6459 list(obj_decoded_lenindef.pps())
6460 pprint(obj_decoded_lenindef, big_blobs=True, with_decode_path=True)
6461 self.assertEqual(tail_lenindef, tail_junk)
6462 self.assertEqual(obj_decoded_lenindef.tlvlen, len(obj_encoded_lenindef))
6463 with self.assertRaises(DecodeError):
6464 obj.decode(obj_encoded_lenindef[:-1], ctx={"bered": True})
6465 with self.assertRaises(DecodeError):
6466 obj.decode(obj_encoded_lenindef[:-2], ctx={"bered": True})
6468 assert_exceeding_data(
6470 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
6474 def test_bered(self):
6475 class SeqOf(self.base_klass):
6477 encoded = Boolean(False).encode()
6478 encoded += Boolean.tag_default + len_encode(1) + b"\x01"
6479 encoded = SeqOf.tag_default + len_encode(len(encoded)) + encoded
6480 with self.assertRaises(DecodeError):
6481 SeqOf().decode(encoded)
6482 decoded, _ = SeqOf().decode(encoded, ctx={"bered": True})
6483 self.assertFalse(decoded.ber_encoded)
6484 self.assertFalse(decoded.lenindef)
6485 self.assertTrue(decoded.bered)
6486 decoded = copy(decoded)
6487 self.assertFalse(decoded.ber_encoded)
6488 self.assertFalse(decoded.lenindef)
6489 self.assertTrue(decoded.bered)
6491 class SeqOf(self.base_klass):
6492 schema = OctetString()
6493 encoded = OctetString(b"whatever").encode()
6495 tag_encode(form=TagFormConstructed, num=4) +
6497 OctetString(b"whatever").encode() +
6500 encoded = SeqOf.tag_default + len_encode(len(encoded)) + encoded
6501 with self.assertRaises(DecodeError):
6502 SeqOf().decode(encoded)
6503 decoded, _ = SeqOf().decode(encoded, ctx={"bered": True})
6504 self.assertFalse(decoded.ber_encoded)
6505 self.assertFalse(decoded.lenindef)
6506 self.assertTrue(decoded.bered)
6507 decoded = copy(decoded)
6508 self.assertFalse(decoded.ber_encoded)
6509 self.assertFalse(decoded.lenindef)
6510 self.assertTrue(decoded.bered)
6513 class TestSequenceOf(SeqOfMixing, CommonMixin, TestCase):
6514 class SeqOf(SequenceOf):
6518 def _test_symmetric_compare_objs(self, obj1, obj2):
6519 self.assertEqual(obj1, obj2)
6520 self.assertSequenceEqual(list(obj1), list(obj2))
6523 class TestSetOf(SeqOfMixing, CommonMixin, TestCase):
6528 def _test_symmetric_compare_objs(self, obj1, obj2):
6529 self.assertSetEqual(
6530 set(int(v) for v in obj1),
6531 set(int(v) for v in obj2),
6534 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
6535 @given(data_strategy())
6536 def test_sorted(self, d):
6537 values = [OctetString(v) for v in d.draw(lists(binary()))]
6540 schema = OctetString()
6542 seq_encoded = seq.encode()
6543 seq_decoded, _ = seq.decode(seq_encoded)
6544 self.assertSequenceEqual(
6545 seq_encoded[seq_decoded.tlen + seq_decoded.llen:],
6546 b"".join(sorted([v.encode() for v in values])),
6549 @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
6550 @given(data_strategy())
6551 def test_unsorted(self, d):
6552 values = [OctetString(v).encode() for v in d.draw(sets(
6553 binary(min_size=1, max_size=5),
6557 values = d.draw(permutations(values))
6558 assume(values != sorted(values))
6559 encoded = b"".join(values)
6560 seq_encoded = b"".join((
6562 len_encode(len(encoded)),
6567 schema = OctetString()
6569 with assertRaisesRegex(self, DecodeError, "unordered SET OF"):
6570 seq.decode(seq_encoded)
6572 for ctx in ({"bered": True}, {"allow_unordered_set": True}):
6573 seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
6574 self.assertTrue(seq_decoded.ber_encoded)
6575 self.assertTrue(seq_decoded.bered)
6576 seq_decoded = copy(seq_decoded)
6577 self.assertTrue(seq_decoded.ber_encoded)
6578 self.assertTrue(seq_decoded.bered)
6579 self.assertSequenceEqual(
6580 [obj.encode() for obj in seq_decoded],
6585 class TestGoMarshalVectors(TestCase):
6587 self.assertSequenceEqual(Integer(10).encode(), hexdec("02010a"))
6588 self.assertSequenceEqual(Integer(127).encode(), hexdec("02017f"))
6589 self.assertSequenceEqual(Integer(128).encode(), hexdec("02020080"))
6590 self.assertSequenceEqual(Integer(-128).encode(), hexdec("020180"))
6591 self.assertSequenceEqual(Integer(-129).encode(), hexdec("0202ff7f"))
6593 class Seq(Sequence):
6595 ("erste", Integer()),
6596 ("zweite", Integer(optional=True))
6599 seq["erste"] = Integer(64)
6600 self.assertSequenceEqual(seq.encode(), hexdec("3003020140"))
6601 seq["erste"] = Integer(0x123456)
6602 self.assertSequenceEqual(seq.encode(), hexdec("30050203123456"))
6603 seq["erste"] = Integer(64)
6604 seq["zweite"] = Integer(65)
6605 self.assertSequenceEqual(seq.encode(), hexdec("3006020140020141"))
6607 class NestedSeq(Sequence):
6611 seq["erste"] = Integer(127)
6612 seq["zweite"] = None
6613 nested = NestedSeq()
6614 nested["nest"] = seq
6615 self.assertSequenceEqual(nested.encode(), hexdec("3005300302017f"))
6617 self.assertSequenceEqual(
6618 OctetString(b"\x01\x02\x03").encode(),
6619 hexdec("0403010203"),
6622 class Seq(Sequence):
6624 ("erste", Integer(impl=tag_encode(5, klass=TagClassContext))),
6627 seq["erste"] = Integer(64)
6628 self.assertSequenceEqual(seq.encode(), hexdec("3003850140"))
6630 class Seq(Sequence):
6632 ("erste", Integer(expl=tag_ctxc(5))),
6635 seq["erste"] = Integer(64)
6636 self.assertSequenceEqual(seq.encode(), hexdec("3005a503020140"))
6638 class Seq(Sequence):
6641 impl=tag_encode(0, klass=TagClassContext),
6646 seq["erste"] = Null()
6647 self.assertSequenceEqual(seq.encode(), hexdec("30028000"))
6649 self.assertSequenceEqual(seq.encode(), hexdec("3000"))
6651 self.assertSequenceEqual(
6652 UTCTime(datetime(1970, 1, 1, 0, 0)).encode(),
6653 hexdec("170d3730303130313030303030305a"),
6655 self.assertSequenceEqual(
6656 UTCTime(datetime(2009, 11, 15, 22, 56, 16)).encode(),
6657 hexdec("170d3039313131353232353631365a"),
6659 self.assertSequenceEqual(
6660 GeneralizedTime(datetime(2100, 4, 5, 12, 1, 1)).encode(),
6661 hexdec("180f32313030303430353132303130315a"),
6664 class Seq(Sequence):
6666 ("erste", GeneralizedTime()),
6669 seq["erste"] = GeneralizedTime(datetime(2009, 11, 15, 22, 56, 16))
6670 self.assertSequenceEqual(
6672 hexdec("3011180f32303039313131353232353631365a"),
6675 self.assertSequenceEqual(
6676 BitString((1, b"\x80")).encode(),
6679 self.assertSequenceEqual(
6680 BitString((12, b"\x81\xF0")).encode(),
6681 hexdec("03030481f0"),
6684 self.assertSequenceEqual(
6685 ObjectIdentifier("1.2.3.4").encode(),
6686 hexdec("06032a0304"),
6688 self.assertSequenceEqual(
6689 ObjectIdentifier("1.2.840.133549.1.1.5").encode(),
6690 hexdec("06092a864888932d010105"),
6692 self.assertSequenceEqual(
6693 ObjectIdentifier("2.100.3").encode(),
6694 hexdec("0603813403"),
6697 self.assertSequenceEqual(
6698 PrintableString("test").encode(),
6699 hexdec("130474657374"),
6701 self.assertSequenceEqual(
6702 PrintableString("x" * 127).encode(),
6703 hexdec("137F" + "78" * 127),
6705 self.assertSequenceEqual(
6706 PrintableString("x" * 128).encode(),
6707 hexdec("138180" + "78" * 128),
6709 self.assertSequenceEqual(UTF8String("Σ").encode(), hexdec("0c02cea3"))
6711 class Seq(Sequence):
6713 ("erste", IA5String()),
6716 seq["erste"] = IA5String("test")
6717 self.assertSequenceEqual(seq.encode(), hexdec("3006160474657374"))
6719 class Seq(Sequence):
6721 ("erste", PrintableString()),
6724 seq["erste"] = PrintableString("test")
6725 self.assertSequenceEqual(seq.encode(), hexdec("3006130474657374"))
6726 # Asterisk is actually not allowable
6727 PrintableString._allowable_chars |= set(b"*")
6728 seq["erste"] = PrintableString("test*")
6729 self.assertSequenceEqual(seq.encode(), hexdec("30071305746573742a"))
6730 PrintableString._allowable_chars -= set(b"*")
6732 class Seq(Sequence):
6734 ("erste", Any(optional=True)),
6735 ("zweite", Integer()),
6738 seq["zweite"] = Integer(64)
6739 self.assertSequenceEqual(seq.encode(), hexdec("3003020140"))
6744 seq.append(Integer(10))
6745 self.assertSequenceEqual(seq.encode(), hexdec("310302010a"))
6747 class _SeqOf(SequenceOf):
6748 schema = PrintableString()
6750 class SeqOf(SequenceOf):
6753 _seqof.append(PrintableString("1"))
6755 seqof.append(_seqof)
6756 self.assertSequenceEqual(seqof.encode(), hexdec("30053003130131"))
6758 class Seq(Sequence):
6760 ("erste", Integer(default=1)),
6763 seq["erste"] = Integer(0)
6764 self.assertSequenceEqual(seq.encode(), hexdec("3003020100"))
6765 seq["erste"] = Integer(1)
6766 self.assertSequenceEqual(seq.encode(), hexdec("3000"))
6767 seq["erste"] = Integer(2)
6768 self.assertSequenceEqual(seq.encode(), hexdec("3003020102"))
6771 class TestPP(TestCase):
6772 @given(data_strategy())
6773 def test_oid_printing(self, d):
6775 str(ObjectIdentifier(k)): v * 2
6776 for k, v in d.draw(dictionaries(oid_strategy(), text_letters())).items()
6778 chosen = d.draw(sampled_from(sorted(oids)))
6779 chosen_id = oids[chosen]
6780 pp = _pp(asn1_type_name=ObjectIdentifier.asn1_type_name, value=chosen)
6781 self.assertNotIn(chosen_id, pp_console_row(pp))
6784 pp_console_row(pp, oid_maps=[{'whatever': 'whenever'}, oids]),
6788 class TestAutoAddSlots(TestCase):
6790 class Inher(Integer):
6793 with self.assertRaises(AttributeError):
6795 inher.unexistent = "whatever"
6798 class TestOIDDefines(TestCase):
6799 @given(data_strategy())
6800 def runTest(self, d):
6801 value_names = list(d.draw(sets(text_letters(), min_size=1, max_size=10)))
6802 value_name_chosen = d.draw(sampled_from(value_names))
6804 ObjectIdentifier(oid)
6805 for oid in d.draw(sets(oid_strategy(), min_size=2, max_size=10))
6807 oid_chosen = d.draw(sampled_from(oids))
6808 values = d.draw(lists(
6810 min_size=len(value_names),
6811 max_size=len(value_names),
6813 for definable_class in (Any, OctetString, BitString):
6815 ("type", ObjectIdentifier(defines=(((value_name_chosen,), {
6816 oid: Integer() for oid in oids[:-1]
6819 for i, value_name in enumerate(value_names):
6820 _schema.append((value_name, definable_class(expl=tag_ctxp(i))))
6822 class Seq(Sequence):
6825 for value_name, value in zip(value_names, values):
6826 seq[value_name] = definable_class(Integer(value).encode())
6827 seq["type"] = oid_chosen
6828 seq, _ = Seq().decode(seq.encode())
6829 for value_name in value_names:
6830 if value_name == value_name_chosen:
6832 self.assertIsNone(seq[value_name].defined)
6833 if value_name_chosen in oids[:-1]:
6834 self.assertIsNotNone(seq[value_name_chosen].defined)
6835 self.assertEqual(seq[value_name_chosen].defined[0], oid_chosen)
6836 self.assertIsInstance(seq[value_name_chosen].defined[1], Integer)
6839 pprint(seq, big_blobs=True, with_decode_path=True)
6842 class TestDefinesByPath(TestCase):
6843 def test_generated(self):
6844 class Seq(Sequence):
6846 ("type", ObjectIdentifier()),
6847 ("value", OctetString(expl=tag_ctxc(123))),
6850 class SeqInner(Sequence):
6852 ("typeInner", ObjectIdentifier()),
6853 ("valueInner", Any()),
6856 class PairValue(SetOf):
6859 class Pair(Sequence):
6861 ("type", ObjectIdentifier()),
6862 ("value", PairValue()),
6865 class Pairs(SequenceOf):
6872 type_octet_stringed,
6874 ObjectIdentifier(oid)
6875 for oid in sets(oid_strategy(), min_size=4, max_size=4).example()
6877 seq_integered = Seq()
6878 seq_integered["type"] = type_integered
6879 seq_integered["value"] = OctetString(Integer(123).encode())
6880 seq_integered_raw = seq_integered.encode()
6884 (type_octet_stringed, OctetString(b"whatever")),
6885 (type_integered, Integer(123)),
6886 (type_octet_stringed, OctetString(b"whenever")),
6887 (type_integered, Integer(234)),
6889 for t, v in pairs_input:
6892 ("value", PairValue((Any(v),))),
6894 seq_inner = SeqInner()
6895 seq_inner["typeInner"] = type_innered
6896 seq_inner["valueInner"] = Any(pairs)
6897 seq_sequenced = Seq()
6898 seq_sequenced["type"] = type_sequenced
6899 seq_sequenced["value"] = OctetString(seq_inner.encode())
6900 seq_sequenced_raw = seq_sequenced.encode()
6902 list(seq_sequenced.pps())
6903 pprint(seq_sequenced, big_blobs=True, with_decode_path=True)
6905 defines_by_path = []
6906 ctx_copied = deepcopy(ctx_dummy)
6907 seq_integered, _ = Seq().decode(
6911 self.assertDictEqual(ctx_copied, ctx_dummy)
6912 self.assertIsNone(seq_integered["value"].defined)
6913 defines_by_path.append(
6914 (("type",), ((("value",), {
6915 type_integered: Integer(),
6916 type_sequenced: SeqInner(),
6919 ctx_copied["defines_by_path"] = defines_by_path
6920 seq_integered, _ = Seq().decode(
6924 del ctx_copied["defines_by_path"]
6925 self.assertDictEqual(ctx_copied, ctx_dummy)
6926 self.assertIsNotNone(seq_integered["value"].defined)
6927 self.assertEqual(seq_integered["value"].defined[0], type_integered)
6928 self.assertEqual(seq_integered["value"].defined[1], Integer(123))
6929 self.assertTrue(seq_integered_raw[
6930 seq_integered["value"].defined[1].offset:
6931 ].startswith(Integer(123).encode()))
6933 list(seq_integered.pps())
6934 pprint(seq_integered, big_blobs=True, with_decode_path=True)
6936 ctx_copied["defines_by_path"] = defines_by_path
6937 seq_sequenced, _ = Seq().decode(
6941 del ctx_copied["defines_by_path"]
6942 self.assertDictEqual(ctx_copied, ctx_dummy)
6943 self.assertIsNotNone(seq_sequenced["value"].defined)
6944 self.assertEqual(seq_sequenced["value"].defined[0], type_sequenced)
6945 seq_inner = seq_sequenced["value"].defined[1]
6946 self.assertIsNone(seq_inner["valueInner"].defined)
6948 list(seq_sequenced.pps())
6949 pprint(seq_sequenced, big_blobs=True, with_decode_path=True)
6951 defines_by_path.append((
6952 ("value", DecodePathDefBy(type_sequenced), "typeInner"),
6953 ((("valueInner",), {type_innered: Pairs()}),),
6955 ctx_copied["defines_by_path"] = defines_by_path
6956 seq_sequenced, _ = Seq().decode(
6960 del ctx_copied["defines_by_path"]
6961 self.assertDictEqual(ctx_copied, ctx_dummy)
6962 self.assertIsNotNone(seq_sequenced["value"].defined)
6963 self.assertEqual(seq_sequenced["value"].defined[0], type_sequenced)
6964 seq_inner = seq_sequenced["value"].defined[1]
6965 self.assertIsNotNone(seq_inner["valueInner"].defined)
6966 self.assertEqual(seq_inner["valueInner"].defined[0], type_innered)
6967 pairs = seq_inner["valueInner"].defined[1]
6969 self.assertIsNone(pair["value"][0].defined)
6971 list(seq_sequenced.pps())
6972 pprint(seq_sequenced, big_blobs=True, with_decode_path=True)
6974 defines_by_path.append((
6977 DecodePathDefBy(type_sequenced),
6979 DecodePathDefBy(type_innered),
6984 type_integered: Integer(),
6985 type_octet_stringed: OctetString(),
6988 ctx_copied["defines_by_path"] = defines_by_path
6989 seq_sequenced, _ = Seq().decode(
6993 del ctx_copied["defines_by_path"]
6994 self.assertDictEqual(ctx_copied, ctx_dummy)
6995 self.assertIsNotNone(seq_sequenced["value"].defined)
6996 self.assertEqual(seq_sequenced["value"].defined[0], type_sequenced)
6997 seq_inner = seq_sequenced["value"].defined[1]
6998 self.assertIsNotNone(seq_inner["valueInner"].defined)
6999 self.assertEqual(seq_inner["valueInner"].defined[0], type_innered)
7000 pairs_got = seq_inner["valueInner"].defined[1]
7001 for pair_input, pair_got in zip(pairs_input, pairs_got):
7002 self.assertEqual(pair_got["value"][0].defined[0], pair_input[0])
7003 self.assertEqual(pair_got["value"][0].defined[1], pair_input[1])
7005 list(seq_sequenced.pps())
7006 pprint(seq_sequenced, big_blobs=True, with_decode_path=True)
7008 @given(oid_strategy(), integers())
7009 def test_simple(self, oid, tgt):
7010 class Inner(Sequence):
7012 ("oid", ObjectIdentifier(defines=((("..", "tgt"), {
7013 ObjectIdentifier(oid): Integer(),
7017 class Outer(Sequence):
7020 ("tgt", OctetString()),
7024 inner["oid"] = ObjectIdentifier(oid)
7026 outer["inner"] = inner
7027 outer["tgt"] = OctetString(Integer(tgt).encode())
7028 decoded, _ = Outer().decode(outer.encode())
7029 self.assertEqual(decoded["tgt"].defined[1], Integer(tgt))
7031 def test_remaining_data(self):
7032 oid = ObjectIdentifier("1.2.3")
7033 class Seq(Sequence):
7035 ("oid", ObjectIdentifier(defines=((("tgt",), {
7038 ("tgt", OctetString()),
7043 ("tgt", OctetString(Integer(123).encode() + b"junk")),
7045 with assertRaisesRegex(self, DecodeError, "remaining data"):
7046 Seq().decode(seq.encode())
7048 def test_remaining_data_seqof(self):
7049 oid = ObjectIdentifier("1.2.3")
7051 schema = OctetString()
7053 class Seq(Sequence):
7055 ("oid", ObjectIdentifier(defines=((("tgt",), {
7063 ("tgt", SeqOf([OctetString(Integer(123).encode() + b"junk")])),
7065 with assertRaisesRegex(self, DecodeError, "remaining data"):
7066 Seq().decode(seq.encode())
7069 class TestAbsDecodePath(TestCase):
7071 lists(text(alphabet=ascii_letters, min_size=1)).map(tuple),
7072 lists(text(alphabet=ascii_letters, min_size=1), min_size=1).map(tuple),
7074 def test_concat(self, decode_path, rel_path):
7075 dp = abs_decode_path(decode_path, rel_path)
7076 self.assertSequenceEqual(dp, decode_path + rel_path)
7080 lists(text(alphabet=ascii_letters, min_size=1)).map(tuple),
7081 lists(text(alphabet=ascii_letters, min_size=1), min_size=1).map(tuple),
7083 def test_abs(self, decode_path, rel_path):
7084 self.assertSequenceEqual(
7085 abs_decode_path(decode_path, ("/",) + rel_path),
7090 lists(text(alphabet=ascii_letters, min_size=1), min_size=5).map(tuple),
7091 integers(min_value=1, max_value=3),
7092 lists(text(alphabet=ascii_letters, min_size=1), min_size=1).map(tuple),
7094 def test_dots(self, decode_path, number_of_dots, rel_path):
7095 self.assertSequenceEqual(
7096 abs_decode_path(decode_path, tuple([".."] * number_of_dots) + rel_path),
7097 decode_path[:-number_of_dots] + rel_path,
7101 class TestStrictDefaultExistence(TestCase):
7102 @given(data_strategy())
7103 def runTest(self, d):
7104 count = d.draw(integers(min_value=1, max_value=10))
7105 chosen = d.draw(integers(min_value=0, max_value=count - 1))
7107 ("int%d" % i, Integer(expl=tag_ctxc(i + 1)))
7108 for i in range(count)
7110 for klass in (Sequence, Set):
7114 for i in range(count):
7115 seq["int%d" % i] = Integer(123)
7117 chosen_choice = "int%d" % chosen
7118 seq.specs[chosen_choice] = seq.specs[chosen_choice](default=123)
7119 with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
7121 decoded, _ = seq.decode(raw, ctx={"allow_default_values": True})
7122 self.assertTrue(decoded.ber_encoded)
7123 self.assertTrue(decoded.bered)
7124 decoded = copy(decoded)
7125 self.assertTrue(decoded.ber_encoded)
7126 self.assertTrue(decoded.bered)
7127 decoded, _ = seq.decode(raw, ctx={"bered": True})
7128 self.assertTrue(decoded.ber_encoded)
7129 self.assertTrue(decoded.bered)
7130 decoded = copy(decoded)
7131 self.assertTrue(decoded.ber_encoded)
7132 self.assertTrue(decoded.bered)
7135 class TestX690PrefixedType(TestCase):
7137 self.assertSequenceEqual(
7138 VisibleString("Jones").encode(),
7139 hexdec("1A054A6F6E6573"),
7141 self.assertSequenceEqual(
7144 impl=tag_encode(3, klass=TagClassApplication),
7146 hexdec("43054A6F6E6573"),
7148 self.assertSequenceEqual(
7152 impl=tag_encode(3, klass=TagClassApplication),
7156 hexdec("A20743054A6F6E6573"),
7158 self.assertSequenceEqual(
7162 impl=tag_encode(3, klass=TagClassApplication),
7164 impl=tag_encode(7, form=TagFormConstructed, klass=TagClassApplication),
7166 hexdec("670743054A6F6E6573"),
7168 self.assertSequenceEqual(
7169 VisibleString("Jones", impl=tag_ctxp(2)).encode(),
7170 hexdec("82054A6F6E6573"),
7174 class TestExplOOB(TestCase):
7176 expl = tag_ctxc(123)
7177 raw = Integer(123).encode() + Integer(234).encode()
7178 raw = b"".join((expl, len_encode(len(raw)), raw))
7179 with assertRaisesRegex(self, DecodeError, "explicit tag out-of-bound"):
7180 Integer(expl=expl).decode(raw)
7181 Integer(expl=expl).decode(raw, ctx={"allow_expl_oob": True})
7184 class TestPickleDifferentVersion(TestCase):
7186 pickled = pickle_dumps(Integer(123), pickle_proto)
7188 version_orig = pyderasn.__version__
7189 pyderasn.__version__ += "different"
7190 with assertRaisesRegex(self, ValueError, "different PyDERASN version"):
7191 pickle_loads(pickled)
7192 pyderasn.__version__ = version_orig
7193 pickle_loads(pickled)