# License along with this program. If not, see
# <http://www.gnu.org/licenses/>.
+from copy import copy
from copy import deepcopy
from datetime import datetime
+from importlib import import_module
from string import ascii_letters
from string import digits
from string import printable
from string import whitespace
+from time import time
from unittest import TestCase
from hypothesis import assume
from six import PY2
from six import text_type
from six import unichr as six_unichr
+from six.moves.cPickle import dumps as pickle_dumps
+from six.moves.cPickle import HIGHEST_PROTOCOL as pickle_proto
+from six.moves.cPickle import loads as pickle_loads
from pyderasn import _pp
from pyderasn import abs_decode_path
lambda decode_path: tuple(str(dp) for dp in decode_path)
)
ctx_dummy = dictionaries(integers(), integers(), min_size=2, max_size=4).example()
+copy_funcs = (
+ copy,
+ lambda obj: pickle_loads(pickle_dumps(obj, pickle_proto)),
+)
+self_module = import_module(__name__)
+
+
+def register_class(klass):
+ klassname = klass.__name__ + str(time()).replace(".", "")
+ klass.__name__ = klassname
+ klass.__qualname__ = klassname
+ setattr(self_module, klassname, klass)
def assert_exceeding_data(self, call, junk):
- if len(junk) > 0:
- with assertRaisesRegex(self, ExceedingData, "%d trailing bytes" % len(junk)):
- call()
+ if len(junk) <= 0:
+ return
+ with assertRaisesRegex(self, ExceedingData, "%d trailing bytes" % len(junk)) as err:
+ call()
+ repr(err)
class TestHex(TestCase):
def test_copy(self, values):
for klass in (Boolean, BooleanInherited):
obj = klass(*values)
- obj_copied = obj.copy()
- self.assert_copied_basic_fields(obj, obj_copied)
+ for copy_func in copy_funcs:
+ obj_copied = copy_func(obj)
+ self.assert_copied_basic_fields(obj, obj_copied)
@given(
booleans(),
repr(obj_expled)
list(obj_expled.pps())
pprint(obj_expled, big_blobs=True, with_decode_path=True)
- obj_expled_encoded = obj_expled.encode()
+ obj_expled_hex_encoded = obj_expled.hexencode()
ctx_copied = deepcopy(ctx_dummy)
- obj_decoded, tail = obj_expled.decode(
- obj_expled_encoded + tail_junk,
+ obj_decoded, tail = obj_expled.hexdecode(
+ obj_expled_hex_encoded + hexenc(tail_junk),
offset=offset,
ctx=ctx_copied,
)
self.assertNotEqual(obj_decoded, obj)
self.assertEqual(bool(obj_decoded), bool(obj_expled))
self.assertEqual(bool(obj_decoded), bool(obj))
- self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
+ self.assertSequenceEqual(obj_decoded.hexencode(), obj_expled_hex_encoded)
self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
self.assertEqual(
self.assertEqual(obj_decoded.expl_offset, offset)
assert_exceeding_data(
self,
- lambda: obj_expled.decod(obj_expled_encoded + tail_junk),
+ lambda: obj_expled.hexdecod(obj_expled_hex_encoded + hexenc(tail_junk)),
tail_junk,
)
self.assertTrue(obj.ber_encoded)
self.assertFalse(obj.lenindef)
self.assertTrue(obj.bered)
- obj = obj.copy()
+ obj = copy(obj)
self.assertTrue(obj.ber_encoded)
self.assertFalse(obj.lenindef)
self.assertTrue(obj.bered)
self.assertFalse(obj.lenindef)
self.assertFalse(obj.ber_encoded)
self.assertTrue(obj.bered)
- obj = obj.copy()
+ obj = copy(obj)
self.assertTrue(obj.expl_lenindef)
self.assertFalse(obj.lenindef)
self.assertFalse(obj.ber_encoded)
def test_copy(self, values):
for klass in (Integer, IntegerInherited):
obj = klass(*values)
- obj_copied = obj.copy()
- self.assert_copied_basic_fields(obj, obj_copied)
- self.assertEqual(obj.specs, obj_copied.specs)
- self.assertEqual(obj._bound_min, obj_copied._bound_min)
- self.assertEqual(obj._bound_max, obj_copied._bound_max)
- self.assertEqual(obj._value, obj_copied._value)
+ for copy_func in copy_funcs:
+ obj_copied = copy_func(obj)
+ self.assert_copied_basic_fields(obj, obj_copied)
+ self.assertEqual(obj.specs, obj_copied.specs)
+ self.assertEqual(obj._bound_min, obj_copied._bound_min)
+ self.assertEqual(obj._bound_max, obj_copied._bound_max)
+ self.assertEqual(obj._value, obj_copied._value)
@given(
integers(),
class BS(klass):
schema = _schema
+ register_class(BS)
obj = BS(
value=value,
impl=impl,
optional=optional or False,
_decoded=_decoded,
)
- obj_copied = obj.copy()
- self.assert_copied_basic_fields(obj, obj_copied)
- self.assertEqual(obj.specs, obj_copied.specs)
- self.assertEqual(obj._value, obj_copied._value)
+ for copy_func in copy_funcs:
+ obj_copied = copy_func(obj)
+ self.assert_copied_basic_fields(obj, obj_copied)
+ self.assertEqual(obj.specs, obj_copied.specs)
+ self.assertEqual(obj._value, obj_copied._value)
@given(
binary(),
self.assertTrue(obj.ber_encoded)
self.assertEqual(obj.lenindef, lenindef_expected)
self.assertTrue(obj.bered)
- obj = obj.copy()
+ obj = copy(obj)
self.assertTrue(obj.ber_encoded)
self.assertEqual(obj.lenindef, lenindef_expected)
self.assertTrue(obj.bered)
self.assertEqual(len(encoded), obj.tlvlen)
+ repr(obj)
+ list(obj.pps())
+ pprint(obj, big_blobs=True, with_decode_path=True)
@given(
integers(min_value=0),
self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.lenindef)
self.assertTrue(obj.bered)
- obj = obj.copy()
+ obj = copy(obj)
self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.lenindef)
self.assertTrue(obj.bered)
def test_copy(self, values):
for klass in (OctetString, OctetStringInherited):
obj = klass(*values)
- obj_copied = obj.copy()
- self.assert_copied_basic_fields(obj, obj_copied)
- self.assertEqual(obj._bound_min, obj_copied._bound_min)
- self.assertEqual(obj._bound_max, obj_copied._bound_max)
- self.assertEqual(obj._value, obj_copied._value)
+ for copy_func in copy_funcs:
+ obj_copied = copy_func(obj)
+ self.assert_copied_basic_fields(obj, obj_copied)
+ self.assertEqual(obj._bound_min, obj_copied._bound_min)
+ self.assertEqual(obj._bound_max, obj_copied._bound_max)
+ self.assertEqual(obj._value, obj_copied._value)
@given(
binary(),
self.assertTrue(obj.ber_encoded)
self.assertEqual(obj.lenindef, lenindef_expected)
self.assertTrue(obj.bered)
- obj = obj.copy()
+ obj = copy(obj)
self.assertTrue(obj.ber_encoded)
self.assertEqual(obj.lenindef, lenindef_expected)
self.assertTrue(obj.bered)
self.assertEqual(len(encoded), obj.tlvlen)
+ repr(obj)
+ list(obj.pps())
+ pprint(obj, big_blobs=True, with_decode_path=True)
@given(
integers(min_value=0),
optional=optional or False,
_decoded=_decoded,
)
- obj_copied = obj.copy()
- self.assert_copied_basic_fields(obj, obj_copied)
+ for copy_func in copy_funcs:
+ obj_copied = copy_func(obj)
+ self.assert_copied_basic_fields(obj, obj_copied)
@given(integers(min_value=1).map(tag_encode))
def test_stripped(self, tag_impl):
optional=optional,
_decoded=_decoded,
)
- obj_copied = obj.copy()
- self.assert_copied_basic_fields(obj, obj_copied)
- self.assertEqual(obj._value, obj_copied._value)
+ for copy_func in copy_funcs:
+ obj_copied = copy_func(obj)
+ self.assert_copied_basic_fields(obj, obj_copied)
+ self.assertEqual(obj._value, obj_copied._value)
@settings(max_examples=LONG_TEST_MAX_EXAMPLES)
@given(
obj, _ = ObjectIdentifier().decode(tampered, ctx={"bered": True})
self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.bered)
- obj = obj.copy()
+ obj = copy(obj)
self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.bered)
with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
ObjectIdentifier().decode(tampered)
+ @given(data_strategy())
+ def test_negative_arcs(self, d):
+ oid = list(d.draw(oid_strategy()))
+ if len(oid) == 2:
+ return
+ idx = d.draw(integers(min_value=3, max_value=len(oid)))
+ oid[idx - 1] *= -1
+ if oid[idx - 1] == 0:
+ oid[idx - 1] = -1
+ with self.assertRaises(InvalidOID):
+ ObjectIdentifier(tuple(oid))
+ with self.assertRaises(InvalidOID):
+ ObjectIdentifier(".".join(str(i) for i in oid))
+
+ @given(data_strategy())
+ def test_plused_arcs(self, d):
+ oid = [str(arc) for arc in d.draw(oid_strategy())]
+ idx = d.draw(integers(min_value=0, max_value=len(oid)))
+ oid[idx - 1] = "+" + oid[idx - 1]
+ with self.assertRaises(InvalidOID):
+ ObjectIdentifier(".".join(str(i) for i in oid))
+
@given(data_strategy())
def test_nonnormalized_arcs(self, d):
arcs = d.draw(lists(
obj, _ = ObjectIdentifier().decode(tampered, ctx={"bered": True})
self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.bered)
- obj = obj.copy()
+ obj = copy(obj)
self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.bered)
with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
class E(Enumerated):
schema = schema_input
+ register_class(E)
obj = E(
value=value,
impl=impl,
optional=optional,
_decoded=_decoded,
)
- obj_copied = obj.copy()
- self.assert_copied_basic_fields(obj, obj_copied)
- self.assertEqual(obj.specs, obj_copied.specs)
+ for copy_func in copy_funcs:
+ obj_copied = copy_func(obj)
+ self.assert_copied_basic_fields(obj, obj_copied)
+ self.assertEqual(obj.specs, obj_copied.specs)
@settings(max_examples=LONG_TEST_MAX_EXAMPLES)
@given(data_strategy())
def test_copy(self, d):
values = d.draw(string_values_strategy(self.text_alphabet()))
obj = self.base_klass(*values)
- obj_copied = obj.copy()
- self.assert_copied_basic_fields(obj, obj_copied)
- self.assertEqual(obj._bound_min, obj_copied._bound_min)
- self.assertEqual(obj._bound_max, obj_copied._bound_max)
- self.assertEqual(obj._value, obj_copied._value)
+ for copy_func in copy_funcs:
+ obj_copied = copy_func(obj)
+ self.assert_copied_basic_fields(obj, obj_copied)
+ self.assertEqual(obj._bound_min, obj_copied._bound_min)
+ self.assertEqual(obj._bound_max, obj_copied._bound_max)
+ self.assertEqual(obj._value, obj_copied._value)
@given(data_strategy())
def test_stripped(self, d):
("&", {"allow_ampersand": True}),
("&*", {"allow_asterisk": True, "allow_ampersand": True}),
):
- s = "hello invalid " + c
+ s = "hello invalid"
+ obj = self.base_klass(s)
+ for prop in kwargs.keys():
+ self.assertFalse(getattr(obj, prop))
+ s += c
with assertRaisesRegex(self, DecodeError, "non-printable"):
self.base_klass(s)
self.base_klass(s, **kwargs)
klass = self.base_klass(**kwargs)
obj = klass(s)
- obj = obj.copy()
+ for prop in kwargs.keys():
+ self.assertTrue(getattr(obj, prop))
+ obj = copy(obj)
obj(s)
+ for prop in kwargs.keys():
+ self.assertTrue(getattr(obj, prop))
class TestTeletexString(
self.assertTrue(obj.ber_encoded)
self.assertFalse(obj.lenindef)
self.assertTrue(obj.bered)
- obj = obj.copy()
+ obj = copy(obj)
self.assertTrue(obj.ber_encoded)
self.assertFalse(obj.lenindef)
self.assertTrue(obj.bered)
self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.lenindef)
self.assertTrue(obj.bered)
- obj = obj.copy()
+ obj = copy(obj)
self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.lenindef)
self.assertTrue(obj.bered)
with self.assertRaises(ObjNotReady) as err:
obj.encode()
repr(err.exception)
- value = d.draw(datetimes(min_value=self.min_datetime))
+ value = d.draw(datetimes(
+ min_value=self.min_datetime,
+ max_value=self.max_datetime,
+ ))
obj = self.base_klass(value)
self.assertTrue(obj.ready)
repr(obj)
max_datetime=self.max_datetime,
))
obj = self.base_klass(*values)
- obj_copied = obj.copy()
- self.assert_copied_basic_fields(obj, obj_copied)
- self.assertEqual(obj._value, obj_copied._value)
+ for copy_func in copy_funcs:
+ obj_copied = copy_func(obj)
+ self.assert_copied_basic_fields(obj, obj_copied)
+ self.assertEqual(obj._value, obj_copied._value)
@given(data_strategy())
def test_stripped(self, d):
with assertRaisesRegex(self, DecodeError, "only microsecond fractions"):
GeneralizedTime(b"20010101000000.0000001Z")
+ def test_non_pure_integers(self):
+ for data in ((
+ # b"20000102030405Z,
+ b"+2000102030405Z",
+ b"2000+102030405Z",
+ b"200001+2030405Z",
+ b"20000102+30405Z",
+ b"2000010203+405Z",
+ b"200001020304+5Z",
+ b"20000102030405.+6Z",
+ b"20000102030405.-6Z",
+ b" 2000102030405Z",
+ b"2000 102030405Z",
+ b"200001 2030405Z",
+ b"20000102 30405Z",
+ b"2000010203 405Z",
+ b"200001020304 5Z",
+ b"20000102030405. 6Z",
+ b"200 0102030405Z",
+ b"20001 02030405Z",
+ b"2000012 030405Z",
+ b"200001023 0405Z",
+ b"20000102034 05Z",
+ b"2000010203045 Z",
+ b"20000102030405.6 Z",
+ )):
+ with self.assertRaises(DecodeError):
+ GeneralizedTime(data)
+
class TestUTCTime(TimeMixin, CommonMixin, TestCase):
base_klass = UTCTime
datetime(1991, 5, 6, 23, 45, 40, 0),
)
+ def test_non_pure_integers(self):
+ for data in ((
+ # b"000102030405Z",
+ b"+10102030405Z",
+ b"00+102030405Z",
+ b"0001+2030405Z",
+ b"000102+30405Z",
+ b"00010203+405Z",
+ b"0001020304+5Z",
+ b" 10102030405Z",
+ b"00 102030405Z",
+ b"0001 2030405Z",
+ b"000102 30405Z",
+ b"00010203 405Z",
+ b"0001020304 5Z",
+ b"1 0102030405Z",
+ b"001 02030405Z",
+ b"00012 030405Z",
+ b"0001023 0405Z",
+ b"000102034 05Z",
+ b"00010203045 Z",
+ )):
+ with self.assertRaises(DecodeError):
+ UTCTime(data)
+
@given(integers(min_value=0, max_value=49))
def test_pre50(self, year):
self.assertEqual(
def test_copy(self, values):
for klass in (Any, AnyInherited):
obj = klass(*values)
- obj_copied = obj.copy()
- self.assert_copied_basic_fields(obj, obj_copied)
- self.assertEqual(obj._value, obj_copied._value)
+ for copy_func in copy_funcs:
+ obj_copied = copy_func(obj)
+ self.assert_copied_basic_fields(obj, obj_copied)
+ self.assertEqual(obj._value, obj_copied._value)
@given(binary().map(OctetString))
def test_stripped(self, value):
self.assertTrue(obj.lenindef)
self.assertFalse(obj.ber_encoded)
self.assertTrue(obj.bered)
- obj = obj.copy()
+ obj = copy(obj)
self.assertTrue(obj.lenindef)
self.assertFalse(obj.ber_encoded)
self.assertTrue(obj.bered)
class Wahl(self.base_klass):
schema = _schema
+ register_class(Wahl)
obj = Wahl(
value=value,
expl=expl,
optional=optional or False,
_decoded=_decoded,
)
- obj_copied = obj.copy()
- self.assertIsNone(obj.tag)
- self.assertIsNone(obj_copied.tag)
- # hack for assert_copied_basic_fields
- obj.tag = "whatever"
- obj_copied.tag = "whatever"
- self.assert_copied_basic_fields(obj, obj_copied)
- self.assertEqual(obj._value, obj_copied._value)
- self.assertEqual(obj.specs, obj_copied.specs)
+ for copy_func in copy_funcs:
+ obj_copied = copy_func(obj)
+ self.assertIsNone(obj.tag)
+ self.assertIsNone(obj_copied.tag)
+ # hack for assert_copied_basic_fields
+ obj.tag = "whatever"
+ obj_copied.tag = "whatever"
+ self.assert_copied_basic_fields(obj, obj_copied)
+ obj.tag = None
+ self.assertEqual(obj._value, obj_copied._value)
+ self.assertEqual(obj.specs, obj_copied.specs)
@given(booleans())
def test_stripped(self, value):
def test_copy(self, d):
class SeqInherited(self.base_klass):
pass
+ register_class(SeqInherited)
for klass in (self.base_klass, SeqInherited):
values = d.draw(seq_values_strategy(seq_klass=klass))
obj = klass(*values)
- obj_copied = obj.copy()
- self.assert_copied_basic_fields(obj, obj_copied)
- self.assertEqual(obj.specs, obj_copied.specs)
- self.assertEqual(obj._value, obj_copied._value)
+ for copy_func in copy_funcs:
+ obj_copied = copy_func(obj)
+ self.assert_copied_basic_fields(obj, obj_copied)
+ self.assertEqual(obj.specs, obj_copied.specs)
+ self.assertEqual(obj._value, obj_copied._value)
@given(data_strategy())
def test_stripped(self, d):
t, _, lv = tag_strip(seq_encoded)
_, _, v = len_decode(lv)
seq_encoded_lenindef = t + LENINDEF + v + EOC
+ with self.assertRaises(DecodeError):
+ seq.decode(seq_encoded_lenindef)
ctx_copied = deepcopy(ctx_dummy)
ctx_copied["bered"] = True
seq_decoded_lenindef, tail_lenindef = seq.decode(
self.assertDictEqual(ctx_copied, ctx_dummy)
self.assertTrue(seq_decoded_lenindef.lenindef)
self.assertTrue(seq_decoded_lenindef.bered)
- seq_decoded_lenindef = seq_decoded_lenindef.copy()
+ seq_decoded_lenindef = copy(seq_decoded_lenindef)
self.assertTrue(seq_decoded_lenindef.lenindef)
self.assertTrue(seq_decoded_lenindef.bered)
with self.assertRaises(DecodeError):
seq_decoded, _ = seq_with_default.decode(seq_encoded, ctx=ctx)
self.assertTrue(seq_decoded.ber_encoded)
self.assertTrue(seq_decoded.bered)
- seq_decoded = seq_decoded.copy()
+ seq_decoded = copy(seq_decoded)
self.assertTrue(seq_decoded.ber_encoded)
self.assertTrue(seq_decoded.bered)
for name, value in _schema:
self.assertFalse(decoded.ber_encoded)
self.assertFalse(decoded.lenindef)
self.assertTrue(decoded.bered)
- decoded = decoded.copy()
+ decoded = copy(decoded)
self.assertFalse(decoded.ber_encoded)
self.assertFalse(decoded.lenindef)
self.assertTrue(decoded.bered)
self.assertFalse(decoded.ber_encoded)
self.assertFalse(decoded.lenindef)
self.assertTrue(decoded.bered)
- decoded = decoded.copy()
+ decoded = copy(decoded)
self.assertFalse(decoded.ber_encoded)
self.assertFalse(decoded.lenindef)
self.assertTrue(decoded.bered)
seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
self.assertTrue(seq_decoded.ber_encoded)
self.assertTrue(seq_decoded.bered)
- seq_decoded = seq_decoded.copy()
+ seq_decoded = copy(seq_decoded)
self.assertTrue(seq_decoded.ber_encoded)
self.assertTrue(seq_decoded.bered)
self.assertSequenceEqual(
class SeqOf(self.base_klass):
schema = _schema
+ register_class(SeqOf)
obj = SeqOf(
value=value,
bounds=bounds,
optional=optional or False,
_decoded=_decoded,
)
- obj_copied = obj.copy()
- self.assert_copied_basic_fields(obj, obj_copied)
- self.assertEqual(obj._bound_min, obj_copied._bound_min)
- self.assertEqual(obj._bound_max, obj_copied._bound_max)
- self.assertEqual(obj._value, obj_copied._value)
+ for copy_func in copy_funcs:
+ obj_copied = copy_func(obj)
+ self.assert_copied_basic_fields(obj, obj_copied)
+ self.assertEqual(obj._bound_min, obj_copied._bound_min)
+ self.assertEqual(obj._bound_max, obj_copied._bound_max)
+ self.assertEqual(obj._value, obj_copied._value)
@given(
lists(binary()),
t, _, lv = tag_strip(obj_encoded)
_, _, v = len_decode(lv)
obj_encoded_lenindef = t + LENINDEF + v + EOC
+ with self.assertRaises(DecodeError):
+ obj.decode(obj_encoded_lenindef)
obj_decoded_lenindef, tail_lenindef = obj.decode(
obj_encoded_lenindef + tail_junk,
ctx={"bered": True},
)
self.assertTrue(obj_decoded_lenindef.lenindef)
self.assertTrue(obj_decoded_lenindef.bered)
- obj_decoded_lenindef = obj_decoded_lenindef.copy()
+ obj_decoded_lenindef = copy(obj_decoded_lenindef)
self.assertTrue(obj_decoded_lenindef.lenindef)
self.assertTrue(obj_decoded_lenindef.bered)
repr(obj_decoded_lenindef)
self.assertFalse(decoded.ber_encoded)
self.assertFalse(decoded.lenindef)
self.assertTrue(decoded.bered)
- decoded = decoded.copy()
+ decoded = copy(decoded)
self.assertFalse(decoded.ber_encoded)
self.assertFalse(decoded.lenindef)
self.assertTrue(decoded.bered)
self.assertFalse(decoded.ber_encoded)
self.assertFalse(decoded.lenindef)
self.assertTrue(decoded.bered)
- decoded = decoded.copy()
+ decoded = copy(decoded)
self.assertFalse(decoded.ber_encoded)
self.assertFalse(decoded.lenindef)
self.assertTrue(decoded.bered)
seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
self.assertTrue(seq_decoded.ber_encoded)
self.assertTrue(seq_decoded.bered)
- seq_decoded = seq_decoded.copy()
+ seq_decoded = copy(seq_decoded)
self.assertTrue(seq_decoded.ber_encoded)
self.assertTrue(seq_decoded.bered)
self.assertSequenceEqual(
min_size=len(value_names),
max_size=len(value_names),
))
- _schema = [
- ("type", ObjectIdentifier(defines=(((value_name_chosen,), {
- oid: Integer() for oid in oids[:-1]
- }),))),
- ]
- for i, value_name in enumerate(value_names):
- _schema.append((value_name, Any(expl=tag_ctxp(i))))
+ for definable_class in (Any, OctetString, BitString):
+ _schema = [
+ ("type", ObjectIdentifier(defines=(((value_name_chosen,), {
+ oid: Integer() for oid in oids[:-1]
+ }),))),
+ ]
+ for i, value_name in enumerate(value_names):
+ _schema.append((value_name, definable_class(expl=tag_ctxp(i))))
- class Seq(Sequence):
- schema = _schema
- seq = Seq()
- for value_name, value in zip(value_names, values):
- seq[value_name] = Any(Integer(value).encode())
- seq["type"] = oid_chosen
- seq, _ = Seq().decode(seq.encode())
- for value_name in value_names:
- if value_name == value_name_chosen:
- continue
- self.assertIsNone(seq[value_name].defined)
- if value_name_chosen in oids[:-1]:
- self.assertIsNotNone(seq[value_name_chosen].defined)
- self.assertEqual(seq[value_name_chosen].defined[0], oid_chosen)
- self.assertIsInstance(seq[value_name_chosen].defined[1], Integer)
- repr(seq)
- list(seq.pps())
- pprint(seq, big_blobs=True, with_decode_path=True)
+ class Seq(Sequence):
+ schema = _schema
+ seq = Seq()
+ for value_name, value in zip(value_names, values):
+ seq[value_name] = definable_class(Integer(value).encode())
+ seq["type"] = oid_chosen
+ seq, _ = Seq().decode(seq.encode())
+ for value_name in value_names:
+ if value_name == value_name_chosen:
+ continue
+ self.assertIsNone(seq[value_name].defined)
+ if value_name_chosen in oids[:-1]:
+ self.assertIsNotNone(seq[value_name_chosen].defined)
+ self.assertEqual(seq[value_name_chosen].defined[0], oid_chosen)
+ self.assertIsInstance(seq[value_name_chosen].defined[1], Integer)
+ repr(seq)
+ list(seq.pps())
+ pprint(seq, big_blobs=True, with_decode_path=True)
class TestDefinesByPath(TestCase):
(type_integered, Integer(234)),
)
for t, v in pairs_input:
- pair = Pair()
- pair["type"] = t
- pair["value"] = PairValue((Any(v),))
- pairs.append(pair)
+ pairs.append(Pair((
+ ("type", t),
+ ("value", PairValue((Any(v),))),
+ )))
seq_inner = SeqInner()
seq_inner["typeInner"] = type_innered
seq_inner["valueInner"] = Any(pairs)
decoded, _ = Outer().decode(outer.encode())
self.assertEqual(decoded["tgt"].defined[1], Integer(tgt))
+ def test_remaining_data(self):
+ oid = ObjectIdentifier("1.2.3")
+ class Seq(Sequence):
+ schema = (
+ ("oid", ObjectIdentifier(defines=((("tgt",), {
+ oid: Integer(),
+ }),))),
+ ("tgt", OctetString()),
+ )
+
+ seq = Seq((
+ ("oid", oid),
+ ("tgt", OctetString(Integer(123).encode() + b"junk")),
+ ))
+ with assertRaisesRegex(self, DecodeError, "remaining data"):
+ Seq().decode(seq.encode())
+
+ def test_remaining_data_seqof(self):
+ oid = ObjectIdentifier("1.2.3")
+ class SeqOf(SetOf):
+ schema = OctetString()
+
+ class Seq(Sequence):
+ schema = (
+ ("oid", ObjectIdentifier(defines=((("tgt",), {
+ oid: Integer(),
+ }),))),
+ ("tgt", SeqOf()),
+ )
+
+ seq = Seq((
+ ("oid", oid),
+ ("tgt", SeqOf([OctetString(Integer(123).encode() + b"junk")])),
+ ))
+ with assertRaisesRegex(self, DecodeError, "remaining data"):
+ Seq().decode(seq.encode())
+
class TestAbsDecodePath(TestCase):
@given(
lists(text(alphabet=ascii_letters, min_size=1), min_size=1).map(tuple),
)
def test_concat(self, decode_path, rel_path):
- self.assertSequenceEqual(
- abs_decode_path(decode_path, rel_path),
- decode_path + rel_path,
- )
+ dp = abs_decode_path(decode_path, rel_path)
+ self.assertSequenceEqual(dp, decode_path + rel_path)
+ repr(dp)
@given(
lists(text(alphabet=ascii_letters, min_size=1)).map(tuple),
decoded, _ = seq.decode(raw, ctx={"allow_default_values": True})
self.assertTrue(decoded.ber_encoded)
self.assertTrue(decoded.bered)
- decoded = decoded.copy()
+ decoded = copy(decoded)
self.assertTrue(decoded.ber_encoded)
self.assertTrue(decoded.bered)
decoded, _ = seq.decode(raw, ctx={"bered": True})
self.assertTrue(decoded.ber_encoded)
self.assertTrue(decoded.bered)
- decoded = decoded.copy()
+ decoded = copy(decoded)
self.assertTrue(decoded.ber_encoded)
self.assertTrue(decoded.bered)
with assertRaisesRegex(self, DecodeError, "explicit tag out-of-bound"):
Integer(expl=expl).decode(raw)
Integer(expl=expl).decode(raw, ctx={"allow_expl_oob": True})
+
+
+class TestPickleDifferentVersion(TestCase):
+ def runTest(self):
+ pickled = pickle_dumps(Integer(123), pickle_proto)
+ import pyderasn
+ version_orig = pyderasn.__version__
+ pyderasn.__version__ += "different"
+ with assertRaisesRegex(self, ValueError, "different PyDERASN version"):
+ pickle_loads(pickled)
+ pyderasn.__version__ = version_orig
+ pickle_loads(pickled)