def test_decode_bool(self):
self.assertTrue(
rencode.loads(rencode.dumps(True)) == True == q_loads(
rencode.dumps(True)))
self.assertTrue(
rencode.loads(rencode.dumps(False)) == False == q_loads(
rencode.dumps(False)))
def test_decode_char(self):
self.assertTrue(
rencode.loads(rencode.dumps(100)) == 100 == q_loads(
rencode.dumps(100)))
self.assertTrue(
rencode.loads(rencode.dumps(-100)) == -100 == q_loads(
rencode.dumps(-100)))
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([62])))
self.assertTrue(0 == q_loads(bytes(bytearray([62]))))
def test_decode_int(self):
self.assertTrue(
rencode.loads(rencode.dumps(7483648)) == 7483648 == q_loads(
rencode.dumps(7483648)))
self.assertTrue(
rencode.loads(rencode.dumps(-7483648)) == -7483648 == q_loads(
rencode.dumps(-7483648)))
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([64])))
self.assertTrue(0 == q_loads(bytes(bytearray([64]))))
def test_decode_short(self):
self.assertTrue(
rencode.loads(rencode.dumps(27123)) == 27123 == q_loads(
rencode.dumps(27123)))
self.assertTrue(
rencode.loads(rencode.dumps(-27123)) == -27123 == q_loads(
rencode.dumps(-27123)))
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([63])))
self.assertTrue(0 == q_loads(bytes(bytearray([63]))))
def test_decode_long_long(self):
self.assertTrue(
rencode.loads(rencode.dumps(8223372036854775808)) ==
8223372036854775808 == q_loads(rencode.dumps(8223372036854775808)))
self.assertTrue(
rencode.loads(rencode.dumps(-8223372036854775808))
== -8223372036854775808 == q_loads(
rencode.dumps(-8223372036854775808)))
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([65])))
self.assertTrue(0 == q_loads(bytes(bytearray([65]))))
def test_decode_list(self):
l = [100, False, b"foobar", u("bäz").encode("utf8")] * 80
self.assertTrue(
list(rencode.loads(rencode.dumps(l))) == list(l) == q_loads(
rencode.dumps(l)))
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([59])))
self.assertTrue(0 == q_loads(bytes(bytearray([59]))))
def test_decode_dict(self):
s = b"abcdefghijklmnopqrstuvwxyz1234567890"
d = dict(zip(s, [b"foo" * 120] * len(s)))
d2 = {b"foo": d, b"bar": d, b"baz": d}
self.assertTrue(rencode.loads(rencode.dumps(d2)) == d2)
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([60])))
self.assertTrue(0 == q_loads(bytes(bytearray([60]))))
def test_decode_int_big_number(self):
n = int(b"9" * 62)
toobig = '={x}\x7f'.format(x='9' * 65).encode()
self.assertTrue(rencode.loads(rencode.dumps(n)) == n)
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([61])))
self.assertRaises(ValueError, rencode.loads, toobig)
self.assertTrue(0 == q_loads(bytes(bytearray([61]))))
self.assertTrue(0 == q_loads(toobig))
def test_decode_utf8(self):
s = b"foobarbaz"
#no assertIsInstance with python2.6
d = rencode.loads(rencode.dumps(s), decode_utf8=True)
if not isinstance(d, unicode):
self.fail('%s is not an instance of %r' % (repr(d), unicode))
s = rencode.dumps(b"\x56\xe4foo\xc3")
self.assertRaises(UnicodeDecodeError, rencode.loads, s, decode_utf8=True)
def test_decode_utf8(self):
s = b"foobarbaz"
#no assertIsInstance with python2.6
d = rencode.loads(rencode.dumps(s), decode_utf8=True)
if not isinstance(d, unicode):
self.fail('%s is not an instance of %r' % (repr(d), unicode))
s = rencode.dumps(b"\x56\xe4foo\xc3")
self.assertRaises(UnicodeDecodeError,
rencode.loads,
s,
decode_utf8=True)
def test_decode_str_nullbytes(self):
b = (202, 132, 100, 114, 97, 119, 1, 0, 0, 63, 1, 242, 63, 1, 60, 132,
120, 50, 54, 52, 49, 51, 48, 58, 0, 0, 0, 1, 65, 154, 35, 215, 48,
204, 4, 35, 242, 3, 122, 218, 67, 192, 127, 40, 241, 127, 2, 86,
240, 63, 135, 177, 23, 119, 63, 31, 226, 248, 19, 13, 192, 111,
74, 126, 2, 15, 240, 31, 239, 48, 85, 238, 159, 155, 197, 241, 23,
119, 63, 2, 23, 245, 63, 24, 240, 86, 36, 176, 15, 187, 185, 248,
242, 255, 0, 126, 123, 141, 206, 60, 188, 1, 27, 254, 141, 169,
132, 93, 220, 252, 121, 184, 8, 31, 224, 63, 244, 226, 75, 224,
119, 135, 229, 248, 3, 243, 248, 220, 227, 203, 193, 3, 224, 127,
47, 134, 59, 5, 99, 249, 254, 35, 196, 127, 17, 252, 71, 136, 254,
35, 196, 112, 4, 177, 3, 63, 5, 220)
d = bytes(bytearray(b))
self.assertEqual(rencode.loads(rencode.dumps(d)), d)
def test_decode_fixed_dict():
rencode.loads(b'q\x81aE\x81cE\x81bE\x81eE\x81dE\x81gE\x81fE\x81iE\x81hE\x81kE\x81jE')
def test_decode_fixed_list():
rencode.loads(b'\xc4EEEE')
def test_decode_none():
rencode.loads(b'E')
def test_decode_bool(self):
self.assertEqual(rencode.loads(rencode.dumps(True)), True)
self.assertEqual(rencode.loads(rencode.dumps(False)), False)
def test_decode_short(self):
self.assertEqual(rencode.loads(rencode.dumps(27123)), 27123)
self.assertEqual(rencode.loads(rencode.dumps(-27123)), -27123)
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([63])))
def test_decode_fixed_str(self):
self.assertEqual(rencode.loads(rencode.dumps(b"foobarbaz")),
b"foobarbaz")
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([130])))
def test_decode_fixed_str(self):
self.assertEqual(rencode.loads(rencode.dumps("foobarbaz")), "foobarbaz")
def test_decode_str(self):
self.assertEqual(rencode.loads(rencode.dumps("f"*255)), "f"*255)
def test_decode_int_big_number(self):
n = int("9"*62)
self.assertEqual(rencode.loads(rencode.dumps(n)), n)
def test_decode_float_64bit(self):
f = rencode.dumps(1234.56, 64)
self.assertEqual(rencode.loads(f), rencode_orig.loads(f))
def test_decode_long_long(self):
self.assertEqual(rencode.loads(rencode.dumps(8223372036854775808)), 8223372036854775808)
self.assertEqual(rencode.loads(rencode.dumps(-8223372036854775808)), -8223372036854775808)
def test_decode_fixed_str(self):
self.assertTrue(
rencode.loads(rencode.dumps(b"foobarbaz")) == b"foobarbaz" ==
q_loads(rencode.dumps(b"foobarbaz")))
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([130])))
self.assertTrue(0 == q_loads(bytes(bytearray([130]))))
def test_decode_str(self):
self.assertTrue(
rencode.loads(rencode.dumps(b"f" * 255)) == b"f" *
255 == q_loads(rencode.dumps(b"f" * 255)))
self.assertRaises(IndexError, rencode.loads, b"50")
self.assertTrue(0 == q_loads(b"50"))
def test_overall_decode():
rencode.loads(overall_decode_str)
def test_decode_unicode(self):
self.assertEqual(rencode.loads(rencode.dumps(u"fööbar")), u"fööbar")
def test_decode_fixed_neg_int(self):
self.assertEqual(rencode.loads(rencode.dumps(-10)), -10)
def test_decode_none(self):
self.assertEqual(rencode.loads(rencode.dumps(None)), None)
def test_decode_long_long(self):
self.assertEqual(rencode.loads(rencode.dumps(8223372036854775808)),
8223372036854775808)
self.assertEqual(rencode.loads(rencode.dumps(-8223372036854775808)),
-8223372036854775808)
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([65])))
def test_decode_bool(self):
self.assertEqual(rencode.loads(rencode.dumps(True)), True)
self.assertEqual(rencode.loads(rencode.dumps(False)), False)
def test_decode_unicode(self):
self.assertEqual(rencode.loads(rencode.dumps(u("fööbar"))),
u("fööbar").encode("utf8"))
def test_decode_list(self):
l = [100, False, "foobar", u"bäz"]*80
self.assertEqual(rencode.loads(rencode.dumps(l)), tuple(l))
def test_decode_fixed_dict(self):
s = b"abcdefghijk"
d = dict(zip(s, [1234] * len(s)))
self.assertEqual(rencode.loads(rencode.dumps(d)), d)
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([104])))
def test_decode_fixed_dict(self):
s = "abcdefghijk"
d = dict(zip(s, [1234]*len(s)))
self.assertEqual(rencode.loads(rencode.dumps(d)), d)
def test_decode_unicode(self):
self.assertTrue(
rencode.loads(rencode.dumps(u("fööbar"))) == u("fööbar").encode(
"utf8") == q_loads(rencode.dumps(u("fööbar"))))
def test_decode_dict(self):
s = "abcdefghijklmnopqrstuvwxyz1234567890"
d = dict(zip(s, ["foo"*120]*len(s)))
d2 = {"foo": d, "bar": d, "baz": d}
self.assertEqual(rencode.loads(rencode.dumps(d2)), d2)
def test_decode_bool():
rencode.loads(b'C')
def test_decode_fixed_pos_int():
rencode.loads(b'(')
def test_decode_list():
rencode.loads(b';EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\x7f')
def test_decode_fixed_neg_int():
rencode.loads(b'b')
def test_decode_dict():
rencode.loads(b'<\x811E\x810E\x813E\x812E\x815E\x814E\x817E\x816E\x819E\x818E\x81aE\x81cE\x81bE\x81eE\x81dE\x81gE\x81fE\x81iE\x81hE\x81kE\x81jE\x81mE\x81lE\x81oE\x81nE\x81qE\x81pE\x81sE\x81rE\x81uE\x81tE\x81wE\x81vE\x81yE\x81xE\x81zE\x7f')
def test_decode_int_char_size():
rencode.loads(b'>d')
rencode.loads(b'>\x9c')
def test_decode_fixed_pos_int(self):
self.assertEqual(rencode.loads(rencode.dumps(10)), 10)
def test_decode_int_short_size():
rencode.loads(b'?i\xf3')
rencode.loads(b'?\x96\r')
def test_decode_char(self):
self.assertEqual(rencode.loads(rencode.dumps(100)), 100)
self.assertEqual(rencode.loads(rencode.dumps(-100)), -100)
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([62])))
def test_decode_int_int_size():
rencode.loads(b'@\x00r1\x00')
rencode.loads(b'@\xff\x8d\xcf\x00')
def test_decode_int(self):
self.assertEqual(rencode.loads(rencode.dumps(7483648)), 7483648)
self.assertEqual(rencode.loads(rencode.dumps(-7483648)), -7483648)
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([64])))
def test_decode_float_32bit(self):
f = rencode.dumps(1234.56)
self.assertTrue(
rencode.loads(f) == rencode_orig.loads(f) == q_loads(f))
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([66])))
self.assertTrue(0 == q_loads(bytes(bytearray([66]))))
def test_decode_float_64bit(self):
f = rencode.dumps(1234.56, 64)
self.assertEqual(rencode.loads(f), rencode_orig.loads(f))
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([44])))
def test_decode_int_big_number():
rencode.loads(b'=99999999999999999999999999999999999999999999999999999999999999\x7f')
def test_decode_str(self):
self.assertEqual(rencode.loads(rencode.dumps(b"f" * 255)), b"f" * 255)
self.assertRaises(IndexError, rencode.loads, b"50")
def test_decode_float_32bit():
rencode.loads(b'BD\x9aQ\xec')
def test_decode_none(self):
self.assertEqual(rencode.loads(rencode.dumps(None)), None)
def test_decode_float_64bit():
rencode.loads(b',@\x93J=p\xa3\xd7\n')
def test_decode_fixed_list(self):
l = [100, False, b"foobar", u("bäz").encode("utf8")] * 4
self.assertEqual(rencode.loads(rencode.dumps(l)), tuple(l))
self.assertRaises(IndexError, rencode.loads, bytes(bytearray([194])))
def test_decode_fixed_str():
rencode.loads(b'\x89foobarbaz')
def test_decode_str_bytes(self):
b = [202, 132, 100, 114, 97, 119, 1, 0, 0, 63, 1, 242, 63]
d = bytes(bytearray(b))
self.assertEqual(rencode.loads(rencode.dumps(d)), d)
def test_decode_str():
rencode.loads(b'255:fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')
def test_decode_int_long_long_size():
rencode.loads(b'Ar\x1fILX\x9c\x00\x00')
rencode.loads(b'A\x8d\xe0\xb6\xb3\xa7d\x00\x00')
def test_decode_none(self):
self.assertIsNone(rencode.loads(rencode.dumps(None)))
self.assertIsNone(q_loads(rencode.dumps(None)))
