if is_py3k:

return bytes(s.encode('latin1'))

elif sys.version_info[:2] >= (2, 6):

return bytes(s)

else:

def randombitarrays(self):

for n in list(range(25)) + [randint(1000, 2000)]:

a = bitarray(endian=['little', 'big'][randint(0, 1)])

a.frombytes(os.urandom(bits2bytes(n)))

del a[n:]

yield a

def randomlists(self):

for n in list(range(25)) + [randint(1000, 2000)]:

yield [bool(randint(0, 1)) for d in range(n)]

def rndsliceidx(self, length):

if randint(0, 1):

return None

else:

return randint(-2 * length, 2 * length - 1)

def slicelen(self, r, length):

return getIndicesEx(r, length)[-1]

def check_obj(self, a):

self.assertEqual(repr(type(a)), "<class 'bitarray.bitarray'>")

unused = 8 * a.buffer_info()[1] - len(a)

self.assert_(0 <= unused < 8)

self.assertEqual(unused, a.buffer_info()[3])

def assertEQUAL(self, a, b):

self.assertEqual(a, b)

self.assertEqual(a.endian(), b.endian())

self.check_obj(a)

self.check_obj(b)

def assertStopIteration(self, it):

if is_py3k:

return

if not isinstance(r, slice):

raise TypeError("slice object expected")

start = r.start

stop = r.stop

step = r.step

if r.step is None:

step = 1

else:

if step == 0:

raise ValueError("slice step cannot be zero")

if step < 0:

defstart = length - 1

defstop = -1

else:

defstart = 0

defstop = length

if r.start is None:

start = defstart

else:

if start < 0: start += length

if start < 0: start = [0, -1][step < 0]

if start >= length: start = [length, length - 1][step < 0]

if r.stop is None:

stop = defstop

else:

if stop < 0: stop += length

if stop < 0: stop = -1

if stop > length: stop = length

if (step < 0 and stop >= length) or (step > 0 and start >= stop):

slicelength = 0

elif step < 0:

slicelength = (stop - start + 1) / step + 1

else:

slicelength = (stop - start - 1) / step + 1

if slicelength < 0:

slicelength = 0

def test_bitdiff(self):

a = bitarray('0011')

b = bitarray('0101')

self.assertEqual(bitdiff(a, b), 2)

self.assertRaises(TypeError, bitdiff, a, '')

self.assertRaises(TypeError, bitdiff, '1', b)

self.assertRaises(TypeError, bitdiff, a, 4)

b.append(1)

self.assertRaises(ValueError, bitdiff, a, b)

for n in list(range(50)) + [randint(1000, 2000)]:

a = bitarray()

a.frombytes(os.urandom(bits2bytes(n)))

del a[n:]

b = bitarray()

b.frombytes(os.urandom(bits2bytes(n)))

del b[n:]

diff = sum(a[i] ^ b[i] for i in range(n))

self.assertEqual(bitdiff(a, b), diff)

def test_bits2bytes(self):

for arg in ['foo', [], None, {}]:

self.assertRaises(TypeError, bits2bytes, arg)

self.assertRaises(TypeError, bits2bytes)

self.assertRaises(TypeError, bits2bytes, 1, 2)

self.assertRaises(ValueError, bits2bytes, -1)

self.assertRaises(ValueError, bits2bytes, -924)

self.assertEqual(bits2bytes(0), 0)

for n in range(1, 1000):

self.assertEqual(bits2bytes(n), (n - 1) // 8 + 1)

for n, m in [(0, 0), (1, 1), (2, 1), (7, 1), (8, 1), (9, 2),

(10, 2), (15, 2), (16, 2), (64, 8), (65, 9),

(0, 0), (1, 1), (65, 9), (2**29, 2**26),

(2**31, 2**28), (2**32, 2**29), (2**34, 2**31),

(2**34+793, 2**31+100), (2**35-8, 2**32-1),

(2**62, 2**59), (2**63-8, 2**60-1)]:

def test_noInitializer(self):

a = bitarray()

self.assertEqual(len(a), 0)

self.assertEqual(a.tolist(), [])

self.check_obj(a)

def test_endian1(self):

a = bitarray(endian='little')

a.fromstring('A')

self.assertEqual(a.endian(), 'little')

self.check_obj(a)

b = bitarray(endian='big')

b.fromstring('A')

self.assertEqual(b.endian(), 'big')

self.check_obj(b)

self.assertEqual(a.tostring(), b.tostring())

def test_endian2(self):

a = bitarray(endian='little')

a.fromstring(' ')

self.assertEqual(a.endian(), 'little')

self.check_obj(a)

b = bitarray(endian='big')

b.fromstring(' ')

self.assertEqual(b.endian(), 'big')

self.check_obj(b)

self.assertEqual(a.tostring(), b.tostring())

self.assertRaises(TypeError, bitarray.__new__, bitarray, endian=0)

self.assertRaises(ValueError, bitarray.__new__, bitarray, endian='')

self.assertRaises(ValueError, bitarray.__new__,

bitarray, endian='foo')

def test_integers(self):

for n in range(50):

a = bitarray(n)

self.assertEqual(len(a), n)

self.check_obj(a)

a = bitarray(int(n))

self.assertEqual(len(a), n)

self.check_obj(a)

self.assertRaises(ValueError, bitarray.__new__, bitarray, -1)

self.assertRaises(ValueError, bitarray.__new__, bitarray, -924)

def test_list(self):

lst = ['foo', None, [1], {}]

a = bitarray(lst)

self.assertEqual(a.tolist(), [True, False, True, False])

self.check_obj(a)

for n in range(50):

lst = [bool(randint(0, 1)) for d in range(n)]

a = bitarray(lst)

self.assertEqual(a.tolist(), lst)

self.check_obj(a)

def test_tuple(self):

tup = ('', True, [], {1:2})

a = bitarray(tup)

self.assertEqual(a.tolist(), [False, True, False, True])

self.check_obj(a)

for n in range(50):

lst = [bool(randint(0, 1)) for d in range(n)]

a = bitarray(tuple(lst))

self.assertEqual(a.tolist(), lst)

self.check_obj(a)

def test_iter1(self):

for n in range(50):

lst = [bool(randint(0, 1)) for d in range(n)]

a = bitarray(iter(lst))

self.assertEqual(a.tolist(), lst)

self.check_obj(a)

def test_iter2(self):

for lst in self.randomlists():

def foo():

for x in lst:

yield x

a = bitarray(foo())

self.assertEqual(a, bitarray(lst))

self.check_obj(a)

def test_01(self):

a = bitarray('0010111')

self.assertEqual(a.tolist(), [0, 0, 1, 0, 1, 1, 1])

self.check_obj(a)

for n in range(50):

lst = [bool(randint(0, 1)) for d in range(n)]

s = ''.join([['0', '1'][x] for x in lst])

a = bitarray(s)

self.assertEqual(a.tolist(), lst)

self.check_obj(a)

self.assertRaises(ValueError, bitarray.__new__, bitarray, '01012100')

def test_rawbytes(self): # this representation is used for pickling

for s, r in [('\x00', ''), ('\x07\xff', '1'), ('\x03\xff', '11111'),

('\x01\x87\xda', '10000111' '1101101')]:

self.assertEqual(bitarray(to_bytes(s), endian='big'),

bitarray(r))

for i in range(1, 8):

self.assertRaises(ValueError, bitarray.__new__,

bitarray, to_bytes(chr(i)))

def test_bitarray(self):

for n in range(50):

a = bitarray(n)

b = bitarray(a)

self.assert_(a is not b)

self.assertEQUAL(a, b)

for end in ('little', 'big'):

a = bitarray(endian=end)

c = bitarray(a)

self.assertEqual(c.endian(), end)

c = bitarray(a, endian='little')

self.assertEqual(c.endian(), 'little')

c = bitarray(a, endian='big')

self.assertEqual(c.endian(), 'big')

def test_None(self):

self.assertEQUAL(bitarray(), bitarray(0))

self.assertEQUAL(bitarray(), bitarray(None))

def test_WrongArgs(self):

self.assertRaises(TypeError, bitarray.__new__, bitarray, 'A', 42, 69)

self.assertRaises(TypeError, bitarray.__new__, bitarray, Ellipsis)

self.assertRaises(TypeError, bitarray.__new__, bitarray, slice(0))

self.assertRaises(TypeError, bitarray.__new__, bitarray, 2.345)

self.assertRaises(TypeError, bitarray.__new__, bitarray, 4+3j)

self.assertRaises(TypeError, bitarray.__new__, bitarray, '', 0, 42)

def test_int(self):

a = bitarray()

self.assertRaises(TypeError, int, a)

if not is_py3k:

self.assertRaises(TypeError, long, a)

def test_float(self):

a = bitarray()

self.assertRaises(TypeError, float, a)

def test_complext(self):

a = bitarray()

self.assertRaises(TypeError, complex, a)

def test_list(self):

for a in self.randombitarrays():

self.assertEqual(list(a), a.tolist())

def test_tuple(self):

for a in self.randombitarrays():

def test_buffer_info1(self):

a = bitarray('0000111100001', endian='little')

self.assertEqual(a.buffer_info()[1:4], (2, 'little', 3))

a = bitarray()

self.assertRaises(TypeError, a.buffer_info, 42)

bi = a.buffer_info()

self.assert_(isinstance(bi, tuple))

self.assertEqual(len(bi), 5)

self.assert_(isinstance(bi[0], int))

if is_py3k:

self.assert_(isinstance(bi[1], int))

self.assert_(isinstance(bi[2], str))

self.assert_(isinstance(bi[3], int))

if is_py3k:

self.assert_(isinstance(bi[4], int))

def test_buffer_info2(self):

for n in range(50):

bi = bitarray(n).buffer_info()

self.assertEqual(bi[1], bits2bytes(n))

self.assertEqual(bi[3] + n, 8 * bi[1])

self.assert_(bi[4] >= bi[1])

def test_buffer_info3(self):

a = bitarray(endian='little')

self.assertEqual(a.buffer_info()[2], 'little')

a = bitarray(endian='big')

self.assertEqual(a.buffer_info()[2], 'big')

def test_endian(self):

a = bitarray(endian='little')

self.assertEqual(a.endian(), 'little')

a = bitarray(endian='big')

self.assertEqual(a.endian(), 'big')

def test_length(self):

for n in range(1000):

a = bitarray(n)

self.assertEqual(len(a), n)

def test_getitem1(self):

a = bitarray()

self.assertRaises(IndexError, a.__getitem__, 0)

a.append(True)

self.assertEqual(a[0], True)

self.assertRaises(IndexError, a.__getitem__, 1)

self.assertRaises(IndexError, a.__getitem__, -2)

a.append(False)

self.assertEqual(a[1], False)

self.assertRaises(IndexError, a.__getitem__, 2)

self.assertRaises(IndexError, a.__getitem__, -3)

def test_getitem2(self):

a = bitarray('1100010')

for i, b in enumerate([True, True, False, False, False, True, False]):

self.assertEqual(a[i], b)

self.assertEqual(a[i-7], b)

self.assertRaises(IndexError, a.__getitem__, 7)

self.assertRaises(IndexError, a.__getitem__, -8)

def test_getitem3(self):

a = bitarray('0100000100001')

self.assertEQUAL(a[:], a)

self.assert_(a[:] is not a)

aa = a.tolist()

self.assertEQUAL(a[11:2:-3], bitarray(aa[11:2:-3]))

self.check_obj(a[:])

self.assertRaises(ValueError, a.__getitem__, slice(None, None, 0))

self.assertRaises(TypeError, a.__getitem__, (1, 2))

def test_getitem4(self):

for a in self.randombitarrays():

aa = a.tolist()

la = len(a)

if la == 0: continue

for dum in range(10):

step = self.rndsliceidx(la)

if step == 0: step = None

s = slice(self.rndsliceidx(la),

self.rndsliceidx(la), step)

self.assertEQUAL(a[s], bitarray(aa[s], endian=a.endian()))

def test_setitem1(self):

a = bitarray([False])

a[0] = 1

self.assertEqual(a.tolist(), [True])

a = bitarray(2)

a[0] = 0

a[1] = 1

self.assertEqual(a.tolist(), [False, True])

a[-1] = 0

a[-2] = 1

self.assertEqual(a.tolist(), [True, False])

self.assertRaises(IndexError, a.__setitem__, 2, True)

self.assertRaises(IndexError, a.__setitem__, -3, False)

def test_setitem2(self):

for a in self.randombitarrays():

la = len(a)

if la == 0:

continue

i = randint(0, la - 1)

aa = a.tolist()

ida = id(a)

val = bool(randint(0, 1))

a[i] = val

aa[i] = val

self.assertEqual(a.tolist(), aa)

self.assertEqual(id(a), ida)

self.check_obj(a)

b = bitarray(la)

b[0:la] = bitarray(a)

self.assertEqual(a, b)

self.assertNotEqual(id(a), id(b))

b = bitarray(la)

b[:] = bitarray(a)

self.assertEqual(a, b)

self.assertNotEqual(id(a), id(b))

b = bitarray(la)

b[::-1] = bitarray(a)

self.assertEqual(a.tolist()[::-1], b.tolist())

def test_setitem3(self):

a = bitarray(5 * [False])

a[0] = 1

a[-2] = 1

self.assertEqual(a, bitarray('10010'))

self.assertRaises(IndexError, a.__setitem__, 5, 'foo')

self.assertRaises(IndexError, a.__setitem__, -6, 'bar')

def test_setitem4(self):

for a in self.randombitarrays():

la = len(a)

if la == 0: continue

for dum in range(3):

step = self.rndsliceidx(la)

if step == 0: step = None

s = slice(self.rndsliceidx(la),

self.rndsliceidx(la), step)

for b in self.randombitarrays():

if len(b) == self.slicelen(s, len(a)) or step is None:

c = bitarray(a)

d = c

c[s] = b

self.assert_(c is d)

self.check_obj(c)

cc = a.tolist()

cc[s] = b.tolist()

self.assertEqual(c, bitarray(cc))

def test_setslice_to_bool(self):

a = bitarray('11111111')

a[::2] = False

self.assertEqual(a, bitarray('01010101'))

a[4::] = True

self.assertEqual(a, bitarray('01011111'))

a[-2:] = False

self.assertEqual(a, bitarray('01011100'))

a[:2:] = True

self.assertEqual(a, bitarray('11011100'))

a[:] = True

self.assertEqual(a, bitarray('11111111'))

def test_setslice_to_int(self):

a = bitarray('11111111')

a[::2] = 0

self.assertEqual(a, bitarray('01010101'))

a[4::] = 1

self.assertEqual(a, bitarray('01011111'))

a.__setitem__(slice(-2, None, None), 0)

self.assertEqual(a, bitarray('01011100'))

self.assertRaises(ValueError, a.__setitem__,

slice(None, None, 2), 3)

self.assertRaises(ValueError, a.__setitem__,

slice(None, 2, None), -1)

def test_delitem1(self):

a = bitarray('100110')

del a[1]

self.assertEqual(len(a), 5)

del a[3]

del a[-2]

self.assertEqual(a, bitarray('100'))

self.assertRaises(IndexError, a.__delitem__, 3)

self.assertRaises(IndexError, a.__delitem__, -4)

def test_delitem2(self):

for a in self.randombitarrays():

la = len(a)

if la == 0: continue

for dum in range(10):

step = self.rndsliceidx(la)

if step == 0: step = None

s = slice(self.rndsliceidx(la),

self.rndsliceidx(la), step)

c = bitarray(a)

d = c

del c[s]

self.assert_(c is d)

self.check_obj(c)

cc = a.tolist()

del cc[s]

def test_instancecheck(self):

a = bitarray('011')

self.assertTrue(isinstance(a, bitarray))

self.assertFalse(isinstance(a, str))

def test_booleanness(self):

self.assertEqual(bool(bitarray('')), False)

self.assertEqual(bool(bitarray('0')), True)

self.assertEqual(bool(bitarray('1')), True)

def test_iterate(self):

for lst in self.randomlists():

acc = []

for b in bitarray(lst):

acc.append(b)

self.assertEqual(acc, lst)

def test_iter1(self):

it = iter(bitarray('011'))

self.assertEqual(next(it), False)

self.assertEqual(next(it), True)

self.assertEqual(next(it), True)

self.assertStopIteration(it)

def test_iter2(self):

for a in self.randombitarrays():

aa = a.tolist()

self.assertEqual(list(a), aa)

self.assertEqual(list(iter(a)), aa)

def test_assignment(self):

a = bitarray('00110111001')

a[1:3] = a[7:9]

a[-1:] = a[:1]

b = bitarray('01010111000')

self.assertEqual(a, b)

def test_compare(self):

for a in self.randombitarrays():

aa = a.tolist()

for b in self.randombitarrays():

bb = b.tolist()

self.assertEqual(a == b, aa == bb)

self.assertEqual(a != b, aa != bb)

self.assertEqual(a <= b, aa <= bb)

self.assertEqual(a < b, aa < bb)

self.assertEqual(a >= b, aa >= bb)

self.assertEqual(a > b, aa > bb)

def test_subclassing(self):

class ExaggeratingBitarray(bitarray):

def __new__(cls, data, offset):

return bitarray.__new__(cls, data)

def __init__(self, data, offset):

self.offset = offset

def __getitem__(self, i):

return bitarray.__getitem__(self, i - self.offset)

for a in self.randombitarrays():

if len(a) == 0:

continue

b = ExaggeratingBitarray(a, 1234)

for i in range(len(a)):

self.assertEqual(a[i], b[i+1234])

def test_endianness1(self):

a = bitarray(endian='little')

a.frombytes(to_bytes('\x01'))

self.assertEqual(a.to01(), '10000000')

b = bitarray(endian='little')

b.frombytes(to_bytes('\x80'))

self.assertEqual(b.to01(), '00000001')

c = bitarray(endian='big')

c.frombytes(to_bytes('\x80'))

self.assertEqual(c.to01(), '10000000')

d = bitarray(endian='big')

d.frombytes(to_bytes('\x01'))

self.assertEqual(d.to01(), '00000001')

self.assertEqual(a, c)

self.assertEqual(b, d)

def test_endianness2(self):

a = bitarray(8, endian='little')

a.setall(False)

a[0] = True

self.assertEqual(a.tobytes(), to_bytes('\x01'))

a[1] = True

self.assertEqual(a.tobytes(), to_bytes('\x03'))

a.frombytes(to_bytes(' '))

self.assertEqual(a.tobytes(), to_bytes('\x03 '))

self.assertEqual(a.to01(), '1100000000000100')

def test_endianness3(self):

a = bitarray(8, endian='big')

a.setall(False)

a[7] = True

self.assertEqual(a.tobytes(), to_bytes('\x01'))

a[6] = True

self.assertEqual(a.tobytes(), to_bytes('\x03'))

a.frombytes(to_bytes(' '))

self.assertEqual(a.tobytes(), to_bytes('\x03 '))

self.assertEqual(a.to01(), '0000001100100000')

def test_endianness4(self):

a = bitarray('00100000', endian='big')

self.assertEqual(a.tobytes(), to_bytes(' '))

b = bitarray('00000100', endian='little')

self.assertEqual(b.tobytes(), to_bytes(' '))

self.assertNotEqual(a, b)

def test_endianness5(self):

a = bitarray('11100000', endian='little')

b = bitarray(a, endian='big')

self.assertNotEqual(a, b)

self.assertEqual(a.tobytes(), b.tobytes())

def test_pickle(self):

from pickle import loads, dumps

for v in range(3):

for a in self.randombitarrays():

b = loads(dumps(a, v))

self.assert_(b is not a)

self.assertEQUAL(a, b)

def test_cPickle(self):

if is_py3k:

return

for v in range(3):

from cPickle import loads, dumps

for a in self.randombitarrays():

b = loads(dumps(a, v))

self.assert_(b is not a)

self.assertEQUAL(a, b)

def test_overflow(self):

from platform import architecture

if architecture()[0] == '64bit':

return

self.assertRaises(OverflowError, bitarray.__new__,

bitarray, 2**34 + 1)

a = bitarray(10 ** 6)

def test_all(self):

a = bitarray()

self.assertTrue(a.all())

if sys.version_info[:2] < (2, 5):

return

for a in self.randombitarrays():

self.assertEqual(all(a), a.all())

self.assertEqual(all(a.tolist()), a.all())

def test_any(self):

a = bitarray()

self.assertFalse(a.any())

if sys.version_info[:2] < (2, 5):

return

for a in self.randombitarrays():

self.assertEqual(any(a), a.any())

self.assertEqual(any(a.tolist()), a.any())

def test_repr(self):

a = bitarray()

self.assertEqual(repr(a), "bitarray()")

a = bitarray('10111')

self.assertEqual(repr(a), "bitarray('10111')")

for a in self.randombitarrays():

b = eval(repr(a))

self.assert_(b is not a)

self.assertEqual(a, b)

self.check_obj(b)

def test_copy(self):

import copy

for a in self.randombitarrays():

b = a.copy()

self.assert_(b is not a)

self.assertEQUAL(a, b)

b = copy.copy(a)

self.assert_(b is not a)

self.assertEQUAL(a, b)

b = copy.deepcopy(a)

self.assert_(b is not a)

self.assertEQUAL(a, b)

def assertReallyEqual(self, a, b):

# assertEqual first, because it will have a good message if the

# assertion fails.

self.assertEqual(a, b)

self.assertEqual(b, a)

self.assertTrue(a == b)

self.assertTrue(b == a)

self.assertFalse(a != b)

self.assertFalse(b != a)

if not is_py3k:

self.assertEqual(0, cmp(a, b))

self.assertEqual(0, cmp(b, a))

def assertReallyNotEqual(self, a, b):

# assertNotEqual first, because it will have a good message if the

# assertion fails.

self.assertNotEqual(a, b)

self.assertNotEqual(b, a)

self.assertFalse(a == b)

self.assertFalse(b == a)

self.assertTrue(a != b)

self.assertTrue(b != a)

if not is_py3k:

self.assertNotEqual(0, cmp(a, b))

self.assertNotEqual(0, cmp(b, a))

def test_equality(self):

self.assertReallyEqual(bitarray(''), bitarray(''))

self.assertReallyEqual(bitarray('0'), bitarray('0'))

self.assertReallyEqual(bitarray('1'), bitarray('1'))

def test_not_equality(self):

self.assertReallyNotEqual(bitarray(''), bitarray('1'))

self.assertReallyNotEqual(bitarray(''), bitarray('0'))

def test_add(self):

c = bitarray('001') + bitarray('110')

self.assertEQUAL(c, bitarray('001110'))

for a in self.randombitarrays():

aa = a.copy()

for b in self.randombitarrays():

bb = b.copy()

c = a + b

self.assertEqual(c, bitarray(a.tolist() + b.tolist()))

self.assertEqual(c.endian(), a.endian())

self.check_obj(c)

self.assertEQUAL(a, aa)

self.assertEQUAL(b, bb)

a = bitarray()

self.assertRaises(TypeError, a.__add__, 42)

def test_iadd(self):

c = bitarray('001')

c += bitarray('110')

self.assertEQUAL(c, bitarray('001110'))

for a in self.randombitarrays():

for b in self.randombitarrays():

c = bitarray(a)

d = c

d += b

self.assertEqual(d, a + b)

self.assert_(c is d)

self.assertEQUAL(c, d)

self.assertEqual(d.endian(), a.endian())

self.check_obj(d)

a = bitarray()

self.assertRaises(TypeError, a.__iadd__, 42)

def test_mul(self):

c = 0 * bitarray('1001111')

self.assertEQUAL(c, bitarray())

c = 3 * bitarray('001')

self.assertEQUAL(c, bitarray('001001001'))

c = bitarray('110') * 3

self.assertEQUAL(c, bitarray('110110110'))

for a in self.randombitarrays():

b = a.copy()

for n in range(-10, 20):

c = a * n

self.assertEQUAL(c, bitarray(n * a.tolist(),

endian=a.endian()))

c = n * a

self.assertEqual(c, bitarray(n * a.tolist(),

endian=a.endian()))

self.assertEQUAL(a, b)

a = bitarray()

self.assertRaises(TypeError, a.__mul__, None)

def test_imul(self):

c = bitarray('1101110011')

idc = id(c)

c *= 0

self.assertEQUAL(c, bitarray())

self.assertEqual(idc, id(c))

c = bitarray('110')

c *= 3

self.assertEQUAL(c, bitarray('110110110'))

for a in self.randombitarrays():

for n in range(-10, 10):

b = a.copy()

idb = id(b)

b *= n

self.assertEQUAL(b, bitarray(n * a.tolist(),

endian=a.endian()))

self.assertEqual(idb, id(b))