class BERBaseEquality(unittest.TestCase):
valuesToTest = (
(pureber.BERInteger, [0]),
(pureber.BERInteger, [1]),
(pureber.BERInteger, [4000]),
(pureber.BERSequence,
[[pureber.BERInteger(1000),
pureber.BERInteger(2000)]]),
(pureber.BERSequence,
[[pureber.BERInteger(2000),
pureber.BERInteger(1000)]]),
(pureber.BEROctetString, ["foo"]),
(pureber.BEROctetString, ["b" + chr(0xe4) + chr(0xe4)]),
)
def testBERBaseEquality(self):
"""BER objects equal BER objects with same type and content"""
for class_, args in self.valuesToTest:
x = class_(*args)
y = class_(*args)
assert x == x
assert x == y
def testBERBaseInEquality(self):
"""BER objects do not equal BER objects with different type or content"""
for i in xrange(len(self.valuesToTest)):
for j in xrange(len(self.valuesToTest)):
if i != j:
i_class, i_args = self.valuesToTest[i]
j_class, j_args = self.valuesToTest[j]
x = i_class(*i_args)
y = j_class(*j_args)
assert x != y
def testToBERIntegerKnownValues(self):
"""str(BERInteger(n)) should give known result with known input"""
for integer, encoded in self.knownValues:
result = pureber.BERInteger(integer)
result = str(result)
result = map(ord, result)
assert encoded == result
def testSanity(self):
"""BERInteger(encoded=BERInteger(n)).value==n for -1000..1000"""
for n in range(-1000, 1001, 10):
encoded = str(pureber.BERInteger(n))
result, bytes = pureber.berDecodeObject(
pureber.BERDecoderContext(), encoded)
self.assertEquals(bytes, len(encoded))
assert isinstance(result, pureber.BERInteger)
result = result.value
assert n == result
def testPartialBERIntegerEncodings(self):
"""BERInteger(encoded="...") with too short input should throw BERExceptionInsufficientData"""
m = str(pureber.BERInteger(42))
assert len(m) == 3
self.assertRaises(pureber.BERExceptionInsufficientData,
pureber.berDecodeObject, pureber.BERDecoderContext(),
m[:2])
self.assertRaises(pureber.BERExceptionInsufficientData,
pureber.berDecodeObject, pureber.BERDecoderContext(),
m[:1])
self.assertEquals((None, 0),
pureber.berDecodeObject(pureber.BERDecoderContext(),
''))
class BERSequenceKnownValues(unittest.TestCase):
knownValues = (
([], [0x30, 0x00]),
([pureber.BERInteger(2)], [0x30, 0x03, 0x02, 0x01, 2]),
([pureber.BERInteger(3)], [0x30, 0x03, 0x02, 0x01, 3]),
([pureber.BERInteger(128)], [0x30, 0x04, 0x02, 0x02, 0, 128]),
([
pureber.BERInteger(2),
pureber.BERInteger(3),
pureber.BERInteger(128)
], [0x30, 0x0a] + [0x02, 0x01, 2] + [0x02, 0x01, 3] +
[0x02, 0x02, 0, 128]),
)
def testToBERSequenceKnownValues(self):
"""str(BERSequence(x)) should give known result with known input"""
for content, encoded in self.knownValues:
result = pureber.BERSequence(content)
result = str(result)
result = map(ord, result)
assert encoded == result
def testFromBERSequenceKnownValues(self):
"""BERSequence(encoded="...") should give known result with known input"""
for content, encoded in self.knownValues:
m = s(*encoded)
result, bytes = pureber.berDecodeObject(
pureber.BERDecoderContext(), m)
self.assertEquals(bytes, len(m))
assert isinstance(result, pureber.BERSequence)
result = result.data
assert len(content) == len(result)
for i in xrange(len(content)):
assert content[i] == result[i]
assert content == result
def testPartialBERSequenceEncodings(self):
"""BERSequence(encoded="...") with too short input should throw BERExceptionInsufficientData"""
m = str(pureber.BERSequence([pureber.BERInteger(2)]))
assert len(m) == 5
self.assertRaises(pureber.BERExceptionInsufficientData,
pureber.berDecodeObject, pureber.BERDecoderContext(),
m[:4])
self.assertRaises(pureber.BERExceptionInsufficientData,
pureber.berDecodeObject, pureber.BERDecoderContext(),
m[:3])
self.assertRaises(pureber.BERExceptionInsufficientData,
pureber.berDecodeObject, pureber.BERDecoderContext(),
m[:2])
self.assertRaises(pureber.BERExceptionInsufficientData,
pureber.berDecodeObject, pureber.BERDecoderContext(),
m[:1])
self.assertEquals((None, 0),
pureber.berDecodeObject(pureber.BERDecoderContext(),
''))