forked from mirrors/gecko-dev
378 lines
12 KiB
Python
378 lines
12 KiB
Python
#!/usr/bin/env python
|
|
|
|
import unittest
|
|
import sys
|
|
|
|
sys.path.insert(0, '..')
|
|
import bitstring
|
|
from bitstring import MmapByteArray
|
|
from bitstring import Bits, BitArray, ConstByteStore, ByteStore
|
|
|
|
class Creation(unittest.TestCase):
|
|
def testCreationFromBytes(self):
|
|
s = Bits(bytes=b'\xa0\xff')
|
|
self.assertEqual((s.len, s.hex), (16, 'a0ff'))
|
|
s = Bits(bytes=b'abc', length=0)
|
|
self.assertEqual(s, '')
|
|
|
|
def testCreationFromBytesErrors(self):
|
|
self.assertRaises(bitstring.CreationError, Bits, bytes=b'abc', length=25)
|
|
|
|
def testCreationFromDataWithOffset(self):
|
|
s1 = Bits(bytes=b'\x0b\x1c\x2f', offset=0, length=20)
|
|
s2 = Bits(bytes=b'\xa0\xb1\xC2', offset=4)
|
|
self.assertEqual((s2.len, s2.hex), (20, '0b1c2'))
|
|
self.assertEqual((s1.len, s1.hex), (20, '0b1c2'))
|
|
self.assertTrue(s1 == s2)
|
|
|
|
def testCreationFromHex(self):
|
|
s = Bits(hex='0xA0ff')
|
|
self.assertEqual((s.len, s.hex), (16, 'a0ff'))
|
|
s = Bits(hex='0x0x0X')
|
|
self.assertEqual((s.length, s.hex), (0, ''))
|
|
|
|
def testCreationFromHexWithWhitespace(self):
|
|
s = Bits(hex=' \n0 X a 4e \r3 \n')
|
|
self.assertEqual(s.hex, 'a4e3')
|
|
|
|
def testCreationFromHexErrors(self):
|
|
self.assertRaises(bitstring.CreationError, Bits, hex='0xx0')
|
|
self.assertRaises(bitstring.CreationError, Bits, hex='0xX0')
|
|
self.assertRaises(bitstring.CreationError, Bits, hex='0Xx0')
|
|
self.assertRaises(bitstring.CreationError, Bits, hex='-2e')
|
|
# These really should fail, but it's awkward and not a big deal...
|
|
# self.assertRaises(bitstring.CreationError, Bits, '0x2', length=2)
|
|
# self.assertRaises(bitstring.CreationError, Bits, '0x3', offset=1)
|
|
|
|
def testCreationFromBin(self):
|
|
s = Bits(bin='1010000011111111')
|
|
self.assertEqual((s.length, s.hex), (16, 'a0ff'))
|
|
s = Bits(bin='00')[:1]
|
|
self.assertEqual(s.bin, '0')
|
|
s = Bits(bin=' 0000 \n 0001\r ')
|
|
self.assertEqual(s.bin, '00000001')
|
|
|
|
def testCreationFromBinWithWhitespace(self):
|
|
s = Bits(bin=' \r\r\n0 B 00 1 1 \t0 ')
|
|
self.assertEqual(s.bin, '00110')
|
|
|
|
def testCreationFromOctErrors(self):
|
|
s = Bits('0b00011')
|
|
self.assertRaises(bitstring.InterpretError, s._getoct)
|
|
self.assertRaises(bitstring.CreationError, s._setoct, '8')
|
|
|
|
def testCreationFromUintWithOffset(self):
|
|
self.assertRaises(bitstring.Error, Bits, uint=12, length=8, offset=1)
|
|
|
|
def testCreationFromUintErrors(self):
|
|
self.assertRaises(bitstring.CreationError, Bits, uint=-1, length=10)
|
|
self.assertRaises(bitstring.CreationError, Bits, uint=12)
|
|
self.assertRaises(bitstring.CreationError, Bits, uint=4, length=2)
|
|
self.assertRaises(bitstring.CreationError, Bits, uint=0, length=0)
|
|
self.assertRaises(bitstring.CreationError, Bits, uint=12, length=-12)
|
|
|
|
def testCreationFromInt(self):
|
|
s = Bits(int=0, length=4)
|
|
self.assertEqual(s.bin, '0000')
|
|
s = Bits(int=1, length=2)
|
|
self.assertEqual(s.bin, '01')
|
|
s = Bits(int=-1, length=11)
|
|
self.assertEqual(s.bin, '11111111111')
|
|
s = Bits(int=12, length=7)
|
|
self.assertEqual(s.int, 12)
|
|
s = Bits(int=-243, length=108)
|
|
self.assertEqual((s.int, s.length), (-243, 108))
|
|
for length in range(6, 10):
|
|
for value in range(-17, 17):
|
|
s = Bits(int=value, length=length)
|
|
self.assertEqual((s.int, s.length), (value, length))
|
|
s = Bits(int=10, length=8)
|
|
|
|
def testCreationFromIntErrors(self):
|
|
self.assertRaises(bitstring.CreationError, Bits, int=-1, length=0)
|
|
self.assertRaises(bitstring.CreationError, Bits, int=12)
|
|
self.assertRaises(bitstring.CreationError, Bits, int=4, length=3)
|
|
self.assertRaises(bitstring.CreationError, Bits, int=-5, length=3)
|
|
|
|
def testCreationFromSe(self):
|
|
for i in range(-100, 10):
|
|
s = Bits(se=i)
|
|
self.assertEqual(s.se, i)
|
|
|
|
def testCreationFromSeWithOffset(self):
|
|
self.assertRaises(bitstring.CreationError, Bits, se=-13, offset=1)
|
|
|
|
def testCreationFromSeErrors(self):
|
|
self.assertRaises(bitstring.CreationError, Bits, se=-5, length=33)
|
|
s = Bits(bin='001000')
|
|
self.assertRaises(bitstring.InterpretError, s._getse)
|
|
|
|
def testCreationFromUe(self):
|
|
[self.assertEqual(Bits(ue=i).ue, i) for i in range(0, 20)]
|
|
|
|
def testCreationFromUeWithOffset(self):
|
|
self.assertRaises(bitstring.CreationError, Bits, ue=104, offset=2)
|
|
|
|
def testCreationFromUeErrors(self):
|
|
self.assertRaises(bitstring.CreationError, Bits, ue=-1)
|
|
self.assertRaises(bitstring.CreationError, Bits, ue=1, length=12)
|
|
s = Bits(bin='10')
|
|
self.assertRaises(bitstring.InterpretError, s._getue)
|
|
|
|
def testCreationFromBool(self):
|
|
a = Bits('bool=1')
|
|
self.assertEqual(a, 'bool=1')
|
|
b = Bits('bool=0')
|
|
self.assertEqual(b, [0])
|
|
c = bitstring.pack('2*bool', 0, 1)
|
|
self.assertEqual(c, '0b01')
|
|
|
|
def testCreationKeywordError(self):
|
|
self.assertRaises(bitstring.CreationError, Bits, squirrel=5)
|
|
|
|
def testDataStoreType(self):
|
|
a = Bits('0xf')
|
|
self.assertEqual(type(a._datastore), bitstring.ConstByteStore)
|
|
|
|
|
|
class Initialisation(unittest.TestCase):
|
|
def testEmptyInit(self):
|
|
a = Bits()
|
|
self.assertEqual(a, '')
|
|
|
|
def testNoPos(self):
|
|
a = Bits('0xabcdef')
|
|
try:
|
|
a.pos
|
|
except AttributeError:
|
|
pass
|
|
else:
|
|
assert False
|
|
|
|
def testFind(self):
|
|
a = Bits('0xabcd')
|
|
r = a.find('0xbc')
|
|
self.assertEqual(r[0], 4)
|
|
r = a.find('0x23462346246', bytealigned=True)
|
|
self.assertFalse(r)
|
|
|
|
def testRfind(self):
|
|
a = Bits('0b11101010010010')
|
|
b = a.rfind('0b010')
|
|
self.assertEqual(b[0], 11)
|
|
|
|
def testFindAll(self):
|
|
a = Bits('0b0010011')
|
|
b = list(a.findall([1]))
|
|
self.assertEqual(b, [2, 5, 6])
|
|
|
|
|
|
class Cut(unittest.TestCase):
|
|
def testCut(self):
|
|
s = Bits(30)
|
|
for t in s.cut(3):
|
|
self.assertEqual(t, [0] * 3)
|
|
|
|
|
|
class InterleavedExpGolomb(unittest.TestCase):
|
|
def testCreation(self):
|
|
s1 = Bits(uie=0)
|
|
s2 = Bits(uie=1)
|
|
self.assertEqual(s1, [1])
|
|
self.assertEqual(s2, [0, 0, 1])
|
|
s1 = Bits(sie=0)
|
|
s2 = Bits(sie=-1)
|
|
s3 = Bits(sie=1)
|
|
self.assertEqual(s1, [1])
|
|
self.assertEqual(s2, [0, 0, 1, 1])
|
|
self.assertEqual(s3, [0, 0, 1, 0])
|
|
|
|
def testCreationFromProperty(self):
|
|
s = BitArray()
|
|
s.uie = 45
|
|
self.assertEqual(s.uie, 45)
|
|
s.sie = -45
|
|
self.assertEqual(s.sie, -45)
|
|
|
|
def testInterpretation(self):
|
|
for x in range(101):
|
|
self.assertEqual(Bits(uie=x).uie, x)
|
|
for x in range(-100, 100):
|
|
self.assertEqual(Bits(sie=x).sie, x)
|
|
|
|
def testErrors(self):
|
|
for f in ['sie=100, 0b1001', '0b00', 'uie=100, 0b1001']:
|
|
s = Bits(f)
|
|
self.assertRaises(bitstring.InterpretError, s._getsie)
|
|
self.assertRaises(bitstring.InterpretError, s._getuie)
|
|
self.assertRaises(ValueError, Bits, 'uie=-10')
|
|
|
|
|
|
class FileBased(unittest.TestCase):
|
|
def setUp(self):
|
|
self.a = Bits(filename='smalltestfile')
|
|
self.b = Bits(filename='smalltestfile', offset=16)
|
|
self.c = Bits(filename='smalltestfile', offset=20, length=16)
|
|
self.d = Bits(filename='smalltestfile', offset=20, length=4)
|
|
|
|
def testCreationWithOffset(self):
|
|
self.assertEqual(self.a, '0x0123456789abcdef')
|
|
self.assertEqual(self.b, '0x456789abcdef')
|
|
self.assertEqual(self.c, '0x5678')
|
|
|
|
def testBitOperators(self):
|
|
x = self.b[4:20]
|
|
self.assertEqual(x, '0x5678')
|
|
self.assertEqual((x & self.c).hex, self.c.hex)
|
|
self.assertEqual(self.c ^ self.b[4:20], 16)
|
|
self.assertEqual(self.a[23:36] | self.c[3:], self.c[3:])
|
|
|
|
def testAddition(self):
|
|
h = self.d + '0x1'
|
|
x = self.a[20:24] + self.c[-4:] + self.c[8:12]
|
|
self.assertEqual(x, '0x587')
|
|
x = self.b + x
|
|
self.assertEqual(x.hex, '456789abcdef587')
|
|
x = BitArray(x)
|
|
del x[12:24]
|
|
self.assertEqual(x, '0x456abcdef587')
|
|
|
|
class Mmap(unittest.TestCase):
|
|
def setUp(self):
|
|
self.f = open('smalltestfile', 'rb')
|
|
|
|
def tearDown(self):
|
|
self.f.close()
|
|
|
|
def testByteArrayEquivalence(self):
|
|
a = MmapByteArray(self.f)
|
|
self.assertEqual(a.bytelength, 8)
|
|
self.assertEqual(len(a), 8)
|
|
self.assertEqual(a[0], 0x01)
|
|
self.assertEqual(a[1], 0x23)
|
|
self.assertEqual(a[7], 0xef)
|
|
self.assertEqual(a[0:1], bytearray([1]))
|
|
self.assertEqual(a[:], bytearray([0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]))
|
|
self.assertEqual(a[2:4], bytearray([0x45, 0x67]))
|
|
|
|
def testWithLength(self):
|
|
a = MmapByteArray(self.f, 3)
|
|
self.assertEqual(a[0], 0x01)
|
|
self.assertEqual(len(a), 3)
|
|
|
|
def testWithOffset(self):
|
|
a = MmapByteArray(self.f, None, 5)
|
|
self.assertEqual(len(a), 3)
|
|
self.assertEqual(a[0], 0xab)
|
|
|
|
def testWithLengthAndOffset(self):
|
|
a = MmapByteArray(self.f, 3, 3)
|
|
self.assertEqual(len(a), 3)
|
|
self.assertEqual(a[0], 0x67)
|
|
self.assertEqual(a[:], bytearray([0x67, 0x89, 0xab]))
|
|
|
|
|
|
class Comparisons(unittest.TestCase):
|
|
def testUnorderable(self):
|
|
a = Bits(5)
|
|
b = Bits(5)
|
|
self.assertRaises(TypeError, a.__lt__, b)
|
|
self.assertRaises(TypeError, a.__gt__, b)
|
|
self.assertRaises(TypeError, a.__le__, b)
|
|
self.assertRaises(TypeError, a.__ge__, b)
|
|
|
|
|
|
class Subclassing(unittest.TestCase):
|
|
|
|
def testIsInstance(self):
|
|
class SubBits(bitstring.Bits): pass
|
|
a = SubBits()
|
|
self.assertTrue(isinstance(a, SubBits))
|
|
|
|
def testClassType(self):
|
|
class SubBits(bitstring.Bits): pass
|
|
self.assertEqual(SubBits().__class__, SubBits)
|
|
|
|
|
|
class LongBoolConversion(unittest.TestCase):
|
|
|
|
def testLongBool(self):
|
|
a = Bits(1000)
|
|
b = bool(a)
|
|
self.assertTrue(b is False)
|
|
|
|
|
|
# Some basic tests for the private ByteStore classes
|
|
|
|
class ConstByteStoreCreation(unittest.TestCase):
|
|
|
|
def testProperties(self):
|
|
a = ConstByteStore(bytearray(b'abc'))
|
|
self.assertEqual(a.bytelength, 3)
|
|
self.assertEqual(a.offset, 0)
|
|
self.assertEqual(a.bitlength, 24)
|
|
self.assertEqual(a._rawarray, b'abc')
|
|
|
|
def testGetBit(self):
|
|
a = ConstByteStore(bytearray([0x0f]))
|
|
self.assertEqual(a.getbit(0), False)
|
|
self.assertEqual(a.getbit(3), False)
|
|
self.assertEqual(a.getbit(4), True)
|
|
self.assertEqual(a.getbit(7), True)
|
|
|
|
b = ConstByteStore(bytearray([0x0f]), 7, 1)
|
|
self.assertEqual(b.getbit(2), False)
|
|
self.assertEqual(b.getbit(3), True)
|
|
|
|
def testGetByte(self):
|
|
a = ConstByteStore(bytearray(b'abcde'), 1, 13)
|
|
self.assertEqual(a.getbyte(0), 97)
|
|
self.assertEqual(a.getbyte(1), 98)
|
|
self.assertEqual(a.getbyte(4), 101)
|
|
|
|
|
|
class PadToken(unittest.TestCase):
|
|
|
|
def testCreation(self):
|
|
a = Bits('pad:10')
|
|
self.assertEqual(a, Bits(10))
|
|
b = Bits('pad:0')
|
|
self.assertEqual(b, Bits())
|
|
c = Bits('0b11, pad:1, 0b111')
|
|
self.assertEqual(c, Bits('0b110111'))
|
|
|
|
def testPack(self):
|
|
s = bitstring.pack('0b11, pad:3=5, 0b1')
|
|
self.assertEqual(s.bin, '110001')
|
|
d = bitstring.pack('pad:c', c=12)
|
|
self.assertEqual(d, Bits(12))
|
|
e = bitstring.pack('0xf, uint:12, pad:1, bin, pad:4, 0b10', 0, '111')
|
|
self.assertEqual(e.bin, '11110000000000000111000010')
|
|
|
|
def testUnpack(self):
|
|
s = Bits('0b111000111')
|
|
x, y = s.unpack('3, pad:3, 3')
|
|
self.assertEqual((x, y), (7, 7))
|
|
x, y = s.unpack('2, pad:2, bin')
|
|
self.assertEqual((x, y), (3, '00111'))
|
|
x = s.unpack('pad:1, pad:2, pad:3')
|
|
self.assertEqual(x, [])
|
|
|
|
|
|
class ModifiedByAddingBug(unittest.TestCase):
|
|
|
|
def testAdding(self):
|
|
a = Bits('0b0')
|
|
b = Bits('0b11')
|
|
c = a + b
|
|
self.assertEqual(c, '0b011')
|
|
self.assertEqual(a, '0b0')
|
|
self.assertEqual(b, '0b11')
|
|
|
|
def testAdding2(self):
|
|
a = Bits(100)
|
|
b = Bits(101)
|
|
c = a + b
|
|
self.assertEqual(a, 100)
|
|
self.assertEqual(b, 101)
|
|
self.assertEqual(c, 201)
|