mirror of
https://repo.dactyloidae.xyz/Dactyloidae/UXP.git
synced 2026-09-05 07:18:39 +09:00
import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo
This commit is contained in:
Roy Tam
commit
dcd9973243
150858 changed files with 23884658 additions and 0 deletions
1
python/pyasn1/test/__init__.py
Normal file
1
python/pyasn1/test/__init__.py
Normal file
|
|
@ -0,0 +1 @@
|
|||
# This file is necessary to make this directory a package.
|
||||
1
python/pyasn1/test/codec/__init__.py
Normal file
1
python/pyasn1/test/codec/__init__.py
Normal file
|
|
@ -0,0 +1 @@
|
|||
# This file is necessary to make this directory a package.
|
||||
1
python/pyasn1/test/codec/ber/__init__.py
Normal file
1
python/pyasn1/test/codec/ber/__init__.py
Normal file
|
|
@ -0,0 +1 @@
|
|||
# This file is necessary to make this directory a package.
|
||||
22
python/pyasn1/test/codec/ber/suite.py
Normal file
22
python/pyasn1/test/codec/ber/suite.py
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
from sys import path, version_info
|
||||
from os.path import sep
|
||||
path.insert(1, path[0]+sep+'ber')
|
||||
import test_encoder, test_decoder
|
||||
from pyasn1.error import PyAsn1Error
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
suite = unittest.TestSuite()
|
||||
loader = unittest.TestLoader()
|
||||
for m in (test_encoder, test_decoder):
|
||||
suite.addTest(loader.loadTestsFromModule(m))
|
||||
|
||||
def runTests(): unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
|
||||
if __name__ == '__main__': runTests()
|
||||
535
python/pyasn1/test/codec/ber/test_decoder.py
Normal file
535
python/pyasn1/test/codec/ber/test_decoder.py
Normal file
|
|
@ -0,0 +1,535 @@
|
|||
from pyasn1.type import tag, namedtype, univ
|
||||
from pyasn1.codec.ber import decoder
|
||||
from pyasn1.compat.octets import ints2octs, str2octs, null
|
||||
from pyasn1.error import PyAsn1Error
|
||||
from sys import version_info
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
class LargeTagDecoderTestCase(unittest.TestCase):
|
||||
def testLargeTag(self):
|
||||
assert decoder.decode(ints2octs((127, 141, 245, 182, 253, 47, 3, 2, 1, 1))) == (1, null)
|
||||
|
||||
class IntegerDecoderTestCase(unittest.TestCase):
|
||||
def testPosInt(self):
|
||||
assert decoder.decode(ints2octs((2, 1, 12))) == (12, null)
|
||||
def testNegInt(self):
|
||||
assert decoder.decode(ints2octs((2, 1, 244))) == (-12, null)
|
||||
def testZero(self):
|
||||
assert decoder.decode(ints2octs((2, 0))) == (0, null)
|
||||
def testZeroLong(self):
|
||||
assert decoder.decode(ints2octs((2, 1, 0))) == (0, null)
|
||||
def testMinusOne(self):
|
||||
assert decoder.decode(ints2octs((2, 1, 255))) == (-1, null)
|
||||
def testPosLong(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((2, 9, 0, 255, 255, 255, 255, 255, 255, 255, 255))
|
||||
) == (0xffffffffffffffff, null)
|
||||
def testNegLong(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((2, 9, 255, 0, 0, 0, 0, 0, 0, 0, 1))
|
||||
) == (-0xffffffffffffffff, null)
|
||||
def testSpec(self):
|
||||
try:
|
||||
decoder.decode(
|
||||
ints2octs((2, 1, 12)), asn1Spec=univ.Null()
|
||||
) == (12, null)
|
||||
except PyAsn1Error:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'wrong asn1Spec worked out'
|
||||
assert decoder.decode(
|
||||
ints2octs((2, 1, 12)), asn1Spec=univ.Integer()
|
||||
) == (12, null)
|
||||
def testTagFormat(self):
|
||||
try:
|
||||
decoder.decode(ints2octs((34, 1, 12)))
|
||||
except PyAsn1Error:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'wrong tagFormat worked out'
|
||||
|
||||
class BooleanDecoderTestCase(unittest.TestCase):
|
||||
def testTrue(self):
|
||||
assert decoder.decode(ints2octs((1, 1, 1))) == (1, null)
|
||||
def testTrueNeg(self):
|
||||
assert decoder.decode(ints2octs((1, 1, 255))) == (1, null)
|
||||
def testExtraTrue(self):
|
||||
assert decoder.decode(ints2octs((1, 1, 1, 0, 120, 50, 50))) == (1, ints2octs((0, 120, 50, 50)))
|
||||
def testFalse(self):
|
||||
assert decoder.decode(ints2octs((1, 1, 0))) == (0, null)
|
||||
def testTagFormat(self):
|
||||
try:
|
||||
decoder.decode(ints2octs((33, 1, 1)))
|
||||
except PyAsn1Error:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'wrong tagFormat worked out'
|
||||
|
||||
class BitStringDecoderTestCase(unittest.TestCase):
|
||||
def testDefMode(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((3, 3, 1, 169, 138))
|
||||
) == ((1,0,1,0,1,0,0,1,1,0,0,0,1,0,1), null)
|
||||
def testIndefMode(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((3, 3, 1, 169, 138))
|
||||
) == ((1,0,1,0,1,0,0,1,1,0,0,0,1,0,1), null)
|
||||
def testDefModeChunked(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((35, 8, 3, 2, 0, 169, 3, 2, 1, 138))
|
||||
) == ((1,0,1,0,1,0,0,1,1,0,0,0,1,0,1), null)
|
||||
def testIndefModeChunked(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((35, 128, 3, 2, 0, 169, 3, 2, 1, 138, 0, 0))
|
||||
) == ((1,0,1,0,1,0,0,1,1,0,0,0,1,0,1), null)
|
||||
def testDefModeChunkedSubst(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((35, 8, 3, 2, 0, 169, 3, 2, 1, 138)),
|
||||
substrateFun=lambda a,b,c: (b,c)
|
||||
) == (ints2octs((3, 2, 0, 169, 3, 2, 1, 138)), 8)
|
||||
def testIndefModeChunkedSubst(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((35, 128, 3, 2, 0, 169, 3, 2, 1, 138, 0, 0)),
|
||||
substrateFun=lambda a,b,c: (b,c)
|
||||
) == (ints2octs((3, 2, 0, 169, 3, 2, 1, 138, 0, 0)), -1)
|
||||
|
||||
class OctetStringDecoderTestCase(unittest.TestCase):
|
||||
def testDefMode(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
|
||||
) == (str2octs('Quick brown fox'), null)
|
||||
def testIndefMode(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((36, 128, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 0, 0))
|
||||
) == (str2octs('Quick brown fox'), null)
|
||||
def testDefModeChunked(self):
|
||||
assert decoder.decode(
|
||||
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))
|
||||
) == (str2octs('Quick brown fox'), null)
|
||||
def testIndefModeChunked(self):
|
||||
assert decoder.decode(
|
||||
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))
|
||||
) == (str2octs('Quick brown fox'), null)
|
||||
def testDefModeChunkedSubst(self):
|
||||
assert decoder.decode(
|
||||
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)),
|
||||
substrateFun=lambda a,b,c: (b,c)
|
||||
) == (ints2octs((4, 4, 81, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 4, 111, 119, 110, 32, 4, 3, 102, 111, 120)), 23)
|
||||
def testIndefModeChunkedSubst(self):
|
||||
assert decoder.decode(
|
||||
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)),
|
||||
substrateFun=lambda a,b,c: (b,c)
|
||||
) == (ints2octs((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)), -1)
|
||||
|
||||
class ExpTaggedOctetStringDecoderTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.o = univ.OctetString(
|
||||
'Quick brown fox',
|
||||
tagSet=univ.OctetString.tagSet.tagExplicitly(
|
||||
tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 5)
|
||||
))
|
||||
|
||||
def testDefMode(self):
|
||||
assert self.o.isSameTypeWith(decoder.decode(
|
||||
ints2octs((101, 17, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
|
||||
)[0])
|
||||
|
||||
def testIndefMode(self):
|
||||
v, s = decoder.decode(ints2octs((101, 128, 36, 128, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 0, 0, 0, 0)))
|
||||
assert self.o.isSameTypeWith(v)
|
||||
assert not s
|
||||
|
||||
def testDefModeChunked(self):
|
||||
v, s = decoder.decode(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)))
|
||||
assert self.o.isSameTypeWith(v)
|
||||
assert not s
|
||||
|
||||
def testIndefModeChunked(self):
|
||||
v, s = decoder.decode(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)))
|
||||
assert self.o.isSameTypeWith(v)
|
||||
assert not s
|
||||
|
||||
def testDefModeSubst(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((101, 17, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120)),
|
||||
substrateFun=lambda a,b,c: (b,c)
|
||||
) == (ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120)), 17)
|
||||
|
||||
def testIndefModeSubst(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((101, 128, 36, 128, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 0, 0, 0, 0)),
|
||||
substrateFun=lambda a,b,c: (b,c)
|
||||
) == (ints2octs((36, 128, 4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 0, 0, 0, 0)), -1)
|
||||
|
||||
class NullDecoderTestCase(unittest.TestCase):
|
||||
def testNull(self):
|
||||
assert decoder.decode(ints2octs((5, 0))) == (null, null)
|
||||
def testTagFormat(self):
|
||||
try:
|
||||
decoder.decode(ints2octs((37, 0)))
|
||||
except PyAsn1Error:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'wrong tagFormat worked out'
|
||||
|
||||
class ObjectIdentifierDecoderTestCase(unittest.TestCase):
|
||||
def testOID(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((6, 6, 43, 6, 0, 191, 255, 126))
|
||||
) == ((1,3,6,0,0xffffe), null)
|
||||
|
||||
def testEdges1(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((6, 1, 255))
|
||||
) == ((6,15), null)
|
||||
|
||||
def testEdges2(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((6, 1, 239))
|
||||
) == ((5,39), null)
|
||||
|
||||
def testEdges3(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((6, 7, 43, 6, 143, 255, 255, 255, 127))
|
||||
) == ((1, 3, 6, 4294967295), null)
|
||||
|
||||
def testNonLeading0x80(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((6, 5, 85, 4, 129, 128, 0)),
|
||||
) == ((2, 5, 4, 16384), null)
|
||||
|
||||
def testLeading0x80(self):
|
||||
try:
|
||||
decoder.decode(
|
||||
ints2octs((6, 5, 85, 4, 128, 129, 0))
|
||||
)
|
||||
except PyAsn1Error:
|
||||
pass
|
||||
else:
|
||||
assert 1, 'Leading 0x80 tolarated'
|
||||
|
||||
def testTagFormat(self):
|
||||
try:
|
||||
decoder.decode(ints2octs((38, 1, 239)))
|
||||
except PyAsn1Error:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'wrong tagFormat worked out'
|
||||
|
||||
class RealDecoderTestCase(unittest.TestCase):
|
||||
def testChar(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((9, 7, 3, 49, 50, 51, 69, 49, 49))
|
||||
) == (univ.Real((123, 10, 11)), null)
|
||||
|
||||
def testBin1(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((9, 4, 128, 245, 4, 77))
|
||||
) == (univ.Real((1101, 2, -11)), null)
|
||||
|
||||
def testBin2(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((9, 4, 128, 11, 4, 77))
|
||||
) == (univ.Real((1101, 2, 11)), null)
|
||||
|
||||
def testBin3(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((9, 3, 192, 10, 123))
|
||||
) == (univ.Real((-123, 2, 10)), null)
|
||||
|
||||
|
||||
def testPlusInf(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((9, 1, 64))
|
||||
) == (univ.Real('inf'), null)
|
||||
|
||||
def testMinusInf(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((9, 1, 65))
|
||||
) == (univ.Real('-inf'), null)
|
||||
|
||||
def testEmpty(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((9, 0))
|
||||
) == (univ.Real(0.0), null)
|
||||
|
||||
def testTagFormat(self):
|
||||
try:
|
||||
decoder.decode(ints2octs((41, 0)))
|
||||
except PyAsn1Error:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'wrong tagFormat worked out'
|
||||
|
||||
class SequenceDecoderTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.s = univ.Sequence(componentType=namedtype.NamedTypes(
|
||||
namedtype.NamedType('place-holder', univ.Null(null)),
|
||||
namedtype.NamedType('first-name', univ.OctetString(null)),
|
||||
namedtype.NamedType('age', univ.Integer(33)),
|
||||
))
|
||||
self.s.setComponentByPosition(0, univ.Null(null))
|
||||
self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
|
||||
self.s.setComponentByPosition(2, univ.Integer(1))
|
||||
self.s.setDefaultComponents()
|
||||
|
||||
def testWithOptionalAndDefaultedDefMode(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithOptionalAndDefaultedIndefMode(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 128, 5, 0, 36, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0))
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithOptionalAndDefaultedDefModeChunked(self):
|
||||
assert decoder.decode(
|
||||
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))
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithOptionalAndDefaultedIndefModeChunked(self):
|
||||
assert decoder.decode(
|
||||
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))
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithOptionalAndDefaultedDefModeSubst(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1)),
|
||||
substrateFun=lambda a,b,c: (b,c)
|
||||
) == (ints2octs((5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1)), 18)
|
||||
|
||||
def testWithOptionalAndDefaultedIndefModeSubst(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 128, 5, 0, 36, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0)),
|
||||
substrateFun=lambda a,b,c: (b,c)
|
||||
) == (ints2octs((5, 0, 36, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0)), -1)
|
||||
|
||||
def testTagFormat(self):
|
||||
try:
|
||||
decoder.decode(
|
||||
ints2octs((16, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1))
|
||||
)
|
||||
except PyAsn1Error:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'wrong tagFormat worked out'
|
||||
|
||||
class GuidedSequenceDecoderTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.s = univ.Sequence(componentType=namedtype.NamedTypes(
|
||||
namedtype.NamedType('place-holder', univ.Null(null)),
|
||||
namedtype.OptionalNamedType('first-name', univ.OctetString(null)),
|
||||
namedtype.DefaultedNamedType('age', univ.Integer(33)),
|
||||
))
|
||||
|
||||
def __init(self):
|
||||
self.s.clear()
|
||||
self.s.setComponentByPosition(0, univ.Null(null))
|
||||
self.s.setDefaultComponents()
|
||||
|
||||
def __initWithOptional(self):
|
||||
self.s.clear()
|
||||
self.s.setComponentByPosition(0, univ.Null(null))
|
||||
self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
|
||||
self.s.setDefaultComponents()
|
||||
|
||||
def __initWithDefaulted(self):
|
||||
self.s.clear()
|
||||
self.s.setComponentByPosition(0, univ.Null(null))
|
||||
self.s.setComponentByPosition(2, univ.Integer(1))
|
||||
self.s.setDefaultComponents()
|
||||
|
||||
def __initWithOptionalAndDefaulted(self):
|
||||
self.s.clear()
|
||||
self.s.setComponentByPosition(0, univ.Null(null))
|
||||
self.s.setComponentByPosition(1, univ.OctetString('quick brown'))
|
||||
self.s.setComponentByPosition(2, univ.Integer(1))
|
||||
self.s.setDefaultComponents()
|
||||
|
||||
def testDefMode(self):
|
||||
self.__init()
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 128, 5, 0, 0, 0)), asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testIndefMode(self):
|
||||
self.__init()
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 128, 5, 0, 0, 0)), asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testDefModeChunked(self):
|
||||
self.__init()
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 2, 5, 0)), asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testIndefModeChunked(self):
|
||||
self.__init()
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 128, 5, 0, 0, 0)), asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithOptionalDefMode(self):
|
||||
self.__initWithOptional()
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 15, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110)), asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithOptionaIndefMode(self):
|
||||
self.__initWithOptional()
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 128, 5, 0, 36, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0, 0, 0)),
|
||||
asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithOptionalDefModeChunked(self):
|
||||
self.__initWithOptional()
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 21, 5, 0, 36, 17, 4, 4, 113, 117, 105, 99, 4, 4, 107, 32, 98, 114, 4, 3, 111, 119, 110)),
|
||||
asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithOptionalIndefModeChunked(self):
|
||||
self.__initWithOptional()
|
||||
assert decoder.decode(
|
||||
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)),
|
||||
asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithDefaultedDefMode(self):
|
||||
self.__initWithDefaulted()
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 5, 5, 0, 2, 1, 1)), asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithDefaultedIndefMode(self):
|
||||
self.__initWithDefaulted()
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 128, 5, 0, 2, 1, 1, 0, 0)), asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithDefaultedDefModeChunked(self):
|
||||
self.__initWithDefaulted()
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 5, 5, 0, 2, 1, 1)), asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithDefaultedIndefModeChunked(self):
|
||||
self.__initWithDefaulted()
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 128, 5, 0, 2, 1, 1, 0, 0)), asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithOptionalAndDefaultedDefMode(self):
|
||||
self.__initWithOptionalAndDefaulted()
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 18, 5, 0, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 2, 1, 1)), asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithOptionalAndDefaultedIndefMode(self):
|
||||
self.__initWithOptionalAndDefaulted()
|
||||
assert decoder.decode(
|
||||
ints2octs((48, 128, 5, 0, 36, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 0, 0, 2, 1, 1, 0, 0)), asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithOptionalAndDefaultedDefModeChunked(self):
|
||||
self.__initWithOptionalAndDefaulted()
|
||||
assert decoder.decode(
|
||||
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)), asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithOptionalAndDefaultedIndefModeChunked(self):
|
||||
self.__initWithOptionalAndDefaulted()
|
||||
assert decoder.decode(
|
||||
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)), asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
class ChoiceDecoderTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.s = univ.Choice(componentType=namedtype.NamedTypes(
|
||||
namedtype.NamedType('place-holder', univ.Null(null)),
|
||||
namedtype.NamedType('number', univ.Integer(0)),
|
||||
namedtype.NamedType('string', univ.OctetString())
|
||||
))
|
||||
|
||||
def testBySpec(self):
|
||||
self.s.setComponentByPosition(0, univ.Null(null))
|
||||
assert decoder.decode(
|
||||
ints2octs((5, 0)), asn1Spec=self.s
|
||||
) == (self.s, null)
|
||||
|
||||
def testWithoutSpec(self):
|
||||
self.s.setComponentByPosition(0, univ.Null(null))
|
||||
assert decoder.decode(ints2octs((5, 0))) == (self.s, null)
|
||||
assert decoder.decode(ints2octs((5, 0))) == (univ.Null(null), null)
|
||||
|
||||
def testUndefLength(self):
|
||||
self.s.setComponentByPosition(2, univ.OctetString('abcdefgh'))
|
||||
assert decoder.decode(ints2octs((36, 128, 4, 3, 97, 98, 99, 4, 3, 100, 101, 102, 4, 2, 103, 104, 0, 0)), asn1Spec=self.s) == (self.s, null)
|
||||
|
||||
def testExplicitTag(self):
|
||||
s = self.s.subtype(explicitTag=tag.Tag(tag.tagClassContext,
|
||||
tag.tagFormatConstructed, 4))
|
||||
s.setComponentByPosition(0, univ.Null(null))
|
||||
assert decoder.decode(ints2octs((164, 2, 5, 0)), asn1Spec=s) == (s, null)
|
||||
|
||||
def testExplicitTagUndefLength(self):
|
||||
s = self.s.subtype(explicitTag=tag.Tag(tag.tagClassContext,
|
||||
tag.tagFormatConstructed, 4))
|
||||
s.setComponentByPosition(0, univ.Null(null))
|
||||
assert decoder.decode(ints2octs((164, 128, 5, 0, 0, 0)), asn1Spec=s) == (s, null)
|
||||
|
||||
class AnyDecoderTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.s = univ.Any()
|
||||
|
||||
def testByUntagged(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((4, 3, 102, 111, 120)), asn1Spec=self.s
|
||||
) == (univ.Any('\004\003fox'), null)
|
||||
|
||||
def testTaggedEx(self):
|
||||
s = univ.Any('\004\003fox').subtype(explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4))
|
||||
assert decoder.decode(ints2octs((164, 5, 4, 3, 102, 111, 120)), asn1Spec=s) == (s, null)
|
||||
|
||||
def testTaggedIm(self):
|
||||
s = univ.Any('\004\003fox').subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4))
|
||||
assert decoder.decode(ints2octs((132, 5, 4, 3, 102, 111, 120)), asn1Spec=s) == (s, null)
|
||||
|
||||
def testByUntaggedIndefMode(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((4, 3, 102, 111, 120)), asn1Spec=self.s
|
||||
) == (univ.Any('\004\003fox'), null)
|
||||
|
||||
def testTaggedExIndefMode(self):
|
||||
s = univ.Any('\004\003fox').subtype(explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4))
|
||||
assert decoder.decode(ints2octs((164, 128, 4, 3, 102, 111, 120, 0, 0)), asn1Spec=s) == (s, null)
|
||||
|
||||
def testTaggedImIndefMode(self):
|
||||
s = univ.Any('\004\003fox').subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4))
|
||||
assert decoder.decode(ints2octs((164, 128, 4, 3, 102, 111, 120, 0, 0)), asn1Spec=s) == (s, null)
|
||||
|
||||
def testByUntaggedSubst(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((4, 3, 102, 111, 120)),
|
||||
asn1Spec=self.s,
|
||||
substrateFun=lambda a,b,c: (b,c)
|
||||
) == (ints2octs((4, 3, 102, 111, 120)), 5)
|
||||
|
||||
def testTaggedExSubst(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((164, 5, 4, 3, 102, 111, 120)),
|
||||
asn1Spec=self.s,
|
||||
substrateFun=lambda a,b,c: (b,c)
|
||||
) == (ints2octs((164, 5, 4, 3, 102, 111, 120)), 7)
|
||||
|
||||
if __name__ == '__main__': unittest.main()
|
||||
338
python/pyasn1/test/codec/ber/test_encoder.py
Normal file
338
python/pyasn1/test/codec/ber/test_encoder.py
Normal file
|
|
@ -0,0 +1,338 @@
|
|||
from pyasn1.type import tag, namedtype, univ
|
||||
from pyasn1.codec.ber import encoder
|
||||
from pyasn1.compat.octets import ints2octs
|
||||
from pyasn1.error import PyAsn1Error
|
||||
from sys import version_info
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
class LargeTagEncoderTestCase(unittest.TestCase):
|
||||
def 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(unittest.TestCase):
|
||||
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 BooleanEncoderTestCase(unittest.TestCase):
|
||||
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 BitStringEncoderTestCase(unittest.TestCase):
|
||||
def 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=0
|
||||
) == 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=0, 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 OctetStringEncoderTestCase(unittest.TestCase):
|
||||
def 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=0
|
||||
) == 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=0, 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(unittest.TestCase):
|
||||
def 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=0
|
||||
) == 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=1, 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=0, 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(unittest.TestCase):
|
||||
def testNull(self):
|
||||
assert encoder.encode(univ.Null('')) == ints2octs((5, 0))
|
||||
|
||||
class ObjectIdentifierEncoderTestCase(unittest.TestCase):
|
||||
def testNull(self):
|
||||
assert encoder.encode(
|
||||
univ.ObjectIdentifier((1,3,6,0,0xffffe))
|
||||
) == ints2octs((6, 6, 43, 6, 0, 191, 255, 126))
|
||||
|
||||
class RealEncoderTestCase(unittest.TestCase):
|
||||
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(
|
||||
univ.Real((1101, 2, 11))
|
||||
) == ints2octs((9, 4, 128, 11, 4, 77))
|
||||
|
||||
def testBin2(self):
|
||||
assert encoder.encode(
|
||||
univ.Real((1101, 2, -11))
|
||||
) == ints2octs((9, 4, 128, 245, 4, 77))
|
||||
|
||||
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 SequenceEncoderTestCase(unittest.TestCase):
|
||||
def 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=0
|
||||
) == ints2octs((48, 128, 5, 0, 0, 0))
|
||||
|
||||
def testDefModeChunked(self):
|
||||
self.__init()
|
||||
assert encoder.encode(
|
||||
self.s, defMode=1, maxChunkSize=4
|
||||
) == ints2octs((48, 2, 5, 0))
|
||||
|
||||
def testIndefModeChunked(self):
|
||||
self.__init()
|
||||
assert encoder.encode(
|
||||
self.s, defMode=0, 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=0
|
||||
) == 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=1, 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=0, 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=0
|
||||
) == ints2octs((48, 128, 5, 0, 2, 1, 1, 0, 0))
|
||||
|
||||
def testWithDefaultedDefModeChunked(self):
|
||||
self.__initWithDefaulted()
|
||||
assert encoder.encode(
|
||||
self.s, defMode=1, maxChunkSize=4
|
||||
) == ints2octs((48, 5, 5, 0, 2, 1, 1))
|
||||
|
||||
def testWithDefaultedIndefModeChunked(self):
|
||||
self.__initWithDefaulted()
|
||||
assert encoder.encode(
|
||||
self.s, defMode=0, 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=0
|
||||
) == 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=1, 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=0, 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 ChoiceEncoderTestCase(unittest.TestCase):
|
||||
def 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(unittest.TestCase):
|
||||
def 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))
|
||||
|
||||
if __name__ == '__main__': unittest.main()
|
||||
1
python/pyasn1/test/codec/cer/__init__.py
Normal file
1
python/pyasn1/test/codec/cer/__init__.py
Normal file
|
|
@ -0,0 +1 @@
|
|||
# This file is necessary to make this directory a package.
|
||||
22
python/pyasn1/test/codec/cer/suite.py
Normal file
22
python/pyasn1/test/codec/cer/suite.py
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
from sys import path, version_info
|
||||
from os.path import sep
|
||||
path.insert(1, path[0]+sep+'cer')
|
||||
import test_encoder, test_decoder
|
||||
from pyasn1.error import PyAsn1Error
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
suite = unittest.TestSuite()
|
||||
loader = unittest.TestLoader()
|
||||
for m in (test_encoder, test_decoder):
|
||||
suite.addTest(loader.loadTestsFromModule(m))
|
||||
|
||||
def runTests(): unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
|
||||
if __name__ == '__main__': runTests()
|
||||
31
python/pyasn1/test/codec/cer/test_decoder.py
Normal file
31
python/pyasn1/test/codec/cer/test_decoder.py
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
from pyasn1.type import univ
|
||||
from pyasn1.codec.cer import decoder
|
||||
from pyasn1.compat.octets import ints2octs, str2octs, null
|
||||
from pyasn1.error import PyAsn1Error
|
||||
from sys import version_info
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
class BooleanDecoderTestCase(unittest.TestCase):
|
||||
def testTrue(self):
|
||||
assert decoder.decode(ints2octs((1, 1, 255))) == (1, null)
|
||||
def testFalse(self):
|
||||
assert decoder.decode(ints2octs((1, 1, 0))) == (0, null)
|
||||
|
||||
class OctetStringDecoderTestCase(unittest.TestCase):
|
||||
def testShortMode(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120)),
|
||||
) == (str2octs('Quick brown fox'), null)
|
||||
def testLongMode(self):
|
||||
assert decoder.decode(
|
||||
ints2octs((36, 128, 4, 130, 3, 232) + (81,)*1000 + (4, 1, 81, 0, 0))
|
||||
) == (str2octs('Q'*1001), null)
|
||||
|
||||
if __name__ == '__main__': unittest.main()
|
||||
107
python/pyasn1/test/codec/cer/test_encoder.py
Normal file
107
python/pyasn1/test/codec/cer/test_encoder.py
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
from pyasn1.type import namedtype, univ
|
||||
from pyasn1.codec.cer import encoder
|
||||
from pyasn1.compat.octets import ints2octs
|
||||
from pyasn1.error import PyAsn1Error
|
||||
from sys import version_info
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
class BooleanEncoderTestCase(unittest.TestCase):
|
||||
def testTrue(self):
|
||||
assert encoder.encode(univ.Boolean(1)) == ints2octs((1, 1, 255))
|
||||
def testFalse(self):
|
||||
assert encoder.encode(univ.Boolean(0)) == ints2octs((1, 1, 0))
|
||||
|
||||
class BitStringEncoderTestCase(unittest.TestCase):
|
||||
def testShortMode(self):
|
||||
assert encoder.encode(
|
||||
univ.BitString((1,0)*501)
|
||||
) == ints2octs((3, 127, 6) + (170,) * 125 + (128,))
|
||||
|
||||
def testLongMode(self):
|
||||
assert encoder.encode(
|
||||
univ.BitString((1,0)*501)
|
||||
) == ints2octs((3, 127, 6) + (170,) * 125 + (128,))
|
||||
|
||||
class OctetStringEncoderTestCase(unittest.TestCase):
|
||||
def testShortMode(self):
|
||||
assert encoder.encode(
|
||||
univ.OctetString('Quick brown fox')
|
||||
) == ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
|
||||
def testLongMode(self):
|
||||
assert encoder.encode(
|
||||
univ.OctetString('Q'*1001)
|
||||
) == ints2octs((36, 128, 4, 130, 3, 232) + (81,)*1000 + (4, 1, 81, 0, 0))
|
||||
|
||||
class SetEncoderTestCase(unittest.TestCase):
|
||||
def 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 testIndefMode(self):
|
||||
self.__init()
|
||||
assert encoder.encode(self.s) == ints2octs((49, 128, 5, 0, 0, 0))
|
||||
|
||||
def testWithOptionalIndefMode(self):
|
||||
self.__initWithOptional()
|
||||
assert encoder.encode(
|
||||
self.s
|
||||
) == ints2octs((49, 128, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 5, 0, 0, 0))
|
||||
|
||||
def testWithDefaultedIndefMode(self):
|
||||
self.__initWithDefaulted()
|
||||
assert encoder.encode(
|
||||
self.s
|
||||
) == ints2octs((49, 128, 2, 1, 1, 5, 0, 0, 0))
|
||||
|
||||
def testWithOptionalAndDefaultedIndefMode(self):
|
||||
self.__initWithOptionalAndDefaulted()
|
||||
assert encoder.encode(
|
||||
self.s
|
||||
) == ints2octs((49, 128, 2, 1, 1, 4, 11, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 5, 0, 0, 0))
|
||||
|
||||
class SetWithChoiceEncoderTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
c = univ.Choice(componentType=namedtype.NamedTypes(
|
||||
namedtype.NamedType('actual', univ.Boolean(0))
|
||||
))
|
||||
self.s = univ.Set(componentType=namedtype.NamedTypes(
|
||||
namedtype.NamedType('place-holder', univ.Null('')),
|
||||
namedtype.NamedType('status', c)
|
||||
))
|
||||
|
||||
def testIndefMode(self):
|
||||
self.s.setComponentByPosition(0)
|
||||
self.s.setComponentByName('status')
|
||||
self.s.getComponentByName('status').setComponentByPosition(0, 1)
|
||||
assert encoder.encode(self.s) == ints2octs((49, 128, 1, 1, 255, 5, 0, 0, 0))
|
||||
|
||||
if __name__ == '__main__': unittest.main()
|
||||
1
python/pyasn1/test/codec/der/__init__.py
Normal file
1
python/pyasn1/test/codec/der/__init__.py
Normal file
|
|
@ -0,0 +1 @@
|
|||
# This file is necessary to make this directory a package.
|
||||
22
python/pyasn1/test/codec/der/suite.py
Normal file
22
python/pyasn1/test/codec/der/suite.py
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
from sys import path, version_info
|
||||
from os.path import sep
|
||||
path.insert(1, path[0]+sep+'der')
|
||||
import test_encoder, test_decoder
|
||||
from pyasn1.error import PyAsn1Error
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
suite = unittest.TestSuite()
|
||||
loader = unittest.TestLoader()
|
||||
for m in (test_encoder, test_decoder):
|
||||
suite.addTest(loader.loadTestsFromModule(m))
|
||||
|
||||
def runTests(): unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
|
||||
if __name__ == '__main__': runTests()
|
||||
20
python/pyasn1/test/codec/der/test_decoder.py
Normal file
20
python/pyasn1/test/codec/der/test_decoder.py
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
from pyasn1.type import univ
|
||||
from pyasn1.codec.der import decoder
|
||||
from pyasn1.error import PyAsn1Error
|
||||
from sys import version_info
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
class OctetStringDecoderTestCase(unittest.TestCase):
|
||||
def testShortMode(self):
|
||||
assert decoder.decode(
|
||||
'\004\017Quick brown fox'.encode()
|
||||
) == ('Quick brown fox'.encode(), ''.encode())
|
||||
|
||||
if __name__ == '__main__': unittest.main()
|
||||
44
python/pyasn1/test/codec/der/test_encoder.py
Normal file
44
python/pyasn1/test/codec/der/test_encoder.py
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
from pyasn1.type import namedtype, univ
|
||||
from pyasn1.codec.der import encoder
|
||||
from pyasn1.compat.octets import ints2octs
|
||||
from pyasn1.error import PyAsn1Error
|
||||
from sys import version_info
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
class OctetStringEncoderTestCase(unittest.TestCase):
|
||||
def testShortMode(self):
|
||||
assert encoder.encode(
|
||||
univ.OctetString('Quick brown fox')
|
||||
) == ints2octs((4, 15, 81, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120))
|
||||
|
||||
class BitStringEncoderTestCase(unittest.TestCase):
|
||||
def testShortMode(self):
|
||||
assert encoder.encode(
|
||||
univ.BitString((1,))
|
||||
) == ints2octs((3, 2, 7, 128))
|
||||
|
||||
class SetWithChoiceEncoderTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
c = univ.Choice(componentType=namedtype.NamedTypes(
|
||||
namedtype.NamedType('name', univ.OctetString('')),
|
||||
namedtype.NamedType('amount', univ.Integer(0))
|
||||
))
|
||||
self.s = univ.Set(componentType=namedtype.NamedTypes(
|
||||
namedtype.NamedType('place-holder', univ.Null('')),
|
||||
namedtype.NamedType('status', c)
|
||||
))
|
||||
|
||||
def testDefMode(self):
|
||||
self.s.setComponentByPosition(0)
|
||||
self.s.setComponentByName('status')
|
||||
self.s.getComponentByName('status').setComponentByPosition(0, 'ann')
|
||||
assert encoder.encode(self.s) == ints2octs((49, 7, 4, 3, 97, 110, 110, 5, 0))
|
||||
|
||||
if __name__ == '__main__': unittest.main()
|
||||
29
python/pyasn1/test/codec/suite.py
Normal file
29
python/pyasn1/test/codec/suite.py
Normal file
|
|
@ -0,0 +1,29 @@
|
|||
from sys import path, version_info
|
||||
from os.path import sep
|
||||
path.insert(1, path[0]+sep+'codec'+sep+'ber')
|
||||
import ber.suite
|
||||
path.insert(1, path[0]+sep+'codec'+sep+'cer')
|
||||
import cer.suite
|
||||
path.insert(1, path[0]+sep+'codec'+sep+'der')
|
||||
import der.suite
|
||||
from pyasn1.error import PyAsn1Error
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
suite = unittest.TestSuite()
|
||||
for m in (
|
||||
ber.suite,
|
||||
cer.suite,
|
||||
der.suite
|
||||
):
|
||||
suite.addTest(getattr(m, 'suite'))
|
||||
|
||||
def runTests(): unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
|
||||
if __name__ == '__main__': runTests()
|
||||
26
python/pyasn1/test/suite.py
Normal file
26
python/pyasn1/test/suite.py
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
from sys import path, version_info
|
||||
from os.path import sep
|
||||
path.insert(1, path[0]+sep+'type')
|
||||
import type.suite
|
||||
path.insert(1, path[0]+sep+'codec')
|
||||
import codec.suite
|
||||
from pyasn1.error import PyAsn1Error
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
suite = unittest.TestSuite()
|
||||
for m in (
|
||||
type.suite,
|
||||
codec.suite
|
||||
):
|
||||
suite.addTest(getattr(m, 'suite'))
|
||||
|
||||
def runTests(): unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
|
||||
if __name__ == '__main__': runTests()
|
||||
1
python/pyasn1/test/type/__init__.py
Normal file
1
python/pyasn1/test/type/__init__.py
Normal file
|
|
@ -0,0 +1 @@
|
|||
# This file is necessary to make this directory a package.
|
||||
20
python/pyasn1/test/type/suite.py
Normal file
20
python/pyasn1/test/type/suite.py
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
import test_tag, test_constraint, test_namedtype, test_univ
|
||||
from pyasn1.error import PyAsn1Error
|
||||
from sys import version_info
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
suite = unittest.TestSuite()
|
||||
loader = unittest.TestLoader()
|
||||
for m in (test_tag, test_constraint, test_namedtype, test_univ):
|
||||
suite.addTest(loader.loadTestsFromModule(m))
|
||||
|
||||
def runTests(): unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
|
||||
if __name__ == '__main__': runTests()
|
||||
280
python/pyasn1/test/type/test_constraint.py
Normal file
280
python/pyasn1/test/type/test_constraint.py
Normal file
|
|
@ -0,0 +1,280 @@
|
|||
from pyasn1.type import constraint, error
|
||||
from pyasn1.error import PyAsn1Error
|
||||
from sys import version_info
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
class SingleValueConstraintTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.c1 = constraint.SingleValueConstraint(1,2)
|
||||
self.c2 = constraint.SingleValueConstraint(3,4)
|
||||
|
||||
def testCmp(self): assert self.c1 == self.c1, 'comparation fails'
|
||||
def testHash(self): assert hash(self.c1) != hash(self.c2), 'hash() fails'
|
||||
def testGoodVal(self):
|
||||
try:
|
||||
self.c1(1)
|
||||
except error.ValueConstraintError:
|
||||
assert 0, 'constraint check fails'
|
||||
def testBadVal(self):
|
||||
try:
|
||||
self.c1(4)
|
||||
except error.ValueConstraintError:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'constraint check fails'
|
||||
|
||||
class ContainedSubtypeConstraintTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.c1 = constraint.ContainedSubtypeConstraint(
|
||||
constraint.SingleValueConstraint(12)
|
||||
)
|
||||
|
||||
def testGoodVal(self):
|
||||
try:
|
||||
self.c1(12)
|
||||
except error.ValueConstraintError:
|
||||
assert 0, 'constraint check fails'
|
||||
def testBadVal(self):
|
||||
try:
|
||||
self.c1(4)
|
||||
except error.ValueConstraintError:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'constraint check fails'
|
||||
|
||||
class ValueRangeConstraintTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.c1 = constraint.ValueRangeConstraint(1,4)
|
||||
|
||||
def testGoodVal(self):
|
||||
try:
|
||||
self.c1(1)
|
||||
except error.ValueConstraintError:
|
||||
assert 0, 'constraint check fails'
|
||||
def testBadVal(self):
|
||||
try:
|
||||
self.c1(-5)
|
||||
except error.ValueConstraintError:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'constraint check fails'
|
||||
|
||||
class ValueSizeConstraintTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.c1 = constraint.ValueSizeConstraint(1,2)
|
||||
|
||||
def testGoodVal(self):
|
||||
try:
|
||||
self.c1('a')
|
||||
except error.ValueConstraintError:
|
||||
assert 0, 'constraint check fails'
|
||||
def testBadVal(self):
|
||||
try:
|
||||
self.c1('abc')
|
||||
except error.ValueConstraintError:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'constraint check fails'
|
||||
|
||||
class PermittedAlphabetConstraintTestCase(SingleValueConstraintTestCase):
|
||||
def setUp(self):
|
||||
self.c1 = constraint.PermittedAlphabetConstraint('A', 'B', 'C')
|
||||
self.c2 = constraint.PermittedAlphabetConstraint('DEF')
|
||||
|
||||
def testGoodVal(self):
|
||||
try:
|
||||
self.c1('A')
|
||||
except error.ValueConstraintError:
|
||||
assert 0, 'constraint check fails'
|
||||
def testBadVal(self):
|
||||
try:
|
||||
self.c1('E')
|
||||
except error.ValueConstraintError:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'constraint check fails'
|
||||
|
||||
class ConstraintsIntersectionTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.c1 = constraint.ConstraintsIntersection(
|
||||
constraint.SingleValueConstraint(4),
|
||||
constraint.ValueRangeConstraint(2, 4)
|
||||
)
|
||||
|
||||
def testCmp1(self):
|
||||
assert constraint.SingleValueConstraint(4) in self.c1, '__cmp__() fails'
|
||||
|
||||
def testCmp2(self):
|
||||
assert constraint.SingleValueConstraint(5) not in self.c1, \
|
||||
'__cmp__() fails'
|
||||
|
||||
def testCmp3(self):
|
||||
c = constraint.ConstraintsUnion(constraint.ConstraintsIntersection(
|
||||
constraint.SingleValueConstraint(4),
|
||||
constraint.ValueRangeConstraint(2, 4)
|
||||
))
|
||||
assert self.c1 in c, '__cmp__() fails'
|
||||
def testCmp4(self):
|
||||
c = constraint.ConstraintsUnion(
|
||||
constraint.ConstraintsIntersection(constraint.SingleValueConstraint(5))
|
||||
)
|
||||
assert self.c1 not in c, '__cmp__() fails'
|
||||
|
||||
def testGoodVal(self):
|
||||
try:
|
||||
self.c1(4)
|
||||
except error.ValueConstraintError:
|
||||
assert 0, 'constraint check fails'
|
||||
def testBadVal(self):
|
||||
try:
|
||||
self.c1(-5)
|
||||
except error.ValueConstraintError:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'constraint check fails'
|
||||
|
||||
class InnerTypeConstraintTestCase(unittest.TestCase):
|
||||
def testConst1(self):
|
||||
c = constraint.InnerTypeConstraint(
|
||||
constraint.SingleValueConstraint(4)
|
||||
)
|
||||
try:
|
||||
c(4, 32)
|
||||
except error.ValueConstraintError:
|
||||
assert 0, 'constraint check fails'
|
||||
try:
|
||||
c(5, 32)
|
||||
except error.ValueConstraintError:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'constraint check fails'
|
||||
def testConst2(self):
|
||||
c = constraint.InnerTypeConstraint(
|
||||
(0, constraint.SingleValueConstraint(4), 'PRESENT'),
|
||||
(1, constraint.SingleValueConstraint(4), 'ABSENT')
|
||||
)
|
||||
try:
|
||||
c(4, 0)
|
||||
except error.ValueConstraintError:
|
||||
raise
|
||||
assert 0, 'constraint check fails'
|
||||
try:
|
||||
c(4, 1)
|
||||
except error.ValueConstraintError:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'constraint check fails'
|
||||
try:
|
||||
c(3, 0)
|
||||
except error.ValueConstraintError:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'constraint check fails'
|
||||
|
||||
# Constraints compositions
|
||||
|
||||
class ConstraintsIntersectionTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.c1 = constraint.ConstraintsIntersection(
|
||||
constraint.ValueRangeConstraint(1, 9),
|
||||
constraint.ValueRangeConstraint(2, 5)
|
||||
)
|
||||
|
||||
def testGoodVal(self):
|
||||
try:
|
||||
self.c1(3)
|
||||
except error.ValueConstraintError:
|
||||
assert 0, 'constraint check fails'
|
||||
def testBadVal(self):
|
||||
try:
|
||||
self.c1(0)
|
||||
except error.ValueConstraintError:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'constraint check fails'
|
||||
|
||||
class ConstraintsUnionTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.c1 = constraint.ConstraintsUnion(
|
||||
constraint.SingleValueConstraint(5),
|
||||
constraint.ValueRangeConstraint(1, 3)
|
||||
)
|
||||
|
||||
def testGoodVal(self):
|
||||
try:
|
||||
self.c1(2)
|
||||
self.c1(5)
|
||||
except error.ValueConstraintError:
|
||||
assert 0, 'constraint check fails'
|
||||
def testBadVal(self):
|
||||
try:
|
||||
self.c1(-5)
|
||||
except error.ValueConstraintError:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'constraint check fails'
|
||||
|
||||
class ConstraintsExclusionTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.c1 = constraint.ConstraintsExclusion(
|
||||
constraint.ValueRangeConstraint(2, 4)
|
||||
)
|
||||
|
||||
def testGoodVal(self):
|
||||
try:
|
||||
self.c1(6)
|
||||
except error.ValueConstraintError:
|
||||
assert 0, 'constraint check fails'
|
||||
def testBadVal(self):
|
||||
try:
|
||||
self.c1(2)
|
||||
except error.ValueConstraintError:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'constraint check fails'
|
||||
|
||||
# Constraints derivations
|
||||
|
||||
class DirectDerivationTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.c1 = constraint.SingleValueConstraint(5)
|
||||
self.c2 = constraint.ConstraintsUnion(
|
||||
self.c1, constraint.ValueRangeConstraint(1, 3)
|
||||
)
|
||||
|
||||
def testGoodVal(self):
|
||||
assert self.c1.isSuperTypeOf(self.c2), 'isSuperTypeOf failed'
|
||||
assert not self.c1.isSubTypeOf(self.c2) , 'isSubTypeOf failed'
|
||||
def testBadVal(self):
|
||||
assert not self.c2.isSuperTypeOf(self.c1) , 'isSuperTypeOf failed'
|
||||
assert self.c2.isSubTypeOf(self.c1) , 'isSubTypeOf failed'
|
||||
|
||||
class IndirectDerivationTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.c1 = constraint.ConstraintsIntersection(
|
||||
constraint.ValueRangeConstraint(1, 30)
|
||||
)
|
||||
self.c2 = constraint.ConstraintsIntersection(
|
||||
self.c1, constraint.ValueRangeConstraint(1, 20)
|
||||
)
|
||||
self.c2 = constraint.ConstraintsIntersection(
|
||||
self.c2, constraint.ValueRangeConstraint(1, 10)
|
||||
)
|
||||
|
||||
def testGoodVal(self):
|
||||
assert self.c1.isSuperTypeOf(self.c2), 'isSuperTypeOf failed'
|
||||
assert not self.c1.isSubTypeOf(self.c2) , 'isSubTypeOf failed'
|
||||
def testBadVal(self):
|
||||
assert not self.c2.isSuperTypeOf(self.c1) , 'isSuperTypeOf failed'
|
||||
assert self.c2.isSubTypeOf(self.c1) , 'isSubTypeOf failed'
|
||||
|
||||
if __name__ == '__main__': unittest.main()
|
||||
|
||||
# how to apply size constriants to constructed types?
|
||||
87
python/pyasn1/test/type/test_namedtype.py
Normal file
87
python/pyasn1/test/type/test_namedtype.py
Normal file
|
|
@ -0,0 +1,87 @@
|
|||
from pyasn1.type import namedtype, univ
|
||||
from pyasn1.error import PyAsn1Error
|
||||
from sys import version_info
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
class NamedTypeCaseBase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.e = namedtype.NamedType('age', univ.Integer())
|
||||
def testIter(self):
|
||||
n, t = self.e
|
||||
assert n == 'age' or t == univ.Integer(), 'unpack fails'
|
||||
|
||||
class NamedTypesCaseBase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.e = namedtype.NamedTypes(
|
||||
namedtype.NamedType('first-name', univ.OctetString('')),
|
||||
namedtype.OptionalNamedType('age', univ.Integer(0)),
|
||||
namedtype.NamedType('family-name', univ.OctetString(''))
|
||||
)
|
||||
def testIter(self):
|
||||
for t in self.e:
|
||||
break
|
||||
else:
|
||||
assert 0, '__getitem__() fails'
|
||||
|
||||
def testGetTypeByPosition(self):
|
||||
assert self.e.getTypeByPosition(0) == univ.OctetString(''), \
|
||||
'getTypeByPosition() fails'
|
||||
|
||||
def testGetNameByPosition(self):
|
||||
assert self.e.getNameByPosition(0) == 'first-name', \
|
||||
'getNameByPosition() fails'
|
||||
|
||||
def testGetPositionByName(self):
|
||||
assert self.e.getPositionByName('first-name') == 0, \
|
||||
'getPositionByName() fails'
|
||||
|
||||
def testGetTypesNearPosition(self):
|
||||
assert self.e.getTagMapNearPosition(0).getPosMap() == {
|
||||
univ.OctetString.tagSet: univ.OctetString('')
|
||||
}
|
||||
assert self.e.getTagMapNearPosition(1).getPosMap() == {
|
||||
univ.Integer.tagSet: univ.Integer(0),
|
||||
univ.OctetString.tagSet: univ.OctetString('')
|
||||
}
|
||||
assert self.e.getTagMapNearPosition(2).getPosMap() == {
|
||||
univ.OctetString.tagSet: univ.OctetString('')
|
||||
}
|
||||
|
||||
def testGetTagMap(self):
|
||||
assert self.e.getTagMap().getPosMap() == {
|
||||
univ.OctetString.tagSet: univ.OctetString(''),
|
||||
univ.Integer.tagSet: univ.Integer(0)
|
||||
}
|
||||
|
||||
def testGetTagMapWithDups(self):
|
||||
try:
|
||||
self.e.getTagMap(1)
|
||||
except PyAsn1Error:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'Duped types not noticed'
|
||||
|
||||
def testGetPositionNearType(self):
|
||||
assert self.e.getPositionNearType(univ.OctetString.tagSet, 0) == 0
|
||||
assert self.e.getPositionNearType(univ.Integer.tagSet, 1) == 1
|
||||
assert self.e.getPositionNearType(univ.OctetString.tagSet, 2) == 2
|
||||
|
||||
class OrderedNamedTypesCaseBase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.e = namedtype.NamedTypes(
|
||||
namedtype.NamedType('first-name', univ.OctetString('')),
|
||||
namedtype.NamedType('age', univ.Integer(0))
|
||||
)
|
||||
|
||||
def testGetTypeByPosition(self):
|
||||
assert self.e.getTypeByPosition(0) == univ.OctetString(''), \
|
||||
'getTypeByPosition() fails'
|
||||
|
||||
if __name__ == '__main__': unittest.main()
|
||||
107
python/pyasn1/test/type/test_tag.py
Normal file
107
python/pyasn1/test/type/test_tag.py
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
from pyasn1.type import tag
|
||||
from pyasn1.error import PyAsn1Error
|
||||
from sys import version_info
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
class TagTestCaseBase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.t1 = tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 3)
|
||||
self.t2 = tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 3)
|
||||
|
||||
class TagCmpTestCase(TagTestCaseBase):
|
||||
def testCmp(self):
|
||||
assert self.t1 == self.t2, 'tag comparation fails'
|
||||
|
||||
def testHash(self):
|
||||
assert hash(self.t1) == hash(self.t2), 'tag hash comparation fails'
|
||||
|
||||
def testSequence(self):
|
||||
assert self.t1[0] == self.t2[0] and \
|
||||
self.t1[1] == self.t2[1] and \
|
||||
self.t1[2] == self.t2[2], 'tag sequence protocol fails'
|
||||
|
||||
class TagSetTestCaseBase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.ts1 = tag.initTagSet(
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12)
|
||||
)
|
||||
self.ts2 = tag.initTagSet(
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12)
|
||||
)
|
||||
|
||||
class TagSetCmpTestCase(TagSetTestCaseBase):
|
||||
def testCmp(self):
|
||||
assert self.ts1 == self.ts2, 'tag set comparation fails'
|
||||
|
||||
def testHash(self):
|
||||
assert hash(self.ts1) == hash(self.ts2), 'tag set hash comp. fails'
|
||||
|
||||
def testLen(self):
|
||||
assert len(self.ts1) == len(self.ts2), 'tag length comparation fails'
|
||||
|
||||
class TaggingTestSuite(TagSetTestCaseBase):
|
||||
def testImplicitTag(self):
|
||||
t = self.ts1.tagImplicitly(
|
||||
tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 14)
|
||||
)
|
||||
assert t == tag.TagSet(
|
||||
tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 12),
|
||||
tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 14)
|
||||
), 'implicit tagging went wrong'
|
||||
|
||||
def testExplicitTag(self):
|
||||
t = self.ts1.tagExplicitly(
|
||||
tag.Tag(tag.tagClassPrivate, tag.tagFormatSimple, 32)
|
||||
)
|
||||
assert t == tag.TagSet(
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12),
|
||||
tag.Tag(tag.tagClassPrivate, tag.tagFormatConstructed, 32)
|
||||
), 'explicit tagging went wrong'
|
||||
|
||||
class TagSetAddTestSuite(TagSetTestCaseBase):
|
||||
def testAdd(self):
|
||||
t = self.ts1 + tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 2)
|
||||
assert t == tag.TagSet(
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12),
|
||||
tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 2)
|
||||
), 'TagSet.__add__() fails'
|
||||
|
||||
def testRadd(self):
|
||||
t = tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 2) + self.ts1
|
||||
assert t == tag.TagSet(
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12),
|
||||
tag.Tag(tag.tagClassApplication, tag.tagFormatSimple, 2),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12)
|
||||
), 'TagSet.__radd__() fails'
|
||||
|
||||
class SuperTagSetTestCase(TagSetTestCaseBase):
|
||||
def testSuperTagCheck1(self):
|
||||
assert self.ts1.isSuperTagSetOf(
|
||||
tag.TagSet(
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12)
|
||||
)), 'isSuperTagSetOf() fails'
|
||||
|
||||
def testSuperTagCheck2(self):
|
||||
assert not self.ts1.isSuperTagSetOf(
|
||||
tag.TagSet(
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 12),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 13)
|
||||
)), 'isSuperTagSetOf() fails'
|
||||
|
||||
def testSuperTagCheck3(self):
|
||||
assert self.ts1.isSuperTagSetOf(
|
||||
tag.TagSet((), tag.Tag(tag.tagClassUniversal,
|
||||
tag.tagFormatSimple, 12))
|
||||
), 'isSuperTagSetOf() fails'
|
||||
|
||||
if __name__ == '__main__': unittest.main()
|
||||
479
python/pyasn1/test/type/test_univ.py
Normal file
479
python/pyasn1/test/type/test_univ.py
Normal file
|
|
@ -0,0 +1,479 @@
|
|||
from pyasn1.type import univ, tag, constraint, namedtype, namedval, error
|
||||
from pyasn1.compat.octets import str2octs, ints2octs
|
||||
from pyasn1.error import PyAsn1Error
|
||||
from sys import version_info
|
||||
if version_info[0:2] < (2, 7) or \
|
||||
version_info[0:2] in ( (3, 0), (3, 1) ):
|
||||
try:
|
||||
import unittest2 as unittest
|
||||
except ImportError:
|
||||
import unittest
|
||||
else:
|
||||
import unittest
|
||||
|
||||
class IntegerTestCase(unittest.TestCase):
|
||||
def testStr(self): assert str(univ.Integer(1)) in ('1','1L'),'str() fails'
|
||||
def testAnd(self): assert univ.Integer(1) & 0 == 0, '__and__() fails'
|
||||
def testOr(self): assert univ.Integer(1) | 0 == 1, '__or__() fails'
|
||||
def testXor(self): assert univ.Integer(1) ^ 0 == 1, '__xor__() fails'
|
||||
def testRand(self): assert 0 & univ.Integer(1) == 0, '__rand__() fails'
|
||||
def testRor(self): assert 0 | univ.Integer(1) == 1, '__ror__() fails'
|
||||
def testRxor(self): assert 0 ^ univ.Integer(1) == 1, '__rxor__() fails'
|
||||
def testAdd(self): assert univ.Integer(-4) + 6 == 2, '__add__() fails'
|
||||
def testRadd(self): assert 4 + univ.Integer(5) == 9, '__radd__() fails'
|
||||
def testSub(self): assert univ.Integer(3) - 6 == -3, '__sub__() fails'
|
||||
def testRsub(self): assert 6 - univ.Integer(3) == 3, '__rsub__() fails'
|
||||
def testMul(self): assert univ.Integer(3) * -3 == -9, '__mul__() fails'
|
||||
def testRmul(self): assert 2 * univ.Integer(3) == 6, '__rmul__() fails'
|
||||
def testDiv(self): assert univ.Integer(3) / 2 == 1, '__div__() fails'
|
||||
def testRdiv(self): assert 6 / univ.Integer(3) == 2, '__rdiv__() fails'
|
||||
def testMod(self): assert univ.Integer(3) % 2 == 1, '__mod__() fails'
|
||||
def testRmod(self): assert 4 % univ.Integer(3) == 1, '__rmod__() fails'
|
||||
def testPow(self): assert univ.Integer(3) ** 2 == 9, '__pow__() fails'
|
||||
def testRpow(self): assert 2 ** univ.Integer(2) == 4, '__rpow__() fails'
|
||||
def testLshift(self): assert univ.Integer(1) << 1 == 2, '<< fails'
|
||||
def testRshift(self): assert univ.Integer(2) >> 1 == 1, '>> fails'
|
||||
def testInt(self): assert int(univ.Integer(3)) == 3, '__int__() fails'
|
||||
def testLong(self): assert int(univ.Integer(8)) == 8, '__long__() fails'
|
||||
def testFloat(self): assert float(univ.Integer(4))==4.0,'__float__() fails'
|
||||
def testPrettyIn(self): assert univ.Integer('3') == 3, 'prettyIn() fails'
|
||||
def testTag(self):
|
||||
assert univ.Integer().getTagSet() == tag.TagSet(
|
||||
(),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x02)
|
||||
)
|
||||
def testNamedVals(self):
|
||||
i = univ.Integer(
|
||||
'asn1', namedValues=univ.Integer.namedValues.clone(('asn1', 1))
|
||||
)
|
||||
assert i == 1, 'named val fails'
|
||||
assert str(i) != 'asn1', 'named val __str__() fails'
|
||||
|
||||
class BooleanTestCase(unittest.TestCase):
|
||||
def testTruth(self):
|
||||
assert univ.Boolean(True) and univ.Boolean(1), 'Truth initializer fails'
|
||||
def testFalse(self):
|
||||
assert not univ.Boolean(False) and not univ.Boolean(0), 'False initializer fails'
|
||||
def testStr(self):
|
||||
assert str(univ.Boolean(1)) in ('1', '1L'), 'str() fails'
|
||||
def testTag(self):
|
||||
assert univ.Boolean().getTagSet() == tag.TagSet(
|
||||
(),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x01)
|
||||
)
|
||||
def testConstraints(self):
|
||||
try:
|
||||
univ.Boolean(2)
|
||||
except error.ValueConstraintError:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'constraint fail'
|
||||
def testSubtype(self):
|
||||
assert univ.Integer().subtype(
|
||||
value=1,
|
||||
implicitTag=tag.Tag(tag.tagClassPrivate,tag.tagFormatSimple,2),
|
||||
subtypeSpec=constraint.SingleValueConstraint(1,3)
|
||||
) == univ.Integer(
|
||||
value=1,
|
||||
tagSet=tag.TagSet(tag.Tag(tag.tagClassPrivate,
|
||||
tag.tagFormatSimple,2)),
|
||||
subtypeSpec=constraint.ConstraintsIntersection(constraint.SingleValueConstraint(1,3))
|
||||
)
|
||||
|
||||
class BitStringTestCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.b = univ.BitString(
|
||||
namedValues=namedval.NamedValues(('Active', 0), ('Urgent', 1))
|
||||
)
|
||||
def testSet(self):
|
||||
assert self.b.clone('Active') == (1,)
|
||||
assert self.b.clone("'1010100110001010'B") == (1,0,1,0,1,0,0,1,1,0,0,0,1,0,1,0)
|
||||
assert self.b.clone("'A98A'H") == (1,0,1,0,1,0,0,1,1,0,0,0,1,0,1,0)
|
||||
assert self.b.clone((1,0,1)) == (1,0,1)
|
||||
def testStr(self):
|
||||
assert str(self.b.clone('Urgent,Active')) == '(1, 1)'
|
||||
def testRepr(self):
|
||||
assert repr(self.b.clone('Urgent,Active')) == 'BitString("\'11\'B")'
|
||||
def testTag(self):
|
||||
assert univ.BitString().getTagSet() == tag.TagSet(
|
||||
(),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x03)
|
||||
)
|
||||
def testLen(self): assert len(self.b.clone("'A98A'H")) == 16
|
||||
def testIter(self):
|
||||
assert self.b.clone("'A98A'H")[0] == 1
|
||||
assert self.b.clone("'A98A'H")[1] == 0
|
||||
assert self.b.clone("'A98A'H")[2] == 1
|
||||
|
||||
class OctetStringTestCase(unittest.TestCase):
|
||||
def testInit(self):
|
||||
assert univ.OctetString(str2octs('abcd')) == str2octs('abcd'), '__init__() fails'
|
||||
def testBinStr(self):
|
||||
assert univ.OctetString(binValue="1000010111101110101111000000111011") == ints2octs((133, 238, 188, 14, 192)), 'bin init fails'
|
||||
def testHexStr(self):
|
||||
assert univ.OctetString(hexValue="FA9823C43E43510DE3422") == ints2octs((250, 152, 35, 196, 62, 67, 81, 13, 227, 66, 32)), 'hex init fails'
|
||||
def testTuple(self):
|
||||
assert univ.OctetString((1,2,3,4,5)) == ints2octs((1,2,3,4,5)), 'tuple init failed'
|
||||
def testStr(self):
|
||||
assert str(univ.OctetString('q')) == 'q', '__str__() fails'
|
||||
def testSeq(self):
|
||||
assert univ.OctetString('q')[0] == str2octs('q')[0],'__getitem__() fails'
|
||||
def testAsOctets(self):
|
||||
assert univ.OctetString('abcd').asOctets() == str2octs('abcd'), 'testAsOctets() fails'
|
||||
def testAsInts(self):
|
||||
assert univ.OctetString('abcd').asNumbers() == (97, 98, 99, 100), 'testAsNumbers() fails'
|
||||
|
||||
def testEmpty(self):
|
||||
try:
|
||||
str(univ.OctetString())
|
||||
except PyAsn1Error:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'empty OctetString() not reported'
|
||||
|
||||
def testAdd(self):
|
||||
assert univ.OctetString('') + 'q' == str2octs('q'), '__add__() fails'
|
||||
def testRadd(self):
|
||||
assert 'b' + univ.OctetString('q') == str2octs('bq'), '__radd__() fails'
|
||||
def testMul(self):
|
||||
assert univ.OctetString('a') * 2 == str2octs('aa'), '__mul__() fails'
|
||||
def testRmul(self):
|
||||
assert 2 * univ.OctetString('b') == str2octs('bb'), '__rmul__() fails'
|
||||
def testTag(self):
|
||||
assert univ.OctetString().getTagSet() == tag.TagSet(
|
||||
(),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x04)
|
||||
)
|
||||
|
||||
class Null(unittest.TestCase):
|
||||
def testStr(self): assert str(univ.Null('')) == '', 'str() fails'
|
||||
def testTag(self):
|
||||
assert univ.Null().getTagSet() == tag.TagSet(
|
||||
(),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x05)
|
||||
)
|
||||
def testConstraints(self):
|
||||
try:
|
||||
univ.Null(2)
|
||||
except error.ValueConstraintError:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'constraint fail'
|
||||
|
||||
class RealTestCase(unittest.TestCase):
|
||||
def testStr(self): assert str(univ.Real(1.0)) == '1.0','str() fails'
|
||||
def testRepr(self): assert repr(univ.Real(-4.1)) == 'Real((-41, 10, -1))','repr() fails'
|
||||
def testAdd(self): assert univ.Real(-4.1) + 1.4 == -2.7, '__add__() fails'
|
||||
def testRadd(self): assert 4 + univ.Real(0.5) == 4.5, '__radd__() fails'
|
||||
def testSub(self): assert univ.Real(3.9) - 1.7 == 2.2, '__sub__() fails'
|
||||
def testRsub(self): assert 6.1 - univ.Real(0.1) == 6, '__rsub__() fails'
|
||||
def testMul(self): assert univ.Real(3.0) * -3 == -9, '__mul__() fails'
|
||||
def testRmul(self): assert 2 * univ.Real(3.0) == 6, '__rmul__() fails'
|
||||
def testDiv(self): assert univ.Real(3.0) / 2 == 1.5, '__div__() fails'
|
||||
def testRdiv(self): assert 6 / univ.Real(3.0) == 2, '__rdiv__() fails'
|
||||
def testMod(self): assert univ.Real(3.0) % 2 == 1, '__mod__() fails'
|
||||
def testRmod(self): assert 4 % univ.Real(3.0) == 1, '__rmod__() fails'
|
||||
def testPow(self): assert univ.Real(3.0) ** 2 == 9, '__pow__() fails'
|
||||
def testRpow(self): assert 2 ** univ.Real(2.0) == 4, '__rpow__() fails'
|
||||
def testInt(self): assert int(univ.Real(3.0)) == 3, '__int__() fails'
|
||||
def testLong(self): assert int(univ.Real(8.0)) == 8, '__long__() fails'
|
||||
def testFloat(self): assert float(univ.Real(4.0))==4.0,'__float__() fails'
|
||||
def testPrettyIn(self): assert univ.Real((3,10,0)) == 3, 'prettyIn() fails'
|
||||
# infinite float values
|
||||
def testStrInf(self):
|
||||
assert str(univ.Real('inf')) == 'inf','str() fails'
|
||||
def testReprInf(self):
|
||||
assert repr(univ.Real('inf')) == 'Real(\'inf\')','repr() fails'
|
||||
def testAddInf(self):
|
||||
assert univ.Real('inf') + 1 == float('inf'), '__add__() fails'
|
||||
def testRaddInf(self):
|
||||
assert 1 + univ.Real('inf') == float('inf'), '__radd__() fails'
|
||||
def testIntInf(self):
|
||||
try:
|
||||
assert int(univ.Real('inf'))
|
||||
except OverflowError:
|
||||
pass
|
||||
else:
|
||||
assert 0, '__int__() fails'
|
||||
def testLongInf(self):
|
||||
try:
|
||||
assert int(univ.Real('inf'))
|
||||
except OverflowError:
|
||||
pass
|
||||
else:
|
||||
assert 0, '__long__() fails'
|
||||
assert int(univ.Real(8.0)) == 8, '__long__() fails'
|
||||
def testFloatInf(self):
|
||||
assert float(univ.Real('-inf')) == float('-inf'),'__float__() fails'
|
||||
def testPrettyInInf(self):
|
||||
assert univ.Real(float('inf')) == float('inf'), 'prettyIn() fails'
|
||||
def testPlusInf(self):
|
||||
assert univ.Real('inf').isPlusInfinity(), 'isPlusInfinity failed'
|
||||
def testMinusInf(self):
|
||||
assert univ.Real('-inf').isMinusInfinity(), 'isMinusInfinity failed'
|
||||
|
||||
def testTag(self):
|
||||
assert univ.Real().getTagSet() == tag.TagSet(
|
||||
(),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x09)
|
||||
)
|
||||
|
||||
class ObjectIdentifier(unittest.TestCase):
|
||||
def testStr(self):
|
||||
assert str(univ.ObjectIdentifier((1,3,6))) == '1.3.6'
|
||||
def testEq(self):
|
||||
assert univ.ObjectIdentifier((1,3,6)) == (1,3,6), '__cmp__() fails'
|
||||
def testAdd(self):
|
||||
assert univ.ObjectIdentifier((1,3)) + (6,)==(1,3,6),'__add__() fails'
|
||||
def testRadd(self):
|
||||
assert (1,) + univ.ObjectIdentifier((3,6))==(1,3,6),'__radd__() fails'
|
||||
def testLen(self):
|
||||
assert len(univ.ObjectIdentifier((1,3))) == 2,'__len__() fails'
|
||||
def testPrefix(self):
|
||||
o = univ.ObjectIdentifier('1.3.6')
|
||||
assert o.isPrefixOf((1,3,6)), 'isPrefixOf() fails'
|
||||
assert o.isPrefixOf((1,3,6,1)), 'isPrefixOf() fails'
|
||||
assert not o.isPrefixOf((1,3)), 'isPrefixOf() fails'
|
||||
def testInput(self):
|
||||
assert univ.ObjectIdentifier('1.3.6')==(1,3,6),'prettyIn() fails'
|
||||
def testTag(self):
|
||||
assert univ.ObjectIdentifier().getTagSet() == tag.TagSet(
|
||||
(),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatSimple, 0x06)
|
||||
)
|
||||
|
||||
class SequenceOf(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.s1 = univ.SequenceOf(
|
||||
componentType=univ.OctetString('')
|
||||
)
|
||||
self.s2 = self.s1.clone()
|
||||
def testTag(self):
|
||||
assert self.s1.getTagSet() == tag.TagSet(
|
||||
(),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x10)
|
||||
), 'wrong tagSet'
|
||||
def testSeq(self):
|
||||
self.s1.setComponentByPosition(0, univ.OctetString('abc'))
|
||||
assert self.s1[0] == str2octs('abc'), 'set by idx fails'
|
||||
self.s1[0] = 'cba'
|
||||
assert self.s1[0] == str2octs('cba'), 'set by idx fails'
|
||||
def testCmp(self):
|
||||
self.s1.clear()
|
||||
self.s1.setComponentByPosition(0, 'abc')
|
||||
self.s2.clear()
|
||||
self.s2.setComponentByPosition(0, univ.OctetString('abc'))
|
||||
assert self.s1 == self.s2, '__cmp__() fails'
|
||||
def testSubtypeSpec(self):
|
||||
s = self.s1.clone(subtypeSpec=constraint.ConstraintsUnion(
|
||||
constraint.SingleValueConstraint(str2octs('abc'))
|
||||
))
|
||||
try:
|
||||
s.setComponentByPosition(0, univ.OctetString('abc'))
|
||||
except:
|
||||
assert 0, 'constraint fails'
|
||||
try:
|
||||
s.setComponentByPosition(1, univ.OctetString('Abc'))
|
||||
except:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'constraint fails'
|
||||
def testSizeSpec(self):
|
||||
s = self.s1.clone(sizeSpec=constraint.ConstraintsUnion(
|
||||
constraint.ValueSizeConstraint(1,1)
|
||||
))
|
||||
s.setComponentByPosition(0, univ.OctetString('abc'))
|
||||
try:
|
||||
s.verifySizeSpec()
|
||||
except:
|
||||
assert 0, 'size spec fails'
|
||||
s.setComponentByPosition(1, univ.OctetString('abc'))
|
||||
try:
|
||||
s.verifySizeSpec()
|
||||
except:
|
||||
pass
|
||||
else:
|
||||
assert 0, 'size spec fails'
|
||||
def testGetComponentTagMap(self):
|
||||
assert self.s1.getComponentTagMap().getPosMap() == {
|
||||
univ.OctetString.tagSet: univ.OctetString('')
|
||||
}
|
||||
def testSubtype(self):
|
||||
self.s1.clear()
|
||||
assert self.s1.subtype(
|
||||
implicitTag=tag.Tag(tag.tagClassPrivate,tag.tagFormatSimple,2),
|
||||
subtypeSpec=constraint.SingleValueConstraint(1,3),
|
||||
sizeSpec=constraint.ValueSizeConstraint(0,1)
|
||||
) == self.s1.clone(
|
||||
tagSet=tag.TagSet(tag.Tag(tag.tagClassPrivate,
|
||||
tag.tagFormatSimple,2)),
|
||||
subtypeSpec=constraint.ConstraintsIntersection(constraint.SingleValueConstraint(1,3)),
|
||||
sizeSpec=constraint.ValueSizeConstraint(0,1)
|
||||
)
|
||||
def testClone(self):
|
||||
self.s1.setComponentByPosition(0, univ.OctetString('abc'))
|
||||
s = self.s1.clone()
|
||||
assert len(s) == 0
|
||||
s = self.s1.clone(cloneValueFlag=1)
|
||||
assert len(s) == 1
|
||||
assert s.getComponentByPosition(0) == self.s1.getComponentByPosition(0)
|
||||
|
||||
class Sequence(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.s1 = univ.Sequence(componentType=namedtype.NamedTypes(
|
||||
namedtype.NamedType('name', univ.OctetString('')),
|
||||
namedtype.OptionalNamedType('nick', univ.OctetString('')),
|
||||
namedtype.DefaultedNamedType('age', univ.Integer(34))
|
||||
))
|
||||
def testTag(self):
|
||||
assert self.s1.getTagSet() == tag.TagSet(
|
||||
(),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x10)
|
||||
), 'wrong tagSet'
|
||||
def testById(self):
|
||||
self.s1.setComponentByName('name', univ.OctetString('abc'))
|
||||
assert self.s1.getComponentByName('name') == str2octs('abc'), 'set by name fails'
|
||||
def testByKey(self):
|
||||
self.s1['name'] = 'abc'
|
||||
assert self.s1['name'] == str2octs('abc'), 'set by key fails'
|
||||
def testGetNearPosition(self):
|
||||
assert self.s1.getComponentTagMapNearPosition(1).getPosMap() == {
|
||||
univ.OctetString.tagSet: univ.OctetString(''),
|
||||
univ.Integer.tagSet: univ.Integer(34)
|
||||
}
|
||||
assert self.s1.getComponentPositionNearType(
|
||||
univ.OctetString.tagSet, 1
|
||||
) == 1
|
||||
def testGetDefaultComponentByPosition(self):
|
||||
self.s1.clear()
|
||||
assert self.s1.getDefaultComponentByPosition(0) == None
|
||||
assert self.s1.getDefaultComponentByPosition(2) == univ.Integer(34)
|
||||
def testSetDefaultComponents(self):
|
||||
self.s1.clear()
|
||||
assert self.s1.getComponentByPosition(2) == None
|
||||
self.s1.setComponentByPosition(0, univ.OctetString('Ping'))
|
||||
self.s1.setComponentByPosition(1, univ.OctetString('Pong'))
|
||||
self.s1.setDefaultComponents()
|
||||
assert self.s1.getComponentByPosition(2) == 34
|
||||
def testClone(self):
|
||||
self.s1.setComponentByPosition(0, univ.OctetString('abc'))
|
||||
self.s1.setComponentByPosition(1, univ.OctetString('def'))
|
||||
self.s1.setComponentByPosition(2, univ.Integer(123))
|
||||
s = self.s1.clone()
|
||||
assert s.getComponentByPosition(0) != self.s1.getComponentByPosition(0)
|
||||
assert s.getComponentByPosition(1) != self.s1.getComponentByPosition(1)
|
||||
assert s.getComponentByPosition(2) != self.s1.getComponentByPosition(2)
|
||||
s = self.s1.clone(cloneValueFlag=1)
|
||||
assert s.getComponentByPosition(0) == self.s1.getComponentByPosition(0)
|
||||
assert s.getComponentByPosition(1) == self.s1.getComponentByPosition(1)
|
||||
assert s.getComponentByPosition(2) == self.s1.getComponentByPosition(2)
|
||||
|
||||
class SetOf(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.s1 = univ.SetOf(componentType=univ.OctetString(''))
|
||||
def testTag(self):
|
||||
assert self.s1.getTagSet() == tag.TagSet(
|
||||
(),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x11)
|
||||
), 'wrong tagSet'
|
||||
def testSeq(self):
|
||||
self.s1.setComponentByPosition(0, univ.OctetString('abc'))
|
||||
assert self.s1[0] == str2octs('abc'), 'set by idx fails'
|
||||
self.s1.setComponentByPosition(0, self.s1[0].clone('cba'))
|
||||
assert self.s1[0] == str2octs('cba'), 'set by idx fails'
|
||||
|
||||
class Set(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.s1 = univ.Set(componentType=namedtype.NamedTypes(
|
||||
namedtype.NamedType('name', univ.OctetString('')),
|
||||
namedtype.OptionalNamedType('null', univ.Null('')),
|
||||
namedtype.DefaultedNamedType('age', univ.Integer(34))
|
||||
))
|
||||
self.s2 = self.s1.clone()
|
||||
def testTag(self):
|
||||
assert self.s1.getTagSet() == tag.TagSet(
|
||||
(),
|
||||
tag.Tag(tag.tagClassUniversal, tag.tagFormatConstructed, 0x11)
|
||||
), 'wrong tagSet'
|
||||
def testByTypeWithPythonValue(self):
|
||||
self.s1.setComponentByType(univ.OctetString.tagSet, 'abc')
|
||||
assert self.s1.getComponentByType(
|
||||
univ.OctetString.tagSet
|
||||
) == str2octs('abc'), 'set by name fails'
|
||||
def testByTypeWithInstance(self):
|
||||
self.s1.setComponentByType(univ.OctetString.tagSet, univ.OctetString('abc'))
|
||||
assert self.s1.getComponentByType(
|
||||
univ.OctetString.tagSet
|
||||
) == str2octs('abc'), 'set by name fails'
|
||||
def testGetTagMap(self):
|
||||
assert self.s1.getTagMap().getPosMap() == {
|
||||
univ.Set.tagSet: univ.Set()
|
||||
}
|
||||
def testGetComponentTagMap(self):
|
||||
assert self.s1.getComponentTagMap().getPosMap() == {
|
||||
univ.OctetString.tagSet: univ.OctetString(''),
|
||||
univ.Null.tagSet: univ.Null(''),
|
||||
univ.Integer.tagSet: univ.Integer(34)
|
||||
}
|
||||
def testGetPositionByType(self):
|
||||
assert self.s1.getComponentPositionByType(
|
||||
univ.Null().getTagSet()
|
||||
) == 1
|
||||
|
||||
class Choice(unittest.TestCase):
|
||||
def setUp(self):
|
||||
innerComp = univ.Choice(componentType=namedtype.NamedTypes(
|
||||
namedtype.NamedType('count', univ.Integer()),
|
||||
namedtype.NamedType('flag', univ.Boolean())
|
||||
))
|
||||
self.s1 = univ.Choice(componentType=namedtype.NamedTypes(
|
||||
namedtype.NamedType('name', univ.OctetString()),
|
||||
namedtype.NamedType('sex', innerComp)
|
||||
))
|
||||
def testTag(self):
|
||||
assert self.s1.getTagSet() == tag.TagSet(), 'wrong tagSet'
|
||||
def testOuterByTypeWithPythonValue(self):
|
||||
self.s1.setComponentByType(univ.OctetString.tagSet, 'abc')
|
||||
assert self.s1.getComponentByType(
|
||||
univ.OctetString.tagSet
|
||||
) == str2octs('abc')
|
||||
def testOuterByTypeWithInstanceValue(self):
|
||||
self.s1.setComponentByType(
|
||||
univ.OctetString.tagSet, univ.OctetString('abc')
|
||||
)
|
||||
assert self.s1.getComponentByType(
|
||||
univ.OctetString.tagSet
|
||||
) == str2octs('abc')
|
||||
def testInnerByTypeWithPythonValue(self):
|
||||
self.s1.setComponentByType(univ.Integer.tagSet, 123, 1)
|
||||
assert self.s1.getComponentByType(
|
||||
univ.Integer.tagSet, 1
|
||||
) == 123
|
||||
def testInnerByTypeWithInstanceValue(self):
|
||||
self.s1.setComponentByType(
|
||||
univ.Integer.tagSet, univ.Integer(123), 1
|
||||
)
|
||||
assert self.s1.getComponentByType(
|
||||
univ.Integer.tagSet, 1
|
||||
) == 123
|
||||
def testCmp(self):
|
||||
self.s1.setComponentByName('name', univ.OctetString('abc'))
|
||||
assert self.s1 == str2octs('abc'), '__cmp__() fails'
|
||||
def testGetComponent(self):
|
||||
self.s1.setComponentByType(univ.OctetString.tagSet, 'abc')
|
||||
assert self.s1.getComponent() == str2octs('abc'), 'getComponent() fails'
|
||||
def testGetName(self):
|
||||
self.s1.setComponentByType(univ.OctetString.tagSet, 'abc')
|
||||
assert self.s1.getName() == 'name', 'getName() fails'
|
||||
def testSetComponentByPosition(self):
|
||||
self.s1.setComponentByPosition(0, univ.OctetString('Jim'))
|
||||
assert self.s1 == str2octs('Jim')
|
||||
def testClone(self):
|
||||
self.s1.setComponentByPosition(0, univ.OctetString('abc'))
|
||||
s = self.s1.clone()
|
||||
assert len(s) == 0
|
||||
s = self.s1.clone(cloneValueFlag=1)
|
||||
assert len(s) == 1
|
||||
assert s.getComponentByPosition(0) == self.s1.getComponentByPosition(0)
|
||||
|
||||
if __name__ == '__main__': unittest.main()
|
||||
Loading…
Add table
Add a link
Reference in a new issue