test_bitstream.py

#!/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 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)
        with open('smalltestfile', 'rb') as f:
            #        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')
        with self.assertRaises(ValueError):
            a.bytes

    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):
        # I couldn't find a way to test both types of native endianness
        # on a single machine, so only one set of tests will run.
        if 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'))
        else:
            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'))

    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 testStructTokens3(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, 18, 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: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))
        with open('smalltestfile', 'rb') as f:
            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))
        with open('smalltestfile', 'rb') as f:
            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 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')