def setUp(self):
"""
Create a test packer.
"""
self.packer = Packer()
class PackTestCase(TestCase):
"""
Test packing of erlang terms.
"""
def setUp(self):
"""
Create a test packer.
"""
self.packer = Packer()
def test_packChar(self):
"""
Pack an integer on 1 byte, not the erlang term.
"""
self.assertEqual(self.packer.packChar(3), "\x03")
def test_packCharError(self):
"""
Char values are limited between 0 and 255, so values out of this
range should raise an error.
"""
self.assertRaises(ValueError, self.packer.packChar, 302)
self.assertRaises(ValueError, self.packer.packChar, -3)
def test_packShort(self):
"""
Pack integers on 2 bytes, not the erlang terms.
"""
self.assertEqual(self.packer.packShort(3), "\x00\x03")
self.assertEqual(self.packer.packShort(2032), "\x07\xf0")
def test_packShortError(self):
"""
Short values are limited between 0 and 65535, so values out of this
range should raise an error.
"""
self.assertRaises(ValueError, self.packer.packShort, 723120)
def test_packInt(self):
"""
Test packing integers, not the erlang terms.
"""
self.assertEqual(self.packer.packInt(3), "\x00\x00\x00\x03")
self.assertEqual(self.packer.packInt(2032), "\x00\x00\x07\xf0")
self.assertEqual(self.packer.packInt(723120), "\x00\x0b\x08\xb0")
def test_packIntError(self):
"""
Int values should fit in 32 bits, so values out of this range should
raise an error.
"""
self.assertRaises(ValueError, self.packer.packInt, pow(2, 32) + 312)
def test_packLargeInt(self):
"""
Test packing a long integer.
"""
i = 2 ** 32 + 10
self.assertEqual(
self.packer.pack_int(i), "n\x05\x00\n\x00\x00\x00\x01")
def test_packAtom(self):
"""
Pack an atom term.
"""
self.assertEqual(self.packer.packOneTerm(Atom("yes")), "d\x00\x03yes")
def test_packNewReference(self):
"""
Test packing a new reference.
"""
r = Reference(Atom("bar"), [3, 4], 2)
self.assertEqual(
self.packer.packOneTerm(r),
"r\x00\x02d\x00\x03bar\x02\x00\x00\x00\x03\x00\x00\x00\x04")
def test_packSmallInteger(self):
"""
Test packing a small integer.
"""
self.assertEqual(self.packer.packOneTerm(123), "a\x7b")
def test_packBigInteger(self):
"""
Test packing a big integer.
"""
self.assertEqual(self.packer.packOneTerm(1230), "b\x00\x00\x04\xce")
self.assertEqual(self.packer.packOneTerm(-123), "b\xff\xff\xff\x85")
def test_packSmallString(self):
"""
Test packing a small string.
"""
self.assertEqual(self.packer.packOneTerm("spam"), "k\x00\x04spam")
def test_packFloat(self):
"""
Test packing a float.
"""
self.assertEqual(
self.packer.packOneTerm(1.234),
"c1.23399999999999998579e+00\x00\x00\x00\x00\x00")
self.assertEqual(
self.packer.packOneTerm(-5.678),
"c-5.67799999999999993605e+00\x00\x00\x00\x00")
def test_packString(self):
"""
Test packing a big string.
"""
# Fake size of short for not allocating a huge string
self.packer.MAX_SHORT = 15
longString = "x" * 20
term = self.packer.packOneTerm(longString)
self.assertEqual(
term,
"l\x00\x00\x00\x14axaxaxaxaxaxaxaxaxaxaxaxaxaxaxaxaxaxaxaxj")
def test_packBInary(self):
"""
Test packing a binary value.
"""
term = self.packer.packOneTerm(Binary("abc"))
self.assertEqual(term, "m\x00\x00\x00\x03abc")
def test_packPid(self):
"""
Test packing a Pid.
"""
p = Pid(Atom("foo"), 1234, 12, 2)
self.assertEqual(
self.packer.packOneTerm(p),
"gd\x00\x03foo\x00\x00\x04\xd2\x00\x00\x00\x0c\x02")
def test_packReference(self):
"""
Test packing an old style reference.
"""
r = Reference(Atom("bar"), 3, 2)
self.assertEqual(
self.packer.packOneTerm(r),
"ed\x00\x03bar\x00\x00\x00\x03\x02")
def test_packSmallTuple(self):
"""
Test packing a tuple of atoms.
"""
t = Tuple((Atom("a"), Atom("b")))
self.assertEqual(
self.packer.packOneTerm(t),
"h\x02d\x00\x01ad\x00\x01b")
def test_packLargeTuple(self):
"""
Test packing a large tuple of atoms.
"""
# Limit the size for not building a huge list
self.packer.MAX_CHAR = 2
t = Tuple((Atom("a"), Atom("b"), Atom("c")))
self.assertEqual(
self.packer.packOneTerm(t),
"i\x00\x00\x00\x03d\x00\x01ad\x00\x01bd\x00\x01c")
def test_packList(self):
"""
Test packing a list of atoms.
"""
t = List((Atom("a"), Atom("b")))
self.assertEqual(
self.packer.packOneTerm(t),
"l\x00\x00\x00\x02d\x00\x01ad\x00\x01bj")
def test_packIntegerList(self):
"""
Test packing a list of integers.
"""
t = List([1, 2])
self.assertEqual(
self.packer.packOneTerm(t), "k\x00\x02\x01\x02")
def test_packEmptyList(self):
"""
Test packing an empty list.
"""
self.assertEqual(self.packer.packOneTerm([]), "j")
def test_packDict(self):
"""
Test primary support for dict.
"""
d = {Atom("foo"): "bar", Atom("spam"): 1}
items = d.items()
elts = (self.packer.packOneTerm(items[0])[1:],
self.packer.packOneTerm(items[1])[1:])
self.assertEqual(
self.packer.packOneTerm(d),
"h\td\x00\x04dicta\x02a\x10a\x10a\x08aPa0h\x10jjjjjjjjjjjjjjjjh"
"\x01h\x10l\x00\x00\x00\x01l\x00\x00\x00%sj"
"jl\x00\x00\x00\x01l\x00\x00\x00%s"
"jjjjjjjjjjjjjjjj" % elts)
def test_packEmptyDict(self):
"""
Test packing an empty dict, against the expected corresponding data
structure, and raw binary.
"""
d = {}
expected = (
Atom("dict"), 0, 16, 16, 8, 80, 48, ([],) * 16, (([],) * 16,))
expectedRaw = (
"h\td\x00\x04dicta\x00a\x10a\x10a\x08aPa0h\x10"
"jjjjjjjjjjjjjjjjh\x01h\x10jjjjjjjjjjjjjjjj")
self.assertEqual(
self.packer.packOneTerm(d), self.packer.packOneTerm(expected))
self.assertEqual(
self.packer.packOneTerm(d), expectedRaw)
def test_packSet(self):
"""
Test primary support for set.
"""
s = set([Atom("bar"), Atom("foo")])
val = [i.text for i in s]
self.assertEqual(
self.packer.packOneTerm(s),
"h\td\x00\x03seta\x02a\x10a\x10a\x08aPa0h\x10jjjjjjjjjjjjjjjj"
"h\x01h\x10l\x00\x00\x00\x01d\x00\x03%sjl\x00\x00\x00\x01"
"d\x00\x03%sjjjjjjjjjjjjjjj" % tuple(val))
def test_packEmptySet(self):
"""
Test packing an empty set, against the expected corresponding data
structure, and raw binary.
"""
s = set()
expected = (
Atom("set"), 0, 16, 16, 8, 80, 48, ([],) * 16, (([],) * 16,))
expectedRaw = (
"h\td\x00\x03seta\x00a\x10a\x10a\x08aPa0h\x10"
"jjjjjjjjjjjjjjjjh\x01h\x10jjjjjjjjjjjjjjjj")
self.assertEqual(
self.packer.packOneTerm(s), self.packer.packOneTerm(expected))
self.assertEqual(
self.packer.packOneTerm(s), expectedRaw)
def test_packUnhandledClass(self):
"""
Try packing an object not handled.
"""
d = object()
self.assertRaises(UnhandledClass, self.packer.packOneTerm, d)
def test_termToBinary(self):
"""
C{termToBinary} should produce a fully compliant object with the
C{MAGIC_VERSION} flag.
"""
self.assertEqual(self.packer.termToBinary(123), "\x83a\x7b")
def test_compressed(self):
"""
C{termToBinary} can compress the binary data retrieved, using
C{zlib.compress} with the given compression level..
"""
self.assertEqual(
self.packer.termToBinary("x" * 35, compress=6),
"\x83P\x00\x00\x00&x\x9c\xcbfP\xae \x0c\x00<S\x10\xf7")
# The string is almost the same because the amount of data is low
# The only bit changing is the one specifying the compressing level
self.assertEqual(
self.packer.termToBinary("x" * 35, compress=2),
"\x83P\x00\x00\x00&x^\xcbfP\xae \x0c\x00<S\x10\xf7")
def test_new_float(self):
"""
Test packing a new format float.
"""
self.assertEqual(
self.packer.packOneTerm(NewFloat(1.234)), "F?\xf3\xbev\xc8\xb49X")
