You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1504 lines
52 KiB
1504 lines
52 KiB
#
|
|
# This file is part of pyasn1 software.
|
|
#
|
|
# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
|
|
# License: http://snmplabs.com/pyasn1/license.html
|
|
#
|
|
import sys
|
|
|
|
try:
|
|
import unittest2 as unittest
|
|
|
|
except ImportError:
|
|
import unittest
|
|
|
|
from tests.base import BaseTestCase
|
|
|
|
from pyasn1.type import tag
|
|
from pyasn1.type import namedtype
|
|
from pyasn1.type import opentype
|
|
from pyasn1.type import univ
|
|
from pyasn1.type import char
|
|
from pyasn1.codec.ber import encoder
|
|
from pyasn1.compat.octets import ints2octs
|
|
from pyasn1.error import PyAsn1Error
|
|
|
|
|
|
class LargeTagEncoderTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
|
|
self.o = univ.Integer().subtype(
|
|
value=1, explicitTag=tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 0xdeadbeaf)
|
|
)
|
|
|
|
def testEncoder(self):
|
|
assert encoder.encode(self.o) == ints2octs((127, 141, 245, 182, 253, 47, 3, 2, 1, 1))
|
|
|
|
|
|
class IntegerEncoderTestCase(BaseTestCase):
|
|
def testPosInt(self):
|
|
assert encoder.encode(univ.Integer(12)) == ints2octs((2, 1, 12))
|
|
|
|
def testNegInt(self):
|
|
assert encoder.encode(univ.Integer(-12)) == ints2octs((2, 1, 244))
|
|
|
|
def testZero(self):
|
|
assert encoder.encode(univ.Integer(0)) == ints2octs((2, 1, 0))
|
|
|
|
def testCompactZero(self):
|
|
encoder.IntegerEncoder.supportCompactZero = True
|
|
substrate = encoder.encode(univ.Integer(0))
|
|
encoder.IntegerEncoder.supportCompactZero = False
|
|
assert substrate == ints2octs((2, 0))
|
|
|
|
def testMinusOne(self):
|
|
assert encoder.encode(univ.Integer(-1)) == ints2octs((2, 1, 255))
|
|
|
|
def testPosLong(self):
|
|
assert encoder.encode(
|
|
univ.Integer(0xffffffffffffffff)
|
|
) == ints2octs((2, 9, 0, 255, 255, 255, 255, 255, 255, 255, 255))
|
|
|
|
def testNegLong(self):
|
|
assert encoder.encode(
|
|
univ.Integer(-0xffffffffffffffff)
|
|
) == ints2octs((2, 9, 255, 0, 0, 0, 0, 0, 0, 0, 1))
|
|
|
|
|
|
class IntegerEncoderWithSchemaTestCase(BaseTestCase):
|
|
def testPosInt(self):
|
|
assert encoder.encode(12, asn1Spec=univ.Integer()) == ints2octs((2, 1, 12))
|
|
|
|
def testNegInt(self):
|
|
assert encoder.encode(-12, asn1Spec=univ.Integer()) == ints2octs((2, 1, 244))
|
|
|
|
def testZero(self):
|
|
assert encoder.encode(0, asn1Spec=univ.Integer()) == ints2octs((2, 1, 0))
|
|
|
|
def testPosLong(self):
|
|
assert encoder.encode(
|
|
0xffffffffffffffff, asn1Spec=univ.Integer()
|
|
) == ints2octs((2, 9, 0, 255, 255, 255, 255, 255, 255, 255, 255))
|
|
|
|
|
|
class BooleanEncoderTestCase(BaseTestCase):
|
|
def testTrue(self):
|
|
assert encoder.encode(univ.Boolean(1)) == ints2octs((1, 1, 1))
|
|
|
|
def testFalse(self):
|
|
assert encoder.encode(univ.Boolean(0)) == ints2octs((1, 1, 0))
|
|
|
|
|
|
class BooleanEncoderWithSchemaTestCase(BaseTestCase):
|
|
def testTrue(self):
|
|
assert encoder.encode(True, asn1Spec=univ.Boolean()) == ints2octs((1, 1, 1))
|
|
|
|
def testFalse(self):
|
|
assert encoder.encode(False, asn1Spec=univ.Boolean()) == ints2octs((1, 1, 0))
|
|
|
|
|
|
class BitStringEncoderTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.b = univ.BitString((1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1))
|
|
|
|
def testDefMode(self):
|
|
assert encoder.encode(self.b) == ints2octs((3, 3, 1, 169, 138))
|
|
|
|
def testIndefMode(self):
|
|
assert encoder.encode(
|
|
self.b, defMode=False
|
|
) == ints2octs((3, 3, 1, 169, 138))
|
|
|
|
def testDefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.b, maxChunkSize=1
|
|
) == ints2octs((35, 8, 3, 2, 0, 169, 3, 2, 1, 138))
|
|
|
|
def testIndefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.b, defMode=False, maxChunkSize=1
|
|
) == ints2octs((35, 128, 3, 2, 0, 169, 3, 2, 1, 138, 0, 0))
|
|
|
|
def testEmptyValue(self):
|
|
assert encoder.encode(univ.BitString([])) == ints2octs((3, 1, 0))
|
|
|
|
|
|
class BitStringEncoderWithSchemaTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.b = (1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1)
|
|
self.s = univ.BitString()
|
|
|
|
def testDefMode(self):
|
|
assert encoder.encode(self.b, asn1Spec=self.s) == ints2octs((3, 3, 1, 169, 138))
|
|
|
|
def testIndefMode(self):
|
|
assert encoder.encode(
|
|
self.b, asn1Spec=self.s, defMode=False
|
|
) == ints2octs((3, 3, 1, 169, 138))
|
|
|
|
def testDefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.b, asn1Spec=self.s, maxChunkSize=1
|
|
) == ints2octs((35, 8, 3, 2, 0, 169, 3, 2, 1, 138))
|
|
|
|
def testIndefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.b, asn1Spec=self.s, defMode=False, maxChunkSize=1
|
|
) == ints2octs((35, 128, 3, 2, 0, 169, 3, 2, 1, 138, 0, 0))
|
|
|
|
def testEmptyValue(self):
|
|
assert encoder.encode([], asn1Spec=self.s) == ints2octs((3, 1, 0))
|
|
|
|
|
|
class OctetStringEncoderTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.o = univ.OctetString('Quick brown fox')
|
|
|
|
def testDefMode(self):
|
|
assert encoder.encode(self.o) == ints2octs(
|
|
(4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
|
|
|
|
def testIndefMode(self):
|
|
assert encoder.encode(
|
|
self.o, defMode=False
|
|
) == ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
|
|
|
|
def testDefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.o, maxChunkSize=4
|
|
) == ints2octs((36, 23, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119,
|
|
110, 32, 4, 3, 102, 111, 120))
|
|
|
|
def testIndefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.o, defMode=False, maxChunkSize=4
|
|
) == ints2octs((36, 128, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110,
|
|
32, 4, 3, 102, 111, 120, 0, 0))
|
|
|
|
|
|
class OctetStringEncoderWithSchemaTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.OctetString()
|
|
self.o = 'Quick brown fox'
|
|
|
|
def testDefMode(self):
|
|
assert encoder.encode(self.o, asn1Spec=self.s) == ints2octs(
|
|
(4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
|
|
|
|
def testIndefMode(self):
|
|
assert encoder.encode(
|
|
self.o, asn1Spec=self.s, defMode=False
|
|
) == ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
|
|
|
|
def testDefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.o, asn1Spec=self.s, maxChunkSize=4
|
|
) == ints2octs((36, 23, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119,
|
|
110, 32, 4, 3, 102, 111, 120))
|
|
|
|
def testIndefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.o, asn1Spec=self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((36, 128, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110,
|
|
32, 4, 3, 102, 111, 120, 0, 0))
|
|
|
|
|
|
class ExpTaggedOctetStringEncoderTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.o = univ.OctetString().subtype(
|
|
value='Quick brown fox',
|
|
explicitTag=tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 5)
|
|
)
|
|
|
|
def testDefMode(self):
|
|
assert encoder.encode(self.o) == ints2octs(
|
|
(101, 17, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
|
|
|
|
def testIndefMode(self):
|
|
assert encoder.encode(
|
|
self.o, defMode=False
|
|
) == ints2octs((101, 128, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 0, 0))
|
|
|
|
def testDefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.o, defMode=True, maxChunkSize=4
|
|
) == ints2octs((101, 25, 36, 23, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3,
|
|
102, 111, 120))
|
|
|
|
def testIndefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.o, defMode=False, maxChunkSize=4
|
|
) == ints2octs((101, 128, 36, 128, 4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120, 0, 0, 0, 0))
|
|
|
|
|
|
class NullEncoderTestCase(BaseTestCase):
|
|
def testNull(self):
|
|
assert encoder.encode(univ.Null('')) == ints2octs((5, 0))
|
|
|
|
|
|
class NullEncoderWithSchemaTestCase(BaseTestCase):
|
|
def testNull(self):
|
|
assert encoder.encode(None, univ.Null()) == ints2octs((5, 0))
|
|
|
|
|
|
class ObjectIdentifierEncoderTestCase(BaseTestCase):
|
|
def testOne(self):
|
|
assert encoder.encode(
|
|
univ.ObjectIdentifier((1, 3, 6, 0, 0xffffe))
|
|
) == ints2octs((6, 6, 43, 6, 0, 191, 255, 126))
|
|
|
|
def testEdge1(self):
|
|
assert encoder.encode(
|
|
univ.ObjectIdentifier((0, 39))
|
|
) == ints2octs((6, 1, 39))
|
|
|
|
def testEdge2(self):
|
|
assert encoder.encode(
|
|
univ.ObjectIdentifier((1, 39))
|
|
) == ints2octs((6, 1, 79))
|
|
|
|
def testEdge3(self):
|
|
# 01111111
|
|
assert encoder.encode(
|
|
univ.ObjectIdentifier((2, 40))
|
|
) == ints2octs((6, 1, 120))
|
|
|
|
def testEdge4(self):
|
|
# 10010000|10000000|10000000|10000000|01001111
|
|
assert encoder.encode(
|
|
univ.ObjectIdentifier((2, 0xffffffff))
|
|
) == ints2octs((6, 5, 0x90, 0x80, 0x80, 0x80, 0x4F))
|
|
|
|
def testEdge5(self):
|
|
# 01111111
|
|
assert encoder.encode(
|
|
univ.ObjectIdentifier((2, 47))
|
|
) == ints2octs((6, 1, 0x7F))
|
|
|
|
def testEdge6(self):
|
|
# 10000001|00000000
|
|
assert encoder.encode(
|
|
univ.ObjectIdentifier((2, 48))
|
|
) == ints2octs((6, 2, 0x81, 0x00))
|
|
|
|
def testEdge7(self):
|
|
# 10000001|00110100|00000003
|
|
assert encoder.encode(
|
|
univ.ObjectIdentifier((2, 100, 3))
|
|
) == ints2octs((6, 3, 0x81, 0x34, 0x03))
|
|
|
|
def testEdge8(self):
|
|
# 10000101|00000000
|
|
assert encoder.encode(
|
|
univ.ObjectIdentifier((2, 560))
|
|
) == ints2octs((6, 2, 133, 0))
|
|
|
|
def testEdge9(self):
|
|
# 10001000|10000100|10000111|0000010
|
|
assert encoder.encode(
|
|
univ.ObjectIdentifier((2, 16843570))
|
|
) == ints2octs((6, 4, 0x88, 0x84, 0x87, 0x02))
|
|
|
|
def testEdgeA(self):
|
|
assert encoder.encode(
|
|
univ.ObjectIdentifier((2, 5))
|
|
) == ints2octs((6, 1, 85))
|
|
|
|
def testImpossible1(self):
|
|
try:
|
|
encoder.encode(univ.ObjectIdentifier((3, 1, 2)))
|
|
except PyAsn1Error:
|
|
pass
|
|
else:
|
|
assert 0, 'impossible leading arc tolerated'
|
|
|
|
def testImpossible2(self):
|
|
try:
|
|
encoder.encode(univ.ObjectIdentifier((0,)))
|
|
except PyAsn1Error:
|
|
pass
|
|
else:
|
|
assert 0, 'single arc OID tolerated'
|
|
|
|
def testImpossible3(self):
|
|
try:
|
|
encoder.encode(univ.ObjectIdentifier((0, 40)))
|
|
except PyAsn1Error:
|
|
pass
|
|
else:
|
|
assert 0, 'second arc overflow tolerated'
|
|
|
|
def testImpossible4(self):
|
|
try:
|
|
encoder.encode(univ.ObjectIdentifier((1, 40)))
|
|
except PyAsn1Error:
|
|
pass
|
|
else:
|
|
assert 0, 'second arc overflow tolerated'
|
|
|
|
def testLarge1(self):
|
|
assert encoder.encode(
|
|
univ.ObjectIdentifier((2, 18446744073709551535184467440737095))
|
|
) == ints2octs((0x06, 0x11, 0x83, 0xC6, 0xDF, 0xD4, 0xCC, 0xB3, 0xFF, 0xFF, 0xFE, 0xF0, 0xB8, 0xD6, 0xB8, 0xCB,
|
|
0xE2, 0xB7, 0x17))
|
|
|
|
def testLarge2(self):
|
|
assert encoder.encode(
|
|
univ.ObjectIdentifier((2, 999, 18446744073709551535184467440737095))
|
|
) == ints2octs((0x06, 0x13, 0x88, 0x37, 0x83, 0xC6, 0xDF, 0xD4, 0xCC, 0xB3, 0xFF, 0xFF, 0xFE, 0xF0, 0xB8, 0xD6,
|
|
0xB8, 0xCB, 0xE2, 0xB6, 0x47))
|
|
|
|
|
|
class ObjectIdentifierWithSchemaEncoderTestCase(BaseTestCase):
|
|
def testOne(self):
|
|
assert encoder.encode(
|
|
(1, 3, 6, 0, 0xffffe), asn1Spec=univ.ObjectIdentifier()
|
|
) == ints2octs((6, 6, 43, 6, 0, 191, 255, 126))
|
|
|
|
|
|
class RealEncoderTestCase(BaseTestCase):
|
|
def testChar(self):
|
|
assert encoder.encode(
|
|
univ.Real((123, 10, 11))
|
|
) == ints2octs((9, 7, 3, 49, 50, 51, 69, 49, 49))
|
|
|
|
def testBin1(self):
|
|
assert encoder.encode( # default binEncBase = 2
|
|
univ.Real((0.5, 2, 0)) # check encbase = 2 and exponent = -1
|
|
) == ints2octs((9, 3, 128, 255, 1))
|
|
|
|
def testBin2(self):
|
|
r = univ.Real((3.25, 2, 0))
|
|
r.binEncBase = 8 # change binEncBase only for this instance of Real
|
|
assert encoder.encode(
|
|
r # check encbase = 8
|
|
) == ints2octs((9, 3, 148, 255, 13))
|
|
|
|
def testBin3(self):
|
|
# change binEncBase in the RealEncoder instance => for all further Real
|
|
binEncBase, encoder.typeMap[univ.Real.typeId].binEncBase = encoder.typeMap[univ.Real.typeId].binEncBase, 16
|
|
assert encoder.encode(
|
|
univ.Real((0.00390625, 2, 0)) # check encbase = 16
|
|
) == ints2octs((9, 3, 160, 254, 1))
|
|
encoder.typeMap[univ.Real.typeId].binEncBase = binEncBase
|
|
|
|
def testBin4(self):
|
|
# choose binEncBase automatically for all further Real (testBin[4-7])
|
|
binEncBase, encoder.typeMap[univ.Real.typeId].binEncBase = encoder.typeMap[univ.Real.typeId].binEncBase, None
|
|
assert encoder.encode(
|
|
univ.Real((1, 2, 0)) # check exponent = 0
|
|
) == ints2octs((9, 3, 128, 0, 1))
|
|
encoder.typeMap[univ.Real.typeId].binEncBase = binEncBase
|
|
|
|
def testBin5(self):
|
|
assert encoder.encode(
|
|
univ.Real((3, 2, -1020)) # case of 2 octs for exponent and
|
|
# negative exponent and abs(exponent) is
|
|
# all 1's and fills the whole octet(s)
|
|
) == ints2octs((9, 4, 129, 252, 4, 3))
|
|
|
|
def testBin6(self):
|
|
assert encoder.encode(
|
|
univ.Real((1, 2, 262140)) # case of 3 octs for exponent and
|
|
# check that first 9 bits for exponent
|
|
# are not all 1's
|
|
) == ints2octs((9, 5, 130, 3, 255, 252, 1))
|
|
|
|
def testBin7(self):
|
|
assert encoder.encode(
|
|
univ.Real((-1, 2, 76354972)) # case of >3 octs for exponent and
|
|
# mantissa < 0
|
|
) == ints2octs((9, 7, 195, 4, 4, 141, 21, 156, 1))
|
|
|
|
def testPlusInf(self):
|
|
assert encoder.encode(univ.Real('inf')) == ints2octs((9, 1, 64))
|
|
|
|
def testMinusInf(self):
|
|
assert encoder.encode(univ.Real('-inf')) == ints2octs((9, 1, 65))
|
|
|
|
def testZero(self):
|
|
assert encoder.encode(univ.Real(0)) == ints2octs((9, 0))
|
|
|
|
|
|
class RealEncoderWithSchemaTestCase(BaseTestCase):
|
|
def testChar(self):
|
|
assert encoder.encode(
|
|
(123, 10, 11), asn1Spec=univ.Real()
|
|
) == ints2octs((9, 7, 3, 49, 50, 51, 69, 49, 49))
|
|
|
|
|
|
if sys.version_info[0:2] > (2, 5):
|
|
class UniversalStringEncoderTestCase(BaseTestCase):
|
|
def testEncoding(self):
|
|
assert encoder.encode(char.UniversalString(sys.version_info[0] >= 3 and 'abc' or unicode('abc'))) == ints2octs(
|
|
(28, 12, 0, 0, 0, 97, 0, 0, 0, 98, 0, 0, 0, 99)), 'Incorrect encoding'
|
|
|
|
|
|
class UniversalStringEncoderWithSchemaTestCase(BaseTestCase):
|
|
def testEncoding(self):
|
|
assert encoder.encode(
|
|
sys.version_info[0] >= 3 and 'abc' or unicode('abc'), asn1Spec=char.UniversalString()
|
|
) == ints2octs((28, 12, 0, 0, 0, 97, 0, 0, 0, 98, 0, 0, 0, 99)), 'Incorrect encoding'
|
|
|
|
|
|
class BMPStringEncoderTestCase(BaseTestCase):
|
|
def testEncoding(self):
|
|
assert encoder.encode(char.BMPString(sys.version_info[0] >= 3 and 'abc' or unicode('abc'))) == ints2octs(
|
|
(30, 6, 0, 97, 0, 98, 0, 99)), 'Incorrect encoding'
|
|
|
|
|
|
class BMPStringEncoderWithSchemaTestCase(BaseTestCase):
|
|
def testEncoding(self):
|
|
assert encoder.encode(
|
|
sys.version_info[0] >= 3 and 'abc' or unicode('abc'), asn1Spec=char.BMPString()
|
|
) == ints2octs((30, 6, 0, 97, 0, 98, 0, 99)), 'Incorrect encoding'
|
|
|
|
|
|
class UTF8StringEncoderTestCase(BaseTestCase):
|
|
def testEncoding(self):
|
|
assert encoder.encode(char.UTF8String(sys.version_info[0] >= 3 and 'abc' or unicode('abc'))) == ints2octs(
|
|
(12, 3, 97, 98, 99)), 'Incorrect encoding'
|
|
|
|
|
|
class UTF8StringEncoderWithSchemaTestCase(BaseTestCase):
|
|
def testEncoding(self):
|
|
assert encoder.encode(
|
|
sys.version_info[0] >= 3 and 'abc' or unicode('abc'), asn1Spec=char.UTF8String()
|
|
) == ints2octs((12, 3, 97, 98, 99)), 'Incorrect encoding'
|
|
|
|
|
|
class SequenceOfEncoderTestCase(BaseTestCase):
|
|
def testEmpty(self):
|
|
s = univ.SequenceOf()
|
|
s.clear()
|
|
assert encoder.encode(s) == ints2octs((48, 0))
|
|
|
|
def testDefMode(self):
|
|
s = univ.SequenceOf()
|
|
s.setComponentByPosition(0, univ.OctetString('quick brown'))
|
|
assert encoder.encode(s) == ints2octs((48, 13, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
|
|
|
|
def testIndefMode(self):
|
|
s = univ.SequenceOf()
|
|
s.setComponentByPosition(0, univ.OctetString('quick brown'))
|
|
assert encoder.encode(
|
|
s, defMode=False
|
|
) == ints2octs((48, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
|
|
|
|
def testDefModeChunked(self):
|
|
s = univ.SequenceOf()
|
|
s.setComponentByPosition(0, univ.OctetString('quick brown'))
|
|
assert encoder.encode(
|
|
s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((48, 19, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
|
|
|
|
def testIndefModeChunked(self):
|
|
s = univ.SequenceOf()
|
|
s.setComponentByPosition(0, univ.OctetString('quick brown'))
|
|
assert encoder.encode(
|
|
s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((48, 128, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
|
|
|
|
|
|
class SequenceOfEncoderWithSchemaTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.SequenceOf(componentType=univ.OctetString())
|
|
self.v = ['quick brown']
|
|
|
|
def testEmpty(self):
|
|
assert encoder.encode([], asn1Spec=self.s) == ints2octs((48, 0))
|
|
|
|
def testDefMode(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s
|
|
) == ints2octs((48, 13, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
|
|
|
|
def testIndefMode(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s, defMode=False
|
|
) == ints2octs((48, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
|
|
|
|
def testDefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((48, 19, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
|
|
|
|
def testIndefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((48, 128, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
|
|
|
|
|
|
class SequenceOfEncoderWithComponentsSchemaTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.SequenceOf(componentType=univ.OctetString())
|
|
|
|
def __init(self):
|
|
self.s.clear()
|
|
self.s.setComponentByPosition(0, 'quick brown')
|
|
|
|
def testDefMode(self):
|
|
self.__init()
|
|
assert encoder.encode(self.s) == ints2octs((48, 13, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
|
|
|
|
def testIndefMode(self):
|
|
self.__init()
|
|
assert encoder.encode(
|
|
self.s, defMode=False
|
|
) == ints2octs((48, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
|
|
|
|
def testDefModeChunked(self):
|
|
self.__init()
|
|
assert encoder.encode(
|
|
self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((48, 19, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
|
|
|
|
def testIndefModeChunked(self):
|
|
self.__init()
|
|
assert encoder.encode(
|
|
self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((48, 128, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
|
|
|
|
|
|
class SetOfEncoderTestCase(BaseTestCase):
|
|
def testEmpty(self):
|
|
s = univ.SetOf()
|
|
s.clear()
|
|
assert encoder.encode(s) == ints2octs((49, 0))
|
|
|
|
def testDefMode(self):
|
|
s = univ.SetOf()
|
|
s.setComponentByPosition(0, univ.OctetString('quick brown'))
|
|
assert encoder.encode(s) == ints2octs((49, 13, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
|
|
|
|
def testIndefMode(self):
|
|
s = univ.SetOf()
|
|
s.setComponentByPosition(0, univ.OctetString('quick brown'))
|
|
assert encoder.encode(
|
|
s, defMode=False
|
|
) == ints2octs((49, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
|
|
|
|
def testDefModeChunked(self):
|
|
s = univ.SetOf()
|
|
s.setComponentByPosition(0, univ.OctetString('quick brown'))
|
|
assert encoder.encode(
|
|
s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((49, 19, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
|
|
|
|
def testIndefModeChunked(self):
|
|
s = univ.SetOf()
|
|
s.setComponentByPosition(0, univ.OctetString('quick brown'))
|
|
assert encoder.encode(
|
|
s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((49, 128, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
|
|
|
|
|
|
class SetOfEncoderWithSchemaTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.SetOf(componentType=univ.OctetString())
|
|
self.v = ['quick brown']
|
|
|
|
def testEmpty(self):
|
|
s = univ.SetOf()
|
|
assert encoder.encode([], asn1Spec=self.s) == ints2octs((49, 0))
|
|
|
|
def testDefMode(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s
|
|
) == ints2octs((49, 13, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
|
|
|
|
def testIndefMode(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s, defMode=False
|
|
) == ints2octs((49, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
|
|
|
|
def testDefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((49, 19, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
|
|
|
|
def testIndefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs(
|
|
(49, 128, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
|
|
|
|
|
|
class SetOfEncoderWithComponentsSchemaTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.SetOf(componentType=univ.OctetString())
|
|
|
|
def __init(self):
|
|
self.s.clear()
|
|
self.s.setComponentByPosition(0, 'quick brown')
|
|
|
|
def testDefMode(self):
|
|
self.__init()
|
|
assert encoder.encode(self.s) == ints2octs((49, 13, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
|
|
|
|
def testIndefMode(self):
|
|
self.__init()
|
|
assert encoder.encode(
|
|
self.s, defMode=False
|
|
) == ints2octs((49, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
|
|
|
|
def testDefModeChunked(self):
|
|
self.__init()
|
|
assert encoder.encode(
|
|
self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((49, 19, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
|
|
|
|
def testIndefModeChunked(self):
|
|
self.__init()
|
|
assert encoder.encode(
|
|
self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((49, 128, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
|
|
|
|
|
|
class SequenceEncoderTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.Sequence()
|
|
self.s.setComponentByPosition(0, univ.Null(''))
|
|
self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
|
|
self.s.setComponentByPosition(2, univ.Integer(1))
|
|
|
|
def testDefMode(self):
|
|
assert encoder.encode(self.s) == ints2octs((48, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
|
|
|
|
def testIndefMode(self):
|
|
assert encoder.encode(
|
|
self.s, defMode=False
|
|
) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
|
|
|
|
def testDefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((48, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1))
|
|
|
|
def testIndefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((48, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0))
|
|
|
|
|
|
class SequenceEncoderWithSchemaTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.Sequence(
|
|
componentType=namedtype.NamedTypes(
|
|
namedtype.NamedType('place-holder', univ.Null()),
|
|
namedtype.OptionalNamedType('first-name', univ.OctetString()),
|
|
namedtype.DefaultedNamedType('age', univ.Integer(33)),
|
|
)
|
|
)
|
|
self.v = {
|
|
'place-holder': None,
|
|
'first-name': 'quick brown',
|
|
'age': 1
|
|
}
|
|
|
|
def testEmpty(self):
|
|
try:
|
|
assert encoder.encode({}, asn1Spec=self.s)
|
|
|
|
except PyAsn1Error:
|
|
pass
|
|
|
|
else:
|
|
assert False, 'empty bare sequence tolerated'
|
|
|
|
def testDefMode(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s
|
|
) == ints2octs((48, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
|
|
|
|
def testIndefMode(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s, defMode=False
|
|
) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
|
|
|
|
def testDefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((48, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1))
|
|
|
|
def testIndefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((48, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0))
|
|
|
|
|
|
class SequenceEncoderWithUntaggedOpenTypesTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
|
|
openType = opentype.OpenType(
|
|
'id',
|
|
{1: univ.Integer(),
|
|
2: univ.OctetString()}
|
|
)
|
|
self.s = univ.Sequence(
|
|
componentType=namedtype.NamedTypes(
|
|
namedtype.NamedType('id', univ.Integer()),
|
|
namedtype.NamedType('blob', univ.Any(), openType=openType)
|
|
)
|
|
)
|
|
|
|
def testEncodeOpenTypeChoiceOne(self):
|
|
self.s.clear()
|
|
|
|
self.s[0] = 1
|
|
self.s[1] = univ.Integer(12)
|
|
|
|
assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
|
|
(48, 5, 2, 1, 1, 49, 50)
|
|
)
|
|
|
|
def testEncodeOpenTypeChoiceTwo(self):
|
|
self.s.clear()
|
|
|
|
self.s[0] = 2
|
|
self.s[1] = univ.OctetString('quick brown')
|
|
|
|
assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
|
|
(48, 14, 2, 1, 2, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110)
|
|
)
|
|
|
|
def testEncodeOpenTypeUnknownId(self):
|
|
self.s.clear()
|
|
|
|
self.s[0] = 2
|
|
self.s[1] = univ.ObjectIdentifier('1.3.6')
|
|
|
|
try:
|
|
encoder.encode(self.s, asn1Spec=self.s)
|
|
|
|
except PyAsn1Error:
|
|
assert False, 'incompatible open type tolerated'
|
|
|
|
def testEncodeOpenTypeIncompatibleType(self):
|
|
self.s.clear()
|
|
|
|
self.s[0] = 2
|
|
self.s[1] = univ.ObjectIdentifier('1.3.6')
|
|
|
|
try:
|
|
encoder.encode(self.s, asn1Spec=self.s)
|
|
|
|
except PyAsn1Error:
|
|
assert False, 'incompatible open type tolerated'
|
|
|
|
|
|
class SequenceEncoderWithImplicitlyTaggedOpenTypesTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
|
|
openType = opentype.OpenType(
|
|
'id',
|
|
{1: univ.Integer(),
|
|
2: univ.OctetString()}
|
|
)
|
|
self.s = univ.Sequence(
|
|
componentType=namedtype.NamedTypes(
|
|
namedtype.NamedType('id', univ.Integer()),
|
|
namedtype.NamedType('blob', univ.Any().subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3)), openType=openType)
|
|
)
|
|
)
|
|
|
|
def testEncodeOpenTypeChoiceOne(self):
|
|
self.s.clear()
|
|
|
|
self.s[0] = 1
|
|
self.s[1] = univ.Integer(12)
|
|
|
|
assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
|
|
(48, 9, 2, 1, 1, 131, 4, 131, 2, 49, 50)
|
|
)
|
|
|
|
|
|
class SequenceEncoderWithExplicitlyTaggedOpenTypesTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
|
|
openType = opentype.OpenType(
|
|
'id',
|
|
{1: univ.Integer(),
|
|
2: univ.OctetString()}
|
|
)
|
|
self.s = univ.Sequence(
|
|
componentType=namedtype.NamedTypes(
|
|
namedtype.NamedType('id', univ.Integer()),
|
|
namedtype.NamedType('blob', univ.Any().subtype(explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3)), openType=openType)
|
|
)
|
|
)
|
|
|
|
def testEncodeOpenTypeChoiceOne(self):
|
|
self.s.clear()
|
|
|
|
self.s[0] = 1
|
|
self.s[1] = univ.Integer(12)
|
|
|
|
assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
|
|
(48, 9, 2, 1, 1, 163, 4, 163, 2, 49, 50)
|
|
)
|
|
|
|
|
|
class SequenceEncoderWithUntaggedSetOfOpenTypesTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
|
|
openType = opentype.OpenType(
|
|
'id',
|
|
{1: univ.Integer(),
|
|
2: univ.OctetString()}
|
|
)
|
|
self.s = univ.Sequence(
|
|
componentType=namedtype.NamedTypes(
|
|
namedtype.NamedType('id', univ.Integer()),
|
|
namedtype.NamedType('blob', univ.SetOf(
|
|
componentType=univ.Any()), openType=openType)
|
|
)
|
|
)
|
|
|
|
def testEncodeOpenTypeChoiceOne(self):
|
|
self.s.clear()
|
|
|
|
self.s[0] = 1
|
|
self.s[1].append(univ.Integer(12))
|
|
|
|
assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
|
|
(48, 7, 2, 1, 1, 49, 2, 49, 50)
|
|
)
|
|
|
|
def testEncodeOpenTypeChoiceTwo(self):
|
|
self.s.clear()
|
|
|
|
self.s[0] = 2
|
|
self.s[1].append(univ.OctetString('quick brown'))
|
|
|
|
assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
|
|
(48, 16, 2, 1, 2, 49, 11, 113, 117, 105, 99, 107, 32, 98, 114,
|
|
111, 119, 110)
|
|
)
|
|
|
|
def testEncodeOpenTypeUnknownId(self):
|
|
self.s.clear()
|
|
|
|
self.s[0] = 2
|
|
self.s[1].append(univ.ObjectIdentifier('1.3.6'))
|
|
|
|
try:
|
|
encoder.encode(self.s, asn1Spec=self.s)
|
|
|
|
except PyAsn1Error:
|
|
assert False, 'incompatible open type tolerated'
|
|
|
|
def testEncodeOpenTypeIncompatibleType(self):
|
|
self.s.clear()
|
|
|
|
self.s[0] = 2
|
|
self.s[1].append(univ.ObjectIdentifier('1.3.6'))
|
|
|
|
try:
|
|
encoder.encode(self.s, asn1Spec=self.s)
|
|
|
|
except PyAsn1Error:
|
|
assert False, 'incompatible open type tolerated'
|
|
|
|
|
|
class SequenceEncoderWithImplicitlyTaggedSetOfOpenTypesTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
|
|
openType = opentype.OpenType(
|
|
'id',
|
|
{1: univ.Integer(),
|
|
2: univ.OctetString()}
|
|
)
|
|
self.s = univ.Sequence(
|
|
componentType=namedtype.NamedTypes(
|
|
namedtype.NamedType('id', univ.Integer()),
|
|
namedtype.NamedType('blob', univ.SetOf(
|
|
componentType=univ.Any().subtype(
|
|
implicitTag=tag.Tag(
|
|
tag.tagClassContext, tag.tagFormatSimple, 3))),
|
|
openType=openType)
|
|
)
|
|
)
|
|
|
|
def testEncodeOpenTypeChoiceOne(self):
|
|
self.s.clear()
|
|
|
|
self.s[0] = 1
|
|
self.s[1].append(univ.Integer(12))
|
|
|
|
assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
|
|
(48, 11, 2, 1, 1, 49, 6, 131, 4, 131, 2, 49, 50)
|
|
)
|
|
|
|
|
|
class SequenceEncoderWithExplicitlyTaggedSetOfOpenTypesTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
|
|
openType = opentype.OpenType(
|
|
'id',
|
|
{1: univ.Integer(),
|
|
2: univ.OctetString()}
|
|
)
|
|
self.s = univ.Sequence(
|
|
componentType=namedtype.NamedTypes(
|
|
namedtype.NamedType('id', univ.Integer()),
|
|
namedtype.NamedType('blob', univ.SetOf(
|
|
componentType=univ.Any().subtype(
|
|
explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3))),
|
|
openType=openType)
|
|
)
|
|
)
|
|
|
|
def testEncodeOpenTypeChoiceOne(self):
|
|
self.s.clear()
|
|
|
|
self.s[0] = 1
|
|
self.s[1].append(univ.Integer(12))
|
|
|
|
assert encoder.encode(self.s, asn1Spec=self.s) == ints2octs(
|
|
(48, 11, 2, 1, 1, 49, 6, 163, 4, 163, 2, 49, 50)
|
|
)
|
|
|
|
|
|
class SequenceEncoderWithComponentsSchemaTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.Sequence(
|
|
componentType=namedtype.NamedTypes(
|
|
namedtype.NamedType('place-holder', univ.Null()),
|
|
namedtype.OptionalNamedType('first-name', univ.OctetString()),
|
|
namedtype.DefaultedNamedType('age', univ.Integer(33)),
|
|
)
|
|
)
|
|
|
|
def __init(self):
|
|
self.s.clear()
|
|
self.s.setComponentByPosition(0, '')
|
|
|
|
def __initWithOptional(self):
|
|
self.s.clear()
|
|
self.s.setComponentByPosition(0, '')
|
|
self.s.setComponentByPosition(1, 'quick brown')
|
|
|
|
def __initWithDefaulted(self):
|
|
self.s.clear()
|
|
self.s.setComponentByPosition(0, '')
|
|
self.s.setComponentByPosition(2, 1)
|
|
|
|
def __initWithOptionalAndDefaulted(self):
|
|
self.s.clear()
|
|
self.s.setComponentByPosition(0, univ.Null(''))
|
|
self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
|
|
self.s.setComponentByPosition(2, univ.Integer(1))
|
|
|
|
def testDefMode(self):
|
|
self.__init()
|
|
assert encoder.encode(self.s) == ints2octs((48, 2, 5, 0))
|
|
|
|
def testIndefMode(self):
|
|
self.__init()
|
|
assert encoder.encode(
|
|
self.s, defMode=False
|
|
) == ints2octs((48, 128, 5, 0, 0, 0))
|
|
|
|
def testDefModeChunked(self):
|
|
self.__init()
|
|
assert encoder.encode(
|
|
self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((48, 2, 5, 0))
|
|
|
|
def testIndefModeChunked(self):
|
|
self.__init()
|
|
assert encoder.encode(
|
|
self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((48, 128, 5, 0, 0, 0))
|
|
|
|
def testWithOptionalDefMode(self):
|
|
self.__initWithOptional()
|
|
assert encoder.encode(self.s) == ints2octs(
|
|
(48, 15, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
|
|
|
|
def testWithOptionalIndefMode(self):
|
|
self.__initWithOptional()
|
|
assert encoder.encode(
|
|
self.s, defMode=False
|
|
) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
|
|
|
|
def testWithOptionalDefModeChunked(self):
|
|
self.__initWithOptional()
|
|
assert encoder.encode(
|
|
self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((48, 21, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
|
|
|
|
def testWithOptionalIndefModeChunked(self):
|
|
self.__initWithOptional()
|
|
assert encoder.encode(
|
|
self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs(
|
|
(48, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
|
|
|
|
def testWithDefaultedDefMode(self):
|
|
self.__initWithDefaulted()
|
|
assert encoder.encode(self.s) == ints2octs((48, 5, 5, 0, 2, 1, 1))
|
|
|
|
def testWithDefaultedIndefMode(self):
|
|
self.__initWithDefaulted()
|
|
assert encoder.encode(
|
|
self.s, defMode=False
|
|
) == ints2octs((48, 128, 5, 0, 2, 1, 1, 0, 0))
|
|
|
|
def testWithDefaultedDefModeChunked(self):
|
|
self.__initWithDefaulted()
|
|
assert encoder.encode(
|
|
self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((48, 5, 5, 0, 2, 1, 1))
|
|
|
|
def testWithDefaultedIndefModeChunked(self):
|
|
self.__initWithDefaulted()
|
|
assert encoder.encode(
|
|
self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((48, 128, 5, 0, 2, 1, 1, 0, 0))
|
|
|
|
def testWithOptionalAndDefaultedDefMode(self):
|
|
self.__initWithOptionalAndDefaulted()
|
|
assert encoder.encode(self.s) == ints2octs(
|
|
(48, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
|
|
|
|
def testWithOptionalAndDefaultedIndefMode(self):
|
|
self.__initWithOptionalAndDefaulted()
|
|
assert encoder.encode(
|
|
self.s, defMode=False
|
|
) == ints2octs((48, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
|
|
|
|
def testWithOptionalAndDefaultedDefModeChunked(self):
|
|
self.__initWithOptionalAndDefaulted()
|
|
assert encoder.encode(
|
|
self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs(
|
|
(48, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1))
|
|
|
|
def testWithOptionalAndDefaultedIndefModeChunked(self):
|
|
self.__initWithOptionalAndDefaulted()
|
|
assert encoder.encode(
|
|
self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((48, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0,
|
|
0, 2, 1, 1, 0, 0))
|
|
|
|
|
|
class ExpTaggedSequenceEncoderTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
s = univ.Sequence(
|
|
componentType=namedtype.NamedTypes(
|
|
namedtype.NamedType('number', univ.Integer()),
|
|
)
|
|
)
|
|
|
|
s = s.subtype(
|
|
explicitTag=tag.Tag(tag.tagClassApplication, tag.tagFormatConstructed, 5)
|
|
)
|
|
|
|
s[0] = 12
|
|
|
|
self.s = s
|
|
|
|
def testDefMode(self):
|
|
assert encoder.encode(self.s) == ints2octs((101, 5, 48, 3, 2, 1, 12))
|
|
|
|
def testIndefMode(self):
|
|
assert encoder.encode(
|
|
self.s, defMode=False
|
|
) == ints2octs((101, 128, 48, 128, 2, 1, 12, 0, 0, 0, 0))
|
|
|
|
|
|
class ExpTaggedSequenceComponentEncoderTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.Sequence(
|
|
componentType=namedtype.NamedTypes(
|
|
namedtype.NamedType('number', univ.Boolean().subtype(explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
|
|
)
|
|
)
|
|
|
|
self.s[0] = True
|
|
|
|
def testDefMode(self):
|
|
assert encoder.encode(self.s) == ints2octs((48, 5, 160, 3, 1, 1, 1))
|
|
|
|
def testIndefMode(self):
|
|
assert encoder.encode(
|
|
self.s, defMode=False
|
|
) == ints2octs((48, 128, 160, 3, 1, 1, 1, 0, 0, 0, 0))
|
|
|
|
|
|
class SetEncoderTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.Set()
|
|
self.s.setComponentByPosition(0, univ.Null(''))
|
|
self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
|
|
self.s.setComponentByPosition(2, univ.Integer(1))
|
|
|
|
def testDefMode(self):
|
|
assert encoder.encode(self.s) == ints2octs((49, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
|
|
|
|
def testIndefMode(self):
|
|
assert encoder.encode(
|
|
self.s, defMode=False
|
|
) == ints2octs((49, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
|
|
|
|
def testDefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((49, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1))
|
|
|
|
def testIndefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((49, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0))
|
|
|
|
|
|
class SetEncoderWithSchemaTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.Set(
|
|
componentType=namedtype.NamedTypes(
|
|
namedtype.NamedType('place-holder', univ.Null()),
|
|
namedtype.OptionalNamedType('first-name', univ.OctetString()),
|
|
namedtype.DefaultedNamedType('age', univ.Integer(33)),
|
|
)
|
|
)
|
|
self.v = {
|
|
'place-holder': None,
|
|
'first-name': 'quick brown',
|
|
'age': 1
|
|
}
|
|
|
|
def testEmpty(self):
|
|
try:
|
|
assert encoder.encode({}, asn1Spec=self.s)
|
|
|
|
except PyAsn1Error:
|
|
pass
|
|
|
|
else:
|
|
assert False, 'empty bare SET tolerated'
|
|
|
|
def testDefMode(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s
|
|
) == ints2octs((49, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
|
|
|
|
def testIndefMode(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s, defMode=False
|
|
) == ints2octs((49, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
|
|
|
|
def testDefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((49, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1))
|
|
|
|
def testIndefModeChunked(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((49, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0))
|
|
|
|
|
|
class SetEncoderWithComponentsSchemaTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.Set(
|
|
componentType=namedtype.NamedTypes(
|
|
namedtype.NamedType('place-holder', univ.Null()),
|
|
namedtype.OptionalNamedType('first-name', univ.OctetString()),
|
|
namedtype.DefaultedNamedType('age', univ.Integer(33)),
|
|
)
|
|
)
|
|
|
|
def __init(self):
|
|
self.s.clear()
|
|
self.s.setComponentByPosition(0, '')
|
|
|
|
def __initWithOptional(self):
|
|
self.s.clear()
|
|
self.s.setComponentByPosition(0, '')
|
|
self.s.setComponentByPosition(1, 'quick brown')
|
|
|
|
def __initWithDefaulted(self):
|
|
self.s.clear()
|
|
self.s.setComponentByPosition(0, '')
|
|
self.s.setComponentByPosition(2, 1)
|
|
|
|
def __initWithOptionalAndDefaulted(self):
|
|
self.s.clear()
|
|
self.s.setComponentByPosition(0, univ.Null(''))
|
|
self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
|
|
self.s.setComponentByPosition(2, univ.Integer(1))
|
|
|
|
def testDefMode(self):
|
|
self.__init()
|
|
assert encoder.encode(self.s) == ints2octs((49, 2, 5, 0))
|
|
|
|
def testIndefMode(self):
|
|
self.__init()
|
|
assert encoder.encode(
|
|
self.s, defMode=False
|
|
) == ints2octs((49, 128, 5, 0, 0, 0))
|
|
|
|
def testDefModeChunked(self):
|
|
self.__init()
|
|
assert encoder.encode(
|
|
self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((49, 2, 5, 0))
|
|
|
|
def testIndefModeChunked(self):
|
|
self.__init()
|
|
assert encoder.encode(
|
|
self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((49, 128, 5, 0, 0, 0))
|
|
|
|
def testWithOptionalDefMode(self):
|
|
self.__initWithOptional()
|
|
assert encoder.encode(self.s) == ints2octs(
|
|
(49, 15, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
|
|
|
|
def testWithOptionalIndefMode(self):
|
|
self.__initWithOptional()
|
|
assert encoder.encode(
|
|
self.s, defMode=False
|
|
) == ints2octs((49, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0))
|
|
|
|
def testWithOptionalDefModeChunked(self):
|
|
self.__initWithOptional()
|
|
assert encoder.encode(
|
|
self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((49, 21, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
|
|
|
|
def testWithOptionalIndefModeChunked(self):
|
|
self.__initWithOptional()
|
|
assert encoder.encode(
|
|
self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs(
|
|
(49, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 0, 0))
|
|
|
|
def testWithDefaultedDefMode(self):
|
|
self.__initWithDefaulted()
|
|
assert encoder.encode(self.s) == ints2octs((49, 5, 5, 0, 2, 1, 1))
|
|
|
|
def testWithDefaultedIndefMode(self):
|
|
self.__initWithDefaulted()
|
|
assert encoder.encode(
|
|
self.s, defMode=False
|
|
) == ints2octs((49, 128, 5, 0, 2, 1, 1, 0, 0))
|
|
|
|
def testWithDefaultedDefModeChunked(self):
|
|
self.__initWithDefaulted()
|
|
assert encoder.encode(
|
|
self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((49, 5, 5, 0, 2, 1, 1))
|
|
|
|
def testWithDefaultedIndefModeChunked(self):
|
|
self.__initWithDefaulted()
|
|
assert encoder.encode(
|
|
self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((49, 128, 5, 0, 2, 1, 1, 0, 0))
|
|
|
|
def testWithOptionalAndDefaultedDefMode(self):
|
|
self.__initWithOptionalAndDefaulted()
|
|
assert encoder.encode(self.s) == ints2octs(
|
|
(49, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
|
|
|
|
def testWithOptionalAndDefaultedIndefMode(self):
|
|
self.__initWithOptionalAndDefaulted()
|
|
assert encoder.encode(
|
|
self.s, defMode=False
|
|
) == ints2octs((49, 128, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1, 0, 0))
|
|
|
|
def testWithOptionalAndDefaultedDefModeChunked(self):
|
|
self.__initWithOptionalAndDefaulted()
|
|
assert encoder.encode(
|
|
self.s, defMode=True, maxChunkSize=4
|
|
) == ints2octs(
|
|
(49, 24, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 2, 1, 1))
|
|
|
|
def testWithOptionalAndDefaultedIndefModeChunked(self):
|
|
self.__initWithOptionalAndDefaulted()
|
|
assert encoder.encode(
|
|
self.s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((49, 128, 5, 0, 36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0))
|
|
|
|
|
|
class ChoiceEncoderTestCase(BaseTestCase):
|
|
|
|
def testEmpty(self):
|
|
s = univ.Choice()
|
|
try:
|
|
encoder.encode(s)
|
|
except PyAsn1Error:
|
|
pass
|
|
else:
|
|
assert 0, 'encoded unset choice'
|
|
|
|
def testDefModeOptionOne(self):
|
|
s = univ.Choice()
|
|
s.setComponentByPosition(0, univ.Null(''))
|
|
assert encoder.encode(s) == ints2octs((5, 0))
|
|
|
|
def testDefModeOptionTwo(self):
|
|
s = univ.Choice()
|
|
s.setComponentByPosition(0, univ.OctetString('quick brown'))
|
|
assert encoder.encode(s) == ints2octs((4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
|
|
|
|
def testIndefMode(self):
|
|
s = univ.Choice()
|
|
s.setComponentByPosition(0, univ.OctetString('quick brown'))
|
|
assert encoder.encode(
|
|
s, defMode=False
|
|
) == ints2octs((4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110))
|
|
|
|
def testDefModeChunked(self):
|
|
s = univ.Choice()
|
|
s.setComponentByPosition(0, univ.OctetString('quick brown'))
|
|
assert encoder.encode(
|
|
s, defMode=True, maxChunkSize=4
|
|
) == ints2octs((36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110))
|
|
|
|
def testIndefModeChunked(self):
|
|
s = univ.Choice()
|
|
s.setComponentByPosition(0, univ.OctetString('quick brown'))
|
|
assert encoder.encode(
|
|
s, defMode=False, maxChunkSize=4
|
|
) == ints2octs((36, 128, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110, 0, 0))
|
|
|
|
|
|
class ChoiceEncoderWithSchemaTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.Choice(
|
|
componentType=namedtype.NamedTypes(
|
|
namedtype.NamedType('place-holder', univ.Null('')),
|
|
namedtype.NamedType('number', univ.Integer(0)),
|
|
namedtype.NamedType('string', univ.OctetString())
|
|
)
|
|
)
|
|
self.v = {
|
|
'place-holder': None
|
|
}
|
|
|
|
def testFilled(self):
|
|
assert encoder.encode(
|
|
self.v, asn1Spec=self.s
|
|
) == ints2octs((5, 0))
|
|
|
|
|
|
class ChoiceEncoderWithComponentsSchemaTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.Choice(
|
|
componentType=namedtype.NamedTypes(
|
|
namedtype.NamedType('place-holder', univ.Null('')),
|
|
namedtype.NamedType('number', univ.Integer(0)),
|
|
namedtype.NamedType('string', univ.OctetString())
|
|
)
|
|
)
|
|
|
|
def testEmpty(self):
|
|
try:
|
|
encoder.encode(self.s)
|
|
except PyAsn1Error:
|
|
pass
|
|
else:
|
|
assert 0, 'encoded unset choice'
|
|
|
|
def testFilled(self):
|
|
self.s.setComponentByPosition(0, univ.Null(''))
|
|
assert encoder.encode(self.s) == ints2octs((5, 0))
|
|
|
|
def testTagged(self):
|
|
s = self.s.subtype(
|
|
explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 4)
|
|
)
|
|
s.setComponentByPosition(0, univ.Null(''))
|
|
assert encoder.encode(s) == ints2octs((164, 2, 5, 0))
|
|
|
|
def testUndefLength(self):
|
|
self.s.setComponentByPosition(2, univ.OctetString('abcdefgh'))
|
|
assert encoder.encode(self.s, defMode=False, maxChunkSize=3) == ints2octs(
|
|
(36, 128, 4, 3, 97, 98, 99, 4, 3, 100, 101, 102, 4, 2, 103, 104, 0, 0))
|
|
|
|
def testTaggedUndefLength(self):
|
|
s = self.s.subtype(
|
|
explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 4)
|
|
)
|
|
s.setComponentByPosition(2, univ.OctetString('abcdefgh'))
|
|
assert encoder.encode(s, defMode=False, maxChunkSize=3) == ints2octs(
|
|
(164, 128, 36, 128, 4, 3, 97, 98, 99, 4, 3, 100, 101, 102, 4, 2, 103, 104, 0, 0, 0, 0))
|
|
|
|
|
|
class AnyEncoderTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.Any(encoder.encode(univ.OctetString('fox')))
|
|
|
|
def testUntagged(self):
|
|
assert encoder.encode(self.s) == ints2octs((4, 3, 102, 111, 120))
|
|
|
|
def testTaggedEx(self):
|
|
s = self.s.subtype(
|
|
explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4)
|
|
)
|
|
assert encoder.encode(s) == ints2octs((164, 5, 4, 3, 102, 111, 120))
|
|
|
|
def testTaggedIm(self):
|
|
s = self.s.subtype(
|
|
implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4)
|
|
)
|
|
assert encoder.encode(s) == ints2octs((132, 5, 4, 3, 102, 111, 120))
|
|
|
|
|
|
class AnyEncoderWithSchemaTestCase(BaseTestCase):
|
|
def setUp(self):
|
|
BaseTestCase.setUp(self)
|
|
self.s = univ.Any()
|
|
self.v = encoder.encode(univ.OctetString('fox'))
|
|
|
|
def testUntagged(self):
|
|
assert encoder.encode(self.v, asn1Spec=self.s) == ints2octs((4, 3, 102, 111, 120))
|
|
|
|
def testTaggedEx(self):
|
|
s = self.s.subtype(
|
|
explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4)
|
|
)
|
|
assert encoder.encode(self.v, asn1Spec=s) == ints2octs((164, 5, 4, 3, 102, 111, 120))
|
|
|
|
def testTaggedIm(self):
|
|
s = self.s.subtype(
|
|
implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4)
|
|
)
|
|
assert encoder.encode(self.v, asn1Spec=s) == ints2octs((132, 5, 4, 3, 102, 111, 120))
|
|
|
|
|
|
suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__])
|
|
|
|
if __name__ == '__main__':
|
|
unittest.TextTestRunner(verbosity=2).run(suite)
|