@staticmethod

def randombitarrays(start=0):

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

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

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

del a[n:]

yield a

@staticmethod

def randomlists():

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

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

@staticmethod

def rndsliceidx(length):

if randint(0, 1):

return None

else:

return randint(-length-5, length+5)

@staticmethod

def other_endian(endian):

t = {'little': 'big',

'big': 'little'}

return t[endian]

@staticmethod

def slicelen(s, length):

assert isinstance(s, slice)

start, stop, step = s.indices(length)

slicelength = (stop - start + (1 if step < 0 else -1)) // step + 1

if slicelength < 0:

slicelength = 0

return slicelength

def check_obj(self, a):

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

('class' if is_py3k else 'type'))

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

self.assertTrue(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):

self.assertRaises(StopIteration, next, it)

def assertRaisesMessage(self, excClass, msg, callable, *args, **kwargs):

try:

callable(*args, **kwargs)

except excClass as e:

if msg != str(e):

def test_version_string(self):

# the version string is not a function, but test it here anyway

self.assertIsInstance(__version__, str)

def test_set_default_endian(self):

self.assertRaises(TypeError, _set_default_endian, 0)

self.assertRaises(TypeError, _set_default_endian, 'little', 0)

self.assertRaises(ValueError, _set_default_endian, 'foo')

for default_endian in 'big', 'little', u'big', u'little':

_set_default_endian(default_endian)

a = bitarray()

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

for x in None, 0, 64, '10111', [1, 0]:

a = bitarray(x)

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

for endian in 'big', 'little':

a = bitarray(endian=endian)

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

# make sure that calling _set_default_endian wrong does not

# change the default endianness

self.assertRaises(ValueError, _set_default_endian, 'foobar')

self.assertEqual(bitarray().endian(), default_endian)

def test_get_default_endian(self):

# takes no arguments

self.assertRaises(TypeError, get_default_endian, 'big')

for default_endian in 'big', 'little':

_set_default_endian(default_endian)

endian = get_default_endian()

self.assertEqual(endian, default_endian)

self.assertIsInstance(endian, str)

def test_bits2bytes(self):

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

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, 100):

m = bits2bytes(n)

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

self.assertIsInstance(m, int)

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),

(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_endian(self):

a = bitarray(endian='little')

a.frombytes(b'ABC')

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

self.assertIsInstance(a.endian(), str)

self.check_obj(a)

b = bitarray(endian='big')

b.frombytes(b'ABC')

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

self.assertIsInstance(a.endian(), str)

self.check_obj(b)

self.assertNotEqual(a, b)

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

def test_endian_default(self):

_set_default_endian('big')

a_big = bitarray()

_set_default_endian('little')

a_little = bitarray()

_set_default_endian('big')

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

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

def test_endian_wrong(self):

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

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

self.assertRaisesMessage(

ValueError,

"bit endianness must be either 'little' or 'big', got: 'foo'",

bitarray.__new__, bitarray, endian='foo')

self.assertRaisesMessage(TypeError,

"'ellipsis' object is not iterable",

bitarray.__new__, bitarray, Ellipsis)

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_iter3(self):

a = bitarray(itertools.repeat(False, 10))

self.assertEqual(a, bitarray(10 * '0'))

# Note that the through value of '0' is True: bool('0') -> True

a = bitarray(itertools.repeat('0', 10))

self.assertEqual(a, bitarray(10 * '1'))

def test_range(self):

a = bitarray(range(-3, 3))

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

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 [(b'\x00', ''), (b'\x07\xff', '1'), (b'\x03\xff', '11111'),

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

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

bitarray(r))

for i in range(1, 8):

self.assertRaises(ValueError, bitarray.__new__,

bitarray, bytes(bytearray([i])))

def test_bitarray_simple(self):

for n in range(10):

a = bitarray(n)

b = bitarray(a)

self.assertFalse(a is b)

self.assertEQUAL(a, b)

def test_bitarray_endian(self):

# Test creating a new bitarray with different endianness from an

# existing bitarray.

for endian in 'little', 'big':

a = bitarray(endian=endian)

b = bitarray(a)

self.assertFalse(a is b)

self.assertEQUAL(a, b)

endian2 = self.other_endian(endian)

c = bitarray(a, endian2)

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

self.assertEqual(a, c) # but only because they are empty

# Even though the byte representation will be the same,

# the bitarrays are not equal.

a = bitarray('11001000' '11110000', endian)

self.assertEqual(len(a) % 8, 0)

c = bitarray(a, endian2)

# This is only equal because the size of the bitarray is a

# multiple of 8, and unused bits are not set (which changes

# the byte representation).

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

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

self.assertNotEqual(a, c)

def test_bitarray_endianness(self):

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

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

self.assertNotEqual(a, b)

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

b.bytereverse()

self.assertEqual(a, b)

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

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

self.assertEqual(a, c)

def test_create_empty(self):

for x in None, 0, '', list(), tuple(), set(), dict():

a = bitarray(x)

self.assertEqual(len(a), 0)

self.assertEQUAL(a, bitarray())

def test_wrong_args(self):

# wrong types

for x in False, True, Ellipsis, slice(0), 0.0, 0 + 0j:

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

# wrong values

for x in -1, 'A':

self.assertRaises(ValueError, bitarray.__new__, bitarray, x)

# test second (endian) argument

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

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

self.assertRaises(ValueError, bitarray.__new__, bitarray, 0, 'foo')

# too many args

def test_numeric(self):

a = bitarray()

self.assertRaises(Exception, int, a)

self.assertRaises(Exception, float, a)

self.assertRaises(Exception, 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(13, 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.assertIsInstance(bi, tuple)

self.assertEqual(len(bi), 5)

self.assertIsInstance(bi[0], int)

def test_buffer_info2(self):

for endian in 'big', 'little':

for n in range(50):

bi = bitarray(n, endian).buffer_info()

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

self.assertEqual(bi[2], endian) # endianness

self.assertEqual(bi[3], 8 * bi[1] - n) # unused

self.assertTrue(bi[4] >= bi[1]) # allocated

def test_endian(self):

for endian in 'big', 'little':

a = bitarray(endian=endian)

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

a = bitarray(endian='big')

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

def test_len(self):

for n in range(100):

a = bitarray(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.assertFalse(a[:] is 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(start=1):

aa = a.tolist()

la = len(a)

for dum in range(10):

step = self.rndsliceidx(la) or 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, bitarray('1'))

a = bitarray(2)

a[0] = 0

a[1] = 1

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

a[-1] = 0

a[-2] = 1

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

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

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

def test_setitem2(self):

for a in self.randombitarrays(start=1):

la = len(a)

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('00000')

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(start=1):

la = len(a)

for dum in range(10):

step = self.rndsliceidx(la) or None

s = slice(self.rndsliceidx(la), self.rndsliceidx(la), step)

lb = randint(0, 10) if step is None else self.slicelen(s, la)

b = bitarray(lb)

c = bitarray(a)

c[s] = b

self.check_obj(c)

cc = a.tolist()

cc[s] = b.tolist()

self.assertEqual(c, bitarray(cc))

def test_setslice_to_bitarray(self):

a = bitarray('11111111' '1111')

a[2:6] = bitarray('0010')

self.assertEqual(a, bitarray('11001011' '1111'))

a.setall(0)

a[::2] = bitarray('111001')

self.assertEqual(a, bitarray('10101000' '0010'))

a.setall(0)

a[3:] = bitarray('111')

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

a = bitarray(12)

a.setall(0)

a[1:11:2] = bitarray('11101')

self.assertEqual(a, bitarray('01010100' '0100'))

a = bitarray(12)

a.setall(0)

a[:-6:-1] = bitarray('10111')

self.assertEqual(a, bitarray('00000001' '1101'))

a = bitarray('1111')

a[3:3] = bitarray('000') # insert

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

a[2:5] = bitarray() # remove

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

a = bitarray('1111')

a[1:3] = bitarray('0000')

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

a[:] = bitarray('010') # replace all values

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

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'))

a[2:5] = False # ^^^

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

a[1::3] = False # ^ ^ ^

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

a[1:6:2] = True # ^ ^ ^

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

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_sieve(self): # Sieve of Eratosthenes

a = bitarray(50)

a.setall(1)

for i in range(2, 8):

if a[i]:

a[i*i::i] = 0

primes = [i for i in range(2, 50) if a[i]]

self.assertEqual(primes, [2, 3, 5, 7, 11, 13, 17, 19,

23, 29, 31, 37, 41, 43, 47])

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)

a = bitarray('10101100' '10110')

del a[3:9] # ^^^^^ ^

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

del a[::3] # ^ ^ ^

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

a = bitarray('10101100' '101101111')

del a[5:-3:3] # ^ ^ ^

self.assertEqual(a, bitarray('1010100' '0101111'))

a = bitarray('10101100' '1011011')

del a[:-9:-2] # ^ ^ ^ ^

self.assertEqual(a, bitarray('10101100' '011'))

def test_delitem2(self):

for a in self.randombitarrays(start=1):

la = len(a)

for dum in range(10):

step = self.rndsliceidx(la) or None

s = slice(self.rndsliceidx(la), self.rndsliceidx(la), step)

c = a.copy()

del c[s]

self.check_obj(c)

c_lst = a.tolist()

del c_lst[s]

def test_instancecheck(self):

a = bitarray('011')

self.assertIsInstance(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_to01(self):

a = bitarray()

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

self.assertIsInstance(a.to01(), str)

a = bitarray('101')

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

self.assertIsInstance(a.to01(), str)

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_eq_ne(self):

self.assertTrue(bitarray(0, 'big') == bitarray(0, 'little'))

self.assertFalse(bitarray(0, 'big') != bitarray(0, 'little'))

for n in range(1, 20):

a = bitarray(n, 'little')

a.setall(1)

for endian in 'little', 'big':

b = bitarray(n, endian)

b.setall(1)

self.assertTrue(a == b)

self.assertFalse(a != b)

b[n - 1] = not b[n - 1] # flip last bit

self.assertTrue(a != b)

self.assertFalse(a == b)

def test_compare_random(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(start=0):

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(b'\x01')

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

b = bitarray(endian='little')

b.frombytes(b'\x80')

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

c = bitarray(endian='big')

c.frombytes(b'\x80')

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

d = bitarray(endian='big')

d.frombytes(b'\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(), b'\x01')

a[1] = True

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

a.frombytes(b' ')

self.assertEqual(a.tobytes(), b'\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(), b'\x01')

a[6] = True

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

a.frombytes(b' ')

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

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

def test_endianness4(self):

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

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

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

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

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):

for a in self.randombitarrays():

b = pickle.loads(pickle.dumps(a))

self.assertFalse(b is a)

self.assertEQUAL(a, b)

def test_overflow(self):

if _sysinfo()[0] == 8:

return

a = bitarray(2**31 - 1);

self.assertRaises(OverflowError, bitarray.append, a, True)

self.assertRaises(IndexError, bitarray.__new__, bitarray, 2**31)

a = bitarray(10 ** 6)

self.assertRaises(OverflowError, a.__imul__, 17180)

def test_unicode_create(self):

a = bitarray(unicode())

self.assertEqual(a, bitarray())

a = bitarray(unicode('111001'))

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

for a in self.randombitarrays():

b = bitarray(unicode(a.to01()))

self.assertEqual(a, b)

def test_unicode_extend(self):

a = bitarray()

a.extend(unicode())

self.assertEqual(a, bitarray())

a = bitarray()

a.extend(unicode('001011'))

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

for a in self.randombitarrays():

b = bitarray()

b.extend(unicode(a.to01()))

self.assertEqual(a, b)

def test_unhashable(self):

a = bitarray()

self.assertRaises(TypeError, hash, a)

def test_all(self):

a = bitarray()

self.assertTrue(a.all())

for s, r in ('0', False), ('1', True), ('01', False):

self.assertEqual(bitarray(s).all(), r)

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())

for s, r in ('0', False), ('1', True), ('01', True):

self.assertEqual(bitarray(s).any(), r)

for a in self.randombitarrays():

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

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

def test_repr(self):

r = repr(bitarray())

self.assertEqual(r, "bitarray()")

self.assertIsInstance(r, str)

r = repr(bitarray('10111'))

self.assertEqual(r, "bitarray('10111')")

self.assertIsInstance(r, str)

for a in self.randombitarrays():

b = eval(repr(a))

self.assertFalse(b is a)

self.assertEqual(a, b)

self.check_obj(b)

def test_copy(self):

for a in self.randombitarrays():

b = a.copy()

self.assertFalse(b is a)

self.assertEQUAL(a, b)

b = copy.copy(a)

self.assertFalse(b is a)

self.assertEQUAL(a, b)

b = copy.deepcopy(a)

self.assertFalse(b is 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)