"Skip a test if the condition is true."

if condition:

return lambda f: None

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)

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

self.assertTrue(0 <= a.padbits < 8)

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

info = a.buffer_info()

if info.imported:

# imported buffer implies that no extra memory is allocated

self.assertEqual(info.alloc, 0)

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

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

self.assertEqual(a.padbits, 0)

else:

# the allocated memory is always larger than the buffer size

self.assertTrue(info.alloc >= a.nbytes)

if info.address == 0:

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

# and the allocated memory size are 0

self.assertEqual(a.nbytes, 0)

self.assertEqual(info.alloc, 0)

if type(a) == frozenbitarray:

# frozenbitarray have read-only memory

self.assertEqual(a.readonly, 1)

if a.padbits: # ensure padbits are zero

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

self.assertEqual(len(b), a.padbits)

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

elif not info.imported:

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

self.assertFalse(a.readonly)

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)), "<class 'bitarray.%s'>" % 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.assertEqual(type(__version__), str)

def test_sysinfo(self):

for key in ["void*", "size_t", "bitarrayobject", "decodetreeobject",

"binode", "HAVE_BUILTIN_BSWAP64",

"PY_LITTLE_ENDIAN", "PY_BIG_ENDIAN",

"Py_GIL_DISABLED", "Py_DEBUG", "DEBUG"]:

res = sysinfo(key)

self.assertEqual(type(res), int)

@skipIf(sys.version_info[:2] < (3, 14))

def test_gil_disabled(self):

self.assertEqual(sysinfo("Py_GIL_DISABLED"),

"free-threading" in sys.version)

# see if GIL is actually disabled in free-threading build

if sysinfo("Py_GIL_DISABLED"):

self.assertFalse(sys._is_gil_enabled())

def test_sysinfo_errors(self):

self.assertRaises(TypeError, sysinfo)

self.assertRaises(TypeError, sysinfo, b"void*")

self.assertRaises(KeyError, sysinfo, "foo")

def test_sysinfo_pointer_size(self):

self.assertEqual(sysinfo("void*"), PTRSIZE)

self.assertEqual(sysinfo("size_t"), PTRSIZE)

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

if not is_pypy: # PyPy doesn't have tuple.__itemsize__

self.assertEqual(PTRSIZE, tuple.__itemsize__)

def test_sysinfo_byteorder(self):

self.assertEqual(sys.byteorder == "little",

sysinfo("PY_LITTLE_ENDIAN"))

self.assertEqual(sys.byteorder == "big",

sysinfo("PY_BIG_ENDIAN"))

def test_get_default_endian(self):

endian = get_default_endian()

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

self.assertEqual(type(endian), str)

a = bitarray()

self.assertEqual(a.endian, endian)

def test_get_default_endian_errors(self):

# takes no arguments

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

def test_bits2bytes(self):

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.assertEqual(type(m), int)

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

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

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

def test_noInitializer(self):

a = bitarray()

self.assertEqual(len(a), 0)

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

self.assertEqual(type(a), bitarray)

self.check_obj(a)

def test_endian(self):

a = bitarray(b"ABC", endian='little')

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

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

self.check_obj(a)

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

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

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

self.check_obj(b)

self.assertNotEqual(a, b)

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

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

a = bitarray(buffer=b'A')

self.assertEqual(a.endian, get_default_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.assertEqual(type(a), bitarray)

for endian in 'little', 'big':

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

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

self.assertEqual(type(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_bytes_bytearray_pad(self):

for endian, res in ("little", b"\x01"), ("big", b"\x80"):

a = bitarray("1", endian)

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

a = bitarray("1", endian)

self.assertEqual(bytes(a), res)

def test_set(self):

for a in self.randombitarrays():

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.assertEqual(type(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)

def test_random_step1(self):

for n in range(200):

a = urandom_2(n)

i = randint(0, n)

j = randint(0, n)

b = a[i:j]

self.assertEqual(b.to01(), a.to01()[i:j])

self.assertEqual(len(b), max(j - i, 0))

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

def test_random(self):

for n in range(200):

a = urandom_2(n)

s = self.random_slice(n)

b = a[s]

self.assertEqual(len(b), len(range(n)[s])) # slicelength

self.assertEqual(list(b), a.tolist()[s])

def test_simple(self):

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

n = len(a)

b = bitarray(n)

b[0:n] = bitarray(a)

self.assertEqual(a, b)

self.assertFalse(a is b)

b = bitarray(n)

b[:] = bitarray(a)

self.assertEqual(a, b)

self.assertFalse(a is b)

b = bitarray(n)

b[::-1] = a

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

def test_random(self):

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

len_a = len(a)

for _ in range(10):

s = self.random_slice(len_a)

len_b = randrange(10) if s.step == 1 else len(range(len_a)[s])

b = bitarray(len_b)

c = bitarray(a)

c[s] = b

self.check_obj(c)

cc = a.tolist()

cc[s] = b.tolist()

self.assertEqual(c, bitarray(cc))

def test_self_random(self):

for a in self.randombitarrays():

n = len(a)

for step in -1, 1:

s = slice(None, None, step)

# ensure slicelength equals len(a)

self.assertEqual(len(range(n)[s]), n)

aa = a.tolist()

a[s] = a

aa[s] = aa

self.assertEqual(a, bitarray(aa))

def test_special(self):

for n in 0, 1, 10, 87:

a = urandom_2(n)

for m in 0, 1, 10, 99:

x = urandom_2(m)

b = a.copy()

b[n:n] = x # insert at end - extend

self.assertEqual(b, a + x)

self.assertEqual(len(b), len(a) + len(x))

b[0:0] = x # insert at 0 - prepend

self.assertEqual(b, x + a + x)

self.check_obj(b)

self.assertEqual(len(b), len(a) + 2 * len(x))

def test_range(self):

# tests C function insert_n()

for _ in range(100):

n = randrange(200)

a = urandom_2(n)

p = randint(0, n)

m = randint(0, 500)

x = urandom_2(m)

b = a.copy()

b[p:p] = x

self.assertEQUAL(b, a[:p] + x + a[p:])

self.assertEqual(len(b), len(a) + m)

self.check_obj(b)

def test_resize(self):

for _ in range(100):

n = randint(0, 200)

a = urandom_2(n)

p1 = randint(0, n)

p2 = randint(0, n)

m = randint(0, 300)

x = urandom_2(m)

b = a.copy()

b[p1:p2] = x

b_lst = a.tolist()

b_lst[p1:p2] = x.tolist()

self.assertEqual(b.tolist(), b_lst)

if p1 <= p2:

self.assertEQUAL(b, a[:p1] + x + a[p2:])

self.assertEqual(len(b), n + p1 - p2 + len(x))

else:

self.assertEqual(b, a[:p1] + x + a[p1:])

self.assertEqual(len(b), n + len(x))

self.check_obj(b)

def test_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_self_shared_buffer(self):

# This is a special case. We have two bitarrays which share the

# same buffer, and then do a slice assignment. The bitarray is

# copied onto itself in reverse order. So we need to make a copy

# in setslice_bitarray(). However, since a and b are two distinct

# objects, it is not enough to check for self == other, but rather

# check whether their buffers overlap.

a = bitarray('11100000')

b = bitarray(buffer=a)

b[::-1] = a

self.assertEqual(a, b)

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

def test_self_shared_buffer_2(self):

# This is an even more special case. We have a bitarrays which

# shares part of anothers bitarray buffer. So in setslice_bitarray(),

# we need to make a copy of other if:

#

# self->ob_item <= other->ob_item <= self->ob_item + Py_SIZE(self)

#

# In words: Is the other buffer inside the self buffer (which inclues

# the previous case)

a = bitarray('11111111 11000000 00000000')

b = bitarray(buffer=memoryview(a)[1:2])

self.assertEqual(b, bitarray('11000000'))

a[15:7:-1] = b

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

@skipIf(is_pypy)

def test_self_shared_buffer_3(self):

# Requires to check for (in setslice_bitarray()):

#

# other->ob_item <= self->ob_item <= other->ob_item + Py_SIZE(other)

#

a = bitarray('11111111 11000000 00000000')

b = bitarray(buffer=memoryview(a)[:2])

c = bitarray(buffer=memoryview(a)[1:])

self.assertEqual(b, bitarray('11111111 11000000'))

self.assertEqual(c, bitarray('11000000 00000000'))

c[::-1] = b

self.assertEqual(c, bitarray('00000011 11111111'))

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

def test_setslice_bitarray(self):

a = ones(12)

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 = zeros(12)

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

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

a.setall(0)

a[5:2] = bitarray('111') # make sure inserts before 5 (not 2)

self.assertEqual(a, bitarray('00000111 0000000'))

a = zeros(12)

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

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

def test_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_frozenbitarray(self):

a = bitarray('11111111 1111')

b = frozenbitarray('0000')

a[2:6] = b

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

self.assertEqual(type(b), frozenbitarray)

self.assertEqual(b, bitarray('0000'))

b = frozenbitarray('011100')

a[::2] = b

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

self.check_obj(a)

self.assertEqual(type(b), frozenbitarray)

self.assertEqual(b, bitarray('011100'))

def test_setslice_bitarray_random_same_length(self):

for _ in range(100):

n = randrange(200)

a = urandom_2(n)

lst_a = a.tolist()

b = urandom_2(randint(0, n))

lst_b = b.tolist()

i = randint(0, n - len(b))

j = i + len(b)

self.assertEqual(j - i, len(b))

a[i:j] = b

lst_a[i:j] = lst_b

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

# a didn't change length

self.assertEqual(len(a), n)

self.check_obj(a)

def test_bitarray_random_step1(self):

for _ in range(50):

n = randrange(300)

a = urandom_2(n)

lst_a = a.tolist()

b = urandom_2(randrange(100))

lst_b = b.tolist()

s = self.random_slice(n, step=1)

a[s] = b

lst_a[s] = lst_b

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

self.check_obj(a)