@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

def randomlists(self):

for a in self.randombitarrays():

yield a.tolist()

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

address, size, endian, unused, allocated = a.buffer_info()

self.assertEqual(size, bits2bytes(len(a)))

self.assertEqual(unused, 8 * size - len(a))

self.assertTrue(0 <= unused < 8)

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

self.assertTrue(endian in ('little', 'big'))

self.assertTrue(allocated >= size)

if address == 0: # NULL

self.assertTrue(size == 0)

self.assertTrue(allocated == 0)

def assertEQUAL(self, a, b):

self.assertEqual(a, b)

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

def assertIsType(self, a, b):

self.assertEqual(type(a).__name__, b)

self.assertEqual(

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

('class' if is_py3k or b == 'frozenbitarray' else 'type', 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.assertIsType(a, 'bitarray')

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)

if not is_py3k:

a = bitarray(long(29))

self.assertEqual(len(a), 29)

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

a = iter(bitarray())

self.assertIsType(a, 'bitarrayiterator')

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, zeros(10))

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

for s in '0010111', u'0010111', '0010 111', u'0010 111':

a = bitarray(s)

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

self.assertRaises(UnicodeEncodeError, bitarray.__new__, bitarray,

u'1\u26050')

def test_string01_whitespace(self):

whitespace = ' \n\r\t\v'

a = bitarray(whitespace)

self.assertEqual(a, bitarray())

# For Python 2 (where strings are bytes), we are in the lucky

# position that none of the valid characters ('\t'=9, '\n'=10,

# '\v'=11, '\r'=13, ' '=32, '0'=48 and '1'=49) are valid header

# bytes for deserialization 0..7, 16..23. Therefore a string of

# '0's and '1'a can start with any whitespace character, as well

# as '0' or '1' obviously.

for c in whitespace:

a = bitarray(c + '1101110001')

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

a = bitarray(' 0\n1\r0\t1\v0 ')

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

def test_rawbytes(self):

self.assertEqual(bitarray(b'\x00').endian(), 'little')

self.assertEqual(bitarray(b'\x10').endian(), 'big')

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

self.assertEQUAL(bitarray(b'\x12\x0f', 'little'),

bitarray('111100', 'little'))

self.assertEQUAL(bitarray(b'\x02\x0f', 'big'),

bitarray('000011', 'big'))

for a, s in [

(bitarray(0, 'little'), b'\x00'),

(bitarray(0, 'big'), b'\x10'),

(bitarray('1', 'little'), b'\x07\x01'),

(bitarray('1', 'big'), b'\x17\x80'),

(bitarray('11110000', 'little'), b'\x00\x0f'),

(bitarray('11110000', 'big'), b'\x10\xf0'),

]:

self.assertEQUAL(bitarray(s), a)

def test_rawbytes_invalid(self):

for s in b'\x01', b'\x04', b'\x07', b'\x11', b'\x15', b'\x17':

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

a = bitarray(s + b'\x00')

head = s[0] if is_py3k else ord(s[0])

endian, unused = divmod(head, 16)

self.assertEqual(a.endian(), ['little', 'big'][endian])

self.assertEqual(len(a), 8 - unused)

self.assertFalse(a.any())

# this error comes from the unpickle() (C function)

self.assertRaisesMessage(ValueError, "invalid header byte 0x11",

bitarray.__new__, bitarray, b'\x011')

s = b'\x21'

if is_py3k:

# on Python 3, we don't allow bitarrays being created from bytes

error = TypeError

msg = ("cannot extend bitarray with 'bytes', use .pack() or "

".frombytes() instead")

else:

# on Python 2, we have an invalid character in the string

error = ValueError

msg = "expected '0' or '1' (or whitespace), got '!' (0x21)"

self.assertRaisesMessage(error, msg, bitarray.__new__, bitarray, s)

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)

b = bitarray(a, endian2)

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

self.assertEqual(a, b)

for a in self.randombitarrays():

endian2 = self.other_endian(a.endian())

b = bitarray(a, endian2)

self.assertEqual(a, b)

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

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

def test_bitarray_endianness(self):

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

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

self.assertEqual(a, b)

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

b.bytereverse()

self.assertNotEqual(a, b)

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

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

self.assertEqual(a, c)

def test_frozenbitarray(self):

a = bitarray(frozenbitarray())

self.assertEQUAL(a, bitarray())

self.assertIsType(a, 'bitarray')

for endian in 'little', 'big':

a = bitarray(frozenbitarray('011', endian=endian))

self.assertEQUAL(a, bitarray('011', endian))

self.assertIsType(a, 'bitarray')

def test_create_empty(self):

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

bitarray(), frozenbitarray()):

a = bitarray(x)

self.assertEqual(len(a), 0)

self.assertEQUAL(a, bitarray())

if is_py3k:

self.assertRaises(TypeError, bitarray.__new__, bitarray, b'')

else:

self.assertEqual(bitarray(b''), 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)

if is_py3k:

self.assertRaises(TypeError, bitarray.__new__, bitarray, b'10')

else:

self.assertEQUAL(bitarray(b'10'), bitarray('10'))

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

self.assertIsInstance(bi[1], int)

self.assertIsInstance(bi[2], str)

self.assertIsInstance(bi[3], int)

self.assertIsInstance(bi[4], 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_getitem_1(self):

a = bitarray()

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

a.append(True)

self.assertEqual(a[0], True)

self.assertEqual(a[-1], True)

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

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

a.append(False)

self.assertEqual(a[1], False)

self.assertEqual(a[-1], False)

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

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

self.assertRaises(TypeError, a.__getitem__, 1.5)

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

self.assertRaises(TypeError, a.__getitem__, 'A')

def test_getitem_2(self):

a = bitarray('1100010')

for i, b in enumerate(a):

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

a = bitarray('01001111 00001')

self.assertEQUAL(a[:], a)

self.assertFalse(a[:] is a)

self.assertEqual(a[13:2:-3], bitarray('1010'))

self.assertEqual(a[2:-1:4], bitarray('010'))

self.assertEqual(a[::2], bitarray('0011001'))

self.assertEqual(a[8:], bitarray('00001'))

self.assertEqual(a[7:], bitarray('100001'))

self.assertEqual(a[:8], bitarray('01001111'))

self.assertEqual(a[::-1], bitarray('10000111 10010'))

self.assertEqual(a[:8:-1], bitarray('1000'))

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

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

def test_getslice_random(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_setitem_simple(self):

a = bitarray('0')

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)

self.assertRaises(TypeError, a.__setitem__, 1.5, 1) # see issue 114

self.assertRaises(TypeError, a.__setitem__, None, 0)

self.assertRaises(TypeError, a.__setitem__, 'a', True)

def test_setitem_random(self):

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

la = len(a)

i = randint(0, la - 1)

aa = a.tolist()

val = bool(randint(0, 1))

a[i] = val

aa[i] = val

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

self.check_obj(a)

def test_setslice_simple(self):

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

la = len(a)

b = bitarray(la)

b[0:la] = bitarray(a)

self.assertEqual(a, b)

self.assertFalse(a is b)

b = bitarray(la)

b[:] = bitarray(a)

self.assertEqual(a, b)

self.assertFalse(a is b)

b = bitarray(la)

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

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

def test_setslice_random(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_self_random(self):

for a in self.randombitarrays():

for step in -1, 1:

s = slice(None, None, step)

aa = a.tolist()

a[s] = a

aa[s] = aa

self.assertEqual(a, bitarray(aa))

def test_setslice_self(self):

a = bitarray('1100111')

a[::-1] = a

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

a[4:] = a

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

a[:-5] = a

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

a = bitarray('01001')

a[:-1] = a

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

a[2::] = a

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

a[2:-2:1] = a

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

a = bitarray('011')

a[2:2] = a

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

a[:] = a

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

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

def test_setslice_to_bitarray_2(self):

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

# assign slice to bitarray with different length

a = bitarray('111111')

a[3:4] = bitarray('00')

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

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

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

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

a[3:3] = False # zero slicelength

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

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

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

a[-2:2:-1] = 1 # ^^^^

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

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

a = bitarray('11111111')

s = slice(2, 6, None)

self.assertRaises(TypeError, a.__setitem__, s, 1.2)

self.assertRaises(TypeError, a.__setitem__, s, None)

self.assertRaises(TypeError, a.__setitem__, s, "0110")

a[s] = False

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

# step != 1 and slicelen != length of assigned bitarray

self.assertRaisesMessage(

ValueError,

"attempt to assign sequence of size 3 to extended slice of size 4",

a.__setitem__, slice(None, None, 2), bitarray('000'))

self.assertRaisesMessage(

ValueError,

"attempt to assign sequence of size 3 to extended slice of size 2",

a.__setitem__, slice(None, None, 4), bitarray('000'))

self.assertRaisesMessage(

ValueError,

"attempt to assign sequence of size 7 to extended slice of size 8",

a.__setitem__, slice(None, None, -1), bitarray('0001000'))

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

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

a = bitarray('100110')

del a[1]

self.assertEqual(len(a), 5)

del a[3], a[-2]

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

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

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

def test_delslice(self):

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

del a[3:3] # zero slicelength

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

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

self.assertEqual(len(a), 11)

del a[:]

self.assertEqual(a, bitarray())

def test_delslice_random(self):

for a in self.randombitarrays():

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)