forked from mirrors/gecko-dev
310 lines
No EOL
8.7 KiB
Python
310 lines
No EOL
8.7 KiB
Python
#!/usr/bin/env python
|
|
"""
|
|
Unit tests for the bitarray module.
|
|
"""
|
|
|
|
import unittest
|
|
import sys
|
|
|
|
sys.path.insert(0, '..')
|
|
import bitstring
|
|
from bitstring import BitArray
|
|
|
|
class All(unittest.TestCase):
|
|
def testCreationFromUint(self):
|
|
s = BitArray(uint=15, length=6)
|
|
self.assertEqual(s.bin, '001111')
|
|
s = BitArray(uint=0, length=1)
|
|
self.assertEqual(s.bin, '0')
|
|
s.uint = 1
|
|
self.assertEqual(s.uint, 1)
|
|
s = BitArray(length=8)
|
|
s.uint = 0
|
|
self.assertEqual(s.uint, 0)
|
|
s.uint = 255
|
|
self.assertEqual(s.uint, 255)
|
|
self.assertEqual(s.len, 8)
|
|
self.assertRaises(bitstring.CreationError, s._setuint, 256)
|
|
|
|
def testCreationFromOct(self):
|
|
s = BitArray(oct='7')
|
|
self.assertEqual(s.oct, '7')
|
|
self.assertEqual(s.bin, '111')
|
|
s.append('0o1')
|
|
self.assertEqual(s.bin, '111001')
|
|
s.oct = '12345670'
|
|
self.assertEqual(s.length, 24)
|
|
self.assertEqual(s.bin, '001010011100101110111000')
|
|
s = BitArray('0o123')
|
|
self.assertEqual(s.oct, '123')
|
|
|
|
|
|
class NoPosAttribute(unittest.TestCase):
|
|
def testReplace(self):
|
|
s = BitArray('0b01')
|
|
s.replace('0b1', '0b11')
|
|
self.assertEqual(s, '0b011')
|
|
|
|
def testDelete(self):
|
|
s = BitArray('0b000000001')
|
|
del s[-1:]
|
|
self.assertEqual(s, '0b00000000')
|
|
|
|
def testInsert(self):
|
|
s = BitArray('0b00')
|
|
s.insert('0xf', 1)
|
|
self.assertEqual(s, '0b011110')
|
|
|
|
def testInsertParameters(self):
|
|
s = BitArray('0b111')
|
|
self.assertRaises(TypeError, s.insert, '0x4')
|
|
|
|
def testOverwrite(self):
|
|
s = BitArray('0b01110')
|
|
s.overwrite('0b000', 1)
|
|
self.assertEqual(s, '0b00000')
|
|
|
|
def testOverwriteParameters(self):
|
|
s = BitArray('0b0000')
|
|
self.assertRaises(TypeError, s.overwrite, '0b111')
|
|
|
|
def testPrepend(self):
|
|
s = BitArray('0b0')
|
|
s.prepend([1])
|
|
self.assertEqual(s, [1, 0])
|
|
|
|
def testRol(self):
|
|
s = BitArray('0b0001')
|
|
s.rol(1)
|
|
self.assertEqual(s, '0b0010')
|
|
|
|
def testRor(self):
|
|
s = BitArray('0b1000')
|
|
s.ror(1)
|
|
self.assertEqual(s, '0b0100')
|
|
|
|
def testSetItem(self):
|
|
s = BitArray('0b000100')
|
|
s[4:5] = '0xf'
|
|
self.assertEqual(s, '0b000111110')
|
|
s[0:1] = [1]
|
|
self.assertEqual(s, '0b100111110')
|
|
|
|
|
|
class Bugs(unittest.TestCase):
|
|
def testAddingNonsense(self):
|
|
a = BitArray([0])
|
|
a += '0' # a uint of length 0 - so nothing gets added.
|
|
self.assertEqual(a, [0])
|
|
self.assertRaises(ValueError, a.__iadd__, '3')
|
|
self.assertRaises(ValueError, a.__iadd__, 'se')
|
|
self.assertRaises(ValueError, a.__iadd__, 'float:32')
|
|
|
|
def testPrependAfterCreationFromDataWithOffset(self):
|
|
s1 = BitArray(bytes=b'\x00\x00\x07\xff\xf0\x00', offset=21, length=15)
|
|
self.assertFalse(s1.any(0))
|
|
s1.prepend('0b0')
|
|
self.assertEqual(s1.bin, '0111111111111111')
|
|
s1.prepend('0b0')
|
|
self.assertEqual(s1.bin, '00111111111111111')
|
|
|
|
|
|
class ByteAligned(unittest.TestCase):
|
|
def testDefault(self, defaultbytealigned=bitstring.bytealigned):
|
|
self.assertFalse(defaultbytealigned)
|
|
|
|
def testChangingIt(self):
|
|
bitstring.bytealigned = True
|
|
self.assertTrue(bitstring.bytealigned)
|
|
bitstring.bytealigned = False
|
|
|
|
def testNotByteAligned(self):
|
|
bitstring.bytealigned = False
|
|
a = BitArray('0x00 ff 0f f')
|
|
l = list(a.findall('0xff'))
|
|
self.assertEqual(l, [8, 20])
|
|
p = a.find('0x0f')[0]
|
|
self.assertEqual(p, 4)
|
|
p = a.rfind('0xff')[0]
|
|
self.assertEqual(p, 20)
|
|
s = list(a.split('0xff'))
|
|
self.assertEqual(s, ['0x00', '0xff0', '0xff'])
|
|
a.replace('0xff', '')
|
|
self.assertEqual(a, '0x000')
|
|
|
|
def testByteAligned(self):
|
|
bitstring.bytealigned = True
|
|
a = BitArray('0x00 ff 0f f')
|
|
l = list(a.findall('0xff'))
|
|
self.assertEqual(l, [8])
|
|
p = a.find('0x0f')[0]
|
|
self.assertEqual(p, 16)
|
|
p = a.rfind('0xff')[0]
|
|
self.assertEqual(p, 8)
|
|
s = list(a.split('0xff'))
|
|
self.assertEqual(s, ['0x00', '0xff0ff'])
|
|
a.replace('0xff', '')
|
|
self.assertEqual(a, '0x000ff')
|
|
|
|
|
|
class SliceAssignment(unittest.TestCase):
|
|
|
|
def testSliceAssignmentSingleBit(self):
|
|
a = BitArray('0b000')
|
|
a[2] = '0b1'
|
|
self.assertEqual(a.bin, '001')
|
|
a[0] = BitArray(bin='1')
|
|
self.assertEqual(a.bin, '101')
|
|
a[-1] = '0b0'
|
|
self.assertEqual(a.bin, '100')
|
|
a[-3] = '0b0'
|
|
self.assertEqual(a.bin, '000')
|
|
|
|
def testSliceAssignmentSingleBitErrors(self):
|
|
a = BitArray('0b000')
|
|
self.assertRaises(IndexError, a.__setitem__, -4, '0b1')
|
|
self.assertRaises(IndexError, a.__setitem__, 3, '0b1')
|
|
self.assertRaises(TypeError, a.__setitem__, 1, 1.3)
|
|
|
|
def testSliceAssignmentMulipleBits(self):
|
|
a = BitArray('0b0')
|
|
a[0] = '0b110'
|
|
self.assertEqual(a.bin, '110')
|
|
a[0] = '0b000'
|
|
self.assertEqual(a.bin, '00010')
|
|
a[0:3] = '0b111'
|
|
self.assertEqual(a.bin, '11110')
|
|
a[-2:] = '0b011'
|
|
self.assertEqual(a.bin, '111011')
|
|
a[:] = '0x12345'
|
|
self.assertEqual(a.hex, '12345')
|
|
a[:] = ''
|
|
self.assertFalse(a)
|
|
|
|
def testSliceAssignmentMultipleBitsErrors(self):
|
|
a = BitArray()
|
|
self.assertRaises(IndexError, a.__setitem__, 0, '0b00')
|
|
a += '0b1'
|
|
a[0:2] = '0b11'
|
|
self.assertEqual(a, '0b11')
|
|
|
|
def testDelSliceStep(self):
|
|
a = BitArray(bin='100111101001001110110100101')
|
|
del a[::2]
|
|
self.assertEqual(a.bin, '0110010101100')
|
|
del a[3:9:3]
|
|
self.assertEqual(a.bin, '01101101100')
|
|
del a[2:7:1]
|
|
self.assertEqual(a.bin, '011100')
|
|
del a[::99]
|
|
self.assertEqual(a.bin, '11100')
|
|
del a[::1]
|
|
self.assertEqual(a.bin, '')
|
|
|
|
def testDelSliceNegativeStep(self):
|
|
a = BitArray('0b0001011101101100100110000001')
|
|
del a[5:23:-3]
|
|
self.assertEqual(a.bin, '0001011101101100100110000001')
|
|
del a[25:3:-3]
|
|
self.assertEqual(a.bin, '00011101010000100001')
|
|
del a[:6:-7]
|
|
self.assertEqual(a.bin, '000111010100010000')
|
|
del a[15::-2]
|
|
self.assertEqual(a.bin, '0010000000')
|
|
del a[::-1]
|
|
self.assertEqual(a.bin, '')
|
|
|
|
def testDelSliceErrors(self):
|
|
a = BitArray(10)
|
|
del a[5:3]
|
|
self.assertEqual(a, 10)
|
|
del a[3:5:-1]
|
|
self.assertEqual(a, 10)
|
|
|
|
def testDelSingleElement(self):
|
|
a = BitArray('0b0010011')
|
|
del a[-1]
|
|
self.assertEqual(a.bin, '001001')
|
|
del a[2]
|
|
self.assertEqual(a.bin, '00001')
|
|
try:
|
|
del a[5]
|
|
self.assertTrue(False)
|
|
except IndexError:
|
|
pass
|
|
|
|
def testSetSliceStep(self):
|
|
a = BitArray(bin='0000000000')
|
|
a[::2] = '0b11111'
|
|
self.assertEqual(a.bin, '1010101010')
|
|
a[4:9:3] = [0, 0]
|
|
self.assertEqual(a.bin, '1010001010')
|
|
a[7:3:-1] = [1, 1, 1, 0]
|
|
self.assertEqual(a.bin, '1010011110')
|
|
a[7:1:-2] = [0, 0, 1]
|
|
self.assertEqual(a.bin, '1011001010')
|
|
a[::-5] = [1, 1]
|
|
self.assertEqual(a.bin, '1011101011')
|
|
a[::-1] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
|
|
self.assertEqual(a.bin, '1000000000')
|
|
|
|
def testSetSliceErrors(self):
|
|
a = BitArray(8)
|
|
try:
|
|
a[::3] = [1]
|
|
self.assertTrue(False)
|
|
except ValueError:
|
|
pass
|
|
class A(object): pass
|
|
try:
|
|
a[1:2] = A()
|
|
self.assertTrue(False)
|
|
except TypeError:
|
|
pass
|
|
try:
|
|
a[1:4:-1] = [1, 2]
|
|
self.assertTrue(False)
|
|
except ValueError:
|
|
pass
|
|
|
|
|
|
class Subclassing(unittest.TestCase):
|
|
|
|
def testIsInstance(self):
|
|
class SubBits(BitArray): pass
|
|
a = SubBits()
|
|
self.assertTrue(isinstance(a, SubBits))
|
|
|
|
def testClassType(self):
|
|
class SubBits(BitArray): pass
|
|
self.assertEqual(SubBits().__class__, SubBits)
|
|
|
|
|
|
class Clear(unittest.TestCase):
|
|
|
|
def testClear(self):
|
|
s = BitArray('0xfff')
|
|
s.clear()
|
|
self.assertEqual(s.len, 0)
|
|
|
|
|
|
class Copy(unittest.TestCase):
|
|
|
|
def testCopyMethod(self):
|
|
s = BitArray(9)
|
|
t = s.copy()
|
|
self.assertEqual(s, t)
|
|
t[0] = True
|
|
self.assertEqual(t.bin, '100000000')
|
|
self.assertEqual(s.bin, '000000000')
|
|
|
|
|
|
class ModifiedByAddingBug(unittest.TestCase):
|
|
|
|
def testAdding(self):
|
|
a = BitArray('0b0')
|
|
b = BitArray('0b11')
|
|
c = a + b
|
|
self.assertEqual(c, '0b011')
|
|
self.assertEqual(a, '0b0')
|
|
self.assertEqual(b, '0b11') |