@staticmethod

def randombitarrays(start=1):

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 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)), "<class 'bitarray.bitarray'>")

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

if is_py3k:

return

self.assertRaises(StopIteration, it.next)

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

def assertIsInstance(self, o, t):

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

self.assertRaises(TypeError, bits2bytes, -4.0)

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

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

(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.assertIsInstance(a.endian(), str)

self.check_obj(a)

b = bitarray(endian='big')

b.fromstring('A')

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

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

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

for n in range(10):

a = bitarray(n)

b = bitarray(a)

self.assertFalse(a is 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_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('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.assertIsInstance(bi, tuple)

self.assertEqual(len(bi), 5)

self.assertIsInstance(bi[0], int)

if is_py3k:

self.assertIsInstance(bi[1], int)

self.assertIsInstance(bi[2], str)

self.assertIsInstance(bi[3], int)

if is_py3k:

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

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.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' '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 = bitarray(a)

d = c

del c[s]

self.assertTrue(c is d)

self.check_obj(c)

cc = a.tolist()

del cc[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(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=1):

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 v in range(3):

for a in self.randombitarrays():

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

self.assertFalse(b is a)

self.assertEQUAL(a, b)

def test_overflow(self):

if _sysinfo()[0] == 8:

return

self.assertRaises(OverflowError, bitarray.__new__,

bitarray, 2**34 + 1)

a = bitarray(10 ** 6)

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

def test_unicode1(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_unicode2(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)

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