diff options
Diffstat (limited to 'python/bitstring/test/test_bitstream.py')
| -rw-r--r-- | python/bitstring/test/test_bitstream.py | 3940 |
1 files changed, 3940 insertions, 0 deletions
diff --git a/python/bitstring/test/test_bitstream.py b/python/bitstring/test/test_bitstream.py new file mode 100644 index 000000000..f94193d32 --- /dev/null +++ b/python/bitstring/test/test_bitstream.py @@ -0,0 +1,3940 @@ +#!/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')
\ No newline at end of file |