205 lines
4.5 KiB
Python
205 lines
4.5 KiB
Python
#!/usr/bin/env python3
|
|
|
|
'''
|
|
generate base58 tests
|
|
|
|
really checking to see if my code matches the python base58 package which has
|
|
159 stars on github
|
|
'''
|
|
|
|
import base58 as b
|
|
import random as r
|
|
|
|
###########################
|
|
### simple cases (single bytes, two bytes, 10 bytes of same byte)
|
|
###########################
|
|
|
|
## 1 byte cases
|
|
|
|
def single_byte_case(byte):
|
|
'''
|
|
return the encode/decode pair corresponding to a single byte
|
|
'''
|
|
decoded_bytes = bytes([byte])
|
|
encoded_bytes = b.b58encode(decoded_bytes)
|
|
return {'db': decoded_bytes, 'eb': encoded_bytes}
|
|
|
|
|
|
def single_byte_cases():
|
|
'''
|
|
return the encode/decode pairs corresponding to every single byte case for
|
|
byte between 0 and 255
|
|
'''
|
|
# range(0, 256) = [0, 256) intersect Z
|
|
return [single_byte_case(n) for n in range(0, 256)]
|
|
|
|
## too many of these
|
|
|
|
### 2 byte cases
|
|
#
|
|
#def two_bytes(n):
|
|
# '''
|
|
# return the two bytes corresponding to <<n // 256, n % 256>>
|
|
# '''
|
|
# return bytes([n // 256, n % 256])
|
|
#
|
|
#
|
|
#def two_byte_case(n):
|
|
# '''
|
|
# return the encode/decode pair corresponding to <<n // 256, n % 256>>
|
|
# '''
|
|
# decoded_bytes = two_bytes(n)
|
|
# encoded_bytes = b.b58encode(decoded_bytes)
|
|
# return {'db': decoded_bytes, 'eb': encoded_bytes}
|
|
#
|
|
#
|
|
#def two_byte_cases():
|
|
# '''
|
|
# return the encode/decode pairs for each two bytes <<n:8, m:8>>
|
|
# '''
|
|
# return [two_byte_case(n) for n in range(0, 256*256)]
|
|
|
|
|
|
## 10 byte cases
|
|
|
|
def ten_bytes(byte):
|
|
'''
|
|
return the ten byte string which is byte repeated 10 times
|
|
'''
|
|
return bytes([byte for _ in range(10)])
|
|
|
|
|
|
def ten_byte_case(n):
|
|
'''
|
|
return the encode/decode pair corresponding to <<n>> * 10
|
|
'''
|
|
decoded_bytes = ten_bytes(n)
|
|
encoded_bytes = b.b58encode(decoded_bytes)
|
|
return {'db': decoded_bytes, 'eb': encoded_bytes}
|
|
|
|
|
|
def ten_byte_cases():
|
|
'''
|
|
return the encode/decode pairs for each string <<n:8>> * 10
|
|
'''
|
|
return [ten_byte_case(n) for n in range(0, 256)]
|
|
|
|
|
|
|
|
## all simple cases in one function
|
|
|
|
def simple_cases():
|
|
return single_byte_cases() + ten_byte_cases()
|
|
|
|
|
|
###########################
|
|
### case generation
|
|
###########################
|
|
|
|
def random_bytes():
|
|
'''
|
|
return between 0 and 999 random bytes
|
|
'''
|
|
# randint is between [left, right]
|
|
len = r.randint(0, 999)
|
|
#len = 10
|
|
acc = []
|
|
for _ in range(len):
|
|
# randint is between [left, right]
|
|
randbyte = r.randint(0, 255)
|
|
acc.append(randbyte)
|
|
return bytes(acc)
|
|
|
|
|
|
def case():
|
|
'''
|
|
return a random encode/decode pair
|
|
'''
|
|
decoded_bytes = random_bytes()
|
|
encoded_bytes = b.b58encode(decoded_bytes)
|
|
return {'db': decoded_bytes, 'eb': encoded_bytes}
|
|
|
|
|
|
def cases(n):
|
|
'''
|
|
return n randomly generated encode/decode pairs
|
|
'''
|
|
return [case() for _ in range(n)]
|
|
|
|
|
|
###########################
|
|
### js formatting
|
|
###########################
|
|
|
|
def format_decoded_js(decoded_bytes):
|
|
'''
|
|
format the bytes as a js Uint8Array
|
|
'''
|
|
return f'new Uint8Array({list(decoded_bytes)})'
|
|
|
|
def format_encoded_js(encoded_bytes):
|
|
s = str(encoded_bytes)[2:-1]
|
|
return '"' + s + '"'
|
|
|
|
def format_case_js(case):
|
|
decoded_bytes = case['db']
|
|
encoded_bytes = case['eb']
|
|
db_js = format_decoded_js(decoded_bytes)
|
|
eb_js = format_encoded_js(encoded_bytes)
|
|
return '{encoded: ' + eb_js + ',\n ' + 'decoded: ' + db_js + '},\n '
|
|
|
|
|
|
def format_cases_js(cases):
|
|
s = '['
|
|
for case in cases:
|
|
s += format_case_js(case)
|
|
# each case adds ",\n " so remove that
|
|
# >>> "12345678"[:-3]
|
|
# '12345'
|
|
s = s[:-3]
|
|
s += ']'
|
|
return s
|
|
|
|
|
|
###########################
|
|
### erlang formatting
|
|
###########################
|
|
|
|
def format_decoded_erl(decoded_bytes):
|
|
'''
|
|
format the bytes as a erl Uint8Array
|
|
'''
|
|
bytes_list = list(decoded_bytes)
|
|
byteslstr = f'{bytes_list}'
|
|
return '<<' + byteslstr[1:-1] + '>>'
|
|
|
|
def format_encoded_erl(encoded_bytes):
|
|
s = str(encoded_bytes)[2:-1]
|
|
return '"' + s + '"'
|
|
|
|
def format_case_erl(case):
|
|
decoded_bytes = case['db']
|
|
encoded_bytes = case['eb']
|
|
db_erl = format_decoded_erl(decoded_bytes)
|
|
eb_erl = format_encoded_erl(encoded_bytes)
|
|
return '{{encoded, ' + eb_erl + '},\n ' + '{decoded, ' + db_erl + '}}.\n'
|
|
|
|
def format_cases_erl(cases):
|
|
s = ''
|
|
for case in cases:
|
|
s += format_case_erl(case)
|
|
return s
|
|
|
|
|
|
###########################
|
|
### main
|
|
###########################
|
|
|
|
def main():
|
|
c = simple_cases() + cases(50)
|
|
print(format_cases_js(c))
|
|
#print(format_cases_erl(c))
|
|
|
|
if __name__ == '__main__':
|
|
main()
|