mirror of
https://github.com/odin-lang/Odin.git
synced 2026-02-22 10:56:41 +00:00
316 lines
8.4 KiB
Python
316 lines
8.4 KiB
Python
from math import *
|
|
from ctypes import *
|
|
from random import *
|
|
import os
|
|
import platform
|
|
import time
|
|
|
|
#
|
|
# Fast tests?
|
|
#
|
|
FAST_TESTS = True
|
|
|
|
#
|
|
# Where is the DLL? If missing, build using: `odin build . -build-mode:shared`
|
|
#
|
|
if platform.system() == "Windows":
|
|
LIB_PATH = os.getcwd() + os.sep + "big.dll"
|
|
elif platform.system() == "Linux":
|
|
LIB_PATH = os.getcwd() + os.sep + "big.so"
|
|
elif platform.system() == "Darwin":
|
|
LIB_PATH = os.getcwd() + os.sep + "big.dylib"
|
|
else:
|
|
print("Platform is unsupported.")
|
|
exit(1)
|
|
|
|
#
|
|
# How many iterations of each random test do we want to run?
|
|
#
|
|
BITS_AND_ITERATIONS = [
|
|
( 120, 10_000),
|
|
( 1_200, 1_000),
|
|
( 4_096, 100),
|
|
(12_000, 10),
|
|
]
|
|
|
|
#
|
|
# Fast tests?
|
|
#
|
|
if FAST_TESTS:
|
|
for k in range(len(BITS_AND_ITERATIONS)):
|
|
b, i = BITS_AND_ITERATIONS[k]
|
|
BITS_AND_ITERATIONS[k] = (b, i // 10 if i >= 100 else 5)
|
|
|
|
#
|
|
# Result values will be passed in a struct { res: cstring, err: Error }
|
|
#
|
|
class Res(Structure):
|
|
_fields_ = [("res", c_char_p), ("err", c_byte)]
|
|
|
|
#
|
|
# Error enum values
|
|
#
|
|
E_None = 0
|
|
E_Out_Of_Memory = 1
|
|
E_Invalid_Pointer = 2
|
|
E_Invalid_Argument = 3
|
|
E_Unknown_Error = 4
|
|
E_Max_Iterations_Reached = 5
|
|
E_Buffer_Overflow = 6
|
|
E_Integer_Overflow = 7
|
|
E_Division_by_Zero = 8
|
|
E_Math_Domain_Error = 9
|
|
E_Unimplemented = 127
|
|
|
|
#
|
|
# Set up exported procedures
|
|
#
|
|
|
|
try:
|
|
l = cdll.LoadLibrary(LIB_PATH)
|
|
except:
|
|
print("Couldn't find or load " + LIB_PATH + ".")
|
|
exit(1)
|
|
|
|
def load(export_name, args, res):
|
|
export_name.argtypes = args
|
|
export_name.restype = res
|
|
return export_name
|
|
|
|
error_string = load(l.test_error_string, [c_byte], c_char_p)
|
|
|
|
#
|
|
# res = a + b, err
|
|
#
|
|
add_two = load(l.test_add_two, [c_char_p, c_char_p, c_longlong], Res)
|
|
|
|
#
|
|
# res = a - b, err
|
|
#
|
|
sub_two = load(l.test_sub_two, [c_char_p, c_char_p, c_longlong], Res)
|
|
|
|
#
|
|
# res = a * b, err
|
|
#
|
|
mul_two = load(l.test_mul_two, [c_char_p, c_char_p, c_longlong], Res)
|
|
|
|
#
|
|
# res = a / b, err
|
|
#
|
|
div_two = load(l.test_div_two, [c_char_p, c_char_p, c_longlong], Res)
|
|
|
|
|
|
#
|
|
# res = log(a, base)
|
|
#
|
|
int_log = load(l.test_log, [c_char_p, c_longlong, c_longlong], Res)
|
|
|
|
|
|
def test(test_name: "", res: Res, param=[], expected_error = E_None, expected_result = ""):
|
|
passed = True
|
|
r = None
|
|
|
|
if res.err != expected_error:
|
|
error_type = error_string(res.err).decode('utf-8')
|
|
error_loc = res.res.decode('utf-8')
|
|
|
|
error = "{}: '{}' error in '{}'".format(test_name, error_type, error_loc)
|
|
if len(param):
|
|
error += " with params {}".format(param)
|
|
|
|
print(error, flush=True)
|
|
passed = False
|
|
elif res.err == E_None:
|
|
try:
|
|
r = res.res.decode('utf-8')
|
|
except:
|
|
pass
|
|
|
|
r = eval(res.res)
|
|
if r != expected_result:
|
|
error = "{}: Result was '{}', expected '{}'".format(test_name, r, expected_result)
|
|
if len(param):
|
|
error += " with params {}".format(param)
|
|
|
|
print(error, flush=True)
|
|
passed = False
|
|
|
|
return passed
|
|
|
|
|
|
def test_add_two(a = 0, b = 0, radix = 10, expected_error = E_None, expected_result = None):
|
|
args = [str(a), str(b), radix]
|
|
sa_c, sb_c = args[0].encode('utf-8'), args[1].encode('utf-8')
|
|
res = add_two(sa_c, sb_c, radix)
|
|
if expected_result == None:
|
|
expected_result = a + b
|
|
return test("test_add_two", res, args, expected_error, expected_result)
|
|
|
|
def test_sub_two(a = 0, b = 0, radix = 10, expected_error = E_None, expected_result = None):
|
|
sa, sb = str(a), str(b)
|
|
sa_c, sb_c = sa.encode('utf-8'), sb.encode('utf-8')
|
|
res = sub_two(sa_c, sb_c, radix)
|
|
if expected_result == None:
|
|
expected_result = a - b
|
|
return test("test_sub_two", res, [sa_c, sb_c, radix], expected_error, expected_result)
|
|
|
|
def test_mul_two(a = 0, b = 0, radix = 10, expected_error = E_None, expected_result = None):
|
|
sa, sb = str(a), str(b)
|
|
sa_c, sb_c = sa.encode('utf-8'), sb.encode('utf-8')
|
|
res = mul_two(sa_c, sb_c, radix)
|
|
if expected_result == None:
|
|
expected_result = a * b
|
|
return test("test_mul_two", res, [sa_c, sb_c, radix], expected_error, expected_result)
|
|
|
|
def test_div_two(a = 0, b = 0, radix = 10, expected_error = E_None, expected_result = None):
|
|
sa, sb = str(a), str(b)
|
|
sa_c, sb_c = sa.encode('utf-8'), sb.encode('utf-8')
|
|
try:
|
|
res = div_two(sa_c, sb_c, radix)
|
|
except:
|
|
print("Exception with arguments:", a, b, radix)
|
|
return False
|
|
if expected_result == None:
|
|
#
|
|
# We don't round the division results, so if one component is negative, we're off by one.
|
|
#
|
|
if a < 0 and b > 0:
|
|
expected_result = int(-(abs(a) / b))
|
|
elif b < 0 and a > 0:
|
|
expected_result = int(-(a / abs((b))))
|
|
else:
|
|
expected_result = a // b if b != 0 else None
|
|
return test("test_div_two", res, [sa_c, sb_c, radix], expected_error, expected_result)
|
|
|
|
|
|
def test_log(a = 0, base = 0, radix = 10, expected_error = E_None, expected_result = None):
|
|
args = [str(a), base, radix]
|
|
sa_c = args[0].encode('utf-8')
|
|
res = int_log(sa_c, base, radix)
|
|
|
|
if expected_result == None:
|
|
expected_result = int(log(a, base))
|
|
return test("test_log", res, args, expected_error, expected_result)
|
|
|
|
|
|
# TODO(Jeroen): Make sure tests cover edge cases, fast paths, and so on.
|
|
#
|
|
# The last two arguments in tests are the expected error and expected result.
|
|
#
|
|
# The expected error defaults to None.
|
|
# By default the Odin implementation will be tested against the Python one.
|
|
# You can override that by supplying an expected result as the last argument instead.
|
|
|
|
TESTS = {
|
|
test_add_two: [
|
|
[ 1234, 5432, 10, ],
|
|
[ 1234, 5432, 110, E_Invalid_Argument, ],
|
|
],
|
|
test_sub_two: [
|
|
[ 1234, 5432, 10, ],
|
|
],
|
|
test_mul_two: [
|
|
[ 1234, 5432, 10, ],
|
|
[ 1099243943008198766717263669950239669, 137638828577110581150675834234248871, 10, ]
|
|
],
|
|
test_div_two: [
|
|
[ 54321, 12345, 10, ],
|
|
[ 55431, 0, 10, E_Division_by_Zero, ],
|
|
],
|
|
test_log: [
|
|
[ 3192, 1, 10, E_Invalid_Argument, ":log:log(a, base):"],
|
|
[ -1234, 2, 10, E_Math_Domain_Error, ":log:log(a, base):"],
|
|
[ 0, 2, 10, E_Math_Domain_Error, ":log:log(a, base):"],
|
|
[ 1024, 2, 10, ],
|
|
],
|
|
}
|
|
|
|
TOTAL_TIME = 0
|
|
total_passes = 0
|
|
total_failures = 0
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
|
test_log(1234, 2, 10)
|
|
|
|
print("---- core:math/big tests ----")
|
|
print()
|
|
|
|
for test_proc in TESTS:
|
|
count_pass = 0
|
|
count_fail = 0
|
|
TIMINGS = {}
|
|
for t in TESTS[test_proc]:
|
|
start = time.perf_counter()
|
|
res = test_proc(*t)
|
|
diff = time.perf_counter() - start
|
|
TOTAL_TIME += diff
|
|
|
|
if test_proc not in TIMINGS:
|
|
TIMINGS[test_proc] = diff
|
|
else:
|
|
TIMINGS[test_proc] += diff
|
|
|
|
if res:
|
|
count_pass += 1
|
|
total_passes += 1
|
|
else:
|
|
count_fail += 1
|
|
total_failures += 1
|
|
|
|
print("{name}: {count_pass:,} passes and {count_fail:,} failures in {timing:.3f} ms.".format(name=test_proc.__name__, count_pass=count_pass, count_fail=count_fail, timing=TIMINGS[test_proc] * 1_000))
|
|
|
|
for BITS, ITERATIONS in BITS_AND_ITERATIONS:
|
|
print()
|
|
print("---- core:math/big with two random {bits:,} bit numbers ----".format(bits=BITS))
|
|
print()
|
|
|
|
for test_proc in [test_add_two, test_sub_two, test_mul_two, test_div_two, test_log]:
|
|
count_pass = 0
|
|
count_fail = 0
|
|
TIMINGS = {}
|
|
|
|
for i in range(ITERATIONS):
|
|
a = randint(-(1 << BITS), 1 << BITS)
|
|
b = randint(-(1 << BITS), 1 << BITS)
|
|
|
|
if test_proc == test_div_two:
|
|
# We've already tested division by zero above.
|
|
if b == 0:
|
|
b == 42
|
|
elif test_proc == test_log:
|
|
# We've already tested log's domain errors.
|
|
a = randint(1, 1 << BITS)
|
|
b = randint(2, 1 << 60)
|
|
else:
|
|
b = randint(0, 1 << BITS)
|
|
|
|
res = None
|
|
|
|
start = time.perf_counter()
|
|
res = test_proc(a, b)
|
|
diff = time.perf_counter() - start
|
|
TOTAL_TIME += diff
|
|
|
|
if test_proc not in TIMINGS:
|
|
TIMINGS[test_proc] = diff
|
|
else:
|
|
TIMINGS[test_proc] += diff
|
|
|
|
if res:
|
|
count_pass += 1
|
|
total_passes += 1
|
|
else:
|
|
count_fail += 1
|
|
total_failures += 1
|
|
|
|
print("{name}: {count_pass:,} passes and {count_fail:,} failures in {timing:.3f} ms.".format(name=test_proc.__name__, count_pass=count_pass, count_fail=count_fail, timing=TIMINGS[test_proc] * 1_000))
|
|
|
|
print()
|
|
print("---- THE END ----")
|
|
print()
|
|
print("total: {count_pass:,} passes and {count_fail:,} failures in {timing:.3f} ms.".format(count_pass=total_passes, count_fail=total_failures, timing=TOTAL_TIME * 1_000))
|
|
|
|
if total_failures:
|
|
exit(1) |