from pyderasn import InvalidValueType
from pyderasn import len_decode
from pyderasn import len_encode
+from pyderasn import LEN_YYMMDDHHMMSSZ
+from pyderasn import LEN_YYYYMMDDHHMMSSDMZ
+from pyderasn import LEN_YYYYMMDDHHMMSSZ
from pyderasn import LENINDEF
from pyderasn import NotEnoughData
from pyderasn import Null
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:
+ Integer(bounds=(values[1], values[2])).decode(
+ Integer(values[0]).encode()
+ )
+ repr(err.exception)
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:
+ Integer(bounds=(values[0], values[1])).decode(
+ Integer(values[2]).encode()
+ )
+ repr(err.exception)
@given(data_strategy())
def test_call(self, d):
with self.assertRaises(BoundsError) as err:
OctetString(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
+ with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ OctetString(bounds=(bound_min, bound_max)).decode(
+ OctetString(value).encode()
+ )
+ repr(err.exception)
value = d.draw(binary(min_size=bound_max + 1))
with self.assertRaises(BoundsError) as err:
OctetString(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
+ with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ OctetString(bounds=(bound_min, bound_max)).decode(
+ OctetString(value).encode()
+ )
+ repr(err.exception)
@given(data_strategy())
def test_call(self, d):
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:
+ self.base_klass(bounds=(bound_min, bound_max)).decode(
+ self.base_klass(value).encode()
+ )
+ repr(err.exception)
value = d.draw(text(alphabet=self.text_alphabet(), min_size=bound_max + 1))
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:
+ self.base_klass(bounds=(bound_min, bound_max)).decode(
+ self.base_klass(value).encode()
+ )
+ repr(err.exception)
@given(data_strategy())
def test_call(self, d):
datetime(2010, 1, 2, 3, 4, 5, 0),
)
+ @given(
+ binary(
+ min_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
+ max_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
+ ),
+ binary(min_size=1, max_size=1),
+ binary(
+ min_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
+ max_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2,
+ ),
+ )
+ def test_junk(self, part0, part1, part2):
+ junk = part0 + part1 + part2
+ assume(not (set(junk) <= set(digits.encode("ascii"))))
+ with self.assertRaises(DecodeError):
+ GeneralizedTime().decode(
+ GeneralizedTime.tag_default +
+ len_encode(len(junk)) +
+ junk
+ )
+
+ @given(
+ binary(
+ min_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
+ max_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
+ ),
+ binary(min_size=1, max_size=1),
+ binary(
+ min_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
+ max_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2,
+ ),
+ )
+ def test_junk_dm(self, part0, part1, part2):
+ junk = part0 + part1 + part2
+ assume(not (set(junk) <= set(digits.encode("ascii"))))
+ with self.assertRaises(DecodeError):
+ GeneralizedTime().decode(
+ GeneralizedTime.tag_default +
+ len_encode(len(junk)) +
+ junk
+ )
+
class TestUTCTime(TimeMixin, CommonMixin, TestCase):
base_klass = UTCTime
1900 + year,
)
+ @given(
+ binary(
+ min_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
+ max_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
+ ),
+ binary(min_size=1, max_size=1),
+ binary(
+ min_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
+ max_size=(LEN_YYMMDDHHMMSSZ - 1) // 2,
+ ),
+ )
+ def test_junk(self, part0, part1, part2):
+ junk = part0 + part1 + part2
+ assume(not (set(junk) <= set(digits.encode("ascii"))))
+ with self.assertRaises(DecodeError):
+ UTCTime().decode(
+ UTCTime.tag_default +
+ len_encode(len(junk)) +
+ junk
+ )
+
@composite
def any_values_strategy(draw, do_expl=False):
seq_encoded = seq.encode()
seq_decoded, tail = seq.decode(seq_encoded + tail_junk)
self.assertFalse(seq_decoded.lenindef)
+ self.assertFalse(seq_decoded.bered)
t, _, lv = tag_strip(seq_encoded)
_, _, v = len_decode(lv)
self.assertSequenceEqual(seq.encode(), empty_seq)
@given(data_strategy())
- def test_encoded_default_accepted(self, d):
+ def test_encoded_default_not_accepted(self, d):
_schema = list(d.draw(dictionaries(
text_letters(),
integers(),
for (n, v), t in zip(_schema, tags)
]
seq_with_default = SeqWithDefault()
- seq_decoded, _ = seq_with_default.decode(seq_encoded)
- for name, value in _schema:
- self.assertEqual(seq_decoded[name], seq_with_default[name])
- self.assertEqual(seq_decoded[name], value)
+ with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
+ seq_with_default.decode(seq_encoded)
+ for ctx in ({"bered": True}, {"allow_default_values": True}):
+ seq_decoded, _ = seq_with_default.decode(seq_encoded, ctx=ctx)
+ self.assertTrue(seq_decoded.bered)
+ for name, value in _schema:
+ self.assertEqual(seq_decoded[name], seq_with_default[name])
+ self.assertEqual(seq_decoded[name], value)
@given(data_strategy())
def test_missing_from_spec(self, d):
b"".join(sorted([seq[name].encode() for name, _ in Seq.schema])),
)
+ @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
+ @given(data_strategy())
+ def test_unsorted(self, d):
+ tags = [
+ tag_encode(tag) for tag in
+ d.draw(sets(integers(min_value=1), min_size=2, max_size=5))
+ ]
+ tags = d.draw(permutations(tags))
+ assume(tags != sorted(tags))
+ encoded = b"".join(OctetString(t, impl=t).encode() for t in tags)
+ seq_encoded = b"".join((
+ Set.tag_default,
+ len_encode(len(encoded)),
+ encoded,
+ ))
+
+ class Seq(Set):
+ schema = [(str(i), OctetString(impl=t)) for i, t in enumerate(tags)]
+ seq = Seq()
+ with assertRaisesRegex(self, DecodeError, "unordered SET"):
+ seq.decode(seq_encoded)
+ for ctx in ({"bered": True}, {"allow_unordered_set": True}):
+ seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
+ self.assertTrue(seq_decoded.bered)
+ self.assertSequenceEqual(
+ [bytes(seq_decoded[str(i)]) for i, t in enumerate(tags)],
+ [t for t in tags],
+ )
+
@composite
def seqof_values_strategy(draw, schema=None, do_expl=False):
schema = Boolean()
bound_min = d.draw(integers(min_value=1, max_value=1 << 7))
bound_max = d.draw(integers(min_value=bound_min, max_value=1 << 7))
- value = [Boolean()] * d.draw(integers(max_value=bound_min - 1))
+ value = [Boolean(False)] * d.draw(integers(max_value=bound_min - 1))
with self.assertRaises(BoundsError) as err:
SeqOf(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
- value = [Boolean()] * d.draw(integers(
+ with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ SeqOf(bounds=(bound_min, bound_max)).decode(
+ SeqOf(value).encode()
+ )
+ repr(err.exception)
+ value = [Boolean(True)] * d.draw(integers(
min_value=bound_max + 1,
max_value=bound_max + 10,
))
with self.assertRaises(BoundsError) as err:
SeqOf(value=value, bounds=(bound_min, bound_max))
repr(err.exception)
+ with assertRaisesRegex(self, DecodeError, "bounds") as err:
+ SeqOf(bounds=(bound_min, bound_max)).decode(
+ SeqOf(value).encode()
+ )
+ repr(err.exception)
@given(integers(min_value=1, max_value=10))
def test_out_of_bounds(self, bound_max):
b"".join(sorted([v.encode() for v in values])),
)
+ @settings(max_examples=LONG_TEST_MAX_EXAMPLES)
+ @given(data_strategy())
+ def test_unsorted(self, d):
+ values = [OctetString(v).encode() for v in d.draw(sets(
+ binary(min_size=1, max_size=5),
+ min_size=2,
+ max_size=5,
+ ))]
+ values = d.draw(permutations(values))
+ assume(values != sorted(values))
+ encoded = b"".join(values)
+ seq_encoded = b"".join((
+ SetOf.tag_default,
+ len_encode(len(encoded)),
+ encoded,
+ ))
+
+ class Seq(SetOf):
+ schema = OctetString()
+ seq = Seq()
+ with assertRaisesRegex(self, DecodeError, "unordered SET OF"):
+ seq.decode(seq_encoded)
+
+ for ctx in ({"bered": True}, {"allow_unordered_set": True}):
+ seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
+ self.assertTrue(seq_decoded.bered)
+ self.assertSequenceEqual(
+ [obj.encode() for obj in seq_decoded],
+ values,
+ )
+
class TestGoMarshalVectors(TestCase):
def runTest(self):
("int%d" % i, Integer(expl=tag_ctxc(i + 1)))
for i in range(count)
]
-
- class Seq(Sequence):
- schema = _schema
- seq = Seq()
- for i in range(count):
- seq["int%d" % i] = Integer(123)
- raw = seq.encode()
- chosen = "int%d" % chosen
- seq.specs[chosen] = seq.specs[chosen](default=123)
- seq.decode(raw)
- with assertRaisesRegex(self, DecodeError, "DEFAULT value met"):
- seq.decode(raw, ctx={"strict_default_existence": True})
+ for klass in (Sequence, Set):
+ class Seq(klass):
+ schema = _schema
+ seq = Seq()
+ for i in range(count):
+ seq["int%d" % i] = Integer(123)
+ 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"):
+ seq.decode(raw)
+ decoded, _ = seq.decode(raw, ctx={"allow_default_values": True})
+ self.assertTrue(decoded.bered)
+ decoded, _ = seq.decode(raw, ctx={"bered": True})
+ self.assertTrue(decoded.bered)
class TestX690PrefixedType(TestCase):
VisibleString("Jones", impl=tag_ctxp(2)).encode(),
hexdec("82054A6F6E6573"),
)
+
+
+class TestExplOOB(TestCase):
+ def runTest(self):
+ 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"):
+ Integer(expl=expl).decode(raw)
+ Integer(expl=expl).decode(raw, ctx={"allow_expl_oob": True})