Examples/test-suite/python/python_overload_simple_cast_runme.py

from python_overload_simple_cast import *

import sys

# For handling in these 2 versions of Python:
# DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
if sys.version_info[0:2] == (3, 8) or sys.version_info[0:2] == (3, 9):
    import warnings
    warnings.filterwarnings("ignore", category=DeprecationWarning)

class Ai:

    def __init__(self, x):
        self.x = x

    def __int__(self):
        return self.x

    def __index__(self):
        return self.x

class Ad:

    def __init__(self, x):
        self.x = x

    def __float__(self):
        return self.x

ai = Ai(4)

ad = Ad(5.0)
add = Ad(5.5)

try:
    fint(add)
    good = 0
except TypeError:
    good = 1

if not good:
    raise RuntimeError("fint(int)")


if fint(ad) != "fint:int":
    raise RuntimeError("fint(int)")

if fdouble(ad) != "fdouble:double":
    raise RuntimeError("fdouble(double)")

if fint(ai) != "fint:int":
    raise RuntimeError("fint(int)")

if fint(5.0) != "fint:int":
    raise RuntimeError("fint(int)")

if fint(3) != "fint:int":
    raise RuntimeError("fint(int)")
if fint(3.0) != "fint:int":
    raise RuntimeError("fint(int)")

if fdouble(ad) != "fdouble:double":
    raise RuntimeError("fdouble(double)")
if fdouble(3) != "fdouble:double":
    raise RuntimeError("fdouble(double)")
if fdouble(3.0) != "fdouble:double":
    raise RuntimeError("fdouble(double)")

if fid(3, 3.0) != "fid:intdouble":
    raise RuntimeError("fid:intdouble")

if fid(3.0, 3) != "fid:doubleint":
    raise RuntimeError("fid:doubleint")

if fid(ad, ai) != "fid:doubleint":
    raise RuntimeError("fid:doubleint")

if fid(ai, ad) != "fid:intdouble":
    raise RuntimeError("fid:intdouble")


if foo(3) != "foo:int":
    raise RuntimeError("foo(int)")

if foo(3.0) != "foo:double":
    raise RuntimeError("foo(double)")

if foo("hello") != "foo:char *":
    raise RuntimeError("foo(char *)")

f = Foo()
b = Bar()

if foo(f) != "foo:Foo *":
    raise RuntimeError("foo(Foo *)")

if foo(b) != "foo:Bar *":
    raise RuntimeError("foo(Bar *)")

v = malloc_void(32)

if foo(v) != "foo:void *":
    raise RuntimeError("foo(void *)")

s = Spam()

if s.foo(3) != "foo:int":
    raise RuntimeError("Spam::foo(int)")

if s.foo(3.0) != "foo:double":
    raise RuntimeError("Spam::foo(double)")

if s.foo("hello") != "foo:char *":
    raise RuntimeError("Spam::foo(char *)")

if s.foo(f) != "foo:Foo *":
    raise RuntimeError("Spam::foo(Foo *)")

if s.foo(b) != "foo:Bar *":
    raise RuntimeError("Spam::foo(Bar *)")

if s.foo(v) != "foo:void *":
    raise RuntimeError("Spam::foo(void *)")

if Spam.bar(3) != "bar:int":
    raise RuntimeError("Spam::bar(int)")

if Spam.bar(3.0) != "bar:double":
    raise RuntimeError("Spam::bar(double)")

if Spam.bar("hello") != "bar:char *":
    raise RuntimeError("Spam::bar(char *)")

if Spam.bar(f) != "bar:Foo *":
    raise RuntimeError("Spam::bar(Foo *)")

if Spam.bar(b) != "bar:Bar *":
    raise RuntimeError("Spam::bar(Bar *)")

if Spam.bar(v) != "bar:void *":
    raise RuntimeError("Spam::bar(void *)")

# Test constructors

s = Spam()
if s.type != "none":
    raise RuntimeError("Spam()")

s = Spam(3)
if s.type != "int":
    raise RuntimeError("Spam(int)")

s = Spam(3.4)
if s.type != "double":
    raise RuntimeError("Spam(double)")

s = Spam("hello")
if s.type != "char *":
    raise RuntimeError("Spam(char *)")

s = Spam(f)
if s.type != "Foo *":
    raise RuntimeError("Spam(Foo *)")

s = Spam(b)
if s.type != "Bar *":
    raise RuntimeError("Spam(Bar *)")

s = Spam(v)
if s.type != "void *":
    raise RuntimeError("Spam(void *)")


# nextafter: ++ and -- operators for float, off by one LSB
# nextafter was released in Python 3.9
if sys.version_info[0:2] >= (3, 9):
    from math import inf, nextafter
else:
    # workaround: try to load nextafter from numpy if available
    try:
        # Skip numpy workaround for consistency in testing
        if True:
            raise RuntimeError("skip test")
        from numpy import nextafter
    except:
        # else just disable this tests
        def nextafter(x, y):
            return None

    # math.inf was added in Python 3.5
    inf = float('inf')

def exceptMatch(fun, arg, res, msg):
    if arg is None or res is None:
        # nextafter is missing, so skipping this test
        return
    if fun(arg) != res:
        raise RuntimeError(msg)

def exceptTypeError(fun, arg, msg):
    if arg is None:
        # nextafter is missing, so skipping this test
        return
    try:
        fun(arg)
        raise RuntimeError(msg)
    except TypeError:
        pass

# x86_64: long is 32bit on MSVC but 64bit on *nix
if not(sizeof_long() in [4, 8]):
    raise RuntimeError("Unexpected size for long")

# unsigned long
ulmax = 2**32 - 1
ulmin = 0
ulmaxd = float(2**32 - 1)
ulmind = 0.0
if sizeof_long() == 8:
    ulmax = 2**64 - 1
    ulmaxd = nextafter(float(2**64), 0.0)

exceptMatch(as_ul, ulmin, ulmin, "as_ul(ulmin)")
exceptMatch(as_ul, ulmax, ulmax, "as_ul(ulmax)")
exceptMatch(as_ul, ulmind, ulmind, "as_ul(ulmind)")
exceptMatch(as_ul, ulmaxd, ulmaxd, "as_ul(ulmaxd)")

exceptTypeError(as_ul, ulmin - 1, "as_ul(ulmin - 1)")
exceptTypeError(as_ul, ulmax + 1, "as_ul(ulmax + 1)")
exceptTypeError(as_ul, nextafter(ulmind, -inf), "as_ul(ulmind - LSB)")
exceptTypeError(as_ul, nextafter(ulmaxd, inf), "as_ul(ulmaxd + LSB)")

# long
lmax = 2**31 - 1
lmin = -2**31
lmaxd = float(2**31 - 1)
lmind = float(-2**31)
lmaxd_v = lmaxd # expected value after the cast
lmind_v = lmind
if sys.version_info[0:2] < (3, 10):
    # PyLong_AsLong(float) truncated the input before 3.10
    lmaxd = nextafter(float(2**31), 0.0)
    lmind = nextafter(float(-2**31 - 1), 0.0)
    lmaxd_v = float(2**31 - 1)
    lmind_v = float(-2**31)
if sizeof_long() == 8:
    lmax = 2**63 - 1
    lmin = -2**63
    lmaxd = nextafter(float(2**63), 0.0)
    lmind = float(-2**63)
    lmaxd_v = lmaxd
    lmind_v = lmind

exceptMatch(as_l, lmin, lmin, "as_l(lmin)")
exceptMatch(as_l, lmax, lmax, "as_l(lmax)")
exceptMatch(as_l, lmind, lmind_v, "as_l(lmind)")
exceptMatch(as_l, lmaxd, lmaxd_v, "as_l(lmaxd)")

exceptTypeError(as_l, lmin - 1, "as_l(lmin - 1)")
exceptTypeError(as_l, lmax + 1, "as_l(lmax + 1)")
exceptTypeError(as_l, nextafter(lmind, -inf), "as_l(lmind - LSB)")
exceptTypeError(as_l, nextafter(lmaxd, inf), "as_l(lmaxd + LSB)")

# unsigned long long
ullmax = 2**64 - 1
ullmin = 0
ullmaxd = float(2**53) # 64 bit double significand
ullmind = 0.0
if sizeof_long() == 8:
    ullmaxd = nextafter(float(2**64), 0.0)

exceptMatch(as_ull, ullmin, ullmin, "as_ull(ullmin)")
exceptMatch(as_ull, ullmax, ullmax, "as_ull(ullmax)")
exceptMatch(as_ull, ullmind, ullmind, "as_ull(ullmind)")
exceptMatch(as_ull, ullmaxd, ullmaxd, "as_ull(ullmaxd)")

exceptTypeError(as_ull, ullmin - 1, "as_ull(ullmin - 1)")
exceptTypeError(as_ull, ullmax + 1, "as_ull(ullmax + 1)")
exceptTypeError(as_ull, nextafter(ullmind, -inf), "as_ull(ullmind - LSB)")
exceptTypeError(as_ull, nextafter(ullmaxd, inf), "as_ull(ullmaxd + LSB)")

# long long
llmax = 2**63 - 1
llmin = -2**63
llmaxd = float(2**53) # 64 bit double significand
llmind = float(-2**53)
if sizeof_long() == 8:
    llmaxd = nextafter(float(2**63), 0.0)
    llmind = float(-2**63)

exceptMatch(as_ll, llmin, llmin, "as_ll(llmin)")
exceptMatch(as_ll, llmax, llmax, "as_ll(llmax)")
exceptMatch(as_ll, llmind, llmind, "as_ll(llmind)")
exceptMatch(as_ll, llmaxd, llmaxd, "as_ll(llmaxd)")

exceptTypeError(as_ll, llmin - 1, "as_ll(llmin - 1)")
exceptTypeError(as_ll, llmax + 1, "as_ll(llmax + 1)")
exceptTypeError(as_ll, nextafter(llmind, -inf), "as_ll(llmind - LSB)")
exceptTypeError(as_ll, nextafter(llmaxd, inf), "as_ll(llmaxd + LSB)")


free_void(v)