tests/test_pyderasn.py

   1 # coding: utf-8
   2 # PyDERASN -- Python ASN.1 DER/BER codec with abstract structures
   3 # Copyright (C) 2017-2020 Sergey Matveev <stargrave@stargrave.org>
   4 #
   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.
   8 #
   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.
  13 #
  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/>.
  17
  18 from copy import copy
  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
  29 from time import time
  30 from unittest import TestCase
  31
  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
  57 from six import PY2
  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
  63
  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
 127
 128
 129 settings.register_profile("local", settings(
 130     deadline=5000,
 131 ))
 132 settings.load_profile("local")
 133 LONG_TEST_MAX_EXAMPLES = settings().max_examples * 4
 134
 135 tag_classes = sampled_from((
 136     TagClassApplication,
 137     TagClassContext,
 138     TagClassPrivate,
 139     TagClassUniversal,
 140 ))
 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)
 144 )
 145 ctx_dummy = dictionaries(integers(), integers(), min_size=2, max_size=4).example()
 146 copy_funcs = (
 147     copy,
 148     lambda obj: pickle_loads(pickle_dumps(obj, pickle_proto)),
 149 )
 150 self_module = import_module(__name__)
 151
 152
 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)
 158
 159
 160 def assert_exceeding_data(self, call, junk):
 161     if len(junk) <= 0:
 162         return
 163     with assertRaisesRegex(self, ExceedingData, "%d trailing bytes" % len(junk)) as err:
 164         call()
 165     repr(err)
 166
 167
 168 class TestHex(TestCase):
 169     @given(binary())
 170     def test_symmetric(self, data):
 171         self.assertEqual(hexdec(hexenc(data)), data)
 172
 173
 174 class TestTagCoder(TestCase):
 175     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
 176     @given(
 177         tag_classes,
 178         tag_forms,
 179         integers(min_value=0, max_value=30),
 180         binary(max_size=5),
 181     )
 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)
 186         self.assertEqual(
 187             byte2int(tag_encode(klass=klass, form=form, num=0)),
 188             byte2int(raw) & (1 << 7 | 1 << 6 | 1 << 5),
 189         )
 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)
 194
 195     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
 196     @given(
 197         tag_classes,
 198         tag_forms,
 199         integers(min_value=31),
 200         binary(max_size=5),
 201     )
 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)
 206         self.assertEqual(
 207             byte2int(tag_encode(klass=klass, form=form, num=0)) | 31,
 208             byte2int(raw[:1]),
 209         )
 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)
 216
 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)):
 222             raw[i] |= 0x80
 223         with assertRaisesRegex(self, DecodeError, "unfinished tag"):
 224             tag_strip(bytes(raw))
 225
 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)),
 238         ):
 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)
 247
 248     def test_go_vectors_invalid(self):
 249         for data in (
 250                 b"\x00\x83\x01\x00",
 251                 b"\x1f\x85",
 252                 b"\x30\x80",
 253                 b"\xa0\x82\x00\xff",
 254                 b"\xa0\x81\x7f",
 255         ):
 256             with self.assertRaises(DecodeError):
 257                 _, _, len_encoded = tag_strip(memoryview(data))
 258                 len_decode(len_encoded)
 259
 260     @given(
 261         integers(min_value=0, max_value=127),
 262         integers(min_value=0, max_value=2),
 263     )
 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):
 268             len_decode(octets)
 269
 270
 271 class TestLenCoder(TestCase):
 272     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
 273     @given(
 274         integers(min_value=0, max_value=127),
 275         binary(max_size=5),
 276     )
 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)
 284
 285     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
 286     @given(
 287         integers(min_value=128),
 288         binary(max_size=5),
 289     )
 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)
 298
 299     def test_empty(self):
 300         with self.assertRaises(NotEnoughData):
 301             len_decode(b"")
 302
 303     @given(integers(min_value=128))
 304     def test_stripped(self, _len):
 305         with self.assertRaises(NotEnoughData):
 306             len_decode(len_encode(_len)[:-1])
 307
 308
 309 text_printable = text(alphabet=printable, min_size=1)
 310
 311
 312 @composite
 313 def text_letters(draw):
 314     result = draw(text(alphabet=ascii_letters, min_size=1))
 315     if PY2:
 316         result = result.encode("ascii")
 317     return result
 318
 319
 320 class CommonMixin(object):
 321     def test_tag_default(self):
 322         obj = self.base_klass()
 323         self.assertEqual(obj.tag, obj.tag_default)
 324
 325     def test_simultaneous_impl_expl(self):
 326         with self.assertRaises(ValueError):
 327             self.base_klass(impl=b"whatever", expl=b"whenever")
 328
 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)
 337
 338     @given(binary(min_size=1))
 339     def test_impl_inherited(self, impl_tag):
 340         class Inherited(self.base_klass):
 341             impl = impl_tag
 342         obj = Inherited()
 343         self.assertSequenceEqual(obj.impl, impl_tag)
 344         self.assertFalse(obj.expled)
 345
 346     @given(binary())
 347     def test_expl_inherited(self, expl_tag):
 348         class Inherited(self.base_klass):
 349             expl = expl_tag
 350         obj = Inherited()
 351         self.assertSequenceEqual(obj.expl, expl_tag)
 352         self.assertTrue(obj.expled)
 353
 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)
 363
 364
 365 @composite
 366 def boolean_values_strategy(draw, do_expl=False):
 367     value = draw(one_of(none(), booleans()))
 368     impl = None
 369     expl = None
 370     if do_expl:
 371         expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
 372     else:
 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()))
 376     _decoded = (
 377         draw(integers(min_value=0)),
 378         draw(integers(min_value=0)),
 379         draw(integers(min_value=0)),
 380     )
 381     return (value, impl, expl, default, optional, _decoded)
 382
 383
 384 class BooleanInherited(Boolean):
 385     pass
 386
 387
 388 class TestBoolean(CommonMixin, TestCase):
 389     base_klass = Boolean
 390
 391     def test_invalid_value_type(self):
 392         with self.assertRaises(InvalidValueType) as err:
 393             Boolean(123)
 394         repr(err.exception)
 395
 396     @given(booleans())
 397     def test_optional(self, optional):
 398         obj = Boolean(default=Boolean(False), optional=optional)
 399         self.assertTrue(obj.optional)
 400
 401     @given(booleans())
 402     def test_ready(self, value):
 403         obj = Boolean()
 404         self.assertFalse(obj.ready)
 405         repr(obj)
 406         list(obj.pps())
 407         pprint(obj, big_blobs=True, with_decode_path=True)
 408         with self.assertRaises(ObjNotReady) as err:
 409             obj.encode()
 410         repr(err.exception)
 411         obj = Boolean(value)
 412         self.assertTrue(obj.ready)
 413         repr(obj)
 414         list(obj.pps())
 415         pprint(obj, big_blobs=True, with_decode_path=True)
 416
 417     @given(booleans(), booleans(), binary(), binary())
 418     def test_comparison(self, value1, value2, tag1, tag2):
 419         for klass in (Boolean, BooleanInherited):
 420             obj1 = klass(value1)
 421             obj2 = klass(value2)
 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)
 429
 430     @given(data_strategy())
 431     def test_call(self, d):
 432         for klass in (Boolean, BooleanInherited):
 433             (
 434                 value_initial,
 435                 impl_initial,
 436                 expl_initial,
 437                 default_initial,
 438                 optional_initial,
 439                 _decoded_initial,
 440             ) = d.draw(boolean_values_strategy())
 441             obj_initial = klass(
 442                 value_initial,
 443                 impl_initial,
 444                 expl_initial,
 445                 default_initial,
 446                 optional_initial or False,
 447                 _decoded_initial,
 448             )
 449             (
 450                 value,
 451                 impl,
 452                 expl,
 453                 default,
 454                 optional,
 455                 _decoded,
 456             ) = d.draw(boolean_values_strategy(do_expl=impl_initial is None))
 457             obj = obj_initial(value, impl, expl, default, optional)
 458             if obj.ready:
 459                 value_expected = default if value is None else value
 460                 value_expected = (
 461                     default_initial if value_expected is None
 462                     else value_expected
 463                 )
 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)
 467             self.assertEqual(
 468                 obj.default,
 469                 default_initial if default is None else default,
 470             )
 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
 474             else:
 475                 optional = True
 476             self.assertEqual(obj.optional, optional)
 477
 478     @given(boolean_values_strategy())
 479     def test_copy(self, values):
 480         for klass in (Boolean, BooleanInherited):
 481             obj = klass(*values)
 482             for copy_func in copy_funcs:
 483                 obj_copied = copy_func(obj)
 484                 self.assert_copied_basic_fields(obj, obj_copied)
 485
 486     @given(
 487         booleans(),
 488         integers(min_value=1).map(tag_encode),
 489     )
 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])
 494
 495     @given(
 496         booleans(),
 497         integers(min_value=1).map(tag_ctxc),
 498     )
 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])
 503
 504     @given(
 505         integers(min_value=31),
 506         integers(min_value=0),
 507         decode_path_strat,
 508     )
 509     def test_bad_tag(self, tag, offset, decode_path):
 510         with self.assertRaises(DecodeError) as err:
 511             Boolean().decode(
 512                 tag_encode(tag)[:-1],
 513                 offset=offset,
 514                 decode_path=decode_path,
 515             )
 516         repr(err.exception)
 517         self.assertEqual(err.exception.offset, offset)
 518         self.assertEqual(err.exception.decode_path, decode_path)
 519
 520     @given(
 521         integers(min_value=31),
 522         integers(min_value=0),
 523         decode_path_strat,
 524     )
 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],
 529                 offset=offset,
 530                 decode_path=decode_path,
 531             )
 532         repr(err.exception)
 533         self.assertEqual(err.exception.offset, offset)
 534         self.assertEqual(err.exception.decode_path, decode_path)
 535
 536     @given(
 537         integers(min_value=128),
 538         integers(min_value=0),
 539         decode_path_strat,
 540     )
 541     def test_bad_len(self, l, offset, decode_path):
 542         with self.assertRaises(DecodeError) as err:
 543             Boolean().decode(
 544                 Boolean.tag_default + len_encode(l)[:-1],
 545                 offset=offset,
 546                 decode_path=decode_path,
 547             )
 548         repr(err.exception)
 549         self.assertEqual(err.exception.offset, offset)
 550         self.assertEqual(err.exception.decode_path, decode_path)
 551
 552     @given(
 553         integers(min_value=128),
 554         integers(min_value=0),
 555         decode_path_strat,
 556     )
 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],
 561                 offset=offset,
 562                 decode_path=decode_path,
 563             )
 564         repr(err.exception)
 565         self.assertEqual(err.exception.offset, offset)
 566         self.assertEqual(err.exception.decode_path, decode_path)
 567
 568     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
 569     @given(
 570         boolean_values_strategy(),
 571         booleans(),
 572         integers(min_value=1).map(tag_ctxc),
 573         integers(min_value=0),
 574         binary(max_size=5),
 575     )
 576     def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
 577         for klass in (Boolean, BooleanInherited):
 578             _, _, _, default, optional, _decoded = values
 579             obj = klass(
 580                 value=value,
 581                 default=default,
 582                 optional=optional,
 583                 _decoded=_decoded,
 584             )
 585             repr(obj)
 586             list(obj.pps())
 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)
 592             repr(obj_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),
 599                 offset=offset,
 600                 ctx=ctx_copied,
 601             )
 602             self.assertDictEqual(ctx_copied, ctx_dummy)
 603             repr(obj_decoded)
 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))
 614             self.assertEqual(
 615                 obj_decoded.expl_llen,
 616                 len(len_encode(len(obj_encoded))),
 617             )
 618             self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
 619             self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
 620             self.assertEqual(
 621                 obj_decoded.offset,
 622                 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
 623             )
 624             self.assertEqual(obj_decoded.expl_offset, offset)
 625             assert_exceeding_data(
 626                 self,
 627                 lambda: obj_expled.hexdecod(obj_expled_hex_encoded + hexenc(tail_junk)),
 628                 tail_junk,
 629             )
 630
 631     @given(integers(min_value=2))
 632     def test_invalid_len(self, l):
 633         with self.assertRaises(InvalidLength):
 634             Boolean().decode(b"".join((
 635                 Boolean.tag_default,
 636                 len_encode(l),
 637                 b"\x00" * l,
 638             )))
 639
 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((
 644                 Boolean.tag_default,
 645                 len_encode(1),
 646                 int2byte(value),
 647             )))
 648         obj, _ = Boolean().decode(
 649             b"".join((
 650                 Boolean.tag_default,
 651                 len_encode(1),
 652                 int2byte(value),
 653             )),
 654             ctx={"bered": True},
 655         )
 656         self.assertTrue(bool(obj))
 657         self.assertTrue(obj.ber_encoded)
 658         self.assertFalse(obj.lenindef)
 659         self.assertTrue(obj.bered)
 660         obj = copy(obj)
 661         self.assertTrue(obj.ber_encoded)
 662         self.assertFalse(obj.lenindef)
 663         self.assertTrue(obj.bered)
 664
 665     @given(
 666         integers(min_value=1).map(tag_ctxc),
 667         binary().filter(lambda x: not x.startswith(EOC)),
 668     )
 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,
 677             ctx={"bered": True},
 678         )
 679         self.assertTrue(obj.expl_lenindef)
 680         self.assertFalse(obj.lenindef)
 681         self.assertFalse(obj.ber_encoded)
 682         self.assertTrue(obj.bered)
 683         obj = copy(obj)
 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)
 689         repr(obj)
 690         list(obj.pps())
 691         pprint(obj, big_blobs=True, with_decode_path=True)
 692
 693     @given(
 694         integers(min_value=1).map(tag_ctxc),
 695         lists(
 696             booleans(),
 697             min_size=1,
 698             max_size=5,
 699         ),
 700     )
 701     def test_ber_expl(self, expl, values):
 702         encoded = b""
 703         for value in values:
 704             encoded += (
 705                 expl +
 706                 LENINDEF +
 707                 Boolean(value).encode() +
 708                 EOC
 709             )
 710         encoded = SequenceOf.tag_default + len_encode(len(encoded)) + encoded
 711
 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)
 719         self.assertSetEqual(
 720             set(
 721                 (
 722                     v.tlvlen,
 723                     v.expl_tlvlen,
 724                     v.expl_tlen,
 725                     v.expl_llen,
 726                     v.ber_encoded,
 727                     v.lenindef,
 728                     v.expl_lenindef,
 729                     v.bered,
 730                 ) for v in seqof
 731             ),
 732             set(((
 733                 3 + EOC_LEN,
 734                 len(expl) + 1 + 3 + EOC_LEN,
 735                 len(expl),
 736                 1,
 737                 False,
 738                 False,
 739                 True,
 740                 True,
 741             ),)),
 742         )
 743         repr(seqof)
 744         list(seqof.pps())
 745         pprint(seqof, big_blobs=True, with_decode_path=True)
 746
 747
 748 @composite
 749 def integer_values_strategy(draw, do_expl=False):
 750     bound_min, value, default, bound_max = sorted(draw(sets(
 751         integers(),
 752         min_size=4,
 753         max_size=4,
 754     )))
 755     if draw(booleans()):
 756         value = None
 757     _specs = None
 758     if draw(booleans()):
 759         _specs = draw(sets(text_letters()))
 760         values = draw(sets(
 761             integers(),
 762             min_size=len(_specs),
 763             max_size=len(_specs),
 764         ))
 765         _specs = list(zip(_specs, values))
 766     bounds = None
 767     if draw(booleans()):
 768         bounds = (bound_min, bound_max)
 769     impl = None
 770     expl = None
 771     if do_expl:
 772         expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
 773     else:
 774         impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
 775     if draw(booleans()):
 776         default = None
 777     optional = draw(one_of(none(), booleans()))
 778     _decoded = (
 779         draw(integers(min_value=0)),
 780         draw(integers(min_value=0)),
 781         draw(integers(min_value=0)),
 782     )
 783     return (value, bounds, impl, expl, default, optional, _specs, _decoded)
 784
 785
 786 class IntegerInherited(Integer):
 787     pass
 788
 789
 790 class TestInteger(CommonMixin, TestCase):
 791     base_klass = Integer
 792
 793     def test_invalid_value_type(self):
 794         with self.assertRaises(InvalidValueType) as err:
 795             Integer(12.3)
 796         repr(err.exception)
 797
 798     @given(sets(text_letters(), min_size=2))
 799     def test_unknown_name(self, names_input):
 800         missing = names_input.pop()
 801
 802         class Int(Integer):
 803             schema = [(n, 123) for n in names_input]
 804         with self.assertRaises(ObjUnknown) as err:
 805             Int(missing)
 806         repr(err.exception)
 807
 808     @given(sets(text_letters(), min_size=2))
 809     def test_known_name(self, names_input):
 810         class Int(Integer):
 811             schema = [(n, 123) for n in names_input]
 812         Int(names_input.pop())
 813
 814     @given(booleans())
 815     def test_optional(self, optional):
 816         obj = Integer(default=Integer(0), optional=optional)
 817         self.assertTrue(obj.optional)
 818
 819     @given(integers())
 820     def test_ready(self, value):
 821         obj = Integer()
 822         self.assertFalse(obj.ready)
 823         repr(obj)
 824         list(obj.pps())
 825         pprint(obj, big_blobs=True, with_decode_path=True)
 826         with self.assertRaises(ObjNotReady) as err:
 827             obj.encode()
 828         repr(err.exception)
 829         obj = Integer(value)
 830         self.assertTrue(obj.ready)
 831         repr(obj)
 832         list(obj.pps())
 833         pprint(obj, big_blobs=True, with_decode_path=True)
 834         hash(obj)
 835
 836     @given(integers(), integers(), binary(), binary())
 837     def test_comparison(self, value1, value2, tag1, tag2):
 838         for klass in (Integer, IntegerInherited):
 839             obj1 = klass(value1)
 840             obj2 = klass(value2)
 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)
 848
 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)],
 853             sorted(values),
 854         )
 855
 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(
 860             integers(),
 861             min_size=len(names_input),
 862             max_size=len(names_input),
 863         )))
 864         chosen_name = d.draw(sampled_from(names_input))
 865         names_input = dict(zip(names_input, values_input))
 866
 867         class Int(Integer):
 868             schema = names_input
 869         _int = Int(chosen_name)
 870         self.assertEqual(_int.named, chosen_name)
 871         self.assertEqual(int(_int), names_input[chosen_name])
 872
 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))
 878
 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]))
 884         repr(err.exception)
 885         with assertRaisesRegex(self, DecodeError, "bounds") as err:
 886             Integer(bounds=(values[1], values[2])).decode(
 887                 Integer(values[0]).encode()
 888             )
 889         repr(err.exception)
 890         with self.assertRaises(BoundsError) as err:
 891             Integer(value=values[2], bounds=(values[0], values[1]))
 892         repr(err.exception)
 893         with assertRaisesRegex(self, DecodeError, "bounds") as err:
 894             Integer(bounds=(values[0], values[1])).decode(
 895                 Integer(values[2]).encode()
 896             )
 897         repr(err.exception)
 898
 899     @given(data_strategy())
 900     def test_call(self, d):
 901         for klass in (Integer, IntegerInherited):
 902             (
 903                 value_initial,
 904                 bounds_initial,
 905                 impl_initial,
 906                 expl_initial,
 907                 default_initial,
 908                 optional_initial,
 909                 _specs_initial,
 910                 _decoded_initial,
 911             ) = d.draw(integer_values_strategy())
 912             obj_initial = klass(
 913                 value_initial,
 914                 bounds_initial,
 915                 impl_initial,
 916                 expl_initial,
 917                 default_initial,
 918                 optional_initial or False,
 919                 _specs_initial,
 920                 _decoded_initial,
 921             )
 922             (
 923                 value,
 924                 bounds,
 925                 impl,
 926                 expl,
 927                 default,
 928                 optional,
 929                 _,
 930                 _decoded,
 931             ) = d.draw(integer_values_strategy(do_expl=impl_initial is None))
 932             if (default is None) and (obj_initial.default is not None):
 933                 bounds = None
 934             if (
 935                     (bounds is None) and
 936                     (value is not None) and
 937                     (bounds_initial is not None) and
 938                     not (bounds_initial[0] <= value <= bounds_initial[1])
 939             ):
 940                 value = None
 941             if (
 942                     (bounds is None) and
 943                     (default is not None) and
 944                     (bounds_initial is not None) and
 945                     not (bounds_initial[0] <= default <= bounds_initial[1])
 946             ):
 947                 default = None
 948             obj = obj_initial(value, bounds, impl, expl, default, optional)
 949             if obj.ready:
 950                 value_expected = default if value is None else value
 951                 value_expected = (
 952                     default_initial if value_expected is None
 953                     else value_expected
 954                 )
 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)
 958             self.assertEqual(
 959                 obj.default,
 960                 default_initial if default is None else default,
 961             )
 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
 965             else:
 966                 optional = True
 967             self.assertEqual(obj.optional, optional)
 968             self.assertEqual(
 969                 (obj._bound_min, obj._bound_max),
 970                 bounds or bounds_initial or (float("-inf"), float("+inf")),
 971             )
 972             self.assertEqual(
 973                 obj.specs,
 974                 {} if _specs_initial is None else dict(_specs_initial),
 975             )
 976
 977     @given(integer_values_strategy())
 978     def test_copy(self, values):
 979         for klass in (Integer, IntegerInherited):
 980             obj = klass(*values)
 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)
 988
 989     @given(
 990         integers(),
 991         integers(min_value=1).map(tag_encode),
 992     )
 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])
 997
 998     @given(
 999         integers(),
1000         integers(min_value=1).map(tag_ctxc),
1001     )
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])
1006
1007     def test_zero_len(self):
1008         with self.assertRaises(NotEnoughData):
1009             Integer().decode(b"".join((
1010                 Integer.tag_default,
1011                 len_encode(0),
1012             )))
1013
1014     @given(
1015         integers(min_value=31),
1016         integers(min_value=0),
1017         decode_path_strat,
1018     )
1019     def test_bad_tag(self, tag, offset, decode_path):
1020         with self.assertRaises(DecodeError) as err:
1021             Integer().decode(
1022                 tag_encode(tag)[:-1],
1023                 offset=offset,
1024                 decode_path=decode_path,
1025             )
1026         repr(err.exception)
1027         self.assertEqual(err.exception.offset, offset)
1028         self.assertEqual(err.exception.decode_path, decode_path)
1029
1030     @given(
1031         integers(min_value=128),
1032         integers(min_value=0),
1033         decode_path_strat,
1034     )
1035     def test_bad_len(self, l, offset, decode_path):
1036         with self.assertRaises(DecodeError) as err:
1037             Integer().decode(
1038                 Integer.tag_default + len_encode(l)[:-1],
1039                 offset=offset,
1040                 decode_path=decode_path,
1041             )
1042         repr(err.exception)
1043         self.assertEqual(err.exception.offset, offset)
1044         self.assertEqual(err.exception.decode_path, decode_path)
1045
1046     @given(
1047         sets(integers(), min_size=2, max_size=2),
1048         integers(min_value=0),
1049         decode_path_strat,
1050     )
1051     def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
1052         value, bound_min = list(sorted(ints))
1053
1054         class Int(Integer):
1055             bounds = (bound_min, bound_min)
1056         with self.assertRaises(DecodeError) as err:
1057             Int().decode(
1058                 Integer(value).encode(),
1059                 offset=offset,
1060                 decode_path=decode_path,
1061             )
1062         repr(err.exception)
1063         self.assertEqual(err.exception.offset, offset)
1064         self.assertEqual(err.exception.decode_path, decode_path)
1065
1066     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
1067     @given(
1068         integer_values_strategy(),
1069         integers(),
1070         integers(min_value=1).map(tag_ctxc),
1071         integers(min_value=0),
1072         binary(max_size=5),
1073     )
1074     def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
1075         for klass in (Integer, IntegerInherited):
1076             _, _, _, _, default, optional, _, _decoded = values
1077             obj = klass(
1078                 value=value,
1079                 default=default,
1080                 optional=optional,
1081                 _decoded=_decoded,
1082             )
1083             repr(obj)
1084             list(obj.pps())
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)
1090             repr(obj_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,
1097                 offset=offset,
1098                 ctx=ctx_copied,
1099             )
1100             self.assertDictEqual(ctx_copied, ctx_dummy)
1101             repr(obj_decoded)
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))
1112             self.assertEqual(
1113                 obj_decoded.expl_llen,
1114                 len(len_encode(len(obj_encoded))),
1115             )
1116             self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
1117             self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
1118             self.assertEqual(
1119                 obj_decoded.offset,
1120                 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
1121             )
1122             self.assertEqual(obj_decoded.expl_offset, offset)
1123             assert_exceeding_data(
1124                 self,
1125                 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
1126                 tail_junk,
1127             )
1128
1129     def test_go_vectors_valid(self):
1130         for data, expect in ((
1131                 (b"\x00", 0),
1132                 (b"\x7f", 127),
1133                 (b"\x80", -128),
1134                 (b"\xff\x7f", -129),
1135                 (b"\xff", -1),
1136                 (b"\x01", 1),
1137                 (b"\x00\xff", 255),
1138                 (b"\xff\x00", -256),
1139                 (b"\x01\x00", 256),
1140                 (b"\x00\x80", 128),
1141                 (b"\x01\x00", 256),
1142                 (b"\x80\x00\x00\x00\x00\x00\x00\x00", -9223372036854775808),
1143                 (b"\x80\x00\x00\x00", -2147483648),
1144         )):
1145             self.assertEqual(
1146                 Integer().decode(b"".join((
1147                     Integer.tag_default,
1148                     len_encode(len(data)),
1149                     data,
1150                 )))[0],
1151                 expect,
1152             )
1153
1154     def test_go_vectors_invalid(self):
1155         for data in ((
1156                 b"\x00\x7f",
1157                 b"\xff\xf0",
1158         )):
1159             with self.assertRaises(DecodeError):
1160                 Integer().decode(b"".join((
1161                     Integer.tag_default,
1162                     len_encode(len(data)),
1163                     data,
1164                 )))
1165
1166
1167 @composite
1168 def bit_string_values_strategy(draw, schema=None, value_required=False, do_expl=False):
1169     if schema is None:
1170         schema = ()
1171         if draw(booleans()):
1172             schema = draw(sets(text_letters(), min_size=1, max_size=256))
1173             bits = draw(sets(
1174                 integers(min_value=0, max_value=255),
1175                 min_size=len(schema),
1176                 max_size=len(schema),
1177             ))
1178             schema = list(zip(schema, bits))
1179
1180     def _value(value_required):
1181         if not value_required and draw(booleans()):
1182             return None
1183         generation_choice = 0
1184         if value_required:
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),
1190             )))
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]))))
1195         return None
1196     value = _value(value_required)
1197     default = _value(value_required=False)
1198     impl = None
1199     expl = None
1200     if do_expl:
1201         expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
1202     else:
1203         impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
1204     optional = draw(one_of(none(), booleans()))
1205     _decoded = (
1206         draw(integers(min_value=0)),
1207         draw(integers(min_value=0)),
1208         draw(integers(min_value=0)),
1209     )
1210     return (schema, value, impl, expl, default, optional, _decoded)
1211
1212
1213 class BitStringInherited(BitString):
1214     pass
1215
1216
1217 class TestBitString(CommonMixin, TestCase):
1218     base_klass = BitString
1219
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)
1227
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])
1233
1234     def test_bad_b_encoding(self):
1235         with self.assertRaises(ValueError):
1236             BitString("'010120101'B")
1237
1238     @given(
1239         integers(min_value=1, max_value=255),
1240         integers(min_value=1, max_value=255),
1241     )
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)
1246
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)
1252
1253     def test_zero_len(self):
1254         with self.assertRaises(NotEnoughData):
1255             BitString().decode(b"".join((
1256                 BitString.tag_default,
1257                 len_encode(0),
1258             )))
1259
1260     def test_invalid_value_type(self):
1261         with self.assertRaises(InvalidValueType) as err:
1262             BitString(123)
1263         repr(err.exception)
1264         with self.assertRaises(InvalidValueType) as err:
1265             BitString(u"123")
1266         repr(err.exception)
1267
1268     def test_obj_unknown(self):
1269         with self.assertRaises(ObjUnknown) as err:
1270             BitString(b"whatever")["whenever"]
1271         repr(err.exception)
1272
1273     def test_get_invalid_type(self):
1274         with self.assertRaises(InvalidValueType) as err:
1275             BitString(b"whatever")[(1, 2, 3)]
1276         repr(err.exception)
1277
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()
1282
1283         class BS(BitString):
1284             schema = [(n, i) for i, n in enumerate(_schema)]
1285         with self.assertRaises(ObjUnknown) as err:
1286             BS((missing,))
1287         repr(err.exception)
1288
1289     @given(booleans())
1290     def test_optional(self, optional):
1291         obj = BitString(default=BitString(b""), optional=optional)
1292         self.assertTrue(obj.optional)
1293
1294     @given(binary())
1295     def test_ready(self, value):
1296         obj = BitString()
1297         self.assertFalse(obj.ready)
1298         repr(obj)
1299         list(obj.pps())
1300         pprint(obj, big_blobs=True, with_decode_path=True)
1301         with self.assertRaises(ObjNotReady) as err:
1302             obj.encode()
1303         repr(err.exception)
1304         obj = BitString(value)
1305         self.assertTrue(obj.ready)
1306         repr(obj)
1307         list(obj.pps())
1308         pprint(obj, big_blobs=True, with_decode_path=True)
1309
1310     @given(
1311         tuples(integers(min_value=0), binary()),
1312         tuples(integers(min_value=0), binary()),
1313         binary(min_size=1),
1314         binary(min_size=1),
1315     )
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)
1327
1328     @given(data_strategy())
1329     def test_call(self, d):
1330         for klass in (BitString, BitStringInherited):
1331             (
1332                 schema_initial,
1333                 value_initial,
1334                 impl_initial,
1335                 expl_initial,
1336                 default_initial,
1337                 optional_initial,
1338                 _decoded_initial,
1339             ) = d.draw(bit_string_values_strategy())
1340
1341             class BS(klass):
1342                 schema = schema_initial
1343             obj_initial = BS(
1344                 value=value_initial,
1345                 impl=impl_initial,
1346                 expl=expl_initial,
1347                 default=default_initial,
1348                 optional=optional_initial or False,
1349                 _decoded=_decoded_initial,
1350             )
1351             (
1352                 _,
1353                 value,
1354                 impl,
1355                 expl,
1356                 default,
1357                 optional,
1358                 _decoded,
1359             ) = d.draw(bit_string_values_strategy(
1360                 schema=schema_initial,
1361                 do_expl=impl_initial is None,
1362             ))
1363             obj = obj_initial(
1364                 value=value,
1365                 impl=impl,
1366                 expl=expl,
1367                 default=default,
1368                 optional=optional,
1369             )
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
1375             else:
1376                 optional = True
1377             self.assertEqual(obj.optional, optional)
1378             self.assertEqual(obj.specs, obj_initial.specs)
1379
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
1384
1385             class BS(klass):
1386                 schema = _schema
1387             register_class(BS)
1388             obj = BS(
1389                 value=value,
1390                 impl=impl,
1391                 expl=expl,
1392                 default=default,
1393                 optional=optional or False,
1394                 _decoded=_decoded,
1395             )
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)
1401
1402     @given(
1403         binary(),
1404         integers(min_value=1).map(tag_encode),
1405     )
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])
1410
1411     @given(
1412         binary(),
1413         integers(min_value=1).map(tag_ctxc),
1414     )
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])
1419
1420     @given(
1421         integers(min_value=31),
1422         integers(min_value=0),
1423         decode_path_strat,
1424     )
1425     def test_bad_tag(self, tag, offset, decode_path):
1426         with self.assertRaises(DecodeError) as err:
1427             BitString().decode(
1428                 tag_encode(tag)[:-1],
1429                 offset=offset,
1430                 decode_path=decode_path,
1431             )
1432         repr(err.exception)
1433         self.assertEqual(err.exception.offset, offset)
1434         self.assertEqual(err.exception.decode_path, decode_path)
1435
1436     @given(
1437         integers(min_value=128),
1438         integers(min_value=0),
1439         decode_path_strat,
1440     )
1441     def test_bad_len(self, l, offset, decode_path):
1442         with self.assertRaises(DecodeError) as err:
1443             BitString().decode(
1444                 BitString.tag_default + len_encode(l)[:-1],
1445                 offset=offset,
1446                 decode_path=decode_path,
1447             )
1448         repr(err.exception)
1449         self.assertEqual(err.exception.offset, offset)
1450         self.assertEqual(err.exception.decode_path, decode_path)
1451
1452     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
1453     @given(data_strategy())
1454     def test_symmetric(self, d):
1455         (
1456             _schema,
1457             value,
1458             _,
1459             _,
1460             default,
1461             optional,
1462             _decoded,
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):
1468             class BS(klass):
1469                 schema = _schema
1470             obj = BS(
1471                 value=value,
1472                 default=default,
1473                 optional=optional,
1474                 _decoded=_decoded,
1475             )
1476             repr(obj)
1477             list(obj.pps())
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)
1483             repr(obj_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,
1490                 offset=offset,
1491                 ctx=ctx_copied,
1492             )
1493             self.assertDictEqual(ctx_copied, ctx_dummy)
1494             repr(obj_decoded)
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))
1505             self.assertEqual(
1506                 obj_decoded.expl_llen,
1507                 len(len_encode(len(obj_encoded))),
1508             )
1509             self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
1510             self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
1511             self.assertEqual(
1512                 obj_decoded.offset,
1513                 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
1514             )
1515             self.assertEqual(obj_decoded.expl_offset, offset)
1516             if isinstance(value, tuple):
1517                 self.assertSetEqual(set(value), set(obj_decoded.named))
1518                 for name in value:
1519                     obj_decoded[name]
1520             assert_exceeding_data(
1521                 self,
1522                 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
1523                 tail_junk,
1524             )
1525
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,
1531                 len_encode(1),
1532                 int2byte(pad_size),
1533             )))
1534
1535     def test_go_vectors_invalid(self):
1536         for data in ((
1537                 b"\x07\x01",
1538                 b"\x07\x40",
1539                 b"\x08\x00",
1540         )):
1541             with self.assertRaises(DecodeError):
1542                 BitString().decode(b"".join((
1543                     BitString.tag_default,
1544                     len_encode(2),
1545                     data,
1546                 )))
1547
1548     def test_go_vectors_valid(self):
1549         obj, _ = BitString().decode(b"".join((
1550             BitString.tag_default,
1551             len_encode(1),
1552             b"\x00",
1553         )))
1554         self.assertEqual(bytes(obj), b"")
1555         self.assertEqual(obj.bit_len, 0)
1556
1557         obj, _ = BitString().decode(b"".join((
1558             BitString.tag_default,
1559             len_encode(2),
1560             b"\x07\x00",
1561         )))
1562         self.assertEqual(bytes(obj), b"\x00")
1563         self.assertEqual(obj.bit_len, 1)
1564
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])
1571
1572     @given(
1573         integers(min_value=1, max_value=30),
1574         lists(
1575             one_of(
1576                 binary(min_size=1, max_size=5),
1577                 lists(
1578                     binary(min_size=1, max_size=5),
1579                     min_size=1,
1580                     max_size=3,
1581                 ),
1582             ),
1583             min_size=0,
1584             max_size=3,
1585         ),
1586         lists(booleans(), min_size=1),
1587         binary(),
1588     )
1589     def test_constructed(self, impl, chunk_inputs, chunk_last_bits, junk):
1590         def chunk_constructed(contents):
1591             return (
1592                 tag_encode(form=TagFormConstructed, num=3) +
1593                 LENINDEF +
1594                 b"".join(BitString(content).encode() for content in contents) +
1595                 EOC
1596             )
1597         chunks = []
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
1605             else:
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
1612         ))
1613         payload_expected += bytes(chunk_last)
1614         bit_len_expected += chunk_last.bit_len
1615         encoded_indefinite = (
1616             tag_encode(form=TagFormConstructed, num=impl) +
1617             LENINDEF +
1618             b"".join(chunks) +
1619             chunk_last.encode() +
1620             EOC
1621         )
1622         encoded_definite = (
1623             tag_encode(form=TagFormConstructed, num=impl) +
1624             len_encode(len(b"".join(chunks) + chunk_last.encode())) +
1625             b"".join(chunks) +
1626             chunk_last.encode()
1627         )
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),
1633         ):
1634             obj, tail = BitString(impl=tag_encode(impl)).decode(
1635                 encoded + junk,
1636                 ctx={"bered": True},
1637             )
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)
1644             obj = copy(obj)
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)
1649             repr(obj)
1650             list(obj.pps())
1651             pprint(obj, big_blobs=True, with_decode_path=True)
1652
1653     @given(
1654         integers(min_value=0),
1655         decode_path_strat,
1656     )
1657     def test_ber_definite_too_short(self, offset, decode_path):
1658         with assertRaisesRegex(self, DecodeError, "longer than data") as err:
1659             BitString().decode(
1660                 tag_encode(3, form=TagFormConstructed) + len_encode(1),
1661                 offset=offset,
1662                 decode_path=decode_path,
1663                 ctx={"bered": True},
1664             )
1665         self.assertEqual(err.exception.decode_path, decode_path)
1666         self.assertEqual(err.exception.offset, offset)
1667
1668     @given(
1669         integers(min_value=0),
1670         decode_path_strat,
1671     )
1672     def test_ber_definite_no_data(self, offset, decode_path):
1673         with assertRaisesRegex(self, DecodeError, "zero length") as err:
1674             BitString().decode(
1675                 tag_encode(3, form=TagFormConstructed) + len_encode(0),
1676                 offset=offset,
1677                 decode_path=decode_path,
1678                 ctx={"bered": True},
1679             )
1680         self.assertEqual(err.exception.decode_path, decode_path)
1681         self.assertEqual(err.exception.offset, offset)
1682
1683     @given(
1684         integers(min_value=0),
1685         decode_path_strat,
1686         integers(min_value=1, max_value=3),
1687     )
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:
1691             BitString().decode(
1692                 tag_encode(3, form=TagFormConstructed) + LENINDEF + chunks * bs,
1693                 offset=offset,
1694                 decode_path=decode_path,
1695                 ctx={"bered": True},
1696             )
1697         self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),))
1698         self.assertEqual(err.exception.offset, offset + 1 + 1 + chunks * len(bs))
1699
1700     @given(
1701         integers(min_value=0),
1702         decode_path_strat,
1703         integers(min_value=1, max_value=3),
1704     )
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:
1709             BitString().decode(
1710                 (
1711                     tag_encode(3, form=TagFormConstructed) +
1712                     len_encode((chunks + 1) * len(bs)) +
1713                     chunks * bs +
1714                     bs_longer
1715                 ),
1716                 offset=offset,
1717                 decode_path=decode_path,
1718                 ctx={"bered": True},
1719             )
1720         self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),))
1721         self.assertEqual(err.exception.offset, offset + 1 + 1 + chunks * len(bs))
1722
1723     @given(
1724         integers(min_value=0),
1725         decode_path_strat,
1726     )
1727     def test_ber_indefinite_no_chunks(self, offset, decode_path):
1728         with assertRaisesRegex(self, DecodeError, "no chunks") as err:
1729             BitString().decode(
1730                 tag_encode(3, form=TagFormConstructed) + LENINDEF + EOC,
1731                 offset=offset,
1732                 decode_path=decode_path,
1733                 ctx={"bered": True},
1734             )
1735         self.assertEqual(err.exception.decode_path, decode_path)
1736         self.assertEqual(err.exception.offset, offset)
1737
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:
1749             BitString().decode(
1750                 (
1751                     tag_encode(3, form=TagFormConstructed) +
1752                     LENINDEF +
1753                     b"".join(chunks) +
1754                     EOC
1755                 ),
1756                 offset=offset,
1757                 decode_path=decode_path,
1758                 ctx={"bered": True},
1759             )
1760         self.assertEqual(
1761             err.exception.decode_path,
1762             decode_path + (str(chunks.index(bs_short)),),
1763         )
1764         self.assertEqual(
1765             err.exception.offset,
1766             offset + 1 + 1 + chunks.index(bs_short) * len(bs_full),
1767         )
1768
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},
1777         )
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)
1783         obj = copy(obj)
1784         self.assertTrue(obj.ber_encoded)
1785         self.assertTrue(obj.lenindef)
1786         self.assertTrue(obj.bered)
1787
1788
1789 @composite
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),
1793         min_size=2,
1794         max_size=2,
1795     )))
1796     value = draw(one_of(
1797         none(),
1798         binary(min_size=bound_min, max_size=bound_max),
1799     ))
1800     default = draw(one_of(
1801         none(),
1802         binary(min_size=bound_min, max_size=bound_max),
1803     ))
1804     bounds = None
1805     if draw(booleans()):
1806         bounds = (bound_min, bound_max)
1807     impl = None
1808     expl = None
1809     if do_expl:
1810         expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
1811     else:
1812         impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
1813     optional = draw(one_of(none(), booleans()))
1814     _decoded = (
1815         draw(integers(min_value=0)),
1816         draw(integers(min_value=0)),
1817         draw(integers(min_value=0)),
1818     )
1819     return (value, bounds, impl, expl, default, optional, _decoded)
1820
1821
1822 class OctetStringInherited(OctetString):
1823     pass
1824
1825
1826 class TestOctetString(CommonMixin, TestCase):
1827     base_klass = OctetString
1828
1829     def test_invalid_value_type(self):
1830         with self.assertRaises(InvalidValueType) as err:
1831             OctetString(text_type(123))
1832         repr(err.exception)
1833
1834     @given(booleans())
1835     def test_optional(self, optional):
1836         obj = OctetString(default=OctetString(b""), optional=optional)
1837         self.assertTrue(obj.optional)
1838
1839     @given(binary())
1840     def test_ready(self, value):
1841         obj = OctetString()
1842         self.assertFalse(obj.ready)
1843         repr(obj)
1844         list(obj.pps())
1845         pprint(obj, big_blobs=True, with_decode_path=True)
1846         with self.assertRaises(ObjNotReady) as err:
1847             obj.encode()
1848         repr(err.exception)
1849         obj = OctetString(value)
1850         self.assertTrue(obj.ready)
1851         repr(obj)
1852         list(obj.pps())
1853         pprint(obj, big_blobs=True, with_decode_path=True)
1854
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)
1867
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)],
1872             sorted(values),
1873         )
1874
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))
1881
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))
1889         repr(err.exception)
1890         with assertRaisesRegex(self, DecodeError, "bounds") as err:
1891             OctetString(bounds=(bound_min, bound_max)).decode(
1892                 OctetString(value).encode()
1893             )
1894         repr(err.exception)
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))
1898         repr(err.exception)
1899         with assertRaisesRegex(self, DecodeError, "bounds") as err:
1900             OctetString(bounds=(bound_min, bound_max)).decode(
1901                 OctetString(value).encode()
1902             )
1903         repr(err.exception)
1904
1905     @given(data_strategy())
1906     def test_call(self, d):
1907         for klass in (OctetString, OctetStringInherited):
1908             (
1909                 value_initial,
1910                 bounds_initial,
1911                 impl_initial,
1912                 expl_initial,
1913                 default_initial,
1914                 optional_initial,
1915                 _decoded_initial,
1916             ) = d.draw(octet_string_values_strategy())
1917             obj_initial = klass(
1918                 value_initial,
1919                 bounds_initial,
1920                 impl_initial,
1921                 expl_initial,
1922                 default_initial,
1923                 optional_initial or False,
1924                 _decoded_initial,
1925             )
1926             (
1927                 value,
1928                 bounds,
1929                 impl,
1930                 expl,
1931                 default,
1932                 optional,
1933                 _decoded,
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):
1936                 bounds = None
1937             if (
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])
1942             ):
1943                 value = None
1944             if (
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])
1949             ):
1950                 default = None
1951             obj = obj_initial(value, bounds, impl, expl, default, optional)
1952             if obj.ready:
1953                 value_expected = default if value is None else value
1954                 value_expected = (
1955                     default_initial if value_expected is None
1956                     else value_expected
1957                 )
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)
1961             self.assertEqual(
1962                 obj.default,
1963                 default_initial if default is None else default,
1964             )
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
1968             else:
1969                 optional = True
1970             self.assertEqual(obj.optional, optional)
1971             self.assertEqual(
1972                 (obj._bound_min, obj._bound_max),
1973                 bounds or bounds_initial or (0, float("+inf")),
1974             )
1975
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)
1986
1987     @given(
1988         binary(),
1989         integers(min_value=1).map(tag_encode),
1990     )
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])
1995
1996     @given(
1997         binary(),
1998         integers(min_value=1).map(tag_ctxc),
1999     )
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])
2004
2005     @given(
2006         integers(min_value=31),
2007         integers(min_value=0),
2008         decode_path_strat,
2009     )
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],
2014                 offset=offset,
2015                 decode_path=decode_path,
2016             )
2017         repr(err.exception)
2018         self.assertEqual(err.exception.offset, offset)
2019         self.assertEqual(err.exception.decode_path, decode_path)
2020
2021     @given(
2022         integers(min_value=128),
2023         integers(min_value=0),
2024         decode_path_strat,
2025     )
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],
2030                 offset=offset,
2031                 decode_path=decode_path,
2032             )
2033         repr(err.exception)
2034         self.assertEqual(err.exception.offset, offset)
2035         self.assertEqual(err.exception.decode_path, decode_path)
2036
2037     @given(
2038         sets(integers(min_value=0, max_value=10), min_size=2, max_size=2),
2039         integers(min_value=0),
2040         decode_path_strat,
2041     )
2042     def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
2043         value, bound_min = list(sorted(ints))
2044
2045         class String(OctetString):
2046             bounds = (bound_min, bound_min)
2047         with self.assertRaises(DecodeError) as err:
2048             String().decode(
2049                 OctetString(b"\x00" * value).encode(),
2050                 offset=offset,
2051                 decode_path=decode_path,
2052             )
2053         repr(err.exception)
2054         self.assertEqual(err.exception.offset, offset)
2055         self.assertEqual(err.exception.decode_path, decode_path)
2056
2057     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
2058     @given(
2059         octet_string_values_strategy(),
2060         binary(),
2061         integers(min_value=1).map(tag_ctxc),
2062         integers(min_value=0),
2063         binary(max_size=5),
2064     )
2065     def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
2066         for klass in (OctetString, OctetStringInherited):
2067             _, _, _, _, default, optional, _decoded = values
2068             obj = klass(
2069                 value=value,
2070                 default=default,
2071                 optional=optional,
2072                 _decoded=_decoded,
2073             )
2074             repr(obj)
2075             list(obj.pps())
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)
2081             repr(obj_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,
2088                 offset=offset,
2089                 ctx=ctx_copied,
2090             )
2091             self.assertDictEqual(ctx_copied, ctx_dummy)
2092             repr(obj_decoded)
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))
2103             self.assertEqual(
2104                 obj_decoded.expl_llen,
2105                 len(len_encode(len(obj_encoded))),
2106             )
2107             self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
2108             self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
2109             self.assertEqual(
2110                 obj_decoded.offset,
2111                 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
2112             )
2113             self.assertEqual(obj_decoded.expl_offset, offset)
2114             assert_exceeding_data(
2115                 self,
2116                 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
2117                 tail_junk,
2118             )
2119
2120     @given(
2121         integers(min_value=1, max_value=30),
2122         lists(
2123             one_of(
2124                 binary(min_size=1, max_size=5),
2125                 lists(
2126                     binary(min_size=1, max_size=5),
2127                     min_size=1,
2128                     max_size=3,
2129                 ),
2130             ),
2131             min_size=1,
2132             max_size=3,
2133         ),
2134         binary(),
2135     )
2136     def test_constructed(self, impl, chunk_inputs, junk):
2137         def chunk_constructed(contents):
2138             return (
2139                 tag_encode(form=TagFormConstructed, num=4) +
2140                 LENINDEF +
2141                 b"".join(OctetString(content).encode() for content in contents) +
2142                 EOC
2143             )
2144         chunks = []
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
2150             else:
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) +
2156             LENINDEF +
2157             b"".join(chunks) +
2158             EOC
2159         )
2160         encoded_definite = (
2161             tag_encode(form=TagFormConstructed, num=impl) +
2162             len_encode(len(b"".join(chunks))) +
2163             b"".join(chunks)
2164         )
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),
2170         ):
2171             obj, tail = OctetString(impl=tag_encode(impl)).decode(
2172                 encoded + junk,
2173                 ctx={"bered": True},
2174             )
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)
2180             obj = copy(obj)
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)
2185             repr(obj)
2186             list(obj.pps())
2187             pprint(obj, big_blobs=True, with_decode_path=True)
2188
2189     @given(
2190         integers(min_value=0),
2191         decode_path_strat,
2192     )
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),
2197                 offset=offset,
2198                 decode_path=decode_path,
2199                 ctx={"bered": True},
2200             )
2201         self.assertEqual(err.exception.decode_path, decode_path)
2202         self.assertEqual(err.exception.offset, offset)
2203
2204     @given(
2205         integers(min_value=0),
2206         decode_path_strat,
2207         integers(min_value=1, max_value=3),
2208     )
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,
2214                 offset=offset,
2215                 decode_path=decode_path,
2216                 ctx={"bered": True},
2217             )
2218         self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),))
2219         self.assertEqual(err.exception.offset, offset + 1 + 1 + chunks * len(bs))
2220
2221     @given(
2222         integers(min_value=0),
2223         decode_path_strat,
2224         integers(min_value=1, max_value=3),
2225     )
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(
2231                 (
2232                     tag_encode(4, form=TagFormConstructed) +
2233                     len_encode((chunks + 1) * len(bs)) +
2234                     chunks * bs +
2235                     bs_longer
2236                 ),
2237                 offset=offset,
2238                 decode_path=decode_path,
2239                 ctx={"bered": True},
2240             )
2241         self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),))
2242         self.assertEqual(err.exception.offset, offset + 1 + 1 + chunks * len(bs))
2243
2244
2245 @composite
2246 def null_values_strategy(draw, do_expl=False):
2247     impl = None
2248     expl = None
2249     if do_expl:
2250         expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
2251     else:
2252         impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
2253     optional = draw(one_of(none(), booleans()))
2254     _decoded = (
2255         draw(integers(min_value=0)),
2256         draw(integers(min_value=0)),
2257         draw(integers(min_value=0)),
2258     )
2259     return (impl, expl, optional, _decoded)
2260
2261
2262 class NullInherited(Null):
2263     pass
2264
2265
2266 class TestNull(CommonMixin, TestCase):
2267     base_klass = Null
2268
2269     def test_ready(self):
2270         obj = Null()
2271         self.assertTrue(obj.ready)
2272         repr(obj)
2273         list(obj.pps())
2274         pprint(obj, big_blobs=True, with_decode_path=True)
2275
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)
2284
2285     @given(data_strategy())
2286     def test_call(self, d):
2287         for klass in (Null, NullInherited):
2288             (
2289                 impl_initial,
2290                 expl_initial,
2291                 optional_initial,
2292                 _decoded_initial,
2293             ) = d.draw(null_values_strategy())
2294             obj_initial = klass(
2295                 impl=impl_initial,
2296                 expl=expl_initial,
2297                 optional=optional_initial or False,
2298                 _decoded=_decoded_initial,
2299             )
2300             (
2301                 impl,
2302                 expl,
2303                 optional,
2304                 _decoded,
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)
2312
2313     @given(null_values_strategy())
2314     def test_copy(self, values):
2315         for klass in (Null, NullInherited):
2316             impl, expl, optional, _decoded = values
2317             obj = klass(
2318                 impl=impl,
2319                 expl=expl,
2320                 optional=optional or False,
2321                 _decoded=_decoded,
2322             )
2323             for copy_func in copy_funcs:
2324                 obj_copied = copy_func(obj)
2325                 self.assert_copied_basic_fields(obj, obj_copied)
2326
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])
2332
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])
2338
2339     @given(
2340         integers(min_value=31),
2341         integers(min_value=0),
2342         decode_path_strat,
2343     )
2344     def test_bad_tag(self, tag, offset, decode_path):
2345         with self.assertRaises(DecodeError) as err:
2346             Null().decode(
2347                 tag_encode(tag)[:-1],
2348                 offset=offset,
2349                 decode_path=decode_path,
2350             )
2351         repr(err.exception)
2352         self.assertEqual(err.exception.offset, offset)
2353         self.assertEqual(err.exception.decode_path, decode_path)
2354
2355     @given(
2356         integers(min_value=128),
2357         integers(min_value=0),
2358         decode_path_strat,
2359     )
2360     def test_bad_len(self, l, offset, decode_path):
2361         with self.assertRaises(DecodeError) as err:
2362             Null().decode(
2363                 Null.tag_default + len_encode(l)[:-1],
2364                 offset=offset,
2365                 decode_path=decode_path,
2366             )
2367         repr(err.exception)
2368         self.assertEqual(err.exception.offset, offset)
2369         self.assertEqual(err.exception.decode_path, decode_path)
2370
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())
2376
2377     @given(
2378         null_values_strategy(),
2379         integers(min_value=1).map(tag_ctxc),
2380         integers(min_value=0),
2381         binary(max_size=5),
2382     )
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)
2387             repr(obj)
2388             list(obj.pps())
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)
2394             repr(obj_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,
2401                 offset=offset,
2402                 ctx=ctx_copied,
2403             )
2404             self.assertDictEqual(ctx_copied, ctx_dummy)
2405             repr(obj_decoded)
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))
2414             self.assertEqual(
2415                 obj_decoded.expl_llen,
2416                 len(len_encode(len(obj_encoded))),
2417             )
2418             self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
2419             self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
2420             self.assertEqual(
2421                 obj_decoded.offset,
2422                 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
2423             )
2424             self.assertEqual(obj_decoded.expl_offset, offset)
2425             assert_exceeding_data(
2426                 self,
2427                 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
2428                 tail_junk,
2429             )
2430
2431     @given(integers(min_value=1))
2432     def test_invalid_len(self, l):
2433         with self.assertRaises(InvalidLength):
2434             Null().decode(b"".join((
2435                 Null.tag_default,
2436                 len_encode(l),
2437             )))
2438
2439
2440 @composite
2441 def oid_strategy(draw):
2442     first_arc = draw(integers(min_value=0, max_value=2))
2443     second_arc = 0
2444     if first_arc in (0, 1):
2445         second_arc = draw(integers(min_value=0, max_value=39))
2446     else:
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)
2450
2451
2452 @composite
2453 def oid_values_strategy(draw, do_expl=False):
2454     value = draw(one_of(none(), oid_strategy()))
2455     impl = None
2456     expl = None
2457     if do_expl:
2458         expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
2459     else:
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()))
2463     _decoded = (
2464         draw(integers(min_value=0)),
2465         draw(integers(min_value=0)),
2466         draw(integers(min_value=0)),
2467     )
2468     return (value, impl, expl, default, optional, _decoded)
2469
2470
2471 class ObjectIdentifierInherited(ObjectIdentifier):
2472     pass
2473
2474
2475 class TestObjectIdentifier(CommonMixin, TestCase):
2476     base_klass = ObjectIdentifier
2477
2478     def test_invalid_value_type(self):
2479         with self.assertRaises(InvalidValueType) as err:
2480             ObjectIdentifier(123)
2481         repr(err.exception)
2482
2483     @given(booleans())
2484     def test_optional(self, optional):
2485         obj = ObjectIdentifier(default=ObjectIdentifier("1.2.3"), optional=optional)
2486         self.assertTrue(obj.optional)
2487
2488     @given(oid_strategy())
2489     def test_ready(self, value):
2490         obj = ObjectIdentifier()
2491         self.assertFalse(obj.ready)
2492         repr(obj)
2493         list(obj.pps())
2494         pprint(obj, big_blobs=True, with_decode_path=True)
2495         with self.assertRaises(ObjNotReady) as err:
2496             obj.encode()
2497         repr(err.exception)
2498         obj = ObjectIdentifier(value)
2499         self.assertTrue(obj.ready)
2500         self.assertFalse(obj.ber_encoded)
2501         repr(obj)
2502         list(obj.pps())
2503         pprint(obj, big_blobs=True, with_decode_path=True)
2504         hash(obj)
2505
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)
2519
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)],
2524             sorted(values),
2525         )
2526
2527     @given(data_strategy())
2528     def test_call(self, d):
2529         for klass in (ObjectIdentifier, ObjectIdentifierInherited):
2530             (
2531                 value_initial,
2532                 impl_initial,
2533                 expl_initial,
2534                 default_initial,
2535                 optional_initial,
2536                 _decoded_initial,
2537             ) = d.draw(oid_values_strategy())
2538             obj_initial = klass(
2539                 value=value_initial,
2540                 impl=impl_initial,
2541                 expl=expl_initial,
2542                 default=default_initial,
2543                 optional=optional_initial or False,
2544                 _decoded=_decoded_initial,
2545             )
2546             (
2547                 value,
2548                 impl,
2549                 expl,
2550                 default,
2551                 optional,
2552                 _decoded,
2553             ) = d.draw(oid_values_strategy(do_expl=impl_initial is None))
2554             obj = obj_initial(
2555                 value=value,
2556                 impl=impl,
2557                 expl=expl,
2558                 default=default,
2559                 optional=optional,
2560             )
2561             if obj.ready:
2562                 value_expected = default if value is None else value
2563                 value_expected = (
2564                     default_initial if value_expected is None
2565                     else value_expected
2566                 )
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)
2570             self.assertEqual(
2571                 obj.default,
2572                 default_initial if default is None else default,
2573             )
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
2577             else:
2578                 optional = True
2579             self.assertEqual(obj.optional, optional)
2580
2581     @given(oid_values_strategy())
2582     def test_copy(self, values):
2583         for klass in (ObjectIdentifier, ObjectIdentifierInherited):
2584             (
2585                 value,
2586                 impl,
2587                 expl,
2588                 default,
2589                 optional,
2590                 _decoded,
2591             ) = values
2592             obj = klass(
2593                 value=value,
2594                 impl=impl,
2595                 expl=expl,
2596                 default=default,
2597                 optional=optional,
2598                 _decoded=_decoded,
2599             )
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)
2604
2605     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
2606     @given(
2607         oid_strategy(),
2608         integers(min_value=1).map(tag_encode),
2609     )
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])
2614
2615     @given(
2616         oid_strategy(),
2617         integers(min_value=1).map(tag_ctxc),
2618     )
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])
2623
2624     @given(
2625         integers(min_value=31),
2626         integers(min_value=0),
2627         decode_path_strat,
2628     )
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],
2633                 offset=offset,
2634                 decode_path=decode_path,
2635             )
2636         repr(err.exception)
2637         self.assertEqual(err.exception.offset, offset)
2638         self.assertEqual(err.exception.decode_path, decode_path)
2639
2640     @given(
2641         integers(min_value=128),
2642         integers(min_value=0),
2643         decode_path_strat,
2644     )
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],
2649                 offset=offset,
2650                 decode_path=decode_path,
2651             )
2652         repr(err.exception)
2653         self.assertEqual(err.exception.offset, offset)
2654         self.assertEqual(err.exception.decode_path, decode_path)
2655
2656     def test_zero_oid(self):
2657         with self.assertRaises(NotEnoughData):
2658             ObjectIdentifier().decode(
2659                 b"".join((ObjectIdentifier.tag_default, len_encode(0)))
2660             )
2661
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]
2669         data = b"".join((
2670             ObjectIdentifier.tag_default,
2671             len_encode(len(data)),
2672             data,
2673         ))
2674         with assertRaisesRegex(self, DecodeError, "unfinished OID"):
2675             obj.decode(data)
2676
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)
2683
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))
2690
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))
2697
2698     @given(text(alphabet=ascii_letters + ".", min_size=1))
2699     def test_junk(self, oid):
2700         with self.assertRaises(InvalidOID):
2701             ObjectIdentifier(oid)
2702
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)))
2708         str(obj)
2709         repr(obj)
2710         pprint(obj, big_blobs=True, with_decode_path=True)
2711
2712     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
2713     @given(
2714         oid_values_strategy(),
2715         oid_strategy(),
2716         integers(min_value=1).map(tag_ctxc),
2717         integers(min_value=0),
2718         binary(max_size=5),
2719     )
2720     def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
2721         for klass in (ObjectIdentifier, ObjectIdentifierInherited):
2722             _, _, _, default, optional, _decoded = values
2723             obj = klass(
2724                 value=value,
2725                 default=default,
2726                 optional=optional,
2727                 _decoded=_decoded,
2728             )
2729             repr(obj)
2730             list(obj.pps())
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)
2736             repr(obj_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,
2743                 offset=offset,
2744                 ctx=ctx_copied,
2745             )
2746             self.assertDictEqual(ctx_copied, ctx_dummy)
2747             repr(obj_decoded)
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))
2758             self.assertEqual(
2759                 obj_decoded.expl_llen,
2760                 len(len_encode(len(obj_encoded))),
2761             )
2762             self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
2763             self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
2764             self.assertEqual(
2765                 obj_decoded.offset,
2766                 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
2767             )
2768             self.assertEqual(obj_decoded.expl_offset, offset)
2769             assert_exceeding_data(
2770                 self,
2771                 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
2772                 tail_junk,
2773             )
2774
2775     @given(
2776         oid_strategy().map(ObjectIdentifier),
2777         oid_strategy().map(ObjectIdentifier),
2778     )
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):
2784             oid1 + str(oid2)
2785
2786     def test_go_vectors_valid(self):
2787         for data, expect in (
2788                 (b"\x55", (2, 5)),
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)),
2792         ):
2793             self.assertEqual(
2794                 ObjectIdentifier().decode(b"".join((
2795                     ObjectIdentifier.tag_default,
2796                     len_encode(len(data)),
2797                     data,
2798                 )))[0],
2799                 expect,
2800             )
2801
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)),
2808                 data,
2809             )))
2810
2811     def test_x690_vector(self):
2812         self.assertEqual(
2813             ObjectIdentifier().decode(hexdec("0603883703"))[0],
2814             ObjectIdentifier((2, 999, 3)),
2815         )
2816
2817     def test_nonnormalized_first_arc(self):
2818         tampered = (
2819             ObjectIdentifier.tag_default +
2820             len_encode(2) +
2821             b'\x80' +
2822             ObjectIdentifier((1, 0)).encode()[-1:]
2823         )
2824         obj, _ = ObjectIdentifier().decode(tampered, ctx={"bered": True})
2825         self.assertTrue(obj.ber_encoded)
2826         self.assertTrue(obj.bered)
2827         obj = copy(obj)
2828         self.assertTrue(obj.ber_encoded)
2829         self.assertTrue(obj.bered)
2830         with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
2831             ObjectIdentifier().decode(tampered)
2832
2833     @given(data_strategy())
2834     def test_negative_arcs(self, d):
2835         oid = list(d.draw(oid_strategy()))
2836         if len(oid) == 2:
2837             return
2838         idx = d.draw(integers(min_value=3, max_value=len(oid)))
2839         oid[idx - 1] *= -1
2840         if oid[idx - 1] == 0:
2841             oid[idx - 1] = -1
2842         with self.assertRaises(InvalidOID):
2843             ObjectIdentifier(tuple(oid))
2844         with self.assertRaises(InvalidOID):
2845             ObjectIdentifier(".".join(str(i) for i in oid))
2846
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))
2854
2855     @given(data_strategy())
2856     def test_nonnormalized_arcs(self, d):
2857         arcs = d.draw(lists(
2858             integers(min_value=0, max_value=100),
2859             min_size=1,
2860             max_size=5,
2861         ))
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(
2867             min_value=0,
2868             max_value=len(v_no_first_arc) - 1,
2869         ))
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))
2874         tampered = (
2875             ObjectIdentifier.tag_default +
2876             len_encode(len(tampered)) +
2877             tampered
2878         )
2879         obj, _ = ObjectIdentifier().decode(tampered, ctx={"bered": True})
2880         self.assertTrue(obj.ber_encoded)
2881         self.assertTrue(obj.bered)
2882         obj = copy(obj)
2883         self.assertTrue(obj.ber_encoded)
2884         self.assertTrue(obj.bered)
2885         with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
2886             ObjectIdentifier().decode(tampered)
2887
2888
2889 @composite
2890 def enumerated_values_strategy(draw, schema=None, do_expl=False):
2891     if schema is None:
2892         schema = list(draw(sets(text_printable, min_size=1, max_size=3)))
2893         values = list(draw(sets(
2894             integers(),
2895             min_size=len(schema),
2896             max_size=len(schema),
2897         )))
2898         schema = list(zip(schema, values))
2899     value = draw(one_of(none(), sampled_from([k for k, v in schema])))
2900     impl = None
2901     expl = None
2902     if do_expl:
2903         expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
2904     else:
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()))
2908     _decoded = (
2909         draw(integers(min_value=0)),
2910         draw(integers(min_value=0)),
2911         draw(integers(min_value=0)),
2912     )
2913     return (schema, value, impl, expl, default, optional, _decoded)
2914
2915
2916 class TestEnumerated(CommonMixin, TestCase):
2917     class EWhatever(Enumerated):
2918         schema = (("whatever", 0),)
2919
2920     base_klass = EWhatever
2921
2922     def test_schema_required(self):
2923         with assertRaisesRegex(self, ValueError, "schema must be specified"):
2924             Enumerated()
2925
2926     def test_invalid_value_type(self):
2927         with self.assertRaises(InvalidValueType) as err:
2928             self.base_klass((1, 2))
2929         repr(err.exception)
2930
2931     @given(sets(text_letters(), min_size=2))
2932     def test_unknown_name(self, schema_input):
2933         missing = schema_input.pop()
2934
2935         class E(Enumerated):
2936             schema = [(n, 123) for n in schema_input]
2937         with self.assertRaises(ObjUnknown) as err:
2938             E(missing)
2939         repr(err.exception)
2940
2941     @given(
2942         sets(text_letters(), min_size=2),
2943         sets(integers(), min_size=2),
2944     )
2945     def test_unknown_value(self, schema_input, values_input):
2946         schema_input.pop()
2947         missing_value = values_input.pop()
2948         _input = list(zip(schema_input, values_input))
2949
2950         class E(Enumerated):
2951             schema = _input
2952         with self.assertRaises(DecodeError) as err:
2953             E(missing_value)
2954         repr(err.exception)
2955
2956     @given(booleans())
2957     def test_optional(self, optional):
2958         obj = self.base_klass(default="whatever", optional=optional)
2959         self.assertTrue(obj.optional)
2960
2961     def test_ready(self):
2962         obj = self.base_klass()
2963         self.assertFalse(obj.ready)
2964         repr(obj)
2965         list(obj.pps())
2966         pprint(obj, big_blobs=True, with_decode_path=True)
2967         with self.assertRaises(ObjNotReady) as err:
2968             obj.encode()
2969         repr(err.exception)
2970         obj = self.base_klass("whatever")
2971         self.assertTrue(obj.ready)
2972         repr(obj)
2973         list(obj.pps())
2974         pprint(obj, big_blobs=True, with_decode_path=True)
2975
2976     @given(integers(), integers(), binary(), binary())
2977     def test_comparison(self, value1, value2, tag1, tag2):
2978         class E(Enumerated):
2979             schema = (
2980                 ("whatever0", value1),
2981                 ("whatever1", value2),
2982             )
2983
2984         class EInherited(E):
2985             pass
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)
2996
2997     @given(data_strategy())
2998     def test_call(self, d):
2999         (
3000             schema_initial,
3001             value_initial,
3002             impl_initial,
3003             expl_initial,
3004             default_initial,
3005             optional_initial,
3006             _decoded_initial,
3007         ) = d.draw(enumerated_values_strategy())
3008
3009         class E(Enumerated):
3010             schema = schema_initial
3011         obj_initial = E(
3012             value=value_initial,
3013             impl=impl_initial,
3014             expl=expl_initial,
3015             default=default_initial,
3016             optional=optional_initial or False,
3017             _decoded=_decoded_initial,
3018         )
3019         (
3020             _,
3021             value,
3022             impl,
3023             expl,
3024             default,
3025             optional,
3026             _decoded,
3027         ) = d.draw(enumerated_values_strategy(
3028             schema=schema_initial,
3029             do_expl=impl_initial is None,
3030         ))
3031         obj = obj_initial(
3032             value=value,
3033             impl=impl,
3034             expl=expl,
3035             default=default,
3036             optional=optional,
3037         )
3038         if obj.ready:
3039             value_expected = default if value is None else value
3040             value_expected = (
3041                 default_initial if value_expected is None
3042                 else value_expected
3043             )
3044             self.assertEqual(
3045                 int(obj),
3046                 dict(schema_initial).get(value_expected, value_expected),
3047             )
3048         self.assertEqual(obj.tag, impl or impl_initial or obj.tag_default)
3049         self.assertEqual(obj.expl_tag, expl or expl_initial)
3050         self.assertEqual(
3051             obj.default,
3052             default_initial if default is None else default,
3053         )
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
3057         else:
3058             optional = True
3059         self.assertEqual(obj.optional, optional)
3060         self.assertEqual(obj.specs, dict(schema_initial))
3061
3062     @given(enumerated_values_strategy())
3063     def test_copy(self, values):
3064         schema_input, value, impl, expl, default, optional, _decoded = values
3065
3066         class E(Enumerated):
3067             schema = schema_input
3068         register_class(E)
3069         obj = E(
3070             value=value,
3071             impl=impl,
3072             expl=expl,
3073             default=default,
3074             optional=optional,
3075             _decoded=_decoded,
3076         )
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)
3081
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(),
3087         )
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))
3092
3093         class E(Enumerated):
3094             schema = schema_input
3095         obj = E(
3096             value=value,
3097             default=default,
3098             optional=optional,
3099             _decoded=_decoded,
3100         )
3101         repr(obj)
3102         list(obj.pps())
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)
3108         repr(obj_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,
3115             offset=offset,
3116             ctx=ctx_copied,
3117         )
3118         self.assertDictEqual(ctx_copied, ctx_dummy)
3119         repr(obj_decoded)
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))
3130         self.assertEqual(
3131             obj_decoded.expl_llen,
3132             len(len_encode(len(obj_encoded))),
3133         )
3134         self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
3135         self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
3136         self.assertEqual(
3137             obj_decoded.offset,
3138             offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
3139         )
3140         self.assertEqual(obj_decoded.expl_offset, offset)
3141         assert_exceeding_data(
3142             self,
3143             lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
3144             tail_junk,
3145         )
3146
3147
3148 @composite
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),
3152         min_size=2,
3153         max_size=2,
3154     )))
3155     value = draw(one_of(
3156         none(),
3157         text(alphabet=alphabet, min_size=bound_min, max_size=bound_max),
3158     ))
3159     default = draw(one_of(
3160         none(),
3161         text(alphabet=alphabet, min_size=bound_min, max_size=bound_max),
3162     ))
3163     bounds = None
3164     if draw(booleans()):
3165         bounds = (bound_min, bound_max)
3166     impl = None
3167     expl = None
3168     if do_expl:
3169         expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
3170     else:
3171         impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
3172     optional = draw(one_of(none(), booleans()))
3173     _decoded = (
3174         draw(integers(min_value=0)),
3175         draw(integers(min_value=0)),
3176         draw(integers(min_value=0)),
3177     )
3178     return (value, bounds, impl, expl, default, optional, _decoded)
3179
3180
3181 class StringMixin(object):
3182     def test_invalid_value_type(self):
3183         with self.assertRaises(InvalidValueType) as err:
3184             self.base_klass((1, 2))
3185         repr(err.exception)
3186
3187     def text_alphabet(self):
3188         if self.base_klass.encoding in ("ascii", "iso-8859-1"):
3189             return printable + whitespace
3190         return None
3191
3192     @given(booleans())
3193     def test_optional(self, optional):
3194         obj = self.base_klass(default=self.base_klass(""), optional=optional)
3195         self.assertTrue(obj.optional)
3196
3197     @given(data_strategy())
3198     def test_ready(self, d):
3199         obj = self.base_klass()
3200         self.assertFalse(obj.ready)
3201         repr(obj)
3202         list(obj.pps())
3203         pprint(obj, big_blobs=True, with_decode_path=True)
3204         text_type(obj)
3205         with self.assertRaises(ObjNotReady) as err:
3206             obj.encode()
3207         repr(err.exception)
3208         value = d.draw(text(alphabet=self.text_alphabet()))
3209         obj = self.base_klass(value)
3210         self.assertTrue(obj.ready)
3211         repr(obj)
3212         list(obj.pps())
3213         pprint(obj, big_blobs=True, with_decode_path=True)
3214         text_type(obj)
3215
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)
3232
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(),
3239             min_size=bound_min,
3240             max_size=bound_max,
3241         ))
3242         self.base_klass(value=value, bounds=(bound_min, bound_max))
3243
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))
3251         repr(err.exception)
3252         with assertRaisesRegex(self, DecodeError, "bounds") as err:
3253             self.base_klass(bounds=(bound_min, bound_max)).decode(
3254                 self.base_klass(value).encode()
3255             )
3256         repr(err.exception)
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))
3260         repr(err.exception)
3261         with assertRaisesRegex(self, DecodeError, "bounds") as err:
3262             self.base_klass(bounds=(bound_min, bound_max)).decode(
3263                 self.base_klass(value).encode()
3264             )
3265         repr(err.exception)
3266
3267     @given(data_strategy())
3268     def test_call(self, d):
3269         (
3270             value_initial,
3271             bounds_initial,
3272             impl_initial,
3273             expl_initial,
3274             default_initial,
3275             optional_initial,
3276             _decoded_initial,
3277         ) = d.draw(string_values_strategy(self.text_alphabet()))
3278         obj_initial = self.base_klass(
3279             value_initial,
3280             bounds_initial,
3281             impl_initial,
3282             expl_initial,
3283             default_initial,
3284             optional_initial or False,
3285             _decoded_initial,
3286         )
3287         (
3288             value,
3289             bounds,
3290             impl,
3291             expl,
3292             default,
3293             optional,
3294             _decoded,
3295         ) = d.draw(string_values_strategy(
3296             self.text_alphabet(),
3297             do_expl=impl_initial is None,
3298         ))
3299         if (default is None) and (obj_initial.default is not None):
3300             bounds = None
3301         if (
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])
3306         ):
3307             value = None
3308         if (
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])
3313         ):
3314             default = None
3315         obj = obj_initial(value, bounds, impl, expl, default, optional)
3316         if obj.ready:
3317             value_expected = default if value is None else value
3318             value_expected = (
3319                 default_initial if value_expected is None
3320                 else value_expected
3321             )
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)
3325         self.assertEqual(
3326             obj.default,
3327             default_initial if default is None else default,
3328         )
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
3332         else:
3333             optional = True
3334         self.assertEqual(obj.optional, optional)
3335         self.assertEqual(
3336             (obj._bound_min, obj._bound_max),
3337             bounds or bounds_initial or (0, float("+inf")),
3338         )
3339
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)
3350
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])
3358
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])
3366
3367     @given(
3368         integers(min_value=31),
3369         integers(min_value=0),
3370         decode_path_strat,
3371     )
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],
3376                 offset=offset,
3377                 decode_path=decode_path,
3378             )
3379         repr(err.exception)
3380         self.assertEqual(err.exception.offset, offset)
3381         self.assertEqual(err.exception.decode_path, decode_path)
3382
3383     @given(
3384         integers(min_value=128),
3385         integers(min_value=0),
3386         decode_path_strat,
3387     )
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],
3392                 offset=offset,
3393                 decode_path=decode_path,
3394             )
3395         repr(err.exception)
3396         self.assertEqual(err.exception.offset, offset)
3397         self.assertEqual(err.exception.decode_path, decode_path)
3398
3399     @given(
3400         sets(integers(min_value=0, max_value=10), min_size=2, max_size=2),
3401         integers(min_value=0),
3402         decode_path_strat,
3403     )
3404     def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
3405         value, bound_min = list(sorted(ints))
3406
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:
3412             String().decode(
3413                 self.base_klass(b"\x00\x00\x00\x00" * value).encode(),
3414                 offset=offset,
3415                 decode_path=decode_path,
3416             )
3417         repr(err.exception)
3418         self.assertEqual(err.exception.offset, offset)
3419         self.assertEqual(err.exception.decode_path, decode_path)
3420
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(
3430             value=value,
3431             default=default,
3432             optional=optional,
3433             _decoded=_decoded,
3434         )
3435         repr(obj)
3436         list(obj.pps())
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)
3442         repr(obj_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,
3449             offset=offset,
3450             ctx=ctx_copied,
3451         )
3452         self.assertDictEqual(ctx_copied, ctx_dummy)
3453         repr(obj_decoded)
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))
3466         self.assertEqual(
3467             obj_decoded.expl_llen,
3468             len(len_encode(len(obj_encoded))),
3469         )
3470         self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
3471         self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
3472         self.assertEqual(
3473             obj_decoded.offset,
3474             offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
3475         )
3476         self.assertEqual(obj_decoded.expl_offset, offset)
3477         assert_exceeding_data(
3478             self,
3479             lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
3480             tail_junk,
3481         )
3482
3483
3484 class TestUTF8String(StringMixin, CommonMixin, TestCase):
3485     base_klass = UTF8String
3486
3487
3488 cyrillic_letters = text(
3489     alphabet="".join(six_unichr(i) for i in list(range(0x0410, 0x044f + 1))),
3490     min_size=1,
3491     max_size=5,
3492 )
3493
3494
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)
3500
3501
3502 class TestNumericString(StringMixin, CommonMixin, TestCase):
3503     base_klass = NumericString
3504
3505     def text_alphabet(self):
3506         return digits + " "
3507
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)
3512
3513     @given(
3514         sets(integers(min_value=0, max_value=10), min_size=2, max_size=2),
3515         integers(min_value=0),
3516         decode_path_strat,
3517     )
3518     def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
3519         value, bound_min = list(sorted(ints))
3520
3521         class String(self.base_klass):
3522             bounds = (bound_min, bound_min)
3523         with self.assertRaises(DecodeError) as err:
3524             String().decode(
3525                 self.base_klass(b"1" * value).encode(),
3526                 offset=offset,
3527                 decode_path=decode_path,
3528             )
3529         repr(err.exception)
3530         self.assertEqual(err.exception.offset, offset)
3531         self.assertEqual(err.exception.decode_path, decode_path)
3532
3533
3534 class TestPrintableString(
3535         UnicodeDecodeErrorMixin,
3536         StringMixin,
3537         CommonMixin,
3538         TestCase,
3539 ):
3540     base_klass = PrintableString
3541
3542     def text_alphabet(self):
3543         return ascii_letters + digits + " '()+,-./:=?"
3544
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)
3549
3550     @given(
3551         sets(integers(min_value=0, max_value=10), min_size=2, max_size=2),
3552         integers(min_value=0),
3553         decode_path_strat,
3554     )
3555     def test_invalid_bounds_while_decoding(self, ints, offset, decode_path):
3556         value, bound_min = list(sorted(ints))
3557
3558         class String(self.base_klass):
3559             bounds = (bound_min, bound_min)
3560         with self.assertRaises(DecodeError) as err:
3561             String().decode(
3562                 self.base_klass(b"1" * value).encode(),
3563                 offset=offset,
3564                 decode_path=decode_path,
3565             )
3566         repr(err.exception)
3567         self.assertEqual(err.exception.offset, offset)
3568         self.assertEqual(err.exception.decode_path, decode_path)
3569
3570     def test_allowable_invalid_chars(self):
3571         for c, kwargs in (
3572                 ("*", {"allow_asterisk": True}),
3573                 ("&", {"allow_ampersand": True}),
3574                 ("&*", {"allow_asterisk": True, "allow_ampersand": True}),
3575         ):
3576             s = "hello invalid"
3577             obj = self.base_klass(s)
3578             for prop in kwargs.keys():
3579                 self.assertFalse(getattr(obj, prop))
3580             s += c
3581             with assertRaisesRegex(self, DecodeError, "non-printable"):
3582                 self.base_klass(s)
3583             self.base_klass(s, **kwargs)
3584             klass = self.base_klass(**kwargs)
3585             obj = klass(s)
3586             for prop in kwargs.keys():
3587                 self.assertTrue(getattr(obj, prop))
3588             obj = copy(obj)
3589             obj(s)
3590             for prop in kwargs.keys():
3591                 self.assertTrue(getattr(obj, prop))
3592
3593
3594 class TestTeletexString(
3595         UnicodeDecodeErrorMixin,
3596         StringMixin,
3597         CommonMixin,
3598         TestCase,
3599 ):
3600     base_klass = TeletexString
3601
3602
3603 class TestVideotexString(
3604         UnicodeDecodeErrorMixin,
3605         StringMixin,
3606         CommonMixin,
3607         TestCase,
3608 ):
3609     base_klass = VideotexString
3610
3611
3612 class TestIA5String(
3613         UnicodeDecodeErrorMixin,
3614         StringMixin,
3615         CommonMixin,
3616         TestCase,
3617 ):
3618     base_klass = IA5String
3619
3620
3621 class TestGraphicString(
3622         UnicodeDecodeErrorMixin,
3623         StringMixin,
3624         CommonMixin,
3625         TestCase,
3626 ):
3627     base_klass = GraphicString
3628
3629
3630 class TestVisibleString(
3631         UnicodeDecodeErrorMixin,
3632         StringMixin,
3633         CommonMixin,
3634         TestCase,
3635 ):
3636     base_klass = VisibleString
3637
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)
3645
3646         obj, tail = VisibleString().decode(
3647             hexdec("3A0904034A6F6E04026573"),
3648             ctx={"bered": True},
3649         )
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)
3655         obj = copy(obj)
3656         self.assertTrue(obj.ber_encoded)
3657         self.assertFalse(obj.lenindef)
3658         self.assertTrue(obj.bered)
3659
3660         obj, tail = VisibleString().decode(
3661             hexdec("3A8004034A6F6E040265730000"),
3662             ctx={"bered": True},
3663         )
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)
3669         obj = copy(obj)
3670         self.assertTrue(obj.ber_encoded)
3671         self.assertTrue(obj.lenindef)
3672         self.assertTrue(obj.bered)
3673
3674
3675 class TestGeneralString(
3676         UnicodeDecodeErrorMixin,
3677         StringMixin,
3678         CommonMixin,
3679         TestCase,
3680 ):
3681     base_klass = GeneralString
3682
3683
3684 class TestUniversalString(StringMixin, CommonMixin, TestCase):
3685     base_klass = UniversalString
3686
3687
3688 class TestBMPString(StringMixin, CommonMixin, TestCase):
3689     base_klass = BMPString
3690
3691
3692 @composite
3693 def generalized_time_values_strategy(
3694         draw,
3695         min_datetime,
3696         max_datetime,
3697         omit_ms=False,
3698         do_expl=False,
3699 ):
3700     value = None
3701     if draw(booleans()):
3702         value = draw(datetimes(min_value=min_datetime, max_value=max_datetime))
3703         if omit_ms:
3704             value = value.replace(microsecond=0)
3705     default = None
3706     if draw(booleans()):
3707         default = draw(datetimes(min_value=min_datetime, max_value=max_datetime))
3708         if omit_ms:
3709             default = default.replace(microsecond=0)
3710     impl = None
3711     expl = None
3712     if do_expl:
3713         expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
3714     else:
3715         impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
3716     optional = draw(one_of(none(), booleans()))
3717     _decoded = (
3718         draw(integers(min_value=0)),
3719         draw(integers(min_value=0)),
3720         draw(integers(min_value=0)),
3721     )
3722     return (value, impl, expl, default, optional, _decoded)
3723
3724
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())
3729         repr(err.exception)
3730
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,
3736         ))
3737         optional = d.draw(booleans())
3738         obj = self.base_klass(default=default, optional=optional)
3739         self.assertTrue(obj.optional)
3740
3741     @given(data_strategy())
3742     def test_ready(self, d):
3743         obj = self.base_klass()
3744         self.assertFalse(obj.ready)
3745         repr(obj)
3746         list(obj.pps())
3747         pprint(obj, big_blobs=True, with_decode_path=True)
3748         with self.assertRaises(ObjNotReady) as err:
3749             obj.encode()
3750         repr(err.exception)
3751         value = d.draw(datetimes(
3752             min_value=self.min_datetime,
3753             max_value=self.max_datetime,
3754         ))
3755         obj = self.base_klass(value)
3756         self.assertTrue(obj.ready)
3757         repr(obj)
3758         list(obj.pps())
3759         pprint(obj, big_blobs=True, with_decode_path=True)
3760
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,
3766         ))
3767         value2 = d.draw(datetimes(
3768             min_value=self.min_datetime,
3769             max_value=self.max_datetime,
3770         ))
3771         tag1 = d.draw(binary(min_size=1))
3772         tag2 = d.draw(binary(min_size=1))
3773         if self.omit_ms:
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)
3786
3787     @given(data_strategy())
3788     def test_call(self, d):
3789         (
3790             value_initial,
3791             impl_initial,
3792             expl_initial,
3793             default_initial,
3794             optional_initial,
3795             _decoded_initial,
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,
3800         ))
3801         obj_initial = self.base_klass(
3802             value=value_initial,
3803             impl=impl_initial,
3804             expl=expl_initial,
3805             default=default_initial,
3806             optional=optional_initial or False,
3807             _decoded=_decoded_initial,
3808         )
3809         (
3810             value,
3811             impl,
3812             expl,
3813             default,
3814             optional,
3815             _decoded,
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,
3821         ))
3822         obj = obj_initial(
3823             value=value,
3824             impl=impl,
3825             expl=expl,
3826             default=default,
3827             optional=optional,
3828         )
3829         if obj.ready:
3830             value_expected = default if value is None else value
3831             value_expected = (
3832                 default_initial if value_expected is None
3833                 else value_expected
3834             )
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)
3838         self.assertEqual(
3839             obj.default,
3840             default_initial if default is None else default,
3841         )
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
3845         else:
3846             optional = True
3847         self.assertEqual(obj.optional, optional)
3848
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,
3854         ))
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)
3860
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,
3866         ))
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])
3871
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,
3877         ))
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])
3882
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,
3889         ))
3890         value = d.draw(datetimes(
3891             min_value=self.min_datetime,
3892             max_value=self.max_datetime,
3893         ))
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(
3899             value=value,
3900             default=default,
3901             optional=optional,
3902             _decoded=_decoded,
3903         )
3904         repr(obj)
3905         list(obj.pps())
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)
3912         repr(obj_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,
3919             offset=offset,
3920             ctx=ctx_copied,
3921         )
3922         self.assertDictEqual(ctx_copied, ctx_dummy)
3923         repr(obj_decoded)
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))
3933         self.assertEqual(
3934             obj_decoded.expl_llen,
3935             len(len_encode(len(obj_encoded))),
3936         )
3937         self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
3938         self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
3939         self.assertEqual(
3940             obj_decoded.offset,
3941             offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
3942         )
3943         self.assertEqual(obj_decoded.expl_offset, offset)
3944         assert_exceeding_data(
3945             self,
3946             lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
3947             tail_junk,
3948         )
3949
3950
3951 class TestGeneralizedTime(TimeMixin, CommonMixin, TestCase):
3952     base_klass = GeneralizedTime
3953     omit_ms = False
3954     min_datetime = datetime(1900, 1, 1)
3955     max_datetime = datetime(9999, 12, 31)
3956
3957     def additional_symmetric_check(self, value, obj_encoded):
3958         if value.microsecond > 0:
3959             self.assertFalse(obj_encoded.endswith(b"0Z"))
3960
3961     def test_repr_not_ready(self):
3962         unicode(GeneralizedTime()) if PY2 else str(GeneralizedTime())
3963         repr(GeneralizedTime())
3964
3965     def test_x690_vector_valid(self):
3966         for data in ((
3967                 b"19920521000000Z",
3968                 b"19920622123421Z",
3969                 b"19920722132100.3Z",
3970         )):
3971             GeneralizedTime(data)
3972
3973     def test_x690_vector_invalid(self):
3974         for data in ((
3975                 b"19920520240000Z",
3976                 b"19920622123421.0Z",
3977                 b"19920722132100.30Z",
3978         )):
3979             with self.assertRaises(DecodeError) as err:
3980                 GeneralizedTime(data)
3981             repr(err.exception)
3982
3983     def test_go_vectors_invalid(self):
3984         for data in ((
3985                 b"20100102030405",
3986                 b"00000100000000Z",
3987                 b"20101302030405Z",
3988                 b"20100002030405Z",
3989                 b"20100100030405Z",
3990                 b"20100132030405Z",
3991                 b"20100231030405Z",
3992                 b"20100102240405Z",
3993                 b"20100102036005Z",
3994                 b"20100102030460Z",
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",
4006         )):
4007             with self.assertRaises(DecodeError) as err:
4008                 GeneralizedTime(data)
4009             repr(err.exception)
4010
4011     def test_go_vectors_valid(self):
4012         self.assertEqual(
4013             GeneralizedTime(b"20100102030405Z").todatetime(),
4014             datetime(2010, 1, 2, 3, 4, 5, 0),
4015         )
4016
4017     def test_go_vectors_valid_ber(self):
4018         for data in ((
4019                 b"20100102030405+0607",
4020                 b"20100102030405-0607",
4021         )):
4022             GeneralizedTime(data, ctx={"bered": True})
4023
4024     def test_utc_offsets(self):
4025         """Some know equal UTC offsets
4026         """
4027         dts = [
4028             GeneralizedTime(data.encode("ascii"), ctx={"bered": True})
4029             for data in (
4030                 "200101011830Z",
4031                 "200101012230+04",
4032                 "200101011130-0700",
4033                 "200101011500-03:30",
4034             )
4035         ]
4036         self.assertEqual(dts[0], dts[1])
4037         self.assertEqual(dts[0], dts[2])
4038         self.assertEqual(dts[0], dts[3])
4039
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("  ,."))
4051         fractions = None
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()):
4071             data += "Z"
4072         elif d.draw(booleans()):
4073             offset_hour = d.draw(integers(min_value=0, max_value=13))
4074             sign = 1
4075             if d.draw(booleans()):
4076                 data += "-"
4077                 sign = -1
4078             else:
4079                 data += "+"
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_der = GeneralizedTime.tag_default + len_encode(len(data)) + data
4089         try:
4090             GeneralizedTime().decod(data_der)
4091         except DecodeError:
4092             dered = False
4093         else:
4094             dered = True
4095         obj = GeneralizedTime().decod(data_der, ctx={"bered": True})
4096         if dt.year > 1970:
4097             self.assertEqual(
4098                 mktime(obj.todatetime().timetuple()),
4099                 mktime(dt.timetuple()),
4100             )
4101         elif not PY2:
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.ber_raw, None if dered else data)
4106         self.assertEqual(obj.encode() == data_der, dered)
4107         repr(obj)
4108         bytes(obj)
4109         str(obj)
4110
4111     def test_invalid_ber(self):
4112         for data in ((
4113                 # "00010203040506.07",
4114                 "-0010203040506.07",
4115                 "0001-203040506.07",
4116                 "000102-3040506.07",
4117                 "00010203-40506.07",
4118                 "0001020304-506.07",
4119                 "000102030405-6.07",
4120                 "00010203040506.-7",
4121                 "+0010203040506.07",
4122                 "0001+203040506.07",
4123                 "000102+3040506.07",
4124                 "00010203+40506.07",
4125                 "0001020304+506.07",
4126                 "000102030405+6.07",
4127                 "00010203040506.+7",
4128                 " 0010203040506.07",
4129                 "0001 203040506.07",
4130                 "000102 3040506.07",
4131                 "00010203 40506.07",
4132                 "0001020304 506.07",
4133                 "000102030405 6.07",
4134                 "00010203040506. 7",
4135                 "001 0203040506.07",
4136                 "00012 03040506.07",
4137                 "0001023 040506.07",
4138                 "000102034 0506.07",
4139                 "00010203045 06.07",
4140                 "0001020304056 .07",
4141                 "00010203040506.7 ",
4142                 "00010203040506.",
4143                 "0001020304050607",
4144
4145                 "-0010203040506",
4146                 "0001-203040506",
4147                 "000102-3040506",
4148                 "00010203-40506",
4149                 "0001020304-506",
4150                 "000102030405-6",
4151                 "0001+203040506",
4152                 "000102+3040506",
4153                 "00010203+40506",
4154                 "0001020304+506",
4155                 "000102030405+6",
4156                 " 0010203040506",
4157                 "0001 203040506",
4158                 "000102 3040506",
4159                 "00010203 40506",
4160                 "0001020304 506",
4161                 "000102030405 6",
4162                 "001 0203040506",
4163                 "00012 03040506",
4164                 "0001023 040506",
4165                 "000102034 0506",
4166                 "00010203045 06",
4167                 "0001020304056 ",
4168
4169                 "-00102030405.07",
4170                 "0001-2030405.07",
4171                 "000102-30405.07",
4172                 "00010203-405.07",
4173                 "0001020304-5.07",
4174                 "000102030405.-7",
4175                 "+00102030405.07",
4176                 "0001+2030405.07",
4177                 "00010203+405.07",
4178                 "0001020304+5.07",
4179                 "000102030405.+7",
4180                 " 00102030405.07",
4181                 "0001 2030405.07",
4182                 "000102 30405.07",
4183                 "00010203 405.07",
4184                 "0001020304 5.07",
4185                 "000102030405. 7",
4186                 "001 02030405.07",
4187                 "00012 030405.07",
4188                 "0001023 0405.07",
4189                 "000102034 05.07",
4190                 "00010203045 .07",
4191                 "000102030405.7 ",
4192                 "000102030405.",
4193
4194                 "-001020304.07",
4195                 "0001-20304.07",
4196                 "000102-304.07",
4197                 "00010203-4.07",
4198                 "0001020304.-7",
4199                 "+001020304.07",
4200                 "0001+20304.07",
4201                 "00010203+4.07",
4202                 "0001020304.+7",
4203                 " 001020304.07",
4204                 "0001 20304.07",
4205                 "000102 304.07",
4206                 "00010203 4.07",
4207                 "0001020304. 7",
4208                 "001 020304.07",
4209                 "00012 0304.07",
4210                 "0001023 04.07",
4211                 "000102034 .07",
4212                 "0001020304.7 ",
4213                 "0001020304.",
4214
4215                 "00010203",
4216                 "00010203040506Y",
4217                 "0001010100+0001",
4218                 "0001010100+00:01",
4219                 "0001010100+01",
4220
4221                 "00010203040506.07+15",
4222                 "00010203040506.07-15",
4223                 "00010203040506.07+14:60",
4224                 "00010203040506.07+1460",
4225                 "00010203040506.07-1460",
4226                 "00010203040506.07+00:60",
4227                 "00010203040506.07-00:60",
4228
4229                 "00010203040506+15",
4230                 "00010203040506-15",
4231                 "00010203040506+14:60",
4232                 "00010203040506+1460",
4233                 "00010203040506-1460",
4234                 "00010203040506+00:60",
4235                 "00010203040506-00:60",
4236
4237                 "0001020304050.07",
4238                 "00010203040.07",
4239                 "000102030.07",
4240                 "0001020304050",
4241                 "00010203040",
4242                 "000102030",
4243         )):
4244             with self.assertRaises(DecodeError):
4245                 GeneralizedTime(data.encode("ascii"), ctx={"bered": True})
4246             data = data.replace(".", ",")
4247             with self.assertRaises(DecodeError):
4248                 GeneralizedTime(data.encode("ascii"), ctx={"bered": True})
4249
4250     @given(
4251         binary(
4252             min_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
4253             max_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
4254         ),
4255         binary(min_size=1, max_size=1),
4256         binary(
4257             min_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
4258             max_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
4259         ),
4260     )
4261     def test_junk(self, part0, part1, part2):
4262         junk = part0 + part1 + part2
4263         assume(not (set(junk) <= set(digits.encode("ascii"))))
4264         with self.assertRaises(DecodeError):
4265             GeneralizedTime().decode(
4266                 GeneralizedTime.tag_default +
4267                 len_encode(len(junk)) +
4268                 junk
4269             )
4270
4271     @given(
4272         binary(
4273             min_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
4274             max_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
4275         ),
4276         binary(min_size=1, max_size=1),
4277         binary(
4278             min_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
4279             max_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
4280         ),
4281     )
4282     def test_junk_dm(self, part0, part1, part2):
4283         junk = part0 + part1 + part2
4284         assume(not (set(junk) <= set(digits.encode("ascii"))))
4285         with self.assertRaises(DecodeError):
4286             GeneralizedTime().decode(
4287                 GeneralizedTime.tag_default +
4288                 len_encode(len(junk)) +
4289                 junk
4290             )
4291
4292     def test_ns_fractions(self):
4293         GeneralizedTime(b"20010101000000.000001Z")
4294         with assertRaisesRegex(self, DecodeError, "only microsecond fractions"):
4295             GeneralizedTime(b"20010101000000.0000001Z")
4296
4297     def test_non_pure_integers(self):
4298         for data in ((
4299                 # b"20000102030405Z,
4300                 b"+2000102030405Z",
4301                 b"2000+102030405Z",
4302                 b"200001+2030405Z",
4303                 b"20000102+30405Z",
4304                 b"2000010203+405Z",
4305                 b"200001020304+5Z",
4306                 b"20000102030405.+6Z",
4307                 b"20000102030405.-6Z",
4308                 b" 2000102030405Z",
4309                 b"2000 102030405Z",
4310                 b"200001 2030405Z",
4311                 b"20000102 30405Z",
4312                 b"2000010203 405Z",
4313                 b"200001020304 5Z",
4314                 b"20000102030405. 6Z",
4315                 b"200 0102030405Z",
4316                 b"20001 02030405Z",
4317                 b"2000012 030405Z",
4318                 b"200001023 0405Z",
4319                 b"20000102034 05Z",
4320                 b"2000010203045 Z",
4321                 b"20000102030405.6 Z",
4322         )):
4323             with self.assertRaises(DecodeError):
4324                 GeneralizedTime(data)
4325
4326
4327 class TestUTCTime(TimeMixin, CommonMixin, TestCase):
4328     base_klass = UTCTime
4329     omit_ms = True
4330     min_datetime = datetime(2000, 1, 1)
4331     max_datetime = datetime(2049, 12, 31)
4332
4333     def additional_symmetric_check(self, value, obj_encoded):
4334         pass
4335
4336     def test_repr_not_ready(self):
4337         unicode(GeneralizedTime()) if PY2 else str(GeneralizedTime())
4338         repr(UTCTime())
4339
4340     def test_x690_vector_valid(self):
4341         for data in ((
4342                 b"920521000000Z",
4343                 b"920622123421Z",
4344                 b"920722132100Z",
4345         )):
4346             UTCTime(data)
4347
4348     def test_x690_vector_invalid(self):
4349         for data in ((
4350                 b"920520240000Z",
4351                 b"9207221321Z",
4352         )):
4353             with self.assertRaises(DecodeError) as err:
4354                 UTCTime(data)
4355             repr(err.exception)
4356
4357     def test_go_vectors_invalid(self):
4358         for data in ((
4359                 b"a10506234540Z",
4360                 b"91a506234540Z",
4361                 b"9105a6234540Z",
4362                 b"910506a34540Z",
4363                 b"910506334a40Z",
4364                 b"91050633444aZ",
4365                 b"910506334461Z",
4366                 b"910506334400Za",
4367                 b"000100000000Z",
4368                 b"101302030405Z",
4369                 b"100002030405Z",
4370                 b"100100030405Z",
4371                 b"100132030405Z",
4372                 b"100231030405Z",
4373                 b"100102240405Z",
4374                 b"100102036005Z",
4375                 b"100102030460Z",
4376                 b"-100102030410Z",
4377                 b"10-0102030410Z",
4378                 b"10-0002030410Z",
4379                 b"1001-02030410Z",
4380                 b"100102-030410Z",
4381                 b"10010203-0410Z",
4382                 b"1001020304-10Z",
4383                 # These ones are INVALID in *DER*, but accepted
4384                 # by Go's encoding/asn1
4385                 b"910506164540-0700",
4386                 b"910506164540+0730",
4387                 b"9105062345Z",
4388                 b"5105062345Z",
4389         )):
4390             with self.assertRaises(DecodeError) as err:
4391                 UTCTime(data)
4392             repr(err.exception)
4393
4394     def test_go_vectors_valid(self):
4395         self.assertEqual(
4396             UTCTime(b"910506234540Z").todatetime(),
4397             datetime(1991, 5, 6, 23, 45, 40, 0),
4398         )
4399
4400     def test_non_pure_integers(self):
4401         for data in ((
4402                 # b"000102030405Z",
4403                 b"+10102030405Z",
4404                 b"00+102030405Z",
4405                 b"0001+2030405Z",
4406                 b"000102+30405Z",
4407                 b"00010203+405Z",
4408                 b"0001020304+5Z",
4409                 b" 10102030405Z",
4410                 b"00 102030405Z",
4411                 b"0001 2030405Z",
4412                 b"000102 30405Z",
4413                 b"00010203 405Z",
4414                 b"0001020304 5Z",
4415                 b"1 0102030405Z",
4416                 b"001 02030405Z",
4417                 b"00012 030405Z",
4418                 b"0001023 0405Z",
4419                 b"000102034 05Z",
4420                 b"00010203045 Z",
4421         )):
4422             with self.assertRaises(DecodeError):
4423                 UTCTime(data)
4424
4425     def test_x680_vector_valid_ber(self):
4426         for data, dt in ((
4427                 (b"8201021200Z", datetime(1982, 1, 2, 12)),
4428                 (b"8201020700-0500", datetime(1982, 1, 2, 12)),
4429                 (b"0101021200Z", datetime(2001, 1, 2, 12)),
4430                 (b"0101020700-0500", datetime(2001, 1, 2, 12)),
4431         )):
4432             data_der = UTCTime.tag_default + len_encode(len(data)) + data
4433             obj = UTCTime().decod(data_der, ctx={"bered": True})
4434             self.assertEqual(obj, dt)
4435             self.assertEqual(obj.todatetime(), dt)
4436             self.assertTrue(obj.ber_encoded)
4437             self.assertTrue(obj.bered)
4438             self.assertEqual(obj.ber_raw, data)
4439             self.assertNotEqual(obj.encode(), data_der)
4440             repr(obj)
4441
4442     def test_go_vectors_valid_ber(self):
4443         for data in ((
4444                 b"910506164540-0700",
4445                 b"910506164540+0730",
4446                 b"9105062345Z",
4447                 b"5105062345Z",
4448         )):
4449             data = UTCTime.tag_default + len_encode(len(data)) + data
4450             obj = UTCTime().decod(data, ctx={"bered": True})
4451             self.assertTrue(obj.ber_encoded)
4452             self.assertTrue(obj.bered)
4453             self.assertNotEqual(obj.encode(), data)
4454             repr(obj)
4455
4456     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
4457     @given(data_strategy())
4458     def test_valid_ber(self, d):
4459         year = d.draw(integers(min_value=0, max_value=99))
4460         month = d.draw(integers(min_value=1, max_value=12))
4461         day = d.draw(integers(min_value=1, max_value=28))
4462         hours = d.draw(integers(min_value=0, max_value=23))
4463         minute = d.draw(integers(min_value=0, max_value=59))
4464         data = "%02d%02d%02d%02d%02d" % (year, month, day, hours, minute)
4465         dt = datetime(
4466             year + (2000 if year < 50 else 1900),
4467             month,
4468             day,
4469             hours,
4470             minute,
4471         )
4472         dered = False
4473         if d.draw(booleans()):
4474             dered = True
4475             seconds = d.draw(integers(min_value=0, max_value=59))
4476             data += "%02d" % seconds
4477             dt += timedelta(seconds=seconds)
4478         if d.draw(booleans()):
4479             data += "Z"
4480         else:
4481             dered = False
4482             offset_hour = d.draw(integers(min_value=0, max_value=13))
4483             offset_minute = d.draw(integers(min_value=0, max_value=59))
4484             offset = timedelta(seconds=offset_hour * 3600 + offset_minute * 60)
4485             if d.draw(booleans()):
4486                 dt += offset
4487                 data += "-"
4488             else:
4489                 dt -= offset
4490                 data += "+"
4491             data += "%02d%02d" % (offset_hour, offset_minute)
4492         data = data.encode("ascii")
4493         data_der = UTCTime.tag_default + len_encode(len(data)) + data
4494         obj = UTCTime().decod(data_der, ctx={"bered": True})
4495         self.assertEqual(obj, dt)
4496         self.assertEqual(obj.todatetime(), dt)
4497         self.assertEqual(obj.ber_encoded, not dered)
4498         self.assertEqual(obj.bered, not dered)
4499         self.assertEqual(obj.ber_raw, None if dered else data)
4500         self.assertEqual(obj.encode() == data_der, dered)
4501         repr(obj)
4502         bytes(obj)
4503         str(obj)
4504
4505     def test_invalid_ber(self):
4506         for data in ((
4507                 # b"0001020304Z",
4508                 b"-101020304Z",
4509                 b"00-1020304Z",
4510                 b"0001-20304Z",
4511                 b"000102-304Z",
4512                 b"000102-104Z",
4513                 b"00000203-4Z",
4514                 b"+101020304Z",
4515                 b"00+1020304Z",
4516                 b"0001+20304Z",
4517                 b"000102+304Z",
4518                 b"000102+104Z",
4519                 b"00000203+4Z",
4520                 b" 101020304Z",
4521                 b"00 1020304Z",
4522                 b"0001 20304Z",
4523                 b"000102 304Z",
4524                 b"000102 104Z",
4525                 b"00000203 4Z",
4526                 b"1 01020304Z",
4527                 b"001 020304Z",
4528                 b"00012 0304Z",
4529                 b"0001023 04Z",
4530                 b"0001021 04Z",
4531                 b"000002034 Z",
4532                 b"0013020304Z",
4533                 b"0001000304Z",
4534                 b"0001320304Z",
4535                 b"0001022404Z",
4536                 b"0001020360Z",
4537                 b"0002300304Z",
4538                 b"0001020304",
4539                 b"0001020304T",
4540                 b"0001020304+",
4541                 b"0001020304-",
4542                 b"0001020304+0",
4543                 b"0001020304+00",
4544                 b"0001020304+000",
4545                 b"0001020304+000Z",
4546                 b"0001020304+0000Z",
4547                 b"0001020304+-101",
4548                 b"0001020304+01-1",
4549                 b"0001020304+0060",
4550                 b"0001020304+1401",
4551                 b"5001010000+0001",
4552                 b"000102030Z",
4553                 b"0001020Z",
4554         )):
4555             with self.assertRaises(DecodeError):
4556                 UTCTime(data, ctx={"bered": True})
4557             data = data[:8] + data[8+2:]
4558             with self.assertRaises(DecodeError):
4559                 UTCTime(data, ctx={"bered": True})
4560
4561         for data in ((
4562                 # b"000102030405Z",
4563                 b"-10102030405Z",
4564                 b"00-102030405Z",
4565                 b"0001-2030405Z",
4566                 b"000102-30405Z",
4567                 b"000102-10405Z",
4568                 b"00000203-405Z",
4569                 b"0000020304-5Z",
4570                 b"+10102030405Z",
4571                 b"00+102030405Z",
4572                 b"0001+2030405Z",
4573                 b"000102+30405Z",
4574                 b"000102+10405Z",
4575                 b"00000203+405Z",
4576                 b"0000020304+5Z",
4577                 b" 10102030405Z",
4578                 b"00 102030405Z",
4579                 b"0001 2030405Z",
4580                 b"000102 30405Z",
4581                 b"000102 10405Z",
4582                 b"00000203 405Z",
4583                 b"0000020304 5Z",
4584                 b"1 0102030405Z",
4585                 b"001 02030405Z",
4586                 b"00012 030405Z",
4587                 b"0001023 0405Z",
4588                 b"0001021 0405Z",
4589                 b"000002034 05Z",
4590                 b"00000203045 Z",
4591                 b"001302030405Z",
4592                 b"000100030405Z",
4593                 b"000132030405Z",
4594                 b"000102240405Z",
4595                 b"000102036005Z",
4596                 b"000230030405Z",
4597                 b"000102030460Z",
4598                 b"000102030405",
4599                 b"000102030405T",
4600                 b"000102030405+",
4601                 b"000102030405-",
4602                 b"000102030405+0",
4603                 b"000102030405+00",
4604                 b"000102030405+000",
4605                 b"000102030405+000Z",
4606                 b"000102030405+0000Z",
4607                 b"000102030405+-101",
4608                 b"000102030405+01-1",
4609                 b"000102030405+0060",
4610                 b"000102030405+1401",
4611                 b"500101000002+0003",
4612         )):
4613             with self.assertRaises(DecodeError):
4614                 UTCTime(data, ctx={"bered": True})
4615
4616     @given(integers(min_value=0, max_value=49))
4617     def test_pre50(self, year):
4618         self.assertEqual(
4619             UTCTime(("%02d1231235959Z" % year).encode("ascii")).todatetime().year,
4620             2000 + year,
4621         )
4622
4623     @given(integers(min_value=50, max_value=99))
4624     def test_post50(self, year):
4625         self.assertEqual(
4626             UTCTime(("%02d1231235959Z" % year).encode("ascii")).todatetime().year,
4627             1900 + year,
4628         )
4629
4630     @given(
4631         binary(
4632             min_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
4633             max_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
4634         ),
4635         binary(min_size=1, max_size=1),
4636         binary(
4637             min_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
4638             max_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
4639         ),
4640     )
4641     def test_junk(self, part0, part1, part2):
4642         junk = part0 + part1 + part2
4643         assume(not (set(junk) <= set(digits.encode("ascii"))))
4644         with self.assertRaises(DecodeError):
4645             UTCTime().decode(
4646                 UTCTime.tag_default +
4647                 len_encode(len(junk)) +
4648                 junk
4649             )
4650
4651
4652 @composite
4653 def any_values_strategy(draw, do_expl=False):
4654     value = draw(one_of(none(), binary()))
4655     expl = None
4656     if do_expl:
4657         expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
4658     optional = draw(one_of(none(), booleans()))
4659     _decoded = (
4660         draw(integers(min_value=0)),
4661         draw(integers(min_value=0)),
4662         draw(integers(min_value=0)),
4663     )
4664     return (value, expl, optional, _decoded)
4665
4666
4667 class AnyInherited(Any):
4668     pass
4669
4670
4671 class TestAny(CommonMixin, TestCase):
4672     base_klass = Any
4673
4674     def test_invalid_value_type(self):
4675         with self.assertRaises(InvalidValueType) as err:
4676             Any(123)
4677         repr(err.exception)
4678
4679     @given(booleans())
4680     def test_optional(self, optional):
4681         obj = Any(optional=optional)
4682         self.assertEqual(obj.optional, optional)
4683
4684     @given(binary())
4685     def test_ready(self, value):
4686         obj = Any()
4687         self.assertFalse(obj.ready)
4688         repr(obj)
4689         list(obj.pps())
4690         pprint(obj, big_blobs=True, with_decode_path=True)
4691         with self.assertRaises(ObjNotReady) as err:
4692             obj.encode()
4693         repr(err.exception)
4694         obj = Any(value)
4695         self.assertTrue(obj.ready)
4696         repr(obj)
4697         list(obj.pps())
4698         pprint(obj, big_blobs=True, with_decode_path=True)
4699
4700     @given(integers())
4701     def test_basic(self, value):
4702         integer_encoded = Integer(value).encode()
4703         for obj in (
4704                 Any(integer_encoded),
4705                 Any(Integer(value)),
4706                 Any(Any(Integer(value))),
4707         ):
4708             self.assertSequenceEqual(bytes(obj), integer_encoded)
4709             self.assertEqual(
4710                 obj.decode(obj.encode())[0].vlen,
4711                 len(integer_encoded),
4712             )
4713             repr(obj)
4714             list(obj.pps())
4715             pprint(obj, big_blobs=True, with_decode_path=True)
4716             self.assertSequenceEqual(obj.encode(), integer_encoded)
4717
4718     @given(binary(), binary())
4719     def test_comparison(self, value1, value2):
4720         for klass in (Any, AnyInherited):
4721             obj1 = klass(value1)
4722             obj2 = klass(value2)
4723             self.assertEqual(obj1 == obj2, value1 == value2)
4724             self.assertEqual(obj1 != obj2, value1 != value2)
4725             self.assertEqual(obj1 == bytes(obj2), value1 == value2)
4726
4727     @given(data_strategy())
4728     def test_call(self, d):
4729         for klass in (Any, AnyInherited):
4730             (
4731                 value_initial,
4732                 expl_initial,
4733                 optional_initial,
4734                 _decoded_initial,
4735             ) = d.draw(any_values_strategy())
4736             obj_initial = klass(
4737                 value_initial,
4738                 expl_initial,
4739                 optional_initial or False,
4740                 _decoded_initial,
4741             )
4742             (
4743                 value,
4744                 expl,
4745                 optional,
4746                 _decoded,
4747             ) = d.draw(any_values_strategy(do_expl=True))
4748             obj = obj_initial(value, expl, optional)
4749             if obj.ready:
4750                 value_expected = None if value is None else value
4751                 self.assertEqual(obj, value_expected)
4752             self.assertEqual(obj.expl_tag, expl or expl_initial)
4753             if obj.default is None:
4754                 optional = optional_initial if optional is None else optional
4755                 optional = False if optional is None else optional
4756             self.assertEqual(obj.optional, optional)
4757
4758     def test_simultaneous_impl_expl(self):
4759         # override it, as Any does not have implicit tag
4760         pass
4761
4762     def test_decoded(self):
4763         # override it, as Any does not have implicit tag
4764         pass
4765
4766     @given(any_values_strategy())
4767     def test_copy(self, values):
4768         for klass in (Any, AnyInherited):
4769             obj = klass(*values)
4770             for copy_func in copy_funcs:
4771                 obj_copied = copy_func(obj)
4772                 self.assert_copied_basic_fields(obj, obj_copied)
4773                 self.assertEqual(obj._value, obj_copied._value)
4774
4775     @given(binary().map(OctetString))
4776     def test_stripped(self, value):
4777         obj = Any(value)
4778         with self.assertRaises(NotEnoughData):
4779             obj.decode(obj.encode()[:-1])
4780
4781     @given(
4782         binary(),
4783         integers(min_value=1).map(tag_ctxc),
4784     )
4785     def test_stripped_expl(self, value, tag_expl):
4786         obj = Any(value, expl=tag_expl)
4787         with self.assertRaises(NotEnoughData):
4788             obj.decode(obj.encode()[:-1])
4789
4790     @given(
4791         integers(min_value=31),
4792         integers(min_value=0),
4793         decode_path_strat,
4794     )
4795     def test_bad_tag(self, tag, offset, decode_path):
4796         with self.assertRaises(DecodeError) as err:
4797             Any().decode(
4798                 tag_encode(tag)[:-1],
4799                 offset=offset,
4800                 decode_path=decode_path,
4801             )
4802         repr(err.exception)
4803         self.assertEqual(err.exception.offset, offset)
4804         self.assertEqual(err.exception.decode_path, decode_path)
4805
4806     @given(
4807         integers(min_value=128),
4808         integers(min_value=0),
4809         decode_path_strat,
4810     )
4811     def test_bad_len(self, l, offset, decode_path):
4812         with self.assertRaises(DecodeError) as err:
4813             Any().decode(
4814                 Any.tag_default + len_encode(l)[:-1],
4815                 offset=offset,
4816                 decode_path=decode_path,
4817             )
4818         repr(err.exception)
4819         self.assertEqual(err.exception.offset, offset)
4820         self.assertEqual(err.exception.decode_path, decode_path)
4821
4822     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
4823     @given(
4824         any_values_strategy(),
4825         integers().map(lambda x: Integer(x).encode()),
4826         integers(min_value=1).map(tag_ctxc),
4827         integers(min_value=0),
4828         binary(max_size=5),
4829     )
4830     def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
4831         for klass in (Any, AnyInherited):
4832             _, _, optional, _decoded = values
4833             obj = klass(value=value, optional=optional, _decoded=_decoded)
4834             repr(obj)
4835             list(obj.pps())
4836             pprint(obj, big_blobs=True, with_decode_path=True)
4837             self.assertFalse(obj.expled)
4838             obj_encoded = obj.encode()
4839             obj_expled = obj(value, expl=tag_expl)
4840             self.assertTrue(obj_expled.expled)
4841             repr(obj_expled)
4842             list(obj_expled.pps())
4843             pprint(obj_expled, big_blobs=True, with_decode_path=True)
4844             obj_expled_encoded = obj_expled.encode()
4845             ctx_copied = deepcopy(ctx_dummy)
4846             obj_decoded, tail = obj_expled.decode(
4847                 obj_expled_encoded + tail_junk,
4848                 offset=offset,
4849                 ctx=ctx_copied,
4850             )
4851             self.assertDictEqual(ctx_copied, ctx_dummy)
4852             repr(obj_decoded)
4853             list(obj_decoded.pps())
4854             pprint(obj_decoded, big_blobs=True, with_decode_path=True)
4855             self.assertEqual(tail, tail_junk)
4856             self.assertEqual(obj_decoded, obj_expled)
4857             self.assertEqual(bytes(obj_decoded), bytes(obj_expled))
4858             self.assertEqual(bytes(obj_decoded), bytes(obj))
4859             self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
4860             self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
4861             self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
4862             self.assertEqual(
4863                 obj_decoded.expl_llen,
4864                 len(len_encode(len(obj_encoded))),
4865             )
4866             self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
4867             self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
4868             self.assertEqual(
4869                 obj_decoded.offset,
4870                 offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
4871             )
4872             self.assertEqual(obj_decoded.expl_offset, offset)
4873             self.assertEqual(obj_decoded.tlen, 0)
4874             self.assertEqual(obj_decoded.llen, 0)
4875             self.assertEqual(obj_decoded.vlen, len(value))
4876             assert_exceeding_data(
4877                 self,
4878                 lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
4879                 tail_junk,
4880             )
4881
4882     @given(
4883         integers(min_value=1).map(tag_ctxc),
4884         integers(min_value=0, max_value=3),
4885         integers(min_value=0),
4886         decode_path_strat,
4887         binary(),
4888     )
4889     def test_indefinite(self, expl, chunks, offset, decode_path, junk):
4890         chunk = Boolean(False, expl=expl).encode()
4891         encoded = (
4892             OctetString.tag_default +
4893             LENINDEF +
4894             b"".join([chunk] * chunks) +
4895             EOC
4896         )
4897         with self.assertRaises(LenIndefForm):
4898             Any().decode(
4899                 encoded + junk,
4900                 offset=offset,
4901                 decode_path=decode_path,
4902             )
4903         obj, tail = Any().decode(
4904             encoded + junk,
4905             offset=offset,
4906             decode_path=decode_path,
4907             ctx={"bered": True},
4908         )
4909         self.assertSequenceEqual(tail, junk)
4910         self.assertEqual(obj.offset, offset)
4911         self.assertEqual(obj.tlvlen, len(encoded))
4912         self.assertTrue(obj.lenindef)
4913         self.assertFalse(obj.ber_encoded)
4914         self.assertTrue(obj.bered)
4915         obj = copy(obj)
4916         self.assertTrue(obj.lenindef)
4917         self.assertFalse(obj.ber_encoded)
4918         self.assertTrue(obj.bered)
4919         repr(obj)
4920         list(obj.pps())
4921         pprint(obj, big_blobs=True, with_decode_path=True)
4922         with self.assertRaises(NotEnoughData) as err:
4923             Any().decode(
4924                 encoded[:-1],
4925                 offset=offset,
4926                 decode_path=decode_path,
4927                 ctx={"bered": True},
4928             )
4929         self.assertEqual(err.exception.offset, offset + 1 + 1 + len(chunk) * chunks)
4930         self.assertEqual(err.exception.decode_path, decode_path + (str(chunks),))
4931
4932         class SeqOf(SequenceOf):
4933             schema = Boolean(expl=expl)
4934
4935         class Seq(Sequence):
4936             schema = (
4937                 ("type", ObjectIdentifier(defines=((("value",), {
4938                     ObjectIdentifier("1.2.3"): SeqOf(impl=OctetString.tag_default),
4939                 }),))),
4940                 ("value", Any()),
4941             )
4942         seq = Seq((
4943             ("type", ObjectIdentifier("1.2.3")),
4944             ("value", Any(encoded)),
4945         ))
4946         seq_encoded = seq.encode()
4947         seq_decoded, _ = Seq().decode(seq_encoded, ctx={"bered": True})
4948         self.assertIsNotNone(seq_decoded["value"].defined)
4949         repr(seq_decoded)
4950         list(seq_decoded.pps())
4951         pprint(seq_decoded, big_blobs=True, with_decode_path=True)
4952         self.assertTrue(seq_decoded.bered)
4953         self.assertFalse(seq_decoded["type"].bered)
4954         self.assertTrue(seq_decoded["value"].bered)
4955
4956         chunk = chunk[:-1] + b"\x01"
4957         chunks = b"".join([chunk] * (chunks + 1))
4958         encoded = OctetString.tag_default + len_encode(len(chunks)) + chunks
4959         seq = Seq((
4960             ("type", ObjectIdentifier("1.2.3")),
4961             ("value", Any(encoded)),
4962         ))
4963         seq_encoded = seq.encode()
4964         seq_decoded, _ = Seq().decode(seq_encoded, ctx={"bered": True})
4965         self.assertIsNotNone(seq_decoded["value"].defined)
4966         repr(seq_decoded)
4967         list(seq_decoded.pps())
4968         pprint(seq_decoded, big_blobs=True, with_decode_path=True)
4969         self.assertTrue(seq_decoded.bered)
4970         self.assertFalse(seq_decoded["type"].bered)
4971         self.assertTrue(seq_decoded["value"].bered)
4972
4973
4974 @composite
4975 def choice_values_strategy(draw, value_required=False, schema=None, do_expl=False):
4976     if schema is None:
4977         names = list(draw(sets(text_letters(), min_size=1, max_size=5)))
4978         tags = [{tag_type: tag_value} for tag_type, tag_value in draw(sets(
4979             one_of(
4980                 tuples(just("impl"), integers(min_value=0).map(tag_encode)),
4981                 tuples(just("expl"), integers(min_value=0).map(tag_ctxp)),
4982             ),
4983             min_size=len(names),
4984             max_size=len(names),
4985         ))]
4986         schema = [
4987             (name, Integer(**tag_kwargs))
4988             for name, tag_kwargs in zip(names, tags)
4989         ]
4990     value = None
4991     if value_required or draw(booleans()):
4992         value = draw(tuples(
4993             sampled_from([name for name, _ in schema]),
4994             integers().map(Integer),
4995         ))
4996     expl = None
4997     if do_expl:
4998         expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
4999     default = draw(one_of(
5000         none(),
5001         tuples(sampled_from([name for name, _ in schema]), integers().map(Integer)),
5002     ))
5003     optional = draw(one_of(none(), booleans()))
5004     _decoded = (
5005         draw(integers(min_value=0)),
5006         draw(integers(min_value=0)),
5007         draw(integers(min_value=0)),
5008     )
5009     return (schema, value, expl, default, optional, _decoded)
5010
5011
5012 class ChoiceInherited(Choice):
5013     pass
5014
5015
5016 class TestChoice(CommonMixin, TestCase):
5017     class Wahl(Choice):
5018         schema = (("whatever", Boolean()),)
5019     base_klass = Wahl
5020
5021     def test_schema_required(self):
5022         with assertRaisesRegex(self, ValueError, "schema must be specified"):
5023             Choice()
5024
5025     def test_impl_forbidden(self):
5026         with assertRaisesRegex(self, ValueError, "no implicit tag allowed"):
5027             Choice(impl=b"whatever")
5028
5029     def test_invalid_value_type(self):
5030         with self.assertRaises(InvalidValueType) as err:
5031             self.base_klass(123)
5032         repr(err.exception)
5033         with self.assertRaises(ObjUnknown) as err:
5034             self.base_klass(("whenever", Boolean(False)))
5035         repr(err.exception)
5036         with self.assertRaises(InvalidValueType) as err:
5037             self.base_klass(("whatever", Integer(123)))
5038         repr(err.exception)
5039
5040     @given(booleans())
5041     def test_optional(self, optional):
5042         obj = self.base_klass(
5043             default=self.base_klass(("whatever", Boolean(False))),
5044             optional=optional,
5045         )
5046         self.assertTrue(obj.optional)
5047
5048     @given(booleans())
5049     def test_ready(self, value):
5050         obj = self.base_klass()
5051         self.assertFalse(obj.ready)
5052         repr(obj)
5053         list(obj.pps())
5054         pprint(obj, big_blobs=True, with_decode_path=True)
5055         self.assertIsNone(obj["whatever"])
5056         with self.assertRaises(ObjNotReady) as err:
5057             obj.encode()
5058         repr(err.exception)
5059         obj["whatever"] = Boolean()
5060         self.assertFalse(obj.ready)
5061         repr(obj)
5062         list(obj.pps())
5063         pprint(obj, big_blobs=True, with_decode_path=True)
5064         obj["whatever"] = Boolean(value)
5065         self.assertTrue(obj.ready)
5066         repr(obj)
5067         list(obj.pps())
5068         pprint(obj, big_blobs=True, with_decode_path=True)
5069
5070     @given(booleans(), booleans())
5071     def test_comparison(self, value1, value2):
5072         class WahlInherited(self.base_klass):
5073             pass
5074         for klass in (self.base_klass, WahlInherited):
5075             obj1 = klass(("whatever", Boolean(value1)))
5076             obj2 = klass(("whatever", Boolean(value2)))
5077             self.assertEqual(obj1 == obj2, value1 == value2)
5078             self.assertEqual(obj1 != obj2, value1 != value2)
5079             self.assertEqual(obj1 == obj2._value, value1 == value2)
5080             self.assertFalse(obj1 == obj2._value[1])
5081
5082     @given(data_strategy())
5083     def test_call(self, d):
5084         for klass in (Choice, ChoiceInherited):
5085             (
5086                 schema_initial,
5087                 value_initial,
5088                 expl_initial,
5089                 default_initial,
5090                 optional_initial,
5091                 _decoded_initial,
5092             ) = d.draw(choice_values_strategy())
5093
5094             class Wahl(klass):
5095                 schema = schema_initial
5096             obj_initial = Wahl(
5097                 value=value_initial,
5098                 expl=expl_initial,
5099                 default=default_initial,
5100                 optional=optional_initial or False,
5101                 _decoded=_decoded_initial,
5102             )
5103             (
5104                 _,
5105                 value,
5106                 expl,
5107                 default,
5108                 optional,
5109                 _decoded,
5110             ) = d.draw(choice_values_strategy(schema=schema_initial, do_expl=True))
5111             obj = obj_initial(value, expl, default, optional)
5112             if obj.ready:
5113                 value_expected = default if value is None else value
5114                 value_expected = (
5115                     default_initial if value_expected is None
5116                     else value_expected
5117                 )
5118                 self.assertEqual(obj.choice, value_expected[0])
5119                 self.assertEqual(obj.value, int(value_expected[1]))
5120             self.assertEqual(obj.expl_tag, expl or expl_initial)
5121             default_expect = default_initial if default is None else default
5122             if default_expect is not None:
5123                 self.assertEqual(obj.default.choice, default_expect[0])
5124                 self.assertEqual(obj.default.value, int(default_expect[1]))
5125             if obj.default is None:
5126                 optional = optional_initial if optional is None else optional
5127                 optional = False if optional is None else optional
5128             else:
5129                 optional = True
5130             self.assertEqual(obj.optional, optional)
5131             self.assertEqual(obj.specs, obj_initial.specs)
5132
5133     def test_simultaneous_impl_expl(self):
5134         # override it, as Any does not have implicit tag
5135         pass
5136
5137     def test_decoded(self):
5138         # override it, as Any does not have implicit tag
5139         pass
5140
5141     @given(choice_values_strategy())
5142     def test_copy(self, values):
5143         _schema, value, expl, default, optional, _decoded = values
5144
5145         class Wahl(self.base_klass):
5146             schema = _schema
5147         register_class(Wahl)
5148         obj = Wahl(
5149             value=value,
5150             expl=expl,
5151             default=default,
5152             optional=optional or False,
5153             _decoded=_decoded,
5154         )
5155         for copy_func in copy_funcs:
5156             obj_copied = copy_func(obj)
5157             self.assertIsNone(obj.tag)
5158             self.assertIsNone(obj_copied.tag)
5159             # hack for assert_copied_basic_fields
5160             obj.tag = "whatever"
5161             obj_copied.tag = "whatever"
5162             self.assert_copied_basic_fields(obj, obj_copied)
5163             obj.tag = None
5164             self.assertEqual(obj._value, obj_copied._value)
5165             self.assertEqual(obj.specs, obj_copied.specs)
5166
5167     @given(booleans())
5168     def test_stripped(self, value):
5169         obj = self.base_klass(("whatever", Boolean(value)))
5170         with self.assertRaises(NotEnoughData):
5171             obj.decode(obj.encode()[:-1])
5172
5173     @given(
5174         booleans(),
5175         integers(min_value=1).map(tag_ctxc),
5176     )
5177     def test_stripped_expl(self, value, tag_expl):
5178         obj = self.base_klass(("whatever", Boolean(value)), expl=tag_expl)
5179         with self.assertRaises(NotEnoughData):
5180             obj.decode(obj.encode()[:-1])
5181
5182     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
5183     @given(data_strategy())
5184     def test_symmetric(self, d):
5185         _schema, value, _, default, optional, _decoded = d.draw(
5186             choice_values_strategy(value_required=True)
5187         )
5188         tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
5189         offset = d.draw(integers(min_value=0))
5190         tail_junk = d.draw(binary(max_size=5))
5191
5192         class Wahl(self.base_klass):
5193             schema = _schema
5194         obj = Wahl(
5195             value=value,
5196             default=default,
5197             optional=optional,
5198             _decoded=_decoded,
5199         )
5200         repr(obj)
5201         list(obj.pps())
5202         pprint(obj, big_blobs=True, with_decode_path=True)
5203         self.assertFalse(obj.expled)
5204         obj_encoded = obj.encode()
5205         obj_expled = obj(value, expl=tag_expl)
5206         self.assertTrue(obj_expled.expled)
5207         repr(obj_expled)
5208         list(obj_expled.pps())
5209         pprint(obj_expled, big_blobs=True, with_decode_path=True)
5210         obj_expled_encoded = obj_expled.encode()
5211         ctx_copied = deepcopy(ctx_dummy)
5212         obj_decoded, tail = obj_expled.decode(
5213             obj_expled_encoded + tail_junk,
5214             offset=offset,
5215             ctx=ctx_copied,
5216         )
5217         self.assertDictEqual(ctx_copied, ctx_dummy)
5218         repr(obj_decoded)
5219         list(obj_decoded.pps())
5220         pprint(obj_decoded, big_blobs=True, with_decode_path=True)
5221         self.assertEqual(tail, tail_junk)
5222         self.assertEqual(obj_decoded, obj_expled)
5223         self.assertEqual(obj_decoded.choice, obj_expled.choice)
5224         self.assertEqual(obj_decoded.value, obj_expled.value)
5225         self.assertEqual(obj_decoded.choice, obj.choice)
5226         self.assertEqual(obj_decoded.value, obj.value)
5227         self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
5228         self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
5229         self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
5230         self.assertEqual(
5231             obj_decoded.expl_llen,
5232             len(len_encode(len(obj_encoded))),
5233         )
5234         self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
5235         self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
5236         self.assertEqual(
5237             obj_decoded.offset,
5238             offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
5239         )
5240         self.assertEqual(obj_decoded.expl_offset, offset)
5241         self.assertSequenceEqual(
5242             obj_expled_encoded[
5243                 obj_decoded.value.fulloffset - offset:
5244                 obj_decoded.value.fulloffset + obj_decoded.value.fulllen - offset
5245             ],
5246             obj_encoded,
5247         )
5248         assert_exceeding_data(
5249             self,
5250             lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
5251             tail_junk,
5252         )
5253
5254     @given(integers())
5255     def test_set_get(self, value):
5256         class Wahl(Choice):
5257             schema = (
5258                 ("erste", Boolean()),
5259                 ("zweite", Integer()),
5260             )
5261         obj = Wahl()
5262         with self.assertRaises(ObjUnknown) as err:
5263             obj["whatever"] = "whenever"
5264         with self.assertRaises(InvalidValueType) as err:
5265             obj["zweite"] = Boolean(False)
5266         obj["zweite"] = Integer(value)
5267         repr(err.exception)
5268         with self.assertRaises(ObjUnknown) as err:
5269             obj["whatever"]
5270         repr(err.exception)
5271         self.assertIsNone(obj["erste"])
5272         self.assertEqual(obj["zweite"], Integer(value))
5273
5274     def test_tag_mismatch(self):
5275         class Wahl(Choice):
5276             schema = (
5277                 ("erste", Boolean()),
5278             )
5279         int_encoded = Integer(123).encode()
5280         bool_encoded = Boolean(False).encode()
5281         obj = Wahl()
5282         obj.decode(bool_encoded)
5283         with self.assertRaises(TagMismatch):
5284             obj.decode(int_encoded)
5285
5286     def test_tag_mismatch_underlying(self):
5287         class SeqOfBoolean(SequenceOf):
5288             schema = Boolean()
5289
5290         class SeqOfInteger(SequenceOf):
5291             schema = Integer()
5292
5293         class Wahl(Choice):
5294             schema = (
5295                 ("erste", SeqOfBoolean()),
5296             )
5297
5298         int_encoded = SeqOfInteger((Integer(123),)).encode()
5299         bool_encoded = SeqOfBoolean((Boolean(False),)).encode()
5300         obj = Wahl()
5301         obj.decode(bool_encoded)
5302         with self.assertRaises(TagMismatch) as err:
5303             obj.decode(int_encoded)
5304         self.assertEqual(err.exception.decode_path, ("erste", "0"))
5305
5306
5307 @composite
5308 def seq_values_strategy(draw, seq_klass, do_expl=False):
5309     value = None
5310     if draw(booleans()):
5311         value = seq_klass()
5312         value._value = draw(dictionaries(
5313             integers(),
5314             one_of(
5315                 booleans().map(Boolean),
5316                 integers().map(Integer),
5317             ),
5318         ))
5319     schema = None
5320     if draw(booleans()):
5321         schema = list(draw(dictionaries(
5322             integers(),
5323             one_of(
5324                 booleans().map(Boolean),
5325                 integers().map(Integer),
5326             ),
5327         )).items())
5328     impl = None
5329     expl = None
5330     if do_expl:
5331         expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
5332     else:
5333         impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
5334     default = None
5335     if draw(booleans()):
5336         default = seq_klass()
5337         default._value = draw(dictionaries(
5338             integers(),
5339             one_of(
5340                 booleans().map(Boolean),
5341                 integers().map(Integer),
5342             ),
5343         ))
5344     optional = draw(one_of(none(), booleans()))
5345     _decoded = (
5346         draw(integers(min_value=0)),
5347         draw(integers(min_value=0)),
5348         draw(integers(min_value=0)),
5349     )
5350     return (value, schema, impl, expl, default, optional, _decoded)
5351
5352
5353 @composite
5354 def sequence_strategy(draw, seq_klass):
5355     inputs = draw(lists(
5356         one_of(
5357             tuples(just(Boolean), booleans(), one_of(none(), booleans())),
5358             tuples(just(Integer), integers(), one_of(none(), integers())),
5359         ),
5360         max_size=6,
5361     ))
5362     tags = draw(sets(
5363         integers(min_value=1),
5364         min_size=len(inputs),
5365         max_size=len(inputs),
5366     ))
5367     inits = [
5368         ({"expl": tag_ctxc(tag)} if expled else {"impl": tag_encode(tag)})
5369         for tag, expled in zip(tags, draw(lists(
5370             booleans(),
5371             min_size=len(inputs),
5372             max_size=len(inputs),
5373         )))
5374     ]
5375     empties = []
5376     for i, optional in enumerate(draw(lists(
5377             sampled_from(("required", "optional", "empty")),
5378             min_size=len(inputs),
5379             max_size=len(inputs),
5380     ))):
5381         if optional in ("optional", "empty"):
5382             inits[i]["optional"] = True
5383         if optional == "empty":
5384             empties.append(i)
5385     empties = set(empties)
5386     names = list(draw(sets(
5387         text_printable,
5388         min_size=len(inputs),
5389         max_size=len(inputs),
5390     )))
5391     schema = []
5392     for i, (klass, value, default) in enumerate(inputs):
5393         schema.append((names[i], klass(default=default, **inits[i])))
5394     seq_name = draw(text_letters())
5395     Seq = type(seq_name, (seq_klass,), {"schema": tuple(schema)})
5396     seq = Seq()
5397     expects = []
5398     for i, (klass, value, default) in enumerate(inputs):
5399         name = names[i]
5400         _, spec = schema[i]
5401         expect = {
5402             "name": name,
5403             "optional": False,
5404             "presented": False,
5405             "default_value": None if spec.default is None else default,
5406             "value": None,
5407         }
5408         if i in empties:
5409             expect["optional"] = True
5410         else:
5411             expect["presented"] = True
5412             expect["value"] = value
5413             if spec.optional:
5414                 expect["optional"] = True
5415             if default is not None and default == value:
5416                 expect["presented"] = False
5417             seq[name] = klass(value)
5418         expects.append(expect)
5419     return seq, expects
5420
5421
5422 @composite
5423 def sequences_strategy(draw, seq_klass):
5424     tags = draw(sets(integers(min_value=1), min_size=0, max_size=5))
5425     inits = [
5426         ({"expl": tag_ctxc(tag)} if expled else {"impl": tag_encode(tag)})
5427         for tag, expled in zip(tags, draw(lists(
5428             booleans(),
5429             min_size=len(tags),
5430             max_size=len(tags),
5431         )))
5432     ]
5433     defaulted = set(
5434         i for i, is_default in enumerate(draw(lists(
5435             booleans(),
5436             min_size=len(tags),
5437             max_size=len(tags),
5438         ))) if is_default
5439     )
5440     names = list(draw(sets(
5441         text_printable,
5442         min_size=len(tags),
5443         max_size=len(tags),
5444     )))
5445     seq_expectses = draw(lists(
5446         sequence_strategy(seq_klass=seq_klass),
5447         min_size=len(tags),
5448         max_size=len(tags),
5449     ))
5450     seqs = [seq for seq, _ in seq_expectses]
5451     schema = []
5452     for i, (name, seq) in enumerate(zip(names, seqs)):
5453         schema.append((
5454             name,
5455             seq(default=(seq if i in defaulted else None), **inits[i]),
5456         ))
5457     seq_name = draw(text_letters())
5458     Seq = type(seq_name, (seq_klass,), {"schema": tuple(schema)})
5459     seq_outer = Seq()
5460     expect_outers = []
5461     for name, (seq_inner, expects_inner) in zip(names, seq_expectses):
5462         expect = {
5463             "name": name,
5464             "expects": expects_inner,
5465             "presented": False,
5466         }
5467         seq_outer[name] = seq_inner
5468         if seq_outer.specs[name].default is None:
5469             expect["presented"] = True
5470         expect_outers.append(expect)
5471     return seq_outer, expect_outers
5472
5473
5474 class SeqMixing(object):
5475     def test_invalid_value_type(self):
5476         with self.assertRaises(InvalidValueType) as err:
5477             self.base_klass(123)
5478         repr(err.exception)
5479
5480     def test_invalid_value_type_set(self):
5481         class Seq(self.base_klass):
5482             schema = (("whatever", Boolean()),)
5483         seq = Seq()
5484         with self.assertRaises(InvalidValueType) as err:
5485             seq["whatever"] = Integer(123)
5486         repr(err.exception)
5487
5488     @given(booleans())
5489     def test_optional(self, optional):
5490         obj = self.base_klass(default=self.base_klass(), optional=optional)
5491         self.assertTrue(obj.optional)
5492
5493     @given(data_strategy())
5494     def test_ready(self, d):
5495         ready = {
5496             str(i): v for i, v in enumerate(d.draw(lists(
5497                 booleans(),
5498                 min_size=1,
5499                 max_size=3,
5500             )))
5501         }
5502         non_ready = {
5503             str(i + len(ready)): v for i, v in enumerate(d.draw(lists(
5504                 booleans(),
5505                 min_size=1,
5506                 max_size=3,
5507             )))
5508         }
5509         schema_input = []
5510         for name in d.draw(permutations(
5511                 list(ready.keys()) + list(non_ready.keys()),
5512         )):
5513             schema_input.append((name, Boolean()))
5514
5515         class Seq(self.base_klass):
5516             schema = tuple(schema_input)
5517         seq = Seq()
5518         for name in ready.keys():
5519             seq[name]
5520             seq[name] = Boolean()
5521         self.assertFalse(seq.ready)
5522         repr(seq)
5523         list(seq.pps())
5524         pprint(seq, big_blobs=True, with_decode_path=True)
5525         for name, value in ready.items():
5526             seq[name] = Boolean(value)
5527         self.assertFalse(seq.ready)
5528         repr(seq)
5529         list(seq.pps())
5530         pprint(seq, big_blobs=True, with_decode_path=True)
5531         with self.assertRaises(ObjNotReady) as err:
5532             seq.encode()
5533         repr(err.exception)
5534         for name, value in non_ready.items():
5535             seq[name] = Boolean(value)
5536         self.assertTrue(seq.ready)
5537         repr(seq)
5538         list(seq.pps())
5539         pprint(seq, big_blobs=True, with_decode_path=True)
5540
5541     @given(data_strategy())
5542     def test_call(self, d):
5543         class SeqInherited(self.base_klass):
5544             pass
5545         for klass in (self.base_klass, SeqInherited):
5546             (
5547                 value_initial,
5548                 schema_initial,
5549                 impl_initial,
5550                 expl_initial,
5551                 default_initial,
5552                 optional_initial,
5553                 _decoded_initial,
5554             ) = d.draw(seq_values_strategy(seq_klass=klass))
5555             obj_initial = klass(
5556                 value_initial,
5557                 schema_initial,
5558                 impl_initial,
5559                 expl_initial,
5560                 default_initial,
5561                 optional_initial or False,
5562                 _decoded_initial,
5563             )
5564             (
5565                 value,
5566                 _,
5567                 impl,
5568                 expl,
5569                 default,
5570                 optional,
5571                 _decoded,
5572             ) = d.draw(seq_values_strategy(
5573                 seq_klass=klass,
5574                 do_expl=impl_initial is None,
5575             ))
5576             obj = obj_initial(value, impl, expl, default, optional)
5577             value_expected = default if value is None else value
5578             value_expected = (
5579                 default_initial if value_expected is None
5580                 else value_expected
5581             )
5582             self.assertEqual(obj._value, getattr(value_expected, "_value", {}))
5583             self.assertEqual(obj.tag, impl or impl_initial or obj.tag_default)
5584             self.assertEqual(obj.expl_tag, expl or expl_initial)
5585             self.assertEqual(
5586                 {} if obj.default is None else obj.default._value,
5587                 getattr(default_initial if default is None else default, "_value", {}),
5588             )
5589             if obj.default is None:
5590                 optional = optional_initial if optional is None else optional
5591                 optional = False if optional is None else optional
5592             else:
5593                 optional = True
5594             self.assertEqual(list(obj.specs.items()), schema_initial or [])
5595             self.assertEqual(obj.optional, optional)
5596
5597     @given(data_strategy())
5598     def test_copy(self, d):
5599         class SeqInherited(self.base_klass):
5600             pass
5601         register_class(SeqInherited)
5602         for klass in (self.base_klass, SeqInherited):
5603             values = d.draw(seq_values_strategy(seq_klass=klass))
5604             obj = klass(*values)
5605             for copy_func in copy_funcs:
5606                 obj_copied = copy_func(obj)
5607                 self.assert_copied_basic_fields(obj, obj_copied)
5608                 self.assertEqual(obj.specs, obj_copied.specs)
5609                 self.assertEqual(obj._value, obj_copied._value)
5610
5611     @given(data_strategy())
5612     def test_stripped(self, d):
5613         value = d.draw(integers())
5614         tag_impl = tag_encode(d.draw(integers(min_value=1)))
5615
5616         class Seq(self.base_klass):
5617             impl = tag_impl
5618             schema = (("whatever", Integer()),)
5619         seq = Seq()
5620         seq["whatever"] = Integer(value)
5621         with self.assertRaises(NotEnoughData):
5622             seq.decode(seq.encode()[:-1])
5623
5624     @given(data_strategy())
5625     def test_stripped_expl(self, d):
5626         value = d.draw(integers())
5627         tag_expl = tag_ctxc(d.draw(integers(min_value=1)))
5628
5629         class Seq(self.base_klass):
5630             expl = tag_expl
5631             schema = (("whatever", Integer()),)
5632         seq = Seq()
5633         seq["whatever"] = Integer(value)
5634         with self.assertRaises(NotEnoughData):
5635             seq.decode(seq.encode()[:-1])
5636
5637     @given(binary(min_size=2))
5638     def test_non_tag_mismatch_raised(self, junk):
5639         try:
5640             _, _, len_encoded = tag_strip(memoryview(junk))
5641             len_decode(len_encoded)
5642         except Exception:
5643             assume(True)
5644         else:
5645             assume(False)
5646
5647         class Seq(self.base_klass):
5648             schema = (
5649                 ("whatever", Integer()),
5650                 ("junk", Any()),
5651                 ("whenever", Integer()),
5652             )
5653         seq = Seq()
5654         seq["whatever"] = Integer(123)
5655         seq["junk"] = Any(junk)
5656         seq["whenever"] = Integer(123)
5657         with self.assertRaises(DecodeError):
5658             seq.decode(seq.encode())
5659
5660     @given(
5661         integers(min_value=31),
5662         integers(min_value=0),
5663         decode_path_strat,
5664     )
5665     def test_bad_tag(self, tag, offset, decode_path):
5666         with self.assertRaises(DecodeError) as err:
5667             self.base_klass().decode(
5668                 tag_encode(tag)[:-1],
5669                 offset=offset,
5670                 decode_path=decode_path,
5671             )
5672         repr(err.exception)
5673         self.assertEqual(err.exception.offset, offset)
5674         self.assertEqual(err.exception.decode_path, decode_path)
5675
5676     @given(
5677         integers(min_value=128),
5678         integers(min_value=0),
5679         decode_path_strat,
5680     )
5681     def test_bad_len(self, l, offset, decode_path):
5682         with self.assertRaises(DecodeError) as err:
5683             self.base_klass().decode(
5684                 self.base_klass.tag_default + len_encode(l)[:-1],
5685                 offset=offset,
5686                 decode_path=decode_path,
5687             )
5688         repr(err.exception)
5689         self.assertEqual(err.exception.offset, offset)
5690         self.assertEqual(err.exception.decode_path, decode_path)
5691
5692     def _assert_expects(self, seq, expects):
5693         for expect in expects:
5694             self.assertEqual(
5695                 seq.specs[expect["name"]].optional,
5696                 expect["optional"],
5697             )
5698             if expect["default_value"] is not None:
5699                 self.assertEqual(
5700                     seq.specs[expect["name"]].default,
5701                     expect["default_value"],
5702                 )
5703             if expect["presented"]:
5704                 self.assertIn(expect["name"], seq)
5705                 self.assertEqual(seq[expect["name"]], expect["value"])
5706
5707     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
5708     @given(data_strategy())
5709     def test_symmetric(self, d):
5710         seq, expects = d.draw(sequence_strategy(seq_klass=self.base_klass))
5711         tail_junk = d.draw(binary(max_size=5))
5712         self.assertTrue(seq.ready)
5713         self.assertFalse(seq.decoded)
5714         self._assert_expects(seq, expects)
5715         repr(seq)
5716         list(seq.pps())
5717         pprint(seq, big_blobs=True, with_decode_path=True)
5718         self.assertTrue(seq.ready)
5719         seq_encoded = seq.encode()
5720         seq_decoded, tail = seq.decode(seq_encoded + tail_junk)
5721         self.assertFalse(seq_decoded.lenindef)
5722         self.assertFalse(seq_decoded.ber_encoded)
5723         self.assertFalse(seq_decoded.bered)
5724
5725         t, _, lv = tag_strip(seq_encoded)
5726         _, _, v = len_decode(lv)
5727         seq_encoded_lenindef = t + LENINDEF + v + EOC
5728         with self.assertRaises(DecodeError):
5729             seq.decode(seq_encoded_lenindef)
5730         ctx_copied = deepcopy(ctx_dummy)
5731         ctx_copied["bered"] = True
5732         seq_decoded_lenindef, tail_lenindef = seq.decode(
5733             seq_encoded_lenindef + tail_junk,
5734             ctx=ctx_copied,
5735         )
5736         del ctx_copied["bered"]
5737         self.assertDictEqual(ctx_copied, ctx_dummy)
5738         self.assertTrue(seq_decoded_lenindef.lenindef)
5739         self.assertTrue(seq_decoded_lenindef.bered)
5740         seq_decoded_lenindef = copy(seq_decoded_lenindef)
5741         self.assertTrue(seq_decoded_lenindef.lenindef)
5742         self.assertTrue(seq_decoded_lenindef.bered)
5743         with self.assertRaises(DecodeError):
5744             seq.decode(seq_encoded_lenindef[:-1], ctx={"bered": True})
5745         with self.assertRaises(DecodeError):
5746             seq.decode(seq_encoded_lenindef[:-2], ctx={"bered": True})
5747         repr(seq_decoded_lenindef)
5748         list(seq_decoded_lenindef.pps())
5749         pprint(seq_decoded_lenindef, big_blobs=True, with_decode_path=True)
5750         self.assertTrue(seq_decoded_lenindef.ready)
5751
5752         for decoded, decoded_tail, encoded in (
5753                 (seq_decoded, tail, seq_encoded),
5754                 (seq_decoded_lenindef, tail_lenindef, seq_encoded_lenindef),
5755         ):
5756             self.assertEqual(decoded_tail, tail_junk)
5757             self._assert_expects(decoded, expects)
5758             self.assertEqual(seq, decoded)
5759             self.assertEqual(decoded.encode(), seq_encoded)
5760             self.assertEqual(decoded.tlvlen, len(encoded))
5761             for expect in expects:
5762                 if not expect["presented"]:
5763                     self.assertNotIn(expect["name"], decoded)
5764                     continue
5765                 self.assertIn(expect["name"], decoded)
5766                 obj = decoded[expect["name"]]
5767                 self.assertTrue(obj.decoded)
5768                 offset = obj.expl_offset if obj.expled else obj.offset
5769                 tlvlen = obj.expl_tlvlen if obj.expled else obj.tlvlen
5770                 self.assertSequenceEqual(
5771                     seq_encoded[offset:offset + tlvlen],
5772                     obj.encode(),
5773                 )
5774
5775         assert_exceeding_data(
5776             self,
5777             lambda: seq.decod(seq_encoded_lenindef + tail_junk, ctx={"bered": True}),
5778             tail_junk,
5779         )
5780
5781     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
5782     @given(data_strategy())
5783     def test_symmetric_with_seq(self, d):
5784         seq, expect_outers = d.draw(sequences_strategy(seq_klass=self.base_klass))
5785         self.assertTrue(seq.ready)
5786         seq_encoded = seq.encode()
5787         seq_decoded, tail = seq.decode(seq_encoded)
5788         self.assertEqual(tail, b"")
5789         self.assertTrue(seq.ready)
5790         self.assertEqual(seq, seq_decoded)
5791         self.assertEqual(seq_decoded.encode(), seq_encoded)
5792         for expect_outer in expect_outers:
5793             if not expect_outer["presented"]:
5794                 self.assertNotIn(expect_outer["name"], seq_decoded)
5795                 continue
5796             self.assertIn(expect_outer["name"], seq_decoded)
5797             obj = seq_decoded[expect_outer["name"]]
5798             self.assertTrue(obj.decoded)
5799             offset = obj.expl_offset if obj.expled else obj.offset
5800             tlvlen = obj.expl_tlvlen if obj.expled else obj.tlvlen
5801             self.assertSequenceEqual(
5802                 seq_encoded[offset:offset + tlvlen],
5803                 obj.encode(),
5804             )
5805             self._assert_expects(obj, expect_outer["expects"])
5806
5807     @given(data_strategy())
5808     def test_default_disappears(self, d):
5809         _schema = list(d.draw(dictionaries(
5810             text_letters(),
5811             sets(integers(), min_size=2, max_size=2),
5812             min_size=1,
5813         )).items())
5814
5815         class Seq(self.base_klass):
5816             schema = [
5817                 (n, Integer(default=d))
5818                 for n, (_, d) in _schema
5819             ]
5820         seq = Seq()
5821         for name, (value, _) in _schema:
5822             seq[name] = Integer(value)
5823         self.assertEqual(len(seq._value), len(_schema))
5824         empty_seq = b"".join((self.base_klass.tag_default, len_encode(0)))
5825         self.assertGreater(len(seq.encode()), len(empty_seq))
5826         for name, (_, default) in _schema:
5827             seq[name] = Integer(default)
5828         self.assertEqual(len(seq._value), 0)
5829         self.assertSequenceEqual(seq.encode(), empty_seq)
5830
5831     @given(data_strategy())
5832     def test_encoded_default_not_accepted(self, d):
5833         _schema = list(d.draw(dictionaries(
5834             text_letters(),
5835             integers(),
5836             min_size=1,
5837         )).items())
5838         tags = [tag_encode(tag) for tag in d.draw(sets(
5839             integers(min_value=0),
5840             min_size=len(_schema),
5841             max_size=len(_schema),
5842         ))]
5843
5844         class SeqWithoutDefault(self.base_klass):
5845             schema = [
5846                 (n, Integer(impl=t))
5847                 for (n, _), t in zip(_schema, tags)
5848             ]
5849         seq_without_default = SeqWithoutDefault()
5850         for name, value in _schema:
5851             seq_without_default[name] = Integer(value)
5852         seq_encoded = seq_without_default.encode()
5853
5854         class SeqWithDefault(self.base_klass):
5855             schema = [
5856                 (n, Integer(default=v, impl=t))
5857                 for (n, v), t in zip(_schema, tags)
5858             ]
5859         seq_with_default = SeqWithDefault()
5860         with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
5861             seq_with_default.decode(seq_encoded)
5862         for ctx in ({"bered": True}, {"allow_default_values": True}):
5863             seq_decoded, _ = seq_with_default.decode(seq_encoded, ctx=ctx)
5864             self.assertTrue(seq_decoded.ber_encoded)
5865             self.assertTrue(seq_decoded.bered)
5866             seq_decoded = copy(seq_decoded)
5867             self.assertTrue(seq_decoded.ber_encoded)
5868             self.assertTrue(seq_decoded.bered)
5869             for name, value in _schema:
5870                 self.assertEqual(seq_decoded[name], seq_with_default[name])
5871                 self.assertEqual(seq_decoded[name], value)
5872
5873     @given(data_strategy())
5874     def test_missing_from_spec(self, d):
5875         names = list(d.draw(sets(text_letters(), min_size=2)))
5876         tags = [tag_encode(tag) for tag in d.draw(sets(
5877             integers(min_value=0),
5878             min_size=len(names),
5879             max_size=len(names),
5880         ))]
5881         names_tags = [(name, tag) for tag, name in sorted(zip(tags, names))]
5882
5883         class SeqFull(self.base_klass):
5884             schema = [(n, Integer(impl=t)) for n, t in names_tags]
5885         seq_full = SeqFull()
5886         for i, name in enumerate(names):
5887             seq_full[name] = Integer(i)
5888         seq_encoded = seq_full.encode()
5889         altered = names_tags[:-2] + names_tags[-1:]
5890
5891         class SeqMissing(self.base_klass):
5892             schema = [(n, Integer(impl=t)) for n, t in altered]
5893         seq_missing = SeqMissing()
5894         with self.assertRaises(TagMismatch):
5895             seq_missing.decode(seq_encoded)
5896
5897     def test_bered(self):
5898         class Seq(self.base_klass):
5899             schema = (("underlying", Boolean()),)
5900         encoded = Boolean.tag_default + len_encode(1) + b"\x01"
5901         encoded = Seq.tag_default + len_encode(len(encoded)) + encoded
5902         decoded, _ = Seq().decode(encoded, ctx={"bered": True})
5903         self.assertFalse(decoded.ber_encoded)
5904         self.assertFalse(decoded.lenindef)
5905         self.assertTrue(decoded.bered)
5906         decoded = copy(decoded)
5907         self.assertFalse(decoded.ber_encoded)
5908         self.assertFalse(decoded.lenindef)
5909         self.assertTrue(decoded.bered)
5910
5911         class Seq(self.base_klass):
5912             schema = (("underlying", OctetString()),)
5913         encoded = (
5914             tag_encode(form=TagFormConstructed, num=4) +
5915             LENINDEF +
5916             OctetString(b"whatever").encode() +
5917             EOC
5918         )
5919         encoded = Seq.tag_default + len_encode(len(encoded)) + encoded
5920         with self.assertRaises(DecodeError):
5921             Seq().decode(encoded)
5922         decoded, _ = Seq().decode(encoded, ctx={"bered": True})
5923         self.assertFalse(decoded.ber_encoded)
5924         self.assertFalse(decoded.lenindef)
5925         self.assertTrue(decoded.bered)
5926         decoded = copy(decoded)
5927         self.assertFalse(decoded.ber_encoded)
5928         self.assertFalse(decoded.lenindef)
5929         self.assertTrue(decoded.bered)
5930
5931
5932 class TestSequence(SeqMixing, CommonMixin, TestCase):
5933     base_klass = Sequence
5934
5935     @given(
5936         integers(),
5937         binary(min_size=1),
5938     )
5939     def test_remaining(self, value, junk):
5940         class Seq(Sequence):
5941             schema = (
5942                 ("whatever", Integer()),
5943             )
5944         int_encoded = Integer(value).encode()
5945         junked = b"".join((
5946             Sequence.tag_default,
5947             len_encode(len(int_encoded + junk)),
5948             int_encoded + junk,
5949         ))
5950         with assertRaisesRegex(self, DecodeError, "remaining"):
5951             Seq().decode(junked)
5952
5953     @given(sets(text_letters(), min_size=2))
5954     def test_obj_unknown(self, names):
5955         missing = names.pop()
5956
5957         class Seq(Sequence):
5958             schema = [(n, Boolean()) for n in names]
5959         seq = Seq()
5960         with self.assertRaises(ObjUnknown) as err:
5961             seq[missing]
5962         repr(err.exception)
5963         with self.assertRaises(ObjUnknown) as err:
5964             seq[missing] = Boolean()
5965         repr(err.exception)
5966
5967     def test_x690_vector(self):
5968         class Seq(Sequence):
5969             schema = (
5970                 ("name", IA5String()),
5971                 ("ok", Boolean()),
5972             )
5973         seq = Seq().decode(hexdec("300A1605536d6974680101FF"))[0]
5974         self.assertEqual(seq["name"], "Smith")
5975         self.assertEqual(seq["ok"], True)
5976
5977
5978 class TestSet(SeqMixing, CommonMixin, TestCase):
5979     base_klass = Set
5980
5981     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
5982     @given(data_strategy())
5983     def test_sorted(self, d):
5984         tags = [
5985             tag_encode(tag) for tag in
5986             d.draw(sets(integers(min_value=1), min_size=1, max_size=10))
5987         ]
5988
5989         class Seq(Set):
5990             schema = [(str(i), OctetString(impl=t)) for i, t in enumerate(tags)]
5991         seq = Seq()
5992         for name, _ in Seq.schema:
5993             seq[name] = OctetString(b"")
5994         seq_encoded = seq.encode()
5995         seq_decoded, _ = seq.decode(seq_encoded)
5996         self.assertSequenceEqual(
5997             seq_encoded[seq_decoded.tlen + seq_decoded.llen:],
5998             b"".join(sorted([seq[name].encode() for name, _ in Seq.schema])),
5999         )
6000
6001     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
6002     @given(data_strategy())
6003     def test_unsorted(self, d):
6004         tags = [
6005             tag_encode(tag) for tag in
6006             d.draw(sets(integers(min_value=1), min_size=2, max_size=5))
6007         ]
6008         tags = d.draw(permutations(tags))
6009         assume(tags != sorted(tags))
6010         encoded = b"".join(OctetString(t, impl=t).encode() for t in tags)
6011         seq_encoded = b"".join((
6012             Set.tag_default,
6013             len_encode(len(encoded)),
6014             encoded,
6015         ))
6016
6017         class Seq(Set):
6018             schema = [(str(i), OctetString(impl=t)) for i, t in enumerate(tags)]
6019         seq = Seq()
6020         with assertRaisesRegex(self, DecodeError, "unordered SET"):
6021             seq.decode(seq_encoded)
6022         for ctx in ({"bered": True}, {"allow_unordered_set": True}):
6023             seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
6024             self.assertTrue(seq_decoded.ber_encoded)
6025             self.assertTrue(seq_decoded.bered)
6026             seq_decoded = copy(seq_decoded)
6027             self.assertTrue(seq_decoded.ber_encoded)
6028             self.assertTrue(seq_decoded.bered)
6029             self.assertSequenceEqual(
6030                 [bytes(seq_decoded[str(i)]) for i, t in enumerate(tags)],
6031                 tags,
6032             )
6033
6034
6035 @composite
6036 def seqof_values_strategy(draw, schema=None, do_expl=False):
6037     if schema is None:
6038         schema = draw(sampled_from((Boolean(), Integer())))
6039     bound_min, bound_max = sorted(draw(sets(
6040         integers(min_value=0, max_value=10),
6041         min_size=2,
6042         max_size=2,
6043     )))
6044     if isinstance(schema, Boolean):
6045         values_generator = booleans().map(Boolean)
6046     elif isinstance(schema, Integer):
6047         values_generator = integers().map(Integer)
6048     values_generator = lists(
6049         values_generator,
6050         min_size=bound_min,
6051         max_size=bound_max,
6052     )
6053     values = draw(one_of(none(), values_generator))
6054     impl = None
6055     expl = None
6056     if do_expl:
6057         expl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
6058     else:
6059         impl = draw(one_of(none(), integers(min_value=1).map(tag_encode)))
6060     default = draw(one_of(none(), values_generator))
6061     optional = draw(one_of(none(), booleans()))
6062     _decoded = (
6063         draw(integers(min_value=0)),
6064         draw(integers(min_value=0)),
6065         draw(integers(min_value=0)),
6066     )
6067     return (
6068         schema,
6069         values,
6070         (bound_min, bound_max),
6071         impl,
6072         expl,
6073         default,
6074         optional,
6075         _decoded,
6076     )
6077
6078
6079 class SeqOfMixing(object):
6080     def test_invalid_value_type(self):
6081         with self.assertRaises(InvalidValueType) as err:
6082             self.base_klass(123)
6083         repr(err.exception)
6084
6085     def test_invalid_values_type(self):
6086         class SeqOf(self.base_klass):
6087             schema = Integer()
6088         with self.assertRaises(InvalidValueType) as err:
6089             SeqOf([Integer(123), Boolean(False), Integer(234)])
6090         repr(err.exception)
6091
6092     def test_schema_required(self):
6093         with assertRaisesRegex(self, ValueError, "schema must be specified"):
6094             self.base_klass.__mro__[1]()
6095
6096     @given(booleans(), booleans(), binary(), binary())
6097     def test_comparison(self, value1, value2, tag1, tag2):
6098         class SeqOf(self.base_klass):
6099             schema = Boolean()
6100         obj1 = SeqOf([Boolean(value1)])
6101         obj2 = SeqOf([Boolean(value2)])
6102         self.assertEqual(obj1 == obj2, value1 == value2)
6103         self.assertEqual(obj1 != obj2, value1 != value2)
6104         self.assertEqual(obj1 == list(obj2), value1 == value2)
6105         self.assertEqual(obj1 == tuple(obj2), value1 == value2)
6106         obj1 = SeqOf([Boolean(value1)], impl=tag1)
6107         obj2 = SeqOf([Boolean(value1)], impl=tag2)
6108         self.assertEqual(obj1 == obj2, tag1 == tag2)
6109         self.assertEqual(obj1 != obj2, tag1 != tag2)
6110
6111     @given(lists(booleans()))
6112     def test_iter(self, values):
6113         class SeqOf(self.base_klass):
6114             schema = Boolean()
6115         obj = SeqOf([Boolean(value) for value in values])
6116         self.assertEqual(len(obj), len(values))
6117         for i, value in enumerate(obj):
6118             self.assertEqual(value, values[i])
6119
6120     @given(data_strategy())
6121     def test_ready(self, d):
6122         ready = [Integer(v) for v in d.draw(lists(
6123             integers(),
6124             min_size=1,
6125             max_size=3,
6126         ))]
6127         non_ready = [
6128             Integer() for _ in
6129             range(d.draw(integers(min_value=1, max_value=5)))
6130         ]
6131
6132         class SeqOf(self.base_klass):
6133             schema = Integer()
6134         values = d.draw(permutations(ready + non_ready))
6135         seqof = SeqOf()
6136         for value in values:
6137             seqof.append(value)
6138         self.assertFalse(seqof.ready)
6139         repr(seqof)
6140         list(seqof.pps())
6141         pprint(seqof, big_blobs=True, with_decode_path=True)
6142         with self.assertRaises(ObjNotReady) as err:
6143             seqof.encode()
6144         repr(err.exception)
6145         for i, value in enumerate(values):
6146             self.assertEqual(seqof[i], value)
6147             if not seqof[i].ready:
6148                 seqof[i] = Integer(i)
6149         self.assertTrue(seqof.ready)
6150         repr(seqof)
6151         list(seqof.pps())
6152         pprint(seqof, big_blobs=True, with_decode_path=True)
6153
6154     def test_spec_mismatch(self):
6155         class SeqOf(self.base_klass):
6156             schema = Integer()
6157         seqof = SeqOf()
6158         seqof.append(Integer(123))
6159         with self.assertRaises(ValueError):
6160             seqof.append(Boolean(False))
6161         with self.assertRaises(ValueError):
6162             seqof[0] = Boolean(False)
6163
6164     @given(data_strategy())
6165     def test_bounds_satisfied(self, d):
6166         class SeqOf(self.base_klass):
6167             schema = Boolean()
6168         bound_min = d.draw(integers(min_value=0, max_value=1 << 7))
6169         bound_max = d.draw(integers(min_value=bound_min, max_value=1 << 7))
6170         value = [Boolean()] * d.draw(integers(min_value=bound_min, max_value=bound_max))
6171         SeqOf(value=value, bounds=(bound_min, bound_max))
6172
6173     @given(data_strategy())
6174     def test_bounds_unsatisfied(self, d):
6175         class SeqOf(self.base_klass):
6176             schema = Boolean()
6177         bound_min = d.draw(integers(min_value=1, max_value=1 << 7))
6178         bound_max = d.draw(integers(min_value=bound_min, max_value=1 << 7))
6179         value = [Boolean(False)] * d.draw(integers(max_value=bound_min - 1))
6180         with self.assertRaises(BoundsError) as err:
6181             SeqOf(value=value, bounds=(bound_min, bound_max))
6182         repr(err.exception)
6183         with assertRaisesRegex(self, DecodeError, "bounds") as err:
6184             SeqOf(bounds=(bound_min, bound_max)).decode(
6185                 SeqOf(value).encode()
6186             )
6187         repr(err.exception)
6188         value = [Boolean(True)] * d.draw(integers(
6189             min_value=bound_max + 1,
6190             max_value=bound_max + 10,
6191         ))
6192         with self.assertRaises(BoundsError) as err:
6193             SeqOf(value=value, bounds=(bound_min, bound_max))
6194         repr(err.exception)
6195         with assertRaisesRegex(self, DecodeError, "bounds") as err:
6196             SeqOf(bounds=(bound_min, bound_max)).decode(
6197                 SeqOf(value).encode()
6198             )
6199         repr(err.exception)
6200
6201     @given(integers(min_value=1, max_value=10))
6202     def test_out_of_bounds(self, bound_max):
6203         class SeqOf(self.base_klass):
6204             schema = Integer()
6205             bounds = (0, bound_max)
6206         seqof = SeqOf()
6207         for _ in range(bound_max):
6208             seqof.append(Integer(123))
6209         with self.assertRaises(BoundsError):
6210             seqof.append(Integer(123))
6211
6212     @given(data_strategy())
6213     def test_call(self, d):
6214         (
6215             schema_initial,
6216             value_initial,
6217             bounds_initial,
6218             impl_initial,
6219             expl_initial,
6220             default_initial,
6221             optional_initial,
6222             _decoded_initial,
6223         ) = d.draw(seqof_values_strategy())
6224
6225         class SeqOf(self.base_klass):
6226             schema = schema_initial
6227         obj_initial = SeqOf(
6228             value=value_initial,
6229             bounds=bounds_initial,
6230             impl=impl_initial,
6231             expl=expl_initial,
6232             default=default_initial,
6233             optional=optional_initial or False,
6234             _decoded=_decoded_initial,
6235         )
6236         (
6237             _,
6238             value,
6239             bounds,
6240             impl,
6241             expl,
6242             default,
6243             optional,
6244             _decoded,
6245         ) = d.draw(seqof_values_strategy(
6246             schema=schema_initial,
6247             do_expl=impl_initial is None,
6248         ))
6249         if (default is None) and (obj_initial.default is not None):
6250             bounds = None
6251         if (
6252                 (bounds is None) and
6253                 (value is not None) and
6254                 (bounds_initial is not None) and
6255                 not (bounds_initial[0] <= len(value) <= bounds_initial[1])
6256         ):
6257             value = None
6258         if (
6259                 (bounds is None) and
6260                 (default is not None) and
6261                 (bounds_initial is not None) and
6262                 not (bounds_initial[0] <= len(default) <= bounds_initial[1])
6263         ):
6264             default = None
6265         obj = obj_initial(
6266             value=value,
6267             bounds=bounds,
6268             impl=impl,
6269             expl=expl,
6270             default=default,
6271             optional=optional,
6272         )
6273         if obj.ready:
6274             value_expected = default if value is None else value
6275             value_expected = (
6276                 default_initial if value_expected is None
6277                 else value_expected
6278             )
6279             value_expected = () if value_expected is None else value_expected
6280             self.assertEqual(obj, value_expected)
6281         self.assertEqual(obj.tag, impl or impl_initial or obj.tag_default)
6282         self.assertEqual(obj.expl_tag, expl or expl_initial)
6283         self.assertEqual(
6284             obj.default,
6285             default_initial if default is None else default,
6286         )
6287         if obj.default is None:
6288             optional = optional_initial if optional is None else optional
6289             optional = False if optional is None else optional
6290         else:
6291             optional = True
6292         self.assertEqual(obj.optional, optional)
6293         self.assertEqual(
6294             (obj._bound_min, obj._bound_max),
6295             bounds or bounds_initial or (0, float("+inf")),
6296         )
6297
6298     @given(seqof_values_strategy())
6299     def test_copy(self, values):
6300         _schema, value, bounds, impl, expl, default, optional, _decoded = values
6301
6302         class SeqOf(self.base_klass):
6303             schema = _schema
6304         register_class(SeqOf)
6305         obj = SeqOf(
6306             value=value,
6307             bounds=bounds,
6308             impl=impl,
6309             expl=expl,
6310             default=default,
6311             optional=optional or False,
6312             _decoded=_decoded,
6313         )
6314         for copy_func in copy_funcs:
6315             obj_copied = copy_func(obj)
6316             self.assert_copied_basic_fields(obj, obj_copied)
6317             self.assertEqual(obj._bound_min, obj_copied._bound_min)
6318             self.assertEqual(obj._bound_max, obj_copied._bound_max)
6319             self.assertEqual(obj._value, obj_copied._value)
6320
6321     @given(
6322         lists(binary()),
6323         integers(min_value=1).map(tag_encode),
6324     )
6325     def test_stripped(self, values, tag_impl):
6326         class SeqOf(self.base_klass):
6327             schema = OctetString()
6328         obj = SeqOf([OctetString(v) for v in values], impl=tag_impl)
6329         with self.assertRaises(NotEnoughData):
6330             obj.decode(obj.encode()[:-1])
6331
6332     @given(
6333         lists(binary()),
6334         integers(min_value=1).map(tag_ctxc),
6335     )
6336     def test_stripped_expl(self, values, tag_expl):
6337         class SeqOf(self.base_klass):
6338             schema = OctetString()
6339         obj = SeqOf([OctetString(v) for v in values], expl=tag_expl)
6340         with self.assertRaises(NotEnoughData):
6341             obj.decode(obj.encode()[:-1])
6342
6343     @given(
6344         integers(min_value=31),
6345         integers(min_value=0),
6346         decode_path_strat,
6347     )
6348     def test_bad_tag(self, tag, offset, decode_path):
6349         with self.assertRaises(DecodeError) as err:
6350             self.base_klass().decode(
6351                 tag_encode(tag)[:-1],
6352                 offset=offset,
6353                 decode_path=decode_path,
6354             )
6355         repr(err.exception)
6356         self.assertEqual(err.exception.offset, offset)
6357         self.assertEqual(err.exception.decode_path, decode_path)
6358
6359     @given(
6360         integers(min_value=128),
6361         integers(min_value=0),
6362         decode_path_strat,
6363     )
6364     def test_bad_len(self, l, offset, decode_path):
6365         with self.assertRaises(DecodeError) as err:
6366             self.base_klass().decode(
6367                 self.base_klass.tag_default + len_encode(l)[:-1],
6368                 offset=offset,
6369                 decode_path=decode_path,
6370             )
6371         repr(err.exception)
6372         self.assertEqual(err.exception.offset, offset)
6373         self.assertEqual(err.exception.decode_path, decode_path)
6374
6375     @given(binary(min_size=1))
6376     def test_tag_mismatch(self, impl):
6377         assume(impl != self.base_klass.tag_default)
6378         with self.assertRaises(TagMismatch):
6379             self.base_klass(impl=impl).decode(self.base_klass().encode())
6380
6381     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
6382     @given(
6383         seqof_values_strategy(schema=Integer()),
6384         lists(integers().map(Integer)),
6385         integers(min_value=1).map(tag_ctxc),
6386         integers(min_value=0),
6387         binary(max_size=5),
6388     )
6389     def test_symmetric(self, values, value, tag_expl, offset, tail_junk):
6390         _, _, _, _, _, default, optional, _decoded = values
6391
6392         class SeqOf(self.base_klass):
6393             schema = Integer()
6394         obj = SeqOf(
6395             value=value,
6396             default=default,
6397             optional=optional,
6398             _decoded=_decoded,
6399         )
6400         repr(obj)
6401         list(obj.pps())
6402         pprint(obj, big_blobs=True, with_decode_path=True)
6403         self.assertFalse(obj.expled)
6404         obj_encoded = obj.encode()
6405         obj_expled = obj(value, expl=tag_expl)
6406         self.assertTrue(obj_expled.expled)
6407         repr(obj_expled)
6408         list(obj_expled.pps())
6409         pprint(obj_expled, big_blobs=True, with_decode_path=True)
6410         obj_expled_encoded = obj_expled.encode()
6411         ctx_copied = deepcopy(ctx_dummy)
6412         obj_decoded, tail = obj_expled.decode(
6413             obj_expled_encoded + tail_junk,
6414             offset=offset,
6415             ctx=ctx_copied,
6416         )
6417         self.assertDictEqual(ctx_copied, ctx_dummy)
6418         repr(obj_decoded)
6419         list(obj_decoded.pps())
6420         pprint(obj_decoded, big_blobs=True, with_decode_path=True)
6421         self.assertEqual(tail, tail_junk)
6422         self._test_symmetric_compare_objs(obj_decoded, obj_expled)
6423         self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
6424         self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
6425         self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
6426         self.assertEqual(
6427             obj_decoded.expl_llen,
6428             len(len_encode(len(obj_encoded))),
6429         )
6430         self.assertEqual(obj_decoded.tlvlen, len(obj_encoded))
6431         self.assertEqual(obj_decoded.expl_vlen, len(obj_encoded))
6432         self.assertEqual(
6433             obj_decoded.offset,
6434             offset + obj_decoded.expl_tlen + obj_decoded.expl_llen,
6435         )
6436         self.assertEqual(obj_decoded.expl_offset, offset)
6437         for obj_inner in obj_decoded:
6438             self.assertIn(obj_inner, obj_decoded)
6439             self.assertSequenceEqual(
6440                 obj_inner.encode(),
6441                 obj_expled_encoded[
6442                     obj_inner.offset - offset:
6443                     obj_inner.offset + obj_inner.tlvlen - offset
6444                 ],
6445             )
6446
6447         t, _, lv = tag_strip(obj_encoded)
6448         _, _, v = len_decode(lv)
6449         obj_encoded_lenindef = t + LENINDEF + v + EOC
6450         with self.assertRaises(DecodeError):
6451             obj.decode(obj_encoded_lenindef)
6452         obj_decoded_lenindef, tail_lenindef = obj.decode(
6453             obj_encoded_lenindef + tail_junk,
6454             ctx={"bered": True},
6455         )
6456         self.assertTrue(obj_decoded_lenindef.lenindef)
6457         self.assertTrue(obj_decoded_lenindef.bered)
6458         obj_decoded_lenindef = copy(obj_decoded_lenindef)
6459         self.assertTrue(obj_decoded_lenindef.lenindef)
6460         self.assertTrue(obj_decoded_lenindef.bered)
6461         repr(obj_decoded_lenindef)
6462         list(obj_decoded_lenindef.pps())
6463         pprint(obj_decoded_lenindef, big_blobs=True, with_decode_path=True)
6464         self.assertEqual(tail_lenindef, tail_junk)
6465         self.assertEqual(obj_decoded_lenindef.tlvlen, len(obj_encoded_lenindef))
6466         with self.assertRaises(DecodeError):
6467             obj.decode(obj_encoded_lenindef[:-1], ctx={"bered": True})
6468         with self.assertRaises(DecodeError):
6469             obj.decode(obj_encoded_lenindef[:-2], ctx={"bered": True})
6470
6471         assert_exceeding_data(
6472             self,
6473             lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
6474             tail_junk,
6475         )
6476
6477     def test_bered(self):
6478         class SeqOf(self.base_klass):
6479             schema = Boolean()
6480         encoded = Boolean(False).encode()
6481         encoded += Boolean.tag_default + len_encode(1) + b"\x01"
6482         encoded = SeqOf.tag_default + len_encode(len(encoded)) + encoded
6483         with self.assertRaises(DecodeError):
6484             SeqOf().decode(encoded)
6485         decoded, _ = SeqOf().decode(encoded, ctx={"bered": True})
6486         self.assertFalse(decoded.ber_encoded)
6487         self.assertFalse(decoded.lenindef)
6488         self.assertTrue(decoded.bered)
6489         decoded = copy(decoded)
6490         self.assertFalse(decoded.ber_encoded)
6491         self.assertFalse(decoded.lenindef)
6492         self.assertTrue(decoded.bered)
6493
6494         class SeqOf(self.base_klass):
6495             schema = OctetString()
6496         encoded = OctetString(b"whatever").encode()
6497         encoded += (
6498             tag_encode(form=TagFormConstructed, num=4) +
6499             LENINDEF +
6500             OctetString(b"whatever").encode() +
6501             EOC
6502         )
6503         encoded = SeqOf.tag_default + len_encode(len(encoded)) + encoded
6504         with self.assertRaises(DecodeError):
6505             SeqOf().decode(encoded)
6506         decoded, _ = SeqOf().decode(encoded, ctx={"bered": True})
6507         self.assertFalse(decoded.ber_encoded)
6508         self.assertFalse(decoded.lenindef)
6509         self.assertTrue(decoded.bered)
6510         decoded = copy(decoded)
6511         self.assertFalse(decoded.ber_encoded)
6512         self.assertFalse(decoded.lenindef)
6513         self.assertTrue(decoded.bered)
6514
6515
6516 class TestSequenceOf(SeqOfMixing, CommonMixin, TestCase):
6517     class SeqOf(SequenceOf):
6518         schema = "whatever"
6519     base_klass = SeqOf
6520
6521     def _test_symmetric_compare_objs(self, obj1, obj2):
6522         self.assertEqual(obj1, obj2)
6523         self.assertSequenceEqual(list(obj1), list(obj2))
6524
6525
6526 class TestSetOf(SeqOfMixing, CommonMixin, TestCase):
6527     class SeqOf(SetOf):
6528         schema = "whatever"
6529     base_klass = SeqOf
6530
6531     def _test_symmetric_compare_objs(self, obj1, obj2):
6532         self.assertSetEqual(
6533             set(int(v) for v in obj1),
6534             set(int(v) for v in obj2),
6535         )
6536
6537     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
6538     @given(data_strategy())
6539     def test_sorted(self, d):
6540         values = [OctetString(v) for v in d.draw(lists(binary()))]
6541
6542         class Seq(SetOf):
6543             schema = OctetString()
6544         seq = Seq(values)
6545         seq_encoded = seq.encode()
6546         seq_decoded, _ = seq.decode(seq_encoded)
6547         self.assertSequenceEqual(
6548             seq_encoded[seq_decoded.tlen + seq_decoded.llen:],
6549             b"".join(sorted([v.encode() for v in values])),
6550         )
6551
6552     @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
6553     @given(data_strategy())
6554     def test_unsorted(self, d):
6555         values = [OctetString(v).encode() for v in d.draw(sets(
6556             binary(min_size=1, max_size=5),
6557             min_size=2,
6558             max_size=5,
6559         ))]
6560         values = d.draw(permutations(values))
6561         assume(values != sorted(values))
6562         encoded = b"".join(values)
6563         seq_encoded = b"".join((
6564             SetOf.tag_default,
6565             len_encode(len(encoded)),
6566             encoded,
6567         ))
6568
6569         class Seq(SetOf):
6570             schema = OctetString()
6571         seq = Seq()
6572         with assertRaisesRegex(self, DecodeError, "unordered SET OF"):
6573             seq.decode(seq_encoded)
6574
6575         for ctx in ({"bered": True}, {"allow_unordered_set": True}):
6576             seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
6577             self.assertTrue(seq_decoded.ber_encoded)
6578             self.assertTrue(seq_decoded.bered)
6579             seq_decoded = copy(seq_decoded)
6580             self.assertTrue(seq_decoded.ber_encoded)
6581             self.assertTrue(seq_decoded.bered)
6582             self.assertSequenceEqual(
6583                 [obj.encode() for obj in seq_decoded],
6584                 values,
6585             )
6586
6587
6588 class TestGoMarshalVectors(TestCase):
6589     def runTest(self):
6590         self.assertSequenceEqual(Integer(10).encode(), hexdec("02010a"))
6591         self.assertSequenceEqual(Integer(127).encode(), hexdec("02017f"))
6592         self.assertSequenceEqual(Integer(128).encode(), hexdec("02020080"))
6593         self.assertSequenceEqual(Integer(-128).encode(), hexdec("020180"))
6594         self.assertSequenceEqual(Integer(-129).encode(), hexdec("0202ff7f"))
6595
6596         class Seq(Sequence):
6597             schema = (
6598                 ("erste", Integer()),
6599                 ("zweite", Integer(optional=True))
6600             )
6601         seq = Seq()
6602         seq["erste"] = Integer(64)
6603         self.assertSequenceEqual(seq.encode(), hexdec("3003020140"))
6604         seq["erste"] = Integer(0x123456)
6605         self.assertSequenceEqual(seq.encode(), hexdec("30050203123456"))
6606         seq["erste"] = Integer(64)
6607         seq["zweite"] = Integer(65)
6608         self.assertSequenceEqual(seq.encode(), hexdec("3006020140020141"))
6609
6610         class NestedSeq(Sequence):
6611             schema = (
6612                 ("nest", Seq()),
6613             )
6614         seq["erste"] = Integer(127)
6615         seq["zweite"] = None
6616         nested = NestedSeq()
6617         nested["nest"] = seq
6618         self.assertSequenceEqual(nested.encode(), hexdec("3005300302017f"))
6619
6620         self.assertSequenceEqual(
6621             OctetString(b"\x01\x02\x03").encode(),
6622             hexdec("0403010203"),
6623         )
6624
6625         class Seq(Sequence):
6626             schema = (
6627                 ("erste", Integer(impl=tag_encode(5, klass=TagClassContext))),
6628             )
6629         seq = Seq()
6630         seq["erste"] = Integer(64)
6631         self.assertSequenceEqual(seq.encode(), hexdec("3003850140"))
6632
6633         class Seq(Sequence):
6634             schema = (
6635                 ("erste", Integer(expl=tag_ctxc(5))),
6636             )
6637         seq = Seq()
6638         seq["erste"] = Integer(64)
6639         self.assertSequenceEqual(seq.encode(), hexdec("3005a503020140"))
6640
6641         class Seq(Sequence):
6642             schema = (
6643                 ("erste", Null(
6644                     impl=tag_encode(0, klass=TagClassContext),
6645                     optional=True,
6646                 )),
6647             )
6648         seq = Seq()
6649         seq["erste"] = Null()
6650         self.assertSequenceEqual(seq.encode(), hexdec("30028000"))
6651         seq["erste"] = None
6652         self.assertSequenceEqual(seq.encode(), hexdec("3000"))
6653
6654         self.assertSequenceEqual(
6655             UTCTime(datetime(1970, 1, 1, 0, 0)).encode(),
6656             hexdec("170d3730303130313030303030305a"),
6657         )
6658         self.assertSequenceEqual(
6659             UTCTime(datetime(2009, 11, 15, 22, 56, 16)).encode(),
6660             hexdec("170d3039313131353232353631365a"),
6661         )
6662         self.assertSequenceEqual(
6663             GeneralizedTime(datetime(2100, 4, 5, 12, 1, 1)).encode(),
6664             hexdec("180f32313030303430353132303130315a"),
6665         )
6666
6667         class Seq(Sequence):
6668             schema = (
6669                 ("erste", GeneralizedTime()),
6670             )
6671         seq = Seq()
6672         seq["erste"] = GeneralizedTime(datetime(2009, 11, 15, 22, 56, 16))
6673         self.assertSequenceEqual(
6674             seq.encode(),
6675             hexdec("3011180f32303039313131353232353631365a"),
6676         )
6677
6678         self.assertSequenceEqual(
6679             BitString((1, b"\x80")).encode(),
6680             hexdec("03020780"),
6681         )
6682         self.assertSequenceEqual(
6683             BitString((12, b"\x81\xF0")).encode(),
6684             hexdec("03030481f0"),
6685         )
6686
6687         self.assertSequenceEqual(
6688             ObjectIdentifier("1.2.3.4").encode(),
6689             hexdec("06032a0304"),
6690         )
6691         self.assertSequenceEqual(
6692             ObjectIdentifier("1.2.840.133549.1.1.5").encode(),
6693             hexdec("06092a864888932d010105"),
6694         )
6695         self.assertSequenceEqual(
6696             ObjectIdentifier("2.100.3").encode(),
6697             hexdec("0603813403"),
6698         )
6699
6700         self.assertSequenceEqual(
6701             PrintableString("test").encode(),
6702             hexdec("130474657374"),
6703         )
6704         self.assertSequenceEqual(
6705             PrintableString("x" * 127).encode(),
6706             hexdec("137F" + "78" * 127),
6707         )
6708         self.assertSequenceEqual(
6709             PrintableString("x" * 128).encode(),
6710             hexdec("138180" + "78" * 128),
6711         )
6712         self.assertSequenceEqual(UTF8String("Σ").encode(), hexdec("0c02cea3"))
6713
6714         class Seq(Sequence):
6715             schema = (
6716                 ("erste", IA5String()),
6717             )
6718         seq = Seq()
6719         seq["erste"] = IA5String("test")
6720         self.assertSequenceEqual(seq.encode(), hexdec("3006160474657374"))
6721
6722         class Seq(Sequence):
6723             schema = (
6724                 ("erste", PrintableString()),
6725             )
6726         seq = Seq()
6727         seq["erste"] = PrintableString("test")
6728         self.assertSequenceEqual(seq.encode(), hexdec("3006130474657374"))
6729         # Asterisk is actually not allowable
6730         PrintableString._allowable_chars |= set(b"*")
6731         seq["erste"] = PrintableString("test*")
6732         self.assertSequenceEqual(seq.encode(), hexdec("30071305746573742a"))
6733         PrintableString._allowable_chars -= set(b"*")
6734
6735         class Seq(Sequence):
6736             schema = (
6737                 ("erste", Any(optional=True)),
6738                 ("zweite", Integer()),
6739             )
6740         seq = Seq()
6741         seq["zweite"] = Integer(64)
6742         self.assertSequenceEqual(seq.encode(), hexdec("3003020140"))
6743
6744         class Seq(SetOf):
6745             schema = Integer()
6746         seq = Seq()
6747         seq.append(Integer(10))
6748         self.assertSequenceEqual(seq.encode(), hexdec("310302010a"))
6749
6750         class _SeqOf(SequenceOf):
6751             schema = PrintableString()
6752
6753         class SeqOf(SequenceOf):
6754             schema = _SeqOf()
6755         _seqof = _SeqOf()
6756         _seqof.append(PrintableString("1"))
6757         seqof = SeqOf()
6758         seqof.append(_seqof)
6759         self.assertSequenceEqual(seqof.encode(), hexdec("30053003130131"))
6760
6761         class Seq(Sequence):
6762             schema = (
6763                 ("erste", Integer(default=1)),
6764             )
6765         seq = Seq()
6766         seq["erste"] = Integer(0)
6767         self.assertSequenceEqual(seq.encode(), hexdec("3003020100"))
6768         seq["erste"] = Integer(1)
6769         self.assertSequenceEqual(seq.encode(), hexdec("3000"))
6770         seq["erste"] = Integer(2)
6771         self.assertSequenceEqual(seq.encode(), hexdec("3003020102"))
6772
6773
6774 class TestPP(TestCase):
6775     @given(data_strategy())
6776     def test_oid_printing(self, d):
6777         oids = {
6778             str(ObjectIdentifier(k)): v * 2
6779             for k, v in d.draw(dictionaries(oid_strategy(), text_letters())).items()
6780         }
6781         chosen = d.draw(sampled_from(sorted(oids)))
6782         chosen_id = oids[chosen]
6783         pp = _pp(asn1_type_name=ObjectIdentifier.asn1_type_name, value=chosen)
6784         self.assertNotIn(chosen_id, pp_console_row(pp))
6785         self.assertIn(
6786             chosen_id,
6787             pp_console_row(pp, oid_maps=[{'whatever': 'whenever'}, oids]),
6788         )
6789
6790
6791 class TestAutoAddSlots(TestCase):
6792     def runTest(self):
6793         class Inher(Integer):
6794             pass
6795
6796         with self.assertRaises(AttributeError):
6797             inher = Inher()
6798             inher.unexistent = "whatever"
6799
6800
6801 class TestOIDDefines(TestCase):
6802     @given(data_strategy())
6803     def runTest(self, d):
6804         value_names = list(d.draw(sets(text_letters(), min_size=1, max_size=10)))
6805         value_name_chosen = d.draw(sampled_from(value_names))
6806         oids = [
6807             ObjectIdentifier(oid)
6808             for oid in d.draw(sets(oid_strategy(), min_size=2, max_size=10))
6809         ]
6810         oid_chosen = d.draw(sampled_from(oids))
6811         values = d.draw(lists(
6812             integers(),
6813             min_size=len(value_names),
6814             max_size=len(value_names),
6815         ))
6816         for definable_class in (Any, OctetString, BitString):
6817             _schema = [
6818                 ("type", ObjectIdentifier(defines=(((value_name_chosen,), {
6819                     oid: Integer() for oid in oids[:-1]
6820                 }),))),
6821             ]
6822             for i, value_name in enumerate(value_names):
6823                 _schema.append((value_name, definable_class(expl=tag_ctxp(i))))
6824
6825             class Seq(Sequence):
6826                 schema = _schema
6827             seq = Seq()
6828             for value_name, value in zip(value_names, values):
6829                 seq[value_name] = definable_class(Integer(value).encode())
6830             seq["type"] = oid_chosen
6831             seq, _ = Seq().decode(seq.encode())
6832             for value_name in value_names:
6833                 if value_name == value_name_chosen:
6834                     continue
6835                 self.assertIsNone(seq[value_name].defined)
6836             if value_name_chosen in oids[:-1]:
6837                 self.assertIsNotNone(seq[value_name_chosen].defined)
6838                 self.assertEqual(seq[value_name_chosen].defined[0], oid_chosen)
6839                 self.assertIsInstance(seq[value_name_chosen].defined[1], Integer)
6840             repr(seq)
6841             list(seq.pps())
6842             pprint(seq, big_blobs=True, with_decode_path=True)
6843
6844
6845 class TestDefinesByPath(TestCase):
6846     def test_generated(self):
6847         class Seq(Sequence):
6848             schema = (
6849                 ("type", ObjectIdentifier()),
6850                 ("value", OctetString(expl=tag_ctxc(123))),
6851             )
6852
6853         class SeqInner(Sequence):
6854             schema = (
6855                 ("typeInner", ObjectIdentifier()),
6856                 ("valueInner", Any()),
6857             )
6858
6859         class PairValue(SetOf):
6860             schema = Any()
6861
6862         class Pair(Sequence):
6863             schema = (
6864                 ("type", ObjectIdentifier()),
6865                 ("value", PairValue()),
6866             )
6867
6868         class Pairs(SequenceOf):
6869             schema = Pair()
6870
6871         (
6872             type_integered,
6873             type_sequenced,
6874             type_innered,
6875             type_octet_stringed,
6876         ) = [
6877             ObjectIdentifier(oid)
6878             for oid in sets(oid_strategy(), min_size=4, max_size=4).example()
6879         ]
6880         seq_integered = Seq()
6881         seq_integered["type"] = type_integered
6882         seq_integered["value"] = OctetString(Integer(123).encode())
6883         seq_integered_raw = seq_integered.encode()
6884
6885         pairs = Pairs()
6886         pairs_input = (
6887             (type_octet_stringed, OctetString(b"whatever")),
6888             (type_integered, Integer(123)),
6889             (type_octet_stringed, OctetString(b"whenever")),
6890             (type_integered, Integer(234)),
6891         )
6892         for t, v in pairs_input:
6893             pairs.append(Pair((
6894                 ("type", t),
6895                 ("value", PairValue((Any(v),))),
6896             )))
6897         seq_inner = SeqInner()
6898         seq_inner["typeInner"] = type_innered
6899         seq_inner["valueInner"] = Any(pairs)
6900         seq_sequenced = Seq()
6901         seq_sequenced["type"] = type_sequenced
6902         seq_sequenced["value"] = OctetString(seq_inner.encode())
6903         seq_sequenced_raw = seq_sequenced.encode()
6904         repr(seq_sequenced)
6905         list(seq_sequenced.pps())
6906         pprint(seq_sequenced, big_blobs=True, with_decode_path=True)
6907
6908         defines_by_path = []
6909         ctx_copied = deepcopy(ctx_dummy)
6910         seq_integered, _ = Seq().decode(
6911             seq_integered_raw,
6912             ctx=ctx_copied,
6913         )
6914         self.assertDictEqual(ctx_copied, ctx_dummy)
6915         self.assertIsNone(seq_integered["value"].defined)
6916         defines_by_path.append(
6917             (("type",), ((("value",), {
6918                 type_integered: Integer(),
6919                 type_sequenced: SeqInner(),
6920             }),))
6921         )
6922         ctx_copied["defines_by_path"] = defines_by_path
6923         seq_integered, _ = Seq().decode(
6924             seq_integered_raw,
6925             ctx=ctx_copied,
6926         )
6927         del ctx_copied["defines_by_path"]
6928         self.assertDictEqual(ctx_copied, ctx_dummy)
6929         self.assertIsNotNone(seq_integered["value"].defined)
6930         self.assertEqual(seq_integered["value"].defined[0], type_integered)
6931         self.assertEqual(seq_integered["value"].defined[1], Integer(123))
6932         self.assertTrue(seq_integered_raw[
6933             seq_integered["value"].defined[1].offset:
6934         ].startswith(Integer(123).encode()))
6935         repr(seq_integered)
6936         list(seq_integered.pps())
6937         pprint(seq_integered, big_blobs=True, with_decode_path=True)
6938
6939         ctx_copied["defines_by_path"] = defines_by_path
6940         seq_sequenced, _ = Seq().decode(
6941             seq_sequenced_raw,
6942             ctx=ctx_copied,
6943         )
6944         del ctx_copied["defines_by_path"]
6945         self.assertDictEqual(ctx_copied, ctx_dummy)
6946         self.assertIsNotNone(seq_sequenced["value"].defined)
6947         self.assertEqual(seq_sequenced["value"].defined[0], type_sequenced)
6948         seq_inner = seq_sequenced["value"].defined[1]
6949         self.assertIsNone(seq_inner["valueInner"].defined)
6950         repr(seq_sequenced)
6951         list(seq_sequenced.pps())
6952         pprint(seq_sequenced, big_blobs=True, with_decode_path=True)
6953
6954         defines_by_path.append((
6955             ("value", DecodePathDefBy(type_sequenced), "typeInner"),
6956             ((("valueInner",), {type_innered: Pairs()}),),
6957         ))
6958         ctx_copied["defines_by_path"] = defines_by_path
6959         seq_sequenced, _ = Seq().decode(
6960             seq_sequenced_raw,
6961             ctx=ctx_copied,
6962         )
6963         del ctx_copied["defines_by_path"]
6964         self.assertDictEqual(ctx_copied, ctx_dummy)
6965         self.assertIsNotNone(seq_sequenced["value"].defined)
6966         self.assertEqual(seq_sequenced["value"].defined[0], type_sequenced)
6967         seq_inner = seq_sequenced["value"].defined[1]
6968         self.assertIsNotNone(seq_inner["valueInner"].defined)
6969         self.assertEqual(seq_inner["valueInner"].defined[0], type_innered)
6970         pairs = seq_inner["valueInner"].defined[1]
6971         for pair in pairs:
6972             self.assertIsNone(pair["value"][0].defined)
6973         repr(seq_sequenced)
6974         list(seq_sequenced.pps())
6975         pprint(seq_sequenced, big_blobs=True, with_decode_path=True)
6976
6977         defines_by_path.append((
6978             (
6979                 "value",
6980                 DecodePathDefBy(type_sequenced),
6981                 "valueInner",
6982                 DecodePathDefBy(type_innered),
6983                 any,
6984                 "type",
6985             ),
6986             ((("value",), {
6987                 type_integered: Integer(),
6988                 type_octet_stringed: OctetString(),
6989             }),),
6990         ))
6991         ctx_copied["defines_by_path"] = defines_by_path
6992         seq_sequenced, _ = Seq().decode(
6993             seq_sequenced_raw,
6994             ctx=ctx_copied,
6995         )
6996         del ctx_copied["defines_by_path"]
6997         self.assertDictEqual(ctx_copied, ctx_dummy)
6998         self.assertIsNotNone(seq_sequenced["value"].defined)
6999         self.assertEqual(seq_sequenced["value"].defined[0], type_sequenced)
7000         seq_inner = seq_sequenced["value"].defined[1]
7001         self.assertIsNotNone(seq_inner["valueInner"].defined)
7002         self.assertEqual(seq_inner["valueInner"].defined[0], type_innered)
7003         pairs_got = seq_inner["valueInner"].defined[1]
7004         for pair_input, pair_got in zip(pairs_input, pairs_got):
7005             self.assertEqual(pair_got["value"][0].defined[0], pair_input[0])
7006             self.assertEqual(pair_got["value"][0].defined[1], pair_input[1])
7007         repr(seq_sequenced)
7008         list(seq_sequenced.pps())
7009         pprint(seq_sequenced, big_blobs=True, with_decode_path=True)
7010
7011     @given(oid_strategy(), integers())
7012     def test_simple(self, oid, tgt):
7013         class Inner(Sequence):
7014             schema = (
7015                 ("oid", ObjectIdentifier(defines=((("..", "tgt"), {
7016                     ObjectIdentifier(oid): Integer(),
7017                 }),))),
7018             )
7019
7020         class Outer(Sequence):
7021             schema = (
7022                 ("inner", Inner()),
7023                 ("tgt", OctetString()),
7024             )
7025
7026         inner = Inner()
7027         inner["oid"] = ObjectIdentifier(oid)
7028         outer = Outer()
7029         outer["inner"] = inner
7030         outer["tgt"] = OctetString(Integer(tgt).encode())
7031         decoded, _ = Outer().decode(outer.encode())
7032         self.assertEqual(decoded["tgt"].defined[1], Integer(tgt))
7033
7034     def test_remaining_data(self):
7035         oid = ObjectIdentifier("1.2.3")
7036         class Seq(Sequence):
7037             schema = (
7038                 ("oid", ObjectIdentifier(defines=((("tgt",), {
7039                     oid: Integer(),
7040                 }),))),
7041                 ("tgt", OctetString()),
7042             )
7043
7044         seq = Seq((
7045             ("oid", oid),
7046             ("tgt", OctetString(Integer(123).encode() + b"junk")),
7047         ))
7048         with assertRaisesRegex(self, DecodeError, "remaining data"):
7049             Seq().decode(seq.encode())
7050
7051     def test_remaining_data_seqof(self):
7052         oid = ObjectIdentifier("1.2.3")
7053         class SeqOf(SetOf):
7054             schema = OctetString()
7055
7056         class Seq(Sequence):
7057             schema = (
7058                 ("oid", ObjectIdentifier(defines=((("tgt",), {
7059                     oid: Integer(),
7060                 }),))),
7061                 ("tgt", SeqOf()),
7062             )
7063
7064         seq = Seq((
7065             ("oid", oid),
7066             ("tgt", SeqOf([OctetString(Integer(123).encode() + b"junk")])),
7067         ))
7068         with assertRaisesRegex(self, DecodeError, "remaining data"):
7069             Seq().decode(seq.encode())
7070
7071
7072 class TestAbsDecodePath(TestCase):
7073     @given(
7074         lists(text(alphabet=ascii_letters, min_size=1)).map(tuple),
7075         lists(text(alphabet=ascii_letters, min_size=1), min_size=1).map(tuple),
7076     )
7077     def test_concat(self, decode_path, rel_path):
7078         dp = abs_decode_path(decode_path, rel_path)
7079         self.assertSequenceEqual(dp, decode_path + rel_path)
7080         repr(dp)
7081
7082     @given(
7083         lists(text(alphabet=ascii_letters, min_size=1)).map(tuple),
7084         lists(text(alphabet=ascii_letters, min_size=1), min_size=1).map(tuple),
7085     )
7086     def test_abs(self, decode_path, rel_path):
7087         self.assertSequenceEqual(
7088             abs_decode_path(decode_path, ("/",) + rel_path),
7089             rel_path,
7090         )
7091
7092     @given(
7093         lists(text(alphabet=ascii_letters, min_size=1), min_size=5).map(tuple),
7094         integers(min_value=1, max_value=3),
7095         lists(text(alphabet=ascii_letters, min_size=1), min_size=1).map(tuple),
7096     )
7097     def test_dots(self, decode_path, number_of_dots, rel_path):
7098         self.assertSequenceEqual(
7099             abs_decode_path(decode_path, tuple([".."] * number_of_dots) + rel_path),
7100             decode_path[:-number_of_dots] + rel_path,
7101         )
7102
7103
7104 class TestStrictDefaultExistence(TestCase):
7105     @given(data_strategy())
7106     def runTest(self, d):
7107         count = d.draw(integers(min_value=1, max_value=10))
7108         chosen = d.draw(integers(min_value=0, max_value=count - 1))
7109         _schema = [
7110             ("int%d" % i, Integer(expl=tag_ctxc(i + 1)))
7111             for i in range(count)
7112         ]
7113         for klass in (Sequence, Set):
7114             class Seq(klass):
7115                 schema = _schema
7116             seq = Seq()
7117             for i in range(count):
7118                 seq["int%d" % i] = Integer(123)
7119             raw = seq.encode()
7120             chosen_choice = "int%d" % chosen
7121             seq.specs[chosen_choice] = seq.specs[chosen_choice](default=123)
7122             with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
7123                 seq.decode(raw)
7124             decoded, _ = seq.decode(raw, ctx={"allow_default_values": True})
7125             self.assertTrue(decoded.ber_encoded)
7126             self.assertTrue(decoded.bered)
7127             decoded = copy(decoded)
7128             self.assertTrue(decoded.ber_encoded)
7129             self.assertTrue(decoded.bered)
7130             decoded, _ = seq.decode(raw, ctx={"bered": True})
7131             self.assertTrue(decoded.ber_encoded)
7132             self.assertTrue(decoded.bered)
7133             decoded = copy(decoded)
7134             self.assertTrue(decoded.ber_encoded)
7135             self.assertTrue(decoded.bered)
7136
7137
7138 class TestX690PrefixedType(TestCase):
7139     def runTest(self):
7140         self.assertSequenceEqual(
7141             VisibleString("Jones").encode(),
7142             hexdec("1A054A6F6E6573"),
7143         )
7144         self.assertSequenceEqual(
7145             VisibleString(
7146                 "Jones",
7147                 impl=tag_encode(3, klass=TagClassApplication),
7148             ).encode(),
7149             hexdec("43054A6F6E6573"),
7150         )
7151         self.assertSequenceEqual(
7152             Any(
7153                 VisibleString(
7154                     "Jones",
7155                     impl=tag_encode(3, klass=TagClassApplication),
7156                 ),
7157                 expl=tag_ctxc(2),
7158             ).encode(),
7159             hexdec("A20743054A6F6E6573"),
7160         )
7161         self.assertSequenceEqual(
7162             OctetString(
7163                 VisibleString(
7164                     "Jones",
7165                     impl=tag_encode(3, klass=TagClassApplication),
7166                 ).encode(),
7167                 impl=tag_encode(7, form=TagFormConstructed, klass=TagClassApplication),
7168             ).encode(),
7169             hexdec("670743054A6F6E6573"),
7170         )
7171         self.assertSequenceEqual(
7172             VisibleString("Jones", impl=tag_ctxp(2)).encode(),
7173             hexdec("82054A6F6E6573"),
7174         )
7175
7176
7177 class TestExplOOB(TestCase):
7178     def runTest(self):
7179         expl = tag_ctxc(123)
7180         raw = Integer(123).encode() + Integer(234).encode()
7181         raw = b"".join((expl, len_encode(len(raw)), raw))
7182         with assertRaisesRegex(self, DecodeError, "explicit tag out-of-bound"):
7183             Integer(expl=expl).decode(raw)
7184         Integer(expl=expl).decode(raw, ctx={"allow_expl_oob": True})
7185
7186
7187 class TestPickleDifferentVersion(TestCase):
7188     def runTest(self):
7189         pickled = pickle_dumps(Integer(123), pickle_proto)
7190         import pyderasn
7191         version_orig = pyderasn.__version__
7192         pyderasn.__version__ += "different"
7193         with assertRaisesRegex(self, ValueError, "different PyDERASN version"):
7194             pickle_loads(pickled)
7195         pyderasn.__version__ = version_orig
7196         pickle_loads(pickled)