"Skip a test if the condition is true."

if condition:

return lambda f: None

fields = (

"address", # 0. address of byte buffer

"size", # 1. buffer size in bytes

"endian", # 2. bit-endianness

"padbits", # 3. number of pad bits

"allocated", # 4. allocated memory

"readonly", # 5. memory is read-only

"imported", # 6. buffer is imported

"exports", # 7. number of buffer exports

)

info = a.buffer_info()

res = dict(zip(fields, info))

if endian == "<RAND>":

endian = choice(['little', 'big'])

a = bitarray(os.urandom(bits2bytes(n)), endian)

del a[n:]

@staticmethod

def random_endian():

return choice(['little', 'big'])

@staticmethod

def randombitarrays(start=0):

for n in range(start, 10):

yield urandom_2(n)

for _ in range(3):

yield urandom_2(randrange(start, 1000))

def randomlists(self):

for a in self.randombitarrays():

yield a.tolist()

@staticmethod

def opposite_endian(endian):

t = {'little': 'big',

'big': 'little'}

return t[endian]

@staticmethod

def random_slice(n, step=None):

return slice(randint(-n - 2, n + 2),

randint(-n - 2, n + 2),

step or randint(-5, 5) or 1)

def check_obj(self, a):

self.assertIsInstance(a, bitarray)

ptr, nbytes, endian, padbits, alloc, readonly, buf, exports = \

a.buffer_info()

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

self.assertTrue(0 <= padbits < 8)

self.assertEqual(endian, a.endian)

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

self.assertEqual(a.nbytes, nbytes)

self.assertEqual(a.padbits, padbits)

self.assertEqual(a.readonly, readonly)

self.assertEqual(len(a) + padbits, 8 * nbytes)

if buf:

# imported buffer implies that no extra memory is allocated

self.assertEqual(alloc, 0)

# an imported buffer will always have a multiple of 8 bits

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

self.assertEqual(len(a), 8 * nbytes)

self.assertEqual(padbits, 0)

else:

# the allocated memory is always larger than the buffer size

self.assertTrue(alloc >= nbytes)

if ptr == 0:

# the buffer being a NULL pointer implies that the buffer size

# and the allocated memory size are 0

self.assertEqual(nbytes, 0)

self.assertEqual(alloc, 0)

if type(a).__name__ == 'frozenbitarray':

self.assertIsInstance(a, frozenbitarray)

# frozenbitarray have read-only memory

self.assertEqual(readonly, 1)

if padbits: # ensure padbits are zero

b = bitarray(bytes(a)[-1:], endian=endian)[-padbits:]

self.assertEqual(len(b), padbits)

self.assertEqual(b.count(), 0)

elif not buf:

self.assertFalse(isinstance(a, frozenbitarray))

# otherwise, unless the buffer is imported, it is writable

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

@staticmethod

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

try:

callable(*args, **kwargs)

raise AssertionError("%s not raised" % excClass.__name__)

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

info = _sysinfo()

self.assertEqual(info[0], PTRSIZE)

self.assertEqual(info[1], PTRSIZE)

self.assertIsInstance(info, tuple)

for x in info:

self.assertIsInstance(x, int)

self.assertEqual(info[7], int(sys.byteorder == 'little'))

self.assertEqual(info[8], int(sys.byteorder == 'big'))

@skipIf(is_pypy) # PyPy doesn't have tuple.__itemsize__

def test_ptrsize(self):

self.assertEqual(PTRSIZE, tuple.__itemsize__)

def test_maxsize(self):

self.assertEqual(sys.maxsize, 2 ** (PTRSIZE * 8 - 1) - 1)

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

_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', None:

a = bitarray(endian=endian)

self.assertEqual(a.endian,

default_endian if endian is None else 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)

for n, res in (0, 0), (1, 1), (7, 1), (8, 1), (9, 2):

self.assertEqual(bits2bytes(n), res)

for n in range(1, 200):

m = bits2bytes(n)

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

self.assertIsInstance(m, int)

k = (1 << n) + randrange(1000)

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(b"ABC", endian='little')

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

self.assertIsInstance(a.endian, str)

self.check_obj(a)

b = bitarray(b"ABC", endian='big')

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, endian=0)

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

self.assertRaisesMessage(

ValueError,

"bit-endianness must be either 'little' or 'big', not 'foo'",

bitarray, endian='foo')

self.assertRaisesMessage(TypeError,

"'ellipsis' object is not iterable",

bitarray, Ellipsis)

def test_buffer_endian(self):

for endian in 'big', 'little':

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

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

_set_default_endian(endian)

a = bitarray(buffer=b'A')

self.assertEqual(a.endian, endian)

self.assertEqual(len(a), 8)

def test_buffer_readonly(self):

a = bitarray(buffer=b'\xf0', endian='little')

self.assertTrue(a.readonly)

self.assertRaises(TypeError, a.clear)

self.assertRaises(TypeError, a.__setitem__, 3, 1)

self.assertEQUAL(a, bitarray('00001111', 'little'))

self.check_obj(a)

@skipIf(is_pypy)

def test_buffer_writable(self):

a = bitarray(buffer=bytearray([65]))

self.assertFalse(a.readonly)

a[6] = 1

def test_buffer_args(self):

# buffer requires no initial argument

self.assertRaises(TypeError, bitarray, 5, buffer=b'DATA\0')

# positinal arguments

a = bitarray(None, 'big', bytearray([15]))

self.assertEQUAL(a, bitarray('00001111', 'big'))

a = bitarray(None, 'little', None)

self.assertEQUAL(a, bitarray(0, 'little'))

def test_none(self):

for a in [bitarray(None),

bitarray(None, buffer=None),

bitarray(None, buffer=Ellipsis),

bitarray(None, None, None),

bitarray(None, None, Ellipsis)]:

self.assertEqual(len(a), 0)

def test_int(self):

for n in range(50):

a = bitarray(n)

self.assertEqual(len(a), n)

self.assertFalse(a.any())

self.assertEqual(a.to01(), n * '0')

self.check_obj(a)

# uninitialized buffer

a = bitarray(n, buffer=Ellipsis)

self.assertEqual(len(a), n)

self.check_obj(a)

self.assertRaises(ValueError, bitarray, -1)

self.assertRaises(ValueError, bitarray, -924)

def test_list(self):

a = bitarray([0, 1, False, True])

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

self.check_obj(a)

self.assertRaises(ValueError, bitarray, [0, 1, 2])

self.assertRaises(TypeError, bitarray, [0, 1, None])

for n in range(50):

lst = [bool(getrandbits(1)) for d in range(n)]

a = bitarray(lst)

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

self.check_obj(a)

def test_sequence(self):

lst = [0, 1, 1, 1, 0]

for x in lst, tuple(lst), array.array('i', lst):

self.assertEqual(len(x), 5) # sequences have len, iterables not

a = bitarray(x)

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

self.check_obj(a)

def test_iter1(self):

for n in range(50):

lst = [bool(getrandbits(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))

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

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

def test_range(self):

self.assertEqual(bitarray(range(2)), bitarray('01'))

self.assertRaises(ValueError, bitarray, range(0, 3))

def test_string01(self):

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

a = bitarray(s)

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

self.check_obj(a)

for lst in self.randomlists():

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

self.assertRaises(ValueError, bitarray, '1\u26050') # UCS2

self.assertRaises(ValueError, bitarray, '0\U00010348') # UCS4

def test_string01_whitespace(self):

a = bitarray(WHITESPACE)

self.assertEqual(a, bitarray())

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

for x in b'\x80', bytearray(b'\x80'):

a = bitarray(x, 'little')

self.assertEqual(len(a), 8 * len(x))

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

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

self.check_obj(a)

for n in range(100):

x = os.urandom(n)

a = bitarray(x)

self.assertEqual(len(a), 8 * n)

self.assertEqual(memoryview(a), x)

def test_byte(self):

for byte, endian, res in [

(b'\x01', 'little', '10000000'),

(b'\x80', 'little', '00000001'),

(b'\x80', 'big', '10000000'),

(b'\x01', 'big', '00000001')]:

a = bitarray(byte, endian)

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

def test_bitarray_simple(self):

for n in range(10):

a = bitarray(n)

b = bitarray(a, endian=None)

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.opposite_endian(endian)

b = bitarray(a, endian2)

self.assertEqual(b.endian, endian2)

self.assertEqual(a, b)

for a in self.randombitarrays():

endian2 = self.opposite_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(), bytes(),

bytearray(), bitarray(), frozenbitarray()):

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

# wrong values

for x in -1, 'A', '\0', '010\0 11':

self.assertRaises(ValueError, bitarray, x)

# test second (endian) argument

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

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

# too many args

self.assertRaises(TypeError, bitarray, 0, 'big', 0)

@skipIf(is_pypy)

def test_weakref(self):

a = bitarray('0100')

b = weakref.proxy(a)

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

a = None

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

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

def test_bytes_bytearray(self):

for n in range(20):

a = urandom_2(8 * n)

self.assertEqual(a.padbits, 0)

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

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

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

info = a.buffer_info()

self.assertIsInstance(info, tuple)

self.assertEqual(len(info), 8)

for i, item in enumerate(info):

if i == 2:

self.assertIsInstance(item, str)

continue

self.assertIsInstance(item, int)

def test_endian(self):

for endian in 'big', 'little':

a = bitarray(endian=endian)

def test_empty(self):

a = bitarray()

a._shift_r8(0, 0, 3)

self.assertEqual(a, bitarray())

def test_explicit(self):

x = bitarray('11000100 11111111 11100111 10111111 00001000')

y = bitarray('11000100 00000111 11111111 00111101 00001000')

x._shift_r8(1, 4, 5)

self.assertEqual(x, y)

x._shift_r8(2, 1, 5) # start > stop -- do nothing

self.assertEqual(x, y)

x._shift_r8(0, 5, 0) # shift = 0 -- do nothing

self.assertEqual(x, y)

x = bitarray('11000100 11110')

y = bitarray('00011000 10011')

x._shift_r8(0, 2, 3)

self.assertEqual(x, y)

x = bitarray('1100011')

y = bitarray('0110001')

x._shift_r8(0, 1, 1)

self.assertEqual(x, y)

def test_random(self):

for _ in range(2000):

n = randrange(200)

x = urandom_2(n)

a = randint(0, x.nbytes)

b = randint(a, x.nbytes)

k = randrange(8)

y = x.copy()

y[8 * a : 8 * b] >>= k

s = x.to01()

if a < b:

s = s[:8 * a] + k * "0" + s[8 * a : 8 * b - k] + s[8 * b:]

if 8 * b > n:

s = s[:n]

x._shift_r8(a, b, k)

self.assertEqual(x.to01(), s)

self.assertEqual(x, y)

self.assertEqual(x.endian, y.endian)

def test_explicit(self):

x = bitarray('11000100 11110')

# ^^^^ ^

y = bitarray('0101110001')

# ^^^^^

x._copy_n(4, y, 1, 5)

self.assertEqual(x, bitarray('11001011 11110'))

# ^^^^ ^

x = bitarray('10110111 101', 'little')

y = x.copy()

x._copy_n(3, x, 3, 7) # copy region of x onto x

self.assertEqual(x, y)

x._copy_n(3, bitarray(x, 'big'), 3, 7) # as before but other endian

self.assertEqual(x, y)

x._copy_n(5, bitarray(), 0, 0) # copy empty bitarray onto x

self.assertEqual(x, y)

def test_example(self):

# example given in examples/copy_n.py

y = bitarray(

'00101110 11111001 01011101 11001011 10110000 01011110 011')

x = bitarray(

'01011101 11100101 01110101 01011001 01110100 10001010 01111011')

x._copy_n(21, y, 6, 31)

self.assertEqual(x, bitarray(

'01011101 11100101 01110101 11110010 10111011 10010111 01101011'))

def check_copy_n(self, N, M, a, b, n):

x = urandom_2(N)

x_lst = x.tolist()

y = x if M < 0 else urandom_2(M)

y_lst = y.tolist()

x_lst[a:a + n] = y_lst[b:b + n]

x._copy_n(a, y, b, n)

self.assertEqual(x, bitarray(x_lst))

self.assertEqual(len(x), N)

self.check_obj(x)

if M < 0:

return

self.assertEqual(y, bitarray(y_lst))

self.assertEqual(len(y), M)

self.check_obj(y)

def test_random(self):

for _ in range(1000):

N = randrange(1000)

n = randint(0, N)

a = randint(0, N - n)

b = randint(0, N - n)

self.check_copy_n(N, -1, a, b, n)

M = randrange(1000)

n = randint(0, min(N, M))

a = randint(0, N - n)

b = randint(0, M - n)

self.check_copy_n(N, M, a, b, n)

@staticmethod

def getslice(a, start, slicelength):

# this is the Python eqivalent of __getitem__ for slices with step=1

b = bitarray(slicelength, a.endian)

b._copy_n(0, a, start, slicelength)

return b

def test_getslice(self):

for a in self.randombitarrays():

a_lst = a.tolist()

n = len(a)

i = randint(0, n)

j = randint(i, n)

b = self.getslice(a, i, j - i)

self.assertEqual(b.tolist(), a_lst[i:j])

def check_overlap(self, a, b, res):

r1 = a._overlap(b)

r2 = b._overlap(a)

self.assertTrue(r1 is r2 is res)

self.check_obj(a)

self.check_obj(b)

def test_empty(self):

a = bitarray()

self.check_overlap(a, a, False)

b = bitarray()

self.check_overlap(a, b, False)

def test_distinct(self):

for a in self.randombitarrays():

# buffers overlaps with itself, unless buffer is NULL

self.check_overlap(a, a, bool(a))

b = a.copy()

self.check_overlap(a, b, False)

def test_shared(self):

a = bitarray(64)

b = bitarray(buffer=a)

self.check_overlap(b, a, True)

c = bitarray(buffer=memoryview(a)[2:4])

self.check_overlap(c, a, True)

d = bitarray(buffer=memoryview(a)[5:])

self.check_overlap(d, c, False)

self.check_overlap(d, b, True)

e = bitarray(buffer=memoryview(a)[3:3])

self.check_overlap(e, c, False)

self.check_overlap(e, d, False)

def test_shared_random(self):

n = 100 # buffer size in bytes

a = bitarray(8 * n)

for _ in range(1000):

i1 = randint(0, n)

j1 = randint(i1, n)

b1 = bitarray(buffer=memoryview(a)[i1:j1])

i2 = randint(0, n)

j2 = randint(i2, n)

b2 = bitarray(buffer=memoryview(a)[i2:j2])

r1, r2 = range(i1, j1), range(i2, j2)

res = bool(r1) and bool(r2) and (i2 in r1 or i1 in r2)

def test_zeros(self):

for n in range(200):

a = zeros(n, self.random_endian())

b = _zlw(a)

self.assertEqual(b, zeros(64))

def test_ones(self):

for n in range(200):

a = ones(n, self.random_endian())

b = _zlw(a)

m = n % 64

self.assertEqual(b, ones(m) + zeros(64 - m))

def test_random(self):

for n in range(200):

a = urandom_2(n)

b = _zlw(a)

nw = 64 * (n // 64) # bits in complete words

m = n % 64

self.assertEqual(len(b), 64)

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

self.assertEqual(b, a[nw:nw + m] + zeros(64 - m))

def test_explicit(self):

a = bitarray()

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

a.append(True)

self.assertEqual(a[0], 1)

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

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

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

a.append(False)

self.assertEqual(a[1], 0)

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

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

a = bitarray('1100010')

for i, v in enumerate(a):

self.assertEqual(a[i], v)

self.assertIsInstance(a[i], int)

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

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

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

def test_range(self):

for a in self.randombitarrays():

aa = a.tolist()

for i in range(len(a)):

def test_explicit(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(ValueError, a.__setitem__, 0, -1)

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

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)

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

def test_random(self):

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

i = randrange(len(a))

aa = a.tolist()

v = getrandbits(1)

a[i] = v

aa[i] = v

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

self.check_obj(a)

@skipIf(is_pypy)

def test_imported(self):

a = bytearray([5, 1, 2, 3])

b = bitarray(endian="little", buffer=a)

self.assertFalse(b.readonly)

# operate on imported (writable) buffer

b[7] = 1

self.assertEqual(a, bytearray([0x85, 1, 2, 3]))

b[-2] = 1

def test_simple(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_random(self):

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

n = len(a)

b = a.copy()

i = randrange(n)

del b[i]

self.assertEQUAL(b, a[:i] + a[i + 1:])

self.assertEqual(len(b), n - 1)

self.check_obj(b)

@skipIf(is_pypy)

def test_imported(self):

a = bytearray([5, 11, 7])

b = bitarray(buffer=a)

self.assertFalse(b.readonly)

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

def test_reverse(self):

for _ in range(20):

n = randrange(200)

a = urandom_2(n)

b = a.copy()

b.reverse()

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