def test_zero_bytes(self):
self.assertEqual(integer.uint_to_bytes(integer.bytes_to_uint(ZERO_BYTES)),
ONE_ZERO_BYTE)
self.assertEqual(integer.uint_to_bytes(_alt_integer.bytes_to_uint_naive(ZERO_BYTES)),
ONE_ZERO_BYTE)
self.assertEqual(integer.uint_to_bytes(_alt_integer.bytes_to_uint_simple(ZERO_BYTES)),
ONE_ZERO_BYTE)
def test_zero_bytes(self):
self.assertEqual(uint_to_bytes(bytes_to_uint(zero_bytes)),
one_zero_byte)
self.assertEqual(uint_to_bytes(bytes_to_uint_naive(zero_bytes)),
one_zero_byte)
self.assertEqual(uint_to_bytes(bytes_to_uint_simple(zero_bytes)),
one_zero_byte)
def test_overflow_allowed(self):
self.assertEqual(uint_to_bytes(0xc0ff, fill_size=1, overflow=True),
b('\xc0\xff'))
self.assertEqual(uint_to_bytes(123456789, fill_size=3, overflow=True),
b('\x07\x5b\xcd\x15'))
self.assertEqual(uint_to_bytes(0xf00dc0ffee, fill_size=4,
overflow=True),
b('\xf0\x0d\xc0\xff\xee'))
def test_fill_size(self):
self.assertEqual(integer.uint_to_bytes(0xc0ff, fill_size=4),
b("\x00\x00\xc0\xff"))
self.assertEqual(integer.uint_to_bytes(0xc0ffee, fill_size=6),
b("\x00\x00\x00\xc0\xff\xee"))
self.assertEqual(integer.uint_to_bytes(123456789, fill_size=6),
b("\x00\x00\x07[\xcd\x15"))
self.assertEqual(integer.uint_to_bytes(123456789, fill_size=7),
b("\x00\x00\x00\x07[\xcd\x15"))
def test_fill_size(self):
self.assertEqual(uint_to_bytes(0xc0ff, fill_size=4),
b('\x00\x00\xc0\xff'))
self.assertEqual(uint_to_bytes(0xc0ffee, fill_size=6),
b('\x00\x00\x00\xc0\xff\xee'))
self.assertEqual(uint_to_bytes(123456789, fill_size=6),
b('\x00\x00\x07[\xcd\x15'))
self.assertEqual(uint_to_bytes(123456789, fill_size=7),
b('\x00\x00\x00\x07[\xcd\x15'))
def test_codec_equivalence(self):
# Padding bytes are not preserved (it is acceptable here).
random_bytes = b("\x00\xbcE\x9a\xda]")
expected_bytes = b("\xbcE\x9a\xda]")
self.assertEqual(uint_to_bytes(bytes_to_uint(random_bytes)),
expected_bytes)
self.assertEqual(uint_to_bytes(bytes_to_uint_naive(random_bytes)),
expected_bytes)
self.assertEqual(uint_to_bytes(bytes_to_uint_simple(random_bytes)),
expected_bytes)
def test_correctness(self):
self.assertEqual(integer.uint_to_bytes(0xeeeeffff),
b("\xee\xee\xff\xff"))
self.assertEqual(integer.uint_to_bytes(0xeeeeff),
b("\xee\xee\xff"))
self.assertEqual(_alt_integer.uint_to_bytes_naive(0xeeeeffff),
b("\xee\xee\xff\xff"))
self.assertEqual(_alt_integer.uint_to_bytes_naive(0xeeeeff),
b("\xee\xee\xff"))
self.assertEqual(_alt_integer.uint_to_bytes_simple(0xeeeeffff),
b("\xee\xee\xff\xff"))
self.assertEqual(_alt_integer.uint_to_bytes_simple(0xeeeeff),
b("\xee\xee\xff"))
def test_correctness(self):
self.assertEqual(uint_to_bytes(0xeeeeffff),
b('\xee\xee\xff\xff'))
self.assertEqual(uint_to_bytes(0xeeeeff),
b('\xee\xee\xff'))
self.assertEqual(uint_to_bytes_naive(0xeeeeffff),
b('\xee\xee\xff\xff'))
self.assertEqual(uint_to_bytes_naive(0xeeeeff),
b('\xee\xee\xff'))
self.assertEqual(uint_to_bytes_simple(0xeeeeffff),
b('\xee\xee\xff\xff'))
self.assertEqual(uint_to_bytes_simple(0xeeeeff),
b('\xee\xee\xff'))
def test_zero(self):
self.assertEqual(uint_to_bytes(0, 4), b('\x00') * 4)
self.assertEqual(uint_to_bytes_array_based(0, 4), b('\x00') * 4)
self.assertEqual(uint_to_bytes_naive(0, 4), b('\x00') * 4)
self.assertEqual(uint_to_bytes_naive_array_based(0, 4), b('\x00') * 4)
self.assertEqual(uint_to_bytes_pycrypto(0, 4), b('\x00') * 4)
self.assertEqual(uint_to_bytes(0, 7), b('\x00') * 7)
self.assertEqual(uint_to_bytes_naive(0, 7), b('\x00') * 7)
self.assertEqual(uint_to_bytes_array_based(0, 7), b('\x00') * 7)
self.assertEqual(uint_to_bytes_naive_array_based(0, 7), b('\x00') * 7)
self.assertEqual(uint_to_bytes_pycrypto(0, 7), b('\x00') * 7)
self.assertEqual(uint_to_bytes(0), b('\x00'))
self.assertEqual(uint_to_bytes_naive(0), b('\x00'))
self.assertEqual(uint_to_bytes_array_based(0), b('\x00'))
self.assertEqual(uint_to_bytes_naive_array_based(0), b('\x00'))
self.assertEqual(uint_to_bytes_pycrypto(0), b('\x00'))
def test_zero(self):
self.assertEqual(integer.uint_to_bytes(0, 4), b("\x00") * 4)
self.assertEqual(_alt_integer.uint_to_bytes_array_based(0, 4), b("\x00") * 4)
self.assertEqual(_alt_integer.uint_to_bytes_naive(0, 4), b("\x00") * 4)
self.assertEqual(_alt_integer.uint_to_bytes_naive_array_based(0, 4), b("\x00") * 4)
self.assertEqual(_alt_integer.uint_to_bytes_pycrypto(0, 4), b("\x00") * 4)
self.assertEqual(integer.uint_to_bytes(0, 7), b("\x00") * 7)
self.assertEqual(_alt_integer.uint_to_bytes_naive(0, 7), b("\x00") * 7)
self.assertEqual(_alt_integer.uint_to_bytes_array_based(0, 7), b("\x00") * 7)
self.assertEqual(_alt_integer.uint_to_bytes_naive_array_based(0, 7), b("\x00") * 7)
self.assertEqual(_alt_integer.uint_to_bytes_pycrypto(0, 7), b("\x00") * 7)
self.assertEqual(integer.uint_to_bytes(0), b("\x00"))
self.assertEqual(_alt_integer.uint_to_bytes_naive(0), b("\x00"))
self.assertEqual(_alt_integer.uint_to_bytes_array_based(0), b("\x00"))
self.assertEqual(_alt_integer.uint_to_bytes_naive_array_based(0), b("\x00"))
self.assertEqual(_alt_integer.uint_to_bytes_pycrypto(0), b("\x00"))
def uint_to_base256(number, encoded, base_zero):
"""Convert uint to base 256."""
if number == 0:
raw_bytes = EMPTY_BYTE
else:
raw_bytes = uint_to_bytes(number)
zero_leading = bytes_leading(encoded, base_zero)
if zero_leading:
raw_bytes = raw_bytes.rjust(len(raw_bytes) + zero_leading, ZERO_BYTE)
return raw_bytes
def sign(self, digest):
"""
Signs a digest with the key.
:param digest:
The SHA-1 digest of the data.
:returns:
Signature byte string.
"""
return integer.uint_to_bytes(self._sign(digest))
def uint_to_base256(number, encoded, base_zero):
"""Convert uint to base 256."""
if number == 0:
raw_bytes = EMPTY_BYTE
else:
raw_bytes = integer.uint_to_bytes(number)
zero_leading = builtins.bytes_leading(encoded, base_zero)
if zero_leading:
raw_bytes = raw_bytes.rjust(len(raw_bytes) + zero_leading, ZERO_BYTE)
return raw_bytes
def sign(self, digest):
"""
Signs a digest with the key.
:param digest:
The SHA-1 digest of the data.
:returns:
Signature byte string.
"""
return integer.uint_to_bytes(self._sign(digest))
def test_correctness_for_primes(self):
for prime in prime_sieve.SIEVE:
self.assertEqual(integer.uint_to_bytes(prime), _alt_integer.uint_to_bytes_naive(prime),
"Boom %d" % prime)
self.assertEqual(_alt_integer.uint_to_bytes_array_based(prime),
_alt_integer.uint_to_bytes_naive(prime),
"Boom %d" % prime)
self.assertEqual(_alt_integer.uint_to_bytes_pycrypto(prime),
_alt_integer.uint_to_bytes_naive(prime),
"Boom %d" % prime)
def test_correctness_for_primes(self):
for prime in SIEVE:
self.assertEqual(uint_to_bytes(prime), uint_to_bytes_naive(prime),
"Boom %d" % prime)
self.assertEqual(uint_to_bytes_array_based(prime),
uint_to_bytes_naive(prime),
"Boom %d" % prime)
self.assertEqual(uint_to_bytes_pycrypto(prime),
uint_to_bytes_naive(prime),
"Boom %d" % prime)
def test_accuracy(self):
self.assertEqual(integer.uint_to_bytes(123456789), b("\x07[\xcd\x15"))
self.assertEqual(_alt_integer.uint_to_bytes_pycrypto(123456789),
b("\x07[\xcd\x15"))
self.assertEqual(_alt_integer.uint_to_bytes_array_based(123456789),
b("\x07[\xcd\x15"))
self.assertEqual(_alt_integer.uint_to_bytes_naive(123456789), b("\x07[\xcd\x15"))
self.assertEqual(_alt_integer.uint_to_bytes_naive_array_based(123456789),
b("\x07[\xcd\x15"))
self.assertEqual(integer.uint_to_bytes(LONG_VALUE),
EXPECTED_BYTES)
self.assertEqual(_alt_integer.uint_to_bytes_pycrypto(LONG_VALUE),
EXPECTED_BYTES)
self.assertEqual(_alt_integer.uint_to_bytes_array_based(LONG_VALUE),
EXPECTED_BYTES)
self.assertEqual(_alt_integer.uint_to_bytes_naive(LONG_VALUE),
EXPECTED_BYTES)
self.assertEqual(_alt_integer.uint_to_bytes_naive_array_based(LONG_VALUE),
EXPECTED_BYTES)
def test_correctness_against_base_implementation(self):
# Slow test.
values = [
1 << 512,
1 << 8192,
1 << 77,
]
for value in values:
self.assertEqual(uint_to_bytes(value),
uint_to_bytes_naive(value),
"Boom %d" % value)
def test_correctness_against_base_implementation(self):
# Slow test.
values = [
1 << 512,
1 << 8192,
1 << 77,
]
for value in values:
self.assertEqual(integer.uint_to_bytes(value),
_alt_integer.uint_to_bytes_naive(value),
"Boom %d" % value)
def test_accuracy(self):
self.assertEqual(uint_to_bytes(123456789), b('\x07[\xcd\x15'))
self.assertEqual(uint_to_bytes_pycrypto(123456789),
b('\x07[\xcd\x15'))
self.assertEqual(uint_to_bytes_array_based(123456789),
b('\x07[\xcd\x15'))
self.assertEqual(uint_to_bytes_naive(123456789), b('\x07[\xcd\x15'))
self.assertEqual(uint_to_bytes_naive_array_based(123456789),
b('\x07[\xcd\x15'))
self.assertEqual(uint_to_bytes(long_value),
expected_bytes)
self.assertEqual(uint_to_bytes_pycrypto(long_value),
expected_bytes)
self.assertEqual(uint_to_bytes_array_based(long_value),
expected_bytes)
self.assertEqual(uint_to_bytes_naive(long_value),
expected_bytes)
self.assertEqual(uint_to_bytes_naive_array_based(long_value),
expected_bytes)
def test_chunk_size(self):
self.assertEqual(uint_to_bytes(long_value,
long_value_blocksize),
expected_blocksize_bytes)
self.assertEqual(uint_to_bytes_pycrypto(long_value,
long_value_blocksize),
expected_blocksize_bytes)
self.assertEqual(uint_to_bytes_array_based(long_value,
long_value_blocksize),
expected_blocksize_bytes)
self.assertEqual(uint_to_bytes_naive(long_value,
long_value_blocksize),
expected_blocksize_bytes)
self.assertEqual(uint_to_bytes_naive_array_based(long_value,
long_value_blocksize),
expected_blocksize_bytes)
self.assertEqual(uint_to_bytes(123456789, 6),
b('\x00\x00\x07[\xcd\x15'))
self.assertEqual(uint_to_bytes(123456789, 7),
b('\x00\x00\x00\x07[\xcd\x15'))
self.assertEqual(uint_to_bytes_pycrypto(123456789, 6),
b('\x00\x00\x07[\xcd\x15'))
self.assertEqual(uint_to_bytes_pycrypto(123456789, 7),
b('\x00\x00\x00\x07[\xcd\x15'))
self.assertEqual(uint_to_bytes_array_based(123456789, 6),
b('\x00\x00\x07[\xcd\x15'))
self.assertEqual(uint_to_bytes_array_based(123456789, 7),
b('\x00\x00\x00\x07[\xcd\x15'))
self.assertEqual(uint_to_bytes_naive(123456789, 6),
b('\x00\x00\x07[\xcd\x15'))
self.assertEqual(uint_to_bytes_naive(123456789, 7),
b('\x00\x00\x00\x07[\xcd\x15'))
self.assertEqual(uint_to_bytes_naive_array_based(123456789, 6),
b('\x00\x00\x07[\xcd\x15'))
self.assertEqual(uint_to_bytes_naive_array_based(123456789, 7),
b('\x00\x00\x00\x07[\xcd\x15'))
def test_chunk_size(self):
self.assertEqual(integer.uint_to_bytes(LONG_VALUE,
LONG_VALUE_BLOCKSIZE),
EXPECTED_BLOCKSIZE_BYTES)
self.assertEqual(_alt_integer.uint_to_bytes_pycrypto(LONG_VALUE,
LONG_VALUE_BLOCKSIZE),
EXPECTED_BLOCKSIZE_BYTES)
self.assertEqual(_alt_integer.uint_to_bytes_array_based(LONG_VALUE,
LONG_VALUE_BLOCKSIZE),
EXPECTED_BLOCKSIZE_BYTES)
self.assertEqual(_alt_integer.uint_to_bytes_naive(LONG_VALUE,
LONG_VALUE_BLOCKSIZE),
EXPECTED_BLOCKSIZE_BYTES)
self.assertEqual(_alt_integer.uint_to_bytes_naive_array_based(LONG_VALUE,
LONG_VALUE_BLOCKSIZE),
EXPECTED_BLOCKSIZE_BYTES)
self.assertEqual(integer.uint_to_bytes(123456789, 6),
b("\x00\x00\x07[\xcd\x15"))
self.assertEqual(integer.uint_to_bytes(123456789, 7),
b("\x00\x00\x00\x07[\xcd\x15"))
self.assertEqual(_alt_integer.uint_to_bytes_pycrypto(123456789, 6),
b("\x00\x00\x07[\xcd\x15"))
self.assertEqual(_alt_integer.uint_to_bytes_pycrypto(123456789, 7),
b("\x00\x00\x00\x07[\xcd\x15"))
self.assertEqual(_alt_integer.uint_to_bytes_array_based(123456789, 6),
b("\x00\x00\x07[\xcd\x15"))
self.assertEqual(_alt_integer.uint_to_bytes_array_based(123456789, 7),
b("\x00\x00\x00\x07[\xcd\x15"))
self.assertEqual(_alt_integer.uint_to_bytes_naive(123456789, 6),
b("\x00\x00\x07[\xcd\x15"))
self.assertEqual(_alt_integer.uint_to_bytes_naive(123456789, 7),
b("\x00\x00\x00\x07[\xcd\x15"))
self.assertEqual(_alt_integer.uint_to_bytes_naive_array_based(123456789, 6),
b("\x00\x00\x07[\xcd\x15"))
self.assertEqual(_alt_integer.uint_to_bytes_naive_array_based(123456789, 7),
b("\x00\x00\x00\x07[\xcd\x15"))
def test_correctness_against_base_implementation(self):
# Slow test.
values = [
1 << 512,
1 << 8192,
1 << 77,
]
for value in values:
self.assertEqual(integer.uint_to_bytes(value), _alt_integer.uint_to_bytes_naive(value),
"Boom %d" % value)
self.assertEqual(_alt_integer.uint_to_bytes_array_based(value),
_alt_integer.uint_to_bytes_naive(value),
"Boom %d" % value)
self.assertEqual(integer.uint_to_bytes(value),
_alt_integer.uint_to_bytes_naive_array_based(value),
"Boom %d" % value)
self.assertEqual(_alt_integer.uint_to_bytes_pycrypto(value),
_alt_integer.uint_to_bytes_naive(value),
"Boom %d" % value)
self.assertEqual(integer.bytes_to_uint(integer.uint_to_bytes(value)),
value,
"Boom %d" % value)
def b58decode_naive(encoded,
_charset=base58.ASCII58_BYTES,
_lookup=base58.ASCII58_ORDS):
"""
Simple implementation for benchmarking.
Base-58 decodes a sequence of bytes into raw bytes. Whitespace is ignored.
:param encoded:
Base-58 encoded bytes.
:param _charset:
(Internal) The character set to use. Defaults to ``base58.ASCII58_BYTES``
that uses natural ASCII order.
:param _lookup:
(Internal) Ordinal-to-character lookup table for the specified
character set.
:returns:
Raw bytes.
"""
if not builtins.is_bytes(encoded):
raise TypeError("encoded data must be bytes: got %r" %
type(encoded).__name__)
# Ignore whitespace.
encoded = re.sub(WHITESPACE_PATTERN, EMPTY_BYTE, encoded)
# Convert to big integer.
number = 0
for i, char in enumerate(reversed(encoded)):
number += _lookup[char] * (58 ** i)
# Obtain raw bytes.
if number:
raw_bytes = integer.uint_to_bytes(number)
else:
# We don't want to convert to b"\x00" when we get number == 0.
# That would add an off-by-one extra zero byte in the result.
raw_bytes = EMPTY_BYTE
# Add prefixed padding if required.
# 0 byte is represented using the first character in the character set.
zero_char = _charset[0]
# The extra [0] index in zero_byte_char[0] is for Python2.x-Python3.x
# compatibility. Indexing into Python 3 bytes yields an integer, whereas
# in Python 2.x it yields a single-byte string.
zero_leading = functional.leading(lambda w: w == zero_char[0], encoded)
if zero_leading:
padding = ZERO_BYTE * zero_leading
raw_bytes = padding + raw_bytes
return raw_bytes
def b58decode_naive(encoded,
_charset=base58.ASCII58_BYTES,
_lookup=base58.ASCII58_ORDS):
"""
Simple implementation for benchmarking.
Base-58 decodes a sequence of bytes into raw bytes. Whitespace is ignored.
:param encoded:
Base-58 encoded bytes.
:param _charset:
(Internal) The character set to use. Defaults to ``base58.ASCII58_BYTES``
that uses natural ASCII order.
:param _lookup:
(Internal) Ordinal-to-character lookup table for the specified
character set.
:returns:
Raw bytes.
"""
if not builtins.is_bytes(encoded):
raise TypeError("encoded data must be bytes: got %r" %
type(encoded).__name__)
# Ignore whitespace.
encoded = re.sub(WHITESPACE_PATTERN, EMPTY_BYTE, encoded)
# Convert to big integer.
number = 0
for i, char in enumerate(reversed(encoded)):
number += _lookup[char] * (58**i)
# Obtain raw bytes.
if number:
raw_bytes = integer.uint_to_bytes(number)
else:
# We don't want to convert to b"\x00" when we get number == 0.
# That would add an off-by-one extra zero byte in the result.
raw_bytes = EMPTY_BYTE
# Add prefixed padding if required.
# 0 byte is represented using the first character in the character set.
zero_char = _charset[0]
# The extra [0] index in zero_byte_char[0] is for Python2.x-Python3.x
# compatibility. Indexing into Python 3 bytes yields an integer, whereas
# in Python 2.x it yields a single-byte string.
zero_leading = functional.leading(lambda w: w == zero_char[0], encoded)
if zero_leading:
padding = ZERO_BYTE * zero_leading
raw_bytes = padding + raw_bytes
return raw_bytes
def test_wikipedia_decoding(self):
decoding_table = [
(b("1"), 1),
(b("10"), 36),
(b("100"), 1296),
(b("1000"), 46656),
(b("10000"), 1679616),
(b("100000"), 60466176),
(b("1000000"), 2176782336),
(b("10000000"), 78364164096),
(b("100000000"), 2821109907456),
]
for encoded, number in decoding_table:
raw_bytes = integer.uint_to_bytes(number)
self.assertEqual(base36.b36encode(raw_bytes), encoded)
self.assertEqual(base36.b36decode(encoded), raw_bytes)
def test_wikipedia_encoding(self):
encoding_table = [
(1, b("1")),
(10, b("A")),
(100, b("2S")),
(1000, b("RS")),
(10000, b("7PS")),
(100000, b("255S")),
(1000000, b("LFLS")),
(1000000000, b("GJDGXS")),
(1000000000000, b("CRE66I9S")),
]
for number, encoded in encoding_table:
raw_bytes = integer.uint_to_bytes(number)
self.assertEqual(base36.b36encode(raw_bytes), encoded)
self.assertEqual(base36.b36decode(encoded), raw_bytes)
def test_wikipedia_decoding(self):
decoding_table = [
(b("1"), 1),
(b("10"), 36),
(b("100"), 1296),
(b("1000"), 46656),
(b("10000"), 1679616),
(b("100000"), 60466176),
(b("1000000"), 2176782336),
(b("10000000"), 78364164096),
(b("100000000"), 2821109907456),
]
for encoded, number in decoding_table:
raw_bytes = integer.uint_to_bytes(number)
self.assertEqual(base36.b36encode(raw_bytes), encoded)
self.assertEqual(base36.b36decode(encoded), raw_bytes)
def test_wikipedia_encoding(self):
encoding_table = [
(1, b("1")),
(10, b("A")),
(100, b("2S")),
(1000, b("RS")),
(10000, b("7PS")),
(100000, b("255S")),
(1000000, b("LFLS")),
(1000000000, b("GJDGXS")),
(1000000000000, b("CRE66I9S")),
]
for number, encoded in encoding_table:
raw_bytes = integer.uint_to_bytes(number)
self.assertEqual(base36.b36encode(raw_bytes), encoded)
self.assertEqual(base36.b36decode(encoded), raw_bytes)
def decimal_decode(encoded):
"""
Decodes decimal-encoded bytes to raw bytes. Leading zeros are converted to
leading zero bytes.
:param encoded:
Decimal-encoded representation.
:returns:
Raw bytes.
"""
padding = ZERO_BYTE * builtins.bytes_leading(encoded, DIGIT_ZERO_BYTE)
int_val = int(encoded)
if int_val:
decoded = padding + integer.uint_to_bytes(int_val)
else:
decoded = padding
return decoded
def decimal_decode(encoded):
"""
Decodes decimal-encoded bytes to raw bytes. Leading zeros are converted to
leading zero bytes.
:param encoded:
Decimal-encoded representation.
:returns:
Raw bytes.
"""
padding = ZERO_BYTE * bytes_leading(encoded, DIGIT_ZERO_BYTE)
int_val = int(encoded)
if int_val:
decoded = padding + uint_to_bytes(int_val)
else:
decoded = padding
return decoded
def pkcs1_v1_5_encode(key_size, data):
"""
Encodes a key using PKCS1's emsa-pkcs1-v1_5 encoding.
:author:
Rick Copeland <*****@*****.**>
:param key_size:
RSA key size.
:param data:
Data
:returns:
A blob of data as large as the key's N, using PKCS1's
"emsa-pkcs1-v1_5" encoding.
"""
size = len(integer.uint_to_bytes(key_size))
filler = FF_BYTE * (size - SHA1_DIGESTINFO_LEN - len(data) - 3)
return ZERO_ONE_BYTES + filler + ZERO_BYTE + SHA1_DIGESTINFO + data
def pkcs1_v1_5_encode(key_size, data):
"""
Encodes a key using PKCS1's emsa-pkcs1-v1_5 encoding.
:author:
Rick Copeland <*****@*****.**>
:param key_size:
RSA key size.
:param data:
Data
:returns:
A blob of data as large as the key's N, using PKCS1's
"emsa-pkcs1-v1_5" encoding.
"""
size = len(integer.uint_to_bytes(key_size))
filler = FF_BYTE * (size - SHA1_DIGESTINFO_LEN - len(data) - 3)
return ZERO_ONE_BYTES + filler + ZERO_BYTE + SHA1_DIGESTINFO + data
def test_zero(self):
self.assertEqual(integer.uint_to_bytes(0), b("\x00"))
self.assertEqual(integer.uint_to_bytes(0, 4), b("\x00") * 4)
self.assertEqual(integer.uint_to_bytes(0, 7), b("\x00") * 7)
self.assertEqual(integer.uint_to_bytes(0, chunk_size=1), b("\x00"))
self.assertEqual(integer.uint_to_bytes(0, chunk_size=4), b("\x00") * 4)
self.assertEqual(integer.uint_to_bytes(0, chunk_size=7), b("\x00") * 7)
self.assertEqual(_alt_integer.uint_to_bytes_naive(0), b("\x00"))
self.assertEqual(_alt_integer.uint_to_bytes_naive(0, 4), b("\x00") * 4)
self.assertEqual(_alt_integer.uint_to_bytes_naive(0, 7), b("\x00") * 7)
self.assertEqual(_alt_integer.uint_to_bytes_simple(0), b("\x00"))
def test_zero(self):
self.assertEqual(uint_to_bytes(0), b('\x00'))
self.assertEqual(uint_to_bytes(0, 4), b('\x00') * 4)
self.assertEqual(uint_to_bytes(0, 7), b('\x00') * 7)
self.assertEqual(uint_to_bytes(0, chunk_size=1), b('\x00'))
self.assertEqual(uint_to_bytes(0, chunk_size=4), b('\x00') * 4)
self.assertEqual(uint_to_bytes(0, chunk_size=7), b('\x00') * 7)
self.assertEqual(uint_to_bytes_naive(0), b('\x00'))
self.assertEqual(uint_to_bytes_naive(0, 4), b('\x00') * 4)
self.assertEqual(uint_to_bytes_naive(0, 7), b('\x00') * 7)
self.assertEqual(uint_to_bytes_simple(0), b('\x00'))
def test_encoding_and_decoding(self):
hello_world = b('\x48\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64')
encoded_hello_world = b58encode(hello_world)
self.assertEqual(encoded_hello_world, b58encode_naive(hello_world))
self.assertEqual(b58decode(encoded_hello_world), hello_world)
self.assertEqual(bytes_to_uint(b58decode(b("16Ho7Hs"))), 3471844090)
self.assertEqual(b58encode(uint_to_bytes(3471844090, 5)), b("16Ho7Hs"))
self.assertEqual(b58encode(raw_data), encoded)
self.assertEqual(b58decode(encoded), raw_data)
self.assertEqual(b58decode(encoded_with_whitespace), raw_data)
self.assertEqual(b58decode_naive(encoded), raw_data)
self.assertEqual(b58decode_naive(encoded_with_whitespace), raw_data)
self.assertEqual(base58_encode(raw_data), encoded)
self.assertEqual(base58_decode(encoded), raw_data)
self.assertEqual(base58_decode(encoded_with_whitespace), raw_data)
def test_encoding_and_decoding(self):
hello_world = b("\x48\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64")
encoded_hello_world = base58.b58encode(hello_world)
self.assertEqual(encoded_hello_world, _alt_base.b58encode_naive(hello_world))
self.assertEqual(base58.b58decode(encoded_hello_world), hello_world)
self.assertEqual(integer.bytes_to_uint(base58.b58decode(b("16Ho7Hs"))), 3471844090)
self.assertEqual(base58.b58encode(integer.uint_to_bytes(3471844090, 5)), b("16Ho7Hs"))
self.assertEqual(base58.b58encode(RAW_DATA), ENCODED)
self.assertEqual(base58.b58decode(ENCODED), RAW_DATA)
self.assertEqual(base58.b58decode(ENCODED_WITH_WHITESPACE), RAW_DATA)
self.assertEqual(_alt_base.b58decode_naive(ENCODED), RAW_DATA)
self.assertEqual(_alt_base.b58decode_naive(ENCODED_WITH_WHITESPACE), RAW_DATA)
self.assertEqual(codec.base58_encode(RAW_DATA), ENCODED)
self.assertEqual(codec.base58_decode(ENCODED), RAW_DATA)
self.assertEqual(codec.base58_decode(ENCODED_WITH_WHITESPACE), RAW_DATA)
def test_chunk_size(self):
self.assertEqual(uint_to_bytes(0xffffeeeeaa, chunk_size=4),
b('\x00\x00\x00\xff\xff\xee\xee\xaa'))
def test_long_value(self):
self.assertEqual(integer.uint_to_bytes(LONG_VALUE),
EXPECTED_BYTES)
self.assertEqual(integer.uint_to_bytes(LONG_VALUE, fill_size=45),
EXPECTED_FILL_BYTES)
def test_chunk_size(self):
self.assertEqual(integer.uint_to_bytes(0xffffeeeeaa, chunk_size=4),
b("\x00\x00\x00\xff\xff\xee\xee\xaa"))
def test_correctness_for_primes(self):
for prime in prime_sieve.SIEVE:
self.assertEqual(integer.uint_to_bytes(prime),
_alt_integer.uint_to_bytes_naive(prime),
"Boom %d" % prime)
