def test_ab64_encode(self):
"""ab64_encode()"""
from passlib.utils.binary import ab64_encode
# accept bytes
self.assertEqual(ab64_encode(hb("69b7")), b"abc")
# reject unicode
self.assertRaises(TypeError if PY3 else UnicodeEncodeError,
ab64_encode, hb("69b7").decode("latin-1"))
# insert correct padding before decoding
self.assertEqual(ab64_encode(hb("69b71d")), b"abcd") # 0 mod 4
self.assertEqual(ab64_encode(hb("69b71d79")), b"abcdeQ") # 2 mod 4
self.assertEqual(ab64_encode(hb("69b71d79f8")), b"abcdefg") # 3 mod 4
# output "./" altchars
self.assertEqual(ab64_encode(hb("69bfbf")), b"ab./")
python类bytes()的实例源码
def test_b64s_decode(self):
"""b64s_decode()"""
from passlib.utils.binary import b64s_decode
# accept bytes or unicode
self.assertEqual(b64s_decode(b"abc"), hb("69b7"))
self.assertEqual(b64s_decode(u("abc")), hb("69b7"))
# reject non-ascii unicode
self.assertRaises(ValueError, b64s_decode, u("ab\xff"))
# underlying a2b_ascii treats non-base64 chars as "Incorrect padding"
self.assertRaises(TypeError, b64s_decode, b"ab\xff")
self.assertRaises(TypeError, b64s_decode, b"ab!")
self.assertRaises(TypeError, b64s_decode, u("ab!"))
# insert correct padding, handle dirty padding bits
self.assertEqual(b64s_decode(b"abcd"), hb("69b71d")) # 0 mod 4
self.assertRaises(ValueError, b64s_decode, b"abcde") # 1 mod 4
self.assertEqual(b64s_decode(b"abcdef"), hb("69b71d79")) # 2 mod 4, dirty padding bits
self.assertEqual(b64s_decode(b"abcdeQ"), hb("69b71d79")) # 2 mod 4, clean padding bits
self.assertEqual(b64s_decode(b"abcdefg"), hb("69b71d79f8")) # 3 mod 4, clean padding bits
def test_b64s_encode(self):
"""b64s_encode()"""
from passlib.utils.binary import b64s_encode
# accept bytes
self.assertEqual(b64s_encode(hb("69b7")), b"abc")
# reject unicode
self.assertRaises(TypeError if PY3 else UnicodeEncodeError,
b64s_encode, hb("69b7").decode("latin-1"))
# insert correct padding before decoding
self.assertEqual(b64s_encode(hb("69b71d")), b"abcd") # 0 mod 4
self.assertEqual(b64s_encode(hb("69b71d79")), b"abcdeQ") # 2 mod 4
self.assertEqual(b64s_encode(hb("69b71d79f8")), b"abcdefg") # 3 mod 4
# output "+/" altchars
self.assertEqual(b64s_encode(hb("69bfbf")), b"ab+/")
def test_non_numeric_input_types(self):
# Test possible non-numeric types for the argument x, including
# subclasses of the explicitly documented accepted types.
class CustomStr(str): pass
class CustomBytes(bytes): pass
class CustomByteArray(bytearray): pass
values = [b'100',
bytearray(b'100'),
CustomStr('100'),
CustomBytes(b'100'),
CustomByteArray(b'100')]
for x in values:
msg = 'x has type %s' % type(x).__name__
self.assertEqual(int(x), 100, msg=msg)
self.assertEqual(int(x, 2), 4, msg=msg)
def test_ab64_encode(self):
"""ab64_encode()"""
from passlib.utils.binary import ab64_encode
# accept bytes
self.assertEqual(ab64_encode(hb("69b7")), b"abc")
# reject unicode
self.assertRaises(TypeError if PY3 else UnicodeEncodeError,
ab64_encode, hb("69b7").decode("latin-1"))
# insert correct padding before decoding
self.assertEqual(ab64_encode(hb("69b71d")), b"abcd") # 0 mod 4
self.assertEqual(ab64_encode(hb("69b71d79")), b"abcdeQ") # 2 mod 4
self.assertEqual(ab64_encode(hb("69b71d79f8")), b"abcdefg") # 3 mod 4
# output "./" altchars
self.assertEqual(ab64_encode(hb("69bfbf")), b"ab./")
def test_b64s_decode(self):
"""b64s_decode()"""
from passlib.utils.binary import b64s_decode
# accept bytes or unicode
self.assertEqual(b64s_decode(b"abc"), hb("69b7"))
self.assertEqual(b64s_decode(u("abc")), hb("69b7"))
# reject non-ascii unicode
self.assertRaises(ValueError, b64s_decode, u("ab\xff"))
# underlying a2b_ascii treats non-base64 chars as "Incorrect padding"
self.assertRaises(TypeError, b64s_decode, b"ab\xff")
self.assertRaises(TypeError, b64s_decode, b"ab!")
self.assertRaises(TypeError, b64s_decode, u("ab!"))
# insert correct padding, handle dirty padding bits
self.assertEqual(b64s_decode(b"abcd"), hb("69b71d")) # 0 mod 4
self.assertRaises(ValueError, b64s_decode, b"abcde") # 1 mod 4
self.assertEqual(b64s_decode(b"abcdef"), hb("69b71d79")) # 2 mod 4, dirty padding bits
self.assertEqual(b64s_decode(b"abcdeQ"), hb("69b71d79")) # 2 mod 4, clean padding bits
self.assertEqual(b64s_decode(b"abcdefg"), hb("69b71d79f8")) # 3 mod 4, clean padding bits
def test_b64s_encode(self):
"""b64s_encode()"""
from passlib.utils.binary import b64s_encode
# accept bytes
self.assertEqual(b64s_encode(hb("69b7")), b"abc")
# reject unicode
self.assertRaises(TypeError if PY3 else UnicodeEncodeError,
b64s_encode, hb("69b7").decode("latin-1"))
# insert correct padding before decoding
self.assertEqual(b64s_encode(hb("69b71d")), b"abcd") # 0 mod 4
self.assertEqual(b64s_encode(hb("69b71d79")), b"abcdeQ") # 2 mod 4
self.assertEqual(b64s_encode(hb("69b71d79f8")), b"abcdefg") # 3 mod 4
# output "+/" altchars
self.assertEqual(b64s_encode(hb("69bfbf")), b"ab+/")
def test_getrandbytes(self):
"""getrandbytes()"""
from passlib.utils import getrandbytes
wrapper = partial(getrandbytes, self.getRandom())
self.assertEqual(len(wrapper(0)), 0)
a = wrapper(10)
b = wrapper(10)
self.assertIsInstance(a, bytes)
self.assertEqual(len(a), 10)
self.assertEqual(len(b), 10)
self.assertNotEqual(a, b)
def test_getrandstr(self, seed):
"""getrandstr()"""
from passlib.utils import getrandstr
wrapper = partial(getrandstr, self.getRandom(seed=seed))
# count 0
self.assertEqual(wrapper('abc',0), '')
# count <0
self.assertRaises(ValueError, wrapper, 'abc', -1)
# letters 0
self.assertRaises(ValueError, wrapper, '', 0)
# letters 1
self.assertEqual(wrapper('a', 5), 'aaaaa')
# NOTE: the following parts are non-deterministic,
# with a small chance of failure (outside chance it may pick
# a string w/o one char, even more remote chance of picking
# same string). to combat this, we run it against multiple
# fixed seeds (using run_with_fixed_seeds decorator),
# and hope that they're sufficient to test the range of behavior.
# letters
x = wrapper(u('abc'), 32)
y = wrapper(u('abc'), 32)
self.assertIsInstance(x, unicode)
self.assertNotEqual(x,y)
self.assertEqual(sorted(set(x)), [u('a'),u('b'),u('c')])
# bytes
x = wrapper(b'abc', 32)
y = wrapper(b'abc', 32)
self.assertIsInstance(x, bytes)
self.assertNotEqual(x,y)
# NOTE: decoding this due to py3 bytes
self.assertEqual(sorted(set(x.decode("ascii"))), [u('a'),u('b'),u('c')])
def test_bytes(self):
"""test b() helper, bytes and native str type"""
if PY3:
import builtins
self.assertIs(bytes, builtins.bytes)
else:
import __builtin__ as builtins
self.assertIs(bytes, builtins.str)
self.assertIsInstance(b'', bytes)
self.assertIsInstance(b'\x00\xff', bytes)
if PY3:
self.assertEqual(b'\x00\xff'.decode("latin-1"), "\x00\xff")
else:
self.assertEqual(b'\x00\xff', "\x00\xff")
def test_to_bytes(self):
"""test to_bytes()"""
from passlib.utils import to_bytes
# check unicode inputs
self.assertEqual(to_bytes(u('abc')), b'abc')
self.assertEqual(to_bytes(u('\x00\xff')), b'\x00\xc3\xbf')
# check unicode w/ encodings
self.assertEqual(to_bytes(u('\x00\xff'), 'latin-1'), b'\x00\xff')
self.assertRaises(ValueError, to_bytes, u('\x00\xff'), 'ascii')
# check bytes inputs
self.assertEqual(to_bytes(b'abc'), b'abc')
self.assertEqual(to_bytes(b'\x00\xff'), b'\x00\xff')
self.assertEqual(to_bytes(b'\x00\xc3\xbf'), b'\x00\xc3\xbf')
# check byte inputs ignores enocding
self.assertEqual(to_bytes(b'\x00\xc3\xbf', "latin-1"),
b'\x00\xc3\xbf')
# check bytes transcoding
self.assertEqual(to_bytes(b'\x00\xc3\xbf', "latin-1", "", "utf-8"),
b'\x00\xff')
# check other
self.assertRaises(AssertionError, to_bytes, 'abc', None)
self.assertRaises(TypeError, to_bytes, None)
def test_ab64_decode(self):
"""ab64_decode()"""
from passlib.utils.binary import ab64_decode
# accept bytes or unicode
self.assertEqual(ab64_decode(b"abc"), hb("69b7"))
self.assertEqual(ab64_decode(u("abc")), hb("69b7"))
# reject non-ascii unicode
self.assertRaises(ValueError, ab64_decode, u("ab\xff"))
# underlying a2b_ascii treats non-base64 chars as "Incorrect padding"
self.assertRaises(TypeError, ab64_decode, b"ab\xff")
self.assertRaises(TypeError, ab64_decode, b"ab!")
self.assertRaises(TypeError, ab64_decode, u("ab!"))
# insert correct padding, handle dirty padding bits
self.assertEqual(ab64_decode(b"abcd"), hb("69b71d")) # 0 mod 4
self.assertRaises(ValueError, ab64_decode, b"abcde") # 1 mod 4
self.assertEqual(ab64_decode(b"abcdef"), hb("69b71d79")) # 2 mod 4, dirty padding bits
self.assertEqual(ab64_decode(b"abcdeQ"), hb("69b71d79")) # 2 mod 4, clean padding bits
self.assertEqual(ab64_decode(b"abcdefg"), hb("69b71d79f8")) # 3 mod 4, clean padding bits
# support "./" or "+/" altchars
# (lets us transition to "+/" representation, merge w/ b64s_decode)
self.assertEqual(ab64_decode(b"ab+/"), hb("69bfbf"))
self.assertEqual(ab64_decode(b"ab./"), hb("69bfbf"))
def test_decode_bytes_padding(self):
"""test decode_bytes() ignores padding bits"""
bchr = (lambda v: bytes([v])) if PY3 else chr
engine = self.engine
m = self.m
decode = engine.decode_bytes
BNULL = b"\x00"
# length == 2 mod 4: 4 bits of padding
self.assertEqual(decode(m(0,0)), BNULL)
for i in range(0,6):
if engine.big: # 4 lsb padding
correct = BNULL if i < 4 else bchr(1<<(i-4))
else: # 4 msb padding
correct = bchr(1<<(i+6)) if i < 2 else BNULL
self.assertEqual(decode(m(0,1<<i)), correct, "%d/4 bits:" % i)
# length == 3 mod 4: 2 bits of padding
self.assertEqual(decode(m(0,0,0)), BNULL*2)
for i in range(0,6):
if engine.big: # 2 lsb are padding
correct = BNULL if i < 2 else bchr(1<<(i-2))
else: # 2 msg are padding
correct = bchr(1<<(i+4)) if i < 4 else BNULL
self.assertEqual(decode(m(0,0,1<<i)), BNULL + correct,
"%d/2 bits:" % i)
def bascii_to_str(s):
assert isinstance(s, bytes)
return s.decode("ascii")
def iter_byte_values(s):
assert isinstance(s, bytes)
return s
def iter_byte_chars(s):
assert isinstance(s, bytes)
# FIXME: there has to be a better way to do this
return (bytes([c]) for c in s)
def bascii_to_str(s):
assert isinstance(s, bytes)
return s
def iter_byte_chars(s):
assert isinstance(s, bytes)
return s
def test_bytes_mul(self):
self.assertEqual(b'\x00' * int(5), b'\x00' * 5)
self.assertEqual(bytes(b'\x00') * int(5), bytes(b'\x00') * 5)
def test_int_bytes(self):
self.assertEqual(int(b'a\r\n', 16), 10)
self.assertEqual(int(bytes(b'a\r\n'), 16), 10)
def test_getrandbytes(self):
"test getrandbytes()"
from passlib.utils import getrandbytes, rng
def f(*a,**k):
return getrandbytes(rng, *a, **k)
self.assertEqual(len(f(0)), 0)
a = f(10)
b = f(10)
self.assertIsInstance(a, bytes)
self.assertEqual(len(a), 10)
self.assertEqual(len(b), 10)
self.assertNotEqual(a, b)
def test_getrandstr(self):
"test getrandstr()"
from passlib.utils import getrandstr, rng
def f(*a,**k):
return getrandstr(rng, *a, **k)
# count 0
self.assertEqual(f('abc',0), '')
# count <0
self.assertRaises(ValueError, f, 'abc', -1)
# letters 0
self.assertRaises(ValueError, f, '', 0)
# letters 1
self.assertEqual(f('a',5), 'aaaaa')
# letters
x = f(u('abc'), 16)
y = f(u('abc'), 16)
self.assertIsInstance(x, unicode)
self.assertNotEqual(x,y)
self.assertEqual(sorted(set(x)), [u('a'),u('b'),u('c')])
# bytes
x = f(b('abc'), 16)
y = f(b('abc'), 16)
self.assertIsInstance(x, bytes)
self.assertNotEqual(x,y)
# NOTE: decoding this due to py3 bytes
self.assertEqual(sorted(set(x.decode("ascii"))), [u('a'),u('b'),u('c')])
# generate_password
from passlib.utils import generate_password
self.assertEqual(len(generate_password(15)), 15)
def test_bytes(self):
"test b() helper, bytes and native str type"
if PY3:
import builtins
self.assertIs(bytes, builtins.bytes)
else:
import __builtin__ as builtins
self.assertIs(bytes, builtins.str)
self.assertIsInstance(b(''), bytes)
self.assertIsInstance(b('\x00\xff'), bytes)
if PY3:
self.assertEqual(b('\x00\xff').decode("latin-1"), "\x00\xff")
else:
self.assertEqual(b('\x00\xff'), "\x00\xff")
def test_to_bytes(self):
"test to_bytes()"
from passlib.utils import to_bytes
# check unicode inputs
self.assertEqual(to_bytes(u('abc')), b('abc'))
self.assertEqual(to_bytes(u('\x00\xff')), b('\x00\xc3\xbf'))
# check unicode w/ encodings
self.assertEqual(to_bytes(u('\x00\xff'), 'latin-1'), b('\x00\xff'))
self.assertRaises(ValueError, to_bytes, u('\x00\xff'), 'ascii')
# check bytes inputs
self.assertEqual(to_bytes(b('abc')), b('abc'))
self.assertEqual(to_bytes(b('\x00\xff')), b('\x00\xff'))
self.assertEqual(to_bytes(b('\x00\xc3\xbf')), b('\x00\xc3\xbf'))
# check byte inputs ignores enocding
self.assertEqual(to_bytes(b('\x00\xc3\xbf'), "latin-1"),
b('\x00\xc3\xbf'))
# check bytes transcoding
self.assertEqual(to_bytes(b('\x00\xc3\xbf'), "latin-1", "", "utf-8"),
b('\x00\xff'))
# check other
self.assertRaises(AssertionError, to_bytes, 'abc', None)
self.assertRaises(TypeError, to_bytes, None)
def test_decode_bytes_padding(self):
"test decode_bytes() ignores padding bits"
bchr = (lambda v: bytes([v])) if PY3 else chr
engine = self.engine
m = self.m
decode = engine.decode_bytes
BNULL = b("\x00")
# length == 2 mod 4: 4 bits of padding
self.assertEqual(decode(m(0,0)), BNULL)
for i in range(0,6):
if engine.big: # 4 lsb padding
correct = BNULL if i < 4 else bchr(1<<(i-4))
else: # 4 msb padding
correct = bchr(1<<(i+6)) if i < 2 else BNULL
self.assertEqual(decode(m(0,1<<i)), correct, "%d/4 bits:" % i)
# length == 3 mod 4: 2 bits of padding
self.assertEqual(decode(m(0,0,0)), BNULL*2)
for i in range(0,6):
if engine.big: # 2 lsb are padding
correct = BNULL if i < 2 else bchr(1<<(i-2))
else: # 2 msg are padding
correct = bchr(1<<(i+4)) if i < 4 else BNULL
self.assertEqual(decode(m(0,0,1<<i)), BNULL + correct,
"%d/2 bits:" % i)
def bascii_to_str(s):
assert isinstance(s, bytes)
return s.decode("ascii")
def iter_byte_values(s):
assert isinstance(s, bytes)
return s
def bascii_to_str(s):
assert isinstance(s, bytes)
return s
def iter_byte_values(s):
assert isinstance(s, bytes)
return (ord(c) for c in s)
def iter_byte_chars(s):
assert isinstance(s, bytes)
return s
