def test_padded_8to23_mixed_big(self):
r = Repacker(Endian.BIG, 8, 23, low_pad=8, high_pad=1)
self.assertEqual(r.repack_unit, 32)
self.assertEqual(r.repack_size(2), 8)
self.assertEqual(r.repackable_size(7), 1)
self.assertEqual(r.repackable_size(8), 2)
a = BinData.from_spaced_hex(8, '11 22 33 44 55 66 77 88 99 aa')
b = r.repack(a, 1, 2)
self.assertEqual(b, BinData.from_spaced_hex(23, '223344 667788'))
def test_padded_8to23_right_little(self):
r = Repacker(Endian.LITTLE, 8, 23, low_pad=9)
self.assertEqual(r.repack_unit, 32)
self.assertEqual(r.repack_size(2), 8)
self.assertEqual(r.repackable_size(7), 1)
self.assertEqual(r.repackable_size(8), 2)
a = BinData.from_spaced_hex(8, '11 22 33 44 55 66 77 88 99 aa')
b = r.repack(a, 1, 2)
self.assertEqual(b, BinData.from_spaced_hex(23, '2aa219 4cc43b'))
def test_add(self):
a = BinData.from_spaced_hex(19, '11111 22222 33333')
b = BinData.from_spaced_hex(19, '44444 55555')
c = BinData.from_spaced_hex(20, '66666 77777')
d = BinData.from_spaced_hex(19, '11111 22222 33333 44444 55555')
self.assertEqual(a + b, d)
with self.assertRaises(ValueError):
a + c
with self.assertRaises(TypeError):
a + 'zlew'
with self.assertRaises(TypeError):
'zlew' + a
def test_split_8to1_little(self):
r = Repacker(Endian.LITTLE, 8, 1)
self.assertEqual(r.repack_unit, 8)
self.assertEqual(r.repack_size(12), 2)
self.assertEqual(r.repack_size(8), 1)
self.assertEqual(r.repack_size(9), 2)
self.assertEqual(r.repack_size(17), 3)
self.assertEqual(r.repackable_size(1), 8)
a = BinData.from_spaced_hex(8, '12 34 56')
b = r.repack(a, 1, 12)
c = BinData.from_spaced_hex(1, ' '.join(format(0x634, '012b')[::-1]))
self.assertEqual(b, c)
def test_gather_8to16_big(self):
r = Repacker(endian=Endian.BIG, from_width=8, to_width=16)
self.assertEqual(r.repack_unit, 16)
self.assertEqual(r.repack_size(2), 4)
self.assertEqual(r.repackable_size(2), 1)
self.assertEqual(r.repackable_size(3), 1)
self.assertEqual(r.repackable_size(4), 2)
a = BinData(8, [1, 2, 3, 4, 5, 6])
b = r.repack(a, start=1, num_elements=2)
self.assertEqual(b, BinData.from_spaced_hex(16, '0203 0405'))
c = r.repack(a, start=1)
self.assertEqual(b, c)
d = r.repack(a)
self.assertEqual(d, BinData.from_spaced_hex(16, '0102 0304 0506'))
def test_mash_8to12_big(self):
r = Repacker(Endian.BIG, 8, 12)
self.assertEqual(r.repack_unit, 24)
self.assertEqual(r.repack_size(1), 2)
self.assertEqual(r.repack_size(2), 3)
self.assertEqual(r.repackable_size(1), 0)
self.assertEqual(r.repackable_size(2), 1)
self.assertEqual(r.repackable_size(3), 2)
self.assertEqual(r.repackable_size(4), 2)
a = BinData.from_spaced_hex(8, '12 34 56 78 9a')
b = r.repack(a, 1, 2)
self.assertEqual(b, BinData.from_spaced_hex(12, '345 678'))
c = r.repack(a, 1)
self.assertEqual(b, c)
d = r.repack(a)
self.assertEqual(d, BinData.from_spaced_hex(12, '123 456 789'))
def test_mash_8to12_little(self):
r = Repacker(Endian.LITTLE, 8, 12)
self.assertEqual(r.repack_unit, 24)
self.assertEqual(r.repack_size(1), 2)
self.assertEqual(r.repack_size(2), 3)
self.assertEqual(r.repackable_size(1), 0)
self.assertEqual(r.repackable_size(2), 1)
self.assertEqual(r.repackable_size(3), 2)
self.assertEqual(r.repackable_size(4), 2)
a = BinData.from_spaced_hex(8, '12 34 56 78 9a')
b = r.repack(a, 1, 2)
self.assertEqual(b, BinData.from_spaced_hex(12, '634 785'))
c = r.repack(a, 1)
self.assertEqual(b, c)
d = r.repack(a)
self.assertEqual(d, BinData.from_spaced_hex(12, '412 563 a78'))
def test_split_16to8_big(self):
r = Repacker(Endian.BIG, 16, 8)
self.assertEqual(r.repack_unit, 16)
self.assertEqual(r.repack_size(3), 2)
self.assertEqual(r.repackable_size(3), 6)
a = BinData(16, [0x1234, 0x5678, 0x9abc])
b = r.repack(a, 1, 3)
self.assertEqual(b, BinData.from_spaced_hex(8, '56 78 9a'))
def test_split_60to20_big(self):
r = Repacker(Endian.BIG, 60, 20)
self.assertEqual(r.repack_unit, 60)
self.assertEqual(r.repack_size(1), 1)
self.assertEqual(r.repack_size(2), 1)
self.assertEqual(r.repack_size(3), 1)
self.assertEqual(r.repack_size(4), 2)
self.assertEqual(r.repackable_size(1), 3)
a = BinData(60, [0xfedcba987654321])
b = r.repack(a)
self.assertEqual(b, BinData.from_spaced_hex(20, 'fedcb a9876 54321'))
def test_init_str(self):
a = BinData.from_spaced_hex(12, '12')
self.assertEqual(a.width, 12)
self.assertEqual(a.raw_data, b'\x12\x00')
self.assertEqual(a.octets_per_element(), 2)
self.assertEqual(a.octets(), 2)
self.assertEqual(len(a), 1)
self.assertEqual(list(a), [0x12])
self.assertEqual(a, a[:])
self.assertEqual(str(a), '012')
self.assertEqual(repr(a),
'BinData.from_spaced_hex(12, \'012\')')
def test_setslice(self):
a = BinData(19, [0x12345, 0x6789a, 0x3cdef])
a[:] = BinData.from_spaced_hex(19, '54321 29876 7edcb')
self.assertEqual(a, BinData.from_spaced_hex(19, '54321 29876 7edcb'))
a[:] = BinData.from_spaced_hex(19, '11111 22222')
self.assertEqual(a, BinData.from_spaced_hex(19, '11111 22222'))
a = BinData(19, [0x12345, 0x6789a, 0x3cdef])
a[1:2] = BinData.from_spaced_hex(19, '54321 29876 7edcb')
c = BinData.from_spaced_hex(19, '12345 54321 29876 7edcb 3cdef')
self.assertEqual(a, c)
a[::-2] = BinData.from_spaced_hex(19, '11111 22222 33333')
c = BinData.from_spaced_hex(19, '33333 54321 22222 7edcb 11111')
self.assertEqual(a, c)
with self.assertRaises(TypeError):
a[3.0:] = BinData.from_spaced_hex(19, '11111 22222')
with self.assertRaises(TypeError):
a[:3.0] = BinData.from_spaced_hex(19, '11111 22222')
with self.assertRaises(TypeError):
a[::3.0] = BinData.from_spaced_hex(19, '11111 22222')
with self.assertRaises(TypeError):
a['zlew':] = BinData.from_spaced_hex(19, '11111 22222')
with self.assertRaises(TypeError):
a[:] = 'zlew'
with self.assertRaises(TypeError):
a[:] = [1, 2, 3]
with self.assertRaises(TypeError):
a[:] = b'\x12\x34'
with self.assertRaises(ValueError):
a[:] = BinData.from_spaced_hex(20, '11111 22222 33333')
with self.assertRaises(ValueError):
a[::2] = BinData.from_spaced_hex(19, '11111 22222')
def test_getslice(self):
a = BinData(19, [0x12345, 0x6789a, 0x3cdef])
self.assertEqual(a[:], a)
self.assertEqual(a[:],
BinData.from_spaced_hex(19, '12345 6789a 3cdef'))
self.assertEqual(a[1:], BinData.from_spaced_hex(19, '6789a 3cdef'))
self.assertEqual(a[4:], BinData.from_spaced_hex(19, ''))
self.assertEqual(a[-1:], BinData.from_spaced_hex(19, '3cdef'))
self.assertEqual(a[:-1], BinData.from_spaced_hex(19, '12345 6789a'))
self.assertEqual(a[:1], BinData.from_spaced_hex(19, '12345'))
self.assertEqual(a[1:2], BinData.from_spaced_hex(19, '6789a'))
self.assertEqual(a[2:1], BinData.from_spaced_hex(19, ''))
self.assertEqual(a[::-1],
BinData.from_spaced_hex(19, '3cdef 6789a 12345'))
self.assertEqual(a[::2], BinData.from_spaced_hex(19, '12345 3cdef'))
self.assertEqual(a[1::2], BinData.from_spaced_hex(19, '6789a'))
b = [5 ** x for x in range(5)]
c = BinData(10, b)
for start in range(-10, 10):
for end in range(-10, 10):
for stride in range(-10, 10):
if stride != 0:
t = b[start:end:stride]
self.assertEqual(list(c[start:end:stride]), t)
with self.assertRaises(TypeError):
a[3.0:]
with self.assertRaises(TypeError):
a[:3.0]
with self.assertRaises(TypeError):
a[::3.0]
with self.assertRaises(TypeError):
a['zlew':]
def test_data(self):
db = DbBackend(None)
node = Node(id=NodeID(),
tags={'my_tag'},
attr={'my_attr': 'my_val'},
pos_start=0x123,
pos_end=0x456,
data={'my_key'},
bindata={'my_bindata': 12345})
id2 = NodeID()
db.create(node)
db.set_data(node.id, 'int', 123)
db.set_data(node.id, 'bool', False)
db.set_data(node.id, 'none', None)
db.set_data(node.id, 'bytes', b'\x01\x02\x03')
db.set_data(node.id, 'str', 'abc')
db.set_data(node.id, 'list', (1, 2, 3))
db.set_data(node.id, 'dict', {'a': 'b', 'c': 'd'})
db.set_data(node.id, 'id', id2)
db.set_data(node.id, 'bindata', BinData.from_spaced_hex(12, '123 456'))
db.set_data(node.id, 'long', 0x123456789abcdef123456789abcdef)
db.set_data(node.id, 'neglong', -0x123456789abcdef123456789abcdef)
n2 = db.get(node.id)
self.assertEqual(
n2.data, {
'int',
'bool',
'bytes',
'str',
'list',
'dict',
'id',
'bindata',
'long',
'neglong',
})
self.assertEqual(db.get_data(node.id, 'int'), 123)
self.assertEqual(db.get_data(node.id, 'bool'), False)
self.assertEqual(db.get_data(node.id, 'none'), None)
self.assertEqual(db.get_data(node.id, 'meh'), None)
b = db.get_data(node.id, 'bytes')
s = db.get_data(node.id, 'str')
self.assertEqual(b, b'\x01\x02\x03')
self.assertEqual(s, 'abc')
self.assertIsInstance(b, bytes)
self.assertIsInstance(s, six.text_type)
self.assertEqual(db.get_data(node.id, 'list'), [1, 2, 3])
self.assertEqual(db.get_data(node.id, 'dict'), {'a': 'b', 'c': 'd'})
self.assertEqual(db.get_data(node.id, 'id'), id2)
self.assertEqual(db.get_data(node.id, 'bindata'),
BinData.from_spaced_hex(12, '123 456'))
self.assertEqual(db.get_data(node.id, 'long'),
0x123456789abcdef123456789abcdef)
self.assertEqual(db.get_data(node.id, 'neglong'),
-0x123456789abcdef123456789abcdef)
with self.assertRaises(TypeError):
db.set_data(node.id, b'zlew', 'zlew')
with self.assertRaises(TypeError):
db.set_data(node.id, 123, 456)
with self.assertRaises(TypeError):
db.get_data(node.id, b'zlew')
with self.assertRaises(TypeError):
db.get_data(node.id, 123)
def test_attr(self):
db = DbBackend(None)
id2 = NodeID()
node = Node(id=NodeID(),
tags={'my_tag'},
attr={
'int': 123,
'bool': False,
'bytes': b'\x01\x02\x03',
'str': 'abc',
'list': (1, 2, 3),
'dict': {
'a': 'b',
'c': 'd'
},
'id': id2,
'bindata': BinData.from_spaced_hex(12, '123 456'),
'long': 0x123456789abcdef123456789abcdef,
'neglong': -0x123456789abcdef123456789abcdef,
},
pos_start=0x123,
pos_end=0x456,
data={'my_key'},
bindata={'my_bindata': 12345})
db.create(node)
n2 = db.get(node.id)
self.assertEqual(
set(n2.attr.keys()), {
'int',
'bool',
'bytes',
'str',
'list',
'dict',
'id',
'bindata',
'long',
'neglong',
})
self.assertEqual(n2.attr['int'], 123)
self.assertEqual(n2.attr['bool'], False)
self.assertNotIn('none', n2.attr)
self.assertNotIn('meh', n2.attr)
b = n2.attr['bytes']
s = n2.attr['str']
self.assertEqual(b, b'\x01\x02\x03')
self.assertEqual(s, 'abc')
self.assertIsInstance(b, bytes)
self.assertIsInstance(s, six.text_type)
self.assertEqual(n2.attr['list'], [1, 2, 3])
self.assertEqual(n2.attr['dict'], {'a': 'b', 'c': 'd'})
self.assertEqual(n2.attr['id'], id2)
self.assertEqual(n2.attr['bindata'],
BinData.from_spaced_hex(12, '123 456'))
self.assertEqual(n2.attr['long'], 0x123456789abcdef123456789abcdef)
self.assertEqual(n2.attr['neglong'], -0x123456789abcdef123456789abcdef)
db.set_attr(node.id, 'int', None)
db.set_attr(node.id, 'bool', True)
db.set_attr(node.id, 'meh', 'meh')
n3 = db.get(node.id)
self.assertEqual(
set(n3.attr.keys()), {
'meh',
'bool',
'bytes',
'str',
'list',
'dict',
'id',
'bindata',
'long',
'neglong',
})
self.assertEqual(n3.attr['bool'], True)
self.assertEqual(n3.attr['meh'], 'meh')
with self.assertRaises(TypeError):
db.set_attr(node.id, b'zlew', 'zlew')
with self.assertRaises(TypeError):
db.set_attr(node.id, 123, 456)
with self.assertRaises(TypeError):
db.set_attr(node.id, 123, 456)
