# coding: utf-8
# PyDERASN -- Python ASN.1 DER codec with abstract structures
-# Copyright (C) 2017 Sergey Matveev <stargrave@stargrave.org>
+# Copyright (C) 2017-2018 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 six import text_type
from pyderasn import _pp
+from pyderasn import abs_decode_path
from pyderasn import Any
from pyderasn import BitString
from pyderasn import BMPString
max_size=len(value_names),
))
_schema = [
- ("type", ObjectIdentifier(defines=(value_name_chosen, {
+ ("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))))
class TestDefinesByPath(TestCase):
- def runTest(self):
+ def test_generated(self):
class Seq(Sequence):
schema = (
("type", ObjectIdentifier()),
seq_integered, _ = Seq().decode(seq_integered_raw)
self.assertIsNone(seq_integered["value"].defined)
defines_by_path.append(
- (("type",), ("value", {
+ (("type",), ((("value",), {
type_integered: Integer(),
type_sequenced: SeqInner(),
- }))
+ }),))
+ )
+ seq_integered, _ = Seq().decode(
+ seq_integered_raw,
+ ctx={"defines_by_path": defines_by_path},
)
- seq_integered, _ = Seq().decode(seq_integered_raw, defines_by_path=defines_by_path)
self.assertIsNotNone(seq_integered["value"].defined)
self.assertEqual(seq_integered["value"].defined[0], type_integered)
self.assertEqual(seq_integered["value"].defined[1], Integer(123))
+ self.assertTrue(seq_integered_raw[
+ seq_integered["value"].defined[1].offset:
+ ].startswith(Integer(123).encode()))
- seq_sequenced, _ = Seq().decode(seq_sequenced_raw, defines_by_path=defines_by_path)
+ seq_sequenced, _ = Seq().decode(
+ seq_sequenced_raw,
+ ctx={"defines_by_path": defines_by_path},
+ )
self.assertIsNotNone(seq_sequenced["value"].defined)
self.assertEqual(seq_sequenced["value"].defined[0], type_sequenced)
seq_inner = seq_sequenced["value"].defined[1]
defines_by_path.append((
("value", decode_path_defby(type_sequenced), "typeInner"),
- ("valueInner", {type_innered: Pairs()}),
+ ((("valueInner",), {type_innered: Pairs()}),),
))
- seq_sequenced, _ = Seq().decode(seq_sequenced_raw, defines_by_path=defines_by_path)
+ seq_sequenced, _ = Seq().decode(
+ seq_sequenced_raw,
+ ctx={"defines_by_path": defines_by_path},
+ )
self.assertIsNotNone(seq_sequenced["value"].defined)
self.assertEqual(seq_sequenced["value"].defined[0], type_sequenced)
seq_inner = seq_sequenced["value"].defined[1]
any,
"type",
),
- ("value", {
+ ((("value",), {
type_integered: Integer(),
type_octet_stringed: OctetString(),
- }),
+ }),),
))
- seq_sequenced, _ = Seq().decode(seq_sequenced_raw, defines_by_path=defines_by_path)
+ seq_sequenced, _ = Seq().decode(
+ seq_sequenced_raw,
+ ctx={"defines_by_path": defines_by_path},
+ )
self.assertIsNotNone(seq_sequenced["value"].defined)
self.assertEqual(seq_sequenced["value"].defined[0], type_sequenced)
seq_inner = seq_sequenced["value"].defined[1]
for pair_input, pair_got in zip(pairs_input, pairs_got):
self.assertEqual(pair_got["value"][0].defined[0], pair_input[0])
self.assertEqual(pair_got["value"][0].defined[1], pair_input[1])
+
+ @given(oid_strategy(), integers())
+ def test_simple(self, oid, tgt):
+ class Inner(Sequence):
+ schema = (
+ ("oid", ObjectIdentifier(defines=((("..", "tgt"), {
+ ObjectIdentifier(oid): Integer(),
+ }),))),
+ )
+
+ class Outer(Sequence):
+ schema = (
+ ("inner", Inner()),
+ ("tgt", OctetString()),
+ )
+
+ inner = Inner()
+ inner["oid"] = ObjectIdentifier(oid)
+ outer = Outer()
+ outer["inner"] = inner
+ outer["tgt"] = OctetString(Integer(tgt).encode())
+ decoded, _ = Outer().decode(outer.encode())
+ self.assertEqual(decoded["tgt"].defined[1], Integer(tgt))
+
+
+class TestAbsDecodePath(TestCase):
+ @given(
+ lists(text(alphabet=ascii_letters, min_size=1)).map(tuple),
+ 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,
+ )
+
+ @given(
+ lists(text(alphabet=ascii_letters, min_size=1)).map(tuple),
+ lists(text(alphabet=ascii_letters, min_size=1), min_size=1).map(tuple),
+ )
+ def test_abs(self, decode_path, rel_path):
+ self.assertSequenceEqual(
+ abs_decode_path(decode_path, ("/",) + rel_path),
+ rel_path,
+ )
+
+ @given(
+ lists(text(alphabet=ascii_letters, min_size=1), min_size=5).map(tuple),
+ integers(min_value=1, max_value=3),
+ lists(text(alphabet=ascii_letters, min_size=1), min_size=1).map(tuple),
+ )
+ def test_dots(self, decode_path, number_of_dots, rel_path):
+ self.assertSequenceEqual(
+ abs_decode_path(decode_path, tuple([".."] * number_of_dots) + rel_path),
+ decode_path[:-number_of_dots] + rel_path,
+ )
+
+
+class TestStrictDefaultExistence(TestCase):
+ @given(data_strategy())
+ def runTest(self, d):
+ count = d.draw(integers(min_value=1, max_value=10))
+ chosen = d.draw(integers(min_value=0, max_value=count - 1))
+ _schema = [
+ ("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})