mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
3940 lines
135 KiB
Python
3940 lines
135 KiB
Python
|
#!/usr/bin/env python
|
||
|
|
|
||
|
|
import unittest
|
||
|
|
import sys
|
||
|
|
sys.path.insert(0, '..')
|
||
|
|
import bitstring
|
||
|
|
import copy
|
||
|
|
import os
|
||
|
|
import collections
|
||
|
|
from bitstring import BitStream, ConstBitStream, pack
|
||
|
|
from bitstring import ByteStore, offsetcopy
|
||
|
|
|
||
|
|
|
||
|
|
class FlexibleInitialisation(unittest.TestCase):
|
||
|
|
def testFlexibleInitialisation(self):
|
||
|
|
a = BitStream('uint:8=12')
|
||
|
|
c = BitStream(' uint : 8 = 12')
|
||
|
|
self.assertTrue(a == c == BitStream(uint=12, length=8))
|
||
|
|
self.assertEqual(a.uint, 12)
|
||
|
|
a = BitStream(' int:2= -1')
|
||
|
|
b = BitStream('int :2 = -1')
|
||
|
|
c = BitStream(' int: 2 =-1 ')
|
||
|
|
self.assertTrue(a == b == c == BitStream(int=-1, length=2))
|
||
|
|
|
||
|
|
def testFlexibleInitialisation2(self):
|
||
|
|
h = BitStream('hex=12')
|
||
|
|
o = BitStream('oct=33')
|
||
|
|
b = BitStream('bin=10')
|
||
|
|
self.assertEqual(h, '0x12')
|
||
|
|
self.assertEqual(o, '0o33')
|
||
|
|
self.assertEqual(b, '0b10')
|
||
|
|
|
||
|
|
def testFlexibleInitialisation3(self):
|
||
|
|
for s in ['se=-1', ' se = -1 ', 'se = -1']:
|
||
|
|
a = BitStream(s)
|
||
|
|
self.assertEqual(a.se, -1)
|
||
|
|
for s in ['ue=23', 'ue =23', 'ue = 23']:
|
||
|
|
a = BitStream(s)
|
||
|
|
self.assertEqual(a.ue, 23)
|
||
|
|
|
||
|
|
def testMultipleStringInitialisation(self):
|
||
|
|
a = BitStream('0b1 , 0x1')
|
||
|
|
self.assertEqual(a, '0b10001')
|
||
|
|
a = BitStream('ue=5, ue=1, se=-2')
|
||
|
|
self.assertEqual(a.read('ue'), 5)
|
||
|
|
self.assertEqual(a.read('ue'), 1)
|
||
|
|
self.assertEqual(a.read('se'), -2)
|
||
|
|
b = BitStream('uint:32 = 12, 0b11') + 'int:100=-100, 0o44'
|
||
|
|
self.assertEqual(b.read(32).uint, 12)
|
||
|
|
self.assertEqual(b.read(2).bin, '11')
|
||
|
|
self.assertEqual(b.read(100).int, -100)
|
||
|
|
|
||
|
|
|
||
|
|
class Reading(unittest.TestCase):
|
||
|
|
def testReadBits(self):
|
||
|
|
s = BitStream(bytes=b'\x4d\x55')
|
||
|
|
self.assertEqual(s.read(4).hex, '4')
|
||
|
|
self.assertEqual(s.read(8).hex, 'd5')
|
||
|
|
self.assertEqual(s.read(1), [0])
|
||
|
|
self.assertEqual(s.read(3).bin, '101')
|
||
|
|
self.assertFalse(s.read(0))
|
||
|
|
|
||
|
|
def testReadByte(self):
|
||
|
|
s = BitStream(hex='4d55')
|
||
|
|
self.assertEqual(s.read(8).hex, '4d')
|
||
|
|
self.assertEqual(s.read(8).hex, '55')
|
||
|
|
|
||
|
|
def testReadBytes(self):
|
||
|
|
s = BitStream(hex='0x112233448811')
|
||
|
|
self.assertEqual(s.read(3 * 8).hex, '112233')
|
||
|
|
self.assertRaises(ValueError, s.read, -2 * 8)
|
||
|
|
s.bitpos += 1
|
||
|
|
self.assertEqual(s.read(2 * 8).bin, '1000100100010000')
|
||
|
|
|
||
|
|
def testReadUE(self):
|
||
|
|
self.assertRaises(bitstring.InterpretError, BitStream('')._getue)
|
||
|
|
# The numbers 0 to 8 as unsigned Exponential-Golomb codes
|
||
|
|
s = BitStream(bin='1 010 011 00100 00101 00110 00111 0001000 0001001')
|
||
|
|
self.assertEqual(s.pos, 0)
|
||
|
|
for i in range(9):
|
||
|
|
self.assertEqual(s.read('ue'), i)
|
||
|
|
self.assertRaises(bitstring.ReadError, s.read, 'ue')
|
||
|
|
|
||
|
|
def testReadSE(self):
|
||
|
|
s = BitStream(bin='010 00110 0001010 0001000 00111')
|
||
|
|
self.assertEqual(s.read('se'), 1)
|
||
|
|
self.assertEqual(s.read('se'), 3)
|
||
|
|
self.assertEqual(s.readlist(3 * ['se']), [5, 4, -3])
|
||
|
|
|
||
|
|
|
||
|
|
class Find(unittest.TestCase):
|
||
|
|
def testFind1(self):
|
||
|
|
s = ConstBitStream(bin='0b0000110110000')
|
||
|
|
self.assertTrue(s.find(BitStream(bin='11011'), False))
|
||
|
|
self.assertEqual(s.bitpos, 4)
|
||
|
|
self.assertEqual(s.read(5).bin, '11011')
|
||
|
|
s.bitpos = 0
|
||
|
|
self.assertFalse(s.find('0b11001', False))
|
||
|
|
|
||
|
|
def testFind2(self):
|
||
|
|
s = BitStream(bin='0')
|
||
|
|
self.assertTrue(s.find(s, False))
|
||
|
|
self.assertEqual(s.pos, 0)
|
||
|
|
self.assertFalse(s.find('0b00', False))
|
||
|
|
self.assertRaises(ValueError, s.find, BitStream(), False)
|
||
|
|
|
||
|
|
def testFindWithOffset(self):
|
||
|
|
s = BitStream(hex='0x112233')[4:]
|
||
|
|
self.assertTrue(s.find('0x23', False))
|
||
|
|
self.assertEqual(s.pos, 8)
|
||
|
|
|
||
|
|
def testFindCornerCases(self):
|
||
|
|
s = BitStream(bin='000111000111')
|
||
|
|
self.assertTrue(s.find('0b000'))
|
||
|
|
self.assertEqual(s.pos, 0)
|
||
|
|
self.assertTrue(s.find('0b000'))
|
||
|
|
self.assertEqual(s.pos, 0)
|
||
|
|
self.assertTrue(s.find('0b0111000111'))
|
||
|
|
self.assertEqual(s.pos, 2)
|
||
|
|
self.assertTrue(s.find('0b000', start=2))
|
||
|
|
self.assertEqual(s.pos, 6)
|
||
|
|
self.assertTrue(s.find('0b111', start=6))
|
||
|
|
self.assertEqual(s.pos, 9)
|
||
|
|
s.pos += 2
|
||
|
|
self.assertTrue(s.find('0b1', start=s.pos))
|
||
|
|
|
||
|
|
def testFindBytes(self):
|
||
|
|
s = BitStream('0x010203040102ff')
|
||
|
|
self.assertFalse(s.find('0x05', bytealigned=True))
|
||
|
|
self.assertTrue(s.find('0x02', bytealigned=True))
|
||
|
|
self.assertEqual(s.read(16).hex, '0203')
|
||
|
|
self.assertTrue(s.find('0x02', start=s.bitpos, bytealigned=True))
|
||
|
|
s.read(1)
|
||
|
|
self.assertFalse(s.find('0x02', start=s.bitpos, bytealigned=True))
|
||
|
|
|
||
|
|
def testFindBytesAlignedCornerCases(self):
|
||
|
|
s = BitStream('0xff')
|
||
|
|
self.assertTrue(s.find(s))
|
||
|
|
self.assertFalse(s.find(BitStream(hex='0x12')))
|
||
|
|
self.assertFalse(s.find(BitStream(hex='0xffff')))
|
||
|
|
|
||
|
|
def testFindBytesBitpos(self):
|
||
|
|
s = BitStream(hex='0x1122334455')
|
||
|
|
s.pos = 2
|
||
|
|
s.find('0x66', bytealigned=True)
|
||
|
|
self.assertEqual(s.pos, 2)
|
||
|
|
s.pos = 38
|
||
|
|
s.find('0x66', bytealigned=True)
|
||
|
|
self.assertEqual(s.pos, 38)
|
||
|
|
|
||
|
|
def testFindByteAligned(self):
|
||
|
|
s = BitStream(hex='0x12345678')
|
||
|
|
self.assertTrue(s.find(BitStream(hex='0x56'), bytealigned=True))
|
||
|
|
self.assertEqual(s.bytepos, 2)
|
||
|
|
s.pos = 0
|
||
|
|
self.assertFalse(s.find(BitStream(hex='0x45'), bytealigned=True))
|
||
|
|
s = BitStream('0x1234')
|
||
|
|
s.find('0x1234')
|
||
|
|
self.assertTrue(s.find('0x1234'))
|
||
|
|
s += '0b111'
|
||
|
|
s.pos = 3
|
||
|
|
s.find('0b1', start=17, bytealigned=True)
|
||
|
|
self.assertFalse(s.find('0b1', start=17, bytealigned=True))
|
||
|
|
self.assertEqual(s.pos, 3)
|
||
|
|
|
||
|
|
def testFindByteAlignedWithOffset(self):
|
||
|
|
s = BitStream(hex='0x112233')[4:]
|
||
|
|
self.assertTrue(s.find(BitStream(hex='0x23')))
|
||
|
|
|
||
|
|
def testFindByteAlignedErrors(self):
|
||
|
|
s = BitStream(hex='0xffff')
|
||
|
|
self.assertRaises(ValueError, s.find, '')
|
||
|
|
self.assertRaises(ValueError, s.find, BitStream())
|
||
|
|
|
||
|
|
|
||
|
|
class Rfind(unittest.TestCase):
|
||
|
|
def testRfind(self):
|
||
|
|
a = BitStream('0b001001001')
|
||
|
|
b = a.rfind('0b001')
|
||
|
|
self.assertEqual(b, (6,))
|
||
|
|
self.assertEqual(a.pos, 6)
|
||
|
|
big = BitStream(length=100000) + '0x12' + BitStream(length=10000)
|
||
|
|
found = big.rfind('0x12', bytealigned=True)
|
||
|
|
self.assertEqual(found, (100000,))
|
||
|
|
self.assertEqual(big.pos, 100000)
|
||
|
|
|
||
|
|
def testRfindByteAligned(self):
|
||
|
|
a = BitStream('0x8888')
|
||
|
|
b = a.rfind('0b1', bytealigned=True)
|
||
|
|
self.assertEqual(b, (8,))
|
||
|
|
self.assertEqual(a.pos, 8)
|
||
|
|
|
||
|
|
def testRfindStartbit(self):
|
||
|
|
a = BitStream('0x0000ffffff')
|
||
|
|
b = a.rfind('0x0000', start=1, bytealigned=True)
|
||
|
|
self.assertEqual(b, ())
|
||
|
|
self.assertEqual(a.pos, 0)
|
||
|
|
b = a.rfind('0x00', start=1, bytealigned=True)
|
||
|
|
self.assertEqual(b, (8,))
|
||
|
|
self.assertEqual(a.pos, 8)
|
||
|
|
|
||
|
|
def testRfindEndbit(self):
|
||
|
|
a = BitStream('0x000fff')
|
||
|
|
b = a.rfind('0b011', bytealigned=False, start=0, end=14)
|
||
|
|
self.assertEqual(bool(b), True)
|
||
|
|
b = a.rfind('0b011', False, 0, 13)
|
||
|
|
self.assertEqual(b, ())
|
||
|
|
|
||
|
|
def testRfindErrors(self):
|
||
|
|
a = BitStream('0x43234234')
|
||
|
|
self.assertRaises(ValueError, a.rfind, '', bytealigned=True)
|
||
|
|
self.assertRaises(ValueError, a.rfind, '0b1', start=-99, bytealigned=True)
|
||
|
|
self.assertRaises(ValueError, a.rfind, '0b1', end=33, bytealigned=True)
|
||
|
|
self.assertRaises(ValueError, a.rfind, '0b1', start=10, end=9, bytealigned=True)
|
||
|
|
|
||
|
|
|
||
|
|
class Shift(unittest.TestCase):
|
||
|
|
def testShiftLeft(self):
|
||
|
|
s = BitStream('0b1010')
|
||
|
|
t = s << 1
|
||
|
|
self.assertEqual(s.bin, '1010')
|
||
|
|
self.assertEqual(t.bin, '0100')
|
||
|
|
t = t << 0
|
||
|
|
self.assertEqual(t, '0b0100')
|
||
|
|
t = t << 100
|
||
|
|
self.assertEqual(t.bin, '0000')
|
||
|
|
|
||
|
|
def testShiftLeftErrors(self):
|
||
|
|
s = BitStream()
|
||
|
|
self.assertRaises(ValueError, s.__lshift__, 1)
|
||
|
|
s = BitStream('0xf')
|
||
|
|
self.assertRaises(ValueError, s.__lshift__, -1)
|
||
|
|
|
||
|
|
def testShiftRight(self):
|
||
|
|
s = BitStream('0b1010')
|
||
|
|
t = s >> 1
|
||
|
|
self.assertEqual(s.bin, '1010')
|
||
|
|
self.assertEqual(t.bin, '0101')
|
||
|
|
q = s >> 0
|
||
|
|
self.assertEqual(q, '0b1010')
|
||
|
|
q.replace('0b1010', '')
|
||
|
|
s = s >> 100
|
||
|
|
self.assertEqual(s.bin, '0000')
|
||
|
|
|
||
|
|
def testShiftRightErrors(self):
|
||
|
|
s = BitStream()
|
||
|
|
self.assertRaises(ValueError, s.__rshift__, 1)
|
||
|
|
s = BitStream('0xf')
|
||
|
|
self.assertRaises(ValueError, s.__rshift__, -1)
|
||
|
|
|
||
|
|
def testShiftRightInPlace(self):
|
||
|
|
s = BitStream('0xffff')[4:12]
|
||
|
|
s >>= 1
|
||
|
|
self.assertEqual(s, '0b01111111')
|
||
|
|
s = BitStream('0b11011')
|
||
|
|
s >>= 2
|
||
|
|
self.assertEqual(s.bin, '00110')
|
||
|
|
s >>= 100000000000000
|
||
|
|
self.assertEqual(s.bin, '00000')
|
||
|
|
s = BitStream('0xff')
|
||
|
|
s >>= 1
|
||
|
|
self.assertEqual(s, '0x7f')
|
||
|
|
s >>= 0
|
||
|
|
self.assertEqual(s, '0x7f')
|
||
|
|
|
||
|
|
def testShiftRightInPlaceErrors(self):
|
||
|
|
s = BitStream()
|
||
|
|
self.assertRaises(ValueError, s.__irshift__, 1)
|
||
|
|
s += '0b11'
|
||
|
|
self.assertRaises(ValueError, s.__irshift__, -1)
|
||
|
|
|
||
|
|
def testShiftLeftInPlace(self):
|
||
|
|
s = BitStream('0xffff')
|
||
|
|
t = s[4:12]
|
||
|
|
t <<= 2
|
||
|
|
self.assertEqual(t, '0b11111100')
|
||
|
|
s = BitStream('0b11011')
|
||
|
|
s <<= 2
|
||
|
|
self.assertEqual(s.bin, '01100')
|
||
|
|
s <<= 100000000000000000000
|
||
|
|
self.assertEqual(s.bin, '00000')
|
||
|
|
s = BitStream('0xff')
|
||
|
|
s <<= 1
|
||
|
|
self.assertEqual(s, '0xfe')
|
||
|
|
s <<= 0
|
||
|
|
self.assertEqual(s, '0xfe')
|
||
|
|
|
||
|
|
def testShiftLeftInPlaceErrors(self):
|
||
|
|
s = BitStream()
|
||
|
|
self.assertRaises(ValueError, s.__ilshift__, 1)
|
||
|
|
s += '0b11'
|
||
|
|
self.assertRaises(ValueError, s.__ilshift__, -1)
|
||
|
|
|
||
|
|
|
||
|
|
class Replace(unittest.TestCase):
|
||
|
|
def testReplace1(self):
|
||
|
|
a = BitStream('0b1')
|
||
|
|
n = a.replace('0b1', '0b0', bytealigned=True)
|
||
|
|
self.assertEqual(a.bin, '0')
|
||
|
|
self.assertEqual(n, 1)
|
||
|
|
n = a.replace('0b1', '0b0', bytealigned=True)
|
||
|
|
self.assertEqual(n, 0)
|
||
|
|
|
||
|
|
def testReplace2(self):
|
||
|
|
a = BitStream('0b00001111111')
|
||
|
|
n = a.replace('0b1', '0b0', bytealigned=True)
|
||
|
|
self.assertEqual(a.bin, '00001111011')
|
||
|
|
self.assertEqual(n, 1)
|
||
|
|
n = a.replace('0b1', '0b0', bytealigned=False)
|
||
|
|
self.assertEqual(a.bin, '00000000000')
|
||
|
|
self.assertEqual(n, 6)
|
||
|
|
|
||
|
|
def testReplace3(self):
|
||
|
|
a = BitStream('0b0')
|
||
|
|
n = a.replace('0b0', '0b110011111', bytealigned=True)
|
||
|
|
self.assertEqual(n, 1)
|
||
|
|
self.assertEqual(a.bin, '110011111')
|
||
|
|
n = a.replace('0b11', '', bytealigned=False)
|
||
|
|
self.assertEqual(n, 3)
|
||
|
|
self.assertEqual(a.bin, '001')
|
||
|
|
|
||
|
|
def testReplace4(self):
|
||
|
|
a = BitStream('0x00114723ef4732344700')
|
||
|
|
n = a.replace('0x47', '0x00', bytealigned=True)
|
||
|
|
self.assertEqual(n, 3)
|
||
|
|
self.assertEqual(a.hex, '00110023ef0032340000')
|
||
|
|
a.replace('0x00', '', bytealigned=True)
|
||
|
|
self.assertEqual(a.hex, '1123ef3234')
|
||
|
|
a.replace('0x11', '', start=1, bytealigned=True)
|
||
|
|
self.assertEqual(a.hex, '1123ef3234')
|
||
|
|
a.replace('0x11', '0xfff', end=7, bytealigned=True)
|
||
|
|
self.assertEqual(a.hex, '1123ef3234')
|
||
|
|
a.replace('0x11', '0xfff', end=8, bytealigned=True)
|
||
|
|
self.assertEqual(a.hex, 'fff23ef3234')
|
||
|
|
|
||
|
|
def testReplace5(self):
|
||
|
|
a = BitStream('0xab')
|
||
|
|
b = BitStream('0xcd')
|
||
|
|
c = BitStream('0xabef')
|
||
|
|
c.replace(a, b)
|
||
|
|
self.assertEqual(c, '0xcdef')
|
||
|
|
self.assertEqual(a, '0xab')
|
||
|
|
self.assertEqual(b, '0xcd')
|
||
|
|
a = BitStream('0x0011223344')
|
||
|
|
a.pos = 12
|
||
|
|
a.replace('0x11', '0xfff', bytealigned=True)
|
||
|
|
self.assertEqual(a.pos, 8)
|
||
|
|
self.assertEqual(a, '0x00fff223344')
|
||
|
|
|
||
|
|
def testReplaceWithSelf(self):
|
||
|
|
a = BitStream('0b11')
|
||
|
|
a.replace('0b1', a)
|
||
|
|
self.assertEqual(a, '0xf')
|
||
|
|
a.replace(a, a)
|
||
|
|
self.assertEqual(a, '0xf')
|
||
|
|
|
||
|
|
def testReplaceCount(self):
|
||
|
|
a = BitStream('0x223344223344223344')
|
||
|
|
n = a.replace('0x2', '0x0', count=0, bytealigned=True)
|
||
|
|
self.assertEqual(n, 0)
|
||
|
|
self.assertEqual(a.hex, '223344223344223344')
|
||
|
|
n = a.replace('0x2', '0x0', count=1, bytealigned=True)
|
||
|
|
self.assertEqual(n, 1)
|
||
|
|
self.assertEqual(a.hex, '023344223344223344')
|
||
|
|
n = a.replace('0x33', '', count=2, bytealigned=True)
|
||
|
|
self.assertEqual(n, 2)
|
||
|
|
self.assertEqual(a.hex, '02442244223344')
|
||
|
|
n = a.replace('0x44', '0x4444', count=1435, bytealigned=True)
|
||
|
|
self.assertEqual(n, 3)
|
||
|
|
self.assertEqual(a.hex, '02444422444422334444')
|
||
|
|
|
||
|
|
def testReplaceBitpos(self):
|
||
|
|
a = BitStream('0xff')
|
||
|
|
a.bitpos = 8
|
||
|
|
a.replace('0xff', '', bytealigned=True)
|
||
|
|
self.assertEqual(a.bitpos, 0)
|
||
|
|
a = BitStream('0b0011110001')
|
||
|
|
a.bitpos = 4
|
||
|
|
a.replace('0b1', '0b000')
|
||
|
|
self.assertEqual(a.bitpos, 8)
|
||
|
|
a = BitStream('0b1')
|
||
|
|
a.bitpos = 1
|
||
|
|
a.replace('0b1', '0b11111', bytealigned=True)
|
||
|
|
self.assertEqual(a.bitpos, 5)
|
||
|
|
a.replace('0b11', '0b0', False)
|
||
|
|
self.assertEqual(a.bitpos, 3)
|
||
|
|
a.append('0b00')
|
||
|
|
a.replace('0b00', '0xffff')
|
||
|
|
self.assertEqual(a.bitpos, 17)
|
||
|
|
|
||
|
|
def testReplaceErrors(self):
|
||
|
|
a = BitStream('0o123415')
|
||
|
|
self.assertRaises(ValueError, a.replace, '', '0o7', bytealigned=True)
|
||
|
|
self.assertRaises(ValueError, a.replace, '0b1', '0b1', start=-100, bytealigned=True)
|
||
|
|
self.assertRaises(ValueError, a.replace, '0b1', '0b1', end=19, bytealigned=True)
|
||
|
|
|
||
|
|
|
||
|
|
class SliceAssignment(unittest.TestCase):
|
||
|
|
|
||
|
|
# TODO: Move this to another class
|
||
|
|
def testSetSlice(self):
|
||
|
|
a = BitStream()
|
||
|
|
a[0:0] = '0xabcdef'
|
||
|
|
self.assertEqual(a.bytepos, 3)
|
||
|
|
a[4:16] = ''
|
||
|
|
self.assertEqual(a, '0xaef')
|
||
|
|
self.assertEqual(a.bitpos, 4)
|
||
|
|
a[8:] = '0x00'
|
||
|
|
self.assertEqual(a, '0xae00')
|
||
|
|
self.assertEqual(a.bytepos, 2)
|
||
|
|
a += '0xf'
|
||
|
|
a[8:] = '0xe'
|
||
|
|
self.assertEqual(a, '0xaee')
|
||
|
|
self.assertEqual(a.bitpos, 12)
|
||
|
|
b = BitStream()
|
||
|
|
b[0:800] = '0xffee'
|
||
|
|
self.assertEqual(b, '0xffee')
|
||
|
|
b[4:48] = '0xeed123'
|
||
|
|
self.assertEqual(b, '0xfeed123')
|
||
|
|
b[-800:8] = '0x0000'
|
||
|
|
self.assertEqual(b, '0x0000ed123')
|
||
|
|
a = BitStream('0xabcde')
|
||
|
|
self.assertEqual(a[-100:-90], '')
|
||
|
|
self.assertEqual(a[-100:-16], '0xa')
|
||
|
|
a[-100:-16] = '0x0'
|
||
|
|
self.assertEqual(a, '0x0bcde')
|
||
|
|
|
||
|
|
def testInsertingUsingSetItem(self):
|
||
|
|
a = BitStream()
|
||
|
|
a[0:0] = '0xdeadbeef'
|
||
|
|
self.assertEqual(a, '0xdeadbeef')
|
||
|
|
self.assertEqual(a.bytepos, 4)
|
||
|
|
a[16:16] = '0xfeed'
|
||
|
|
self.assertEqual(a, '0xdeadfeedbeef')
|
||
|
|
self.assertEqual(a.bytepos, 4)
|
||
|
|
a[0:0] = '0xa'
|
||
|
|
self.assertEqual(a, '0xadeadfeedbeef')
|
||
|
|
self.assertEqual(a.bitpos, 4)
|
||
|
|
a.bytepos = 6
|
||
|
|
a[0:0] = '0xff'
|
||
|
|
self.assertEqual(a.bytepos, 1)
|
||
|
|
a[8:0] = '0x00000'
|
||
|
|
self.assertTrue(a.startswith('0xff00000adead'))
|
||
|
|
|
||
|
|
def testSliceAssignmentBitPos(self):
|
||
|
|
a = BitStream('int:64=-1')
|
||
|
|
a.pos = 64
|
||
|
|
a[0:8] = ''
|
||
|
|
self.assertEqual(a.pos, 0)
|
||
|
|
a.pos = 52
|
||
|
|
a[48:56] = '0x0000'
|
||
|
|
self.assertEqual(a.pos, 64)
|
||
|
|
a[10:10] = '0x0'
|
||
|
|
self.assertEqual(a.pos, 14)
|
||
|
|
a[56:68] = '0x000'
|
||
|
|
self.assertEqual(a.pos, 14)
|
||
|
|
|
||
|
|
|
||
|
|
class Pack(unittest.TestCase):
|
||
|
|
def testPack1(self):
|
||
|
|
s = bitstring.pack('uint:6, bin, hex, int:6, se, ue, oct', 10, '0b110', 'ff', -1, -6, 6, '54')
|
||
|
|
t = BitStream('uint:6=10, 0b110, 0xff, int:6=-1, se=-6, ue=6, oct=54')
|
||
|
|
self.assertEqual(s, t)
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'tomato', '0')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'uint', 12)
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'hex', 'penguin')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'hex12', '0x12')
|
||
|
|
|
||
|
|
def testPackWithLiterals(self):
|
||
|
|
s = bitstring.pack('0xf')
|
||
|
|
self.assertEqual(s, '0xf')
|
||
|
|
self.assertTrue(type(s), BitStream)
|
||
|
|
s = pack('0b1')
|
||
|
|
self.assertEqual(s, '0b1')
|
||
|
|
s = pack('0o7')
|
||
|
|
self.assertEqual(s, '0o7')
|
||
|
|
s = pack('int:10=-1')
|
||
|
|
self.assertEqual(s, '0b1111111111')
|
||
|
|
s = pack('uint:10=1')
|
||
|
|
self.assertEqual(s, '0b0000000001')
|
||
|
|
s = pack('ue=12')
|
||
|
|
self.assertEqual(s.ue, 12)
|
||
|
|
s = pack('se=-12')
|
||
|
|
self.assertEqual(s.se, -12)
|
||
|
|
s = pack('bin=01')
|
||
|
|
self.assertEqual(s.bin, '01')
|
||
|
|
s = pack('hex=01')
|
||
|
|
self.assertEqual(s.hex, '01')
|
||
|
|
s = pack('oct=01')
|
||
|
|
self.assertEqual(s.oct, '01')
|
||
|
|
|
||
|
|
def testPackWithDict(self):
|
||
|
|
a = pack('uint:6=width, se=height', height=100, width=12)
|
||
|
|
w, h = a.unpack('uint:6, se')
|
||
|
|
self.assertEqual(w, 12)
|
||
|
|
self.assertEqual(h, 100)
|
||
|
|
d = {}
|
||
|
|
d['w'] = '0xf'
|
||
|
|
d['300'] = 423
|
||
|
|
d['e'] = '0b1101'
|
||
|
|
a = pack('int:100=300, bin=e, uint:12=300', **d)
|
||
|
|
x, y, z = a.unpack('int:100, bin, uint:12')
|
||
|
|
self.assertEqual(x, 423)
|
||
|
|
self.assertEqual(y, '1101')
|
||
|
|
self.assertEqual(z, 423)
|
||
|
|
|
||
|
|
def testPackWithDict2(self):
|
||
|
|
a = pack('int:5, bin:3=b, 0x3, bin=c, se=12', 10, b='0b111', c='0b1')
|
||
|
|
b = BitStream('int:5=10, 0b111, 0x3, 0b1, se=12')
|
||
|
|
self.assertEqual(a, b)
|
||
|
|
a = pack('bits:3=b', b=BitStream('0b101'))
|
||
|
|
self.assertEqual(a, '0b101')
|
||
|
|
a = pack('bits:24=b', b=BitStream('0x001122'))
|
||
|
|
self.assertEqual(a, '0x001122')
|
||
|
|
|
||
|
|
def testPackWithDict3(self):
|
||
|
|
s = pack('hex:4=e, hex:4=0xe, hex:4=e', e='f')
|
||
|
|
self.assertEqual(s, '0xfef')
|
||
|
|
s = pack('sep', sep='0b00')
|
||
|
|
self.assertEqual(s, '0b00')
|
||
|
|
|
||
|
|
def testPackWithDict4(self):
|
||
|
|
s = pack('hello', hello='0xf')
|
||
|
|
self.assertEqual(s, '0xf')
|
||
|
|
s = pack('x, y, x, y, x', x='0b10', y='uint:12=100')
|
||
|
|
t = BitStream('0b10, uint:12=100, 0b10, uint:12=100, 0b10')
|
||
|
|
self.assertEqual(s, t)
|
||
|
|
a = [1, 2, 3, 4, 5]
|
||
|
|
s = pack('int:8, div,' * 5, *a, **{'div': '0b1'})
|
||
|
|
t = BitStream('int:8=1, 0b1, int:8=2, 0b1, int:8=3, 0b1, int:8=4, 0b1, int:8=5, 0b1')
|
||
|
|
self.assertEqual(s, t)
|
||
|
|
|
||
|
|
def testPackWithLocals(self):
|
||
|
|
width = 352
|
||
|
|
height = 288
|
||
|
|
s = pack('uint:12=width, uint:12=height', **locals())
|
||
|
|
self.assertEqual(s, '0x160120')
|
||
|
|
|
||
|
|
def testPackWithLengthRestriction(self):
|
||
|
|
s = pack('bin:3', '0b000')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'bin:3', '0b0011')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'bin:3', '0b11')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'bin:3=0b0011')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'bin:3=0b11')
|
||
|
|
|
||
|
|
s = pack('hex:4', '0xf')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'hex:4', '0b111')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'hex:4', '0b11111')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'hex:8=0xf')
|
||
|
|
|
||
|
|
s = pack('oct:6', '0o77')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'oct:6', '0o1')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'oct:6', '0o111')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'oct:3', '0b1')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'oct:3=hello', hello='0o12')
|
||
|
|
|
||
|
|
s = pack('bits:3', BitStream('0b111'))
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'bits:3', BitStream('0b11'))
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'bits:3', BitStream('0b1111'))
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'bits:12=b', b=BitStream('0b11'))
|
||
|
|
|
||
|
|
def testPackNull(self):
|
||
|
|
s = pack('')
|
||
|
|
self.assertFalse(s)
|
||
|
|
s = pack(',')
|
||
|
|
self.assertFalse(s)
|
||
|
|
s = pack(',,,,,0b1,,,,,,,,,,,,,0b1,,,,,,,,,,')
|
||
|
|
self.assertEqual(s, '0b11')
|
||
|
|
s = pack(',,uint:12,,bin:3,', 100, '100')
|
||
|
|
a, b = s.unpack(',,,uint:12,,,,bin:3,,,')
|
||
|
|
self.assertEqual(a, 100)
|
||
|
|
self.assertEqual(b, '100')
|
||
|
|
|
||
|
|
def testPackDefaultUint(self):
|
||
|
|
s = pack('10, 5', 1, 2)
|
||
|
|
a, b = s.unpack('10, 5')
|
||
|
|
self.assertEqual((a, b), (1, 2))
|
||
|
|
s = pack('10=150, 12=qee', qee=3)
|
||
|
|
self.assertEqual(s, 'uint:10=150, uint:12=3')
|
||
|
|
t = BitStream('100=5')
|
||
|
|
self.assertEqual(t, 'uint:100=5')
|
||
|
|
|
||
|
|
def testPackDefualtUintErrors(self):
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, '5=-1')
|
||
|
|
|
||
|
|
def testPackingLongKeywordBitstring(self):
|
||
|
|
s = pack('bits=b', b=BitStream(128000))
|
||
|
|
self.assertEqual(s, BitStream(128000))
|
||
|
|
|
||
|
|
def testPackingWithListFormat(self):
|
||
|
|
f = ['bin', 'hex', 'uint:10']
|
||
|
|
a = pack(','.join(f), '00', '234', 100)
|
||
|
|
b = pack(f, '00', '234', 100)
|
||
|
|
self.assertEqual(a, b)
|
||
|
|
|
||
|
|
|
||
|
|
class Unpack(unittest.TestCase):
|
||
|
|
def testUnpack1(self):
|
||
|
|
s = BitStream('uint:13=23, hex=e, bin=010, int:41=-554, 0o44332, se=-12, ue=4')
|
||
|
|
s.pos = 11
|
||
|
|
a, b, c, d, e, f, g = s.unpack('uint:13, hex:4, bin:3, int:41, oct:15, se, ue')
|
||
|
|
self.assertEqual(a, 23)
|
||
|
|
self.assertEqual(b, 'e')
|
||
|
|
self.assertEqual(c, '010')
|
||
|
|
self.assertEqual(d, -554)
|
||
|
|
self.assertEqual(e, '44332')
|
||
|
|
self.assertEqual(f, -12)
|
||
|
|
self.assertEqual(g, 4)
|
||
|
|
self.assertEqual(s.pos, 11)
|
||
|
|
|
||
|
|
def testUnpack2(self):
|
||
|
|
s = BitStream('0xff, 0b000, uint:12=100')
|
||
|
|
a, b, c = s.unpack('bits:8, bits, uint:12')
|
||
|
|
self.assertEqual(type(s), BitStream)
|
||
|
|
self.assertEqual(a, '0xff')
|
||
|
|
self.assertEqual(type(s), BitStream)
|
||
|
|
self.assertEqual(b, '0b000')
|
||
|
|
self.assertEqual(c, 100)
|
||
|
|
a, b = s.unpack(['bits:11', 'uint'])
|
||
|
|
self.assertEqual(a, '0xff, 0b000')
|
||
|
|
self.assertEqual(b, 100)
|
||
|
|
|
||
|
|
def testUnpackNull(self):
|
||
|
|
s = pack('0b1, , , 0xf,')
|
||
|
|
a, b = s.unpack('bin:1,,,hex:4,')
|
||
|
|
self.assertEqual(a, '1')
|
||
|
|
self.assertEqual(b, 'f')
|
||
|
|
|
||
|
|
|
||
|
|
class FromFile(unittest.TestCase):
|
||
|
|
def testCreationFromFileOperations(self):
|
||
|
|
s = BitStream(filename='smalltestfile')
|
||
|
|
s.append('0xff')
|
||
|
|
self.assertEqual(s.hex, '0123456789abcdefff')
|
||
|
|
|
||
|
|
s = ConstBitStream(filename='smalltestfile')
|
||
|
|
t = BitStream('0xff') + s
|
||
|
|
self.assertEqual(t.hex, 'ff0123456789abcdef')
|
||
|
|
|
||
|
|
s = BitStream(filename='smalltestfile')
|
||
|
|
del s[:1]
|
||
|
|
self.assertEqual((BitStream('0b0') + s).hex, '0123456789abcdef')
|
||
|
|
|
||
|
|
s = BitStream(filename='smalltestfile')
|
||
|
|
del s[:7 * 8]
|
||
|
|
self.assertEqual(s.hex, 'ef')
|
||
|
|
|
||
|
|
s = BitStream(filename='smalltestfile')
|
||
|
|
s.insert('0xc', 4)
|
||
|
|
self.assertEqual(s.hex, '0c123456789abcdef')
|
||
|
|
|
||
|
|
s = BitStream(filename='smalltestfile')
|
||
|
|
s.prepend('0xf')
|
||
|
|
self.assertEqual(s.hex, 'f0123456789abcdef')
|
||
|
|
|
||
|
|
s = BitStream(filename='smalltestfile')
|
||
|
|
s.overwrite('0xaaa', 12)
|
||
|
|
self.assertEqual(s.hex, '012aaa6789abcdef')
|
||
|
|
|
||
|
|
s = BitStream(filename='smalltestfile')
|
||
|
|
s.reverse()
|
||
|
|
self.assertEqual(s.hex, 'f7b3d591e6a2c480')
|
||
|
|
|
||
|
|
s = BitStream(filename='smalltestfile')
|
||
|
|
del s[-60:]
|
||
|
|
self.assertEqual(s.hex, '0')
|
||
|
|
|
||
|
|
s = BitStream(filename='smalltestfile')
|
||
|
|
del s[:60]
|
||
|
|
self.assertEqual(s.hex, 'f')
|
||
|
|
|
||
|
|
def testFileProperties(self):
|
||
|
|
s = ConstBitStream(filename='smalltestfile')
|
||
|
|
self.assertEqual(s.hex, '0123456789abcdef')
|
||
|
|
self.assertEqual(s.uint, 81985529216486895)
|
||
|
|
self.assertEqual(s.int, 81985529216486895)
|
||
|
|
self.assertEqual(s.bin, '0000000100100011010001010110011110001001101010111100110111101111')
|
||
|
|
self.assertEqual(s[:-1].oct, '002215053170465363367')
|
||
|
|
s.bitpos = 0
|
||
|
|
self.assertEqual(s.read('se'), -72)
|
||
|
|
s.bitpos = 0
|
||
|
|
self.assertEqual(s.read('ue'), 144)
|
||
|
|
self.assertEqual(s.bytes, b'\x01\x23\x45\x67\x89\xab\xcd\xef')
|
||
|
|
self.assertEqual(s.tobytes(), b'\x01\x23\x45\x67\x89\xab\xcd\xef')
|
||
|
|
|
||
|
|
def testCreationFromFileWithLength(self):
|
||
|
|
s = ConstBitStream(filename='test.m1v', length=32)
|
||
|
|
self.assertEqual(s.length, 32)
|
||
|
|
self.assertEqual(s.hex, '000001b3')
|
||
|
|
s = ConstBitStream(filename='test.m1v', length=0)
|
||
|
|
self.assertFalse(s)
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, filename='smalltestfile', length=65)
|
||
|
|
self.assertRaises(bitstring.CreationError, ConstBitStream, filename='smalltestfile', length=64, offset=1)
|
||
|
|
# self.assertRaises(bitstring.CreationError, ConstBitStream, filename='smalltestfile', offset=65)
|
||
|
|
f = open('smalltestfile', 'rb')
|
||
|
|
# self.assertRaises(bitstring.CreationError, ConstBitStream, auto=f, offset=65)
|
||
|
|
self.assertRaises(bitstring.CreationError, ConstBitStream, auto=f, length=65)
|
||
|
|
self.assertRaises(bitstring.CreationError, ConstBitStream, auto=f, offset=60, length=5)
|
||
|
|
|
||
|
|
def testCreationFromFileWithOffset(self):
|
||
|
|
a = BitStream(filename='test.m1v', offset=4)
|
||
|
|
self.assertEqual(a.peek(4 * 8).hex, '00001b31')
|
||
|
|
b = BitStream(filename='test.m1v', offset=28)
|
||
|
|
self.assertEqual(b.peek(8).hex, '31')
|
||
|
|
|
||
|
|
def testFileSlices(self):
|
||
|
|
s = BitStream(filename='smalltestfile')
|
||
|
|
self.assertEqual(s[-16:].hex, 'cdef')
|
||
|
|
|
||
|
|
def testCreataionFromFileErrors(self):
|
||
|
|
self.assertRaises(IOError, BitStream, filename='Idonotexist')
|
||
|
|
|
||
|
|
def testFindInFile(self):
|
||
|
|
s = BitStream(filename='test.m1v')
|
||
|
|
self.assertTrue(s.find('0x160120'))
|
||
|
|
self.assertEqual(s.bytepos, 4)
|
||
|
|
s3 = s.read(3 * 8)
|
||
|
|
self.assertEqual(s3.hex, '160120')
|
||
|
|
s.bytepos = 0
|
||
|
|
self.assertTrue(s._pos == 0)
|
||
|
|
self.assertTrue(s.find('0x0001b2'))
|
||
|
|
self.assertEqual(s.bytepos, 13)
|
||
|
|
|
||
|
|
def testHexFromFile(self):
|
||
|
|
s = BitStream(filename='test.m1v')
|
||
|
|
self.assertEqual(s[0:32].hex, '000001b3')
|
||
|
|
self.assertEqual(s[-32:].hex, '000001b7')
|
||
|
|
s.hex = '0x11'
|
||
|
|
self.assertEqual(s.hex, '11')
|
||
|
|
|
||
|
|
def testFileOperations(self):
|
||
|
|
s1 = BitStream(filename='test.m1v')
|
||
|
|
s2 = BitStream(filename='test.m1v')
|
||
|
|
self.assertEqual(s1.read(32).hex, '000001b3')
|
||
|
|
self.assertEqual(s2.read(32).hex, '000001b3')
|
||
|
|
s1.bytepos += 4
|
||
|
|
self.assertEqual(s1.read(8).hex, '02')
|
||
|
|
self.assertEqual(s2.read(5 * 8).hex, '1601208302')
|
||
|
|
s1.pos = s1.len
|
||
|
|
try:
|
||
|
|
s1.pos += 1
|
||
|
|
self.assertTrue(False)
|
||
|
|
except ValueError:
|
||
|
|
pass
|
||
|
|
|
||
|
|
def testFileBitGetting(self):
|
||
|
|
s = ConstBitStream(filename='smalltestfile', offset=16, length=8) # 0x45
|
||
|
|
b = s[1]
|
||
|
|
self.assertTrue(b)
|
||
|
|
b = s.any(0, [-1, -2, -3])
|
||
|
|
self.assertTrue(b)
|
||
|
|
b = s.all(0, [0, 1, 2])
|
||
|
|
self.assertFalse(b)
|
||
|
|
|
||
|
|
def testVeryLargeFiles(self):
|
||
|
|
# This uses an 11GB file which isn't distributed for obvious reasons
|
||
|
|
# and so this test won't work for anyone except me!
|
||
|
|
try:
|
||
|
|
s = ConstBitStream(filename='11GB.mkv')
|
||
|
|
except IOError:
|
||
|
|
return
|
||
|
|
self.assertEqual(s.len, 11743020505 * 8)
|
||
|
|
self.assertEqual(s[1000000000:1000000100].hex, 'bdef7335d4545f680d669ce24')
|
||
|
|
self.assertEqual(s[-4::8].hex, 'bbebf7a1')
|
||
|
|
|
||
|
|
|
||
|
|
class CreationErrors(unittest.TestCase):
|
||
|
|
def testIncorrectBinAssignment(self):
|
||
|
|
s = BitStream()
|
||
|
|
self.assertRaises(bitstring.CreationError, s._setbin_safe, '0010020')
|
||
|
|
|
||
|
|
def testIncorrectHexAssignment(self):
|
||
|
|
s = BitStream()
|
||
|
|
self.assertRaises(bitstring.CreationError, s._sethex, '0xabcdefg')
|
||
|
|
|
||
|
|
|
||
|
|
class Length(unittest.TestCase):
|
||
|
|
def testLengthZero(self):
|
||
|
|
self.assertEqual(BitStream('').len, 0)
|
||
|
|
|
||
|
|
def testLength(self):
|
||
|
|
self.assertEqual(BitStream('0x80').len, 8)
|
||
|
|
|
||
|
|
def testLengthErrors(self):
|
||
|
|
#TODO: Lots of new checks, for various inits which now disallow length and offset
|
||
|
|
pass
|
||
|
|
#self.assertRaises(ValueError, BitStream, bin='111', length=-1)
|
||
|
|
#self.assertRaises(ValueError, BitStream, bin='111', length=4)
|
||
|
|
|
||
|
|
def testOffsetLengthError(self):
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, hex='0xffff', offset=-1)
|
||
|
|
|
||
|
|
|
||
|
|
class SimpleConversions(unittest.TestCase):
|
||
|
|
def testConvertToUint(self):
|
||
|
|
self.assertEqual(BitStream('0x10').uint, 16)
|
||
|
|
self.assertEqual(BitStream('0b000111').uint, 7)
|
||
|
|
|
||
|
|
def testConvertToInt(self):
|
||
|
|
self.assertEqual(BitStream('0x10').int, 16)
|
||
|
|
self.assertEqual(BitStream('0b11110').int, -2)
|
||
|
|
|
||
|
|
def testConvertToHex(self):
|
||
|
|
self.assertEqual(BitStream(bytes=b'\x00\x12\x23\xff').hex, '001223ff')
|
||
|
|
s = BitStream('0b11111')
|
||
|
|
self.assertRaises(bitstring.InterpretError, s._gethex)
|
||
|
|
|
||
|
|
|
||
|
|
class Empty(unittest.TestCase):
|
||
|
|
def testEmptyBitstring(self):
|
||
|
|
s = BitStream()
|
||
|
|
self.assertRaises(bitstring.ReadError, s.read, 1)
|
||
|
|
self.assertEqual(s.bin, '')
|
||
|
|
self.assertEqual(s.hex, '')
|
||
|
|
self.assertRaises(bitstring.InterpretError, s._getint)
|
||
|
|
self.assertRaises(bitstring.InterpretError, s._getuint)
|
||
|
|
self.assertFalse(s)
|
||
|
|
|
||
|
|
def testNonEmptyBitStream(self):
|
||
|
|
s = BitStream(bin='0')
|
||
|
|
self.assertFalse(not s.len)
|
||
|
|
|
||
|
|
|
||
|
|
class Position(unittest.TestCase):
|
||
|
|
def testBitPosition(self):
|
||
|
|
s = BitStream(bytes=b'\x00\x00\x00')
|
||
|
|
self.assertEqual(s.bitpos, 0)
|
||
|
|
s.read(5)
|
||
|
|
self.assertEqual(s.pos, 5)
|
||
|
|
s.pos = s.len
|
||
|
|
self.assertRaises(bitstring.ReadError, s.read, 1)
|
||
|
|
|
||
|
|
def testBytePosition(self):
|
||
|
|
s = BitStream(bytes=b'\x00\x00\x00')
|
||
|
|
self.assertEqual(s.bytepos, 0)
|
||
|
|
s.read(10)
|
||
|
|
self.assertRaises(bitstring.ByteAlignError, s._getbytepos)
|
||
|
|
s.read(6)
|
||
|
|
self.assertEqual(s.bytepos, 2)
|
||
|
|
|
||
|
|
def testSeekToBit(self):
|
||
|
|
s = BitStream(bytes=b'\x00\x00\x00\x00\x00\x00')
|
||
|
|
s.bitpos = 0
|
||
|
|
self.assertEqual(s.bitpos, 0)
|
||
|
|
self.assertRaises(ValueError, s._setbitpos, -1)
|
||
|
|
self.assertRaises(ValueError, s._setbitpos, 6 * 8 + 1)
|
||
|
|
s.bitpos = 6 * 8
|
||
|
|
self.assertEqual(s.bitpos, 6 * 8)
|
||
|
|
|
||
|
|
def testSeekToByte(self):
|
||
|
|
s = BitStream(bytes=b'\x00\x00\x00\x00\x00\xab')
|
||
|
|
s.bytepos = 5
|
||
|
|
self.assertEqual(s.read(8).hex, 'ab')
|
||
|
|
|
||
|
|
def testAdvanceBitsAndBytes(self):
|
||
|
|
s = BitStream(bytes=b'\x00\x00\x00\x00\x00\x00\x00\x00')
|
||
|
|
s.pos += 5
|
||
|
|
self.assertEqual(s.pos, 5)
|
||
|
|
s.bitpos += 16
|
||
|
|
self.assertEqual(s.pos, 2 * 8 + 5)
|
||
|
|
s.pos -= 8
|
||
|
|
self.assertEqual(s.pos, 8 + 5)
|
||
|
|
|
||
|
|
def testRetreatBitsAndBytes(self):
|
||
|
|
a = BitStream(length=100)
|
||
|
|
a.pos = 80
|
||
|
|
a.bytepos -= 5
|
||
|
|
self.assertEqual(a.bytepos, 5)
|
||
|
|
a.pos -= 5
|
||
|
|
self.assertEqual(a.pos, 35)
|
||
|
|
|
||
|
|
|
||
|
|
class Offset(unittest.TestCase):
|
||
|
|
def testOffset1(self):
|
||
|
|
s = BitStream(bytes=b'\x00\x1b\x3f', offset=4)
|
||
|
|
self.assertEqual(s.read(8).bin, '00000001')
|
||
|
|
self.assertEqual(s.length, 20)
|
||
|
|
|
||
|
|
def testOffset2(self):
|
||
|
|
s1 = BitStream(bytes=b'\xf1\x02\x04')
|
||
|
|
s2 = BitStream(bytes=b'\xf1\x02\x04', length=23)
|
||
|
|
for i in [1, 2, 3, 4, 5, 6, 7, 6, 5, 4, 3, 2, 1, 0, 7, 3, 5, 1, 4]:
|
||
|
|
s1._datastore = offsetcopy(s1._datastore, i)
|
||
|
|
self.assertEqual(s1.hex, 'f10204')
|
||
|
|
s2._datastore = offsetcopy(s2._datastore, i)
|
||
|
|
self.assertEqual(s2.bin, '11110001000000100000010')
|
||
|
|
|
||
|
|
|
||
|
|
class Append(unittest.TestCase):
|
||
|
|
def testAppend(self):
|
||
|
|
s1 = BitStream('0b00000')
|
||
|
|
s1.append(BitStream(bool=True))
|
||
|
|
self.assertEqual(s1.bin, '000001')
|
||
|
|
self.assertEqual((BitStream('0x0102') + BitStream('0x0304')).hex, '01020304')
|
||
|
|
|
||
|
|
def testAppendSameBitstring(self):
|
||
|
|
s1 = BitStream('0xf0')[:6]
|
||
|
|
s1.append(s1)
|
||
|
|
self.assertEqual(s1.bin, '111100111100')
|
||
|
|
|
||
|
|
def testAppendWithOffset(self):
|
||
|
|
s = BitStream(bytes=b'\x28\x28', offset=1)
|
||
|
|
s.append('0b0')
|
||
|
|
self.assertEqual(s.hex, '5050')
|
||
|
|
|
||
|
|
|
||
|
|
class ByteAlign(unittest.TestCase):
|
||
|
|
def testByteAlign(self):
|
||
|
|
s = BitStream(hex='0001ff23')
|
||
|
|
s.bytealign()
|
||
|
|
self.assertEqual(s.bytepos, 0)
|
||
|
|
s.pos += 11
|
||
|
|
s.bytealign()
|
||
|
|
self.assertEqual(s.bytepos, 2)
|
||
|
|
s.pos -= 10
|
||
|
|
s.bytealign()
|
||
|
|
self.assertEqual(s.bytepos, 1)
|
||
|
|
|
||
|
|
def testByteAlignWithOffset(self):
|
||
|
|
s = BitStream(hex='0112233')
|
||
|
|
s._datastore = offsetcopy(s._datastore, 3)
|
||
|
|
bitstoalign = s.bytealign()
|
||
|
|
self.assertEqual(bitstoalign, 0)
|
||
|
|
self.assertEqual(s.read(5).bin, '00001')
|
||
|
|
|
||
|
|
def testInsertByteAligned(self):
|
||
|
|
s = BitStream('0x0011')
|
||
|
|
s.insert(BitStream('0x22'), 8)
|
||
|
|
self.assertEqual(s.hex, '002211')
|
||
|
|
s = BitStream(0)
|
||
|
|
s.insert(BitStream(bin='101'), 0)
|
||
|
|
self.assertEqual(s.bin, '101')
|
||
|
|
|
||
|
|
|
||
|
|
class Truncate(unittest.TestCase):
|
||
|
|
def testTruncateStart(self):
|
||
|
|
s = BitStream('0b1')
|
||
|
|
del s[:1]
|
||
|
|
self.assertFalse(s)
|
||
|
|
s = BitStream(hex='1234')
|
||
|
|
self.assertEqual(s.hex, '1234')
|
||
|
|
del s[:4]
|
||
|
|
self.assertEqual(s.hex, '234')
|
||
|
|
del s[:9]
|
||
|
|
self.assertEqual(s.bin, '100')
|
||
|
|
del s[:2]
|
||
|
|
self.assertEqual(s.bin, '0')
|
||
|
|
self.assertEqual(s.len, 1)
|
||
|
|
del s[:1]
|
||
|
|
self.assertFalse(s)
|
||
|
|
|
||
|
|
def testTruncateEnd(self):
|
||
|
|
s = BitStream('0b1')
|
||
|
|
del s[-1:]
|
||
|
|
self.assertFalse(s)
|
||
|
|
s = BitStream(bytes=b'\x12\x34')
|
||
|
|
self.assertEqual(s.hex, '1234')
|
||
|
|
del s[-4:]
|
||
|
|
self.assertEqual(s.hex, '123')
|
||
|
|
del s[-9:]
|
||
|
|
self.assertEqual(s.bin, '000')
|
||
|
|
del s[-3:]
|
||
|
|
self.assertFalse(s)
|
||
|
|
s = BitStream('0b001')
|
||
|
|
del s[:2]
|
||
|
|
del s[-1:]
|
||
|
|
self.assertFalse(s)
|
||
|
|
|
||
|
|
|
||
|
|
class Slice(unittest.TestCase):
|
||
|
|
def testByteAlignedSlice(self):
|
||
|
|
s = BitStream(hex='0x123456')
|
||
|
|
self.assertEqual(s[8:16].hex, '34')
|
||
|
|
s = s[8:24]
|
||
|
|
self.assertEqual(s.len, 16)
|
||
|
|
self.assertEqual(s.hex, '3456')
|
||
|
|
s = s[0:8]
|
||
|
|
self.assertEqual(s.hex, '34')
|
||
|
|
s.hex = '0x123456'
|
||
|
|
self.assertEqual(s[8:24][0:8].hex, '34')
|
||
|
|
|
||
|
|
def testSlice(self):
|
||
|
|
s = BitStream(bin='000001111100000')
|
||
|
|
s1 = s[0:5]
|
||
|
|
s2 = s[5:10]
|
||
|
|
s3 = s[10:15]
|
||
|
|
self.assertEqual(s1.bin, '00000')
|
||
|
|
self.assertEqual(s2.bin, '11111')
|
||
|
|
self.assertEqual(s3.bin, '00000')
|
||
|
|
|
||
|
|
|
||
|
|
class Insert(unittest.TestCase):
|
||
|
|
def testInsert(self):
|
||
|
|
s1 = BitStream(hex='0x123456')
|
||
|
|
s2 = BitStream(hex='0xff')
|
||
|
|
s1.bytepos = 1
|
||
|
|
s1.insert(s2)
|
||
|
|
self.assertEqual(s1.bytepos, 2)
|
||
|
|
self.assertEqual(s1.hex, '12ff3456')
|
||
|
|
s1.insert('0xee', 24)
|
||
|
|
self.assertEqual(s1.hex, '12ff34ee56')
|
||
|
|
self.assertEqual(s1.bitpos, 32)
|
||
|
|
self.assertRaises(ValueError, s1.insert, '0b1', -1000)
|
||
|
|
self.assertRaises(ValueError, s1.insert, '0b1', 1000)
|
||
|
|
|
||
|
|
def testInsertNull(self):
|
||
|
|
s = BitStream(hex='0x123').insert(BitStream(), 3)
|
||
|
|
self.assertEqual(s.hex, '123')
|
||
|
|
|
||
|
|
def testInsertBits(self):
|
||
|
|
one = BitStream(bin='1')
|
||
|
|
zero = BitStream(bin='0')
|
||
|
|
s = BitStream(bin='00')
|
||
|
|
s.insert(one, 0)
|
||
|
|
self.assertEqual(s.bin, '100')
|
||
|
|
s.insert(zero, 0)
|
||
|
|
self.assertEqual(s.bin, '0100')
|
||
|
|
s.insert(one, s.len)
|
||
|
|
self.assertEqual(s.bin, '01001')
|
||
|
|
s.insert(s, 2)
|
||
|
|
self.assertEqual(s.bin, '0101001001')
|
||
|
|
|
||
|
|
|
||
|
|
class Resetting(unittest.TestCase):
|
||
|
|
def testSetHex(self):
|
||
|
|
s = BitStream()
|
||
|
|
s.hex = '0'
|
||
|
|
self.assertEqual(s.hex, '0')
|
||
|
|
s.hex = '0x010203045'
|
||
|
|
self.assertEqual(s.hex, '010203045')
|
||
|
|
self.assertRaises(bitstring.CreationError, s._sethex, '0x002g')
|
||
|
|
|
||
|
|
def testSetBin(self):
|
||
|
|
s = BitStream(bin="000101101")
|
||
|
|
self.assertEqual(s.bin, '000101101')
|
||
|
|
self.assertEqual(s.len, 9)
|
||
|
|
s.bin = '0'
|
||
|
|
self.assertEqual(s.bin, '0')
|
||
|
|
self.assertEqual(s.len, 1)
|
||
|
|
|
||
|
|
def testSetEmptyBin(self):
|
||
|
|
s = BitStream(hex='0x000001b3')
|
||
|
|
s.bin = ''
|
||
|
|
self.assertEqual(s.len, 0)
|
||
|
|
self.assertEqual(s.bin, '')
|
||
|
|
|
||
|
|
def testSetInvalidBin(self):
|
||
|
|
s = BitStream()
|
||
|
|
self.assertRaises(bitstring.CreationError, s._setbin_safe, '00102')
|
||
|
|
|
||
|
|
|
||
|
|
class Overwriting(unittest.TestCase):
|
||
|
|
def testOverwriteBit(self):
|
||
|
|
s = BitStream(bin='0')
|
||
|
|
s.overwrite(BitStream(bin='1'), 0)
|
||
|
|
self.assertEqual(s.bin, '1')
|
||
|
|
|
||
|
|
def testOverwriteLimits(self):
|
||
|
|
s = BitStream(bin='0b11111')
|
||
|
|
s.overwrite(BitStream(bin='000'), 0)
|
||
|
|
self.assertEqual(s.bin, '00011')
|
||
|
|
s.overwrite('0b000', 2)
|
||
|
|
self.assertEqual(s.bin, '00000')
|
||
|
|
|
||
|
|
def testOverwriteNull(self):
|
||
|
|
s = BitStream(hex='342563fedec')
|
||
|
|
s2 = BitStream(s)
|
||
|
|
s.overwrite(BitStream(bin=''), 23)
|
||
|
|
self.assertEqual(s.bin, s2.bin)
|
||
|
|
|
||
|
|
def testOverwritePosition(self):
|
||
|
|
s1 = BitStream(hex='0123456')
|
||
|
|
s2 = BitStream(hex='ff')
|
||
|
|
s1.bytepos = 1
|
||
|
|
s1.overwrite(s2)
|
||
|
|
self.assertEqual((s1.hex, s1.bytepos), ('01ff456', 2))
|
||
|
|
s1.overwrite('0xff', 0)
|
||
|
|
self.assertEqual((s1.hex, s1.bytepos), ('ffff456', 1))
|
||
|
|
|
||
|
|
def testOverwriteWithSelf(self):
|
||
|
|
s = BitStream('0x123')
|
||
|
|
s.overwrite(s)
|
||
|
|
self.assertEqual(s, '0x123')
|
||
|
|
|
||
|
|
|
||
|
|
class Split(unittest.TestCase):
|
||
|
|
def testSplitByteAlignedCornerCases(self):
|
||
|
|
s = BitStream()
|
||
|
|
bsl = s.split(BitStream(hex='0xff'))
|
||
|
|
self.assertEqual(next(bsl).hex, '')
|
||
|
|
self.assertRaises(StopIteration, next, bsl)
|
||
|
|
s = BitStream(hex='aabbcceeddff')
|
||
|
|
delimiter = BitStream()
|
||
|
|
bsl = s.split(delimiter)
|
||
|
|
self.assertRaises(ValueError, next, bsl)
|
||
|
|
delimiter = BitStream(hex='11')
|
||
|
|
bsl = s.split(delimiter)
|
||
|
|
self.assertEqual(next(bsl).hex, s.hex)
|
||
|
|
|
||
|
|
def testSplitByteAligned(self):
|
||
|
|
s = BitStream(hex='0x1234aa1234bbcc1234ffff')
|
||
|
|
delimiter = BitStream(hex='1234')
|
||
|
|
bsl = s.split(delimiter)
|
||
|
|
self.assertEqual([b.hex for b in bsl], ['', '1234aa', '1234bbcc', '1234ffff'])
|
||
|
|
self.assertEqual(s.pos, 0)
|
||
|
|
|
||
|
|
def testSplitByteAlignedWithIntialBytes(self):
|
||
|
|
s = BitStream(hex='aa471234fedc43 47112233 47 4723 472314')
|
||
|
|
delimiter = BitStream(hex='47')
|
||
|
|
s.find(delimiter)
|
||
|
|
self.assertEqual(s.bytepos, 1)
|
||
|
|
bsl = s.split(delimiter, start=0)
|
||
|
|
self.assertEqual([b.hex for b in bsl], ['aa', '471234fedc43', '47112233',
|
||
|
|
'47', '4723', '472314'])
|
||
|
|
self.assertEqual(s.bytepos, 1)
|
||
|
|
|
||
|
|
def testSplitByteAlignedWithOverlappingDelimiter(self):
|
||
|
|
s = BitStream(hex='aaffaaffaaffaaffaaff')
|
||
|
|
bsl = s.split(BitStream(hex='aaffaa'))
|
||
|
|
self.assertEqual([b.hex for b in bsl], ['', 'aaffaaff', 'aaffaaffaaff'])
|
||
|
|
|
||
|
|
|
||
|
|
class Adding(unittest.TestCase):
|
||
|
|
def testAdding(self):
|
||
|
|
s1 = BitStream(hex='0x0102')
|
||
|
|
s2 = BitStream(hex='0x0304')
|
||
|
|
s3 = s1 + s2
|
||
|
|
self.assertEqual(s1.hex, '0102')
|
||
|
|
self.assertEqual(s2.hex, '0304')
|
||
|
|
self.assertEqual(s3.hex, '01020304')
|
||
|
|
s3 += s1
|
||
|
|
self.assertEqual(s3.hex, '010203040102')
|
||
|
|
self.assertEqual(s2[9:16].bin, '0000100')
|
||
|
|
self.assertEqual(s1[0:9].bin, '000000010')
|
||
|
|
s4 = BitStream(bin='000000010') +\
|
||
|
|
BitStream(bin='0000100')
|
||
|
|
self.assertEqual(s4.bin, '0000000100000100')
|
||
|
|
s2p = s2[9:16]
|
||
|
|
s1p = s1[0:9]
|
||
|
|
s5p = s1p + s2p
|
||
|
|
s5 = s1[0:9] + s2[9:16]
|
||
|
|
self.assertEqual(s5.bin, '0000000100000100')
|
||
|
|
|
||
|
|
def testMoreAdding(self):
|
||
|
|
s = BitStream(bin='00') + BitStream(bin='') + BitStream(bin='11')
|
||
|
|
self.assertEqual(s.bin, '0011')
|
||
|
|
s = '0b01'
|
||
|
|
s += BitStream('0b11')
|
||
|
|
self.assertEqual(s.bin, '0111')
|
||
|
|
s = BitStream('0x00')
|
||
|
|
t = BitStream('0x11')
|
||
|
|
s += t
|
||
|
|
self.assertEqual(s.hex, '0011')
|
||
|
|
self.assertEqual(t.hex, '11')
|
||
|
|
s += s
|
||
|
|
self.assertEqual(s.hex, '00110011')
|
||
|
|
|
||
|
|
def testRadd(self):
|
||
|
|
s = '0xff' + BitStream('0xee')
|
||
|
|
self.assertEqual(s.hex, 'ffee')
|
||
|
|
|
||
|
|
|
||
|
|
def testTruncateAsserts(self):
|
||
|
|
s = BitStream('0x001122')
|
||
|
|
s.bytepos = 2
|
||
|
|
del s[-s.len:]
|
||
|
|
self.assertEqual(s.bytepos, 0)
|
||
|
|
s.append('0x00')
|
||
|
|
s.append('0x1122')
|
||
|
|
s.bytepos = 2
|
||
|
|
del s[:s.len]
|
||
|
|
self.assertEqual(s.bytepos, 0)
|
||
|
|
s.append('0x00')
|
||
|
|
|
||
|
|
def testOverwriteErrors(self):
|
||
|
|
s = BitStream(bin='11111')
|
||
|
|
self.assertRaises(ValueError, s.overwrite, BitStream(bin='1'), -10)
|
||
|
|
self.assertRaises(ValueError, s.overwrite, BitStream(bin='1'), 6)
|
||
|
|
self.assertRaises(ValueError, s.overwrite, BitStream(bin='11111'), 1)
|
||
|
|
|
||
|
|
def testDeleteBits(self):
|
||
|
|
s = BitStream(bin='000111100000')
|
||
|
|
s.bitpos = 4
|
||
|
|
del s[4:8]
|
||
|
|
self.assertEqual(s.bin, '00010000')
|
||
|
|
del s[4:1004]
|
||
|
|
self.assertTrue(s.bin, '0001')
|
||
|
|
|
||
|
|
def testDeleteBitsWithPosition(self):
|
||
|
|
s = BitStream(bin='000111100000')
|
||
|
|
del s[4:8]
|
||
|
|
self.assertEqual(s.bin, '00010000')
|
||
|
|
|
||
|
|
def testDeleteBytes(self):
|
||
|
|
s = BitStream('0x00112233')
|
||
|
|
del s[8:8]
|
||
|
|
self.assertEqual(s.hex, '00112233')
|
||
|
|
self.assertEqual(s.pos, 0)
|
||
|
|
del s[8:16]
|
||
|
|
self.assertEqual(s.hex, '002233')
|
||
|
|
self.assertEqual(s.bytepos, 0)
|
||
|
|
del s[:24]
|
||
|
|
self.assertFalse(s)
|
||
|
|
self.assertEqual(s.pos, 0)
|
||
|
|
|
||
|
|
def testGetItemWithPositivePosition(self):
|
||
|
|
s = BitStream(bin='0b1011')
|
||
|
|
self.assertEqual(s[0], True)
|
||
|
|
self.assertEqual(s[1], False)
|
||
|
|
self.assertEqual(s[2], True)
|
||
|
|
self.assertEqual(s[3], True)
|
||
|
|
self.assertRaises(IndexError, s.__getitem__, 4)
|
||
|
|
|
||
|
|
def testGetItemWithNegativePosition(self):
|
||
|
|
s = BitStream(bin='1011')
|
||
|
|
self.assertEqual(s[-1], True)
|
||
|
|
self.assertEqual(s[-2], True)
|
||
|
|
self.assertEqual(s[-3], False)
|
||
|
|
self.assertEqual(s[-4], True)
|
||
|
|
self.assertRaises(IndexError, s.__getitem__, -5)
|
||
|
|
|
||
|
|
def testSlicing(self):
|
||
|
|
s = ConstBitStream(hex='0123456789')
|
||
|
|
self.assertEqual(s[0:8].hex, '01')
|
||
|
|
self.assertFalse(s[0:0])
|
||
|
|
self.assertFalse(s[23:20])
|
||
|
|
self.assertEqual(s[8:12].bin, '0010')
|
||
|
|
self.assertEqual(s[32:80], '0x89')
|
||
|
|
|
||
|
|
def testNegativeSlicing(self):
|
||
|
|
s = ConstBitStream(hex='012345678')
|
||
|
|
self.assertEqual(s[:-8].hex, '0123456')
|
||
|
|
self.assertEqual(s[-16:-8].hex, '56')
|
||
|
|
self.assertEqual(s[-24:].hex, '345678')
|
||
|
|
self.assertEqual(s[-1000:-24], '0x012')
|
||
|
|
|
||
|
|
def testLen(self):
|
||
|
|
s = BitStream()
|
||
|
|
self.assertEqual(len(s), 0)
|
||
|
|
s.append(BitStream(bin='001'))
|
||
|
|
self.assertEqual(len(s), 3)
|
||
|
|
|
||
|
|
def testJoin(self):
|
||
|
|
s1 = BitStream(bin='0')
|
||
|
|
s2 = BitStream(bin='1')
|
||
|
|
s3 = BitStream(bin='000')
|
||
|
|
s4 = BitStream(bin='111')
|
||
|
|
strings = [s1, s2, s1, s3, s4]
|
||
|
|
s = BitStream().join(strings)
|
||
|
|
self.assertEqual(s.bin, '010000111')
|
||
|
|
|
||
|
|
def testJoin2(self):
|
||
|
|
s1 = BitStream(hex='00112233445566778899aabbccddeeff')
|
||
|
|
s2 = BitStream(bin='0b000011')
|
||
|
|
bsl = [s1[0:32], s1[4:12], s2, s2, s2, s2]
|
||
|
|
s = ConstBitStream().join(bsl)
|
||
|
|
self.assertEqual(s.hex, '00112233010c30c3')
|
||
|
|
|
||
|
|
bsl = [BitStream(uint=j, length=12) for j in range(10) for i in range(10)]
|
||
|
|
s = BitStream().join(bsl)
|
||
|
|
self.assertEqual(s.length, 1200)
|
||
|
|
|
||
|
|
|
||
|
|
def testPos(self):
|
||
|
|
s = BitStream(bin='1')
|
||
|
|
self.assertEqual(s.bitpos, 0)
|
||
|
|
s.read(1)
|
||
|
|
self.assertEqual(s.bitpos, 1)
|
||
|
|
|
||
|
|
def testWritingData(self):
|
||
|
|
strings = [BitStream(bin=x) for x in ['0', '001', '0011010010', '010010', '1011']]
|
||
|
|
s = BitStream().join(strings)
|
||
|
|
s2 = BitStream(bytes=s.bytes)
|
||
|
|
self.assertEqual(s2.bin, '000100110100100100101011')
|
||
|
|
s2.append(BitStream(bin='1'))
|
||
|
|
s3 = BitStream(bytes=s2.tobytes())
|
||
|
|
self.assertEqual(s3.bin, '00010011010010010010101110000000')
|
||
|
|
|
||
|
|
def testWritingDataWithOffsets(self):
|
||
|
|
s1 = BitStream(bytes=b'\x10')
|
||
|
|
s2 = BitStream(bytes=b'\x08\x00', length=8, offset=1)
|
||
|
|
s3 = BitStream(bytes=b'\x04\x00', length=8, offset=2)
|
||
|
|
self.assertTrue(s1 == s2)
|
||
|
|
self.assertTrue(s2 == s3)
|
||
|
|
self.assertTrue(s1.bytes == s2.bytes)
|
||
|
|
self.assertTrue(s2.bytes == s3.bytes)
|
||
|
|
|
||
|
|
def testVariousThings1(self):
|
||
|
|
hexes = ['12345678', '87654321', 'ffffffffff', 'ed', '12ec']
|
||
|
|
bins = ['001010', '1101011', '0010000100101110110110', '11', '011']
|
||
|
|
bsl = []
|
||
|
|
for (hex, bin) in list(zip(hexes, bins)) * 5:
|
||
|
|
bsl.append(BitStream(hex=hex))
|
||
|
|
bsl.append(BitStream(bin=bin))
|
||
|
|
s = BitStream().join(bsl)
|
||
|
|
for (hex, bin) in list(zip(hexes, bins)) * 5:
|
||
|
|
h = s.read(4 * len(hex))
|
||
|
|
b = s.read(len(bin))
|
||
|
|
self.assertEqual(h.hex, hex)
|
||
|
|
self.assertEqual(b.bin, bin)
|
||
|
|
|
||
|
|
def testVariousThings2(self):
|
||
|
|
s1 = BitStream(hex="0x1f08")[:13]
|
||
|
|
self.assertEqual(s1.bin, '0001111100001')
|
||
|
|
s2 = BitStream(bin='0101')
|
||
|
|
self.assertEqual(s2.bin, '0101')
|
||
|
|
s1.append(s2)
|
||
|
|
self.assertEqual(s1.length, 17)
|
||
|
|
self.assertEqual(s1.bin, '00011111000010101')
|
||
|
|
s1 = s1[3:8]
|
||
|
|
self.assertEqual(s1.bin, '11111')
|
||
|
|
|
||
|
|
def testVariousThings3(self):
|
||
|
|
s1 = BitStream(hex='0x012480ff')[2:27]
|
||
|
|
s2 = s1 + s1
|
||
|
|
self.assertEqual(s2.length, 50)
|
||
|
|
s3 = s2[0:25]
|
||
|
|
s4 = s2[25:50]
|
||
|
|
self.assertEqual(s3.bin, s4.bin)
|
||
|
|
|
||
|
|
def testPeekBit(self):
|
||
|
|
s = BitStream(bin='01')
|
||
|
|
self.assertEqual(s.peek(1), [0])
|
||
|
|
self.assertEqual(s.peek(1), [0])
|
||
|
|
self.assertEqual(s.read(1), [0])
|
||
|
|
self.assertEqual(s.peek(1), [1])
|
||
|
|
self.assertEqual(s.peek(1), [1])
|
||
|
|
|
||
|
|
s = BitStream(bytes=b'\x1f', offset=3)
|
||
|
|
self.assertEqual(s.len, 5)
|
||
|
|
self.assertEqual(s.peek(5).bin, '11111')
|
||
|
|
self.assertEqual(s.peek(5).bin, '11111')
|
||
|
|
s.pos += 1
|
||
|
|
self.assertRaises(bitstring.ReadError, s.peek, 5)
|
||
|
|
|
||
|
|
s = BitStream(hex='001122334455')
|
||
|
|
self.assertEqual(s.peek(8).hex, '00')
|
||
|
|
self.assertEqual(s.read(8).hex, '00')
|
||
|
|
s.pos += 33
|
||
|
|
self.assertRaises(bitstring.ReadError, s.peek, 8)
|
||
|
|
|
||
|
|
s = BitStream(hex='001122334455')
|
||
|
|
self.assertEqual(s.peek(8 * 2).hex, '0011')
|
||
|
|
self.assertEqual(s.read(8 * 3).hex, '001122')
|
||
|
|
self.assertEqual(s.peek(8 * 3).hex, '334455')
|
||
|
|
self.assertRaises(bitstring.ReadError, s.peek, 25)
|
||
|
|
|
||
|
|
def testAdvanceBit(self):
|
||
|
|
s = BitStream(hex='0xff')
|
||
|
|
s.bitpos = 6
|
||
|
|
s.pos += 1
|
||
|
|
self.assertEqual(s.bitpos, 7)
|
||
|
|
s.bitpos += 1
|
||
|
|
try:
|
||
|
|
s.pos += 1
|
||
|
|
self.assertTrue(False)
|
||
|
|
except ValueError:
|
||
|
|
pass
|
||
|
|
|
||
|
|
def testAdvanceByte(self):
|
||
|
|
s = BitStream(hex='0x010203')
|
||
|
|
s.bytepos += 1
|
||
|
|
self.assertEqual(s.bytepos, 1)
|
||
|
|
s.bytepos += 1
|
||
|
|
self.assertEqual(s.bytepos, 2)
|
||
|
|
s.bytepos += 1
|
||
|
|
try:
|
||
|
|
s.bytepos += 1
|
||
|
|
self.assertTrue(False)
|
||
|
|
except ValueError:
|
||
|
|
pass
|
||
|
|
|
||
|
|
def testRetreatBit(self):
|
||
|
|
s = BitStream(hex='0xff')
|
||
|
|
try:
|
||
|
|
s.pos -= 1
|
||
|
|
self.assertTrue(False)
|
||
|
|
except ValueError:
|
||
|
|
pass
|
||
|
|
s.pos = 5
|
||
|
|
s.pos -= 1
|
||
|
|
self.assertEqual(s.pos, 4)
|
||
|
|
|
||
|
|
def testRetreatByte(self):
|
||
|
|
s = BitStream(hex='0x010203')
|
||
|
|
try:
|
||
|
|
s.bytepos -= 1
|
||
|
|
self.assertTrue(False)
|
||
|
|
except ValueError:
|
||
|
|
pass
|
||
|
|
s.bytepos = 3
|
||
|
|
s.bytepos -= 1
|
||
|
|
self.assertEqual(s.bytepos, 2)
|
||
|
|
self.assertEqual(s.read(8).hex, '03')
|
||
|
|
|
||
|
|
def testCreationByAuto(self):
|
||
|
|
s = BitStream('0xff')
|
||
|
|
self.assertEqual(s.hex, 'ff')
|
||
|
|
s = BitStream('0b00011')
|
||
|
|
self.assertEqual(s.bin, '00011')
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, 'hello')
|
||
|
|
s1 = BitStream(bytes=b'\xf5', length=3, offset=5)
|
||
|
|
s2 = BitStream(s1, length=1, offset=1)
|
||
|
|
self.assertEqual(s2, '0b0')
|
||
|
|
s = BitStream(bytes=b'\xff', offset=2)
|
||
|
|
t = BitStream(s, offset=2)
|
||
|
|
self.assertEqual(t, '0b1111')
|
||
|
|
self.assertRaises(TypeError, BitStream, auto=1.2)
|
||
|
|
|
||
|
|
def testCreationByAuto2(self):
|
||
|
|
s = BitStream('bin=001')
|
||
|
|
self.assertEqual(s.bin, '001')
|
||
|
|
s = BitStream('oct=0o007')
|
||
|
|
self.assertEqual(s.oct, '007')
|
||
|
|
s = BitStream('hex=123abc')
|
||
|
|
self.assertEqual(s, '0x123abc')
|
||
|
|
|
||
|
|
s = BitStream('bin:2=01')
|
||
|
|
self.assertEqual(s, '0b01')
|
||
|
|
for s in ['bin:1=01', 'bits:4=0b1', 'oct:3=000', 'hex:4=0x1234']:
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, s)
|
||
|
|
|
||
|
|
def testInsertUsingAuto(self):
|
||
|
|
s = BitStream('0xff')
|
||
|
|
s.insert('0x00', 4)
|
||
|
|
self.assertEqual(s.hex, 'f00f')
|
||
|
|
self.assertRaises(ValueError, s.insert, 'ff')
|
||
|
|
|
||
|
|
def testOverwriteUsingAuto(self):
|
||
|
|
s = BitStream('0x0110')
|
||
|
|
s.overwrite('0b1')
|
||
|
|
self.assertEqual(s.hex, '8110')
|
||
|
|
s.overwrite('')
|
||
|
|
self.assertEqual(s.hex, '8110')
|
||
|
|
self.assertRaises(ValueError, s.overwrite, '0bf')
|
||
|
|
|
||
|
|
def testFindUsingAuto(self):
|
||
|
|
s = BitStream('0b000000010100011000')
|
||
|
|
self.assertTrue(s.find('0b101'))
|
||
|
|
self.assertEqual(s.pos, 7)
|
||
|
|
|
||
|
|
def testFindbytealignedUsingAuto(self):
|
||
|
|
s = BitStream('0x00004700')
|
||
|
|
self.assertTrue(s.find('0b01000111', bytealigned=True))
|
||
|
|
self.assertEqual(s.bytepos, 2)
|
||
|
|
|
||
|
|
def testAppendUsingAuto(self):
|
||
|
|
s = BitStream('0b000')
|
||
|
|
s.append('0b111')
|
||
|
|
self.assertEqual(s.bin, '000111')
|
||
|
|
s.append('0b0')
|
||
|
|
self.assertEqual(s.bin, '0001110')
|
||
|
|
|
||
|
|
def testSplitByteAlignedUsingAuto(self):
|
||
|
|
s = BitStream('0x000143563200015533000123')
|
||
|
|
sections = s.split('0x0001')
|
||
|
|
self.assertEqual(next(sections).hex, '')
|
||
|
|
self.assertEqual(next(sections).hex, '0001435632')
|
||
|
|
self.assertEqual(next(sections).hex, '00015533')
|
||
|
|
self.assertEqual(next(sections).hex, '000123')
|
||
|
|
self.assertRaises(StopIteration, next, sections)
|
||
|
|
|
||
|
|
def testSplitByteAlignedWithSelf(self):
|
||
|
|
s = BitStream('0x1234')
|
||
|
|
sections = s.split(s)
|
||
|
|
self.assertEqual(next(sections).hex, '')
|
||
|
|
self.assertEqual(next(sections).hex, '1234')
|
||
|
|
self.assertRaises(StopIteration, next, sections)
|
||
|
|
|
||
|
|
def testPrepend(self):
|
||
|
|
s = BitStream('0b000')
|
||
|
|
s.prepend('0b11')
|
||
|
|
self.assertEqual(s.bin, '11000')
|
||
|
|
s.prepend(s)
|
||
|
|
self.assertEqual(s.bin, '1100011000')
|
||
|
|
s.prepend('')
|
||
|
|
self.assertEqual(s.bin, '1100011000')
|
||
|
|
|
||
|
|
def testNullSlice(self):
|
||
|
|
s = BitStream('0x111')
|
||
|
|
t = s[1:1]
|
||
|
|
self.assertEqual(t._datastore.bytelength, 0)
|
||
|
|
|
||
|
|
def testMultipleAutos(self):
|
||
|
|
s = BitStream('0xa')
|
||
|
|
s.prepend('0xf')
|
||
|
|
s.append('0xb')
|
||
|
|
self.assertEqual(s, '0xfab')
|
||
|
|
s.prepend(s)
|
||
|
|
s.append('0x100')
|
||
|
|
s.overwrite('0x5', 4)
|
||
|
|
self.assertEqual(s, '0xf5bfab100')
|
||
|
|
|
||
|
|
def testReverse(self):
|
||
|
|
s = BitStream('0b0011')
|
||
|
|
s.reverse()
|
||
|
|
self.assertEqual(s.bin, '1100')
|
||
|
|
s = BitStream('0b10')
|
||
|
|
s.reverse()
|
||
|
|
self.assertEqual(s.bin, '01')
|
||
|
|
s = BitStream()
|
||
|
|
s.reverse()
|
||
|
|
self.assertEqual(s.bin, '')
|
||
|
|
|
||
|
|
def testInitWithConcatenatedStrings(self):
|
||
|
|
s = BitStream('0xff 0Xee 0xd 0xcc')
|
||
|
|
self.assertEqual(s.hex, 'ffeedcc')
|
||
|
|
s = BitStream('0b0 0B111 0b001')
|
||
|
|
self.assertEqual(s.bin, '0111001')
|
||
|
|
s += '0b1' + '0B1'
|
||
|
|
self.assertEqual(s.bin, '011100111')
|
||
|
|
s = BitStream(hex='ff0xee')
|
||
|
|
self.assertEqual(s.hex, 'ffee')
|
||
|
|
s = BitStream(bin='000b0b11')
|
||
|
|
self.assertEqual(s.bin, '0011')
|
||
|
|
s = BitStream(' 0o123 0O 7 0 o1')
|
||
|
|
self.assertEqual(s.oct, '12371')
|
||
|
|
s += ' 0 o 332'
|
||
|
|
self.assertEqual(s.oct, '12371332')
|
||
|
|
|
||
|
|
def testEquals(self):
|
||
|
|
s1 = BitStream('0b01010101')
|
||
|
|
s2 = BitStream('0b01010101')
|
||
|
|
self.assertTrue(s1 == s2)
|
||
|
|
s3 = BitStream()
|
||
|
|
s4 = BitStream()
|
||
|
|
self.assertTrue(s3 == s4)
|
||
|
|
self.assertFalse(s3 != s4)
|
||
|
|
s5 = BitStream(bytes=b'\xff', offset=2, length=3)
|
||
|
|
s6 = BitStream('0b111')
|
||
|
|
self.assertTrue(s5 == s6)
|
||
|
|
class A(object):
|
||
|
|
pass
|
||
|
|
self.assertFalse(s5 == A())
|
||
|
|
|
||
|
|
def testLargeEquals(self):
|
||
|
|
s1 = BitStream(1000000)
|
||
|
|
s2 = BitStream(1000000)
|
||
|
|
s1.set(True, [-1, 55, 53214, 534211, 999999])
|
||
|
|
s2.set(True, [-1, 55, 53214, 534211, 999999])
|
||
|
|
self.assertEqual(s1, s2)
|
||
|
|
s1.set(True, 800000)
|
||
|
|
self.assertNotEqual(s1, s2)
|
||
|
|
|
||
|
|
def testNotEquals(self):
|
||
|
|
s1 = BitStream('0b0')
|
||
|
|
s2 = BitStream('0b1')
|
||
|
|
self.assertTrue(s1 != s2)
|
||
|
|
self.assertFalse(s1 != BitStream('0b0'))
|
||
|
|
|
||
|
|
def testEqualityWithAutoInitialised(self):
|
||
|
|
a = BitStream('0b00110111')
|
||
|
|
self.assertTrue(a == '0b00110111')
|
||
|
|
self.assertTrue(a == '0x37')
|
||
|
|
self.assertTrue('0b0011 0111' == a)
|
||
|
|
self.assertTrue('0x3 0x7' == a)
|
||
|
|
self.assertFalse(a == '0b11001000')
|
||
|
|
self.assertFalse('0x3737' == a)
|
||
|
|
|
||
|
|
def testInvertSpecialMethod(self):
|
||
|
|
s = BitStream('0b00011001')
|
||
|
|
self.assertEqual((~s).bin, '11100110')
|
||
|
|
self.assertEqual((~BitStream('0b0')).bin, '1')
|
||
|
|
self.assertEqual((~BitStream('0b1')).bin, '0')
|
||
|
|
self.assertTrue(~~s == s)
|
||
|
|
|
||
|
|
def testInvertBitPosition(self):
|
||
|
|
s = ConstBitStream('0xefef')
|
||
|
|
s.pos = 8
|
||
|
|
t = ~s
|
||
|
|
self.assertEqual(s.pos, 8)
|
||
|
|
self.assertEqual(t.pos, 0)
|
||
|
|
|
||
|
|
def testInvertSpecialMethodErrors(self):
|
||
|
|
s = BitStream()
|
||
|
|
self.assertRaises(bitstring.Error, s.__invert__)
|
||
|
|
|
||
|
|
def testJoinWithAuto(self):
|
||
|
|
s = BitStream().join(['0xf', '0b00', BitStream(bin='11')])
|
||
|
|
self.assertEqual(s, '0b11110011')
|
||
|
|
|
||
|
|
def testAutoBitStringCopy(self):
|
||
|
|
s = BitStream('0xabcdef')
|
||
|
|
t = BitStream(s)
|
||
|
|
self.assertEqual(t.hex, 'abcdef')
|
||
|
|
del s[-8:]
|
||
|
|
self.assertEqual(t.hex, 'abcdef')
|
||
|
|
|
||
|
|
class Multiplication(unittest.TestCase):
|
||
|
|
|
||
|
|
def testMultiplication(self):
|
||
|
|
a = BitStream('0xff')
|
||
|
|
b = a * 8
|
||
|
|
self.assertEqual(b, '0xffffffffffffffff')
|
||
|
|
b = 4 * a
|
||
|
|
self.assertEqual(b, '0xffffffff')
|
||
|
|
self.assertTrue(1 * a == a * 1 == a)
|
||
|
|
c = a * 0
|
||
|
|
self.assertFalse(c)
|
||
|
|
a *= 3
|
||
|
|
self.assertEqual(a, '0xffffff')
|
||
|
|
a *= 0
|
||
|
|
self.assertFalse(a)
|
||
|
|
one = BitStream('0b1')
|
||
|
|
zero = BitStream('0b0')
|
||
|
|
mix = one * 2 + 3 * zero + 2 * one * 2
|
||
|
|
self.assertEqual(mix, '0b110001111')
|
||
|
|
q = BitStream()
|
||
|
|
q *= 143
|
||
|
|
self.assertFalse(q)
|
||
|
|
q += [True, True, False]
|
||
|
|
q.pos += 2
|
||
|
|
q *= 0
|
||
|
|
self.assertFalse(q)
|
||
|
|
self.assertEqual(q.bitpos, 0)
|
||
|
|
|
||
|
|
def testMultiplicationWithFiles(self):
|
||
|
|
a = BitStream(filename='test.m1v')
|
||
|
|
b = a.len
|
||
|
|
a *= 3
|
||
|
|
self.assertEqual(a.len, 3 * b)
|
||
|
|
|
||
|
|
def testMultiplicationErrors(self):
|
||
|
|
a = BitStream('0b1')
|
||
|
|
b = BitStream('0b0')
|
||
|
|
self.assertRaises(ValueError, a.__mul__, -1)
|
||
|
|
self.assertRaises(ValueError, a.__imul__, -1)
|
||
|
|
self.assertRaises(ValueError, a.__rmul__, -1)
|
||
|
|
self.assertRaises(TypeError, a.__mul__, 1.2)
|
||
|
|
self.assertRaises(TypeError, a.__rmul__, b)
|
||
|
|
self.assertRaises(TypeError, a.__imul__, b)
|
||
|
|
|
||
|
|
def testFileAndMemEquivalence(self):
|
||
|
|
a = ConstBitStream(filename='smalltestfile')
|
||
|
|
b = BitStream(filename='smalltestfile')
|
||
|
|
self.assertTrue(isinstance(a._datastore._rawarray, bitstring.MmapByteArray))
|
||
|
|
self.assertTrue(isinstance(b._datastore._rawarray, bytearray))
|
||
|
|
self.assertEqual(a._datastore.getbyte(0), b._datastore.getbyte(0))
|
||
|
|
self.assertEqual(a._datastore.getbyteslice(1, 5), bytearray(b._datastore.getbyteslice(1, 5)))
|
||
|
|
|
||
|
|
|
||
|
|
class BitWise(unittest.TestCase):
|
||
|
|
|
||
|
|
def testBitwiseAnd(self):
|
||
|
|
a = BitStream('0b01101')
|
||
|
|
b = BitStream('0b00110')
|
||
|
|
self.assertEqual((a & b).bin, '00100')
|
||
|
|
self.assertEqual((a & '0b11111'), a)
|
||
|
|
self.assertRaises(ValueError, a.__and__, '0b1')
|
||
|
|
self.assertRaises(ValueError, b.__and__, '0b110111111')
|
||
|
|
c = BitStream('0b0011011')
|
||
|
|
c.pos = 4
|
||
|
|
d = c & '0b1111000'
|
||
|
|
self.assertEqual(d.pos, 0)
|
||
|
|
self.assertEqual(d.bin, '0011000')
|
||
|
|
d = '0b1111000' & c
|
||
|
|
self.assertEqual(d.bin, '0011000')
|
||
|
|
|
||
|
|
def testBitwiseOr(self):
|
||
|
|
a = BitStream('0b111001001')
|
||
|
|
b = BitStream('0b011100011')
|
||
|
|
self.assertEqual((a | b).bin, '111101011')
|
||
|
|
self.assertEqual((a | '0b000000000'), a)
|
||
|
|
self.assertRaises(ValueError, a.__or__, '0b0000')
|
||
|
|
self.assertRaises(ValueError, b.__or__, a + '0b1')
|
||
|
|
a = '0xff00' | BitStream('0x00f0')
|
||
|
|
self.assertEqual(a.hex, 'fff0')
|
||
|
|
|
||
|
|
def testBitwiseXor(self):
|
||
|
|
a = BitStream('0b111001001')
|
||
|
|
b = BitStream('0b011100011')
|
||
|
|
self.assertEqual((a ^ b).bin, '100101010')
|
||
|
|
self.assertEqual((a ^ '0b111100000').bin, '000101001')
|
||
|
|
self.assertRaises(ValueError, a.__xor__, '0b0000')
|
||
|
|
self.assertRaises(ValueError, b.__xor__, a + '0b1')
|
||
|
|
a = '0o707' ^ BitStream('0o777')
|
||
|
|
self.assertEqual(a.oct, '070')
|
||
|
|
|
||
|
|
class Split(unittest.TestCase):
|
||
|
|
|
||
|
|
def testSplit(self):
|
||
|
|
a = BitStream('0b0 010100111 010100 0101 010')
|
||
|
|
a.pos = 20
|
||
|
|
subs = [i.bin for i in a.split('0b010')]
|
||
|
|
self.assertEqual(subs, ['0', '010100111', '010100', '0101', '010'])
|
||
|
|
self.assertEqual(a.pos, 20)
|
||
|
|
|
||
|
|
def testSplitCornerCases(self):
|
||
|
|
a = BitStream('0b000000')
|
||
|
|
bsl = a.split('0b1', False)
|
||
|
|
self.assertEqual(next(bsl), a)
|
||
|
|
self.assertRaises(StopIteration, next, bsl)
|
||
|
|
b = BitStream()
|
||
|
|
bsl = b.split('0b001', False)
|
||
|
|
self.assertFalse(next(bsl))
|
||
|
|
self.assertRaises(StopIteration, next, bsl)
|
||
|
|
|
||
|
|
def testSplitErrors(self):
|
||
|
|
a = BitStream('0b0')
|
||
|
|
b = a.split('', False)
|
||
|
|
self.assertRaises(ValueError, next, b)
|
||
|
|
|
||
|
|
def testSliceWithOffset(self):
|
||
|
|
a = BitStream(bytes=b'\x00\xff\x00', offset=7)
|
||
|
|
b = a[7:12]
|
||
|
|
self.assertEqual(b.bin, '11000')
|
||
|
|
|
||
|
|
def testSplitWithMaxsplit(self):
|
||
|
|
a = BitStream('0xaabbccbbccddbbccddee')
|
||
|
|
self.assertEqual(len(list(a.split('0xbb', bytealigned=True))), 4)
|
||
|
|
bsl = list(a.split('0xbb', count=1, bytealigned=True))
|
||
|
|
self.assertEqual((len(bsl), bsl[0]), (1, '0xaa'))
|
||
|
|
bsl = list(a.split('0xbb', count=2, bytealigned=True))
|
||
|
|
self.assertEqual(len(bsl), 2)
|
||
|
|
self.assertEqual(bsl[0], '0xaa')
|
||
|
|
self.assertEqual(bsl[1], '0xbbcc')
|
||
|
|
|
||
|
|
def testSplitMore(self):
|
||
|
|
s = BitStream('0b1100011001110110')
|
||
|
|
for i in range(10):
|
||
|
|
a = list(s.split('0b11', False, count=i))
|
||
|
|
b = list(s.split('0b11', False))[:i]
|
||
|
|
self.assertEqual(a, b)
|
||
|
|
b = s.split('0b11', count=-1)
|
||
|
|
self.assertRaises(ValueError, next, b)
|
||
|
|
|
||
|
|
def testSplitStartbit(self):
|
||
|
|
a = BitStream('0b0010101001000000001111')
|
||
|
|
bsl = a.split('0b001', bytealigned=False, start=1)
|
||
|
|
self.assertEqual([x.bin for x in bsl], ['010101', '001000000', '001111'])
|
||
|
|
b = a.split('0b001', start=-100)
|
||
|
|
self.assertRaises(ValueError, next, b)
|
||
|
|
b = a.split('0b001', start=23)
|
||
|
|
self.assertRaises(ValueError, next, b)
|
||
|
|
b = a.split('0b1', start=10, end=9)
|
||
|
|
self.assertRaises(ValueError, next, b)
|
||
|
|
|
||
|
|
def testSplitStartbitByteAligned(self):
|
||
|
|
a = BitStream('0x00ffffee')
|
||
|
|
bsl = list(a.split('0b111', start=9, bytealigned=True))
|
||
|
|
self.assertEqual([x.bin for x in bsl], ['1111111', '11111111', '11101110'])
|
||
|
|
|
||
|
|
def testSplitEndbit(self):
|
||
|
|
a = BitStream('0b000010001001011')
|
||
|
|
bsl = list(a.split('0b1', bytealigned=False, end=14))
|
||
|
|
self.assertEqual([x.bin for x in bsl], ['0000', '1000', '100', '10', '1'])
|
||
|
|
self.assertEqual(list(a[4:12].split('0b0', False)), list(a.split('0b0', start=4, end=12)))
|
||
|
|
# Shouldn't raise ValueError
|
||
|
|
bsl = list(a.split('0xffee', end=15))
|
||
|
|
# Whereas this one will when we call next()
|
||
|
|
bsl = a.split('0xffee', end=16)
|
||
|
|
self.assertRaises(ValueError, next, bsl)
|
||
|
|
|
||
|
|
def testSplitEndbitByteAligned(self):
|
||
|
|
a = BitStream('0xff00ff')[:22]
|
||
|
|
bsl = list(a.split('0b 0000 0000 111', end=19))
|
||
|
|
self.assertEqual([x.bin for x in bsl], ['11111111', '00000000111'])
|
||
|
|
bsl = list(a.split('0b 0000 0000 111', end=18))
|
||
|
|
self.assertEqual([x.bin for x in bsl], ['111111110000000011'])
|
||
|
|
|
||
|
|
def testSplitMaxSplit(self):
|
||
|
|
a = BitStream('0b1' * 20)
|
||
|
|
for i in range(10):
|
||
|
|
bsl = list(a.split('0b1', count=i))
|
||
|
|
self.assertEqual(len(bsl), i)
|
||
|
|
|
||
|
|
#######################
|
||
|
|
|
||
|
|
def testPositionInSlice(self):
|
||
|
|
a = BitStream('0x00ffff00')
|
||
|
|
a.bytepos = 2
|
||
|
|
b = a[8:24]
|
||
|
|
self.assertEqual(b.bytepos, 0)
|
||
|
|
|
||
|
|
def testFindByteAlignedWithBits(self):
|
||
|
|
a = BitStream('0x00112233445566778899')
|
||
|
|
a.find('0b0001', bytealigned=True)
|
||
|
|
self.assertEqual(a.bitpos, 8)
|
||
|
|
|
||
|
|
def testFindStartbitNotByteAligned(self):
|
||
|
|
a = BitStream('0b0010000100')
|
||
|
|
found = a.find('0b1', start=4)
|
||
|
|
self.assertEqual((found, a.bitpos), ((7,), 7))
|
||
|
|
found = a.find('0b1', start=2)
|
||
|
|
self.assertEqual((found, a.bitpos), ((2,), 2))
|
||
|
|
found = a.find('0b1', bytealigned=False, start=8)
|
||
|
|
self.assertEqual((found, a.bitpos), ((), 2))
|
||
|
|
|
||
|
|
def testFindEndbitNotByteAligned(self):
|
||
|
|
a = BitStream('0b0010010000')
|
||
|
|
found = a.find('0b1', bytealigned=False, end=2)
|
||
|
|
self.assertEqual((found, a.bitpos), ((), 0))
|
||
|
|
found = a.find('0b1', end=3)
|
||
|
|
self.assertEqual((found, a.bitpos), ((2,), 2))
|
||
|
|
found = a.find('0b1', bytealigned=False, start=3, end=5)
|
||
|
|
self.assertEqual((found, a.bitpos), ((), 2))
|
||
|
|
found = a.find('0b1', start=3, end=6)
|
||
|
|
self.assertEqual((found[0], a.bitpos), (5, 5))
|
||
|
|
|
||
|
|
def testFindStartbitByteAligned(self):
|
||
|
|
a = BitStream('0xff001122ff0011ff')
|
||
|
|
a.pos = 40
|
||
|
|
found = a.find('0x22', start=23, bytealigned=True)
|
||
|
|
self.assertEqual((found, a.bytepos), ((24,), 3))
|
||
|
|
a.bytepos = 4
|
||
|
|
found = a.find('0x22', start=24, bytealigned=True)
|
||
|
|
self.assertEqual((found, a.bytepos), ((24,), 3))
|
||
|
|
found = a.find('0x22', start=25, bytealigned=True)
|
||
|
|
self.assertEqual((found, a.pos), ((), 24))
|
||
|
|
found = a.find('0b111', start=40, bytealigned=True)
|
||
|
|
self.assertEqual((found, a.pos), ((56,), 56))
|
||
|
|
|
||
|
|
def testFindEndbitByteAligned(self):
|
||
|
|
a = BitStream('0xff001122ff0011ff')
|
||
|
|
found = a.find('0x22', end=31, bytealigned=True)
|
||
|
|
self.assertFalse(found)
|
||
|
|
self.assertEqual(a.pos, 0)
|
||
|
|
found = a.find('0x22', end=32, bytealigned=True)
|
||
|
|
self.assertTrue(found)
|
||
|
|
self.assertEqual(a.pos, 24)
|
||
|
|
self.assertEqual(found[0], 24)
|
||
|
|
|
||
|
|
def testFindStartEndbitErrors(self):
|
||
|
|
a = BitStream('0b00100')
|
||
|
|
self.assertRaises(ValueError, a.find, '0b1', bytealigned=False, start=-100)
|
||
|
|
self.assertRaises(ValueError, a.find, '0b1', end=6)
|
||
|
|
self.assertRaises(ValueError, a.find, '0b1', start=4, end=3)
|
||
|
|
b = BitStream('0x0011223344')
|
||
|
|
self.assertRaises(ValueError, a.find, '0x22', bytealigned=True, start=-100)
|
||
|
|
self.assertRaises(ValueError, a.find, '0x22', end=41, bytealigned=True)
|
||
|
|
|
||
|
|
def testPrependAndAppendAgain(self):
|
||
|
|
c = BitStream('0x1122334455667788')
|
||
|
|
c.bitpos = 40
|
||
|
|
c.prepend('0b1')
|
||
|
|
self.assertEqual(c.bitpos, 41)
|
||
|
|
c = BitStream()
|
||
|
|
c.prepend('0x1234')
|
||
|
|
self.assertEqual(c.bytepos, 2)
|
||
|
|
c = BitStream()
|
||
|
|
c.append('0x1234')
|
||
|
|
self.assertEqual(c.bytepos, 0)
|
||
|
|
s = BitStream(bytes=b'\xff\xff', offset=2)
|
||
|
|
self.assertEqual(s.length, 14)
|
||
|
|
t = BitStream(bytes=b'\x80', offset=1, length=2)
|
||
|
|
s.prepend(t)
|
||
|
|
self.assertEqual(s, '0x3fff')
|
||
|
|
|
||
|
|
def testFindAll(self):
|
||
|
|
a = BitStream('0b11111')
|
||
|
|
p = a.findall('0b1')
|
||
|
|
self.assertEqual(list(p), [0, 1, 2, 3, 4])
|
||
|
|
p = a.findall('0b11')
|
||
|
|
self.assertEqual(list(p), [0, 1, 2, 3])
|
||
|
|
p = a.findall('0b10')
|
||
|
|
self.assertEqual(list(p), [])
|
||
|
|
a = BitStream('0x4733eeff66554747335832434547')
|
||
|
|
p = a.findall('0x47', bytealigned=True)
|
||
|
|
self.assertEqual(list(p), [0, 6 * 8, 7 * 8, 13 * 8])
|
||
|
|
p = a.findall('0x4733', bytealigned=True)
|
||
|
|
self.assertEqual(list(p), [0, 7 * 8])
|
||
|
|
a = BitStream('0b1001001001001001001')
|
||
|
|
p = a.findall('0b1001', bytealigned=False)
|
||
|
|
self.assertEqual(list(p), [0, 3, 6, 9, 12, 15])
|
||
|
|
self.assertEqual(a.pos, 15)
|
||
|
|
|
||
|
|
def testFindAllGenerator(self):
|
||
|
|
a = BitStream('0xff1234512345ff1234ff12ff')
|
||
|
|
p = a.findall('0xff', bytealigned=True)
|
||
|
|
self.assertEqual(next(p), 0)
|
||
|
|
self.assertEqual(next(p), 6 * 8)
|
||
|
|
self.assertEqual(next(p), 9 * 8)
|
||
|
|
self.assertEqual(next(p), 11 * 8)
|
||
|
|
self.assertRaises(StopIteration, next, p)
|
||
|
|
|
||
|
|
def testFindAllCount(self):
|
||
|
|
s = BitStream('0b1') * 100
|
||
|
|
for i in [0, 1, 23]:
|
||
|
|
self.assertEqual(len(list(s.findall('0b1', count=i))), i)
|
||
|
|
b = s.findall('0b1', bytealigned=True, count=-1)
|
||
|
|
self.assertRaises(ValueError, next, b)
|
||
|
|
|
||
|
|
def testContains(self):
|
||
|
|
a = BitStream('0b1') + '0x0001dead0001'
|
||
|
|
self.assertTrue('0xdead' in a)
|
||
|
|
self.assertEqual(a.pos, 0)
|
||
|
|
self.assertFalse('0xfeed' in a)
|
||
|
|
|
||
|
|
def testRepr(self):
|
||
|
|
max = bitstring.MAX_CHARS
|
||
|
|
bls = ['', '0b1', '0o5', '0x43412424f41', '0b00101001010101']
|
||
|
|
for bs in bls:
|
||
|
|
a = BitStream(bs)
|
||
|
|
b = eval(a.__repr__())
|
||
|
|
self.assertTrue(a == b)
|
||
|
|
for f in [ConstBitStream(filename='test.m1v'),
|
||
|
|
ConstBitStream(filename='test.m1v', length=17),
|
||
|
|
ConstBitStream(filename='test.m1v', length=23, offset=23102)]:
|
||
|
|
f2 = eval(f.__repr__())
|
||
|
|
self.assertEqual(f._datastore._rawarray.source.name, f2._datastore._rawarray.source.name)
|
||
|
|
self.assertTrue(f2.tobytes() == f.tobytes())
|
||
|
|
a = BitStream('0b1')
|
||
|
|
self.assertEqual(repr(a), "BitStream('0b1')")
|
||
|
|
a += '0b11'
|
||
|
|
self.assertEqual(repr(a), "BitStream('0b111')")
|
||
|
|
a += '0b1'
|
||
|
|
self.assertEqual(repr(a), "BitStream('0xf')")
|
||
|
|
a *= max
|
||
|
|
self.assertEqual(repr(a), "BitStream('0x" + "f" * max + "')")
|
||
|
|
a += '0xf'
|
||
|
|
self.assertEqual(repr(a), "BitStream('0x" + "f" * max + "...') # length=%d" % (max * 4 + 4))
|
||
|
|
|
||
|
|
def testPrint(self):
|
||
|
|
s = BitStream(hex='0x00')
|
||
|
|
self.assertEqual('0x' + s.hex, s.__str__())
|
||
|
|
s = BitStream(filename='test.m1v')
|
||
|
|
self.assertEqual('0x' + s[0:bitstring.MAX_CHARS * 4].hex + '...', s.__str__())
|
||
|
|
self.assertEqual(BitStream().__str__(), '')
|
||
|
|
s = BitStream('0b11010')
|
||
|
|
self.assertEqual('0b' + s.bin, s.__str__())
|
||
|
|
s = BitStream('0x12345678901234567890,0b1')
|
||
|
|
self.assertEqual('0x12345678901234567890, 0b1', s.__str__())
|
||
|
|
|
||
|
|
def testIter(self):
|
||
|
|
a = BitStream('0b001010')
|
||
|
|
b = BitStream()
|
||
|
|
for bit in a:
|
||
|
|
b.append(ConstBitStream(bool=bit))
|
||
|
|
self.assertEqual(a, b)
|
||
|
|
|
||
|
|
def testDelitem(self):
|
||
|
|
a = BitStream('0xffee')
|
||
|
|
del a[0:8]
|
||
|
|
self.assertEqual(a.hex, 'ee')
|
||
|
|
del a[0:8]
|
||
|
|
self.assertFalse(a)
|
||
|
|
del a[10:12]
|
||
|
|
self.assertFalse(a)
|
||
|
|
|
||
|
|
def testNonZeroBitsAtStart(self):
|
||
|
|
a = BitStream(bytes=b'\xff', offset=2)
|
||
|
|
b = BitStream('0b00')
|
||
|
|
b += a
|
||
|
|
self.assertTrue(b == '0b0011 1111')
|
||
|
|
#self.assertEqual(a._datastore.rawbytes, b'\xff')
|
||
|
|
self.assertEqual(a.tobytes(), b'\xfc')
|
||
|
|
|
||
|
|
def testNonZeroBitsAtEnd(self):
|
||
|
|
a = BitStream(bytes=b'\xff', length=5)
|
||
|
|
#self.assertEqual(a._datastore.rawbytes, b'\xff')
|
||
|
|
b = BitStream('0b00')
|
||
|
|
a += b
|
||
|
|
self.assertTrue(a == '0b1111100')
|
||
|
|
self.assertEqual(a.tobytes(), b'\xf8')
|
||
|
|
self.assertRaises(ValueError, a._getbytes)
|
||
|
|
|
||
|
|
def testNewOffsetErrors(self):
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, hex='ff', offset=-1)
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, '0xffffffff', offset=33)
|
||
|
|
|
||
|
|
def testSliceStep(self):
|
||
|
|
a = BitStream('0x3')
|
||
|
|
b = a[::1]
|
||
|
|
self.assertEqual(a, b)
|
||
|
|
self.assertEqual(a[2:4:1], '0b11')
|
||
|
|
self.assertEqual(a[0:2:1], '0b00')
|
||
|
|
self.assertEqual(a[:3], '0o1')
|
||
|
|
|
||
|
|
a = BitStream('0x0011223344556677')
|
||
|
|
self.assertEqual(a[-8:], '0x77')
|
||
|
|
self.assertEqual(a[:-24], '0x0011223344')
|
||
|
|
self.assertEqual(a[-1000:-24], '0x0011223344')
|
||
|
|
|
||
|
|
def testInterestingSliceStep(self):
|
||
|
|
a = BitStream('0b0011000111')
|
||
|
|
self.assertEqual(a[7:3:-1], '0b1000')
|
||
|
|
self.assertEqual(a[9:2:-1], '0b1110001')
|
||
|
|
self.assertEqual(a[8:2:-2], '0b100')
|
||
|
|
self.assertEqual(a[100:-20:-3], '0b1010')
|
||
|
|
self.assertEqual(a[100:-20:-1], '0b1110001100')
|
||
|
|
self.assertEqual(a[10:2:-1], '0b1110001')
|
||
|
|
self.assertEqual(a[100:2:-1], '0b1110001')
|
||
|
|
|
||
|
|
def testInsertionOrderAndBitpos(self):
|
||
|
|
b = BitStream()
|
||
|
|
b[0:0] = '0b0'
|
||
|
|
b[0:0] = '0b1'
|
||
|
|
self.assertEqual(b, '0b10')
|
||
|
|
self.assertEqual(b.bitpos, 1)
|
||
|
|
a = BitStream()
|
||
|
|
a.insert('0b0')
|
||
|
|
a.insert('0b1')
|
||
|
|
self.assertEqual(a, '0b01')
|
||
|
|
self.assertEqual(a.bitpos, 2)
|
||
|
|
|
||
|
|
def testOverwriteOrderAndBitpos(self):
|
||
|
|
a = BitStream('0xff')
|
||
|
|
a.overwrite('0xa')
|
||
|
|
self.assertEqual(a, '0xaf')
|
||
|
|
self.assertEqual(a.bitpos, 4)
|
||
|
|
a.overwrite('0xb')
|
||
|
|
self.assertEqual(a, '0xab')
|
||
|
|
self.assertEqual(a.bitpos, 8)
|
||
|
|
self.assertRaises(ValueError, a.overwrite, '0b1')
|
||
|
|
a.overwrite('0xa', 4)
|
||
|
|
self.assertEqual(a, '0xaa')
|
||
|
|
self.assertEqual(a.bitpos, 8)
|
||
|
|
a.overwrite(a, 0)
|
||
|
|
self.assertEqual(a, '0xaa')
|
||
|
|
|
||
|
|
def testInitSliceWithInt(self):
|
||
|
|
a = BitStream(length=8)
|
||
|
|
a[:] = 100
|
||
|
|
self.assertEqual(a.uint, 100)
|
||
|
|
a[0] = 1
|
||
|
|
self.assertEqual(a.bin, '11100100')
|
||
|
|
a[1] = 0
|
||
|
|
self.assertEqual(a.bin, '10100100')
|
||
|
|
a[-1] = -1
|
||
|
|
self.assertEqual(a.bin, '10100101')
|
||
|
|
a[-3:] = -2
|
||
|
|
self.assertEqual(a.bin, '10100110')
|
||
|
|
|
||
|
|
def testInitSliceWithIntErrors(self):
|
||
|
|
a = BitStream('0b0000')
|
||
|
|
self.assertRaises(ValueError, a.__setitem__, slice(0, 4), 16)
|
||
|
|
self.assertRaises(ValueError, a.__setitem__, slice(0, 4), -9)
|
||
|
|
self.assertRaises(ValueError, a.__setitem__, 0, 2)
|
||
|
|
self.assertRaises(ValueError, a.__setitem__, 0, -2)
|
||
|
|
|
||
|
|
def testReverseWithSlice(self):
|
||
|
|
a = BitStream('0x0012ff')
|
||
|
|
a.reverse()
|
||
|
|
self.assertEqual(a, '0xff4800')
|
||
|
|
a.reverse(8, 16)
|
||
|
|
self.assertEqual(a, '0xff1200')
|
||
|
|
b = a[8:16]
|
||
|
|
b.reverse()
|
||
|
|
a[8:16] = b
|
||
|
|
self.assertEqual(a, '0xff4800')
|
||
|
|
|
||
|
|
def testReverseWithSliceErrors(self):
|
||
|
|
a = BitStream('0x123')
|
||
|
|
self.assertRaises(ValueError, a.reverse, -1, 4)
|
||
|
|
self.assertRaises(ValueError, a.reverse, 10, 9)
|
||
|
|
self.assertRaises(ValueError, a.reverse, 1, 10000)
|
||
|
|
|
||
|
|
def testInitialiseFromList(self):
|
||
|
|
a = BitStream([])
|
||
|
|
self.assertFalse(a)
|
||
|
|
a = BitStream([True, False, [], [0], 'hello'])
|
||
|
|
self.assertEqual(a, '0b10011')
|
||
|
|
a += []
|
||
|
|
self.assertEqual(a, '0b10011')
|
||
|
|
a += [True, False, True]
|
||
|
|
self.assertEqual(a, '0b10011101')
|
||
|
|
a.find([12, 23])
|
||
|
|
self.assertEqual(a.pos, 3)
|
||
|
|
self.assertEqual([1, 0, False, True], BitStream('0b1001'))
|
||
|
|
a = [True] + BitStream('0b1')
|
||
|
|
self.assertEqual(a, '0b11')
|
||
|
|
|
||
|
|
def testInitialiseFromTuple(self):
|
||
|
|
a = BitStream(())
|
||
|
|
self.assertFalse(a)
|
||
|
|
a = BitStream((0, 1, '0', '1'))
|
||
|
|
self.assertEqual('0b0111', a)
|
||
|
|
a.replace((True, True), [])
|
||
|
|
self.assertEqual(a, (False, True))
|
||
|
|
|
||
|
|
def testCut(self):
|
||
|
|
a = BitStream('0x00112233445')
|
||
|
|
b = list(a.cut(8))
|
||
|
|
self.assertEqual(b, ['0x00', '0x11', '0x22', '0x33', '0x44'])
|
||
|
|
b = list(a.cut(4, 8, 16))
|
||
|
|
self.assertEqual(b, ['0x1', '0x1'])
|
||
|
|
b = list(a.cut(4, 0, 44, 4))
|
||
|
|
self.assertEqual(b, ['0x0', '0x0', '0x1', '0x1'])
|
||
|
|
a = BitStream()
|
||
|
|
b = list(a.cut(10))
|
||
|
|
self.assertTrue(not b)
|
||
|
|
|
||
|
|
def testCutErrors(self):
|
||
|
|
a = BitStream('0b1')
|
||
|
|
b = a.cut(1, 1, 2)
|
||
|
|
self.assertRaises(ValueError, next, b)
|
||
|
|
b = a.cut(1, -2, 1)
|
||
|
|
self.assertRaises(ValueError, next, b)
|
||
|
|
b = a.cut(0)
|
||
|
|
self.assertRaises(ValueError, next, b)
|
||
|
|
b = a.cut(1, count=-1)
|
||
|
|
self.assertRaises(ValueError, next, b)
|
||
|
|
|
||
|
|
def testCutProblem(self):
|
||
|
|
s = BitStream('0x1234')
|
||
|
|
for n in list(s.cut(4)):
|
||
|
|
s.prepend(n)
|
||
|
|
self.assertEqual(s, '0x43211234')
|
||
|
|
|
||
|
|
def testJoinFunctions(self):
|
||
|
|
a = BitStream().join(['0xa', '0xb', '0b1111'])
|
||
|
|
self.assertEqual(a, '0xabf')
|
||
|
|
a = BitStream('0b1').join(['0b0' for i in range(10)])
|
||
|
|
self.assertEqual(a, '0b0101010101010101010')
|
||
|
|
a = BitStream('0xff').join([])
|
||
|
|
self.assertFalse(a)
|
||
|
|
|
||
|
|
def testAddingBitpos(self):
|
||
|
|
a = BitStream('0xff')
|
||
|
|
b = BitStream('0x00')
|
||
|
|
a.bitpos = b.bitpos = 8
|
||
|
|
c = a + b
|
||
|
|
self.assertEqual(c.bitpos, 0)
|
||
|
|
|
||
|
|
def testIntelligentRead1(self):
|
||
|
|
a = BitStream(uint=123, length=23)
|
||
|
|
u = a.read('uint:23')
|
||
|
|
self.assertEqual(u, 123)
|
||
|
|
self.assertEqual(a.pos, a.len)
|
||
|
|
b = BitStream(int=-12, length=44)
|
||
|
|
i = b.read('int:44')
|
||
|
|
self.assertEqual(i, -12)
|
||
|
|
self.assertEqual(b.pos, b.len)
|
||
|
|
u2, i2 = (a + b).readlist('uint:23, int:44')
|
||
|
|
self.assertEqual((u2, i2), (123, -12))
|
||
|
|
|
||
|
|
def testIntelligentRead2(self):
|
||
|
|
a = BitStream(ue=822)
|
||
|
|
u = a.read('ue')
|
||
|
|
self.assertEqual(u, 822)
|
||
|
|
self.assertEqual(a.pos, a.len)
|
||
|
|
b = BitStream(se=-1001)
|
||
|
|
s = b.read('se')
|
||
|
|
self.assertEqual(s, -1001)
|
||
|
|
self.assertEqual(b.pos, b.len)
|
||
|
|
s, u1, u2 = (b + 2 * a).readlist('se, ue, ue')
|
||
|
|
self.assertEqual((s, u1, u2), (-1001, 822, 822))
|
||
|
|
|
||
|
|
def testIntelligentRead3(self):
|
||
|
|
a = BitStream('0x123') + '0b11101'
|
||
|
|
h = a.read('hex:12')
|
||
|
|
self.assertEqual(h, '123')
|
||
|
|
b = a.read('bin: 5')
|
||
|
|
self.assertEqual(b, '11101')
|
||
|
|
c = '0b' + b + a
|
||
|
|
b, h = c.readlist('bin:5, hex:12')
|
||
|
|
self.assertEqual((b, h), ('11101', '123'))
|
||
|
|
|
||
|
|
def testIntelligentRead4(self):
|
||
|
|
a = BitStream('0o007')
|
||
|
|
o = a.read('oct:9')
|
||
|
|
self.assertEqual(o, '007')
|
||
|
|
self.assertEqual(a.pos, a.len)
|
||
|
|
|
||
|
|
def testIntelligentRead5(self):
|
||
|
|
a = BitStream('0x00112233')
|
||
|
|
c0, c1, c2 = a.readlist('bits:8, bits:8, bits:16')
|
||
|
|
self.assertEqual((c0, c1, c2), (BitStream('0x00'), BitStream('0x11'), BitStream('0x2233')))
|
||
|
|
a.pos = 0
|
||
|
|
c = a.read('bits:16')
|
||
|
|
self.assertEqual(c, BitStream('0x0011'))
|
||
|
|
|
||
|
|
def testIntelligentRead6(self):
|
||
|
|
a = BitStream('0b000111000')
|
||
|
|
b1, b2, b3 = a.readlist('bin :3, int: 3, int:3')
|
||
|
|
self.assertEqual(b1, '000')
|
||
|
|
self.assertEqual(b2, -1)
|
||
|
|
self.assertEqual(b3, 0)
|
||
|
|
|
||
|
|
def testIntelligentRead7(self):
|
||
|
|
a = BitStream('0x1234')
|
||
|
|
a1, a2, a3, a4 = a.readlist('bin:0, oct:0, hex:0, bits:0')
|
||
|
|
self.assertTrue(a1 == a2 == a3 == '')
|
||
|
|
self.assertFalse(a4)
|
||
|
|
self.assertRaises(ValueError, a.read, 'int:0')
|
||
|
|
self.assertRaises(ValueError, a.read, 'uint:0')
|
||
|
|
self.assertEqual(a.pos, 0)
|
||
|
|
|
||
|
|
def testIntelligentRead8(self):
|
||
|
|
a = BitStream('0x123456')
|
||
|
|
for t in ['hex:1', 'oct:1', 'hex4', '-5', 'fred', 'bin:-2',
|
||
|
|
'uint:p', 'uint:-2', 'int:u', 'int:-3', 'ses', 'uee', '-14']:
|
||
|
|
self.assertRaises(ValueError, a.read, t)
|
||
|
|
|
||
|
|
def testIntelligentRead9(self):
|
||
|
|
a = BitStream('0xff')
|
||
|
|
self.assertEqual(a.read('intle'), -1)
|
||
|
|
|
||
|
|
def testFillerReads1(self):
|
||
|
|
s = BitStream('0x012345')
|
||
|
|
t = s.read('bits')
|
||
|
|
self.assertEqual(s, t)
|
||
|
|
s.pos = 0
|
||
|
|
a, b = s.readlist('hex:8, hex')
|
||
|
|
self.assertEqual(a, '01')
|
||
|
|
self.assertEqual(b, '2345')
|
||
|
|
self.assertTrue(isinstance(b, str))
|
||
|
|
s.bytepos = 0
|
||
|
|
a, b = s.readlist('bin, hex:20')
|
||
|
|
self.assertEqual(a, '0000')
|
||
|
|
self.assertEqual(b, '12345')
|
||
|
|
self.assertTrue(isinstance(a, str))
|
||
|
|
|
||
|
|
def testFillerReads2(self):
|
||
|
|
s = BitStream('0xabcdef')
|
||
|
|
self.assertRaises(bitstring.Error, s.readlist, 'bits, se')
|
||
|
|
self.assertRaises(bitstring.Error, s.readlist, 'hex:4, bits, ue, bin:4')
|
||
|
|
s.pos = 0
|
||
|
|
self.assertRaises(bitstring.Error, s.readlist, 'bin, bin')
|
||
|
|
|
||
|
|
def testIntelligentPeek(self):
|
||
|
|
a = BitStream('0b01, 0x43, 0o4, uint:23=2, se=5, ue=3')
|
||
|
|
b, c, e = a.peeklist('bin:2, hex:8, oct:3')
|
||
|
|
self.assertEqual((b, c, e), ('01', '43', '4'))
|
||
|
|
self.assertEqual(a.pos, 0)
|
||
|
|
a.pos = 13
|
||
|
|
f, g, h = a.peeklist('uint:23, se, ue')
|
||
|
|
self.assertEqual((f, g, h), (2, 5, 3))
|
||
|
|
self.assertEqual(a.pos, 13)
|
||
|
|
|
||
|
|
def testReadMultipleBits(self):
|
||
|
|
s = BitStream('0x123456789abcdef')
|
||
|
|
a, b = s.readlist([4, 4])
|
||
|
|
self.assertEqual(a, '0x1')
|
||
|
|
self.assertEqual(b, '0x2')
|
||
|
|
c, d, e = s.readlist([8, 16, 8])
|
||
|
|
self.assertEqual(c, '0x34')
|
||
|
|
self.assertEqual(d, '0x5678')
|
||
|
|
self.assertEqual(e, '0x9a')
|
||
|
|
|
||
|
|
def testPeekMultipleBits(self):
|
||
|
|
s = BitStream('0b1101, 0o721, 0x2234567')
|
||
|
|
a, b, c, d = s.peeklist([2, 1, 1, 9])
|
||
|
|
self.assertEqual(a, '0b11')
|
||
|
|
self.assertEqual(bool(b), False)
|
||
|
|
self.assertEqual(bool(c), True)
|
||
|
|
self.assertEqual(d, '0o721')
|
||
|
|
self.assertEqual(s.pos, 0)
|
||
|
|
a, b = s.peeklist([4, 9])
|
||
|
|
self.assertEqual(a, '0b1101')
|
||
|
|
self.assertEqual(b, '0o721')
|
||
|
|
s.pos = 13
|
||
|
|
a, b = s.peeklist([16, 8])
|
||
|
|
self.assertEqual(a, '0x2234')
|
||
|
|
self.assertEqual(b, '0x56')
|
||
|
|
self.assertEqual(s.pos, 13)
|
||
|
|
|
||
|
|
def testDifficultPrepends(self):
|
||
|
|
a = BitStream('0b1101011')
|
||
|
|
b = BitStream()
|
||
|
|
for i in range(10):
|
||
|
|
b.prepend(a)
|
||
|
|
self.assertEqual(b, a * 10)
|
||
|
|
|
||
|
|
def testPackingWrongNumberOfThings(self):
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'bin:1')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, '', 100)
|
||
|
|
|
||
|
|
def testPackWithVariousKeys(self):
|
||
|
|
a = pack('uint10', uint10='0b1')
|
||
|
|
self.assertEqual(a, '0b1')
|
||
|
|
b = pack('0b110', **{'0b110': '0xfff'})
|
||
|
|
self.assertEqual(b, '0xfff')
|
||
|
|
|
||
|
|
def testPackWithVariableLength(self):
|
||
|
|
for i in range(1, 11):
|
||
|
|
a = pack('uint:n', 0, n=i)
|
||
|
|
self.assertEqual(a.bin, '0' * i)
|
||
|
|
|
||
|
|
def testToBytes(self):
|
||
|
|
a = BitStream(bytes=b'\xab\x00')
|
||
|
|
b = a.tobytes()
|
||
|
|
self.assertEqual(a.bytes, b)
|
||
|
|
for i in range(7):
|
||
|
|
del a[-1:]
|
||
|
|
self.assertEqual(a.tobytes(), b'\xab\x00')
|
||
|
|
del a[-1:]
|
||
|
|
self.assertEqual(a.tobytes(), b'\xab')
|
||
|
|
|
||
|
|
def testToFile(self):
|
||
|
|
a = BitStream('0x0000ff')[:17]
|
||
|
|
f = open('temp_bitstring_unit_testing_file', 'wb')
|
||
|
|
a.tofile(f)
|
||
|
|
f.close()
|
||
|
|
b = BitStream(filename='temp_bitstring_unit_testing_file')
|
||
|
|
self.assertEqual(b, '0x000080')
|
||
|
|
|
||
|
|
a = BitStream('0x911111')
|
||
|
|
del a[:1]
|
||
|
|
self.assertEqual(a + '0b0', '0x222222')
|
||
|
|
f = open('temp_bitstring_unit_testing_file', 'wb')
|
||
|
|
a.tofile(f)
|
||
|
|
f.close()
|
||
|
|
b = BitStream(filename='temp_bitstring_unit_testing_file')
|
||
|
|
self.assertEqual(b, '0x222222')
|
||
|
|
os.remove('temp_bitstring_unit_testing_file')
|
||
|
|
|
||
|
|
#def testToFileWithLargerFile(self):
|
||
|
|
# a = BitStream(length=16000000)
|
||
|
|
# a[1] = '0b1'
|
||
|
|
# a[-2] = '0b1'
|
||
|
|
# f = open('temp_bitstring_unit_testing_file' ,'wb')
|
||
|
|
# a.tofile(f)
|
||
|
|
# f.close()
|
||
|
|
# b = BitStream(filename='temp_bitstring_unit_testing_file')
|
||
|
|
# self.assertEqual(b.len, 16000000)
|
||
|
|
# self.assertEqual(b[1], True)
|
||
|
|
#
|
||
|
|
# f = open('temp_bitstring_unit_testing_file' ,'wb')
|
||
|
|
# a[1:].tofile(f)
|
||
|
|
# f.close()
|
||
|
|
# b = BitStream(filename='temp_bitstring_unit_testing_file')
|
||
|
|
# self.assertEqual(b.len, 16000000)
|
||
|
|
# self.assertEqual(b[0], True)
|
||
|
|
# os.remove('temp_bitstring_unit_testing_file')
|
||
|
|
|
||
|
|
def testTokenParser(self):
|
||
|
|
tp = bitstring.tokenparser
|
||
|
|
self.assertEqual(tp('hex'), (True, [('hex', None, None)]))
|
||
|
|
self.assertEqual(tp('hex=14'), (True, [('hex', None, '14')]))
|
||
|
|
self.assertEqual(tp('se'), (False, [('se', None, None)]))
|
||
|
|
self.assertEqual(tp('ue=12'), (False, [('ue', None, '12')]))
|
||
|
|
self.assertEqual(tp('0xef'), (False, [('0x', None, 'ef')]))
|
||
|
|
self.assertEqual(tp('uint:12'), (False, [('uint', 12, None)]))
|
||
|
|
self.assertEqual(tp('int:30=-1'), (False, [('int', 30, '-1')]))
|
||
|
|
self.assertEqual(tp('bits:10'), (False, [('bits', 10, None)]))
|
||
|
|
self.assertEqual(tp('bits:10'), (False, [('bits', 10, None)]))
|
||
|
|
self.assertEqual(tp('123'), (False, [('uint', 123, None)]))
|
||
|
|
self.assertEqual(tp('123'), (False, [('uint', 123, None)]))
|
||
|
|
self.assertRaises(ValueError, tp, 'hex12')
|
||
|
|
self.assertEqual(tp('hex12', ('hex12',)), (False, [('hex12', None, None)]))
|
||
|
|
self.assertEqual(tp('2*bits:6'), (False, [('bits', 6, None), ('bits', 6, None)]))
|
||
|
|
|
||
|
|
def testAutoFromFileObject(self):
|
||
|
|
with open('test.m1v', 'rb') as f:
|
||
|
|
s = ConstBitStream(f, offset=32, length=12)
|
||
|
|
self.assertEqual(s.uint, 352)
|
||
|
|
t = ConstBitStream('0xf') + f
|
||
|
|
self.assertTrue(t.startswith('0xf000001b3160'))
|
||
|
|
s2 = ConstBitStream(f)
|
||
|
|
t2 = BitStream('0xc')
|
||
|
|
t2.prepend(s2)
|
||
|
|
self.assertTrue(t2.startswith('0x000001b3'))
|
||
|
|
self.assertTrue(t2.endswith('0xc'))
|
||
|
|
with open('test.m1v', 'rb') as b:
|
||
|
|
u = BitStream(bytes=b.read())
|
||
|
|
# TODO: u == s2 is much slower than u.bytes == s2.bytes
|
||
|
|
self.assertEqual(u.bytes, s2.bytes)
|
||
|
|
|
||
|
|
def testFileBasedCopy(self):
|
||
|
|
with open('smalltestfile', 'rb') as f:
|
||
|
|
s = BitStream(f)
|
||
|
|
t = BitStream(s)
|
||
|
|
s.prepend('0b1')
|
||
|
|
self.assertEqual(s[1:], t)
|
||
|
|
s = BitStream(f)
|
||
|
|
t = copy.copy(s)
|
||
|
|
t.append('0b1')
|
||
|
|
self.assertEqual(s, t[:-1])
|
||
|
|
|
||
|
|
def testBigEndianSynonyms(self):
|
||
|
|
s = BitStream('0x12318276ef')
|
||
|
|
self.assertEqual(s.int, s.intbe)
|
||
|
|
self.assertEqual(s.uint, s.uintbe)
|
||
|
|
s = BitStream(intbe=-100, length=16)
|
||
|
|
self.assertEqual(s, 'int:16=-100')
|
||
|
|
s = BitStream(uintbe=13, length=24)
|
||
|
|
self.assertEqual(s, 'int:24=13')
|
||
|
|
s = BitStream('uintbe:32=1000')
|
||
|
|
self.assertEqual(s, 'uint:32=1000')
|
||
|
|
s = BitStream('intbe:8=2')
|
||
|
|
self.assertEqual(s, 'int:8=2')
|
||
|
|
self.assertEqual(s.read('intbe'), 2)
|
||
|
|
s.pos = 0
|
||
|
|
self.assertEqual(s.read('uintbe'), 2)
|
||
|
|
|
||
|
|
def testBigEndianSynonymErrors(self):
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, uintbe=100, length=15)
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, intbe=100, length=15)
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, 'uintbe:17=100')
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, 'intbe:7=2')
|
||
|
|
s = BitStream('0b1')
|
||
|
|
self.assertRaises(bitstring.InterpretError, s._getintbe)
|
||
|
|
self.assertRaises(bitstring.InterpretError, s._getuintbe)
|
||
|
|
self.assertRaises(ValueError, s.read, 'uintbe')
|
||
|
|
self.assertRaises(ValueError, s.read, 'intbe')
|
||
|
|
|
||
|
|
def testLittleEndianUint(self):
|
||
|
|
s = BitStream(uint=100, length=16)
|
||
|
|
self.assertEqual(s.uintle, 25600)
|
||
|
|
s = BitStream(uintle=100, length=16)
|
||
|
|
self.assertEqual(s.uint, 25600)
|
||
|
|
self.assertEqual(s.uintle, 100)
|
||
|
|
s.uintle += 5
|
||
|
|
self.assertEqual(s.uintle, 105)
|
||
|
|
s = BitStream('uintle:32=999')
|
||
|
|
self.assertEqual(s.uintle, 999)
|
||
|
|
s.byteswap()
|
||
|
|
self.assertEqual(s.uint, 999)
|
||
|
|
s = pack('uintle:24', 1001)
|
||
|
|
self.assertEqual(s.uintle, 1001)
|
||
|
|
self.assertEqual(s.length, 24)
|
||
|
|
self.assertEqual(s.read('uintle'), 1001)
|
||
|
|
|
||
|
|
def testLittleEndianInt(self):
|
||
|
|
s = BitStream(int=100, length=16)
|
||
|
|
self.assertEqual(s.intle, 25600)
|
||
|
|
s = BitStream(intle=100, length=16)
|
||
|
|
self.assertEqual(s.int, 25600)
|
||
|
|
self.assertEqual(s.intle, 100)
|
||
|
|
s.intle += 5
|
||
|
|
self.assertEqual(s.intle, 105)
|
||
|
|
s = BitStream('intle:32=999')
|
||
|
|
self.assertEqual(s.intle, 999)
|
||
|
|
s.byteswap()
|
||
|
|
self.assertEqual(s.int, 999)
|
||
|
|
s = pack('intle:24', 1001)
|
||
|
|
self.assertEqual(s.intle, 1001)
|
||
|
|
self.assertEqual(s.length, 24)
|
||
|
|
self.assertEqual(s.read('intle'), 1001)
|
||
|
|
|
||
|
|
def testLittleEndianErrors(self):
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, 'uintle:15=10')
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, 'intle:31=-999')
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, uintle=100, length=15)
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, intle=100, length=15)
|
||
|
|
s = BitStream('0xfff')
|
||
|
|
self.assertRaises(bitstring.InterpretError, s._getintle)
|
||
|
|
self.assertRaises(bitstring.InterpretError, s._getuintle)
|
||
|
|
self.assertRaises(ValueError, s.read, 'uintle')
|
||
|
|
self.assertRaises(ValueError, s.read, 'intle')
|
||
|
|
|
||
|
|
def testStructTokens1(self):
|
||
|
|
self.assertEqual(pack('<b', 23), BitStream('intle:8=23'))
|
||
|
|
self.assertEqual(pack('<B', 23), BitStream('uintle:8=23'))
|
||
|
|
self.assertEqual(pack('<h', 23), BitStream('intle:16=23'))
|
||
|
|
self.assertEqual(pack('<H', 23), BitStream('uintle:16=23'))
|
||
|
|
self.assertEqual(pack('<l', 23), BitStream('intle:32=23'))
|
||
|
|
self.assertEqual(pack('<L', 23), BitStream('uintle:32=23'))
|
||
|
|
self.assertEqual(pack('<q', 23), BitStream('intle:64=23'))
|
||
|
|
self.assertEqual(pack('<Q', 23), BitStream('uintle:64=23'))
|
||
|
|
self.assertEqual(pack('>b', 23), BitStream('intbe:8=23'))
|
||
|
|
self.assertEqual(pack('>B', 23), BitStream('uintbe:8=23'))
|
||
|
|
self.assertEqual(pack('>h', 23), BitStream('intbe:16=23'))
|
||
|
|
self.assertEqual(pack('>H', 23), BitStream('uintbe:16=23'))
|
||
|
|
self.assertEqual(pack('>l', 23), BitStream('intbe:32=23'))
|
||
|
|
self.assertEqual(pack('>L', 23), BitStream('uintbe:32=23'))
|
||
|
|
self.assertEqual(pack('>q', 23), BitStream('intbe:64=23'))
|
||
|
|
self.assertEqual(pack('>Q', 23), BitStream('uintbe:64=23'))
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, '<B', -1)
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, '<H', -1)
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, '<L', -1)
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, '<Q', -1)
|
||
|
|
|
||
|
|
def testStructTokens2(self):
|
||
|
|
endianness = sys.byteorder
|
||
|
|
sys.byteorder = 'little'
|
||
|
|
self.assertEqual(pack('@b', 23), BitStream('intle:8=23'))
|
||
|
|
self.assertEqual(pack('@B', 23), BitStream('uintle:8=23'))
|
||
|
|
self.assertEqual(pack('@h', 23), BitStream('intle:16=23'))
|
||
|
|
self.assertEqual(pack('@H', 23), BitStream('uintle:16=23'))
|
||
|
|
self.assertEqual(pack('@l', 23), BitStream('intle:32=23'))
|
||
|
|
self.assertEqual(pack('@L', 23), BitStream('uintle:32=23'))
|
||
|
|
self.assertEqual(pack('@q', 23), BitStream('intle:64=23'))
|
||
|
|
self.assertEqual(pack('@Q', 23), BitStream('uintle:64=23'))
|
||
|
|
sys.byteorder = 'big'
|
||
|
|
self.assertEqual(pack('@b', 23), BitStream('intbe:8=23'))
|
||
|
|
self.assertEqual(pack('@B', 23), BitStream('uintbe:8=23'))
|
||
|
|
self.assertEqual(pack('@h', 23), BitStream('intbe:16=23'))
|
||
|
|
self.assertEqual(pack('@H', 23), BitStream('uintbe:16=23'))
|
||
|
|
self.assertEqual(pack('@l', 23), BitStream('intbe:32=23'))
|
||
|
|
self.assertEqual(pack('@L', 23), BitStream('uintbe:32=23'))
|
||
|
|
self.assertEqual(pack('@q', 23), BitStream('intbe:64=23'))
|
||
|
|
self.assertEqual(pack('@Q', 23), BitStream('uintbe:64=23'))
|
||
|
|
sys.byteorder = endianness
|
||
|
|
|
||
|
|
def testNativeEndianness(self):
|
||
|
|
s = pack('@2L', 40, 40)
|
||
|
|
if sys.byteorder == 'little':
|
||
|
|
self.assertEqual(s, pack('<2L', 40, 40))
|
||
|
|
else:
|
||
|
|
self.assertEqual(sys.byteorder, 'big')
|
||
|
|
self.assertEqual(s, pack('>2L', 40, 40))
|
||
|
|
|
||
|
|
def testStructTokens2(self):
|
||
|
|
s = pack('>hhl', 1, 2, 3)
|
||
|
|
a, b, c = s.unpack('>hhl')
|
||
|
|
self.assertEqual((a, b, c), (1, 2, 3))
|
||
|
|
s = pack('<QL, >Q \tL', 1001, 43, 21, 9999)
|
||
|
|
self.assertEqual(s.unpack('<QL, >QL'), [1001, 43, 21, 9999])
|
||
|
|
|
||
|
|
def testStructTokensMultiplicativeFactors(self):
|
||
|
|
s = pack('<2h', 1, 2)
|
||
|
|
a, b = s.unpack('<2h')
|
||
|
|
self.assertEqual((a, b), (1, 2))
|
||
|
|
s = pack('<100q', *range(100))
|
||
|
|
self.assertEqual(s.len, 100 * 64)
|
||
|
|
self.assertEqual(s[44*64:45*64].uintle, 44)
|
||
|
|
s = pack('@L0B2h', 5, 5, 5)
|
||
|
|
self.assertEqual(s.unpack('@Lhh'), [5, 5, 5])
|
||
|
|
|
||
|
|
def testStructTokensErrors(self):
|
||
|
|
for f in ['>>q', '<>q', 'q>', '2q', 'q', '>-2q', '@a', '>int:8', '>q2']:
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, f, 100)
|
||
|
|
|
||
|
|
def testImmutableBitStreams(self):
|
||
|
|
a = ConstBitStream('0x012345')
|
||
|
|
self.assertEqual(a, '0x012345')
|
||
|
|
b = BitStream('0xf') + a
|
||
|
|
self.assertEqual(b, '0xf012345')
|
||
|
|
try:
|
||
|
|
a.append(b)
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.prepend(b)
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a[0] = '0b1'
|
||
|
|
self.assertTrue(False)
|
||
|
|
except TypeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
del a[5]
|
||
|
|
self.assertTrue(False)
|
||
|
|
except TypeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.replace('0b1', '0b0')
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.insert('0b11', 4)
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.reverse()
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.reversebytes()
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
self.assertEqual(a, '0x012345')
|
||
|
|
self.assertTrue(isinstance(a, ConstBitStream))
|
||
|
|
|
||
|
|
def testReverseBytes(self):
|
||
|
|
a = BitStream('0x123456')
|
||
|
|
a.byteswap()
|
||
|
|
self.assertEqual(a, '0x563412')
|
||
|
|
b = a + '0b1'
|
||
|
|
b.byteswap()
|
||
|
|
self.assertEqual('0x123456, 0b1', b)
|
||
|
|
a = BitStream('0x54')
|
||
|
|
a.byteswap()
|
||
|
|
self.assertEqual(a, '0x54')
|
||
|
|
a = BitStream()
|
||
|
|
a.byteswap()
|
||
|
|
self.assertFalse(a)
|
||
|
|
|
||
|
|
def testReverseBytes2(self):
|
||
|
|
a = BitStream()
|
||
|
|
a.byteswap()
|
||
|
|
self.assertFalse(a)
|
||
|
|
a = BitStream('0x00112233')
|
||
|
|
a.byteswap(0, 0, 16)
|
||
|
|
self.assertEqual(a, '0x11002233')
|
||
|
|
a.byteswap(0, 4, 28)
|
||
|
|
self.assertEqual(a, '0x12302103')
|
||
|
|
a.byteswap(start=0, end=18)
|
||
|
|
self.assertEqual(a, '0x30122103')
|
||
|
|
self.assertRaises(ValueError, a.byteswap, 0, 10, 2)
|
||
|
|
self.assertRaises(ValueError, a.byteswap, 0, -4, 4)
|
||
|
|
self.assertRaises(ValueError, a.byteswap, 0, 24, 48)
|
||
|
|
a.byteswap(0, 24)
|
||
|
|
self.assertEqual(a, '0x30122103')
|
||
|
|
a.byteswap(0, 11, 11)
|
||
|
|
self.assertEqual(a, '0x30122103')
|
||
|
|
|
||
|
|
def testCapitalsInPack(self):
|
||
|
|
a = pack('A', A='0b1')
|
||
|
|
self.assertEqual(a, '0b1')
|
||
|
|
format = 'bits:4=BL_OFFT, uint:12=width, uint:12=height'
|
||
|
|
d = {'BL_OFFT': '0b1011', 'width': 352, 'height': 288}
|
||
|
|
s = bitstring.pack(format, **d)
|
||
|
|
self.assertEqual(s, '0b1011, uint:12=352, uint:12=288')
|
||
|
|
a = pack('0X0, uint:8, hex', 45, '0XABcD')
|
||
|
|
self.assertEqual(a, '0x0, uint:8=45, 0xabCD')
|
||
|
|
|
||
|
|
def testOtherCapitals(self):
|
||
|
|
a = ConstBitStream('0XABC, 0O0, 0B11')
|
||
|
|
self.assertEqual(a, 'hex=0Xabc, oct=0, bin=0B11')
|
||
|
|
|
||
|
|
def testEfficientOverwrite(self):
|
||
|
|
a = BitStream(1000000000)
|
||
|
|
a.overwrite([1], 123456)
|
||
|
|
self.assertEqual(a[123456], True)
|
||
|
|
a.overwrite('0xff', 1)
|
||
|
|
self.assertEqual(a[0:32:1], '0x7f800000')
|
||
|
|
b = BitStream('0xffff')
|
||
|
|
b.overwrite('0x0000')
|
||
|
|
self.assertEqual(b, '0x0000')
|
||
|
|
self.assertEqual(b.pos, 16)
|
||
|
|
c = BitStream(length=1000)
|
||
|
|
c.overwrite('0xaaaaaaaaaaaa', 81)
|
||
|
|
self.assertEqual(c[81:81 + 6 * 8], '0xaaaaaaaaaaaa')
|
||
|
|
self.assertEqual(len(list(c.findall('0b1'))), 24)
|
||
|
|
s = BitStream(length=1000)
|
||
|
|
s = s[5:]
|
||
|
|
s.overwrite('0xffffff', 500)
|
||
|
|
s.pos = 500
|
||
|
|
self.assertEqual(s.read(4 * 8), '0xffffff00')
|
||
|
|
s.overwrite('0xff', 502)
|
||
|
|
self.assertEqual(s[502:518], '0xffff')
|
||
|
|
|
||
|
|
def testPeekAndReadListErrors(self):
|
||
|
|
a = BitStream('0x123456')
|
||
|
|
self.assertRaises(ValueError, a.read, 'hex:8, hex:8')
|
||
|
|
self.assertRaises(ValueError, a.peek, 'hex:8, hex:8')
|
||
|
|
self.assertRaises(TypeError, a.read, 10, 12)
|
||
|
|
self.assertRaises(TypeError, a.peek, 12, 14)
|
||
|
|
self.assertRaises(TypeError, a.read, 8, 8)
|
||
|
|
self.assertRaises(TypeError, a.peek, 80, 80)
|
||
|
|
|
||
|
|
def testStartswith(self):
|
||
|
|
a = BitStream()
|
||
|
|
self.assertTrue(a.startswith(BitStream()))
|
||
|
|
self.assertFalse(a.startswith('0b0'))
|
||
|
|
a = BitStream('0x12ff')
|
||
|
|
self.assertTrue(a.startswith('0x1'))
|
||
|
|
self.assertTrue(a.startswith('0b0001001'))
|
||
|
|
self.assertTrue(a.startswith('0x12ff'))
|
||
|
|
self.assertFalse(a.startswith('0x12ff, 0b1'))
|
||
|
|
self.assertFalse(a.startswith('0x2'))
|
||
|
|
|
||
|
|
def testStartswithStartEnd(self):
|
||
|
|
s = BitStream('0x123456')
|
||
|
|
self.assertTrue(s.startswith('0x234', 4))
|
||
|
|
self.assertFalse(s.startswith('0x123', end=11))
|
||
|
|
self.assertTrue(s.startswith('0x123', end=12))
|
||
|
|
self.assertTrue(s.startswith('0x34', 8, 16))
|
||
|
|
self.assertFalse(s.startswith('0x34', 7, 16))
|
||
|
|
self.assertFalse(s.startswith('0x34', 9, 16))
|
||
|
|
self.assertFalse(s.startswith('0x34', 8, 15))
|
||
|
|
|
||
|
|
def testEndswith(self):
|
||
|
|
a = BitStream()
|
||
|
|
self.assertTrue(a.endswith(''))
|
||
|
|
self.assertFalse(a.endswith(BitStream('0b1')))
|
||
|
|
a = BitStream('0xf2341')
|
||
|
|
self.assertTrue(a.endswith('0x41'))
|
||
|
|
self.assertTrue(a.endswith('0b001'))
|
||
|
|
self.assertTrue(a.endswith('0xf2341'))
|
||
|
|
self.assertFalse(a.endswith('0x1f2341'))
|
||
|
|
self.assertFalse(a.endswith('0o34'))
|
||
|
|
|
||
|
|
def testEndswithStartEnd(self):
|
||
|
|
s = BitStream('0x123456')
|
||
|
|
self.assertTrue(s.endswith('0x234', end=16))
|
||
|
|
self.assertFalse(s.endswith('0x456', start=13))
|
||
|
|
self.assertTrue(s.endswith('0x456', start=12))
|
||
|
|
self.assertTrue(s.endswith('0x34', 8, 16))
|
||
|
|
self.assertTrue(s.endswith('0x34', 7, 16))
|
||
|
|
self.assertFalse(s.endswith('0x34', 9, 16))
|
||
|
|
self.assertFalse(s.endswith('0x34', 8, 15))
|
||
|
|
|
||
|
|
def testUnhashability(self):
|
||
|
|
s = BitStream('0xf')
|
||
|
|
self.assertRaises(TypeError, set, [s])
|
||
|
|
self.assertRaises(TypeError, hash, [s])
|
||
|
|
|
||
|
|
def testConstBitStreamSetCreation(self):
|
||
|
|
sl = [ConstBitStream(uint=i, length=7) for i in range(15)]
|
||
|
|
s = set(sl)
|
||
|
|
self.assertEqual(len(s), 15)
|
||
|
|
s.add(ConstBitStream('0b0000011'))
|
||
|
|
self.assertEqual(len(s), 15)
|
||
|
|
self.assertRaises(TypeError, s.add, BitStream('0b0000011'))
|
||
|
|
|
||
|
|
def testConstBitStreamFunctions(self):
|
||
|
|
s = ConstBitStream('0xf, 0b1')
|
||
|
|
self.assertEqual(type(s), ConstBitStream)
|
||
|
|
t = copy.copy(s)
|
||
|
|
self.assertEqual(type(t), ConstBitStream)
|
||
|
|
a = s + '0o3'
|
||
|
|
self.assertEqual(type(a), ConstBitStream)
|
||
|
|
b = a[0:4]
|
||
|
|
self.assertEqual(type(b), ConstBitStream)
|
||
|
|
b = a[4:3]
|
||
|
|
self.assertEqual(type(b), ConstBitStream)
|
||
|
|
b = a[5:2:-1]
|
||
|
|
self.assertEqual(type(b), ConstBitStream)
|
||
|
|
b = ~a
|
||
|
|
self.assertEqual(type(b), ConstBitStream)
|
||
|
|
b = a << 2
|
||
|
|
self.assertEqual(type(b), ConstBitStream)
|
||
|
|
b = a >> 2
|
||
|
|
self.assertEqual(type(b), ConstBitStream)
|
||
|
|
b = a * 2
|
||
|
|
self.assertEqual(type(b), ConstBitStream)
|
||
|
|
b = a * 0
|
||
|
|
self.assertEqual(type(b), ConstBitStream)
|
||
|
|
b = a & ~a
|
||
|
|
self.assertEqual(type(b), ConstBitStream)
|
||
|
|
b = a | ~a
|
||
|
|
self.assertEqual(type(b), ConstBitStream)
|
||
|
|
b = a ^ ~a
|
||
|
|
self.assertEqual(type(b), ConstBitStream)
|
||
|
|
b = a._slice(4, 4)
|
||
|
|
self.assertEqual(type(b), ConstBitStream)
|
||
|
|
b = a.read(4)
|
||
|
|
self.assertEqual(type(b), ConstBitStream)
|
||
|
|
|
||
|
|
def testConstBitStreamProperties(self):
|
||
|
|
a = ConstBitStream('0x123123')
|
||
|
|
try:
|
||
|
|
a.hex = '0x234'
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.oct = '0o234'
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.bin = '0b101'
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.ue = 3453
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.se = -123
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.int = 432
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.uint = 4412
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.intle = 123
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.uintle = 4412
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.intbe = 123
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.uintbe = 4412
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.intne = 123
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.uintne = 4412
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
try:
|
||
|
|
a.bytes = b'hello'
|
||
|
|
self.assertTrue(False)
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
|
||
|
|
def testConstBitStreamMisc(self):
|
||
|
|
a = ConstBitStream('0xf')
|
||
|
|
b = a
|
||
|
|
a += '0xe'
|
||
|
|
self.assertEqual(b, '0xf')
|
||
|
|
self.assertEqual(a, '0xfe')
|
||
|
|
c = BitStream(a)
|
||
|
|
self.assertEqual(a, c)
|
||
|
|
a = ConstBitStream('0b1')
|
||
|
|
a._append(a)
|
||
|
|
self.assertEqual(a, '0b11')
|
||
|
|
self.assertEqual(type(a), ConstBitStream)
|
||
|
|
a._prepend(a)
|
||
|
|
self.assertEqual(a, '0b1111')
|
||
|
|
self.assertEqual(type(a), ConstBitStream)
|
||
|
|
|
||
|
|
def testConstBitStreamHashibility(self):
|
||
|
|
a = ConstBitStream('0x1')
|
||
|
|
b = ConstBitStream('0x2')
|
||
|
|
c = ConstBitStream('0x1')
|
||
|
|
c.pos = 3
|
||
|
|
s = set((a, b, c))
|
||
|
|
self.assertEqual(len(s), 2)
|
||
|
|
self.assertEqual(hash(a), hash(c))
|
||
|
|
|
||
|
|
def testConstBitStreamCopy(self):
|
||
|
|
a = ConstBitStream('0xabc')
|
||
|
|
a.pos = 11
|
||
|
|
b = copy.copy(a)
|
||
|
|
b.pos = 4
|
||
|
|
self.assertEqual(id(a._datastore), id(b._datastore))
|
||
|
|
self.assertEqual(a.pos, 11)
|
||
|
|
self.assertEqual(b.pos, 4)
|
||
|
|
|
||
|
|
def testPython26stuff(self):
|
||
|
|
s = BitStream('0xff')
|
||
|
|
self.assertTrue(isinstance(s.tobytes(), bytes))
|
||
|
|
self.assertTrue(isinstance(s.bytes, bytes))
|
||
|
|
|
||
|
|
def testReadFromBits(self):
|
||
|
|
a = ConstBitStream('0xaabbccdd')
|
||
|
|
b = a.read(8)
|
||
|
|
self.assertEqual(b, '0xaa')
|
||
|
|
self.assertEqual(a[0:8], '0xaa')
|
||
|
|
self.assertEqual(a[-1], True)
|
||
|
|
a.pos = 0
|
||
|
|
self.assertEqual(a.read(4).uint, 10)
|
||
|
|
|
||
|
|
|
||
|
|
class Set(unittest.TestCase):
|
||
|
|
def testSet(self):
|
||
|
|
a = BitStream(length=16)
|
||
|
|
a.set(True, 0)
|
||
|
|
self.assertEqual(a, '0b10000000 00000000')
|
||
|
|
a.set(1, 15)
|
||
|
|
self.assertEqual(a, '0b10000000 00000001')
|
||
|
|
b = a[4:12]
|
||
|
|
b.set(True, 1)
|
||
|
|
self.assertEqual(b, '0b01000000')
|
||
|
|
b.set(True, -1)
|
||
|
|
self.assertEqual(b, '0b01000001')
|
||
|
|
b.set(1, -8)
|
||
|
|
self.assertEqual(b, '0b11000001')
|
||
|
|
self.assertRaises(IndexError, b.set, True, -9)
|
||
|
|
self.assertRaises(IndexError, b.set, True, 8)
|
||
|
|
|
||
|
|
def testSetNegativeIndex(self):
|
||
|
|
a = BitStream(10)
|
||
|
|
a.set(1, -1)
|
||
|
|
self.assertEqual(a.bin, '0000000001')
|
||
|
|
a.set(1, [-1, -10])
|
||
|
|
self.assertEqual(a.bin, '1000000001')
|
||
|
|
self.assertRaises(IndexError, a.set, 1, [-11])
|
||
|
|
|
||
|
|
def testFileBasedSetUnset(self):
|
||
|
|
a = BitStream(filename='test.m1v')
|
||
|
|
a.set(True, (0, 1, 2, 3, 4))
|
||
|
|
self.assertEqual(a[0:32], '0xf80001b3')
|
||
|
|
a = BitStream(filename='test.m1v')
|
||
|
|
a.set(False, (28, 29, 30, 31))
|
||
|
|
self.assertTrue(a.startswith('0x000001b0'))
|
||
|
|
|
||
|
|
def testSetList(self):
|
||
|
|
a = BitStream(length=18)
|
||
|
|
a.set(True, range(18))
|
||
|
|
self.assertEqual(a.int, -1)
|
||
|
|
a.set(False, range(18))
|
||
|
|
self.assertEqual(a.int, 0)
|
||
|
|
|
||
|
|
def testUnset(self):
|
||
|
|
a = BitStream(length=16, int=-1)
|
||
|
|
a.set(False, 0)
|
||
|
|
self.assertEqual(~a, '0b10000000 00000000')
|
||
|
|
a.set(0, 15)
|
||
|
|
self.assertEqual(~a, '0b10000000 00000001')
|
||
|
|
b = a[4:12]
|
||
|
|
b.set(False, 1)
|
||
|
|
self.assertEqual(~b, '0b01000000')
|
||
|
|
b.set(False, -1)
|
||
|
|
self.assertEqual(~b, '0b01000001')
|
||
|
|
b.set(False, -8)
|
||
|
|
self.assertEqual(~b, '0b11000001')
|
||
|
|
self.assertRaises(IndexError, b.set, False, -9)
|
||
|
|
self.assertRaises(IndexError, b.set, False, 8)
|
||
|
|
|
||
|
|
def testSetWholeBitStream(self):
|
||
|
|
a = BitStream(14)
|
||
|
|
a.set(1)
|
||
|
|
self.assertTrue(a.all(1))
|
||
|
|
a.set(0)
|
||
|
|
self.assertTrue(a.all(0))
|
||
|
|
|
||
|
|
|
||
|
|
class Invert(unittest.TestCase):
|
||
|
|
def testInvertBits(self):
|
||
|
|
a = BitStream('0b111000')
|
||
|
|
a.invert(range(a.len))
|
||
|
|
self.assertEqual(a, '0b000111')
|
||
|
|
a.invert([0, 1, -1])
|
||
|
|
self.assertEqual(a, '0b110110')
|
||
|
|
|
||
|
|
def testInvertWholeBitStream(self):
|
||
|
|
a = BitStream('0b11011')
|
||
|
|
a.invert()
|
||
|
|
self.assertEqual(a, '0b00100')
|
||
|
|
|
||
|
|
def testInvertSingleBit(self):
|
||
|
|
a = BitStream('0b000001')
|
||
|
|
a.invert(0)
|
||
|
|
self.assertEqual(a.bin, '100001')
|
||
|
|
a.invert(-1)
|
||
|
|
self.assertEqual(a.bin, '100000')
|
||
|
|
|
||
|
|
def testInvertErrors(self):
|
||
|
|
a = BitStream(10)
|
||
|
|
self.assertRaises(IndexError, a.invert, 10)
|
||
|
|
self.assertRaises(IndexError, a.invert, -11)
|
||
|
|
self.assertRaises(IndexError, a.invert, [1, 2, 10])
|
||
|
|
|
||
|
|
|
||
|
|
#######################
|
||
|
|
|
||
|
|
def testIor(self):
|
||
|
|
a = BitStream('0b1101001')
|
||
|
|
a |= '0b1110000'
|
||
|
|
self.assertEqual(a, '0b1111001')
|
||
|
|
b = a[2:]
|
||
|
|
c = a[1:-1]
|
||
|
|
b |= c
|
||
|
|
self.assertEqual(c, '0b11100')
|
||
|
|
self.assertEqual(b, '0b11101')
|
||
|
|
|
||
|
|
def testIand(self):
|
||
|
|
a = BitStream('0b0101010101000')
|
||
|
|
a &= '0b1111110000000'
|
||
|
|
self.assertEqual(a, '0b0101010000000')
|
||
|
|
s = BitStream(filename='test.m1v', offset=26, length=24)
|
||
|
|
s &= '0xff00ff'
|
||
|
|
self.assertEqual(s, '0xcc0004')
|
||
|
|
|
||
|
|
def testIxor(self):
|
||
|
|
a = BitStream('0b11001100110011')
|
||
|
|
a ^= '0b11111100000010'
|
||
|
|
self.assertEqual(a, '0b00110000110001')
|
||
|
|
|
||
|
|
def testLogicalInplaceErrors(self):
|
||
|
|
a = BitStream(4)
|
||
|
|
self.assertRaises(ValueError, a.__ior__, '0b111')
|
||
|
|
self.assertRaises(ValueError, a.__iand__, '0b111')
|
||
|
|
self.assertRaises(ValueError, a.__ixor__, '0b111')
|
||
|
|
|
||
|
|
|
||
|
|
class AllAndAny(unittest.TestCase):
|
||
|
|
def testAll(self):
|
||
|
|
a = BitStream('0b0111')
|
||
|
|
self.assertTrue(a.all(True, (1, 3)))
|
||
|
|
self.assertFalse(a.all(True, (0, 1, 2)))
|
||
|
|
self.assertTrue(a.all(True, [-1]))
|
||
|
|
self.assertFalse(a.all(True, [0]))
|
||
|
|
|
||
|
|
def testFileBasedAll(self):
|
||
|
|
a = BitStream(filename='test.m1v')
|
||
|
|
self.assertTrue(a.all(True, [31]))
|
||
|
|
a = BitStream(filename='test.m1v')
|
||
|
|
self.assertTrue(a.all(False, (0, 1, 2, 3, 4)))
|
||
|
|
|
||
|
|
def testFileBasedAny(self):
|
||
|
|
a = BitStream(filename='test.m1v')
|
||
|
|
self.assertTrue(a.any(True, (31, 12)))
|
||
|
|
a = BitStream(filename='test.m1v')
|
||
|
|
self.assertTrue(a.any(False, (0, 1, 2, 3, 4)))
|
||
|
|
|
||
|
|
def testAny(self):
|
||
|
|
a = BitStream('0b10011011')
|
||
|
|
self.assertTrue(a.any(True, (1, 2, 3, 5)))
|
||
|
|
self.assertFalse(a.any(True, (1, 2, 5)))
|
||
|
|
self.assertTrue(a.any(True, (-1,)))
|
||
|
|
self.assertFalse(a.any(True, (1,)))
|
||
|
|
|
||
|
|
def testAllFalse(self):
|
||
|
|
a = BitStream('0b0010011101')
|
||
|
|
self.assertTrue(a.all(False, (0, 1, 3, 4)))
|
||
|
|
self.assertFalse(a.all(False, (0, 1, 2, 3, 4)))
|
||
|
|
|
||
|
|
def testAnyFalse(self):
|
||
|
|
a = BitStream('0b01001110110111111111111111111')
|
||
|
|
self.assertTrue(a.any(False, (4, 5, 6, 2)))
|
||
|
|
self.assertFalse(a.any(False, (1, 15, 20)))
|
||
|
|
|
||
|
|
def testAnyEmptyBitstring(self):
|
||
|
|
a = ConstBitStream()
|
||
|
|
self.assertFalse(a.any(True))
|
||
|
|
self.assertFalse(a.any(False))
|
||
|
|
|
||
|
|
def testAllEmptyBitStream(self):
|
||
|
|
a = ConstBitStream()
|
||
|
|
self.assertTrue(a.all(True))
|
||
|
|
self.assertTrue(a.all(False))
|
||
|
|
|
||
|
|
def testAnyWholeBitstring(self):
|
||
|
|
a = ConstBitStream('0xfff')
|
||
|
|
self.assertTrue(a.any(True))
|
||
|
|
self.assertFalse(a.any(False))
|
||
|
|
|
||
|
|
def testAllWholeBitstring(self):
|
||
|
|
a = ConstBitStream('0xfff')
|
||
|
|
self.assertTrue(a.all(True))
|
||
|
|
self.assertFalse(a.all(False))
|
||
|
|
|
||
|
|
def testErrors(self):
|
||
|
|
a = BitStream('0xf')
|
||
|
|
self.assertRaises(IndexError, a.all, True, [5])
|
||
|
|
self.assertRaises(IndexError, a.all, True, [-5])
|
||
|
|
self.assertRaises(IndexError, a.any, True, [5])
|
||
|
|
self.assertRaises(IndexError, a.any, True, [-5])
|
||
|
|
|
||
|
|
###################
|
||
|
|
|
||
|
|
def testFloatInitialisation(self):
|
||
|
|
for f in (0.0000001, -1.0, 1.0, 0.2, -3.1415265, 1.331e32):
|
||
|
|
a = BitStream(float=f, length=64)
|
||
|
|
a.pos = 6
|
||
|
|
self.assertEqual(a.float, f)
|
||
|
|
a = BitStream('float:64=%s' % str(f))
|
||
|
|
a.pos = 6
|
||
|
|
self.assertEqual(a.float, f)
|
||
|
|
a = BitStream('floatbe:64=%s' % str(f))
|
||
|
|
a.pos = 6
|
||
|
|
self.assertEqual(a.floatbe, f)
|
||
|
|
a = BitStream('floatle:64=%s' % str(f))
|
||
|
|
a.pos = 6
|
||
|
|
self.assertEqual(a.floatle, f)
|
||
|
|
a = BitStream('floatne:64=%s' % str(f))
|
||
|
|
a.pos = 6
|
||
|
|
self.assertEqual(a.floatne, f)
|
||
|
|
b = BitStream(float=f, length=32)
|
||
|
|
b.pos = 6
|
||
|
|
self.assertAlmostEqual(b.float / f, 1.0)
|
||
|
|
b = BitStream('float:32=%s' % str(f))
|
||
|
|
b.pos = 6
|
||
|
|
self.assertAlmostEqual(b.float / f, 1.0)
|
||
|
|
b = BitStream('floatbe:32=%s' % str(f))
|
||
|
|
b.pos = 6
|
||
|
|
self.assertAlmostEqual(b.floatbe / f, 1.0)
|
||
|
|
b = BitStream('floatle:32=%s' % str(f))
|
||
|
|
b.pos = 6
|
||
|
|
self.assertAlmostEqual(b.floatle / f, 1.0)
|
||
|
|
b = BitStream('floatne:32=%s' % str(f))
|
||
|
|
b.pos = 6
|
||
|
|
self.assertAlmostEqual(b.floatne / f, 1.0)
|
||
|
|
a = BitStream('0x12345678')
|
||
|
|
a.pos = 6
|
||
|
|
a.float = 23
|
||
|
|
self.assertEqual(a.float, 23.0)
|
||
|
|
|
||
|
|
def testFloatInitStrings(self):
|
||
|
|
for s in ('5', '+0.0001', '-1e101', '4.', '.2', '-.65', '43.21E+32'):
|
||
|
|
a = BitStream('float:64=%s' % s)
|
||
|
|
self.assertEqual(a.float, float(s))
|
||
|
|
|
||
|
|
def testFloatPacking(self):
|
||
|
|
a = pack('>d', 0.01)
|
||
|
|
self.assertEqual(a.float, 0.01)
|
||
|
|
self.assertEqual(a.floatbe, 0.01)
|
||
|
|
a.byteswap()
|
||
|
|
self.assertEqual(a.floatle, 0.01)
|
||
|
|
b = pack('>f', 1e10)
|
||
|
|
self.assertAlmostEqual(b.float / 1e10, 1.0)
|
||
|
|
c = pack('<f', 10.3)
|
||
|
|
self.assertAlmostEqual(c.floatle / 10.3, 1.0)
|
||
|
|
d = pack('>5d', 10.0, 5.0, 2.5, 1.25, 0.1)
|
||
|
|
self.assertEqual(d.unpack('>5d'), [10.0, 5.0, 2.5, 1.25, 0.1])
|
||
|
|
|
||
|
|
def testFloatReading(self):
|
||
|
|
a = BitStream('floatle:64=12, floatbe:64=-0.01, floatne:64=3e33')
|
||
|
|
x, y, z = a.readlist('floatle:64, floatbe:64, floatne:64')
|
||
|
|
self.assertEqual(x, 12.0)
|
||
|
|
self.assertEqual(y, -0.01)
|
||
|
|
self.assertEqual(z, 3e33)
|
||
|
|
a = BitStream('floatle:32=12, floatbe:32=-0.01, floatne:32=3e33')
|
||
|
|
x, y, z = a.readlist('floatle:32, floatbe:32, floatne:32')
|
||
|
|
self.assertAlmostEqual(x / 12.0, 1.0)
|
||
|
|
self.assertAlmostEqual(y / -0.01, 1.0)
|
||
|
|
self.assertAlmostEqual(z / 3e33, 1.0)
|
||
|
|
a = BitStream('0b11, floatle:64=12, 0xfffff')
|
||
|
|
a.pos = 2
|
||
|
|
self.assertEqual(a.read('floatle:64'), 12.0)
|
||
|
|
b = BitStream(floatle=20, length=32)
|
||
|
|
b.floatle = 10.0
|
||
|
|
b = [0] + b
|
||
|
|
self.assertEqual(b[1:].floatle, 10.0)
|
||
|
|
|
||
|
|
def testNonAlignedFloatReading(self):
|
||
|
|
s = BitStream('0b1, float:32 = 10.0')
|
||
|
|
x, y = s.readlist('1, float:32')
|
||
|
|
self.assertEqual(y, 10.0)
|
||
|
|
s[1:] = 'floatle:32=20.0'
|
||
|
|
x, y = s.unpack('1, floatle:32')
|
||
|
|
self.assertEqual(y, 20.0)
|
||
|
|
|
||
|
|
def testFloatErrors(self):
|
||
|
|
a = BitStream('0x3')
|
||
|
|
self.assertRaises(bitstring.InterpretError, a._getfloat)
|
||
|
|
self.assertRaises(bitstring.CreationError, a._setfloat, -0.2)
|
||
|
|
for l in (8, 10, 12, 16, 30, 128, 200):
|
||
|
|
self.assertRaises(ValueError, BitStream, float=1.0, length=l)
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, floatle=0.3, length=0)
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, floatle=0.3, length=1)
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, float=2)
|
||
|
|
self.assertRaises(bitstring.InterpretError, a.read, 'floatle:2')
|
||
|
|
|
||
|
|
def testReadErrorChangesPos(self):
|
||
|
|
a = BitStream('0x123123')
|
||
|
|
try:
|
||
|
|
a.read('10, 5')
|
||
|
|
except ValueError:
|
||
|
|
pass
|
||
|
|
self.assertEqual(a.pos, 0)
|
||
|
|
|
||
|
|
def testRor(self):
|
||
|
|
a = BitStream('0b11001')
|
||
|
|
a.ror(0)
|
||
|
|
self.assertEqual(a, '0b11001')
|
||
|
|
a.ror(1)
|
||
|
|
self.assertEqual(a, '0b11100')
|
||
|
|
a.ror(5)
|
||
|
|
self.assertEqual(a, '0b11100')
|
||
|
|
a.ror(101)
|
||
|
|
self.assertEqual(a, '0b01110')
|
||
|
|
a = BitStream('0b1')
|
||
|
|
a.ror(1000000)
|
||
|
|
self.assertEqual(a, '0b1')
|
||
|
|
|
||
|
|
def testRorErrors(self):
|
||
|
|
a = BitStream()
|
||
|
|
self.assertRaises(bitstring.Error, a.ror, 0)
|
||
|
|
a += '0b001'
|
||
|
|
self.assertRaises(ValueError, a.ror, -1)
|
||
|
|
|
||
|
|
def testRol(self):
|
||
|
|
a = BitStream('0b11001')
|
||
|
|
a.rol(0)
|
||
|
|
self.assertEqual(a, '0b11001')
|
||
|
|
a.rol(1)
|
||
|
|
self.assertEqual(a, '0b10011')
|
||
|
|
a.rol(5)
|
||
|
|
self.assertEqual(a, '0b10011')
|
||
|
|
a.rol(101)
|
||
|
|
self.assertEqual(a, '0b00111')
|
||
|
|
a = BitStream('0b1')
|
||
|
|
a.rol(1000000)
|
||
|
|
self.assertEqual(a, '0b1')
|
||
|
|
|
||
|
|
def testRolFromFile(self):
|
||
|
|
a = BitStream(filename='test.m1v')
|
||
|
|
l = a.len
|
||
|
|
a.rol(1)
|
||
|
|
self.assertTrue(a.startswith('0x000003'))
|
||
|
|
self.assertEqual(a.len, l)
|
||
|
|
self.assertTrue(a.endswith('0x0036e'))
|
||
|
|
|
||
|
|
def testRorFromFile(self):
|
||
|
|
a = BitStream(filename='test.m1v')
|
||
|
|
l = a.len
|
||
|
|
a.ror(1)
|
||
|
|
self.assertTrue(a.startswith('0x800000'))
|
||
|
|
self.assertEqual(a.len, l)
|
||
|
|
self.assertTrue(a.endswith('0x000db'))
|
||
|
|
|
||
|
|
def testRolErrors(self):
|
||
|
|
a = BitStream()
|
||
|
|
self.assertRaises(bitstring.Error, a.rol, 0)
|
||
|
|
a += '0b001'
|
||
|
|
self.assertRaises(ValueError, a.rol, -1)
|
||
|
|
|
||
|
|
def testBytesToken(self):
|
||
|
|
a = BitStream('0x010203')
|
||
|
|
b = a.read('bytes:1')
|
||
|
|
self.assertTrue(isinstance(b, bytes))
|
||
|
|
self.assertEqual(b, b'\x01')
|
||
|
|
x, y, z = a.unpack('4, bytes:2, uint')
|
||
|
|
self.assertEqual(x, 0)
|
||
|
|
self.assertEqual(y, b'\x10\x20')
|
||
|
|
self.assertEqual(z, 3)
|
||
|
|
s = pack('bytes:4', b'abcd')
|
||
|
|
self.assertEqual(s.bytes, b'abcd')
|
||
|
|
|
||
|
|
def testBytesTokenMoreThoroughly(self):
|
||
|
|
a = BitStream('0x0123456789abcdef')
|
||
|
|
a.pos += 16
|
||
|
|
self.assertEqual(a.read('bytes:1'), b'\x45')
|
||
|
|
self.assertEqual(a.read('bytes:3'), b'\x67\x89\xab')
|
||
|
|
x, y, z = a.unpack('bits:28, bytes, bits:12')
|
||
|
|
self.assertEqual(y, b'\x78\x9a\xbc')
|
||
|
|
|
||
|
|
def testDedicatedReadFunctions(self):
|
||
|
|
a = BitStream('0b11, uint:43=98798798172, 0b11111')
|
||
|
|
x = a._readuint(43, 2)
|
||
|
|
self.assertEqual(x, 98798798172)
|
||
|
|
self.assertEqual(a.pos, 0)
|
||
|
|
x = a._readint(43, 2)
|
||
|
|
self.assertEqual(x, 98798798172)
|
||
|
|
self.assertEqual(a.pos, 0)
|
||
|
|
|
||
|
|
a = BitStream('0b11, uintbe:48=98798798172, 0b11111')
|
||
|
|
x = a._readuintbe(48, 2)
|
||
|
|
self.assertEqual(x, 98798798172)
|
||
|
|
self.assertEqual(a.pos, 0)
|
||
|
|
x = a._readintbe(48, 2)
|
||
|
|
self.assertEqual(x, 98798798172)
|
||
|
|
self.assertEqual(a.pos, 0)
|
||
|
|
|
||
|
|
a = BitStream('0b111, uintle:40=123516, 0b111')
|
||
|
|
self.assertEqual(a._readuintle(40, 3), 123516)
|
||
|
|
b = BitStream('0xff, uintle:800=999, 0xffff')
|
||
|
|
self.assertEqual(b._readuintle(800, 8), 999)
|
||
|
|
|
||
|
|
a = BitStream('0b111, intle:48=999999999, 0b111111111111')
|
||
|
|
self.assertEqual(a._readintle(48, 3), 999999999)
|
||
|
|
b = BitStream('0xff, intle:200=918019283740918263512351235, 0xfffffff')
|
||
|
|
self.assertEqual(b._readintle(200, 8), 918019283740918263512351235)
|
||
|
|
|
||
|
|
a = BitStream('0b111, floatbe:64=-5.32, 0xffffffff')
|
||
|
|
self.assertEqual(a._readfloat(64, 3), -5.32)
|
||
|
|
|
||
|
|
a = BitStream('0b111, floatle:64=9.9998, 0b111')
|
||
|
|
self.assertEqual(a._readfloatle(64, 3), 9.9998)
|
||
|
|
|
||
|
|
def testAutoInitWithInt(self):
|
||
|
|
a = BitStream(0)
|
||
|
|
self.assertFalse(a)
|
||
|
|
a = BitStream(1)
|
||
|
|
self.assertEqual(a, '0b0')
|
||
|
|
a = BitStream(1007)
|
||
|
|
self.assertEqual(a, BitStream(length=1007))
|
||
|
|
self.assertRaises(bitstring.CreationError, BitStream, -1)
|
||
|
|
|
||
|
|
a = 6 + ConstBitStream('0b1') + 3
|
||
|
|
self.assertEqual(a, '0b0000001000')
|
||
|
|
a += 1
|
||
|
|
self.assertEqual(a, '0b00000010000')
|
||
|
|
self.assertEqual(ConstBitStream(13), 13)
|
||
|
|
|
||
|
|
def testReadingProblems(self):
|
||
|
|
a = BitStream('0x000001')
|
||
|
|
b = a.read('uint:24')
|
||
|
|
self.assertEqual(b, 1)
|
||
|
|
a.pos = 0
|
||
|
|
self.assertRaises(bitstring.ReadError, a.read, 'bytes:4')
|
||
|
|
|
||
|
|
def testAddVersesInPlaceAdd(self):
|
||
|
|
a1 = ConstBitStream('0xabc')
|
||
|
|
b1 = a1
|
||
|
|
a1 += '0xdef'
|
||
|
|
self.assertEqual(a1, '0xabcdef')
|
||
|
|
self.assertEqual(b1, '0xabc')
|
||
|
|
|
||
|
|
a2 = BitStream('0xabc')
|
||
|
|
b2 = a2
|
||
|
|
c2 = a2 + '0x0'
|
||
|
|
a2 += '0xdef'
|
||
|
|
self.assertEqual(a2, '0xabcdef')
|
||
|
|
self.assertEqual(b2, '0xabcdef')
|
||
|
|
self.assertEqual(c2, '0xabc0')
|
||
|
|
|
||
|
|
def testAndVersesInPlaceAnd(self):
|
||
|
|
a1 = ConstBitStream('0xabc')
|
||
|
|
b1 = a1
|
||
|
|
a1 &= '0xf0f'
|
||
|
|
self.assertEqual(a1, '0xa0c')
|
||
|
|
self.assertEqual(b1, '0xabc')
|
||
|
|
|
||
|
|
a2 = BitStream('0xabc')
|
||
|
|
b2 = a2
|
||
|
|
c2 = a2 & '0x00f'
|
||
|
|
a2 &= '0xf0f'
|
||
|
|
self.assertEqual(a2, '0xa0c')
|
||
|
|
self.assertEqual(b2, '0xa0c')
|
||
|
|
self.assertEqual(c2, '0x00c')
|
||
|
|
|
||
|
|
def testOrVersesInPlaceOr(self):
|
||
|
|
a1 = ConstBitStream('0xabc')
|
||
|
|
b1 = a1
|
||
|
|
a1 |= '0xf0f'
|
||
|
|
self.assertEqual(a1, '0xfbf')
|
||
|
|
self.assertEqual(b1, '0xabc')
|
||
|
|
|
||
|
|
a2 = BitStream('0xabc')
|
||
|
|
b2 = a2
|
||
|
|
c2 = a2 | '0x00f'
|
||
|
|
a2 |= '0xf0f'
|
||
|
|
self.assertEqual(a2, '0xfbf')
|
||
|
|
self.assertEqual(b2, '0xfbf')
|
||
|
|
self.assertEqual(c2, '0xabf')
|
||
|
|
|
||
|
|
def testXorVersesInPlaceXor(self):
|
||
|
|
a1 = ConstBitStream('0xabc')
|
||
|
|
b1 = a1
|
||
|
|
a1 ^= '0xf0f'
|
||
|
|
self.assertEqual(a1, '0x5b3')
|
||
|
|
self.assertEqual(b1, '0xabc')
|
||
|
|
|
||
|
|
a2 = BitStream('0xabc')
|
||
|
|
b2 = a2
|
||
|
|
c2 = a2 ^ '0x00f'
|
||
|
|
a2 ^= '0xf0f'
|
||
|
|
self.assertEqual(a2, '0x5b3')
|
||
|
|
self.assertEqual(b2, '0x5b3')
|
||
|
|
self.assertEqual(c2, '0xab3')
|
||
|
|
|
||
|
|
def testMulVersesInPlaceMul(self):
|
||
|
|
a1 = ConstBitStream('0xabc')
|
||
|
|
b1 = a1
|
||
|
|
a1 *= 3
|
||
|
|
self.assertEqual(a1, '0xabcabcabc')
|
||
|
|
self.assertEqual(b1, '0xabc')
|
||
|
|
|
||
|
|
a2 = BitStream('0xabc')
|
||
|
|
b2 = a2
|
||
|
|
c2 = a2 * 2
|
||
|
|
a2 *= 3
|
||
|
|
self.assertEqual(a2, '0xabcabcabc')
|
||
|
|
self.assertEqual(b2, '0xabcabcabc')
|
||
|
|
self.assertEqual(c2, '0xabcabc')
|
||
|
|
|
||
|
|
def testLshiftVersesInPlaceLshift(self):
|
||
|
|
a1 = ConstBitStream('0xabc')
|
||
|
|
b1 = a1
|
||
|
|
a1 <<= 4
|
||
|
|
self.assertEqual(a1, '0xbc0')
|
||
|
|
self.assertEqual(b1, '0xabc')
|
||
|
|
|
||
|
|
a2 = BitStream('0xabc')
|
||
|
|
b2 = a2
|
||
|
|
c2 = a2 << 8
|
||
|
|
a2 <<= 4
|
||
|
|
self.assertEqual(a2, '0xbc0')
|
||
|
|
self.assertEqual(b2, '0xbc0')
|
||
|
|
self.assertEqual(c2, '0xc00')
|
||
|
|
|
||
|
|
def testRshiftVersesInPlaceRshift(self):
|
||
|
|
a1 = ConstBitStream('0xabc')
|
||
|
|
b1 = a1
|
||
|
|
a1 >>= 4
|
||
|
|
self.assertEqual(a1, '0x0ab')
|
||
|
|
self.assertEqual(b1, '0xabc')
|
||
|
|
|
||
|
|
a2 = BitStream('0xabc')
|
||
|
|
b2 = a2
|
||
|
|
c2 = a2 >> 8
|
||
|
|
a2 >>= 4
|
||
|
|
self.assertEqual(a2, '0x0ab')
|
||
|
|
self.assertEqual(b2, '0x0ab')
|
||
|
|
self.assertEqual(c2, '0x00a')
|
||
|
|
|
||
|
|
def testAutoFromBool(self):
|
||
|
|
a = ConstBitStream() + True + False + True
|
||
|
|
self.assertEqual(a, '0b00')
|
||
|
|
# self.assertEqual(a, '0b101')
|
||
|
|
# b = ConstBitStream(False)
|
||
|
|
# self.assertEqual(b, '0b0')
|
||
|
|
# c = ConstBitStream(True)
|
||
|
|
# self.assertEqual(c, '0b1')
|
||
|
|
# self.assertEqual(b, False)
|
||
|
|
# self.assertEqual(c, True)
|
||
|
|
# self.assertEqual(b & True, False)
|
||
|
|
|
||
|
|
|
||
|
|
class Bugs(unittest.TestCase):
|
||
|
|
def testBugInReplace(self):
|
||
|
|
s = BitStream('0x00112233')
|
||
|
|
l = list(s.split('0x22', start=8, bytealigned=True))
|
||
|
|
self.assertEqual(l, ['0x11', '0x2233'])
|
||
|
|
s = BitStream('0x00112233')
|
||
|
|
s.replace('0x22', '0xffff', start=8, bytealigned=True)
|
||
|
|
self.assertEqual(s, '0x0011ffff33')
|
||
|
|
s = BitStream('0x0123412341234')
|
||
|
|
s.replace('0x23', '0xf', start=9, bytealigned=True)
|
||
|
|
self.assertEqual(s, '0x012341f41f4')
|
||
|
|
|
||
|
|
def testTruncateStartBug(self):
|
||
|
|
a = BitStream('0b000000111')[2:]
|
||
|
|
a._truncatestart(6)
|
||
|
|
self.assertEqual(a, '0b1')
|
||
|
|
|
||
|
|
def testNullBits(self):
|
||
|
|
s = ConstBitStream(bin='')
|
||
|
|
t = ConstBitStream(oct='')
|
||
|
|
u = ConstBitStream(hex='')
|
||
|
|
v = ConstBitStream(bytes=b'')
|
||
|
|
self.assertFalse(s)
|
||
|
|
self.assertFalse(t)
|
||
|
|
self.assertFalse(u)
|
||
|
|
self.assertFalse(v)
|
||
|
|
|
||
|
|
def testMultiplicativeFactorsCreation(self):
|
||
|
|
s = BitStream('1*0b1')
|
||
|
|
self.assertEqual(s, '0b1')
|
||
|
|
s = BitStream('4*0xc')
|
||
|
|
self.assertEqual(s, '0xcccc')
|
||
|
|
s = BitStream('0b1, 0*0b0')
|
||
|
|
self.assertEqual(s, '0b1')
|
||
|
|
s = BitStream('0b1, 3*uint:8=34, 2*0o755')
|
||
|
|
self.assertEqual(s, '0b1, uint:8=34, uint:8=34, uint:8=34, 0o755755')
|
||
|
|
s = BitStream('0*0b1001010')
|
||
|
|
self.assertFalse(s)
|
||
|
|
|
||
|
|
def testMultiplicativeFactorsReading(self):
|
||
|
|
s = BitStream('0xc') * 5
|
||
|
|
a, b, c, d, e = s.readlist('5*4')
|
||
|
|
self.assertTrue(a == b == c == d == e == 12)
|
||
|
|
s = ConstBitStream('2*0b101, 4*uint:7=3')
|
||
|
|
a, b, c, d, e = s.readlist('2*bin:3, 3*uint:7')
|
||
|
|
self.assertTrue(a == b == '101')
|
||
|
|
self.assertTrue(c == d == e == 3)
|
||
|
|
|
||
|
|
def testMultiplicativeFactorsPacking(self):
|
||
|
|
s = pack('3*bin', '1', '001', '101')
|
||
|
|
self.assertEqual(s, '0b1001101')
|
||
|
|
s = pack('hex, 2*se=-56, 3*uint:37', '34', 1, 2, 3)
|
||
|
|
a, b, c, d, e, f = s.unpack('hex:8, 2*se, 3*uint:37')
|
||
|
|
self.assertEqual(a, '34')
|
||
|
|
self.assertEqual(b, -56)
|
||
|
|
self.assertEqual(c, -56)
|
||
|
|
self.assertEqual((d, e, f), (1, 2, 3))
|
||
|
|
# This isn't allowed yet. See comment in tokenparser.
|
||
|
|
#s = pack('fluffy*uint:8', *range(3), fluffy=3)
|
||
|
|
#a, b, c = s.readlist('2*uint:8, 1*uint:8, 0*uint:8')
|
||
|
|
#self.assertEqual((a, b, c), (0, 1, 2))
|
||
|
|
|
||
|
|
def testMultiplicativeFactorsUnpacking(self):
|
||
|
|
s = ConstBitStream('0b10111')
|
||
|
|
a, b, c, d = s.unpack('3*bool, bin')
|
||
|
|
self.assertEqual((a, b, c), (True, False, True))
|
||
|
|
self.assertEqual(d, '11')
|
||
|
|
|
||
|
|
|
||
|
|
def testPackingDefaultIntWithKeyword(self):
|
||
|
|
s = pack('12', 100)
|
||
|
|
self.assertEqual(s.unpack('12')[0], 100)
|
||
|
|
s = pack('oh_no_not_the_eyes=33', oh_no_not_the_eyes=17)
|
||
|
|
self.assertEqual(s.uint, 33)
|
||
|
|
self.assertEqual(s.len, 17)
|
||
|
|
|
||
|
|
def testInitFromIterable(self):
|
||
|
|
self.assertTrue(isinstance(range(10), collections.Iterable))
|
||
|
|
s = ConstBitStream(range(12))
|
||
|
|
self.assertEqual(s, '0x7ff')
|
||
|
|
|
||
|
|
def testFunctionNegativeIndices(self):
|
||
|
|
# insert
|
||
|
|
s = BitStream('0b0111')
|
||
|
|
s.insert('0b0', -1)
|
||
|
|
self.assertEqual(s, '0b01101')
|
||
|
|
self.assertRaises(ValueError, s.insert, '0b0', -1000)
|
||
|
|
|
||
|
|
# reverse
|
||
|
|
s.reverse(-2)
|
||
|
|
self.assertEqual(s, '0b01110')
|
||
|
|
t = BitStream('0x778899abcdef')
|
||
|
|
t.reverse(-12, -4)
|
||
|
|
self.assertEqual(t, '0x778899abc7bf')
|
||
|
|
|
||
|
|
# reversebytes
|
||
|
|
t.byteswap(0, -40, -16)
|
||
|
|
self.assertEqual(t, '0x77ab9988c7bf')
|
||
|
|
|
||
|
|
# overwrite
|
||
|
|
t.overwrite('0x666', -20)
|
||
|
|
self.assertEqual(t, '0x77ab998666bf')
|
||
|
|
|
||
|
|
# find
|
||
|
|
found = t.find('0x998', bytealigned=True, start=-31)
|
||
|
|
self.assertFalse(found)
|
||
|
|
found = t.find('0x998', bytealigned=True, start=-32)
|
||
|
|
self.assertTrue(found)
|
||
|
|
self.assertEqual(t.pos, 16)
|
||
|
|
t.pos = 0
|
||
|
|
found = t.find('0x988', bytealigned=True, end=-21)
|
||
|
|
self.assertFalse(found)
|
||
|
|
found = t.find('0x998', bytealigned=True, end=-20)
|
||
|
|
self.assertTrue(found)
|
||
|
|
self.assertEqual(t.pos, 16)
|
||
|
|
|
||
|
|
#findall
|
||
|
|
s = BitStream('0x1234151f')
|
||
|
|
l = list(s.findall('0x1', bytealigned=True, start=-15))
|
||
|
|
self.assertEqual(l, [24])
|
||
|
|
l = list(s.findall('0x1', bytealigned=True, start=-16))
|
||
|
|
self.assertEqual(l, [16, 24])
|
||
|
|
l = list(s.findall('0x1', bytealigned=True, end=-5))
|
||
|
|
self.assertEqual(l, [0, 16])
|
||
|
|
l = list(s.findall('0x1', bytealigned=True, end=-4))
|
||
|
|
self.assertEqual(l, [0, 16, 24])
|
||
|
|
|
||
|
|
# rfind
|
||
|
|
found = s.rfind('0x1f', end=-1)
|
||
|
|
self.assertFalse(found)
|
||
|
|
found = s.rfind('0x12', start=-31)
|
||
|
|
self.assertFalse(found)
|
||
|
|
|
||
|
|
# cut
|
||
|
|
s = BitStream('0x12345')
|
||
|
|
l = list(s.cut(4, start=-12, end=-4))
|
||
|
|
self.assertEqual(l, ['0x3', '0x4'])
|
||
|
|
|
||
|
|
# split
|
||
|
|
s = BitStream('0xfe0012fe1200fe')
|
||
|
|
l = list(s.split('0xfe', bytealigned=True, end=-1))
|
||
|
|
self.assertEqual(l, ['', '0xfe0012', '0xfe1200f, 0b111'])
|
||
|
|
l = list(s.split('0xfe', bytealigned=True, start=-8))
|
||
|
|
self.assertEqual(l, ['', '0xfe'])
|
||
|
|
|
||
|
|
# startswith
|
||
|
|
self.assertTrue(s.startswith('0x00f', start=-16))
|
||
|
|
self.assertTrue(s.startswith('0xfe00', end=-40))
|
||
|
|
self.assertFalse(s.startswith('0xfe00', end=-41))
|
||
|
|
|
||
|
|
# endswith
|
||
|
|
self.assertTrue(s.endswith('0x00fe', start=-16))
|
||
|
|
self.assertFalse(s.endswith('0x00fe', start=-15))
|
||
|
|
self.assertFalse(s.endswith('0x00fe', end=-1))
|
||
|
|
self.assertTrue(s.endswith('0x00f', end=-4))
|
||
|
|
|
||
|
|
# replace
|
||
|
|
s.replace('0xfe', '', end=-1)
|
||
|
|
self.assertEqual(s, '0x00121200fe')
|
||
|
|
s.replace('0x00', '', start=-24)
|
||
|
|
self.assertEqual(s, '0x001212fe')
|
||
|
|
|
||
|
|
def testRotateStartAndEnd(self):
|
||
|
|
a = BitStream('0b110100001')
|
||
|
|
a.rol(1, 3, 6)
|
||
|
|
self.assertEqual(a, '0b110001001')
|
||
|
|
a.ror(1, start=-4)
|
||
|
|
self.assertEqual(a, '0b110001100')
|
||
|
|
a.rol(202, end=-5)
|
||
|
|
self.assertEqual(a, '0b001101100')
|
||
|
|
a.ror(3, end=4)
|
||
|
|
self.assertEqual(a, '0b011001100')
|
||
|
|
self.assertRaises(ValueError, a.rol, 5, start=-4, end=-6)
|
||
|
|
|
||
|
|
def testByteSwapInt(self):
|
||
|
|
s = pack('5*uintle:16', *range(10, 15))
|
||
|
|
self.assertEqual(list(range(10, 15)), s.unpack('5*uintle:16'))
|
||
|
|
swaps = s.byteswap(2)
|
||
|
|
self.assertEqual(list(range(10, 15)), s.unpack('5*uintbe:16'))
|
||
|
|
self.assertEqual(swaps, 5)
|
||
|
|
s = BitStream('0xf234567f')
|
||
|
|
swaps = s.byteswap(1, start=4)
|
||
|
|
self.assertEqual(swaps, 3)
|
||
|
|
self.assertEqual(s, '0xf234567f')
|
||
|
|
s.byteswap(2, start=4)
|
||
|
|
self.assertEqual(s, '0xf452367f')
|
||
|
|
s.byteswap(2, start=4, end=-4)
|
||
|
|
self.assertEqual(s, '0xf234567f')
|
||
|
|
s.byteswap(3)
|
||
|
|
self.assertEqual(s, '0x5634f27f')
|
||
|
|
s.byteswap(2, repeat=False)
|
||
|
|
self.assertEqual(s, '0x3456f27f')
|
||
|
|
swaps = s.byteswap(5)
|
||
|
|
self.assertEqual(swaps, 0)
|
||
|
|
swaps = s.byteswap(4, repeat=False)
|
||
|
|
self.assertEqual(swaps, 1)
|
||
|
|
self.assertEqual(s, '0x7ff25634')
|
||
|
|
|
||
|
|
def testByteSwapPackCode(self):
|
||
|
|
s = BitStream('0x0011223344556677')
|
||
|
|
swaps = s.byteswap('b')
|
||
|
|
self.assertEqual(s, '0x0011223344556677')
|
||
|
|
self.assertEqual(swaps, 8)
|
||
|
|
swaps = s.byteswap('>3h', repeat=False)
|
||
|
|
self.assertEqual(s, '0x1100332255446677')
|
||
|
|
self.assertEqual(swaps, 1)
|
||
|
|
|
||
|
|
def testByteSwapIterable(self):
|
||
|
|
s = BitStream('0x0011223344556677')
|
||
|
|
swaps = s.byteswap(range(1, 4), repeat=False)
|
||
|
|
self.assertEqual(swaps, 1)
|
||
|
|
self.assertEqual(s, '0x0022115544336677')
|
||
|
|
swaps = s.byteswap([2], start=8)
|
||
|
|
self.assertEqual(s, '0x0011224455663377')
|
||
|
|
self.assertEqual(3, swaps)
|
||
|
|
swaps = s.byteswap([2, 3], start=4)
|
||
|
|
self.assertEqual(swaps, 1)
|
||
|
|
self.assertEqual(s, '0x0120156452463377')
|
||
|
|
|
||
|
|
def testByteSwapErrors(self):
|
||
|
|
s = BitStream('0x0011223344556677')
|
||
|
|
self.assertRaises(ValueError, s.byteswap, 'z')
|
||
|
|
self.assertRaises(ValueError, s.byteswap, -1)
|
||
|
|
self.assertRaises(ValueError, s.byteswap, [-1])
|
||
|
|
self.assertRaises(ValueError, s.byteswap, [1, 'e'])
|
||
|
|
self.assertRaises(ValueError, s.byteswap, '!h')
|
||
|
|
self.assertRaises(ValueError, s.byteswap, 2, start=-1000)
|
||
|
|
self.assertRaises(TypeError, s.byteswap, 5.4)
|
||
|
|
|
||
|
|
def testByteSwapFromFile(self):
|
||
|
|
s = BitStream(filename='smalltestfile')
|
||
|
|
swaps = s.byteswap('2bh')
|
||
|
|
self.assertEqual(s, '0x0123674589abefcd')
|
||
|
|
self.assertEqual(swaps, 2)
|
||
|
|
|
||
|
|
def testBracketExpander(self):
|
||
|
|
be = bitstring.expand_brackets
|
||
|
|
self.assertEqual(be('hello'), 'hello')
|
||
|
|
self.assertEqual(be('(hello)'), 'hello')
|
||
|
|
self.assertEqual(be('1*(hello)'), 'hello')
|
||
|
|
self.assertEqual(be('2*(hello)'), 'hello,hello')
|
||
|
|
self.assertEqual(be('1*(a, b)'), 'a,b')
|
||
|
|
self.assertEqual(be('2*(a, b)'), 'a,b,a,b')
|
||
|
|
self.assertEqual(be('2*(a), 3*(b)'), 'a,a,b,b,b')
|
||
|
|
self.assertEqual(be('2*(a, b, 3*(c, d), e)'), 'a,b,c,d,c,d,c,d,e,a,b,c,d,c,d,c,d,e')
|
||
|
|
|
||
|
|
def testBracketTokens(self):
|
||
|
|
s = BitStream('3*(0x0, 0b1)')
|
||
|
|
self.assertEqual(s, '0x0, 0b1, 0x0, 0b1, 0x0, 0b1')
|
||
|
|
s = pack('2*(uint:12, 3*(7, 6))', *range(3, 17))
|
||
|
|
a = s.unpack('12, 7, 6, 7, 6, 7, 6, 12, 7, 6, 7, 6, 7, 6')
|
||
|
|
self.assertEqual(a, list(range(3, 17)))
|
||
|
|
b = s.unpack('2*(12,3*(7,6))')
|
||
|
|
self.assertEqual(a, b)
|
||
|
|
|
||
|
|
def testPackCodeDicts(self):
|
||
|
|
self.assertEqual(sorted(bitstring.REPLACEMENTS_BE.keys()),
|
||
|
|
sorted(bitstring.REPLACEMENTS_LE.keys()))
|
||
|
|
self.assertEqual(sorted(bitstring.REPLACEMENTS_BE.keys()),
|
||
|
|
sorted(bitstring.PACK_CODE_SIZE.keys()))
|
||
|
|
for key in bitstring.PACK_CODE_SIZE:
|
||
|
|
be = pack(bitstring.REPLACEMENTS_BE[key], 0)
|
||
|
|
le = pack(bitstring.REPLACEMENTS_LE[key], 0)
|
||
|
|
self.assertEqual(be.len, bitstring.PACK_CODE_SIZE[key] * 8)
|
||
|
|
self.assertEqual(le.len, be.len)
|
||
|
|
|
||
|
|
# These tests don't compile for Python 3, so they're commented out to save me stress.
|
||
|
|
#def testUnicode(self):
|
||
|
|
#a = ConstBitStream(u'uint:12=34')
|
||
|
|
#self.assertEqual(a.uint, 34)
|
||
|
|
#a += u'0xfe'
|
||
|
|
#self.assertEqual(a[12:], '0xfe')
|
||
|
|
#a = BitStream('0x1122')
|
||
|
|
#c = a.byteswap(u'h')
|
||
|
|
#self.assertEqual(c, 1)
|
||
|
|
#self.assertEqual(a, u'0x2211')
|
||
|
|
|
||
|
|
#def testLongInt(self):
|
||
|
|
#a = BitStream(4L)
|
||
|
|
#self.assertEqual(a, '0b0000')
|
||
|
|
#a[1:3] = -1L
|
||
|
|
#self.assertEqual(a, '0b0110')
|
||
|
|
#a[0] = 1L
|
||
|
|
#self.assertEqual(a, '0b1110')
|
||
|
|
#a *= 4L
|
||
|
|
#self.assertEqual(a, '0xeeee')
|
||
|
|
#c = a.byteswap(2L)
|
||
|
|
#self.assertEqual(c, 1)
|
||
|
|
#a = BitStream('0x11223344')
|
||
|
|
#a.byteswap([1, 2L])
|
||
|
|
#self.assertEqual(a, '0x11332244')
|
||
|
|
#b = a*2L
|
||
|
|
#self.assertEqual(b, '0x1133224411332244')
|
||
|
|
#s = pack('uint:12', 46L)
|
||
|
|
#self.assertEqual(s.uint, 46)
|
||
|
|
|
||
|
|
|
||
|
|
class UnpackWithDict(unittest.TestCase):
|
||
|
|
def testLengthKeywords(self):
|
||
|
|
a = ConstBitStream('2*13=100, 0b111')
|
||
|
|
x, y, z = a.unpack('n, uint:m, bin:q', n=13, m=13, q=3)
|
||
|
|
self.assertEqual(x, 100)
|
||
|
|
self.assertEqual(y, 100)
|
||
|
|
self.assertEqual(z, '111')
|
||
|
|
|
||
|
|
def testLengthKeywordsWithStretch(self):
|
||
|
|
a = ConstBitStream('0xff, 0b000, 0xf')
|
||
|
|
x, y, z = a.unpack('hex:a, bin, hex:b', a=8, b=4)
|
||
|
|
self.assertEqual(y, '000')
|
||
|
|
|
||
|
|
def testUnusedKeyword(self):
|
||
|
|
a = ConstBitStream('0b110')
|
||
|
|
x, = a.unpack('bin:3', notused=33)
|
||
|
|
self.assertEqual(x, '110')
|
||
|
|
|
||
|
|
def testLengthKeywordErrors(self):
|
||
|
|
a = pack('uint:p=33', p=12)
|
||
|
|
self.assertRaises(ValueError, a.unpack, 'uint:p')
|
||
|
|
self.assertRaises(ValueError, a.unpack, 'uint:p', p='a_string')
|
||
|
|
|
||
|
|
|
||
|
|
class ReadWithDict(unittest.TestCase):
|
||
|
|
def testLengthKeywords(self):
|
||
|
|
s = BitStream('0x0102')
|
||
|
|
x, y = s.readlist('a, hex:b', a=8, b=4)
|
||
|
|
self.assertEqual((x, y), (1, '0'))
|
||
|
|
self.assertEqual(s.pos, 12)
|
||
|
|
|
||
|
|
def testBytesKeywordProblem(self):
|
||
|
|
s = BitStream('0x01')
|
||
|
|
x, = s.unpack('bytes:a', a=1)
|
||
|
|
self.assertEqual(x, b'\x01')
|
||
|
|
|
||
|
|
s = BitStream('0x000ff00a')
|
||
|
|
x, y, z = s.unpack('12, bytes:x, bits', x=2)
|
||
|
|
self.assertEqual((x, y, z), (0, b'\xff\x00', '0xa'))
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
class PeekWithDict(unittest.TestCase):
|
||
|
|
def testLengthKeywords(self):
|
||
|
|
s = BitStream('0x0102')
|
||
|
|
x, y = s.peeklist('a, hex:b', a=8, b=4)
|
||
|
|
self.assertEqual((x, y), (1, '0'))
|
||
|
|
self.assertEqual(s.pos, 0)
|
||
|
|
|
||
|
|
##class Miscellany(unittest.TestCase):
|
||
|
|
##
|
||
|
|
## def testNumpyInt(self):
|
||
|
|
## try:
|
||
|
|
## import numpy
|
||
|
|
## a = ConstBitStream(uint=numpy.uint8(5), length=3)
|
||
|
|
## self.assertEqual(a.uint, 5)
|
||
|
|
## except ImportError:
|
||
|
|
## # Not to worry
|
||
|
|
## pass
|
||
|
|
|
||
|
|
class BoolToken(unittest.TestCase):
|
||
|
|
def testInterpretation(self):
|
||
|
|
a = ConstBitStream('0b1')
|
||
|
|
self.assertEqual(a.bool, True)
|
||
|
|
self.assertEqual(a.read('bool'), True)
|
||
|
|
self.assertEqual(a.unpack('bool')[0], True)
|
||
|
|
b = ConstBitStream('0b0')
|
||
|
|
self.assertEqual(b.bool, False)
|
||
|
|
self.assertEqual(b.peek('bool'), False)
|
||
|
|
self.assertEqual(b.unpack('bool')[0], False)
|
||
|
|
|
||
|
|
def testPack(self):
|
||
|
|
a = pack('bool=True')
|
||
|
|
b = pack('bool=False')
|
||
|
|
self.assertEqual(a.bool, True)
|
||
|
|
self.assertEqual(b.bool, False)
|
||
|
|
c = pack('4*bool', False, True, 'False', 'True')
|
||
|
|
self.assertEqual(c, '0b0101')
|
||
|
|
|
||
|
|
def testAssignment(self):
|
||
|
|
a = BitStream()
|
||
|
|
a.bool = True
|
||
|
|
self.assertEqual(a.bool, True)
|
||
|
|
a.hex = 'ee'
|
||
|
|
a.bool = False
|
||
|
|
self.assertEqual(a.bool, False)
|
||
|
|
a.bool = 'False'
|
||
|
|
self.assertEqual(a.bool, False)
|
||
|
|
a.bool = 'True'
|
||
|
|
self.assertEqual(a.bool, True)
|
||
|
|
a.bool = 0
|
||
|
|
self.assertEqual(a.bool, False)
|
||
|
|
a.bool = 1
|
||
|
|
self.assertEqual(a.bool, True)
|
||
|
|
|
||
|
|
def testErrors(self):
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'bool', 'hello')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'bool=true')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'True')
|
||
|
|
self.assertRaises(bitstring.CreationError, pack, 'bool', 2)
|
||
|
|
a = BitStream('0b11')
|
||
|
|
self.assertRaises(bitstring.InterpretError, a._getbool)
|
||
|
|
b = BitStream()
|
||
|
|
self.assertRaises(bitstring.InterpretError, a._getbool)
|
||
|
|
self.assertRaises(bitstring.CreationError, a._setbool, 'false')
|
||
|
|
|
||
|
|
def testLengthWithBoolRead(self):
|
||
|
|
a = ConstBitStream('0xf')
|
||
|
|
self.assertRaises(ValueError, a.read, 'bool:0')
|
||
|
|
self.assertRaises(ValueError, a.read, 'bool:1')
|
||
|
|
self.assertRaises(ValueError, a.read, 'bool:2')
|
||
|
|
|
||
|
|
|
||
|
|
class ReadWithIntegers(unittest.TestCase):
|
||
|
|
def testReadInt(self):
|
||
|
|
a = ConstBitStream('0xffeedd')
|
||
|
|
b = a.read(8)
|
||
|
|
self.assertEqual(b.hex, 'ff')
|
||
|
|
self.assertEqual(a.pos, 8)
|
||
|
|
b = a.peek(8)
|
||
|
|
self.assertEqual(b.hex, 'ee')
|
||
|
|
self.assertEqual(a.pos, 8)
|
||
|
|
b = a.peek(1)
|
||
|
|
self.assertEqual(b, '0b1')
|
||
|
|
b = a.read(1)
|
||
|
|
self.assertEqual(b, '0b1')
|
||
|
|
|
||
|
|
def testReadIntList(self):
|
||
|
|
a = ConstBitStream('0xab, 0b110')
|
||
|
|
b, c = a.readlist([8, 3])
|
||
|
|
self.assertEqual(b.hex, 'ab')
|
||
|
|
self.assertEqual(c.bin, '110')
|
||
|
|
|
||
|
|
|
||
|
|
class FileReadingStrategy(unittest.TestCase):
|
||
|
|
def testBitStreamIsAlwaysRead(self):
|
||
|
|
a = BitStream(filename='smalltestfile')
|
||
|
|
self.assertTrue(isinstance(a._datastore, bitstring.ByteStore))
|
||
|
|
f = open('smalltestfile', 'rb')
|
||
|
|
b = BitStream(f)
|
||
|
|
self.assertTrue(isinstance(b._datastore, bitstring.ByteStore))
|
||
|
|
|
||
|
|
def testBitsIsNeverRead(self):
|
||
|
|
a = ConstBitStream(filename='smalltestfile')
|
||
|
|
self.assertTrue(isinstance(a._datastore._rawarray, bitstring.MmapByteArray))
|
||
|
|
f = open('smalltestfile', 'rb')
|
||
|
|
b = ConstBitStream(f)
|
||
|
|
self.assertTrue(isinstance(b._datastore._rawarray, bitstring.MmapByteArray))
|
||
|
|
|
||
|
|
|
||
|
|
class Count(unittest.TestCase):
|
||
|
|
def testCount(self):
|
||
|
|
a = ConstBitStream('0xf0f')
|
||
|
|
self.assertEqual(a.count(True), 8)
|
||
|
|
self.assertEqual(a.count(False), 4)
|
||
|
|
|
||
|
|
b = BitStream()
|
||
|
|
self.assertEqual(b.count(True), 0)
|
||
|
|
self.assertEqual(b.count(False), 0)
|
||
|
|
|
||
|
|
def testCountWithOffsetData(self):
|
||
|
|
a = ConstBitStream('0xff0120ff')
|
||
|
|
b = a[1:-1]
|
||
|
|
self.assertEqual(b.count(1), 16)
|
||
|
|
self.assertEqual(b.count(0), 14)
|
||
|
|
|
||
|
|
|
||
|
|
class ZeroBitReads(unittest.TestCase):
|
||
|
|
def testInteger(self):
|
||
|
|
a = ConstBitStream('0x123456')
|
||
|
|
self.assertRaises(bitstring.InterpretError, a.read, 'uint:0')
|
||
|
|
self.assertRaises(bitstring.InterpretError, a.read, 'float:0')
|
||
|
|
|
||
|
|
#class EfficientBitsCopies(unittest.TestCase):
|
||
|
|
#
|
||
|
|
# def testBitsCopy(self):
|
||
|
|
# a = ConstBitStream('0xff')
|
||
|
|
# b = ConstBitStream(a)
|
||
|
|
# c = a[:]
|
||
|
|
# d = copy.copy(a)
|
||
|
|
# self.assertTrue(a._datastore is b._datastore)
|
||
|
|
# self.assertTrue(a._datastore is c._datastore)
|
||
|
|
# self.assertTrue(a._datastore is d._datastore)
|
||
|
|
|
||
|
|
class InitialiseFromBytes(unittest.TestCase):
|
||
|
|
def testBytesBehaviour(self):
|
||
|
|
a = ConstBitStream(b'uint:5=2')
|
||
|
|
b = ConstBitStream(b'')
|
||
|
|
c = ConstBitStream(bytes=b'uint:5=2')
|
||
|
|
if b'' == '':
|
||
|
|
# Python 2
|
||
|
|
self.assertEqual(a, 'uint:5=2')
|
||
|
|
self.assertFalse(b)
|
||
|
|
self.assertEqual(c.bytes, b'uint:5=2')
|
||
|
|
else:
|
||
|
|
self.assertEqual(a.bytes, b'uint:5=2')
|
||
|
|
self.assertFalse(b)
|
||
|
|
self.assertEqual(c, b'uint:5=2')
|
||
|
|
|
||
|
|
def testBytearrayBehaviour(self):
|
||
|
|
a = ConstBitStream(bytearray(b'uint:5=2'))
|
||
|
|
b = ConstBitStream(bytearray(4))
|
||
|
|
c = ConstBitStream(bytes=bytearray(b'uint:5=2'))
|
||
|
|
self.assertEqual(a.bytes, b'uint:5=2')
|
||
|
|
self.assertEqual(b, '0x00000000')
|
||
|
|
self.assertEqual(c.bytes, b'uint:5=2')
|
||
|
|
|
||
|
|
|
||
|
|
class CoverageCompletionTests(unittest.TestCase):
|
||
|
|
def testUeReadError(self):
|
||
|
|
s = ConstBitStream('0b000000001')
|
||
|
|
self.assertRaises(bitstring.ReadError, s.read, 'ue')
|
||
|
|
|
||
|
|
def testOverwriteWithSelf(self):
|
||
|
|
s = BitStream('0b1101')
|
||
|
|
s.overwrite(s)
|
||
|
|
self.assertEqual(s, '0b1101')
|
||
|
|
|
||
|
|
|
||
|
|
class Subclassing(unittest.TestCase):
|
||
|
|
|
||
|
|
def testIsInstance(self):
|
||
|
|
class SubBits(BitStream): pass
|
||
|
|
a = SubBits()
|
||
|
|
self.assertTrue(isinstance(a, SubBits))
|
||
|
|
|
||
|
|
def testClassType(self):
|
||
|
|
class SubBits(BitStream): pass
|
||
|
|
self.assertEqual(SubBits().__class__, SubBits)
|
||
|
|
|
||
|
|
|
||
|
|
class BytesProblems(unittest.TestCase):
|
||
|
|
|
||
|
|
def testOffsetButNoLength(self):
|
||
|
|
b = BitStream(bytes=b'\x00\xaa', offset=8)
|
||
|
|
self.assertEqual(b.hex, 'aa')
|
||
|
|
b = BitStream(bytes=b'\x00\xaa', offset=4)
|
||
|
|
self.assertEqual(b.hex, '0aa')
|
||
|
|
|
||
|
|
def testInvert(self):
|
||
|
|
b = BitStream(bytes=b'\x00\xaa', offset=8, length=8)
|
||
|
|
self.assertEqual(b.hex, 'aa')
|
||
|
|
b.invert()
|
||
|
|
self.assertEqual(b.hex, '55')
|
||
|
|
|
||
|
|
def testPrepend(self):
|
||
|
|
b = BitStream(bytes=b'\xaa\xbb', offset=8, length=4)
|
||
|
|
self.assertEqual(b.hex, 'b')
|
||
|
|
b.prepend('0xe')
|
||
|
|
self.assertEqual(b.hex, 'eb')
|
||
|
|
b = BitStream(bytes=b'\x00\xaa', offset=8, length=8)
|
||
|
|
b.prepend('0xee')
|
||
|
|
self.assertEqual(b.hex, 'eeaa')
|
||
|
|
|
||
|
|
def testByteSwap(self):
|
||
|
|
b = BitStream(bytes=b'\x01\x02\x03\x04', offset=8)
|
||
|
|
b.byteswap()
|
||
|
|
self.assertEqual(b, '0x040302')
|
||
|
|
|
||
|
|
def testBinProperty(self):
|
||
|
|
b = BitStream(bytes=b'\x00\xaa', offset=8, length=4)
|
||
|
|
self.assertEqual(b.bin, '1010')
|