diff options
Diffstat (limited to 'c/test_c.py')
| -rw-r--r-- | c/test_c.py | 4256 |
1 files changed, 4256 insertions, 0 deletions
diff --git a/c/test_c.py b/c/test_c.py new file mode 100644 index 0000000..da5f751 --- /dev/null +++ b/c/test_c.py @@ -0,0 +1,4256 @@ +import py +def _setup_path(): + import os, sys + if '__pypy__' in sys.builtin_module_names: + py.test.skip("_cffi_backend.c: not tested on top of pypy, " + "use pypy/module/_cffi_backend/test/ instead.") + sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..')) +_setup_path() +from _cffi_backend import * +from _cffi_backend import _testfunc, _get_types, _get_common_types, __version__ + +# ____________________________________________________________ + +import sys +assert __version__ == "1.12.2", ("This test_c.py file is for testing a version" + " of cffi that differs from the one that we" + " get from 'import _cffi_backend'") +if sys.version_info < (3,): + type_or_class = "type" + mandatory_b_prefix = '' + mandatory_u_prefix = 'u' + bytechr = chr + bitem2bchr = lambda x: x + class U(object): + def __add__(self, other): + return eval('u'+repr(other).replace(r'\\u', r'\u') + .replace(r'\\U', r'\U')) + u = U() + str2bytes = str + strict_compare = False +else: + type_or_class = "class" + long = int + unicode = str + unichr = chr + mandatory_b_prefix = 'b' + mandatory_u_prefix = '' + bytechr = lambda n: bytes([n]) + bitem2bchr = bytechr + u = "" + str2bytes = lambda s: bytes(s, "ascii") + strict_compare = True + +def size_of_int(): + BInt = new_primitive_type("int") + return sizeof(BInt) + +def size_of_long(): + BLong = new_primitive_type("long") + return sizeof(BLong) + +def size_of_ptr(): + BInt = new_primitive_type("int") + BPtr = new_pointer_type(BInt) + return sizeof(BPtr) + + +def find_and_load_library(name, flags=RTLD_NOW): + import ctypes.util + if name is None: + path = None + else: + path = ctypes.util.find_library(name) + if path is None and name == 'c': + assert sys.platform == 'win32' + assert sys.version_info >= (3,) + py.test.skip("dlopen(None) cannot work on Windows with Python 3") + return load_library(path, flags) + +def test_load_library(): + x = find_and_load_library('c') + assert repr(x).startswith("<clibrary '") + x = find_and_load_library('c', RTLD_NOW | RTLD_GLOBAL) + assert repr(x).startswith("<clibrary '") + x = find_and_load_library('c', RTLD_LAZY) + assert repr(x).startswith("<clibrary '") + +def test_all_rtld_symbols(): + import sys + FFI_DEFAULT_ABI # these symbols must be defined + FFI_CDECL + RTLD_LAZY + RTLD_NOW + RTLD_GLOBAL + RTLD_LOCAL + if sys.platform.startswith("linux"): + RTLD_NODELETE + RTLD_NOLOAD + RTLD_DEEPBIND + +def test_new_primitive_type(): + py.test.raises(KeyError, new_primitive_type, "foo") + p = new_primitive_type("signed char") + assert repr(p) == "<ctype 'signed char'>" + +def check_dir(p, expected): + got = [name for name in dir(p) if not name.startswith('_')] + assert got == sorted(expected) + +def test_inspect_primitive_type(): + p = new_primitive_type("signed char") + assert p.kind == "primitive" + assert p.cname == "signed char" + check_dir(p, ['cname', 'kind']) + +def test_cast_to_signed_char(): + p = new_primitive_type("signed char") + x = cast(p, -65 + 17*256) + assert repr(x) == "<cdata 'signed char' -65>" + assert repr(type(x)) == "<%s '_cffi_backend.CData'>" % type_or_class + assert int(x) == -65 + x = cast(p, -66 + (1<<199)*256) + assert repr(x) == "<cdata 'signed char' -66>" + assert int(x) == -66 + assert (x == cast(p, -66)) is True + assert (x != cast(p, -66)) is False + q = new_primitive_type("short") + assert (x == cast(q, -66)) is True + assert (x != cast(q, -66)) is False + +def test_sizeof_type(): + py.test.raises(TypeError, sizeof, 42.5) + p = new_primitive_type("short") + assert sizeof(p) == 2 + +def test_integer_types(): + for name in ['signed char', 'short', 'int', 'long', 'long long']: + p = new_primitive_type(name) + size = sizeof(p) + min = -(1 << (8*size-1)) + max = (1 << (8*size-1)) - 1 + assert int(cast(p, min)) == min + assert int(cast(p, max)) == max + assert int(cast(p, min - 1)) == max + assert int(cast(p, max + 1)) == min + py.test.raises(TypeError, cast, p, None) + assert long(cast(p, min - 1)) == max + assert int(cast(p, b'\x08')) == 8 + assert int(cast(p, u+'\x08')) == 8 + for name in ['char', 'short', 'int', 'long', 'long long']: + p = new_primitive_type('unsigned ' + name) + size = sizeof(p) + max = (1 << (8*size)) - 1 + assert int(cast(p, 0)) == 0 + assert int(cast(p, max)) == max + assert int(cast(p, -1)) == max + assert int(cast(p, max + 1)) == 0 + assert long(cast(p, -1)) == max + assert int(cast(p, b'\xFE')) == 254 + assert int(cast(p, u+'\xFE')) == 254 + +def test_no_float_on_int_types(): + p = new_primitive_type('long') + py.test.raises(TypeError, float, cast(p, 42)) + py.test.raises(TypeError, complex, cast(p, 42)) + +def test_float_types(): + INF = 1E200 * 1E200 + for name in ["float", "double"]: + p = new_primitive_type(name) + assert bool(cast(p, 0)) is False # since 1.7 + assert bool(cast(p, -0.0)) is False # since 1.7 + assert bool(cast(p, 1e-42)) is True + assert bool(cast(p, -1e-42)) is True + assert bool(cast(p, INF)) + assert bool(cast(p, -INF)) + assert bool(cast(p, float("nan"))) + assert int(cast(p, -150)) == -150 + assert int(cast(p, 61.91)) == 61 + assert long(cast(p, 61.91)) == 61 + assert type(int(cast(p, 61.91))) is int + assert type(int(cast(p, 1E22))) is long + assert type(long(cast(p, 61.91))) is long + assert type(long(cast(p, 1E22))) is long + py.test.raises(OverflowError, int, cast(p, INF)) + py.test.raises(OverflowError, int, cast(p, -INF)) + assert float(cast(p, 1.25)) == 1.25 + assert float(cast(p, INF)) == INF + assert float(cast(p, -INF)) == -INF + if name == "float": + assert float(cast(p, 1.1)) != 1.1 # rounding error + assert float(cast(p, 1E200)) == INF # limited range + + assert cast(p, -1.1) == cast(p, -1.1) + assert repr(float(cast(p, -0.0))) == '-0.0' + assert float(cast(p, b'\x09')) == 9.0 + assert float(cast(p, u+'\x09')) == 9.0 + assert float(cast(p, True)) == 1.0 + py.test.raises(TypeError, cast, p, None) + +def test_complex_types(): + INF = 1E200 * 1E200 + for name in ["float", "double"]: + p = new_primitive_type(name + " _Complex") + assert bool(cast(p, 0)) is False + assert bool(cast(p, INF)) + assert bool(cast(p, -INF)) + assert bool(cast(p, 0j)) is False + assert bool(cast(p, INF*1j)) + assert bool(cast(p, -INF*1j)) + # "can't convert complex to float", like CPython's "float(0j)" + py.test.raises(TypeError, int, cast(p, -150)) + py.test.raises(TypeError, long, cast(p, -150)) + py.test.raises(TypeError, float, cast(p, -150)) + assert complex(cast(p, 1.25)) == 1.25 + assert complex(cast(p, 1.25j)) == 1.25j + assert complex(cast(p, complex(0,INF))) == complex(0,INF) + assert complex(cast(p, -INF)) == -INF + if name == "float": + assert complex(cast(p, 1.1j)) != 1.1j # rounding error + assert complex(cast(p, 1E200+3j)) == INF+3j # limited range + assert complex(cast(p, complex(3,1E200))) == complex(3,INF) # limited range + + assert cast(p, -1.1j) == cast(p, -1.1j) + assert repr(complex(cast(p, -0.0)).real) == '-0.0' + #assert repr(complex(cast(p, -0j))) == '-0j' # http://bugs.python.org/issue29602 + assert complex(cast(p, b'\x09')) == 9.0 + 0j + assert complex(cast(p, u+'\x09')) == 9.0 + 0j + assert complex(cast(p, True)) == 1.0 + 0j + py.test.raises(TypeError, cast, p, None) + # + py.test.raises(TypeError, cast, new_primitive_type(name), 1+0j) + # + for basetype in ["char", "int", "uint64_t", "float", + "double", "long double"]: + baseobj = cast(new_primitive_type(basetype), 65) + py.test.raises(TypeError, complex, baseobj) + # + BArray = new_array_type(new_pointer_type(p), 10) + x = newp(BArray, None) + x[5] = 12.34 + 56.78j + assert type(x[5]) is complex + assert abs(x[5] - (12.34 + 56.78j)) < 1e-5 + assert (x[5] == 12.34 + 56.78j) == (name == "double") # rounding error + # + class Foo: + def __complex__(self): + return 2 + 3j + assert complex(Foo()) == 2 + 3j + assert complex(cast(p, Foo())) == 2 + 3j + py.test.raises(TypeError, cast, new_primitive_type("int"), 1+0j) + +def test_character_type(): + p = new_primitive_type("char") + assert bool(cast(p, 'A')) is True + assert bool(cast(p, '\x00')) is False # since 1.7 + assert cast(p, '\x00') == cast(p, -17*256) + assert int(cast(p, 'A')) == 65 + assert long(cast(p, 'A')) == 65 + assert type(int(cast(p, 'A'))) is int + assert type(long(cast(p, 'A'))) is long + assert str(cast(p, 'A')) == repr(cast(p, 'A')) + assert repr(cast(p, 'A')) == "<cdata 'char' %s'A'>" % mandatory_b_prefix + assert repr(cast(p, 255)) == r"<cdata 'char' %s'\xff'>" % mandatory_b_prefix + assert repr(cast(p, 0)) == r"<cdata 'char' %s'\x00'>" % mandatory_b_prefix + +def test_pointer_type(): + p = new_primitive_type("int") + assert repr(p) == "<ctype 'int'>" + p = new_pointer_type(p) + assert repr(p) == "<ctype 'int *'>" + p = new_pointer_type(p) + assert repr(p) == "<ctype 'int * *'>" + p = new_pointer_type(p) + assert repr(p) == "<ctype 'int * * *'>" + +def test_inspect_pointer_type(): + p1 = new_primitive_type("int") + p2 = new_pointer_type(p1) + assert p2.kind == "pointer" + assert p2.cname == "int *" + assert p2.item is p1 + check_dir(p2, ['cname', 'kind', 'item']) + p3 = new_pointer_type(p2) + assert p3.item is p2 + +def test_pointer_to_int(): + BInt = new_primitive_type("int") + py.test.raises(TypeError, newp, BInt) + py.test.raises(TypeError, newp, BInt, None) + BPtr = new_pointer_type(BInt) + p = newp(BPtr) + assert repr(p) == "<cdata 'int *' owning %d bytes>" % size_of_int() + p = newp(BPtr, None) + assert repr(p) == "<cdata 'int *' owning %d bytes>" % size_of_int() + p = newp(BPtr, 5000) + assert repr(p) == "<cdata 'int *' owning %d bytes>" % size_of_int() + q = cast(BPtr, p) + assert repr(q).startswith("<cdata 'int *' 0x") + assert p == q + assert hash(p) == hash(q) + e = py.test.raises(TypeError, newp, new_array_type(BPtr, None), None) + assert str(e.value) == ( + "expected new array length or list/tuple/str, not NoneType") + +def test_pointer_bool(): + BInt = new_primitive_type("int") + BPtr = new_pointer_type(BInt) + p = cast(BPtr, 0) + assert bool(p) is False + p = cast(BPtr, 42) + assert bool(p) is True + +def test_pointer_to_pointer(): + BInt = new_primitive_type("int") + BPtr = new_pointer_type(BInt) + BPtrPtr = new_pointer_type(BPtr) + p = newp(BPtrPtr, None) + assert repr(p) == "<cdata 'int * *' owning %d bytes>" % size_of_ptr() + +def test_reading_pointer_to_int(): + BInt = new_primitive_type("int") + BPtr = new_pointer_type(BInt) + p = newp(BPtr, None) + assert p[0] == 0 + p = newp(BPtr, 5000) + assert p[0] == 5000 + py.test.raises(IndexError, "p[1]") + py.test.raises(IndexError, "p[-1]") + +def test_reading_pointer_to_float(): + BFloat = new_primitive_type("float") + py.test.raises(TypeError, newp, BFloat, None) + BPtr = new_pointer_type(BFloat) + p = newp(BPtr, None) + assert p[0] == 0.0 and type(p[0]) is float + p = newp(BPtr, 1.25) + assert p[0] == 1.25 and type(p[0]) is float + p = newp(BPtr, 1.1) + assert p[0] != 1.1 and abs(p[0] - 1.1) < 1E-5 # rounding errors + +def test_cast_float_to_int(): + for type in ["int", "unsigned int", "long", "unsigned long", + "long long", "unsigned long long"]: + p = new_primitive_type(type) + assert int(cast(p, 4.2)) == 4 + py.test.raises(TypeError, newp, new_pointer_type(p), 4.2) + +def test_newp_integer_types(): + for name in ['signed char', 'short', 'int', 'long', 'long long']: + p = new_primitive_type(name) + pp = new_pointer_type(p) + size = sizeof(p) + min = -(1 << (8*size-1)) + max = (1 << (8*size-1)) - 1 + assert newp(pp, min)[0] == min + assert newp(pp, max)[0] == max + py.test.raises(OverflowError, newp, pp, min - 2 ** 32) + py.test.raises(OverflowError, newp, pp, min - 2 ** 64) + py.test.raises(OverflowError, newp, pp, max + 2 ** 32) + py.test.raises(OverflowError, newp, pp, max + 2 ** 64) + py.test.raises(OverflowError, newp, pp, min - 1) + py.test.raises(OverflowError, newp, pp, max + 1) + py.test.raises(OverflowError, newp, pp, min - 1 - 2 ** 32) + py.test.raises(OverflowError, newp, pp, min - 1 - 2 ** 64) + py.test.raises(OverflowError, newp, pp, max + 1) + py.test.raises(OverflowError, newp, pp, max + 1 + 2 ** 32) + py.test.raises(OverflowError, newp, pp, max + 1 + 2 ** 64) + py.test.raises(TypeError, newp, pp, 1.0) + for name in ['char', 'short', 'int', 'long', 'long long']: + p = new_primitive_type('unsigned ' + name) + pp = new_pointer_type(p) + size = sizeof(p) + max = (1 << (8*size)) - 1 + assert newp(pp, 0)[0] == 0 + assert newp(pp, max)[0] == max + py.test.raises(OverflowError, newp, pp, -1) + py.test.raises(OverflowError, newp, pp, max + 1) + +def test_reading_pointer_to_char(): + BChar = new_primitive_type("char") + py.test.raises(TypeError, newp, BChar, None) + BPtr = new_pointer_type(BChar) + p = newp(BPtr, None) + assert p[0] == b'\x00' + p = newp(BPtr, b'A') + assert p[0] == b'A' + py.test.raises(TypeError, newp, BPtr, 65) + py.test.raises(TypeError, newp, BPtr, b"foo") + py.test.raises(TypeError, newp, BPtr, u+"foo") + c = cast(BChar, b'A') + assert str(c) == repr(c) + assert int(c) == ord(b'A') + py.test.raises(TypeError, cast, BChar, b'foo') + py.test.raises(TypeError, cast, BChar, u+'foo') + e = py.test.raises(TypeError, newp, new_array_type(BPtr, None), 12.3) + assert str(e.value) == ( + "expected new array length or list/tuple/str, not float") + +def test_reading_pointer_to_pointer(): + BVoidP = new_pointer_type(new_void_type()) + BCharP = new_pointer_type(new_primitive_type("char")) + BInt = new_primitive_type("int") + BIntPtr = new_pointer_type(BInt) + BIntPtrPtr = new_pointer_type(BIntPtr) + q = newp(BIntPtr, 42) + assert q[0] == 42 + p = newp(BIntPtrPtr, None) + assert p[0] is not None + assert p[0] == cast(BVoidP, 0) + assert p[0] == cast(BCharP, 0) + assert p[0] != None + assert repr(p[0]) == "<cdata 'int *' NULL>" + p[0] = q + assert p[0] != cast(BVoidP, 0) + assert p[0] != cast(BCharP, 0) + assert p[0][0] == 42 + q[0] += 1 + assert p[0][0] == 43 + p = newp(BIntPtrPtr, q) + assert p[0][0] == 43 + +def test_load_standard_library(): + if sys.platform == "win32": + py.test.raises(OSError, find_and_load_library, None) + return + x = find_and_load_library(None) + BVoidP = new_pointer_type(new_void_type()) + assert x.load_function(BVoidP, 'strcpy') + py.test.raises(AttributeError, x.load_function, + BVoidP, 'xxx_this_function_does_not_exist') + # the next one is from 'libm', not 'libc', but we assume + # that it is already loaded too, so it should work + assert x.load_function(BVoidP, 'sqrt') + # + x.close_lib() + py.test.raises(ValueError, x.load_function, BVoidP, 'sqrt') + x.close_lib() + +def test_no_len_on_nonarray(): + p = new_primitive_type("int") + py.test.raises(TypeError, len, cast(p, 42)) + +def test_cmp_none(): + p = new_primitive_type("int") + x = cast(p, 42) + assert (x == None) is False + assert (x != None) is True + assert (x == ["hello"]) is False + assert (x != ["hello"]) is True + y = cast(p, 0) + assert (y == None) is False + +def test_invalid_indexing(): + p = new_primitive_type("int") + x = cast(p, 42) + py.test.raises(TypeError, "x[0]") + +def test_default_str(): + BChar = new_primitive_type("char") + x = cast(BChar, 42) + assert str(x) == repr(x) + BInt = new_primitive_type("int") + x = cast(BInt, 42) + assert str(x) == repr(x) + BArray = new_array_type(new_pointer_type(BInt), 10) + x = newp(BArray, None) + assert str(x) == repr(x) + +def test_default_unicode(): + BInt = new_primitive_type("int") + x = cast(BInt, 42) + assert unicode(x) == unicode(repr(x)) + BArray = new_array_type(new_pointer_type(BInt), 10) + x = newp(BArray, None) + assert unicode(x) == unicode(repr(x)) + +def test_cast_from_cdataint(): + BInt = new_primitive_type("int") + x = cast(BInt, 0) + y = cast(new_pointer_type(BInt), x) + assert bool(y) is False + # + x = cast(BInt, 42) + y = cast(BInt, x) + assert int(y) == 42 + y = cast(new_primitive_type("char"), x) + assert int(y) == 42 + y = cast(new_primitive_type("float"), x) + assert float(y) == 42.0 + # + z = cast(BInt, 42.5) + assert int(z) == 42 + z = cast(BInt, y) + assert int(z) == 42 + +def test_void_type(): + p = new_void_type() + assert p.kind == "void" + assert p.cname == "void" + check_dir(p, ['kind', 'cname']) + +def test_array_type(): + p = new_primitive_type("int") + assert repr(p) == "<ctype 'int'>" + # + py.test.raises(TypeError, new_array_type, new_pointer_type(p), "foo") + py.test.raises(ValueError, new_array_type, new_pointer_type(p), -42) + # + p1 = new_array_type(new_pointer_type(p), None) + assert repr(p1) == "<ctype 'int[]'>" + py.test.raises(ValueError, new_array_type, new_pointer_type(p1), 42) + # + p1 = new_array_type(new_pointer_type(p), 42) + p2 = new_array_type(new_pointer_type(p1), 25) + assert repr(p2) == "<ctype 'int[25][42]'>" + p2 = new_array_type(new_pointer_type(p1), None) + assert repr(p2) == "<ctype 'int[][42]'>" + # + py.test.raises(OverflowError, + new_array_type, new_pointer_type(p), sys.maxsize+1) + py.test.raises(OverflowError, + new_array_type, new_pointer_type(p), sys.maxsize // 3) + +def test_inspect_array_type(): + p = new_primitive_type("int") + p1 = new_array_type(new_pointer_type(p), None) + assert p1.kind == "array" + assert p1.cname == "int[]" + assert p1.item is p + assert p1.length is None + check_dir(p1, ['cname', 'kind', 'item', 'length']) + p1 = new_array_type(new_pointer_type(p), 42) + assert p1.kind == "array" + assert p1.cname == "int[42]" + assert p1.item is p + assert p1.length == 42 + check_dir(p1, ['cname', 'kind', 'item', 'length']) + +def test_array_instance(): + LENGTH = 1423 + p = new_primitive_type("int") + p1 = new_array_type(new_pointer_type(p), LENGTH) + a = newp(p1, None) + assert repr(a) == "<cdata 'int[%d]' owning %d bytes>" % ( + LENGTH, LENGTH * size_of_int()) + assert len(a) == LENGTH + for i in range(LENGTH): + assert a[i] == 0 + py.test.raises(IndexError, "a[LENGTH]") + py.test.raises(IndexError, "a[-1]") + for i in range(LENGTH): + a[i] = i * i + 1 + for i in range(LENGTH): + assert a[i] == i * i + 1 + e = py.test.raises(IndexError, "a[LENGTH+100] = 500") + assert ('(expected %d < %d)' % (LENGTH+100, LENGTH)) in str(e.value) + py.test.raises(TypeError, int, a) + +def test_array_of_unknown_length_instance(): + p = new_primitive_type("int") + p1 = new_array_type(new_pointer_type(p), None) + py.test.raises(TypeError, newp, p1, None) + py.test.raises(ValueError, newp, p1, -42) + a = newp(p1, 42) + assert len(a) == 42 + for i in range(42): + a[i] -= i + for i in range(42): + assert a[i] == -i + py.test.raises(IndexError, "a[42]") + py.test.raises(IndexError, "a[-1]") + py.test.raises(IndexError, "a[42] = 123") + py.test.raises(IndexError, "a[-1] = 456") + +def test_array_of_unknown_length_instance_with_initializer(): + p = new_primitive_type("int") + p1 = new_array_type(new_pointer_type(p), None) + a = newp(p1, list(range(42))) + assert len(a) == 42 + a = newp(p1, tuple(range(142))) + assert len(a) == 142 + +def test_array_initializer(): + p = new_primitive_type("int") + p1 = new_array_type(new_pointer_type(p), None) + a = newp(p1, list(range(100, 142))) + for i in range(42): + assert a[i] == 100 + i + # + p2 = new_array_type(new_pointer_type(p), 43) + a = newp(p2, tuple(range(100, 142))) + for i in range(42): + assert a[i] == 100 + i + assert a[42] == 0 # extra uninitialized item + +def test_array_add(): + p = new_primitive_type("int") + p1 = new_array_type(new_pointer_type(p), 5) # int[5] + p2 = new_array_type(new_pointer_type(p1), 3) # int[3][5] + a = newp(p2, [list(range(n, n+5)) for n in [100, 200, 300]]) + assert repr(a) == "<cdata 'int[3][5]' owning %d bytes>" % ( + 3*5*size_of_int(),) + assert repr(a + 0).startswith("<cdata 'int(*)[5]' 0x") + assert 0 + a == a + 0 != 1 + a == a + 1 + assert repr(a[0]).startswith("<cdata 'int[5]' 0x") + assert repr((a + 0)[0]).startswith("<cdata 'int[5]' 0x") + assert repr(a[0] + 0).startswith("<cdata 'int *' 0x") + assert type(a[0][0]) is int + assert type((a[0] + 0)[0]) is int + +def test_array_sub(): + BInt = new_primitive_type("int") + BArray = new_array_type(new_pointer_type(BInt), 5) # int[5] + a = newp(BArray, None) + p = a + 1 + assert p - a == 1 + assert p - (a+0) == 1 + assert a == (p - 1) + BPtr = new_pointer_type(new_primitive_type("short")) + q = newp(BPtr, None) + py.test.raises(TypeError, "p - q") + py.test.raises(TypeError, "q - p") + py.test.raises(TypeError, "a - q") + e = py.test.raises(TypeError, "q - a") + assert str(e.value) == "cannot subtract cdata 'short *' and cdata 'int *'" + +def test_ptr_sub_unaligned(): + BInt = new_primitive_type("int") + BIntPtr = new_pointer_type(BInt) + a = cast(BIntPtr, 1240) + for bi in range(1430, 1438): + b = cast(BIntPtr, bi) + if ((bi - 1240) % size_of_int()) == 0: + assert b - a == (bi - 1240) // size_of_int() + assert a - b == (1240 - bi) // size_of_int() + else: + py.test.raises(ValueError, "b - a") + py.test.raises(ValueError, "a - b") + +def test_cast_primitive_from_cdata(): + p = new_primitive_type("int") + n = cast(p, cast(p, -42)) + assert int(n) == -42 + # + p = new_primitive_type("unsigned int") + n = cast(p, cast(p, 42)) + assert int(n) == 42 + # + p = new_primitive_type("long long") + n = cast(p, cast(p, -(1<<60))) + assert int(n) == -(1<<60) + # + p = new_primitive_type("unsigned long long") + n = cast(p, cast(p, 1<<63)) + assert int(n) == 1<<63 + # + p = new_primitive_type("float") + n = cast(p, cast(p, 42.5)) + assert float(n) == 42.5 + # + p = new_primitive_type("char") + n = cast(p, cast(p, "A")) + assert int(n) == ord("A") + +def test_new_primitive_from_cdata(): + p = new_primitive_type("int") + p1 = new_pointer_type(p) + n = newp(p1, cast(p, -42)) + assert n[0] == -42 + # + p = new_primitive_type("unsigned int") + p1 = new_pointer_type(p) + n = newp(p1, cast(p, 42)) + assert n[0] == 42 + # + p = new_primitive_type("float") + p1 = new_pointer_type(p) + n = newp(p1, cast(p, 42.5)) + assert n[0] == 42.5 + # + p = new_primitive_type("char") + p1 = new_pointer_type(p) + n = newp(p1, cast(p, "A")) + assert n[0] == b"A" + +def test_cast_between_pointers(): + BIntP = new_pointer_type(new_primitive_type("int")) + BIntA = new_array_type(BIntP, None) + a = newp(BIntA, [40, 41, 42, 43, 44]) + BShortP = new_pointer_type(new_primitive_type("short")) + b = cast(BShortP, a) + c = cast(BIntP, b) + assert c[3] == 43 + BLongLong = new_primitive_type("long long") + d = cast(BLongLong, c) + e = cast(BIntP, d) + assert e[3] == 43 + f = cast(BIntP, int(d)) + assert f[3] == 43 + # + b = cast(BShortP, 0) + assert not b + c = cast(BIntP, b) + assert not c + assert int(cast(BLongLong, c)) == 0 + +def test_alignof(): + BInt = new_primitive_type("int") + assert alignof(BInt) == sizeof(BInt) + BPtr = new_pointer_type(BInt) + assert alignof(BPtr) == sizeof(BPtr) + BArray = new_array_type(BPtr, None) + assert alignof(BArray) == alignof(BInt) + +def test_new_struct_type(): + BStruct = new_struct_type("foo") + assert repr(BStruct) == "<ctype 'foo'>" + BStruct = new_struct_type("struct foo") + assert repr(BStruct) == "<ctype 'struct foo'>" + BPtr = new_pointer_type(BStruct) + assert repr(BPtr) == "<ctype 'struct foo *'>" + py.test.raises(ValueError, sizeof, BStruct) + py.test.raises(ValueError, alignof, BStruct) + +def test_new_union_type(): + BUnion = new_union_type("union foo") + assert repr(BUnion) == "<ctype 'union foo'>" + BPtr = new_pointer_type(BUnion) + assert repr(BPtr) == "<ctype 'union foo *'>" + +def test_complete_struct(): + BLong = new_primitive_type("long") + BChar = new_primitive_type("char") + BShort = new_primitive_type("short") + BStruct = new_struct_type("struct foo") + assert BStruct.kind == "struct" + assert BStruct.cname == "struct foo" + assert BStruct.fields is None + check_dir(BStruct, ['cname', 'kind', 'fields']) + # + complete_struct_or_union(BStruct, [('a1', BLong, -1), + ('a2', BChar, -1), + ('a3', BShort, -1)]) + d = BStruct.fields + assert len(d) == 3 + assert d[0][0] == 'a1' + assert d[0][1].type is BLong + assert d[0][1].offset == 0 + assert d[0][1].bitshift == -1 + assert d[0][1].bitsize == -1 + assert d[1][0] == 'a2' + assert d[1][1].type is BChar + assert d[1][1].offset == sizeof(BLong) + assert d[1][1].bitshift == -1 + assert d[1][1].bitsize == -1 + assert d[2][0] == 'a3' + assert d[2][1].type is BShort + assert d[2][1].offset == sizeof(BLong) + sizeof(BShort) + assert d[2][1].bitshift == -1 + assert d[2][1].bitsize == -1 + assert sizeof(BStruct) == 2 * sizeof(BLong) + assert alignof(BStruct) == alignof(BLong) + +def test_complete_union(): + BLong = new_primitive_type("long") + BChar = new_primitive_type("char") + BUnion = new_union_type("union foo") + assert BUnion.kind == "union" + assert BUnion.cname == "union foo" + assert BUnion.fields is None + complete_struct_or_union(BUnion, [('a1', BLong, -1), + ('a2', BChar, -1)]) + d = BUnion.fields + assert len(d) == 2 + assert d[0][0] == 'a1' + assert d[0][1].type is BLong + assert d[0][1].offset == 0 + assert d[1][0] == 'a2' + assert d[1][1].type is BChar + assert d[1][1].offset == 0 + assert sizeof(BUnion) == sizeof(BLong) + assert alignof(BUnion) == alignof(BLong) + +def test_struct_instance(): + BInt = new_primitive_type("int") + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + p = cast(BStructPtr, 42) + e = py.test.raises(AttributeError, "p.a1") # opaque + assert str(e.value) == ("cdata 'struct foo *' points to an opaque type: " + "cannot read fields") + e = py.test.raises(AttributeError, "p.a1 = 10") # opaque + assert str(e.value) == ("cdata 'struct foo *' points to an opaque type: " + "cannot write fields") + + complete_struct_or_union(BStruct, [('a1', BInt, -1), + ('a2', BInt, -1)]) + p = newp(BStructPtr, None) + s = p[0] + assert s.a1 == 0 + s.a2 = 123 + assert s.a1 == 0 + assert s.a2 == 123 + py.test.raises(OverflowError, "s.a1 = sys.maxsize+1") + assert s.a1 == 0 + e = py.test.raises(AttributeError, "p.foobar") + assert str(e.value) == "cdata 'struct foo *' has no field 'foobar'" + e = py.test.raises(AttributeError, "p.foobar = 42") + assert str(e.value) == "cdata 'struct foo *' has no field 'foobar'" + e = py.test.raises(AttributeError, "s.foobar") + assert str(e.value) == "cdata 'struct foo' has no field 'foobar'" + e = py.test.raises(AttributeError, "s.foobar = 42") + assert str(e.value) == "cdata 'struct foo' has no field 'foobar'" + j = cast(BInt, 42) + e = py.test.raises(AttributeError, "j.foobar") + assert str(e.value) == "cdata 'int' has no attribute 'foobar'" + e = py.test.raises(AttributeError, "j.foobar = 42") + assert str(e.value) == "cdata 'int' has no attribute 'foobar'" + j = cast(new_pointer_type(BInt), 42) + e = py.test.raises(AttributeError, "j.foobar") + assert str(e.value) == "cdata 'int *' has no attribute 'foobar'" + e = py.test.raises(AttributeError, "j.foobar = 42") + assert str(e.value) == "cdata 'int *' has no attribute 'foobar'" + pp = newp(new_pointer_type(BStructPtr), p) + e = py.test.raises(AttributeError, "pp.a1") + assert str(e.value) == "cdata 'struct foo * *' has no attribute 'a1'" + e = py.test.raises(AttributeError, "pp.a1 = 42") + assert str(e.value) == "cdata 'struct foo * *' has no attribute 'a1'" + +def test_union_instance(): + BInt = new_primitive_type("int") + BUInt = new_primitive_type("unsigned int") + BUnion = new_union_type("union bar") + complete_struct_or_union(BUnion, [('a1', BInt, -1), ('a2', BUInt, -1)]) + p = newp(new_pointer_type(BUnion), [-42]) + bigval = -42 + (1 << (8*size_of_int())) + assert p.a1 == -42 + assert p.a2 == bigval + p = newp(new_pointer_type(BUnion), {'a2': bigval}) + assert p.a1 == -42 + assert p.a2 == bigval + py.test.raises(OverflowError, newp, new_pointer_type(BUnion), + {'a1': bigval}) + p = newp(new_pointer_type(BUnion), []) + assert p.a1 == p.a2 == 0 + +def test_struct_pointer(): + BInt = new_primitive_type("int") + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a1', BInt, -1), + ('a2', BInt, -1)]) + p = newp(BStructPtr, None) + assert p.a1 == 0 # read/write via the pointer (C equivalent: '->') + p.a2 = 123 + assert p.a1 == 0 + assert p.a2 == 123 + +def test_struct_init_list(): + BVoidP = new_pointer_type(new_void_type()) + BInt = new_primitive_type("int") + BIntPtr = new_pointer_type(BInt) + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a1', BInt, -1), + ('a2', BInt, -1), + ('a3', BInt, -1), + ('p4', BIntPtr, -1)]) + s = newp(BStructPtr, [123, 456]) + assert s.a1 == 123 + assert s.a2 == 456 + assert s.a3 == 0 + assert s.p4 == cast(BVoidP, 0) + assert s.p4 != 0 + # + s = newp(BStructPtr, {'a2': 41122, 'a3': -123}) + assert s.a1 == 0 + assert s.a2 == 41122 + assert s.a3 == -123 + assert s.p4 == cast(BVoidP, 0) + # + py.test.raises(KeyError, newp, BStructPtr, {'foobar': 0}) + # + p = newp(BIntPtr, 14141) + s = newp(BStructPtr, [12, 34, 56, p]) + assert s.p4 == p + assert s.p4 + # + s = newp(BStructPtr, [12, 34, 56, cast(BVoidP, 0)]) + assert s.p4 == cast(BVoidP, 0) + assert not s.p4 + # + py.test.raises(TypeError, newp, BStructPtr, [12, 34, 56, None]) + +def test_array_in_struct(): + BInt = new_primitive_type("int") + BStruct = new_struct_type("struct foo") + BArrayInt5 = new_array_type(new_pointer_type(BInt), 5) + complete_struct_or_union(BStruct, [('a1', BArrayInt5, -1)]) + s = newp(new_pointer_type(BStruct), [[20, 24, 27, 29, 30]]) + assert s.a1[2] == 27 + assert repr(s.a1).startswith("<cdata 'int[5]' 0x") + +def test_offsetof(): + def offsetof(BType, fieldname): + return typeoffsetof(BType, fieldname)[1] + BInt = new_primitive_type("int") + BStruct = new_struct_type("struct foo") + py.test.raises(TypeError, offsetof, BInt, "abc") + py.test.raises(TypeError, offsetof, BStruct, "abc") + complete_struct_or_union(BStruct, [('abc', BInt, -1), ('def', BInt, -1)]) + assert offsetof(BStruct, 'abc') == 0 + assert offsetof(BStruct, 'def') == size_of_int() + py.test.raises(KeyError, offsetof, BStruct, "ghi") + assert offsetof(new_pointer_type(BStruct), "def") == size_of_int() + +def test_function_type(): + BInt = new_primitive_type("int") + BFunc = new_function_type((BInt, BInt), BInt, False) + assert repr(BFunc) == "<ctype 'int(*)(int, int)'>" + BFunc2 = new_function_type((), BFunc, False) + assert repr(BFunc2) == "<ctype 'int(*(*)())(int, int)'>" + +def test_inspect_function_type(): + BInt = new_primitive_type("int") + BFunc = new_function_type((BInt, BInt), BInt, False) + assert BFunc.kind == "function" + assert BFunc.cname == "int(*)(int, int)" + assert BFunc.args == (BInt, BInt) + assert BFunc.result is BInt + assert BFunc.ellipsis is False + assert BFunc.abi == FFI_DEFAULT_ABI + +def test_function_type_taking_struct(): + BChar = new_primitive_type("char") + BShort = new_primitive_type("short") + BStruct = new_struct_type("struct foo") + complete_struct_or_union(BStruct, [('a1', BChar, -1), + ('a2', BShort, -1)]) + BFunc = new_function_type((BStruct,), BShort, False) + assert repr(BFunc) == "<ctype 'short(*)(struct foo)'>" + +def test_function_void_result(): + BVoid = new_void_type() + BInt = new_primitive_type("int") + BFunc = new_function_type((BInt, BInt), BVoid, False) + assert repr(BFunc) == "<ctype 'void(*)(int, int)'>" + +def test_function_void_arg(): + BVoid = new_void_type() + BInt = new_primitive_type("int") + py.test.raises(TypeError, new_function_type, (BVoid,), BInt, False) + +def test_call_function_0(): + BSignedChar = new_primitive_type("signed char") + BFunc0 = new_function_type((BSignedChar, BSignedChar), BSignedChar, False) + f = cast(BFunc0, _testfunc(0)) + assert f(40, 2) == 42 + assert f(-100, -100) == -200 + 256 + py.test.raises(OverflowError, f, 128, 0) + py.test.raises(OverflowError, f, 0, 128) + +def test_call_function_0_pretend_bool_result(): + BSignedChar = new_primitive_type("signed char") + BBool = new_primitive_type("_Bool") + BFunc0 = new_function_type((BSignedChar, BSignedChar), BBool, False) + f = cast(BFunc0, _testfunc(0)) + assert f(40, -39) is True + assert f(40, -40) is False + py.test.raises(ValueError, f, 40, 2) + +def test_call_function_1(): + BInt = new_primitive_type("int") + BLong = new_primitive_type("long") + BFunc1 = new_function_type((BInt, BLong), BLong, False) + f = cast(BFunc1, _testfunc(1)) + assert f(40, 2) == 42 + assert f(-100, -100) == -200 + int_max = (1 << (8*size_of_int()-1)) - 1 + long_max = (1 << (8*size_of_long()-1)) - 1 + if int_max == long_max: + assert f(int_max, 1) == - int_max - 1 + else: + assert f(int_max, 1) == int_max + 1 + +def test_call_function_2(): + BLongLong = new_primitive_type("long long") + BFunc2 = new_function_type((BLongLong, BLongLong), BLongLong, False) + f = cast(BFunc2, _testfunc(2)) + longlong_max = (1 << (8*sizeof(BLongLong)-1)) - 1 + assert f(longlong_max - 42, 42) == longlong_max + assert f(43, longlong_max - 42) == - longlong_max - 1 + +def test_call_function_3(): + BFloat = new_primitive_type("float") + BDouble = new_primitive_type("double") + BFunc3 = new_function_type((BFloat, BDouble), BDouble, False) + f = cast(BFunc3, _testfunc(3)) + assert f(1.25, 5.1) == 1.25 + 5.1 # exact + res = f(1.3, 5.1) + assert res != 6.4 and abs(res - 6.4) < 1E-5 # inexact + +def test_call_function_4(): + BFloat = new_primitive_type("float") + BDouble = new_primitive_type("double") + BFunc4 = new_function_type((BFloat, BDouble), BFloat, False) + f = cast(BFunc4, _testfunc(4)) + res = f(1.25, 5.1) + assert res != 6.35 and abs(res - 6.35) < 1E-5 # inexact + +def test_call_function_5(): + BVoid = new_void_type() + BFunc5 = new_function_type((), BVoid, False) + f = cast(BFunc5, _testfunc(5)) + f() # did not crash + +def test_call_function_6(): + BInt = new_primitive_type("int") + BIntPtr = new_pointer_type(BInt) + BFunc6 = new_function_type((BIntPtr,), BIntPtr, False) + f = cast(BFunc6, _testfunc(6)) + x = newp(BIntPtr, 42) + res = f(x) + assert typeof(res) is BIntPtr + assert res[0] == 42 - 1000 + # + BIntArray = new_array_type(BIntPtr, None) + BFunc6bis = new_function_type((BIntArray,), BIntPtr, False) + f = cast(BFunc6bis, _testfunc(6)) + # + res = f([142]) + assert typeof(res) is BIntPtr + assert res[0] == 142 - 1000 + # + res = f((143,)) + assert typeof(res) is BIntPtr + assert res[0] == 143 - 1000 + # + x = newp(BIntArray, [242]) + res = f(x) + assert typeof(res) is BIntPtr + assert res[0] == 242 - 1000 + # + py.test.raises(TypeError, f, 123456) + py.test.raises(TypeError, f, "foo") + py.test.raises(TypeError, f, u+"bar") + +def test_call_function_7(): + BChar = new_primitive_type("char") + BShort = new_primitive_type("short") + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a1', BChar, -1), + ('a2', BShort, -1)]) + BFunc7 = new_function_type((BStruct,), BShort, False) + f = cast(BFunc7, _testfunc(7)) + res = f({'a1': b'A', 'a2': -4042}) + assert res == -4042 + ord(b'A') + # + x = newp(BStructPtr, {'a1': b'A', 'a2': -4042}) + res = f(x[0]) + assert res == -4042 + ord(b'A') + +def test_call_function_20(): + BChar = new_primitive_type("char") + BShort = new_primitive_type("short") + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a1', BChar, -1), + ('a2', BShort, -1)]) + BFunc20 = new_function_type((BStructPtr,), BShort, False) + f = cast(BFunc20, _testfunc(20)) + x = newp(BStructPtr, {'a1': b'A', 'a2': -4042}) + # can't pass a 'struct foo' + py.test.raises(TypeError, f, x[0]) + +def test_call_function_21(): + BInt = new_primitive_type("int") + BStruct = new_struct_type("struct foo") + complete_struct_or_union(BStruct, [('a', BInt, -1), + ('b', BInt, -1), + ('c', BInt, -1), + ('d', BInt, -1), + ('e', BInt, -1), + ('f', BInt, -1), + ('g', BInt, -1), + ('h', BInt, -1), + ('i', BInt, -1), + ('j', BInt, -1)]) + BFunc21 = new_function_type((BStruct,), BInt, False) + f = cast(BFunc21, _testfunc(21)) + res = f(list(range(13, 3, -1))) + lst = [(n << i) for (i, n) in enumerate(range(13, 3, -1))] + assert res == sum(lst) + +def test_call_function_22(): + BInt = new_primitive_type("int") + BArray10 = new_array_type(new_pointer_type(BInt), 10) + BStruct = new_struct_type("struct foo") + BStructP = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a', BArray10, -1)]) + BFunc22 = new_function_type((BStruct, BStruct), BStruct, False) + f = cast(BFunc22, _testfunc(22)) + p1 = newp(BStructP, {'a': list(range(100, 110))}) + p2 = newp(BStructP, {'a': list(range(1000, 1100, 10))}) + res = f(p1[0], p2[0]) + for i in range(10): + assert res.a[i] == p1.a[i] - p2.a[i] + +def test_call_function_23(): + BVoid = new_void_type() # declaring the function as int(void*) + BVoidP = new_pointer_type(BVoid) + BInt = new_primitive_type("int") + BFunc23 = new_function_type((BVoidP,), BInt, False) + f = cast(BFunc23, _testfunc(23)) + res = f(b"foo") + assert res == 1000 * ord(b'f') + res = f(cast(BVoidP, 0)) # NULL + assert res == -42 + py.test.raises(TypeError, f, None) + py.test.raises(TypeError, f, 0) + py.test.raises(TypeError, f, 0.0) + +def test_call_function_23_bis(): + # declaring the function as int(unsigned char*) + BUChar = new_primitive_type("unsigned char") + BUCharP = new_pointer_type(BUChar) + BInt = new_primitive_type("int") + BFunc23 = new_function_type((BUCharP,), BInt, False) + f = cast(BFunc23, _testfunc(23)) + res = f(b"foo") + assert res == 1000 * ord(b'f') + +def test_call_function_23_bool_array(): + # declaring the function as int(_Bool*) + BBool = new_primitive_type("_Bool") + BBoolP = new_pointer_type(BBool) + BInt = new_primitive_type("int") + BFunc23 = new_function_type((BBoolP,), BInt, False) + f = cast(BFunc23, _testfunc(23)) + res = f(b"\x01\x01") + assert res == 1000 + py.test.raises(ValueError, f, b"\x02\x02") + +def test_cannot_pass_struct_with_array_of_length_0(): + BInt = new_primitive_type("int") + BArray0 = new_array_type(new_pointer_type(BInt), 0) + BStruct = new_struct_type("struct foo") + BStructP = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a', BArray0)]) + BFunc = new_function_type((BStruct,), BInt, False) + py.test.raises(NotImplementedError, cast(BFunc, 123), cast(BStructP, 123)) + BFunc2 = new_function_type((BInt,), BStruct, False) + py.test.raises(NotImplementedError, cast(BFunc2, 123), 123) + +def test_call_function_9(): + BInt = new_primitive_type("int") + BFunc9 = new_function_type((BInt,), BInt, True) # vararg + f = cast(BFunc9, _testfunc(9)) + assert f(0) == 0 + assert f(1, cast(BInt, 42)) == 42 + assert f(2, cast(BInt, 40), cast(BInt, 2)) == 42 + py.test.raises(TypeError, f, 1, 42) + py.test.raises(TypeError, f, 2, None) + # promotion of chars and shorts to ints + BSChar = new_primitive_type("signed char") + BUChar = new_primitive_type("unsigned char") + BSShort = new_primitive_type("short") + assert f(3, cast(BSChar, -3), cast(BUChar, 200), cast(BSShort, -5)) == 192 + +def test_call_function_24(): + BFloat = new_primitive_type("float") + BFloatComplex = new_primitive_type("float _Complex") + BFunc3 = new_function_type((BFloat, BFloat), BFloatComplex, False) + if 0: # libffi returning nonsense silently, so logic disabled for now + f = cast(BFunc3, _testfunc(24)) + result = f(1.25, 5.1) + assert type(result) == complex + assert result.real == 1.25 # exact + assert (result.imag != 2*5.1) and (abs(result.imag - 2*5.1) < 1e-5) # inexact + else: + f = cast(BFunc3, _testfunc(9)) + py.test.raises(NotImplementedError, f, 12.3, 34.5) + +def test_call_function_25(): + BDouble = new_primitive_type("double") + BDoubleComplex = new_primitive_type("double _Complex") + BFunc3 = new_function_type((BDouble, BDouble), BDoubleComplex, False) + if 0: # libffi returning nonsense silently, so logic disabled for now + f = cast(BFunc3, _testfunc(25)) + result = f(1.25, 5.1) + assert type(result) == complex + assert result.real == 1.25 # exact + assert (result.imag != 2*5.1) and (abs(result.imag - 2*5.1) < 1e-10) # inexact + else: + f = cast(BFunc3, _testfunc(9)) + py.test.raises(NotImplementedError, f, 12.3, 34.5) + +def test_cannot_call_with_a_autocompleted_struct(): + BSChar = new_primitive_type("signed char") + BDouble = new_primitive_type("double") + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('c', BDouble, -1, 8), + ('a', BSChar, -1, 2), + ('b', BSChar, -1, 0)]) + BFunc = new_function_type((BStruct,), BDouble) # internally not callable + dummy_func = cast(BFunc, 42) + e = py.test.raises(NotImplementedError, dummy_func, "?") + msg = ("ctype 'struct foo' not supported as argument. It is a struct " + 'declared with "...;", but the C calling convention may depend ' + "on the missing fields; or, it contains anonymous struct/unions. " + "Such structs are only supported as argument if the function is " + "'API mode' and non-variadic (i.e. declared inside ffibuilder." + "cdef()+ffibuilder.set_source() and not taking a final '...' " + "argument)") + assert str(e.value) == msg + +def test_new_charp(): + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BCharA = new_array_type(BCharP, None) + x = newp(BCharA, 42) + assert len(x) == 42 + x = newp(BCharA, b"foobar") + assert len(x) == 7 + +def test_load_and_call_function(): + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BLong = new_primitive_type("long") + BFunc = new_function_type((BCharP,), BLong, False) + ll = find_and_load_library('c') + strlen = ll.load_function(BFunc, "strlen") + input = newp(new_array_type(BCharP, None), b"foobar") + assert strlen(input) == 6 + # + assert strlen(b"foobarbaz") == 9 + # + BVoidP = new_pointer_type(new_void_type()) + strlenaddr = ll.load_function(BVoidP, "strlen") + assert strlenaddr == cast(BVoidP, strlen) + +def test_read_variable(): + ## FIXME: this test assumes glibc specific behavior, it's not compliant with C standard + ## https://bugs.pypy.org/issue1643 + if not sys.platform.startswith("linux"): + py.test.skip("untested") + BVoidP = new_pointer_type(new_void_type()) + ll = find_and_load_library('c') + stderr = ll.read_variable(BVoidP, "stderr") + assert stderr == cast(BVoidP, _testfunc(8)) + # + ll.close_lib() + py.test.raises(ValueError, ll.read_variable, BVoidP, "stderr") + +def test_read_variable_as_unknown_length_array(): + ## FIXME: this test assumes glibc specific behavior, it's not compliant with C standard + ## https://bugs.pypy.org/issue1643 + if not sys.platform.startswith("linux"): + py.test.skip("untested") + BCharP = new_pointer_type(new_primitive_type("char")) + BArray = new_array_type(BCharP, None) + ll = find_and_load_library('c') + stderr = ll.read_variable(BArray, "stderr") + assert repr(stderr).startswith("<cdata 'char *' 0x") + # ^^ and not 'char[]', which is basically not allowed and would crash + +def test_write_variable(): + ## FIXME: this test assumes glibc specific behavior, it's not compliant with C standard + ## https://bugs.pypy.org/issue1643 + if not sys.platform.startswith("linux"): + py.test.skip("untested") + BVoidP = new_pointer_type(new_void_type()) + ll = find_and_load_library('c') + stderr = ll.read_variable(BVoidP, "stderr") + ll.write_variable(BVoidP, "stderr", cast(BVoidP, 0)) + assert ll.read_variable(BVoidP, "stderr") is not None + assert not ll.read_variable(BVoidP, "stderr") + ll.write_variable(BVoidP, "stderr", stderr) + assert ll.read_variable(BVoidP, "stderr") == stderr + # + ll.close_lib() + py.test.raises(ValueError, ll.write_variable, BVoidP, "stderr", stderr) + +def test_callback(): + BInt = new_primitive_type("int") + def make_callback(): + def cb(n): + return n + 1 + BFunc = new_function_type((BInt,), BInt, False) + return callback(BFunc, cb, 42) # 'cb' and 'BFunc' go out of scope + f = make_callback() + assert f(-142) == -141 + assert repr(f).startswith( + "<cdata 'int(*)(int)' calling <function ") + assert "cb at 0x" in repr(f) + e = py.test.raises(TypeError, f) + assert str(e.value) == "'int(*)(int)' expects 1 arguments, got 0" + +def test_callback_exception(): + try: + import cStringIO + except ImportError: + import io as cStringIO # Python 3 + import linecache + def matches(istr, ipattern): + str, pattern = istr, ipattern + while '$' in pattern: + i = pattern.index('$') + assert str[:i] == pattern[:i] + j = str.find(pattern[i+1], i) + assert i + 1 <= j <= str.find('\n', i) + str = str[j:] + pattern = pattern[i+1:] + assert str == pattern + return True + def check_value(x): + if x == 10000: + raise ValueError(42) + def Zcb1(x): + check_value(x) + return x * 3 + BShort = new_primitive_type("short") + BFunc = new_function_type((BShort,), BShort, False) + f = callback(BFunc, Zcb1, -42) + # + seen = [] + oops_result = None + def oops(*args): + seen.append(args) + return oops_result + ff = callback(BFunc, Zcb1, -42, oops) + # + orig_stderr = sys.stderr + orig_getline = linecache.getline + try: + linecache.getline = lambda *args: 'LINE' # hack: speed up PyPy tests + sys.stderr = cStringIO.StringIO() + assert f(100) == 300 + assert sys.stderr.getvalue() == '' + assert f(10000) == -42 + assert matches(sys.stderr.getvalue(), """\ +From cffi callback <function$Zcb1 at 0x$>: +Traceback (most recent call last): + File "$", line $, in Zcb1 + $ + File "$", line $, in check_value + $ +ValueError: 42 +""") + sys.stderr = cStringIO.StringIO() + bigvalue = 20000 + assert f(bigvalue) == -42 + assert matches(sys.stderr.getvalue(), """\ +From cffi callback <function$Zcb1 at 0x$>: +Trying to convert the result back to C: +OverflowError: integer 60000 does not fit 'short' +""") + sys.stderr = cStringIO.StringIO() + bigvalue = 20000 + assert len(seen) == 0 + assert ff(bigvalue) == -42 + assert sys.stderr.getvalue() == "" + assert len(seen) == 1 + exc, val, tb = seen[0] + assert exc is OverflowError + assert str(val) == "integer 60000 does not fit 'short'" + # + sys.stderr = cStringIO.StringIO() + bigvalue = 20000 + del seen[:] + oops_result = 81 + assert ff(bigvalue) == 81 + oops_result = None + assert sys.stderr.getvalue() == "" + assert len(seen) == 1 + exc, val, tb = seen[0] + assert exc is OverflowError + assert str(val) == "integer 60000 does not fit 'short'" + # + sys.stderr = cStringIO.StringIO() + bigvalue = 20000 + del seen[:] + oops_result = "xy" # not None and not an int! + assert ff(bigvalue) == -42 + oops_result = None + assert matches(sys.stderr.getvalue(), """\ +From cffi callback <function$Zcb1 at 0x$>: +Trying to convert the result back to C: +OverflowError: integer 60000 does not fit 'short' + +During the call to 'onerror', another exception occurred: + +TypeError: $integer$ +""") + # + sys.stderr = cStringIO.StringIO() + seen = "not a list" # this makes the oops() function crash + assert ff(bigvalue) == -42 + assert matches(sys.stderr.getvalue(), """\ +From cffi callback <function$Zcb1 at 0x$>: +Trying to convert the result back to C: +OverflowError: integer 60000 does not fit 'short' + +During the call to 'onerror', another exception occurred: + +Traceback (most recent call last): + File "$", line $, in oops + $ +AttributeError: 'str' object has no attribute 'append' +""") + finally: + sys.stderr = orig_stderr + linecache.getline = orig_getline + +def test_callback_return_type(): + for rettype in ["signed char", "short", "int", "long", "long long", + "unsigned char", "unsigned short", "unsigned int", + "unsigned long", "unsigned long long"]: + BRet = new_primitive_type(rettype) + def cb(n): + return n + 1 + BFunc = new_function_type((BRet,), BRet) + f = callback(BFunc, cb, 42) + assert f(41) == 42 + if rettype.startswith("unsigned "): + min = 0 + max = (1 << (8*sizeof(BRet))) - 1 + else: + min = -(1 << (8*sizeof(BRet)-1)) + max = (1 << (8*sizeof(BRet)-1)) - 1 + assert f(min) == min + 1 + assert f(max - 1) == max + assert f(max) == 42 + +def test_a_lot_of_callbacks(): + BIGNUM = 10000 + if 'PY_DOT_PY' in globals(): BIGNUM = 100 # tests on py.py + # + BInt = new_primitive_type("int") + BFunc = new_function_type((BInt,), BInt, False) + def make_callback(m): + def cb(n): + return n + m + return callback(BFunc, cb, 42) # 'cb' and 'BFunc' go out of scope + # + flist = [make_callback(i) for i in range(BIGNUM)] + for i, f in enumerate(flist): + assert f(-142) == -142 + i + +def test_callback_receiving_tiny_struct(): + BSChar = new_primitive_type("signed char") + BInt = new_primitive_type("int") + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a', BSChar, -1), + ('b', BSChar, -1)]) + def cb(s): + return s.a + 10 * s.b + BFunc = new_function_type((BStruct,), BInt) + f = callback(BFunc, cb) + p = newp(BStructPtr, [-2, -4]) + n = f(p[0]) + assert n == -42 + +def test_callback_returning_tiny_struct(): + BSChar = new_primitive_type("signed char") + BInt = new_primitive_type("int") + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a', BSChar, -1), + ('b', BSChar, -1)]) + def cb(n): + return newp(BStructPtr, [-n, -3*n])[0] + BFunc = new_function_type((BInt,), BStruct) + f = callback(BFunc, cb) + s = f(10) + assert typeof(s) is BStruct + assert repr(s) == "<cdata 'struct foo' owning 2 bytes>" + assert s.a == -10 + assert s.b == -30 + +def test_callback_receiving_struct(): + BSChar = new_primitive_type("signed char") + BInt = new_primitive_type("int") + BDouble = new_primitive_type("double") + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a', BSChar, -1), + ('b', BDouble, -1)]) + def cb(s): + return s.a + int(s.b) + BFunc = new_function_type((BStruct,), BInt) + f = callback(BFunc, cb) + p = newp(BStructPtr, [-2, 44.444]) + n = f(p[0]) + assert n == 42 + +def test_callback_returning_struct(): + BSChar = new_primitive_type("signed char") + BInt = new_primitive_type("int") + BDouble = new_primitive_type("double") + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a', BSChar, -1), + ('b', BDouble, -1)]) + def cb(n): + return newp(BStructPtr, [-n, 1E-42])[0] + BFunc = new_function_type((BInt,), BStruct) + f = callback(BFunc, cb) + s = f(10) + assert typeof(s) is BStruct + assert repr(s) in ["<cdata 'struct foo' owning 12 bytes>", + "<cdata 'struct foo' owning 16 bytes>"] + assert s.a == -10 + assert s.b == 1E-42 + +def test_callback_receiving_big_struct(): + BInt = new_primitive_type("int") + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a', BInt, -1), + ('b', BInt, -1), + ('c', BInt, -1), + ('d', BInt, -1), + ('e', BInt, -1), + ('f', BInt, -1), + ('g', BInt, -1), + ('h', BInt, -1), + ('i', BInt, -1), + ('j', BInt, -1)]) + def cb(s): + for i, name in enumerate("abcdefghij"): + assert getattr(s, name) == 13 - i + return 42 + BFunc = new_function_type((BStruct,), BInt) + f = callback(BFunc, cb) + p = newp(BStructPtr, list(range(13, 3, -1))) + n = f(p[0]) + assert n == 42 + +def test_callback_returning_big_struct(): + BInt = new_primitive_type("int") + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a', BInt, -1), + ('b', BInt, -1), + ('c', BInt, -1), + ('d', BInt, -1), + ('e', BInt, -1), + ('f', BInt, -1), + ('g', BInt, -1), + ('h', BInt, -1), + ('i', BInt, -1), + ('j', BInt, -1)]) + def cb(): + return newp(BStructPtr, list(range(13, 3, -1)))[0] + BFunc = new_function_type((), BStruct) + f = callback(BFunc, cb) + s = f() + assert typeof(s) is BStruct + assert repr(s) in ["<cdata 'struct foo' owning 40 bytes>", + "<cdata 'struct foo' owning 80 bytes>"] + for i, name in enumerate("abcdefghij"): + assert getattr(s, name) == 13 - i + +def test_callback_returning_void(): + BVoid = new_void_type() + BFunc = new_function_type((), BVoid, False) + def cb(): + seen.append(42) + f = callback(BFunc, cb) + seen = [] + f() + assert seen == [42] + py.test.raises(TypeError, callback, BFunc, cb, -42) + +def test_enum_type(): + BUInt = new_primitive_type("unsigned int") + BEnum = new_enum_type("foo", (), (), BUInt) + assert repr(BEnum) == "<ctype 'foo'>" + assert BEnum.kind == "enum" + assert BEnum.cname == "foo" + assert BEnum.elements == {} + # + BInt = new_primitive_type("int") + BEnum = new_enum_type("enum foo", ('def', 'c', 'ab'), (0, 1, -20), BInt) + assert BEnum.kind == "enum" + assert BEnum.cname == "enum foo" + assert BEnum.elements == {-20: 'ab', 0: 'def', 1: 'c'} + # 'elements' is not the real dict, but merely a copy + BEnum.elements[2] = '??' + assert BEnum.elements == {-20: 'ab', 0: 'def', 1: 'c'} + # + BEnum = new_enum_type("enum bar", ('ab', 'cd'), (5, 5), BUInt) + assert BEnum.elements == {5: 'ab'} + assert BEnum.relements == {'ab': 5, 'cd': 5} + +def test_cast_to_enum(): + BInt = new_primitive_type("int") + BEnum = new_enum_type("enum foo", ('def', 'c', 'ab'), (0, 1, -20), BInt) + assert sizeof(BEnum) == sizeof(BInt) + e = cast(BEnum, 0) + assert repr(e) == "<cdata 'enum foo' 0: def>" + assert repr(cast(BEnum, -42)) == "<cdata 'enum foo' -42>" + assert repr(cast(BEnum, -20)) == "<cdata 'enum foo' -20: ab>" + assert string(e) == 'def' + assert string(cast(BEnum, -20)) == 'ab' + assert int(cast(BEnum, 1)) == 1 + assert int(cast(BEnum, 0)) == 0 + assert int(cast(BEnum, -242 + 2**128)) == -242 + assert string(cast(BEnum, -242 + 2**128)) == '-242' + # + BUInt = new_primitive_type("unsigned int") + BEnum = new_enum_type("enum bar", ('def', 'c', 'ab'), (0, 1, 20), BUInt) + e = cast(BEnum, -1) + assert repr(e) == "<cdata 'enum bar' 4294967295>" # unsigned int + # + BLong = new_primitive_type("long") + BEnum = new_enum_type("enum baz", (), (), BLong) + assert sizeof(BEnum) == sizeof(BLong) + e = cast(BEnum, -1) + assert repr(e) == "<cdata 'enum baz' -1>" + +def test_enum_with_non_injective_mapping(): + BInt = new_primitive_type("int") + BEnum = new_enum_type("enum foo", ('ab', 'cd'), (7, 7), BInt) + e = cast(BEnum, 7) + assert repr(e) == "<cdata 'enum foo' 7: ab>" + assert string(e) == 'ab' + +def test_enum_in_struct(): + BInt = new_primitive_type("int") + BEnum = new_enum_type("enum foo", ('def', 'c', 'ab'), (0, 1, -20), BInt) + BStruct = new_struct_type("struct bar") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a1', BEnum, -1)]) + p = newp(BStructPtr, [-20]) + assert p.a1 == -20 + p = newp(BStructPtr, [12]) + assert p.a1 == 12 + e = py.test.raises(TypeError, newp, BStructPtr, [None]) + msg = str(e.value) + assert ("an integer is required" in msg or # CPython + "unsupported operand type for int(): 'NoneType'" in msg or # old PyPys + "expected integer, got NoneType object" in msg) # newer PyPys + py.test.raises(TypeError, 'p.a1 = "def"') + if sys.version_info < (3,): + BEnum2 = new_enum_type(unicode("foo"), (unicode('abc'),), (5,), BInt) + assert string(cast(BEnum2, 5)) == 'abc' + assert type(string(cast(BEnum2, 5))) is str + +def test_enum_overflow(): + max_uint = 2 ** (size_of_int()*8) - 1 + max_int = max_uint // 2 + max_ulong = 2 ** (size_of_long()*8) - 1 + max_long = max_ulong // 2 + for BPrimitive in [new_primitive_type("int"), + new_primitive_type("unsigned int"), + new_primitive_type("long"), + new_primitive_type("unsigned long")]: + for x in [max_uint, max_int, max_ulong, max_long]: + for testcase in [x, x+1, -x-1, -x-2]: + if int(cast(BPrimitive, testcase)) == testcase: + # fits + BEnum = new_enum_type("foo", ("AA",), (testcase,), + BPrimitive) + assert int(cast(BEnum, testcase)) == testcase + else: + # overflows + py.test.raises(OverflowError, new_enum_type, + "foo", ("AA",), (testcase,), BPrimitive) + +def test_callback_returning_enum(): + BInt = new_primitive_type("int") + BEnum = new_enum_type("foo", ('def', 'c', 'ab'), (0, 1, -20), BInt) + def cb(n): + if n & 1: + return cast(BEnum, n) + else: + return n + BFunc = new_function_type((BInt,), BEnum) + f = callback(BFunc, cb) + assert f(0) == 0 + assert f(1) == 1 + assert f(-20) == -20 + assert f(20) == 20 + assert f(21) == 21 + +def test_callback_returning_enum_unsigned(): + BInt = new_primitive_type("int") + BUInt = new_primitive_type("unsigned int") + BEnum = new_enum_type("foo", ('def', 'c', 'ab'), (0, 1, 20), BUInt) + def cb(n): + if n & 1: + return cast(BEnum, n) + else: + return n + BFunc = new_function_type((BInt,), BEnum) + f = callback(BFunc, cb) + assert f(0) == 0 + assert f(1) == 1 + assert f(-21) == 2**32 - 21 + assert f(20) == 20 + assert f(21) == 21 + +def test_callback_returning_char(): + BInt = new_primitive_type("int") + BChar = new_primitive_type("char") + def cb(n): + return bytechr(n) + BFunc = new_function_type((BInt,), BChar) + f = callback(BFunc, cb) + assert f(0) == b'\x00' + assert f(255) == b'\xFF' + +def _hacked_pypy_uni4(): + pyuni4 = {1: True, 2: False}[len(u+'\U00012345')] + return 'PY_DOT_PY' in globals() and not pyuni4 + +def test_callback_returning_wchar_t(): + BInt = new_primitive_type("int") + BWChar = new_primitive_type("wchar_t") + def cb(n): + if n == -1: + return u+'\U00012345' + if n == -2: + raise ValueError + return unichr(n) + BFunc = new_function_type((BInt,), BWChar) + f = callback(BFunc, cb) + assert f(0) == unichr(0) + assert f(255) == unichr(255) + assert f(0x1234) == u+'\u1234' + if sizeof(BWChar) == 4 and not _hacked_pypy_uni4(): + assert f(-1) == u+'\U00012345' + assert f(-2) == u+'\x00' # and an exception printed to stderr + +def test_struct_with_bitfields(): + BLong = new_primitive_type("long") + BStruct = new_struct_type("struct foo") + LONGBITS = 8 * sizeof(BLong) + complete_struct_or_union(BStruct, [('a1', BLong, 1), + ('a2', BLong, 2), + ('a3', BLong, 3), + ('a4', BLong, LONGBITS - 5)]) + d = BStruct.fields + assert d[0][1].offset == d[1][1].offset == d[2][1].offset == 0 + assert d[3][1].offset == sizeof(BLong) + def f(m, r): + if sys.byteorder == 'little': + return r + else: + return LONGBITS - m - r + assert d[0][1].bitshift == f(1, 0) + assert d[0][1].bitsize == 1 + assert d[1][1].bitshift == f(2, 1) + assert d[1][1].bitsize == 2 + assert d[2][1].bitshift == f(3, 3) + assert d[2][1].bitsize == 3 + assert d[3][1].bitshift == f(LONGBITS - 5, 0) + assert d[3][1].bitsize == LONGBITS - 5 + assert sizeof(BStruct) == 2 * sizeof(BLong) + assert alignof(BStruct) == alignof(BLong) + +def test_bitfield_instance(): + BInt = new_primitive_type("int") + BUnsignedInt = new_primitive_type("unsigned int") + BStruct = new_struct_type("struct foo") + complete_struct_or_union(BStruct, [('a1', BInt, 1), + ('a2', BUnsignedInt, 2), + ('a3', BInt, 3)]) + p = newp(new_pointer_type(BStruct), None) + p.a1 = -1 + assert p.a1 == -1 + p.a1 = 0 + py.test.raises(OverflowError, "p.a1 = 2") + assert p.a1 == 0 + # + p.a1 = -1 + p.a2 = 3 + p.a3 = -4 + py.test.raises(OverflowError, "p.a3 = 4") + e = py.test.raises(OverflowError, "p.a3 = -5") + assert str(e.value) == ("value -5 outside the range allowed by the " + "bit field width: -4 <= x <= 3") + assert p.a1 == -1 and p.a2 == 3 and p.a3 == -4 + # + # special case for convenience: "int x:1", while normally signed, + # allows also setting the value "1" (it still gets read back as -1) + p.a1 = 1 + assert p.a1 == -1 + e = py.test.raises(OverflowError, "p.a1 = -2") + assert str(e.value) == ("value -2 outside the range allowed by the " + "bit field width: -1 <= x <= 1") + +def test_bitfield_instance_init(): + BInt = new_primitive_type("int") + BStruct = new_struct_type("struct foo") + complete_struct_or_union(BStruct, [('a1', BInt, 1)]) + p = newp(new_pointer_type(BStruct), [-1]) + assert p.a1 == -1 + p = newp(new_pointer_type(BStruct), {'a1': -1}) + assert p.a1 == -1 + # + BUnion = new_union_type("union bar") + complete_struct_or_union(BUnion, [('a1', BInt, 1)]) + p = newp(new_pointer_type(BUnion), [-1]) + assert p.a1 == -1 + +def test_weakref(): + import _weakref + BInt = new_primitive_type("int") + BPtr = new_pointer_type(BInt) + rlist = [_weakref.ref(BInt), + _weakref.ref(newp(BPtr, 42)), + _weakref.ref(cast(BPtr, 42)), + _weakref.ref(cast(BInt, 42)), + _weakref.ref(buffer(newp(BPtr, 42))), + ] + for i in range(5): + import gc; gc.collect() + if [r() for r in rlist] == [None for r in rlist]: + break + +def test_no_inheritance(): + BInt = new_primitive_type("int") + try: + class foo(type(BInt)): pass + except TypeError: + pass + else: + raise AssertionError + x = cast(BInt, 42) + try: + class foo(type(x)): pass + except TypeError: + pass + else: + raise AssertionError + +def test_assign_string(): + BChar = new_primitive_type("char") + BArray1 = new_array_type(new_pointer_type(BChar), 5) + BArray2 = new_array_type(new_pointer_type(BArray1), 5) + a = newp(BArray2, [b"abc", b"de", b"ghij"]) + assert string(a[1]) == b"de" + assert string(a[2]) == b"ghij" + a[2] = b"." + assert string(a[2]) == b"." + a[2] = b"12345" + assert string(a[2]) == b"12345" + e = py.test.raises(IndexError, 'a[2] = b"123456"') + assert 'char[5]' in str(e.value) + assert 'got 6 characters' in str(e.value) + +def test_add_error(): + x = cast(new_primitive_type("int"), 42) + py.test.raises(TypeError, "x + 1") + py.test.raises(TypeError, "x - 1") + +def test_void_errors(): + py.test.raises(ValueError, alignof, new_void_type()) + py.test.raises(TypeError, newp, new_pointer_type(new_void_type()), None) + +def test_too_many_items(): + BChar = new_primitive_type("char") + BArray = new_array_type(new_pointer_type(BChar), 5) + py.test.raises(IndexError, newp, BArray, tuple(b'123456')) + py.test.raises(IndexError, newp, BArray, list(b'123456')) + py.test.raises(IndexError, newp, BArray, b'123456') + BStruct = new_struct_type("struct foo") + complete_struct_or_union(BStruct, []) + py.test.raises(TypeError, newp, new_pointer_type(BStruct), b'') + py.test.raises(ValueError, newp, new_pointer_type(BStruct), [b'1']) + +def test_more_type_errors(): + BInt = new_primitive_type("int") + BChar = new_primitive_type("char") + BArray = new_array_type(new_pointer_type(BChar), 5) + py.test.raises(TypeError, newp, BArray, 12.34) + BArray = new_array_type(new_pointer_type(BInt), 5) + py.test.raises(TypeError, newp, BArray, 12.34) + BFloat = new_primitive_type("float") + py.test.raises(TypeError, cast, BFloat, newp(BArray, None)) + +def test_more_overflow_errors(): + BUInt = new_primitive_type("unsigned int") + py.test.raises(OverflowError, newp, new_pointer_type(BUInt), -1) + py.test.raises(OverflowError, newp, new_pointer_type(BUInt), 2**32) + +def test_newp_copying(): + """Test that we can do newp(<type>, <cdata of the given type>) for most + types, including same-type arrays. + """ + BInt = new_primitive_type("int") + p = newp(new_pointer_type(BInt), cast(BInt, 42)) + assert p[0] == 42 + # + BUInt = new_primitive_type("unsigned int") + p = newp(new_pointer_type(BUInt), cast(BUInt, 42)) + assert p[0] == 42 + # + BChar = new_primitive_type("char") + p = newp(new_pointer_type(BChar), cast(BChar, '!')) + assert p[0] == b'!' + # + BFloat = new_primitive_type("float") + p = newp(new_pointer_type(BFloat), cast(BFloat, 12.25)) + assert p[0] == 12.25 + # + BStruct = new_struct_type("struct foo_s") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a1', BInt, -1)]) + s1 = newp(BStructPtr, [42]) + p1 = newp(new_pointer_type(BStructPtr), s1) + assert p1[0] == s1 + # + BArray = new_array_type(new_pointer_type(BInt), None) + a1 = newp(BArray, [1, 2, 3, 4]) + py.test.raises(TypeError, newp, BArray, a1) + BArray6 = new_array_type(new_pointer_type(BInt), 6) + a1 = newp(BArray6, [10, 20, 30]) + a2 = newp(BArray6, a1) + assert list(a2) == [10, 20, 30, 0, 0, 0] + # + s1 = newp(BStructPtr, [42]) + s2 = newp(BStructPtr, s1[0]) + assert s2.a1 == 42 + # + BUnion = new_union_type("union foo_u") + BUnionPtr = new_pointer_type(BUnion) + complete_struct_or_union(BUnion, [('a1', BInt, -1)]) + u1 = newp(BUnionPtr, [42]) + u2 = newp(BUnionPtr, u1[0]) + assert u2.a1 == 42 + # + BFunc = new_function_type((BInt,), BUInt) + p1 = cast(BFunc, 42) + p2 = newp(new_pointer_type(BFunc), p1) + assert p2[0] == p1 + +def test_string(): + BChar = new_primitive_type("char") + assert string(cast(BChar, 42)) == b'*' + assert string(cast(BChar, 0)) == b'\x00' + BCharP = new_pointer_type(BChar) + BArray = new_array_type(BCharP, 10) + a = newp(BArray, b"hello") + assert len(a) == 10 + assert string(a) == b"hello" + p = a + 2 + assert string(p) == b"llo" + assert string(newp(new_array_type(BCharP, 4), b"abcd")) == b"abcd" + py.test.raises(RuntimeError, string, cast(BCharP, 0)) + assert string(a, 4) == b"hell" + assert string(a, 5) == b"hello" + assert string(a, 6) == b"hello" + +def test_string_byte(): + BByte = new_primitive_type("signed char") + assert string(cast(BByte, 42)) == b'*' + assert string(cast(BByte, 0)) == b'\x00' + BArray = new_array_type(new_pointer_type(BByte), None) + a = newp(BArray, [65, 66, 67]) + assert type(string(a)) is bytes and string(a) == b'ABC' + # + BByte = new_primitive_type("unsigned char") + assert string(cast(BByte, 42)) == b'*' + assert string(cast(BByte, 0)) == b'\x00' + BArray = new_array_type(new_pointer_type(BByte), None) + a = newp(BArray, [65, 66, 67]) + assert type(string(a)) is bytes and string(a) == b'ABC' + if 'PY_DOT_PY' not in globals() and sys.version_info < (3,): + assert string(a, 8).startswith(b'ABC') # may contain additional garbage + +def test_string_wchar(): + for typename in ["wchar_t", "char16_t", "char32_t"]: + _test_string_wchar_variant(typename) + +def _test_string_wchar_variant(typename): + BWChar = new_primitive_type(typename) + assert string(cast(BWChar, 42)) == u+'*' + assert string(cast(BWChar, 0x4253)) == u+'\u4253' + assert string(cast(BWChar, 0)) == u+'\x00' + BArray = new_array_type(new_pointer_type(BWChar), None) + a = newp(BArray, [u+'A', u+'B', u+'C']) + assert type(string(a)) is unicode and string(a) == u+'ABC' + if 'PY_DOT_PY' not in globals() and sys.version_info < (3,): + try: + # may contain additional garbage + assert string(a, 8).startswith(u+'ABC') + except ValueError: # garbage contains values > 0x10FFFF + assert sizeof(BWChar) == 4 + +def test_string_typeerror(): + BShort = new_primitive_type("short") + BArray = new_array_type(new_pointer_type(BShort), None) + a = newp(BArray, [65, 66, 67]) + py.test.raises(TypeError, string, a) + +def test_bug_convert_to_ptr(): + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BDouble = new_primitive_type("double") + x = cast(BDouble, 42) + py.test.raises(TypeError, newp, new_pointer_type(BCharP), x) + +def test_set_struct_fields(): + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BCharArray10 = new_array_type(BCharP, 10) + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a1', BCharArray10, -1)]) + p = newp(BStructPtr, None) + assert string(p.a1) == b'' + p.a1 = b'foo' + assert string(p.a1) == b'foo' + assert list(p.a1) == [b'f', b'o', b'o'] + [b'\x00'] * 7 + p.a1 = [b'x', b'y'] + assert string(p.a1) == b'xyo' + +def test_invalid_function_result_types(): + BFunc = new_function_type((), new_void_type()) + BArray = new_array_type(new_pointer_type(BFunc), 5) # works + new_function_type((), BFunc) # works + new_function_type((), new_primitive_type("int")) + new_function_type((), new_pointer_type(BFunc)) + BUnion = new_union_type("union foo_u") + complete_struct_or_union(BUnion, []) + BFunc = new_function_type((), BUnion) + py.test.raises(NotImplementedError, cast(BFunc, 123)) + py.test.raises(TypeError, new_function_type, (), BArray) + +def test_struct_return_in_func(): + BChar = new_primitive_type("char") + BShort = new_primitive_type("short") + BFloat = new_primitive_type("float") + BDouble = new_primitive_type("double") + BInt = new_primitive_type("int") + BStruct = new_struct_type("struct foo_s") + complete_struct_or_union(BStruct, [('a1', BChar, -1), + ('a2', BShort, -1)]) + BFunc10 = new_function_type((BInt,), BStruct) + f = cast(BFunc10, _testfunc(10)) + s = f(40) + assert repr(s) == "<cdata 'struct foo_s' owning 4 bytes>" + assert s.a1 == bytechr(40) + assert s.a2 == 40 * 40 + # + BStruct11 = new_struct_type("struct test11") + complete_struct_or_union(BStruct11, [('a1', BInt, -1), + ('a2', BInt, -1)]) + BFunc11 = new_function_type((BInt,), BStruct11) + f = cast(BFunc11, _testfunc(11)) + s = f(40) + assert repr(s) == "<cdata 'struct test11' owning 8 bytes>" + assert s.a1 == 40 + assert s.a2 == 40 * 40 + # + BStruct12 = new_struct_type("struct test12") + complete_struct_or_union(BStruct12, [('a1', BDouble, -1), + ]) + BFunc12 = new_function_type((BInt,), BStruct12) + f = cast(BFunc12, _testfunc(12)) + s = f(40) + assert repr(s) == "<cdata 'struct test12' owning 8 bytes>" + assert s.a1 == 40.0 + # + BStruct13 = new_struct_type("struct test13") + complete_struct_or_union(BStruct13, [('a1', BInt, -1), + ('a2', BInt, -1), + ('a3', BInt, -1)]) + BFunc13 = new_function_type((BInt,), BStruct13) + f = cast(BFunc13, _testfunc(13)) + s = f(40) + assert repr(s) == "<cdata 'struct test13' owning 12 bytes>" + assert s.a1 == 40 + assert s.a2 == 40 * 40 + assert s.a3 == 40 * 40 * 40 + # + BStruct14 = new_struct_type("struct test14") + complete_struct_or_union(BStruct14, [('a1', BFloat, -1), + ]) + BFunc14 = new_function_type((BInt,), BStruct14) + f = cast(BFunc14, _testfunc(14)) + s = f(40) + assert repr(s) == "<cdata 'struct test14' owning 4 bytes>" + assert s.a1 == 40.0 + # + BStruct15 = new_struct_type("struct test15") + complete_struct_or_union(BStruct15, [('a1', BFloat, -1), + ('a2', BInt, -1)]) + BFunc15 = new_function_type((BInt,), BStruct15) + f = cast(BFunc15, _testfunc(15)) + s = f(40) + assert repr(s) == "<cdata 'struct test15' owning 8 bytes>" + assert s.a1 == 40.0 + assert s.a2 == 40 * 40 + # + BStruct16 = new_struct_type("struct test16") + complete_struct_or_union(BStruct16, [('a1', BFloat, -1), + ('a2', BFloat, -1)]) + BFunc16 = new_function_type((BInt,), BStruct16) + f = cast(BFunc16, _testfunc(16)) + s = f(40) + assert repr(s) == "<cdata 'struct test16' owning 8 bytes>" + assert s.a1 == 40.0 + assert s.a2 == -40.0 + # + BStruct17 = new_struct_type("struct test17") + complete_struct_or_union(BStruct17, [('a1', BInt, -1), + ('a2', BFloat, -1)]) + BFunc17 = new_function_type((BInt,), BStruct17) + f = cast(BFunc17, _testfunc(17)) + s = f(40) + assert repr(s) == "<cdata 'struct test17' owning 8 bytes>" + assert s.a1 == 40 + assert s.a2 == 40.0 * 40.0 + # + BStruct17Ptr = new_pointer_type(BStruct17) + BFunc18 = new_function_type((BStruct17Ptr,), BInt) + f = cast(BFunc18, _testfunc(18)) + x = f([[40, 2.5]]) + assert x == 42 + x = f([{'a2': 43.1}]) + assert x == 43 + +def test_cast_with_functionptr(): + BFunc = new_function_type((), new_void_type()) + BFunc2 = new_function_type((), new_primitive_type("short")) + BCharP = new_pointer_type(new_primitive_type("char")) + BIntP = new_pointer_type(new_primitive_type("int")) + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a1', BFunc, -1)]) + newp(BStructPtr, [cast(BFunc, 0)]) + newp(BStructPtr, [cast(BCharP, 0)]) + py.test.raises(TypeError, newp, BStructPtr, [cast(BIntP, 0)]) + py.test.raises(TypeError, newp, BStructPtr, [cast(BFunc2, 0)]) + +def test_wchar(): + _test_wchar_variant("wchar_t") + if sys.platform.startswith("linux"): + BWChar = new_primitive_type("wchar_t") + assert sizeof(BWChar) == 4 + # wchar_t is often signed on Linux, but not always (e.g. on ARM) + assert int(cast(BWChar, -1)) in (-1, 4294967295) + +def test_char16(): + BChar16 = new_primitive_type("char16_t") + assert sizeof(BChar16) == 2 + _test_wchar_variant("char16_t") + assert int(cast(BChar16, -1)) == 0xffff # always unsigned + +def test_char32(): + BChar32 = new_primitive_type("char32_t") + assert sizeof(BChar32) == 4 + _test_wchar_variant("char32_t") + assert int(cast(BChar32, -1)) == 0xffffffff # always unsigned + +def _test_wchar_variant(typename): + BWChar = new_primitive_type(typename) + BInt = new_primitive_type("int") + pyuni4 = {1: True, 2: False}[len(u+'\U00012345')] + wchar4 = {2: False, 4: True}[sizeof(BWChar)] + assert str(cast(BWChar, 0x45)) == "<cdata '%s' %s'E'>" % ( + typename, mandatory_u_prefix) + assert str(cast(BWChar, 0x1234)) == "<cdata '%s' %s'\u1234'>" % ( + typename, mandatory_u_prefix) + if not _hacked_pypy_uni4(): + if wchar4: + x = cast(BWChar, 0x12345) + assert str(x) == "<cdata '%s' %s'\U00012345'>" % ( + typename, mandatory_u_prefix) + assert int(x) == 0x12345 + else: + x = cast(BWChar, 0x18345) + assert str(x) == "<cdata '%s' %s'\u8345'>" % ( + typename, mandatory_u_prefix) + assert int(x) == 0x8345 + # + BWCharP = new_pointer_type(BWChar) + BStruct = new_struct_type("struct foo_s") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a1', BWChar, -1), + ('a2', BWCharP, -1)]) + s = newp(BStructPtr) + s.a1 = u+'\x00' + assert s.a1 == u+'\x00' + py.test.raises(TypeError, "s.a1 = b'a'") + py.test.raises(TypeError, "s.a1 = bytechr(0xFF)") + s.a1 = u+'\u1234' + assert s.a1 == u+'\u1234' + if pyuni4: + if wchar4: + s.a1 = u+'\U00012345' + assert s.a1 == u+'\U00012345' + elif wchar4: + if not _hacked_pypy_uni4(): + s.a1 = cast(BWChar, 0x12345) + assert s.a1 == u+'\ud808\udf45' + s.a1 = u+'\ud807\udf44' + assert s.a1 == u+'\U00011f44' + else: + py.test.raises(TypeError, "s.a1 = u+'\U00012345'") + # + BWCharArray = new_array_type(BWCharP, None) + a = newp(BWCharArray, u+'hello \u1234 world') + assert len(a) == 14 # including the final null + assert string(a) == u+'hello \u1234 world' + a[13] = u+'!' + assert string(a) == u+'hello \u1234 world!' + assert str(a) == repr(a) + assert a[6] == u+'\u1234' + a[6] = u+'-' + assert string(a) == u+'hello - world!' + assert str(a) == repr(a) + # + if wchar4 and not _hacked_pypy_uni4(): + u1 = u+'\U00012345\U00012346\U00012347' + a = newp(BWCharArray, u1) + assert len(a) == 4 + assert string(a) == u1 + assert len(list(a)) == 4 + expected = [u+'\U00012345', u+'\U00012346', u+'\U00012347', unichr(0)] + assert list(a) == expected + got = [a[i] for i in range(4)] + assert got == expected + py.test.raises(IndexError, 'a[4]') + # + w = cast(BWChar, 'a') + assert repr(w) == "<cdata '%s' %s'a'>" % (typename, mandatory_u_prefix) + assert str(w) == repr(w) + assert string(w) == u+'a' + assert int(w) == ord('a') + w = cast(BWChar, 0x1234) + assert repr(w) == "<cdata '%s' %s'\u1234'>" % (typename, mandatory_u_prefix) + assert str(w) == repr(w) + assert string(w) == u+'\u1234' + assert int(w) == 0x1234 + w = cast(BWChar, u+'\u8234') + assert repr(w) == "<cdata '%s' %s'\u8234'>" % (typename, mandatory_u_prefix) + assert str(w) == repr(w) + assert string(w) == u+'\u8234' + assert int(w) == 0x8234 + w = cast(BInt, u+'\u1234') + assert repr(w) == "<cdata 'int' 4660>" + if wchar4 and not _hacked_pypy_uni4(): + w = cast(BWChar, u+'\U00012345') + assert repr(w) == "<cdata '%s' %s'\U00012345'>" % ( + typename, mandatory_u_prefix) + assert str(w) == repr(w) + assert string(w) == u+'\U00012345' + assert int(w) == 0x12345 + w = cast(BInt, u+'\U00012345') + assert repr(w) == "<cdata 'int' 74565>" + py.test.raises(TypeError, cast, BInt, u+'') + py.test.raises(TypeError, cast, BInt, u+'XX') + assert int(cast(BInt, u+'a')) == ord('a') + # + a = newp(BWCharArray, u+'hello - world') + p = cast(BWCharP, a) + assert string(p) == u+'hello - world' + p[6] = u+'\u2345' + assert string(p) == u+'hello \u2345 world' + # + s = newp(BStructPtr, [u+'\u1234', p]) + assert s.a1 == u+'\u1234' + assert s.a2 == p + assert str(s.a2) == repr(s.a2) + assert string(s.a2) == u+'hello \u2345 world' + # + q = cast(BWCharP, 0) + assert str(q) == repr(q) + py.test.raises(RuntimeError, string, q) + # + def cb(p): + assert repr(p).startswith("<cdata '%s *' 0x" % typename) + return len(string(p)) + BFunc = new_function_type((BWCharP,), BInt, False) + f = callback(BFunc, cb, -42) + assert f(u+'a\u1234b') == 3 + # + if wchar4 and not pyuni4 and not _hacked_pypy_uni4(): + # try out-of-range wchar_t values + x = cast(BWChar, 1114112) + py.test.raises(ValueError, string, x) + x = cast(BWChar, -1) + py.test.raises(ValueError, string, x) + +def test_wchar_variants_mix(): + BWChar = new_primitive_type("wchar_t") + BChar16 = new_primitive_type("char16_t") + BChar32 = new_primitive_type("char32_t") + assert int(cast(BChar32, cast(BChar16, -2))) == 0xfffe + assert int(cast(BWChar, cast(BChar16, -2))) == 0xfffe + assert int(cast(BChar16, cast(BChar32, 0x0001f345))) == 0xf345 + assert int(cast(BChar16, cast(BWChar, 0x0001f345))) == 0xf345 + # + BChar16A = new_array_type(new_pointer_type(BChar16), None) + BChar32A = new_array_type(new_pointer_type(BChar32), None) + x = cast(BChar32, 'A') + py.test.raises(TypeError, newp, BChar16A, [x]) + x = cast(BChar16, 'A') + py.test.raises(TypeError, newp, BChar32A, [x]) + # + a = newp(BChar16A, u+'\U00012345') + assert len(a) == 3 + a = newp(BChar32A, u+'\U00012345') + assert len(a) == 2 # even if the Python unicode string above is 2 chars + +def test_keepalive_struct(): + # exception to the no-keepalive rule: p=newp(BStructPtr) returns a + # pointer owning the memory, and p[0] returns a pointer to the + # struct that *also* owns the memory + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a1', new_primitive_type("int"), -1), + ('a2', new_primitive_type("int"), -1), + ('a3', new_primitive_type("int"), -1)]) + p = newp(BStructPtr) + assert repr(p) == "<cdata 'struct foo *' owning 12 bytes>" + q = p[0] + assert repr(q) == "<cdata 'struct foo' owning 12 bytes>" + q.a1 = 123456 + assert p.a1 == 123456 + r = cast(BStructPtr, p) + assert repr(r[0]).startswith("<cdata 'struct foo &' 0x") + del p + import gc; gc.collect() + assert q.a1 == 123456 + assert repr(q) == "<cdata 'struct foo' owning 12 bytes>" + assert q.a1 == 123456 + +def test_nokeepalive_struct(): + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + BStructPtrPtr = new_pointer_type(BStructPtr) + complete_struct_or_union(BStruct, [('a1', new_primitive_type("int"), -1)]) + p = newp(BStructPtr) + pp = newp(BStructPtrPtr) + pp[0] = p + s = pp[0][0] + assert repr(s).startswith("<cdata 'struct foo &' 0x") + +def test_owning_repr(): + BInt = new_primitive_type("int") + BArray = new_array_type(new_pointer_type(BInt), None) # int[] + p = newp(BArray, 7) + assert repr(p) == "<cdata 'int[]' owning 28 bytes>" + assert sizeof(p) == 28 + # + BArray = new_array_type(new_pointer_type(BInt), 7) # int[7] + p = newp(BArray, None) + assert repr(p) == "<cdata 'int[7]' owning 28 bytes>" + assert sizeof(p) == 28 + +def test_cannot_dereference_void(): + BVoidP = new_pointer_type(new_void_type()) + p = cast(BVoidP, 123456) + py.test.raises(TypeError, "p[0]") + p = cast(BVoidP, 0) + py.test.raises((TypeError, RuntimeError), "p[0]") + +def test_iter(): + BInt = new_primitive_type("int") + BIntP = new_pointer_type(BInt) + BArray = new_array_type(BIntP, None) # int[] + p = newp(BArray, 7) + assert list(p) == list(iter(p)) == [0] * 7 + # + py.test.raises(TypeError, iter, cast(BInt, 5)) + py.test.raises(TypeError, iter, cast(BIntP, 123456)) + +def test_cmp(): + BInt = new_primitive_type("int") + BIntP = new_pointer_type(BInt) + BVoidP = new_pointer_type(new_void_type()) + p = newp(BIntP, 123) + q = cast(BInt, 124) + assert (p == q) is False + assert (p != q) is True + assert (q == p) is False + assert (q != p) is True + if strict_compare: + py.test.raises(TypeError, "p < q") + py.test.raises(TypeError, "p <= q") + py.test.raises(TypeError, "q < p") + py.test.raises(TypeError, "q <= p") + py.test.raises(TypeError, "p > q") + py.test.raises(TypeError, "p >= q") + r = cast(BVoidP, p) + assert (p < r) is False + assert (p <= r) is True + assert (p == r) is True + assert (p != r) is False + assert (p > r) is False + assert (p >= r) is True + s = newp(BIntP, 125) + assert (p == s) is False + assert (p != s) is True + assert (p < s) is (p <= s) is (s > p) is (s >= p) + assert (p > s) is (p >= s) is (s < p) is (s <= p) + assert (p < s) ^ (p > s) + +def test_buffer(): + try: + import __builtin__ + except ImportError: + import builtins as __builtin__ + BShort = new_primitive_type("short") + s = newp(new_pointer_type(BShort), 100) + assert sizeof(s) == size_of_ptr() + assert sizeof(BShort) == 2 + assert len(buffer(s)) == 2 + # + BChar = new_primitive_type("char") + BCharArray = new_array_type(new_pointer_type(BChar), None) + c = newp(BCharArray, b"hi there") + # + buf = buffer(c) + assert repr(buf).startswith('<_cffi_backend.buffer object at 0x') + assert bytes(buf) == b"hi there\x00" + assert type(buf) is buffer + if sys.version_info < (3,): + assert str(buf) == "hi there\x00" + assert unicode(buf) == u+"hi there\x00" + else: + assert str(buf) == repr(buf) + # --mb_length-- + assert len(buf) == len(b"hi there\x00") + # --mb_item-- + for i in range(-12, 12): + try: + expected = b"hi there\x00"[i] + except IndexError: + py.test.raises(IndexError, "buf[i]") + else: + assert buf[i] == bitem2bchr(expected) + # --mb_slice-- + assert buf[:] == b"hi there\x00" + for i in range(-12, 12): + assert buf[i:] == b"hi there\x00"[i:] + assert buf[:i] == b"hi there\x00"[:i] + for j in range(-12, 12): + assert buf[i:j] == b"hi there\x00"[i:j] + # --misc-- + assert list(buf) == list(map(bitem2bchr, b"hi there\x00")) + # --mb_as_buffer-- + if hasattr(__builtin__, 'buffer'): # Python <= 2.7 + py.test.raises(TypeError, __builtin__.buffer, c) + bf1 = __builtin__.buffer(buf) + assert len(bf1) == len(buf) and bf1[3] == "t" + if hasattr(__builtin__, 'memoryview'): # Python >= 2.7 + py.test.raises(TypeError, memoryview, c) + mv1 = memoryview(buf) + assert len(mv1) == len(buf) and mv1[3] in (b"t", ord(b"t")) + # --mb_ass_item-- + expected = list(map(bitem2bchr, b"hi there\x00")) + for i in range(-12, 12): + try: + expected[i] = bytechr(i & 0xff) + except IndexError: + py.test.raises(IndexError, "buf[i] = bytechr(i & 0xff)") + else: + buf[i] = bytechr(i & 0xff) + assert list(buf) == expected + # --mb_ass_slice-- + buf[:] = b"hi there\x00" + assert list(buf) == list(c) == list(map(bitem2bchr, b"hi there\x00")) + py.test.raises(ValueError, 'buf[:] = b"shorter"') + py.test.raises(ValueError, 'buf[:] = b"this is much too long!"') + buf[4:2] = b"" # no effect, but should work + assert buf[:] == b"hi there\x00" + buf[:2] = b"HI" + assert buf[:] == b"HI there\x00" + buf[:2] = b"hi" + expected = list(map(bitem2bchr, b"hi there\x00")) + x = 0 + for i in range(-12, 12): + for j in range(-12, 12): + start = i if i >= 0 else i + len(buf) + stop = j if j >= 0 else j + len(buf) + start = max(0, min(len(buf), start)) + stop = max(0, min(len(buf), stop)) + sample = bytechr(x & 0xff) * (stop - start) + x += 1 + buf[i:j] = sample + expected[i:j] = map(bitem2bchr, sample) + assert list(buf) == expected + +def test_getcname(): + BUChar = new_primitive_type("unsigned char") + BArray = new_array_type(new_pointer_type(BUChar), 123) + assert getcname(BArray, "<-->") == "unsigned char<-->[123]" + +def test_errno(): + BVoid = new_void_type() + BFunc5 = new_function_type((), BVoid) + f = cast(BFunc5, _testfunc(5)) + set_errno(50) + f() + assert get_errno() == 65 + f(); f() + assert get_errno() == 95 + +def test_errno_callback(): + if globals().get('PY_DOT_PY') == '2.5': + py.test.skip("cannot run this test on py.py with Python 2.5") + set_errno(95) + def cb(): + e = get_errno() + set_errno(e - 6) + BVoid = new_void_type() + BFunc5 = new_function_type((), BVoid) + f = callback(BFunc5, cb) + f() + assert get_errno() == 89 + f(); f() + assert get_errno() == 77 + +def test_cast_to_array(): + # not valid in C! extension to get a non-owning <cdata 'int[3]'> + BInt = new_primitive_type("int") + BIntP = new_pointer_type(BInt) + BArray = new_array_type(BIntP, 3) + x = cast(BArray, 0) + assert repr(x) == "<cdata 'int[3]' NULL>" + +def test_cast_invalid(): + BStruct = new_struct_type("struct foo") + complete_struct_or_union(BStruct, []) + p = cast(new_pointer_type(BStruct), 123456) + s = p[0] + py.test.raises(TypeError, cast, BStruct, s) + +def test_bug_float_convertion(): + BDouble = new_primitive_type("double") + BDoubleP = new_pointer_type(BDouble) + py.test.raises(TypeError, newp, BDoubleP, "foobar") + +def test_bug_delitem(): + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + x = newp(BCharP) + py.test.raises(TypeError, "del x[0]") + +def test_bug_delattr(): + BLong = new_primitive_type("long") + BStruct = new_struct_type("struct foo") + complete_struct_or_union(BStruct, [('a1', BLong, -1)]) + x = newp(new_pointer_type(BStruct)) + py.test.raises(AttributeError, "del x.a1") + +def test_variable_length_struct(): + py.test.skip("later") + BLong = new_primitive_type("long") + BArray = new_array_type(new_pointer_type(BLong), None) + BStruct = new_struct_type("struct foo") + BStructP = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a1', BLong, -1), + ('a2', BArray, -1)]) + assert sizeof(BStruct) == size_of_long() + assert alignof(BStruct) == alignof(BLong) + # + py.test.raises(TypeError, newp, BStructP, None) + x = newp(BStructP, 5) + assert sizeof(x) == 6 * size_of_long() + x[4] = 123 + assert x[4] == 123 + py.test.raises(IndexError, "x[5]") + assert len(x.a2) == 5 + # + py.test.raises(TypeError, newp, BStructP, [123]) + x = newp(BStructP, [123, 5]) + assert x.a1 == 123 + assert len(x.a2) == 5 + assert list(x.a2) == [0] * 5 + # + x = newp(BStructP, {'a2': 5}) + assert x.a1 == 0 + assert len(x.a2) == 5 + assert list(x.a2) == [0] * 5 + # + x = newp(BStructP, [123, (4, 5)]) + assert x.a1 == 123 + assert len(x.a2) == 2 + assert list(x.a2) == [4, 5] + # + x = newp(BStructP, {'a2': (4, 5)}) + assert x.a1 == 0 + assert len(x.a2) == 2 + assert list(x.a2) == [4, 5] + +def test_autocast_int(): + BInt = new_primitive_type("int") + BIntPtr = new_pointer_type(BInt) + BLongLong = new_primitive_type("long long") + BULongLong = new_primitive_type("unsigned long long") + BULongLongPtr = new_pointer_type(BULongLong) + x = newp(BIntPtr, cast(BInt, 42)) + assert x[0] == 42 + x = newp(BIntPtr, cast(BLongLong, 42)) + assert x[0] == 42 + x = newp(BIntPtr, cast(BULongLong, 42)) + assert x[0] == 42 + x = newp(BULongLongPtr, cast(BInt, 42)) + assert x[0] == 42 + py.test.raises(OverflowError, newp, BULongLongPtr, cast(BInt, -42)) + x = cast(BInt, cast(BInt, 42)) + assert int(x) == 42 + x = cast(BInt, cast(BLongLong, 42)) + assert int(x) == 42 + x = cast(BInt, cast(BULongLong, 42)) + assert int(x) == 42 + x = cast(BULongLong, cast(BInt, 42)) + assert int(x) == 42 + x = cast(BULongLong, cast(BInt, -42)) + assert int(x) == 2 ** 64 - 42 + x = cast(BIntPtr, cast(BInt, 42)) + assert int(cast(BInt, x)) == 42 + +def test_autocast_float(): + BFloat = new_primitive_type("float") + BDouble = new_primitive_type("float") + BFloatPtr = new_pointer_type(BFloat) + x = newp(BFloatPtr, cast(BDouble, 12.5)) + assert x[0] == 12.5 + x = cast(BFloat, cast(BDouble, 12.5)) + assert float(x) == 12.5 + +def test_longdouble(): + py_py = 'PY_DOT_PY' in globals() + BInt = new_primitive_type("int") + BLongDouble = new_primitive_type("long double") + BLongDoublePtr = new_pointer_type(BLongDouble) + BLongDoubleArray = new_array_type(BLongDoublePtr, None) + a = newp(BLongDoubleArray, 1) + x = a[0] + if not py_py: + assert repr(x).startswith("<cdata 'long double' 0.0") + assert float(x) == 0.0 + assert int(x) == 0 + # + b = newp(BLongDoubleArray, [1.23]) + x = b[0] + if not py_py: + assert repr(x).startswith("<cdata 'long double' 1.23") + assert float(x) == 1.23 + assert int(x) == 1 + # + BFunc19 = new_function_type((BLongDouble, BInt), BLongDouble) + f = cast(BFunc19, _testfunc(19)) + start = lstart = 1.5 + for i in range(107): + start = 4 * start - start * start + lstart = f(lstart, 1) + lother = f(1.5, 107) + if not py_py: + assert float(lstart) == float(lother) + assert repr(lstart) == repr(lother) + if sizeof(BLongDouble) > sizeof(new_primitive_type("double")): + assert float(lstart) != start + assert repr(lstart).startswith("<cdata 'long double' ") + # + c = newp(BLongDoubleArray, [lstart]) + x = c[0] + assert float(f(lstart, 107)) == float(f(x, 107)) + +def test_get_array_of_length_zero(): + for length in [0, 5, 10]: + BLong = new_primitive_type("long") + BLongP = new_pointer_type(BLong) + BArray0 = new_array_type(BLongP, length) + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a1', BArray0, -1)]) + p = newp(BStructPtr, None) + if length == 0: + assert repr(p.a1).startswith("<cdata 'long *' 0x") + else: + assert repr(p.a1).startswith("<cdata 'long[%d]' 0x" % length) + +def test_nested_anonymous_struct(): + BInt = new_primitive_type("int") + BChar = new_primitive_type("char") + BStruct = new_struct_type("struct foo") + BInnerStruct = new_struct_type("struct foo") + complete_struct_or_union(BInnerStruct, [('a1', BInt, -1), + ('a2', BChar, -1)]) + complete_struct_or_union(BStruct, [('', BInnerStruct, -1), + ('a3', BChar, -1)]) + assert sizeof(BInnerStruct) == sizeof(BInt) * 2 # with alignment + assert sizeof(BStruct) == sizeof(BInt) * 3 # 'a3' is placed after + d = BStruct.fields + assert len(d) == 3 + assert d[0][0] == 'a1' + assert d[0][1].type is BInt + assert d[0][1].offset == 0 + assert d[0][1].bitshift == -1 + assert d[0][1].bitsize == -1 + assert d[1][0] == 'a2' + assert d[1][1].type is BChar + assert d[1][1].offset == sizeof(BInt) + assert d[1][1].bitshift == -1 + assert d[1][1].bitsize == -1 + assert d[2][0] == 'a3' + assert d[2][1].type is BChar + assert d[2][1].offset == sizeof(BInt) * 2 + assert d[2][1].bitshift == -1 + assert d[2][1].bitsize == -1 + +def test_nested_anonymous_struct_2(): + BInt = new_primitive_type("int") + BStruct = new_struct_type("struct foo") + BInnerUnion = new_union_type("union bar") + complete_struct_or_union(BInnerUnion, [('a1', BInt, -1), + ('a2', BInt, -1)]) + complete_struct_or_union(BStruct, [('b1', BInt, -1), + ('', BInnerUnion, -1), + ('b2', BInt, -1)]) + assert sizeof(BInnerUnion) == sizeof(BInt) + assert sizeof(BStruct) == sizeof(BInt) * 3 + fields = [(name, fld.offset, fld.flags) for (name, fld) in BStruct.fields] + assert fields == [ + ('b1', 0 * sizeof(BInt), 0), + ('a1', 1 * sizeof(BInt), 0), + ('a2', 1 * sizeof(BInt), 1), + ('b2', 2 * sizeof(BInt), 0), + ] + +def test_sizeof_union(): + # a union has the largest alignment of its members, and a total size + # that is the largest of its items *possibly further aligned* if + # another smaller item has a larger alignment... + BChar = new_primitive_type("char") + BShort = new_primitive_type("short") + assert sizeof(BShort) == alignof(BShort) == 2 + BStruct = new_struct_type("struct foo") + complete_struct_or_union(BStruct, [('a1', BChar), + ('a2', BChar), + ('a3', BChar)]) + assert sizeof(BStruct) == 3 and alignof(BStruct) == 1 + BUnion = new_union_type("union u") + complete_struct_or_union(BUnion, [('s', BStruct), + ('i', BShort)]) + assert sizeof(BUnion) == 4 + assert alignof(BUnion) == 2 + +def test_unaligned_struct(): + BInt = new_primitive_type("int") + BStruct = new_struct_type("struct foo") + complete_struct_or_union(BStruct, [('b', BInt, -1, 1)], + None, 5, 1) + +def test_CData_CType(): + CData, CType = _get_types() + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + nullchr = cast(BChar, 0) + chrref = newp(BCharP, None) + assert isinstance(nullchr, CData) + assert isinstance(chrref, CData) + assert not isinstance(BChar, CData) + assert not isinstance(nullchr, CType) + assert not isinstance(chrref, CType) + assert isinstance(BChar, CType) + +def test_no_cdata_float(): + BInt = new_primitive_type("int") + BIntP = new_pointer_type(BInt) + BUInt = new_primitive_type("unsigned int") + BUIntP = new_pointer_type(BUInt) + BFloat = new_primitive_type("float") + py.test.raises(TypeError, newp, BIntP, cast(BFloat, 0.0)) + py.test.raises(TypeError, newp, BUIntP, cast(BFloat, 0.0)) + +def test_bool(): + BBool = new_primitive_type("_Bool") + BBoolP = new_pointer_type(BBool) + assert int(cast(BBool, False)) == 0 + assert int(cast(BBool, True)) == 1 + assert bool(cast(BBool, False)) is False # since 1.7 + assert bool(cast(BBool, True)) is True + assert int(cast(BBool, 3)) == 1 + assert int(cast(BBool, long(3))) == 1 + assert int(cast(BBool, long(10)**4000)) == 1 + assert int(cast(BBool, -0.1)) == 1 + assert int(cast(BBool, -0.0)) == 0 + assert int(cast(BBool, '\x00')) == 0 + assert int(cast(BBool, '\xff')) == 1 + assert newp(BBoolP, False)[0] == 0 + assert newp(BBoolP, True)[0] == 1 + assert newp(BBoolP, 0)[0] == 0 + assert newp(BBoolP, 1)[0] == 1 + py.test.raises(TypeError, newp, BBoolP, 1.0) + py.test.raises(TypeError, newp, BBoolP, '\x00') + py.test.raises(OverflowError, newp, BBoolP, 2) + py.test.raises(OverflowError, newp, BBoolP, -1) + BCharP = new_pointer_type(new_primitive_type("char")) + p = newp(BCharP, b'\x01') + q = cast(BBoolP, p) + assert q[0] is True + p = newp(BCharP, b'\x00') + q = cast(BBoolP, p) + assert q[0] is False + py.test.raises(TypeError, string, cast(BBool, False)) + BDouble = new_primitive_type("double") + assert int(cast(BBool, cast(BDouble, 0.1))) == 1 + assert int(cast(BBool, cast(BDouble, 0.0))) == 0 + BBoolA = new_array_type(BBoolP, None) + p = newp(BBoolA, b'\x01\x00') + assert p[0] is True + assert p[1] is False + +def test_bool_forbidden_cases(): + BBool = new_primitive_type("_Bool") + BBoolP = new_pointer_type(BBool) + BBoolA = new_array_type(BBoolP, None) + BCharP = new_pointer_type(new_primitive_type("char")) + p = newp(BCharP, b'X') + q = cast(BBoolP, p) + py.test.raises(ValueError, "q[0]") + py.test.raises(TypeError, newp, BBoolP, b'\x00') + assert newp(BBoolP, 0)[0] is False + assert newp(BBoolP, 1)[0] is True + py.test.raises(OverflowError, newp, BBoolP, 2) + py.test.raises(OverflowError, newp, BBoolP, -1) + py.test.raises(ValueError, newp, BBoolA, b'\x00\x01\x02') + py.test.raises(OverflowError, newp, BBoolA, [0, 1, 2]) + py.test.raises(TypeError, string, newp(BBoolP, 1)) + py.test.raises(TypeError, string, newp(BBoolA, [1])) + +def test_typeoffsetof(): + BChar = new_primitive_type("char") + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a1', BChar, -1), + ('a2', BChar, -1), + ('a3', BChar, -1)]) + py.test.raises(TypeError, typeoffsetof, BStructPtr, None) + py.test.raises(TypeError, typeoffsetof, BStruct, None) + assert typeoffsetof(BStructPtr, 'a1') == (BChar, 0) + assert typeoffsetof(BStruct, 'a1') == (BChar, 0) + assert typeoffsetof(BStructPtr, 'a2') == (BChar, 1) + assert typeoffsetof(BStruct, 'a3') == (BChar, 2) + assert typeoffsetof(BStructPtr, 'a2', 0) == (BChar, 1) + assert typeoffsetof(BStruct, u+'a3') == (BChar, 2) + py.test.raises(TypeError, typeoffsetof, BStructPtr, 'a2', 1) + py.test.raises(KeyError, typeoffsetof, BStructPtr, 'a4') + py.test.raises(KeyError, typeoffsetof, BStruct, 'a5') + py.test.raises(TypeError, typeoffsetof, BStruct, 42) + py.test.raises(TypeError, typeoffsetof, BChar, 'a1') + +def test_typeoffsetof_array(): + BInt = new_primitive_type("int") + BIntP = new_pointer_type(BInt) + BArray = new_array_type(BIntP, None) + py.test.raises(TypeError, typeoffsetof, BArray, None) + py.test.raises(TypeError, typeoffsetof, BArray, 'a1') + assert typeoffsetof(BArray, 51) == (BInt, 51 * size_of_int()) + assert typeoffsetof(BIntP, 51) == (BInt, 51 * size_of_int()) + assert typeoffsetof(BArray, -51) == (BInt, -51 * size_of_int()) + MAX = sys.maxsize // size_of_int() + assert typeoffsetof(BArray, MAX) == (BInt, MAX * size_of_int()) + assert typeoffsetof(BIntP, MAX) == (BInt, MAX * size_of_int()) + py.test.raises(OverflowError, typeoffsetof, BArray, MAX + 1) + +def test_typeoffsetof_no_bitfield(): + BInt = new_primitive_type("int") + BStruct = new_struct_type("struct foo") + complete_struct_or_union(BStruct, [('a1', BInt, 4)]) + py.test.raises(TypeError, typeoffsetof, BStruct, 'a1') + +def test_rawaddressof(): + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BStruct = new_struct_type("struct foo") + BStructPtr = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('a1', BChar, -1), + ('a2', BChar, -1), + ('a3', BChar, -1)]) + p = newp(BStructPtr) + assert repr(p) == "<cdata 'struct foo *' owning 3 bytes>" + s = p[0] + assert repr(s) == "<cdata 'struct foo' owning 3 bytes>" + a = rawaddressof(BStructPtr, s, 0) + assert repr(a).startswith("<cdata 'struct foo *' 0x") + py.test.raises(TypeError, rawaddressof, BStruct, s, 0) + b = rawaddressof(BCharP, s, 0) + assert b == cast(BCharP, p) + c = rawaddressof(BStructPtr, a, 0) + assert c == a + py.test.raises(TypeError, rawaddressof, BStructPtr, cast(BChar, '?'), 0) + # + d = rawaddressof(BCharP, s, 1) + assert d == cast(BCharP, p) + 1 + # + e = cast(BCharP, 109238) + f = rawaddressof(BCharP, e, 42) + assert f == e + 42 + # + BCharA = new_array_type(BCharP, None) + e = newp(BCharA, 50) + f = rawaddressof(BCharP, e, 42) + assert f == e + 42 + +def test_newp_signed_unsigned_char(): + BCharArray = new_array_type( + new_pointer_type(new_primitive_type("char")), None) + p = newp(BCharArray, b"foo") + assert len(p) == 4 + assert list(p) == [b"f", b"o", b"o", b"\x00"] + # + BUCharArray = new_array_type( + new_pointer_type(new_primitive_type("unsigned char")), None) + p = newp(BUCharArray, b"fo\xff") + assert len(p) == 4 + assert list(p) == [ord("f"), ord("o"), 0xff, 0] + # + BSCharArray = new_array_type( + new_pointer_type(new_primitive_type("signed char")), None) + p = newp(BSCharArray, b"fo\xff") + assert len(p) == 4 + assert list(p) == [ord("f"), ord("o"), -1, 0] + +def test_newp_from_bytearray_doesnt_work(): + BCharArray = new_array_type( + new_pointer_type(new_primitive_type("char")), None) + py.test.raises(TypeError, newp, BCharArray, bytearray(b"foo")) + p = newp(BCharArray, 5) + buffer(p)[:] = bytearray(b"foo.\x00") + assert len(p) == 5 + assert list(p) == [b"f", b"o", b"o", b".", b"\x00"] + p[1:3] = bytearray(b"XY") + assert list(p) == [b"f", b"X", b"Y", b".", b"\x00"] + +def test_string_assignment_to_byte_array(): + BByteArray = new_array_type( + new_pointer_type(new_primitive_type("unsigned char")), None) + p = newp(BByteArray, 5) + p[0:3] = bytearray(b"XYZ") + assert list(p) == [ord("X"), ord("Y"), ord("Z"), 0, 0] + +# XXX hack +if sys.version_info >= (3,): + try: + import posix, io + posix.fdopen = io.open + except ImportError: + pass # win32 + +def test_FILE(): + if sys.platform == "win32": + py.test.skip("testing FILE not implemented") + # + BFILE = new_struct_type("struct _IO_FILE") + BFILEP = new_pointer_type(BFILE) + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BInt = new_primitive_type("int") + BFunc = new_function_type((BCharP, BFILEP), BInt, False) + BFunc2 = new_function_type((BFILEP, BCharP), BInt, True) + ll = find_and_load_library('c') + fputs = ll.load_function(BFunc, "fputs") + fscanf = ll.load_function(BFunc2, "fscanf") + # + import posix + fdr, fdw = posix.pipe() + fr1 = posix.fdopen(fdr, 'rb', 256) + fw1 = posix.fdopen(fdw, 'wb', 256) + # + fw1.write(b"X") + res = fputs(b"hello world\n", fw1) + assert res >= 0 + fw1.flush() # should not be needed + # + p = newp(new_array_type(BCharP, 100), None) + res = fscanf(fr1, b"%s\n", p) + assert res == 1 + assert string(p) == b"Xhello" + fr1.close() + fw1.close() + +def test_FILE_only_for_FILE_arg(): + if sys.platform == "win32": + py.test.skip("testing FILE not implemented") + # + B_NOT_FILE = new_struct_type("struct NOT_FILE") + B_NOT_FILEP = new_pointer_type(B_NOT_FILE) + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BInt = new_primitive_type("int") + BFunc = new_function_type((BCharP, B_NOT_FILEP), BInt, False) + ll = find_and_load_library('c') + fputs = ll.load_function(BFunc, "fputs") + # + import posix + fdr, fdw = posix.pipe() + fr1 = posix.fdopen(fdr, 'r') + fw1 = posix.fdopen(fdw, 'w') + # + e = py.test.raises(TypeError, fputs, b"hello world\n", fw1) + assert str(e.value).startswith( + "initializer for ctype 'struct NOT_FILE *' must " + "be a cdata pointer, not ") + +def test_FILE_object(): + if sys.platform == "win32": + py.test.skip("testing FILE not implemented") + # + BFILE = new_struct_type("FILE") + BFILEP = new_pointer_type(BFILE) + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BInt = new_primitive_type("int") + BFunc = new_function_type((BCharP, BFILEP), BInt, False) + BFunc2 = new_function_type((BFILEP,), BInt, False) + ll = find_and_load_library('c') + fputs = ll.load_function(BFunc, "fputs") + fileno = ll.load_function(BFunc2, "fileno") + # + import posix + fdr, fdw = posix.pipe() + fw1 = posix.fdopen(fdw, 'wb', 256) + # + fw1p = cast(BFILEP, fw1) + fw1.write(b"X") + fw1.flush() + res = fputs(b"hello\n", fw1p) + assert res >= 0 + res = fileno(fw1p) + assert (res == fdw) == (sys.version_info < (3,)) + fw1.close() + # + data = posix.read(fdr, 256) + assert data == b"Xhello\n" + posix.close(fdr) + +def test_errno_saved(): + set_errno(42) + # a random function that will reset errno to 0 (at least on non-windows) + import os; os.stat('.') + # + res = get_errno() + assert res == 42 + +def test_GetLastError(): + if sys.platform != "win32": + py.test.skip("GetLastError(): only for Windows") + # + lib = find_and_load_library('KERNEL32.DLL') + BInt = new_primitive_type("int") + BVoid = new_void_type() + BFunc1 = new_function_type((BInt,), BVoid, False) + BFunc2 = new_function_type((), BInt, False) + SetLastError = lib.load_function(BFunc1, "SetLastError") + GetLastError = lib.load_function(BFunc2, "GetLastError") + # + SetLastError(42) + # a random function that will reset the real GetLastError() to 0 + import nt; nt.stat('.') + # + res = GetLastError() + assert res == 42 + # + SetLastError(2) + code, message = getwinerror() + assert code == 2 + assert message == "The system cannot find the file specified" + # + code, message = getwinerror(1155) + assert code == 1155 + assert message == ("No application is associated with the " + "specified file for this operation") + +def test_nonstandard_integer_types(): + for typename in ['int8_t', 'uint8_t', 'int16_t', 'uint16_t', 'int32_t', + 'uint32_t', 'int64_t', 'uint64_t', 'intptr_t', + 'uintptr_t', 'ptrdiff_t', 'size_t', 'ssize_t', + 'int_least8_t', 'uint_least8_t', + 'int_least16_t', 'uint_least16_t', + 'int_least32_t', 'uint_least32_t', + 'int_least64_t', 'uint_least64_t', + 'int_fast8_t', 'uint_fast8_t', + 'int_fast16_t', 'uint_fast16_t', + 'int_fast32_t', 'uint_fast32_t', + 'int_fast64_t', 'uint_fast64_t', + 'intmax_t', 'uintmax_t']: + new_primitive_type(typename) # works + +def test_cannot_convert_unicode_to_charp(): + BCharP = new_pointer_type(new_primitive_type("char")) + BCharArray = new_array_type(BCharP, None) + py.test.raises(TypeError, newp, BCharArray, u+'foobar') + +def test_buffer_keepalive(): + BCharP = new_pointer_type(new_primitive_type("char")) + BCharArray = new_array_type(BCharP, None) + buflist = [] + for i in range(20): + c = newp(BCharArray, str2bytes("hi there %d" % i)) + buflist.append(buffer(c)) + import gc; gc.collect() + for i in range(20): + buf = buflist[i] + assert buf[:] == str2bytes("hi there %d\x00" % i) + +def test_slice(): + BIntP = new_pointer_type(new_primitive_type("int")) + BIntArray = new_array_type(BIntP, None) + c = newp(BIntArray, 5) + assert len(c) == 5 + assert repr(c) == "<cdata 'int[]' owning 20 bytes>" + d = c[1:4] + assert len(d) == 3 + assert repr(d) == "<cdata 'int[]' sliced length 3>" + d[0] = 123 + d[2] = 456 + assert c[1] == 123 + assert c[3] == 456 + assert d[2] == 456 + py.test.raises(IndexError, "d[3]") + py.test.raises(IndexError, "d[-1]") + +def test_slice_ptr(): + BIntP = new_pointer_type(new_primitive_type("int")) + BIntArray = new_array_type(BIntP, None) + c = newp(BIntArray, 5) + d = (c+1)[0:2] + assert len(d) == 2 + assert repr(d) == "<cdata 'int[]' sliced length 2>" + d[1] += 50 + assert c[2] == 50 + +def test_slice_array_checkbounds(): + BIntP = new_pointer_type(new_primitive_type("int")) + BIntArray = new_array_type(BIntP, None) + c = newp(BIntArray, 5) + c[0:5] + assert len(c[5:5]) == 0 + py.test.raises(IndexError, "c[-1:1]") + cp = c + 0 + cp[-1:1] + +def test_nonstandard_slice(): + BIntP = new_pointer_type(new_primitive_type("int")) + BIntArray = new_array_type(BIntP, None) + c = newp(BIntArray, 5) + e = py.test.raises(IndexError, "c[:5]") + assert str(e.value) == "slice start must be specified" + e = py.test.raises(IndexError, "c[4:]") + assert str(e.value) == "slice stop must be specified" + e = py.test.raises(IndexError, "c[1:2:3]") + assert str(e.value) == "slice with step not supported" + e = py.test.raises(IndexError, "c[1:2:1]") + assert str(e.value) == "slice with step not supported" + e = py.test.raises(IndexError, "c[4:2]") + assert str(e.value) == "slice start > stop" + e = py.test.raises(IndexError, "c[6:6]") + assert str(e.value) == "index too large (expected 6 <= 5)" + +def test_setslice(): + BIntP = new_pointer_type(new_primitive_type("int")) + BIntArray = new_array_type(BIntP, None) + c = newp(BIntArray, 5) + c[1:3] = [100, 200] + assert list(c) == [0, 100, 200, 0, 0] + cp = c + 3 + cp[-1:1] = [300, 400] + assert list(c) == [0, 100, 300, 400, 0] + cp[-1:1] = iter([500, 600]) + assert list(c) == [0, 100, 500, 600, 0] + py.test.raises(ValueError, "cp[-1:1] = [1000]") + assert list(c) == [0, 100, 1000, 600, 0] + py.test.raises(ValueError, "cp[-1:1] = (700, 800, 900)") + assert list(c) == [0, 100, 700, 800, 0] + +def test_setslice_array(): + BIntP = new_pointer_type(new_primitive_type("int")) + BIntArray = new_array_type(BIntP, None) + c = newp(BIntArray, 5) + d = newp(BIntArray, [10, 20, 30]) + c[1:4] = d + assert list(c) == [0, 10, 20, 30, 0] + # + BShortP = new_pointer_type(new_primitive_type("short")) + BShortArray = new_array_type(BShortP, None) + d = newp(BShortArray, [40, 50]) + c[1:3] = d + assert list(c) == [0, 40, 50, 30, 0] + +def test_cdata_name_module_doc(): + p = new_primitive_type("signed char") + x = cast(p, 17) + assert x.__module__ == '_cffi_backend' + assert x.__name__ == '<cdata>' + assert hasattr(x, '__doc__') + +def test_different_types_of_ptr_equality(): + BVoidP = new_pointer_type(new_void_type()) + BIntP = new_pointer_type(new_primitive_type("int")) + x = cast(BVoidP, 12345) + assert x == cast(BIntP, 12345) + assert x != cast(BIntP, 12344) + assert hash(x) == hash(cast(BIntP, 12345)) + +def test_new_handle(): + import _weakref + BVoidP = new_pointer_type(new_void_type()) + BCharP = new_pointer_type(new_primitive_type("char")) + class mylist(list): + pass + o = mylist([2, 3, 4]) + x = newp_handle(BVoidP, o) + assert repr(x) == "<cdata 'void *' handle to [2, 3, 4]>" + assert x + assert from_handle(x) is o + assert from_handle(cast(BCharP, x)) is o + wr = _weakref.ref(o) + del o + import gc; gc.collect() + assert wr() is not None + assert from_handle(x) == list((2, 3, 4)) + assert from_handle(cast(BCharP, x)) == list((2, 3, 4)) + del x + for i in range(3): + if wr() is not None: + import gc; gc.collect() + assert wr() is None + py.test.raises(RuntimeError, from_handle, cast(BCharP, 0)) + +def test_new_handle_cycle(): + import _weakref + BVoidP = new_pointer_type(new_void_type()) + class A(object): + pass + o = A() + o.cycle = newp_handle(BVoidP, o) + wr = _weakref.ref(o) + del o + for i in range(3): + if wr() is not None: + import gc; gc.collect() + assert wr() is None + +def _test_bitfield_details(flag): + BChar = new_primitive_type("char") + BShort = new_primitive_type("short") + BInt = new_primitive_type("int") + BUInt = new_primitive_type("unsigned int") + BStruct = new_struct_type("struct foo1") + complete_struct_or_union(BStruct, [('a', BChar, -1), + ('b1', BInt, 9), + ('b2', BUInt, 7), + ('c', BChar, -1)], -1, -1, -1, flag) + if not (flag & SF_MSVC_BITFIELDS): # gcc, any variant + assert typeoffsetof(BStruct, 'c') == (BChar, 3) + assert sizeof(BStruct) == 4 + else: # msvc + assert typeoffsetof(BStruct, 'c') == (BChar, 8) + assert sizeof(BStruct) == 12 + assert alignof(BStruct) == 4 + # + p = newp(new_pointer_type(BStruct), None) + p.a = b'A' + p.b1 = -201 + p.b2 = 99 + p.c = b'\x9D' + raw = buffer(p)[:] + if sys.byteorder == 'little': + if flag & SF_MSVC_BITFIELDS: + assert raw == b'A\x00\x00\x007\xC7\x00\x00\x9D\x00\x00\x00' + elif flag & SF_GCC_LITTLE_ENDIAN: + assert raw == b'A7\xC7\x9D' + elif flag & SF_GCC_BIG_ENDIAN: + assert raw == b'A\xE3\x9B\x9D' + else: + raise AssertionError("bad flag") + else: + if flag & SF_MSVC_BITFIELDS: + assert raw == b'A\x00\x00\x00\x00\x00\xC77\x9D\x00\x00\x00' + elif flag & SF_GCC_LITTLE_ENDIAN: + assert raw == b'A\xC77\x9D' + elif flag & SF_GCC_BIG_ENDIAN: + assert raw == b'A\x9B\xE3\x9D' + else: + raise AssertionError("bad flag") + # + BStruct = new_struct_type("struct foo2") + complete_struct_or_union(BStruct, [('a', BChar, -1), + ('', BShort, 9), + ('c', BChar, -1)], -1, -1, -1, flag) + assert typeoffsetof(BStruct, 'c') == (BChar, 4) + if flag & SF_MSVC_BITFIELDS: + assert sizeof(BStruct) == 6 + assert alignof(BStruct) == 2 + elif flag & SF_GCC_X86_BITFIELDS: + assert sizeof(BStruct) == 5 + assert alignof(BStruct) == 1 + elif flag & SF_GCC_ARM_BITFIELDS: + assert sizeof(BStruct) == 6 + assert alignof(BStruct) == 2 + else: + raise AssertionError("bad flag") + # + BStruct = new_struct_type("struct foo2") + complete_struct_or_union(BStruct, [('a', BChar, -1), + ('', BInt, 0), + ('', BInt, 0), + ('c', BChar, -1)], -1, -1, -1, flag) + if flag & SF_MSVC_BITFIELDS: + assert typeoffsetof(BStruct, 'c') == (BChar, 1) + assert sizeof(BStruct) == 2 + assert alignof(BStruct) == 1 + elif flag & SF_GCC_X86_BITFIELDS: + assert typeoffsetof(BStruct, 'c') == (BChar, 4) + assert sizeof(BStruct) == 5 + assert alignof(BStruct) == 1 + elif flag & SF_GCC_ARM_BITFIELDS: + assert typeoffsetof(BStruct, 'c') == (BChar, 4) + assert sizeof(BStruct) == 8 + assert alignof(BStruct) == 4 + else: + raise AssertionError("bad flag") + + +SF_MSVC_BITFIELDS = 0x01 +SF_GCC_ARM_BITFIELDS = 0x02 +SF_GCC_X86_BITFIELDS = 0x10 + +SF_GCC_BIG_ENDIAN = 0x04 +SF_GCC_LITTLE_ENDIAN = 0x40 + +SF_PACKED = 0x08 + +def test_bitfield_as_x86_gcc(): + _test_bitfield_details(flag=SF_GCC_X86_BITFIELDS|SF_GCC_LITTLE_ENDIAN) + +def test_bitfield_as_msvc(): + _test_bitfield_details(flag=SF_MSVC_BITFIELDS|SF_GCC_LITTLE_ENDIAN) + +def test_bitfield_as_arm_gcc(): + _test_bitfield_details(flag=SF_GCC_ARM_BITFIELDS|SF_GCC_LITTLE_ENDIAN) + +def test_bitfield_as_ppc_gcc(): + # PowerPC uses the same format as X86, but is big-endian + _test_bitfield_details(flag=SF_GCC_X86_BITFIELDS|SF_GCC_BIG_ENDIAN) + + +def test_struct_array_no_length(): + BInt = new_primitive_type("int") + BIntP = new_pointer_type(BInt) + BArray = new_array_type(BIntP, None) + BStruct = new_struct_type("foo") + py.test.raises(TypeError, complete_struct_or_union, + BStruct, [('x', BArray), + ('y', BInt)]) + # + BStruct = new_struct_type("foo") + complete_struct_or_union(BStruct, [('x', BInt), + ('y', BArray)]) + assert sizeof(BStruct) == size_of_int() + d = BStruct.fields + assert len(d) == 2 + assert d[0][0] == 'x' + assert d[0][1].type is BInt + assert d[0][1].offset == 0 + assert d[0][1].bitshift == -1 + assert d[0][1].bitsize == -1 + assert d[1][0] == 'y' + assert d[1][1].type is BArray + assert d[1][1].offset == size_of_int() + assert d[1][1].bitshift == -2 + assert d[1][1].bitsize == -1 + # + p = newp(new_pointer_type(BStruct)) + p.x = 42 + assert p.x == 42 + assert typeof(p.y) is BArray + assert len(p.y) == 0 + assert p.y == cast(BIntP, p) + 1 + # + p = newp(new_pointer_type(BStruct), [100]) + assert p.x == 100 + assert len(p.y) == 0 + # + # Tests for + # ffi.new("struct_with_var_array *", [field.., [the_array_items..]]) + # ffi.new("struct_with_var_array *", [field.., array_size]) + plist = [] + for i in range(20): + if i % 2 == 0: + p = newp(new_pointer_type(BStruct), [100, [200, i, 400]]) + else: + p = newp(new_pointer_type(BStruct), [100, 3]) + p.y[1] = i + p.y[0] = 200 + assert p.y[2] == 0 + p.y[2] = 400 + assert len(p.y) == 3 + assert len(p[0].y) == 3 + assert len(buffer(p)) == sizeof(BInt) * 4 + assert sizeof(p[0]) == sizeof(BInt) * 4 + plist.append(p) + for i in range(20): + p = plist[i] + assert p.x == 100 + assert p.y[0] == 200 + assert p.y[1] == i + assert p.y[2] == 400 + assert list(p.y) == [200, i, 400] + # + # the following assignment works, as it normally would, for any array field + p.y = [501, 601] + assert list(p.y) == [501, 601, 400] + p[0].y = [500, 600] + assert list(p[0].y) == [500, 600, 400] + assert repr(p) == "<cdata 'foo *' owning %d bytes>" % ( + sizeof(BStruct) + 3 * sizeof(BInt),) + assert repr(p[0]) == "<cdata 'foo' owning %d bytes>" % ( + sizeof(BStruct) + 3 * sizeof(BInt),) + assert sizeof(p[0]) == sizeof(BStruct) + 3 * sizeof(BInt) + # + # from a non-owning pointer, we can't get the length + q = cast(new_pointer_type(BStruct), p) + assert q.y[0] == 500 + assert q[0].y[0] == 500 + py.test.raises(TypeError, len, q.y) + py.test.raises(TypeError, len, q[0].y) + assert typeof(q.y) is BIntP + assert typeof(q[0].y) is BIntP + assert sizeof(q[0]) == sizeof(BStruct) + # + # error cases + py.test.raises(IndexError, "p.y[4]") + py.test.raises(TypeError, "p.y = cast(BIntP, 0)") + py.test.raises(TypeError, "p.y = 15") + py.test.raises(TypeError, "p.y = None") + # + # accepting this may be specified by the C99 standard, + # or a GCC strangeness... + BStruct2 = new_struct_type("bar") + complete_struct_or_union(BStruct2, [('f', BStruct), + ('n', BInt)]) + p = newp(new_pointer_type(BStruct2), {'n': 42}) + assert p.n == 42 + # + # more error cases + py.test.raises(TypeError, newp, new_pointer_type(BStruct), [100, None]) + BArray4 = new_array_type(BIntP, 4) + BStruct4 = new_struct_type("test4") + complete_struct_or_union(BStruct4, [('a', BArray4)]) # not varsized + py.test.raises(TypeError, newp, new_pointer_type(BStruct4), [None]) + py.test.raises(TypeError, newp, new_pointer_type(BStruct4), [4]) + p = newp(new_pointer_type(BStruct4), [[10, 20, 30]]) + assert p.a[0] == 10 + assert p.a[1] == 20 + assert p.a[2] == 30 + assert p.a[3] == 0 + +def test_struct_array_no_length_explicit_position(): + BInt = new_primitive_type("int") + BIntP = new_pointer_type(BInt) + BArray = new_array_type(BIntP, None) + BStruct = new_struct_type("foo") + complete_struct_or_union(BStruct, [('x', BArray, -1, 0), # actually 3 items + ('y', BInt, -1, 12)]) + p = newp(new_pointer_type(BStruct), [[10, 20], 30]) + assert p.x[0] == 10 + assert p.x[1] == 20 + assert p.x[2] == 0 + assert p.y == 30 + p = newp(new_pointer_type(BStruct), {'x': [40], 'y': 50}) + assert p.x[0] == 40 + assert p.x[1] == 0 + assert p.x[2] == 0 + assert p.y == 50 + p = newp(new_pointer_type(BStruct), {'y': 60}) + assert p.x[0] == 0 + assert p.x[1] == 0 + assert p.x[2] == 0 + assert p.y == 60 + # + # This "should" work too, allocating a larger structure + # (a bit strange in this case, but useful in general) + plist = [] + for i in range(20): + p = newp(new_pointer_type(BStruct), [[10, 20, 30, 40, 50, 60, 70]]) + plist.append(p) + for i in range(20): + p = plist[i] + assert p.x[0] == 10 + assert p.x[1] == 20 + assert p.x[2] == 30 + assert p.x[3] == 40 == p.y + assert p.x[4] == 50 + assert p.x[5] == 60 + assert p.x[6] == 70 + +def test_struct_array_not_aligned(): + # struct a { int x; char y; char z[]; }; + # ends up of size 8, but 'z' is at offset 5 + BChar = new_primitive_type("char") + BInt = new_primitive_type("int") + BCharP = new_pointer_type(BChar) + BArray = new_array_type(BCharP, None) + BStruct = new_struct_type("foo") + complete_struct_or_union(BStruct, [('x', BInt), + ('y', BChar), + ('z', BArray)]) + assert sizeof(BStruct) == 2 * size_of_int() + def offsetof(BType, fieldname): + return typeoffsetof(BType, fieldname)[1] + base = offsetof(BStruct, 'z') + assert base == size_of_int() + 1 + # + p = newp(new_pointer_type(BStruct), {'z': 3}) + assert sizeof(p[0]) == base + 3 + q = newp(new_pointer_type(BStruct), {'z': size_of_int()}) + assert sizeof(q) == size_of_ptr() + assert sizeof(q[0]) == base + size_of_int() + assert len(p.z) == 3 + assert len(p[0].z) == 3 + assert len(q.z) == size_of_int() + assert len(q[0].z) == size_of_int() + +def test_ass_slice(): + BChar = new_primitive_type("char") + BArray = new_array_type(new_pointer_type(BChar), None) + p = newp(BArray, b"foobar") + p[2:5] = [b"*", b"Z", b"T"] + p[1:3] = b"XY" + assert list(p) == [b"f", b"X", b"Y", b"Z", b"T", b"r", b"\x00"] + py.test.raises(TypeError, "p[1:5] = u+'XYZT'") + py.test.raises(TypeError, "p[1:5] = [1, 2, 3, 4]") + # + for typename in ["wchar_t", "char16_t", "char32_t"]: + BUniChar = new_primitive_type(typename) + BArray = new_array_type(new_pointer_type(BUniChar), None) + p = newp(BArray, u+"foobar") + p[2:5] = [u+"*", u+"Z", u+"T"] + p[1:3] = u+"XY" + assert list(p) == [u+"f", u+"X", u+"Y", u+"Z", u+"T", u+"r", u+"\x00"] + py.test.raises(TypeError, "p[1:5] = b'XYZT'") + py.test.raises(TypeError, "p[1:5] = [1, 2, 3, 4]") + +def test_void_p_arithmetic(): + BVoid = new_void_type() + BInt = new_primitive_type("intptr_t") + p = cast(new_pointer_type(BVoid), 100000) + assert int(cast(BInt, p)) == 100000 + assert int(cast(BInt, p + 42)) == 100042 + assert int(cast(BInt, p - (-42))) == 100042 + assert (p + 42) - p == 42 + q = cast(new_pointer_type(new_primitive_type("char")), 100000) + py.test.raises(TypeError, "p - q") + py.test.raises(TypeError, "q - p") + py.test.raises(TypeError, "p + cast(new_primitive_type('int'), 42)") + py.test.raises(TypeError, "p - cast(new_primitive_type('int'), 42)") + +def test_sizeof_sliced_array(): + BInt = new_primitive_type("int") + BArray = new_array_type(new_pointer_type(BInt), 10) + p = newp(BArray, None) + assert sizeof(p[2:9]) == 7 * sizeof(BInt) + +def test_packed(): + BLong = new_primitive_type("long") + BChar = new_primitive_type("char") + BShort = new_primitive_type("short") + for extra_args in [(SF_PACKED,), (0, 1)]: + BStruct = new_struct_type("struct foo") + complete_struct_or_union(BStruct, [('a1', BLong, -1), + ('a2', BChar, -1), + ('a3', BShort, -1)], + None, -1, -1, *extra_args) + d = BStruct.fields + assert len(d) == 3 + assert d[0][0] == 'a1' + assert d[0][1].type is BLong + assert d[0][1].offset == 0 + assert d[0][1].bitshift == -1 + assert d[0][1].bitsize == -1 + assert d[1][0] == 'a2' + assert d[1][1].type is BChar + assert d[1][1].offset == sizeof(BLong) + assert d[1][1].bitshift == -1 + assert d[1][1].bitsize == -1 + assert d[2][0] == 'a3' + assert d[2][1].type is BShort + assert d[2][1].offset == sizeof(BLong) + sizeof(BChar) + assert d[2][1].bitshift == -1 + assert d[2][1].bitsize == -1 + assert sizeof(BStruct) == sizeof(BLong) + sizeof(BChar) + sizeof(BShort) + assert alignof(BStruct) == 1 + # + BStruct2 = new_struct_type("struct foo") + complete_struct_or_union(BStruct2, [('b1', BChar, -1), + ('b2', BLong, -1)], + None, -1, -1, 0, 2) + d = BStruct2.fields + assert len(d) == 2 + assert d[0][0] == 'b1' + assert d[0][1].type is BChar + assert d[0][1].offset == 0 + assert d[0][1].bitshift == -1 + assert d[0][1].bitsize == -1 + assert d[1][0] == 'b2' + assert d[1][1].type is BLong + assert d[1][1].offset == 2 + assert d[1][1].bitshift == -1 + assert d[1][1].bitsize == -1 + assert sizeof(BStruct2) == 2 + sizeof(BLong) + assert alignof(BStruct2) == 2 + +def test_packed_with_bitfields(): + if sys.platform == "win32": + py.test.skip("testing gcc behavior") + BLong = new_primitive_type("long") + BChar = new_primitive_type("char") + BStruct = new_struct_type("struct foo") + py.test.raises(NotImplementedError, + complete_struct_or_union, + BStruct, [('a1', BLong, 30), + ('a2', BChar, 5)], + None, -1, -1, SF_PACKED) + +def test_from_buffer(): + import array + a = array.array('H', [10000, 20000, 30000]) + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BCharA = new_array_type(BCharP, None) + c = from_buffer(BCharA, a) + assert typeof(c) is BCharA + assert len(c) == 6 + assert repr(c) == "<cdata 'char[]' buffer len 6 from 'array.array' object>" + p = new_pointer_type(new_primitive_type("unsigned short")) + cast(p, c)[1] += 500 + assert list(a) == [10000, 20500, 30000] + +def test_from_buffer_not_str_unicode(): + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BCharA = new_array_type(BCharP, None) + p1 = from_buffer(BCharA, b"foo") + assert p1 == from_buffer(BCharA, b"foo") + import gc; gc.collect() + assert p1 == from_buffer(BCharA, b"foo") + py.test.raises(TypeError, from_buffer, BCharA, u+"foo") + try: + from __builtin__ import buffer + except ImportError: + pass + else: + # Python 2 only + contents = from_buffer(BCharA, buffer(b"foo")) + assert len(contents) == len(p1) + for i in range(len(contents)): + assert contents[i] == p1[i] + p4 = buffer(u+"foo") + contents = from_buffer(BCharA, buffer(u+"foo")) + assert len(contents) == len(p4) + for i in range(len(contents)): + assert contents[i] == p4[i] + try: + from __builtin__ import memoryview + except ImportError: + pass + else: + contents = from_buffer(BCharA, memoryview(b"foo")) + assert len(contents) == len(p1) + for i in range(len(contents)): + assert contents[i] == p1[i] + + +def test_from_buffer_bytearray(): + a = bytearray(b"xyz") + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BCharA = new_array_type(BCharP, None) + p = from_buffer(BCharA, a) + assert typeof(p) is BCharA + assert len(p) == 3 + assert repr(p) == "<cdata 'char[]' buffer len 3 from 'bytearray' object>" + assert p[2] == b"z" + p[2] = b"." + assert a[2] == ord(".") + a[2] = ord("?") + assert p[2] == b"?" + +def test_from_buffer_more_cases(): + try: + from _cffi_backend import _testbuff + except ImportError: + py.test.skip("not for pypy") + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BCharA = new_array_type(BCharP, None) + # + def check1(bufobj, expected): + c = from_buffer(BCharA, bufobj) + assert typeof(c) is BCharA + if sys.version_info >= (3,): + expected = [bytes(c, "ascii") for c in expected] + assert list(c) == list(expected) + # + def check(methods, expected, expected_for_memoryview=None): + if sys.version_info >= (3,): + if methods <= 7: + return + if expected_for_memoryview is not None: + expected = expected_for_memoryview + class X(object): + pass + _testbuff(X, methods) + bufobj = X() + check1(bufobj, expected) + try: + from __builtin__ import buffer + bufobjb = buffer(bufobj) + except (TypeError, ImportError): + pass + else: + check1(bufobjb, expected) + try: + bufobjm = memoryview(bufobj) + except (TypeError, NameError): + pass + else: + check1(bufobjm, expected_for_memoryview or expected) + # + check(1, "RDB") + check(2, "WRB") + check(4, "CHB") + check(8, "GTB") + check(16, "ROB") + # + check(1 | 2, "RDB") + check(1 | 4, "RDB") + check(2 | 4, "CHB") + check(1 | 8, "RDB", "GTB") + check(1 | 16, "RDB", "ROB") + check(2 | 8, "WRB", "GTB") + check(2 | 16, "WRB", "ROB") + check(4 | 8, "CHB", "GTB") + check(4 | 16, "CHB", "ROB") + +def test_from_buffer_require_writable(): + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BCharA = new_array_type(BCharP, None) + p1 = from_buffer(BCharA, b"foo", False) + assert p1 == from_buffer(BCharA, b"foo", False) + py.test.raises((TypeError, BufferError), from_buffer, BCharA, b"foo", True) + ba = bytearray(b"foo") + p1 = from_buffer(BCharA, ba, True) + p1[0] = b"g" + assert ba == b"goo" + +def test_from_buffer_types(): + BInt = new_primitive_type("int") + BIntP = new_pointer_type(BInt) + BIntA = new_array_type(BIntP, None) + lst = [-12345678, 87654321, 489148] + bytestring = buffer(newp(BIntA, lst))[:] + b'XYZ' + # + p1 = from_buffer(BIntA, bytestring) # int[] + assert typeof(p1) is BIntA + assert len(p1) == 3 + assert p1[0] == lst[0] + assert p1[1] == lst[1] + assert p1[2] == lst[2] + py.test.raises(IndexError, "p1[3]") + py.test.raises(IndexError, "p1[-1]") + # + py.test.raises(TypeError, from_buffer, BInt, bytestring) + py.test.raises(TypeError, from_buffer, BIntP, bytestring) + # + BIntA2 = new_array_type(BIntP, 2) + p2 = from_buffer(BIntA2, bytestring) # int[2] + assert typeof(p2) is BIntA2 + assert len(p2) == 2 + assert p2[0] == lst[0] + assert p2[1] == lst[1] + py.test.raises(IndexError, "p2[2]") + py.test.raises(IndexError, "p2[-1]") + assert p2 == p1 + # + BIntA4 = new_array_type(BIntP, 4) # int[4]: too big + py.test.raises(ValueError, from_buffer, BIntA4, bytestring) + # + BStruct = new_struct_type("foo") + complete_struct_or_union(BStruct, [('a1', BInt, -1), + ('a2', BInt, -1)]) + BStructP = new_pointer_type(BStruct) + BStructA = new_array_type(BStructP, None) + p1 = from_buffer(BStructA, bytestring) # struct[] + assert len(p1) == 1 + assert typeof(p1) is BStructA + assert p1[0].a1 == lst[0] + assert p1[0].a2 == lst[1] + py.test.raises(IndexError, "p1[1]") + # + BEmptyStruct = new_struct_type("empty") + complete_struct_or_union(BEmptyStruct, [], Ellipsis, 0) + assert sizeof(BEmptyStruct) == 0 + BEmptyStructP = new_pointer_type(BEmptyStruct) + BEmptyStructA = new_array_type(BEmptyStructP, None) + py.test.raises(ZeroDivisionError, from_buffer, # empty[] + BEmptyStructA, bytestring) + # + BEmptyStructA5 = new_array_type(BEmptyStructP, 5) + p1 = from_buffer(BEmptyStructA5, bytestring) # struct empty[5] + assert typeof(p1) is BEmptyStructA5 + assert len(p1) == 5 + assert cast(BIntP, p1) == from_buffer(BIntA, bytestring) + +def test_memmove(): + Short = new_primitive_type("short") + ShortA = new_array_type(new_pointer_type(Short), None) + Char = new_primitive_type("char") + CharA = new_array_type(new_pointer_type(Char), None) + p = newp(ShortA, [-1234, -2345, -3456, -4567, -5678]) + memmove(p, p + 1, 4) + assert list(p) == [-2345, -3456, -3456, -4567, -5678] + p[2] = 999 + memmove(p + 2, p, 6) + assert list(p) == [-2345, -3456, -2345, -3456, 999] + memmove(p + 4, newp(CharA, b"\x71\x72"), 2) + if sys.byteorder == 'little': + assert list(p) == [-2345, -3456, -2345, -3456, 0x7271] + else: + assert list(p) == [-2345, -3456, -2345, -3456, 0x7172] + +def test_memmove_buffer(): + import array + Short = new_primitive_type("short") + ShortA = new_array_type(new_pointer_type(Short), None) + a = array.array('H', [10000, 20000, 30000]) + p = newp(ShortA, 5) + memmove(p, a, 6) + assert list(p) == [10000, 20000, 30000, 0, 0] + memmove(p + 1, a, 6) + assert list(p) == [10000, 10000, 20000, 30000, 0] + b = array.array('h', [-1000, -2000, -3000]) + memmove(b, a, 4) + assert b.tolist() == [10000, 20000, -3000] + assert a.tolist() == [10000, 20000, 30000] + p[0] = 999 + p[1] = 998 + p[2] = 997 + p[3] = 996 + p[4] = 995 + memmove(b, p, 2) + assert b.tolist() == [999, 20000, -3000] + memmove(b, p + 2, 4) + assert b.tolist() == [997, 996, -3000] + p[2] = -p[2] + p[3] = -p[3] + memmove(b, p + 2, 6) + assert b.tolist() == [-997, -996, 995] + +def test_memmove_readonly_readwrite(): + SignedChar = new_primitive_type("signed char") + SignedCharA = new_array_type(new_pointer_type(SignedChar), None) + p = newp(SignedCharA, 5) + memmove(p, b"abcde", 3) + assert list(p) == [ord("a"), ord("b"), ord("c"), 0, 0] + memmove(p, bytearray(b"ABCDE"), 2) + assert list(p) == [ord("A"), ord("B"), ord("c"), 0, 0] + py.test.raises((TypeError, BufferError), memmove, b"abcde", p, 3) + ba = bytearray(b"xxxxx") + memmove(dest=ba, src=p, n=3) + assert ba == bytearray(b"ABcxx") + memmove(ba, b"EFGH", 4) + assert ba == bytearray(b"EFGHx") + +def test_memmove_sign_check(): + SignedChar = new_primitive_type("signed char") + SignedCharA = new_array_type(new_pointer_type(SignedChar), None) + p = newp(SignedCharA, 5) + py.test.raises(ValueError, memmove, p, p + 1, -1) # not segfault + +def test_memmove_bad_cdata(): + BInt = new_primitive_type("int") + p = cast(BInt, 42) + py.test.raises(TypeError, memmove, p, bytearray(b'a'), 1) + py.test.raises(TypeError, memmove, bytearray(b'a'), p, 1) + +def test_dereference_null_ptr(): + BInt = new_primitive_type("int") + BIntPtr = new_pointer_type(BInt) + p = cast(BIntPtr, 0) + py.test.raises(RuntimeError, "p[0]") + py.test.raises(RuntimeError, "p[0] = 42") + py.test.raises(RuntimeError, "p[42]") + py.test.raises(RuntimeError, "p[42] = -1") + +def test_mixup(): + BStruct1 = new_struct_type("foo") + BStruct2 = new_struct_type("foo") # <= same name as BStruct1 + BStruct3 = new_struct_type("bar") + BStruct1Ptr = new_pointer_type(BStruct1) + BStruct2Ptr = new_pointer_type(BStruct2) + BStruct3Ptr = new_pointer_type(BStruct3) + BStruct1PtrPtr = new_pointer_type(BStruct1Ptr) + BStruct2PtrPtr = new_pointer_type(BStruct2Ptr) + BStruct3PtrPtr = new_pointer_type(BStruct3Ptr) + pp1 = newp(BStruct1PtrPtr) + pp2 = newp(BStruct2PtrPtr) + pp3 = newp(BStruct3PtrPtr) + pp1[0] = pp1[0] + e = py.test.raises(TypeError, "pp3[0] = pp1[0]") + assert str(e.value).startswith("initializer for ctype 'bar *' must be a ") + assert str(e.value).endswith(", not cdata 'foo *'") + e = py.test.raises(TypeError, "pp2[0] = pp1[0]") + assert str(e.value) == ("initializer for ctype 'foo *' appears indeed to " + "be 'foo *', but the types are different (check " + "that you are not e.g. mixing up different ffi " + "instances)") + +def test_stdcall_function_type(): + assert FFI_CDECL == FFI_DEFAULT_ABI + try: + stdcall = FFI_STDCALL + except NameError: + stdcall = FFI_DEFAULT_ABI + BInt = new_primitive_type("int") + BFunc = new_function_type((BInt, BInt), BInt, False, stdcall) + if stdcall != FFI_DEFAULT_ABI: + assert repr(BFunc) == "<ctype 'int(__stdcall *)(int, int)'>" + else: + assert repr(BFunc) == "<ctype 'int(*)(int, int)'>" + +def test_get_common_types(): + d = {} + _get_common_types(d) + assert d['bool'] == '_Bool' + +def test_unpack(): + BChar = new_primitive_type("char") + BArray = new_array_type(new_pointer_type(BChar), 10) # char[10] + p = newp(BArray, b"abc\x00def") + p0 = p + assert unpack(p, 10) == b"abc\x00def\x00\x00\x00" + assert unpack(p+1, 5) == b"bc\x00de" + + for typename in ["wchar_t", "char16_t", "char32_t"]: + BWChar = new_primitive_type(typename) + BArray = new_array_type(new_pointer_type(BWChar), 10) # wchar_t[10] + p = newp(BArray, u"abc\x00def") + assert unpack(p, 10) == u"abc\x00def\x00\x00\x00" + + for typename, samples in [ + ("uint8_t", [0, 2**8-1]), + ("uint16_t", [0, 2**16-1]), + ("uint32_t", [0, 2**32-1]), + ("uint64_t", [0, 2**64-1]), + ("int8_t", [-2**7, 2**7-1]), + ("int16_t", [-2**15, 2**15-1]), + ("int32_t", [-2**31, 2**31-1]), + ("int64_t", [-2**63, 2**63-1]), + ("_Bool", [False, True]), + ("float", [0.0, 10.5]), + ("double", [12.34, 56.78]), + ]: + BItem = new_primitive_type(typename) + BArray = new_array_type(new_pointer_type(BItem), 10) + p = newp(BArray, samples) + result = unpack(p, len(samples)) + assert result == samples + for i in range(len(samples)): + assert result[i] == p[i] and type(result[i]) is type(p[i]) + assert (type(result[i]) is bool) == (type(samples[i]) is bool) + # + BInt = new_primitive_type("int") + py.test.raises(TypeError, unpack, p) + py.test.raises(TypeError, unpack, b"foobar", 6) + py.test.raises(TypeError, unpack, cast(BInt, 42), 1) + # + BPtr = new_pointer_type(BInt) + random_ptr = cast(BPtr, -424344) + other_ptr = cast(BPtr, 54321) + BArray = new_array_type(new_pointer_type(BPtr), None) + lst = unpack(newp(BArray, [random_ptr, other_ptr]), 2) + assert lst == [random_ptr, other_ptr] + # + BFunc = new_function_type((BInt, BInt), BInt, False) + BFuncPtr = new_pointer_type(BFunc) + lst = unpack(newp(new_array_type(BFuncPtr, None), 2), 2) + assert len(lst) == 2 + assert not lst[0] and not lst[1] + assert typeof(lst[0]) is BFunc + # + BStruct = new_struct_type("foo") + BStructPtr = new_pointer_type(BStruct) + e = py.test.raises(ValueError, unpack, cast(BStructPtr, 42), 5) + assert str(e.value) == "'foo *' points to items of unknown size" + complete_struct_or_union(BStruct, [('a1', BInt, -1), + ('a2', BInt, -1)]) + array_of_structs = newp(new_array_type(BStructPtr, None), [[4,5], [6,7]]) + lst = unpack(array_of_structs, 2) + assert typeof(lst[0]) is BStruct + assert lst[0].a1 == 4 and lst[1].a2 == 7 + # + py.test.raises(RuntimeError, unpack, cast(new_pointer_type(BChar), 0), 0) + py.test.raises(RuntimeError, unpack, cast(new_pointer_type(BChar), 0), 10) + # + py.test.raises(ValueError, unpack, p0, -1) + py.test.raises(ValueError, unpack, p, -1) + +def test_cdata_dir(): + BInt = new_primitive_type("int") + p = cast(BInt, 42) + check_dir(p, []) + p = newp(new_array_type(new_pointer_type(BInt), None), 5) + check_dir(p, []) + BStruct = new_struct_type("foo") + p = cast(new_pointer_type(BStruct), 0) + check_dir(p, []) # opaque + complete_struct_or_union(BStruct, [('a2', BInt, -1), + ('a1', BInt, -1)]) + check_dir(p, ['a1', 'a2']) # always sorted + p = newp(new_pointer_type(BStruct), None) + check_dir(p, ['a1', 'a2']) + check_dir(p[0], ['a1', 'a2']) + pp = newp(new_pointer_type(new_pointer_type(BStruct)), p) + check_dir(pp, []) + check_dir(pp[0], ['a1', 'a2']) + check_dir(pp[0][0], ['a1', 'a2']) + +def test_char_pointer_conversion(): + import warnings + assert __version__.startswith("1."), ( + "the warning will be an error if we ever release cffi 2.x") + BCharP = new_pointer_type(new_primitive_type("char")) + BIntP = new_pointer_type(new_primitive_type("int")) + BVoidP = new_pointer_type(new_void_type()) + BUCharP = new_pointer_type(new_primitive_type("unsigned char")) + z1 = cast(BCharP, 0) + z2 = cast(BIntP, 0) + z3 = cast(BVoidP, 0) + z4 = cast(BUCharP, 0) + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always") + newp(new_pointer_type(BIntP), z1) # warn + assert len(w) == 1 + newp(new_pointer_type(BVoidP), z1) # fine + assert len(w) == 1 + newp(new_pointer_type(BCharP), z2) # warn + assert len(w) == 2 + newp(new_pointer_type(BVoidP), z2) # fine + assert len(w) == 2 + newp(new_pointer_type(BCharP), z3) # fine + assert len(w) == 2 + newp(new_pointer_type(BIntP), z3) # fine + assert len(w) == 2 + newp(new_pointer_type(BCharP), z4) # fine (ignore signedness here) + assert len(w) == 2 + newp(new_pointer_type(BUCharP), z1) # fine (ignore signedness here) + assert len(w) == 2 + newp(new_pointer_type(BUCharP), z3) # fine + assert len(w) == 2 + # check that the warnings are associated with lines in this file + assert w[1].lineno == w[0].lineno + 4 + +def test_primitive_comparison(): + def assert_eq(a, b): + assert (a == b) is True + assert (b == a) is True + assert (a != b) is False + assert (b != a) is False + assert (a < b) is False + assert (a <= b) is True + assert (a > b) is False + assert (a >= b) is True + assert (b < a) is False + assert (b <= a) is True + assert (b > a) is False + assert (b >= a) is True + assert hash(a) == hash(b) + def assert_lt(a, b, check_hash=True): + assert (a == b) is False + assert (b == a) is False + assert (a != b) is True + assert (b != a) is True + assert (a < b) is True + assert (a <= b) is True + assert (a > b) is False + assert (a >= b) is False + assert (b < a) is False + assert (b <= a) is False + assert (b > a) is True + assert (b >= a) is True + if check_hash: + assert hash(a) != hash(b) # (or at least, it is unlikely) + def assert_gt(a, b, check_hash=True): + assert_lt(b, a, check_hash) + def assert_ne(a, b): + assert (a == b) is False + assert (b == a) is False + assert (a != b) is True + assert (b != a) is True + if strict_compare: + py.test.raises(TypeError, "a < b") + py.test.raises(TypeError, "a <= b") + py.test.raises(TypeError, "a > b") + py.test.raises(TypeError, "a >= b") + py.test.raises(TypeError, "b < a") + py.test.raises(TypeError, "b <= a") + py.test.raises(TypeError, "b > a") + py.test.raises(TypeError, "b >= a") + elif a < b: + assert_lt(a, b) + else: + assert_lt(b, a) + assert_eq(5, 5) + assert_lt(3, 5) + assert_ne('5', 5) + # + t1 = new_primitive_type("char") + t2 = new_primitive_type("int") + t3 = new_primitive_type("unsigned char") + t4 = new_primitive_type("unsigned int") + t5 = new_primitive_type("float") + t6 = new_primitive_type("double") + assert_eq(cast(t1, 65), b'A') + assert_lt(cast(t1, 64), b'\x99') + assert_gt(cast(t1, 200), b'A') + assert_ne(cast(t1, 65), 65) + assert_eq(cast(t2, -25), -25) + assert_lt(cast(t2, -25), -24) + assert_gt(cast(t2, -25), -26) + assert_eq(cast(t3, 65), 65) + assert_ne(cast(t3, 65), b'A') + assert_ne(cast(t3, 65), cast(t1, 65)) + assert_gt(cast(t4, -1), -1, check_hash=False) + assert_gt(cast(t4, -1), cast(t2, -1), check_hash=False) + assert_gt(cast(t4, -1), 99999) + assert_eq(cast(t4, -1), 256 ** size_of_int() - 1) + assert_eq(cast(t5, 3.0), 3) + assert_eq(cast(t5, 3.5), 3.5) + assert_lt(cast(t5, 3.3), 3.3) # imperfect rounding + assert_eq(cast(t6, 3.3), 3.3) + assert_eq(cast(t5, 3.5), cast(t6, 3.5)) + assert_lt(cast(t5, 3.1), cast(t6, 3.1)) # imperfect rounding + assert_eq(cast(t5, 7.0), cast(t3, 7)) + assert_lt(cast(t5, 3.1), 3.101) + assert_gt(cast(t5, 3.1), 3) + +def test_explicit_release_new(): + # release() on a ffi.new() object has no effect on CPython, but + # really releases memory on PyPy. We can't test that effect + # though, because a released cdata is not marked. + BIntP = new_pointer_type(new_primitive_type("int")) + p = newp(BIntP) + p[0] = 42 + py.test.raises(IndexError, "p[1]") + release(p) + # here, reading p[0] might give garbage or segfault... + release(p) # no effect + # + BStruct = new_struct_type("struct foo") + BStructP = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('p', BIntP, -1)]) + pstruct = newp(BStructP) + assert pstruct.p == cast(BIntP, 0) + release(pstruct) + # here, reading pstruct.p might give garbage or segfault... + release(pstruct) # no effect + +def test_explicit_release_new_contextmgr(): + BIntP = new_pointer_type(new_primitive_type("int")) + with newp(BIntP) as p: + p[0] = 42 + assert p[0] == 42 + # here, reading p[0] might give garbage or segfault... + release(p) # no effect + +def test_explicit_release_badtype(): + BIntP = new_pointer_type(new_primitive_type("int")) + p = cast(BIntP, 12345) + py.test.raises(ValueError, release, p) + py.test.raises(ValueError, release, p) + BStruct = new_struct_type("struct foo") + BStructP = new_pointer_type(BStruct) + complete_struct_or_union(BStruct, [('p', BIntP, -1)]) + pstruct = newp(BStructP) + py.test.raises(ValueError, release, pstruct[0]) + +def test_explicit_release_badtype_contextmgr(): + BIntP = new_pointer_type(new_primitive_type("int")) + p = cast(BIntP, 12345) + py.test.raises(ValueError, "with p: pass") + py.test.raises(ValueError, "with p: pass") + +def test_explicit_release_gc(): + BIntP = new_pointer_type(new_primitive_type("int")) + seen = [] + intp1 = newp(BIntP, 12345) + p1 = cast(BIntP, intp1) + p = gcp(p1, seen.append) + assert seen == [] + release(p) + assert seen == [p1] + assert p1[0] == 12345 + assert p[0] == 12345 # true so far, but might change to raise RuntimeError + release(p) # no effect + +def test_explicit_release_gc_contextmgr(): + BIntP = new_pointer_type(new_primitive_type("int")) + seen = [] + intp1 = newp(BIntP, 12345) + p1 = cast(BIntP, intp1) + p = gcp(p1, seen.append) + with p: + assert p[0] == 12345 + assert seen == [] + assert seen == [p1] + assert p1[0] == 12345 + assert p[0] == 12345 # true so far, but might change to raise RuntimeError + release(p) # no effect + +def test_explicit_release_from_buffer(): + a = bytearray(b"xyz") + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BCharA = new_array_type(BCharP, None) + p = from_buffer(BCharA, a) + assert p[2] == b"z" + release(p) + assert p[2] == b"z" # true so far, but might change to raise RuntimeError + release(p) # no effect + +def test_explicit_release_from_buffer_contextmgr(): + a = bytearray(b"xyz") + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BCharA = new_array_type(BCharP, None) + p = from_buffer(BCharA, a) + with p: + assert p[2] == b"z" + assert p[2] == b"z" # true so far, but might change to raise RuntimeError + release(p) # no effect + +def test_explicit_release_bytearray_on_cpython(): + if '__pypy__' in sys.builtin_module_names: + py.test.skip("pypy's bytearray are never locked") + a = bytearray(b"xyz") + BChar = new_primitive_type("char") + BCharP = new_pointer_type(BChar) + BCharA = new_array_type(BCharP, None) + a += b't' * 10 + p = from_buffer(BCharA, a) + py.test.raises(BufferError, "a += b'u' * 100") + release(p) + a += b'v' * 100 + release(p) # no effect + a += b'w' * 1000 + assert a == bytearray(b"xyz" + b't' * 10 + b'v' * 100 + b'w' * 1000) |