# coding: utf-8
# PyDERASN -- Python ASN.1 DER/CER/BER codec with abstract structures
-# Copyright (C) 2017-2020 Sergey Matveev <stargrave@stargrave.org>
+# Copyright (C) 2017-2021 Sergey Matveev <stargrave@stargrave.org>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as
from time import mktime
from time import time
from unittest import TestCase
+from unittest.mock import patch
from dateutil.tz import UTC
from hypothesis import assume
from hypothesis.strategies import sets
from hypothesis.strategies import text
from hypothesis.strategies import tuples
-from six import assertRaisesRegex
-from six import binary_type
-from six import byte2int
-from six import indexbytes
-from six import int2byte
-from six import iterbytes
-from six import PY2
-from six import text_type
-from six import unichr as six_unichr
-from six.moves import xrange as six_xrange
-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 pickle import dumps as pickle_dumps
+from pickle import HIGHEST_PROTOCOL as pickle_proto
+from pickle import loads as pickle_loads
from pyderasn import _pp
from pyderasn import abs_decode_path
from pyderasn import UTF8String
from pyderasn import VideotexString
from pyderasn import VisibleString
+import pyderasn
max_examples = environ.get("MAX_EXAMPLES")
def assert_exceeding_data(self, call, junk):
if len(junk) <= 0:
return
- with assertRaisesRegex(self, ExceedingData, "%d trailing bytes" % len(junk)) as err:
+ with self.assertRaisesRegex(ExceedingData, "%d trailing bytes" % len(junk)) as err:
call()
repr(err)
self.assertEqual(tag_decode(raw), (klass, form, num))
self.assertEqual(len(raw), 1)
self.assertEqual(
- byte2int(tag_encode(klass=klass, form=form, num=0)),
- byte2int(raw) & (1 << 7 | 1 << 6 | 1 << 5),
+ tag_encode(klass=klass, form=form, num=0)[0],
+ raw[0] & (1 << 7 | 1 << 6 | 1 << 5),
)
stripped, tlen, tail = tag_strip(memoryview(raw + junk))
self.assertSequenceEqual(stripped.tobytes(), raw)
self.assertEqual(tag_decode(raw), (klass, form, num))
self.assertGreater(len(raw), 1)
self.assertEqual(
- byte2int(tag_encode(klass=klass, form=form, num=0)) | 31,
- byte2int(raw[:1]),
+ tag_encode(klass=klass, form=form, num=0)[0] | 31,
+ raw[0],
)
- self.assertEqual(byte2int(raw[-1:]) & 0x80, 0)
- self.assertTrue(all(b & 0x80 > 0 for b in iterbytes(raw[1:-1])))
+ self.assertEqual(raw[-1] & 0x80, 0)
+ self.assertTrue(all(b & 0x80 > 0 for b in raw[1:-1]))
stripped, tlen, tail = tag_strip(memoryview(raw + junk))
self.assertSequenceEqual(stripped.tobytes(), raw)
self.assertEqual(tlen, len(raw))
raw = bytearray(tag_encode(num=num))
for i in range(1, len(raw)):
raw[i] |= 0x80
- with assertRaisesRegex(self, DecodeError, "unfinished tag"):
+ with self.assertRaisesRegex(DecodeError, "unfinished tag"):
tag_strip(bytes(raw))
def test_go_vectors_valid(self):
integers(min_value=0, max_value=2),
)
def test_long_instead_of_short(self, l, dummy_num):
- octets = (b"\x00" * dummy_num) + int2byte(l)
- octets = int2byte((dummy_num + 1) | 0x80) + octets
+ octets = (b"\x00" * dummy_num) + bytes([l])
+ octets = bytes([(dummy_num + 1) | 0x80]) + octets
with self.assertRaises(DecodeError):
len_decode(octets)
def test_leading_zero_byte(self, klass, form, num):
raw = tag_encode(klass=klass, form=form, num=num)
raw = b"".join((raw[:1], b"\x80", raw[1:]))
- with assertRaisesRegex(self, DecodeError, "leading zero byte"):
+ with self.assertRaisesRegex(DecodeError, "leading zero byte"):
tag_strip(raw)
@given(tag_classes, tag_forms, integers(max_value=30, min_value=0))
def test_unexpected_long_form(self, klass, form, num):
- raw = int2byte(klass | form | 31) + int2byte(num)
- with assertRaisesRegex(self, DecodeError, "unexpected long form"):
+ raw = bytes([klass | form | 31, num])
+ with self.assertRaisesRegex(DecodeError, "unexpected long form"):
tag_strip(raw)
raw = len_encode(l) + junk
decoded, llen, tail = len_decode(memoryview(raw))
self.assertEqual(decoded, l)
- self.assertEqual((llen - 1) | 0x80, byte2int(raw))
+ self.assertEqual((llen - 1) | 0x80, raw[0])
self.assertEqual(llen, len(raw) - len(junk))
- self.assertNotEqual(indexbytes(raw, 1), 0)
+ self.assertNotEqual(raw[1], 0)
self.assertSequenceEqual(tail.tobytes(), junk)
def test_empty(self):
@composite
def text_letters(draw):
result = draw(text(alphabet=ascii_letters, min_size=1))
- if PY2:
- result = result.encode("ascii")
return result
@given(integers(min_value=0 + 1, max_value=255 - 1))
def test_ber_value(self, value):
- with assertRaisesRegex(self, DecodeError, "unacceptable Boolean value"):
+ with self.assertRaisesRegex(DecodeError, "unacceptable Boolean value"):
Boolean().decode(b"".join((
Boolean.tag_default,
len_encode(1),
- int2byte(value),
+ bytes([value]),
)))
- encoded = b"".join((
- Boolean.tag_default,
- len_encode(1),
- int2byte(value),
- ))
+ encoded = b"".join((Boolean.tag_default, len_encode(1), bytes([value])))
obj, _ = Boolean().decode(encoded, ctx={"bered": True})
list(Boolean().decode_evgen(encoded, ctx={"bered": True}))
self.assertTrue(bool(obj))
encoded = expl + LENINDEF + Boolean(False).encode()
with self.assertRaises(LenIndefForm):
Boolean(expl=expl).decode(encoded + junk)
- with assertRaisesRegex(self, DecodeError, "no EOC"):
+ with self.assertRaisesRegex(DecodeError, "no EOC"):
Boolean(expl=expl).decode(encoded + junk, ctx={"bered": True})
obj, tail = Boolean(expl=expl).decode(
encoded + EOC + junk,
with self.assertRaises(BoundsError) as err:
Integer(value=values[0], bounds=(values[1], values[2]))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
Integer(bounds=(values[1], values[2])).decode(
Integer(values[0]).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
Integer(bounds=(values[1], values[2])).decode(
encode2pass(Integer(values[0]))
)
with self.assertRaises(BoundsError) as err:
Integer(value=values[2], bounds=(values[0], values[1]))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
Integer(bounds=(values[0], values[1])).decode(
Integer(values[2]).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
Integer(bounds=(values[0], values[1])).decode(
encode2pass(Integer(values[2]))
)
BitString().decode(b"".join((
BitString.tag_default,
len_encode(1),
- int2byte(pad_size),
+ bytes([pad_size]),
)))
def test_go_vectors_invalid(self):
payload_expected = b""
bit_len_expected = 0
for chunk_input in chunk_inputs:
- if isinstance(chunk_input, binary_type):
+ if isinstance(chunk_input, bytes):
chunks.append(BitString(chunk_input).encode())
payload_expected += chunk_input
bit_len_expected += len(chunk_input) * 8
b"".join(chunks) +
chunk_last.encode()
)
- with assertRaisesRegex(self, DecodeError, "unallowed BER"):
+ with self.assertRaisesRegex(DecodeError, "unallowed BER"):
BitString(impl=tag_encode(impl)).decode(encoded_indefinite)
for lenindef_expected, encoded in (
(True, encoded_indefinite),
decode_path_strat,
)
def test_ber_definite_too_short(self, offset, decode_path):
- with assertRaisesRegex(self, DecodeError, "longer than data") as err:
+ with self.assertRaisesRegex(DecodeError, "longer than data") as err:
BitString().decode(
tag_encode(3, form=TagFormConstructed) + len_encode(1),
offset=offset,
decode_path_strat,
)
def test_ber_definite_no_data(self, offset, decode_path):
- with assertRaisesRegex(self, DecodeError, "zero length") as err:
+ with self.assertRaisesRegex(DecodeError, "zero length") as err:
BitString().decode(
tag_encode(3, form=TagFormConstructed) + len_encode(0),
offset=offset,
def test_ber_definite_chunk_out_of_bounds(self, offset, decode_path, chunks):
bs = BitString(b"data").encode()
bs_longer = BitString(b"data-longer").encode()
- with assertRaisesRegex(self, DecodeError, "chunk out of bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "chunk out of bounds") as err:
BitString().decode(
(
tag_encode(3, form=TagFormConstructed) +
decode_path_strat,
)
def test_ber_indefinite_no_chunks(self, offset, decode_path):
- with assertRaisesRegex(self, DecodeError, "no chunks") as err:
+ with self.assertRaisesRegex(DecodeError, "no chunks") as err:
BitString().decode(
tag_encode(3, form=TagFormConstructed) + LENINDEF + EOC,
offset=offset,
chunks.append(bs_short)
offset = d.draw(integers(min_value=0))
decode_path = d.draw(decode_path_strat)
- with assertRaisesRegex(self, DecodeError, "multiple of 8 bits") as err:
+ with self.assertRaisesRegex(DecodeError, "multiple of 8 bits") as err:
BitString().decode(
(
tag_encode(3, form=TagFormConstructed) +
def test_invalid_value_type(self):
with self.assertRaises(InvalidValueType) as err:
- OctetString(text_type(123))
+ OctetString(str(123))
repr(err.exception)
@given(booleans())
with self.assertRaises(BoundsError) as err:
OctetString(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
OctetString(bounds=(bound_min, bound_max)).decode(
OctetString(value).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
OctetString(bounds=(bound_min, bound_max)).decode(
encode2pass(OctetString(value))
)
with self.assertRaises(BoundsError) as err:
OctetString(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
OctetString(bounds=(bound_min, bound_max)).decode(
OctetString(value).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
OctetString(bounds=(bound_min, bound_max)).decode(
encode2pass(OctetString(value))
)
chunks_len_expected = []
payload_expected = b""
for chunk_input in chunk_inputs:
- if isinstance(chunk_input, binary_type):
+ if isinstance(chunk_input, bytes):
chunks.append(OctetString(chunk_input).encode())
payload_expected += chunk_input
chunks_len_expected.append(len(chunk_input))
len_encode(len(b"".join(chunks))) +
b"".join(chunks)
)
- with assertRaisesRegex(self, DecodeError, "unallowed BER"):
+ with self.assertRaisesRegex(DecodeError, "unallowed BER"):
OctetString(impl=tag_encode(impl)).decode(encoded_indefinite)
for lenindef_expected, encoded in (
(True, encoded_indefinite),
decode_path_strat,
)
def test_ber_definite_too_short(self, offset, decode_path):
- with assertRaisesRegex(self, DecodeError, "longer than data") as err:
+ with self.assertRaisesRegex(DecodeError, "longer than data") as err:
OctetString().decode(
tag_encode(4, form=TagFormConstructed) + len_encode(1),
offset=offset,
def test_ber_definite_chunk_out_of_bounds(self, offset, decode_path, chunks):
bs = OctetString(b"data").encode()
bs_longer = OctetString(b"data-longer").encode()
- with assertRaisesRegex(self, DecodeError, "chunk out of bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "chunk out of bounds") as err:
OctetString().decode(
(
tag_encode(4, form=TagFormConstructed) +
len_encode(len(data)),
data,
))
- with assertRaisesRegex(self, DecodeError, "unfinished OID"):
+ with self.assertRaisesRegex(DecodeError, "unfinished OID"):
obj.decode(data)
@given(integers(min_value=0))
obj = copy(obj)
self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.bered)
- with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
+ with self.assertRaisesRegex(DecodeError, "non normalized arc encoding"):
ObjectIdentifier().decode(tampered)
@given(data_strategy())
obj = copy(obj)
self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.bered)
- with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
+ with self.assertRaisesRegex(DecodeError, "non normalized arc encoding"):
ObjectIdentifier().decode(tampered)
base_klass = EWhatever
def test_schema_required(self):
- with assertRaisesRegex(self, ValueError, "schema must be specified"):
+ with self.assertRaisesRegex(ValueError, "schema must be specified"):
Enumerated()
def test_invalid_value_type(self):
repr(err.exception)
def text_alphabet(self):
- return "".join(six_unichr(c) for c in six_xrange(256))
+ return "".join(chr(c) for c in range(256))
@given(booleans())
def test_optional(self, optional):
repr(obj)
list(obj.pps())
pprint(obj, big_blobs=True, with_decode_path=True)
- text_type(obj)
+ str(obj)
with self.assertRaises(ObjNotReady) as err:
obj.encode()
repr(err.exception)
repr(obj)
list(obj.pps())
pprint(obj, big_blobs=True, with_decode_path=True)
- text_type(obj)
+ str(obj)
@given(data_strategy())
def test_comparison(self, d):
self.assertEqual(obj1 == obj2, value1 == value2)
self.assertEqual(obj1 != obj2, value1 != value2)
self.assertEqual(obj1 == bytes(obj2), value1 == value2)
- self.assertEqual(obj1 == text_type(obj2), value1 == value2)
+ self.assertEqual(obj1 == str(obj2), value1 == value2)
obj1 = self.base_klass(value1, impl=tag1)
obj2 = self.base_klass(value1, impl=tag2)
self.assertEqual(obj1 == obj2, tag1 == tag2)
with self.assertRaises(BoundsError) as err:
self.base_klass(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
self.base_klass(bounds=(bound_min, bound_max)).decode(
self.base_klass(value).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
self.base_klass(bounds=(bound_min, bound_max)).decode(
encode2pass(self.base_klass(value))
)
with self.assertRaises(BoundsError) as err:
self.base_klass(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
self.base_klass(bounds=(bound_min, bound_max)).decode(
self.base_klass(value).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
self.base_klass(bounds=(bound_min, bound_max)).decode(
encode2pass(self.base_klass(value))
)
self.assertNotEqual(obj_decoded, obj)
self.assertEqual(bytes(obj_decoded), bytes(obj_expled))
self.assertEqual(bytes(obj_decoded), bytes(obj))
- self.assertEqual(text_type(obj_decoded), text_type(obj_expled))
- self.assertEqual(text_type(obj_decoded), text_type(obj))
+ self.assertEqual(str(obj_decoded), str(obj_expled))
+ self.assertEqual(str(obj_decoded), str(obj))
self.assertSequenceEqual(obj_decoded.encode(), obj_expled_encoded)
self.assertSequenceEqual(obj_decoded.expl_tag, tag_expl)
self.assertEqual(obj_decoded.expl_tlen, len(tag_expl))
cyrillic_letters = text(
- alphabet="".join(six_unichr(i) for i in list(range(0x0410, 0x044f + 1))),
+ alphabet="".join(chr(i) for i in list(range(0x0410, 0x044f + 1))),
min_size=1,
max_size=5,
)
@given(text(alphabet=ascii_letters, min_size=1, max_size=5))
def test_non_numeric(self, non_numeric_text):
- with assertRaisesRegex(self, DecodeError, "alphabet value"):
+ with self.assertRaisesRegex(DecodeError, "alphabet value"):
self.base_klass(non_numeric_text)
@given(
@given(text(alphabet=sorted(set(whitespace) - set(" ")), min_size=1, max_size=5))
def test_non_printable(self, non_printable_text):
- with assertRaisesRegex(self, DecodeError, "alphabet value"):
+ with self.assertRaisesRegex(DecodeError, "alphabet value"):
self.base_klass(non_printable_text)
@given(
for prop in kwargs.keys():
self.assertFalse(getattr(obj, prop))
s += c
- with assertRaisesRegex(self, DecodeError, "alphabet value"):
+ with self.assertRaisesRegex(DecodeError, "alphabet value"):
self.base_klass(s)
self.base_klass(s, **kwargs)
klass = self.base_klass(**kwargs)
base_klass = IA5String
def text_alphabet(self):
- return "".join(six_unichr(c) for c in six_xrange(128))
+ return "".join(chr(c) for c in range(128))
@given(integers(min_value=128, max_value=255))
def test_alphabet_bad(self, code):
self.assertFalse(obj_encoded.endswith(b"0Z"))
def test_repr_not_ready(self):
- unicode(GeneralizedTime()) if PY2 else str(GeneralizedTime())
+ str(GeneralizedTime())
repr(GeneralizedTime())
def test_x690_vector_valid(self):
@settings(max_examples=LONG_TEST_MAX_EXAMPLES)
@given(data_strategy())
def test_valid_ber(self, d):
- min_year = 1901 if PY2 else 2
- year = d.draw(integers(min_value=min_year, max_value=9999))
+ year = d.draw(integers(min_value=2, max_value=9999))
month = d.draw(integers(min_value=1, max_value=12))
day = d.draw(integers(min_value=1, max_value=28))
hours = d.draw(integers(min_value=0, max_value=23))
def test_ns_fractions(self):
GeneralizedTime(b"20010101000000.000001Z")
- with assertRaisesRegex(self, DecodeError, "only microsecond fractions"):
+ with self.assertRaisesRegex(DecodeError, "only microsecond fractions"):
GeneralizedTime(b"20010101000000.0000001Z")
def test_non_pure_integers(self):
GeneralizedTime(data)
def test_aware(self):
- with assertRaisesRegex(self, ValueError, "only naive"):
+ with self.assertRaisesRegex(ValueError, "only naive"):
GeneralizedTime(datetime(2000, 1, 1, 1, tzinfo=UTC))
pass
def test_repr_not_ready(self):
- unicode(GeneralizedTime()) if PY2 else str(GeneralizedTime())
+ str(GeneralizedTime())
repr(UTCTime())
def test_x690_vector_valid(self):
)
def test_aware(self):
- with assertRaisesRegex(self, ValueError, "only naive"):
+ with self.assertRaisesRegex(ValueError, "only naive"):
UTCTime(datetime(2000, 1, 1, 1, tzinfo=UTC))
+ def test_raises_if_no_dateutil(self):
+ with patch("pyderasn.tzUTC", new="missing"):
+ with self.assertRaisesRegex(NotImplementedError, "dateutil"):
+ UTCTime(datetime.now()).totzdatetime()
+
+ def test_tzinfo_gives_datetime_with_tzutc_tzinfo(self):
+ self.assertEqual(UTCTime(datetime.now()).totzdatetime().tzinfo, UTC)
+
@composite
def tlv_value_strategy(draw):
base_klass = Wahl
def test_schema_required(self):
- with assertRaisesRegex(self, ValueError, "schema must be specified"):
+ with self.assertRaisesRegex(ValueError, "schema must be specified"):
Choice()
def test_impl_forbidden(self):
- with assertRaisesRegex(self, ValueError, "no implicit tag allowed"):
+ with self.assertRaisesRegex(ValueError, "no implicit tag allowed"):
Choice(impl=b"whatever")
def test_invalid_value_type(self):
return seq_outer, expect_outers
-class SeqMixing(object):
+class SeqMixin(object):
def test_invalid_value_type(self):
with self.assertRaises(InvalidValueType) as err:
self.base_klass(123)
for (n, v), t in zip(_schema, tags)
]
seq_with_default = SeqWithDefault()
- with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
+ with self.assertRaisesRegex(DecodeError, "DEFAULT value met"):
seq_with_default.decode(seq_encoded)
- with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
+ with self.assertRaisesRegex(DecodeError, "DEFAULT value met"):
list(seq_with_default.decode_evgen(seq_encoded))
for ctx in ({"bered": True}, {"allow_default_values": True}):
seq_decoded, _ = seq_with_default.decode(seq_encoded, ctx=ctx)
self.assertTrue(decoded.bered)
-class TestSequence(SeqMixing, CommonMixin, TestCase):
+class TestSequence(SeqMixin, CommonMixin, TestCase):
base_klass = Sequence
@given(
len_encode(len(int_encoded + junk)),
int_encoded + junk,
))
- with assertRaisesRegex(self, DecodeError, "remaining"):
+ with self.assertRaisesRegex(DecodeError, "remaining"):
Seq().decode(junked)
@given(sets(text_letters(), min_size=2))
self.assertEqual(seq["ok"], True)
-class TestSet(SeqMixing, CommonMixin, TestCase):
+class TestSet(SeqMixin, CommonMixin, TestCase):
base_klass = Set
@settings(max_examples=LONG_TEST_MAX_EXAMPLES)
len_encode(len(encoded)),
encoded,
))
- with assertRaisesRegex(self, DecodeError, "unordered SET"):
+ with self.assertRaisesRegex(DecodeError, "unordered SET"):
seq.decode(seq_encoded)
for ctx in ({"bered": True}, {"allow_unordered_set": True}):
seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
)
-class SeqOfMixing(object):
+class SeqOfMixin(object):
def test_invalid_value_type(self):
with self.assertRaises(InvalidValueType) as err:
self.base_klass(123)
repr(err.exception)
def test_schema_required(self):
- with assertRaisesRegex(self, ValueError, "schema must be specified"):
+ with self.assertRaisesRegex(ValueError, "schema must be specified"):
self.base_klass.__mro__[1]()
@given(booleans(), booleans(), binary(min_size=1), binary(min_size=1))
with self.assertRaises(BoundsError) as err:
SeqOf(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
SeqOf(bounds=(bound_min, bound_max)).decode(
SeqOf(value).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
SeqOf(bounds=(bound_min, bound_max)).decode(
encode2pass(SeqOf(value))
)
with self.assertRaises(BoundsError) as err:
SeqOf(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
SeqOf(bounds=(bound_min, bound_max)).decode(
SeqOf(value).encode()
)
repr(err.exception)
- with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ with self.assertRaisesRegex(DecodeError, "bounds") as err:
SeqOf(bounds=(bound_min, bound_max)).decode(
encode2pass(SeqOf(value))
)
self.assertTrue(decoded.bered)
-class TestSequenceOf(SeqOfMixing, CommonMixin, TestCase):
+class TestSequenceOf(SeqOfMixin, CommonMixin, TestCase):
class SeqOf(SequenceOf):
schema = "whatever"
base_klass = SeqOf
register_class(SeqOf)
seqof = SeqOf()
pickle_dumps(seqof)
- seqof = seqof(iter(six_xrange(10)))
- with assertRaisesRegex(self, ValueError, "iterator"):
+ seqof = seqof(iter(range(10)))
+ with self.assertRaisesRegex(ValueError, "iterator"):
pickle_dumps(seqof)
def test_iterator_bounds(self):
seqof = None
def gen(n):
- for i in six_xrange(n):
+ for i in range(n):
yield Integer(i)
for n in (9, 21):
seqof = SeqOf(gen(n))
bounds = (1, float("+inf"))
def gen():
- for i in six_xrange(10):
+ for i in range(10):
yield Integer(i)
seqof = SeqOf(gen())
self.assertTrue(seqof.ready)
bounds = (1, float("+inf"))
def gen():
- for i in six_xrange(10):
+ for i in range(10):
yield Integer(i)
seqof = SeqOf(gen())
self.assertTrue(seqof.ready)
self.assertFalse(seqof.ready)
-class TestSetOf(SeqOfMixing, CommonMixin, TestCase):
+class TestSetOf(SeqOfMixin, CommonMixin, TestCase):
class SeqOf(SetOf):
schema = "whatever"
base_klass = SeqOf
class Seq(SetOf):
schema = OctetString()
seq = Seq()
- with assertRaisesRegex(self, DecodeError, "unordered SET OF"):
+ with self.assertRaisesRegex(DecodeError, "unordered SET OF"):
seq.decode(seq_encoded)
for ctx in ({"bered": True}, {"allow_unordered_set": True}):
seq["erste"] = PrintableString("test")
self.assertSequenceEqual(seq.encode(), hexdec("3006130474657374"))
# Asterisk is actually not allowable
- PrintableString._allowable_chars |= set(b"*")
+ pyderasn.PRINTABLE_ALLOWABLE_CHARS |= set(b"*")
seq["erste"] = PrintableString("test*")
self.assertSequenceEqual(seq.encode(), hexdec("30071305746573742a"))
- PrintableString._allowable_chars -= set(b"*")
+ pyderasn.PRINTABLE_ALLOWABLE_CHARS -= set(b"*")
class Seq(Sequence):
schema = (
("oid", oid),
("tgt", OctetString(Integer(123).encode() + b"junk")),
))
- with assertRaisesRegex(self, DecodeError, "remaining data"):
+ with self.assertRaisesRegex(DecodeError, "remaining data"):
Seq().decode(seq.encode())
def test_remaining_data_seqof(self):
("oid", oid),
("tgt", SeqOf([OctetString(Integer(123).encode() + b"junk")])),
))
- with assertRaisesRegex(self, DecodeError, "remaining data"):
+ with self.assertRaisesRegex(DecodeError, "remaining data"):
Seq().decode(seq.encode())
raw = seq.encode()
chosen_choice = "int%d" % chosen
seq.specs[chosen_choice] = seq.specs[chosen_choice](default=123)
- with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
+ with self.assertRaisesRegex(DecodeError, "DEFAULT value met"):
seq.decode(raw)
decoded, _ = seq.decode(raw, ctx={"allow_default_values": True})
self.assertTrue(decoded.ber_encoded)
expl = tag_ctxc(123)
raw = Integer(123).encode() + Integer(234).encode()
raw = b"".join((expl, len_encode(len(raw)), raw))
- with assertRaisesRegex(self, DecodeError, "explicit tag out-of-bound"):
+ with self.assertRaisesRegex(DecodeError, "explicit tag out-of-bound"):
Integer(expl=expl).decode(raw)
Integer(expl=expl).decode(raw, ctx={"allow_expl_oob": True})
import pyderasn
version_orig = pyderasn.__version__
pyderasn.__version__ += "different"
- with assertRaisesRegex(self, ValueError, "different PyDERASN version"):
+ with self.assertRaisesRegex(ValueError, "different PyDERASN version"):
pickle_loads(pickled)
pyderasn.__version__ = version_orig
pickle_loads(pickled)