def test_1(self):

for default_endian in 'big', 'little':

_set_default_endian(default_endian)

a = zeros(0)

self.assertEqual(a, bitarray())

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

b = zeros(0, endian=None)

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

for n in range(100):

a = zeros(n)

self.assertEqual(len(a), n)

self.assertFalse(a.any())

self.assertEqual(a.count(1), 0)

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

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

for endian in 'big', 'little':

a = zeros(3, endian)

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

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

def test_wrong_args(self):

self.assertRaises(TypeError, zeros) # no argument

self.assertRaises(TypeError, zeros, '')

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

self.assertRaises(TypeError, zeros, [])

self.assertRaises(TypeError, zeros, 1.0)

self.assertRaises(ValueError, zeros, -1)

# endian not string

for x in 0, 1, {}, [], False, True:

self.assertRaises(TypeError, zeros, 0, x)

# endian wrong string

def test_1(self):

for default_endian in 'big', 'little':

_set_default_endian(default_endian)

a = urandom(0)

self.assertEqual(a, bitarray())

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

b = urandom(0, endian=None)

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

for n in range(100):

a = urandom(n)

self.assertEqual(len(a), n)

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

a = urandom(1000)

b = urandom(1000)

self.assertNotEqual(a, b)

self.assertTrue(400 < a.count() < 600)

self.assertTrue(400 < b.count() < 600)

def test_wrong_args(self):

self.assertRaises(TypeError, urandom)

self.assertRaises(TypeError, urandom, '')

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

self.assertRaises(TypeError, urandom, [])

self.assertRaises(TypeError, urandom, 1.0)

self.assertRaises(ValueError, urandom, -1)

self.assertRaises(TypeError, urandom, 0, 1)

@staticmethod

def get_code_string(a):

f = StringIO()

pprint(a, stream=f)

return f.getvalue()

def round_trip(self, a):

b = eval(self.get_code_string(a))

self.assertEqual(b, a)

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

def test_bitarray(self):

a = bitarray('110')

self.assertEqual(self.get_code_string(a), "bitarray('110')\n")

self.round_trip(a)

def test_frozenbitarray(self):

a = frozenbitarray('01')

self.assertEqual(self.get_code_string(a), "frozenbitarray('01')\n")

self.round_trip(a)

def test_formatting(self):

a = bitarray(200)

for width in range(40, 130, 10):

for n in range(1, 10):

f = StringIO()

pprint(a, stream=f, group=n, width=width)

r = f.getvalue()

self.assertEqual(eval(r), a)

s = r.strip("bitary(')\n")

for group in s.split()[:-1]:

self.assertEqual(len(group), n)

for line in s.split('\n'):

self.assertTrue(len(line) < width)

def test_fallback(self):

for a in None, 'asd', [1, 2], bitarray(), frozenbitarray('1'):

self.round_trip(a)

def test_subclass(self):

class Foo(bitarray):

pass

a = Foo()

code = self.get_code_string(a)

self.assertEqual(code, "Foo()\n")

b = eval(code)

self.assertEqual(b, a)

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

def test_random(self):

for n in range(150):

self.round_trip(urandom(n))

def test_file(self):

tmpdir = tempfile.mkdtemp()

tmpfile = os.path.join(tmpdir, 'testfile')

a = bitarray(1000)

try:

with open(tmpfile, 'w') as fo:

pprint(a, fo)

with open(tmpfile, 'r') as fi:

b = eval(fi.read())

self.assertEqual(a, b)

finally:

def test_simple(self):

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

b = make_endian(a, 'big')

self.assertTrue(b is a)

c = make_endian(a, 'little')

self.assertTrue(c == a)

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

self.assertIsType(c, 'bitarray')

# wrong arguments

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

self.assertRaises(TypeError, make_endian, bitarray(), 1)

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

def test_empty(self):

a = bitarray(endian='little')

b = make_endian(a, 'big')

self.assertTrue(b == a)

self.assertEqual(len(b), 0)

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

def test_from_frozen(self):

a = frozenbitarray('1101111', 'big')

b = make_endian(a, 'big')

self.assertTrue(b is a)

c = make_endian(a, 'little')

self.assertTrue(c == a)

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

#self.assertIsType(c, 'frozenbitarray')

def test_random(self):

for a in self.randombitarrays():

aa = a.copy()

for endian in 'big', 'little':

b = make_endian(a, endian)

self.assertEqual(a, b)

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

if a.endian() == endian:

self.assertTrue(b is a)

def test_simple(self):

self.assertRaises(TypeError, rindex)

self.assertRaises(TypeError, rindex, None)

self.assertRaises(TypeError, rindex, bitarray(), 1, 2)

for endian in 'big', 'little':

a = bitarray('00010110000', endian)

self.assertEqual(rindex(a), 6)

self.assertEqual(rindex(a, 1), 6)

self.assertEqual(rindex(a, 'A'), 6)

self.assertEqual(rindex(a, True), 6)

a = bitarray('00010110111', endian)

self.assertEqual(rindex(a, 0), 7)

self.assertEqual(rindex(a, None), 7)

self.assertEqual(rindex(a, False), 7)

a = frozenbitarray('00010110111', endian)

self.assertEqual(rindex(a, 0), 7)

self.assertEqual(rindex(a, None), 7)

self.assertEqual(rindex(a, False), 7)

for v in 0, 1:

self.assertRaises(ValueError, rindex,

bitarray(0, endian), v)

self.assertRaises(ValueError, rindex,

bitarray('000', endian), 1)

self.assertRaises(ValueError, rindex,

bitarray('11111', endian), 0)

def test_random(self):

for a in self.randombitarrays():

v = randint(0, 1)

try:

i = rindex(a, v)

except ValueError:

i = None

s = a.to01()

try:

j = s.rindex(str(v))

except ValueError:

j = None

self.assertEqual(i, j)

def test_many_set(self):

for _ in range(10):

n = randint(1, 100000)

v = randint(0, 1)

a = bitarray(n)

a.setall(not v)

lst = [randint(0, n - 1) for _ in range(100)]

for i in lst:

a[i] = v

self.assertEqual(rindex(a, v), max(lst))

def test_one_set(self):

for _ in range(10):

N = randint(1, 10000)

a = bitarray(N)

a.setall(0)

a[randint(0, N - 1)] = 1

def test_simple(self):

self.assertRaises(TypeError, strip, '0110')

self.assertRaises(TypeError, strip, bitarray(), 123)

self.assertRaises(ValueError, strip, bitarray(), 'up')

for default_endian in 'big', 'little':

_set_default_endian(default_endian)

a = bitarray('00010110000')

self.assertEQUAL(strip(a), bitarray('0001011'))

self.assertEQUAL(strip(a, 'left'), bitarray('10110000'))

self.assertEQUAL(strip(a, 'both'), bitarray('1011'))

b = frozenbitarray('00010110000')

c = strip(b, 'both')

self.assertEqual(c, bitarray('1011'))

self.assertIsType(c, 'frozenbitarray')

def test_zeros(self):

for n in range(10):

for mode in 'left', 'right', 'both':

a = zeros(n)

c = strip(a, mode)

self.assertIsType(c, 'bitarray')

self.assertEqual(c, bitarray())

self.assertEqual(a, zeros(n))

b = frozenbitarray(a)

c = strip(b, mode)

self.assertIsType(c, 'frozenbitarray')

self.assertEqual(c, bitarray())

def test_random(self):

for a in self.randombitarrays():

b = a.copy()

f = frozenbitarray(a)

s = a.to01()

for mode, res in [

('left', bitarray(s.lstrip('0'), a.endian())),

('right', bitarray(s.rstrip('0'), a.endian())),

('both', bitarray(s.strip('0'), a.endian())),

]:

c = strip(a, mode)

self.assertEQUAL(c, res)

self.assertIsType(c, 'bitarray')

self.assertEQUAL(a, b)

c = strip(f, mode)

self.assertEQUAL(c, res)

self.assertIsType(c, 'frozenbitarray')

self.assertEQUAL(f, b)

def test_one_set(self):

for _ in range(10):

n = randint(1, 10000)

a = bitarray(n)

a.setall(0)

a[randint(0, n - 1)] = 1

self.assertEqual(strip(a, 'both'), bitarray('1'))

@staticmethod

def count_n(a, n):

"return the index i for which a[:i].count() == n"

i, j = n, a.count(1, 0, n)

while j < n:

if a[i]:

j += 1

i += 1

return i

def check_result(self, a, n, i):

self.assertEqual(a.count(1, 0, i), n)

if i > 0:

self.assertTrue(a[i - 1])

def test_simple(self):

a = bitarray('111110111110111110111110011110111110111110111000')

b = a.copy()

self.assertEqual(len(a), 48)

self.assertEqual(a.count(), 37)

self.assertRaises(TypeError, count_n, '', 0)

self.assertEqual(count_n(a, 0), 0)

self.assertEqual(count_n(a, 20), 23)

self.assertEqual(count_n(a, 37), 45)

self.assertRaisesMessage(ValueError, "non-negative integer expected",

count_n, a, -1) # n < 0

self.assertRaisesMessage(ValueError, "n larger than bitarray size",

count_n, a, 49) # n > len(a)

self.assertRaisesMessage(ValueError, "n exceeds total count",

count_n, a, 38) # n > a.count()

self.assertRaises(TypeError, count_n, a, "7")

for n in range(0, 37):

i = count_n(a, n)

self.check_result(a, n, i)

self.assertEqual(a[:i].count(), n)

self.assertEqual(i, self.count_n(a, n))

self.assertEQUAL(a, b)

def test_frozen(self):

a = frozenbitarray('001111101111101111101111100111100')

self.assertEqual(len(a), 33)

self.assertEqual(a.count(), 24)

self.assertRaises(TypeError, count_n, '', 0)

self.assertEqual(count_n(a, 0), 0)

self.assertEqual(count_n(a, 10), 13)

self.assertEqual(count_n(a, 24), 31)

self.assertRaises(ValueError, count_n, a, -1) # n < 0

self.assertRaises(ValueError, count_n, a, 25) # n > a.count()

self.assertRaises(ValueError, count_n, a, 34) # n > len(a)

self.assertRaises(TypeError, count_n, a, "7")

def test_large(self):

for N in list(range(100)) + [1000, 10000, 100000]:

a = bitarray(N)

v = randint(0, 1)

a.setall(not v)

for _ in range(randint(0, min(N, 100))):

a[randint(0, N - 1)] = v

n = randint(0, a.count())

self.check_result(a, n, count_n(a, n))

# check for total count

tc = a.count()

self.assertTrue(count_n(a, tc) <= N)

self.assertRaises(ValueError, count_n, a, tc + 1)

def test_one_set(self):

N = 100000

for _ in range(10):

a = bitarray(N)

a.setall(0)

self.assertEqual(count_n(a, 0), 0)

self.assertRaises(ValueError, count_n, a, 1)

i = randint(0, N - 1)

a[i] = 1

self.assertEqual(count_n(a, 1), i + 1)

self.assertRaises(ValueError, count_n, a, 2)

def test_random(self):

for a in self.randombitarrays():

n = a.count() // 2

i = count_n(a, n)

def test_count_byte(self):

ones = bitarray(8)

ones.setall(1)

zeros = bitarray(8)

zeros.setall(0)

for i in range(0, 256):

a = bitarray()

a.frombytes(bytes(bytearray([i])))

cnt = a.count()

self.assertEqual(count_and(a, zeros), 0)

self.assertEqual(count_and(a, ones), cnt)

self.assertEqual(count_and(a, a), cnt)

self.assertEqual(count_or(a, zeros), cnt)

self.assertEqual(count_or(a, ones), 8)

self.assertEqual(count_or(a, a), cnt)

self.assertEqual(count_xor(a, zeros), cnt)

self.assertEqual(count_xor(a, ones), 8 - cnt)

self.assertEqual(count_xor(a, a), 0)

def test_bit_count1(self):

a = bitarray('001111')

aa = a.copy()

b = bitarray('010011')

bb = b.copy()

self.assertEqual(count_and(a, b), 2)

self.assertEqual(count_or(a, b), 5)

self.assertEqual(count_xor(a, b), 3)

for f in count_and, count_or, count_xor:

# not two arguments

self.assertRaises(TypeError, f)

self.assertRaises(TypeError, f, a)

self.assertRaises(TypeError, f, a, b, 3)

# wrong argument types

self.assertRaises(TypeError, f, a, '')

self.assertRaises(TypeError, f, '1', b)

self.assertRaises(TypeError, f, a, 4)

self.assertEQUAL(a, aa)

self.assertEQUAL(b, bb)

b.append(1)

for f in count_and, count_or, count_xor:

self.assertRaises(ValueError, f, a, b)

self.assertRaises(ValueError, f,

bitarray('110', 'big'),

bitarray('101', 'little'))

def test_bit_count_frozen(self):

a = frozenbitarray('001111')

b = frozenbitarray('010011')

self.assertEqual(count_and(a, b), 2)

self.assertEqual(count_or(a, b), 5)

self.assertEqual(count_xor(a, b), 3)

def test_bit_count_random(self):

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

a = urandom(n)

b = urandom(n)

self.assertEqual(count_and(a, b), (a & b).count())

self.assertEqual(count_or(a, b), (a | b).count())

def test_basic(self):

a = frozenbitarray('0101')

b = bitarray('0111')

self.assertTrue(subset(a, b))

self.assertFalse(subset(b, a))

self.assertRaises(TypeError, subset)

self.assertRaises(TypeError, subset, a, '')

self.assertRaises(TypeError, subset, '1', b)

self.assertRaises(TypeError, subset, a, 4)

b.append(1)

self.assertRaises(ValueError, subset, a, b)

def subset_simple(self, a, b):

return (a & b).count() == a.count()

def test_True(self):

for a, b in [('', ''), ('0', '1'), ('0', '0'), ('1', '1'),

('000', '111'), ('0101', '0111'),

('000010111', '010011111')]:

a, b = bitarray(a), bitarray(b)

self.assertTrue(subset(a, b) is True)

self.assertTrue(self.subset_simple(a, b) is True)

def test_False(self):

for a, b in [('1', '0'), ('1101', '0111'),

('0000101111', '0100111011')]:

a, b = bitarray(a), bitarray(b)

self.assertTrue(subset(a, b) is False)

self.assertTrue(self.subset_simple(a, b) is False)

def test_random(self):

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

b = a.copy()

# we set one random bit in b to 1, so a is always a subset of b

b[randint(0, len(a) - 1)] = 1

self.assertTrue(subset(a, b))

# but b in not always a subset of a

self.assertEqual(subset(b, a), self.subset_simple(b, a))

# we set all bits in a, which ensures that b is a subset of a

a.setall(1)

def test_bitarray(self):

a = bitarray()

self.assertTrue(parity(a) is False)

par = False

for _ in range(100):

self.assertTrue(parity(a) is par)

a.append(1)

par = not par

def test_unused_bits(self):

a = bitarray(1)

a.setall(1)

self.assertTrue(parity(a))

def test_return_type(self):

p = parity(bitarray('101'))

self.assertIsInstance(p, bool)

def test_frozenbitarray(self):

self.assertTrue(parity(frozenbitarray()) is False)

self.assertTrue(parity(frozenbitarray('0010011')) is True)

self.assertTrue(parity(frozenbitarray('10100110')) is False)

def test_wrong_args(self):

self.assertRaises(TypeError, parity, '')

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

def test_byte(self):

for i in range(256):

a = bitarray()

a.frombytes(bytes(bytearray([i])))

self.assertEqual(parity(a), a.count() % 2)

def test_random(self):

for a in self.randombitarrays():

'0': bitarray('0000'), '1': bitarray('0001'),

'2': bitarray('0010'), '3': bitarray('0011'),

'4': bitarray('0100'), '5': bitarray('0101'),

'6': bitarray('0110'), '7': bitarray('0111'),

'8': bitarray('1000'), '9': bitarray('1001'),

'a': bitarray('1010'), 'b': bitarray('1011'),

'c': bitarray('1100'), 'd': bitarray('1101'),

'e': bitarray('1110'), 'f': bitarray('1111'),

def test_ba2hex(self):

self.assertEqual(ba2hex(bitarray(0, 'big')), '')

self.assertEqual(ba2hex(bitarray('1110', 'big')), 'e')

self.assertEqual(ba2hex(bitarray('1110', 'little')), '7')

self.assertEqual(ba2hex(bitarray('0000 0001', 'big')), '01')

self.assertEqual(ba2hex(bitarray('1000 0000', 'big')), '80')

self.assertEqual(ba2hex(bitarray('0000 0001', 'little')), '08')

self.assertEqual(ba2hex(bitarray('1000 0000', 'little')), '10')

self.assertEqual(ba2hex(frozenbitarray('1100 0111', 'big')), 'c7')

# length not multiple of 4

self.assertRaises(ValueError, ba2hex, bitarray('10'))

self.assertRaises(TypeError, ba2hex, '101')

c = ba2hex(bitarray('1101', 'big'))

self.assertIsInstance(c, str)

for n in range(7):

a = bitarray(n * '1111', 'big')

b = a.copy()

self.assertEqual(ba2hex(a), n * 'f')

# ensure original object wasn't altered

self.assertEQUAL(a, b)

def test_hex2ba(self):

_set_default_endian('big')

self.assertEqual(hex2ba(''), bitarray())

for c in 'e', 'E', b'e', b'E', u'e', u'E':

a = hex2ba(c)

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

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

self.assertEQUAL(hex2ba('01'), bitarray('0000 0001', 'big'))

self.assertEQUAL(hex2ba('08', 'little'),

bitarray('0000 0001', 'little'))

self.assertEQUAL(hex2ba('aD'), bitarray('1010 1101', 'big'))

self.assertEQUAL(hex2ba(b'10aF'),

bitarray('0001 0000 1010 1111', 'big'))

self.assertEQUAL(hex2ba(b'10aF', 'little'),

bitarray('1000 0000 0101 1111', 'little'))

def test_hex2ba_errors(self):

self.assertRaises(TypeError, hex2ba, 0)

for endian in 'little', 'big':

_set_default_endian(endian)

self.assertRaises(ValueError, hex2ba, '01a7g89')

self.assertRaises(UnicodeEncodeError, hex2ba, u'10\u20ac')

# check for NUL bytes

for b in b'\0', b'\0f', b'f\0', b'\0ff', b'f\0f', b'ff\0':

self.assertRaises(ValueError, hex2ba, b)

@staticmethod

def hex2ba(s, endian=None):

a = bitarray(0, endian or get_default_endian())

a.encode(CODEDICT[a.endian()], s)

return a

@staticmethod

def ba2hex(a):

return ''.join(a.iterdecode(CODEDICT[a.endian()]))

def test_explicit(self):

data = [ # little big

('', '', ''),

('1000', '1', '8'),

('1000 1100', '13', '8c'),

('1000 1100 1110', '137', '8ce'),

('1000 1100 1110 1111' , '137f', '8cef'),

('1000 1100 1110 1111 0100', '137f2', '8cef4'),

]

for bs, hex_le, hex_be in data:

a_be = bitarray(bs, 'big')

a_le = bitarray(bs, 'little')

self.assertEQUAL(hex2ba(hex_be, 'big'), a_be)

self.assertEQUAL(hex2ba(hex_le, 'little'), a_le)

self.assertEqual(ba2hex(a_be), hex_be)

self.assertEqual(ba2hex(a_le), hex_le)

# test simple encode / decode implementation

self.assertEQUAL(self.hex2ba(hex_be, 'big'), a_be)

self.assertEQUAL(self.hex2ba(hex_le, 'little'), a_le)

self.assertEqual(self.ba2hex(a_be), hex_be)

self.assertEqual(self.ba2hex(a_le), hex_le)

def test_round_trip(self):

s = ''.join(choice(hexdigits) for _ in range(randint(10, 100)))

for default_endian in 'big', 'little':

_set_default_endian(default_endian)

a = hex2ba(s)

self.check_obj(a)

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

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

t = ba2hex(a)

self.assertEqual(t, s.lower())

b = hex2ba(t, default_endian)

self.assertEQUAL(a, b)

# test simple encode / decode implementation

self.assertEQUAL(a, self.hex2ba(t))

def test_ba2base(self):

c = ba2base(16, bitarray('1101', 'big'))

self.assertIsInstance(c, str)

def test_base2ba(self):

_set_default_endian('big')

for c in 'e', 'E', b'e', b'E', u'e', u'E':

a = base2ba(16, c)

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

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

def test_explicit(self):

data = [ # n little big

('', 2, '', ''),

('1 0 1', 2, '101', '101'),

('11 01 00', 4, '320', '310'),

('111 001', 8, '74', '71'),

('1111 0001', 16, 'f8', 'f1'),

('11111 00001', 32, '7Q', '7B'),

('111111 000001', 64, '/g', '/B'),

]

for bs, n, s_le, s_be in data:

a_le = bitarray(bs, 'little')

a_be = bitarray(bs, 'big')

self.assertEQUAL(base2ba(n, s_le, 'little'), a_le)

self.assertEQUAL(base2ba(n, s_be, 'big'), a_be)

self.assertEqual(ba2base(n, a_le), s_le)

self.assertEqual(ba2base(n, a_be), s_be)

def test_empty(self):

for n in 2, 4, 8, 16, 32, 64:

a = base2ba(n, '')

self.assertEqual(a, bitarray())

self.assertEqual(ba2base(n, a), '')

def test_upper(self):

self.assertEqual(base2ba(16, 'F'), bitarray('1111'))

def test_invalid_characters(self):

for n, s in ((2, '2'), (4, '4'), (8, '8'), (16, 'g'), (32, '8'),

(32, '1'), (32, 'a'), (64, '-'), (64, '_')):

self.assertRaises(ValueError, base2ba, n, s)

def test_invalid_args(self):

a = bitarray()

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

self.assertRaises(TypeError, base2ba, None, '')

for i in range(-10, 260):

if i in (2, 4, 8, 16, 32, 64):

continue

self.assertRaises(ValueError, ba2base, i, a)

self.assertRaises(ValueError, base2ba, i, '')

def test_binary(self):

a = base2ba(2, '1011')

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

self.assertEqual(ba2base(2, a), '1011')

for a in self.randombitarrays():

s = ba2base(2, a)

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

self.assertEQUAL(base2ba(2, s, a.endian()), a)

def test_quaternary(self):

a = base2ba(4, '0123', 'big')

self.assertEqual(a, bitarray('00 01 10 11'))

self.assertEqual(ba2base(4, a), '0123')

def test_octal(self):

a = base2ba(8, '0147', 'big')

self.assertEqual(a, bitarray('000 001 100 111'))

self.assertEqual(ba2base(8, a), '0147')

def test_hexadecimal(self):

a = base2ba(16, 'F61', 'big')

self.assertEqual(a, bitarray('1111 0110 0001'))

self.assertEqual(ba2base(16, a), 'f61')

for n in range(100):

s = ''.join(choice(hexdigits) for _ in range(n))

for endian in 'big', 'little':

a = base2ba(16, s, endian)

self.assertEQUAL(a, hex2ba(s, endian))

self.assertEqual(ba2base(16, a), ba2hex(a))

def test_base32(self):

a = base2ba(32, '7SH', 'big')

self.assertEqual(a, bitarray('11111 10010 00111'))

self.assertEqual(ba2base(32, a), '7SH')

msg = os.urandom(randint(10, 100) * 5)

s = base64.b32encode(msg).decode()

a = base2ba(32, s, 'big')

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

self.assertEqual(ba2base(32, a), s)

def test_base64(self):

a = base2ba(64, '/jH', 'big')

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

self.assertEqual(ba2base(64, a), '/jH')

msg = os.urandom(randint(10, 100) * 3)

s = base64.standard_b64encode(msg).decode()

a = base2ba(64, s, 'big')

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

self.assertEqual(ba2base(64, a), s)

def test_alphabets(self):

for m, n, alpabet in [

(1, 2, '01'),

(2, 4, '0123'),

(3, 8, '01234567'),

(4, 16, '0123456789abcdef'),

(5, 32, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'),

(6, 64, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

'abcdefghijklmnopqrstuvwxyz0123456789+/'),

]:

self.assertEqual(1 << m, n)

self.assertEqual(len(alpabet), n)

for i, c in enumerate(alpabet):

for endian in 'big', 'little':

self.assertEqual(ba2int(base2ba(n, c, endian)), i)

self.assertEqual(ba2base(n, int2ba(i, m, endian)), c)

def test_random(self):

for a in self.randombitarrays():

for m in range(1, 7):

n = 1 << m

if len(a) % m == 0:

s = ba2base(n, a)

b = base2ba(n, s, a.endian())

self.assertEQUAL(a, b)

self.check_obj(b)

else:

self.assertRaises(ValueError, ba2base, n, a)

def test_random2(self):

for m in range(1, 7):

n = 1 << m

for length in range(0, 100, m):

a = urandom(length, 'little')

self.assertEQUAL(base2ba(n, ba2base(n, a), 'little'), a)

b = bitarray(a, 'big')

def test_ba2int(self):

self.assertEqual(ba2int(bitarray('0')), 0)

self.assertEqual(ba2int(bitarray('1')), 1)

self.assertEqual(ba2int(bitarray('00101', 'big')), 5)

self.assertEqual(ba2int(bitarray('00101', 'little')), 20)

self.assertEqual(ba2int(frozenbitarray('11')), 3)

self.assertRaises(ValueError, ba2int, bitarray())

self.assertRaises(ValueError, ba2int, frozenbitarray())

self.assertRaises(TypeError, ba2int, '101')

a = bitarray('111')

b = a.copy()

self.assertEqual(ba2int(a), 7)

# ensure original object wasn't altered

self.assertEQUAL(a, b)

def test_int2ba(self):

self.assertEqual(int2ba(0), bitarray('0'))

self.assertEqual(int2ba(1), bitarray('1'))

self.assertEqual(int2ba(5), bitarray('101'))

self.assertEQUAL(int2ba(6, endian='big'), bitarray('110', 'big'))

self.assertEQUAL(int2ba(6, endian='little'),

bitarray('011', 'little'))

self.assertRaises(TypeError, int2ba, 1.0)

self.assertRaises(TypeError, int2ba, 1, 3.0)

self.assertRaises(ValueError, int2ba, 1, 0)

self.assertRaises(TypeError, int2ba, 1, 10, 123)

self.assertRaises(ValueError, int2ba, 1, 10, 'asd')

# signed integer requires length

self.assertRaises(TypeError, int2ba, 100, signed=True)

def test_signed(self):

for s, i in [

('0', 0),

('1', -1),

('00', 0),

('10', 1),

('01', -2),