summaryrefslogtreecommitdiff
path: root/testing/cffi1/test_new_ffi_1.py
diff options
context:
space:
mode:
Diffstat (limited to 'testing/cffi1/test_new_ffi_1.py')
-rw-r--r--testing/cffi1/test_new_ffi_1.py1831
1 files changed, 0 insertions, 1831 deletions
diff --git a/testing/cffi1/test_new_ffi_1.py b/testing/cffi1/test_new_ffi_1.py
deleted file mode 100644
index 640830b..0000000
--- a/testing/cffi1/test_new_ffi_1.py
+++ /dev/null
@@ -1,1831 +0,0 @@
-import py
-import pytest
-import platform, imp
-import sys, os, ctypes
-import cffi
-from testing.udir import udir
-from testing.support import *
-from cffi.recompiler import recompile
-from cffi.cffi_opcode import PRIMITIVE_TO_INDEX
-
-SIZE_OF_INT = ctypes.sizeof(ctypes.c_int)
-SIZE_OF_LONG = ctypes.sizeof(ctypes.c_long)
-SIZE_OF_SHORT = ctypes.sizeof(ctypes.c_short)
-SIZE_OF_PTR = ctypes.sizeof(ctypes.c_void_p)
-SIZE_OF_WCHAR = ctypes.sizeof(ctypes.c_wchar)
-
-
-def setup_module():
- global ffi, construction_params
- ffi1 = cffi.FFI()
- DEFS = r"""
- struct repr { short a, b, c; };
- struct simple { int a; short b, c; };
- struct array { int a[2]; char b[3]; };
- struct recursive { int value; struct recursive *next; };
- union simple_u { int a; short b, c; };
- union init_u { char a; int b; };
- struct four_s { int a; short b, c, d; };
- union four_u { int a; short b, c, d; };
- struct string { const char *name; };
- struct ustring { const wchar_t *name; };
- struct voidp { void *p; int *q; short *r; };
- struct ab { int a, b; };
- struct abc { int a, b, c; };
-
- /* don't use A0, B0, CC0, D0 because termios.h might be included
- and it has its own #defines for these names */
- enum foq { cffiA0, cffiB0, cffiCC0, cffiD0 };
- enum bar { A1, B1=-2, CC1, D1, E1 };
- enum baz { A2=0x1000, B2=0x2000 };
- enum foo2 { A3, B3, C3, D3 };
- struct bar_with_e { enum foo2 e; };
- enum noncont { A4, B4=42, C4 };
- enum etypes {A5='!', B5='\'', C5=0x10, D5=010, E5=- 0x10, F5=-010};
- typedef enum { Value0 = 0 } e_t, *pe_t;
- enum e_noninj { AA3=0, BB3=0, CC3=0, DD3=0 };
- enum e_prev { AA4, BB4=2, CC4=4, DD4=BB4, EE4, FF4=CC4, GG4=FF4 };
-
- struct nesting { struct abc d, e; };
- struct array2 { int a, b; int c[99]; };
- struct align { char a; short b; char c; };
- struct bitfield { int a:10, b:20, c:3; };
- typedef enum { AA2, BB2, CC2 } foo_e_t;
- typedef struct { foo_e_t f:2; } bfenum_t;
- typedef struct { int a; } anon_foo_t;
- typedef struct { char b, c; } anon_bar_t;
- typedef struct named_foo_s { int a; } named_foo_t, *named_foo_p;
- typedef struct { int a; } unnamed_foo_t, *unnamed_foo_p;
- struct nonpacked { char a; int b; };
- struct array0 { int len; short data[0]; };
- struct array_no_length { int x; int a[]; };
-
- struct nested_anon {
- struct { int a, b; };
- union { int c, d; };
- };
- struct nested_field_ofs_s {
- struct { int a; char b; };
- union { char c; };
- };
- union nested_anon_u {
- struct { int a, b; };
- union { int c, d; };
- };
- struct abc50 { int a, b; int c[50]; };
- struct ints_and_bitfield { int a,b,c,d,e; int x:1; };
- """
- DEFS_PACKED = """
- struct is_packed { char a; int b; } /*here*/;
- """
- if sys.platform == "win32":
- DEFS = DEFS.replace('data[0]', 'data[1]') # not supported
- CCODE = (DEFS + "\n#pragma pack(push,1)\n" + DEFS_PACKED +
- "\n#pragma pack(pop)\n")
- else:
- CCODE = (DEFS +
- DEFS_PACKED.replace('/*here*/', '__attribute__((packed))'))
-
- ffi1.cdef(DEFS)
- ffi1.cdef(DEFS_PACKED, packed=True)
- ffi1.set_source("test_new_ffi_1", CCODE)
-
- outputfilename = recompile(ffi1, "test_new_ffi_1", CCODE,
- tmpdir=str(udir))
- module = imp.load_dynamic("test_new_ffi_1", outputfilename)
- ffi = module.ffi
- construction_params = (ffi1, CCODE)
-
-
-class TestNewFFI1:
-
- def test_integer_ranges(self):
- for (c_type, size) in [('char', 1),
- ('short', 2),
- ('short int', 2),
- ('', 4),
- ('int', 4),
- ('long', SIZE_OF_LONG),
- ('long int', SIZE_OF_LONG),
- ('long long', 8),
- ('long long int', 8),
- ]:
- for unsigned in [None, False, True]:
- c_decl = {None: '',
- False: 'signed ',
- True: 'unsigned '}[unsigned] + c_type
- if c_decl == 'char' or c_decl == '':
- continue
- self._test_int_type(ffi, c_decl, size, unsigned)
-
- def test_fixedsize_int(self):
- for size in [1, 2, 4, 8]:
- self._test_int_type(ffi, 'int%d_t' % (8*size), size, False)
- self._test_int_type(ffi, 'uint%d_t' % (8*size), size, True)
- self._test_int_type(ffi, 'intptr_t', SIZE_OF_PTR, False)
- self._test_int_type(ffi, 'uintptr_t', SIZE_OF_PTR, True)
- self._test_int_type(ffi, 'ptrdiff_t', SIZE_OF_PTR, False)
- self._test_int_type(ffi, 'size_t', SIZE_OF_PTR, True)
- self._test_int_type(ffi, 'ssize_t', SIZE_OF_PTR, False)
-
- def _test_int_type(self, ffi, c_decl, size, unsigned):
- if unsigned:
- min = 0
- max = (1 << (8*size)) - 1
- else:
- min = -(1 << (8*size-1))
- max = (1 << (8*size-1)) - 1
- min = int(min)
- max = int(max)
- p = ffi.cast(c_decl, min)
- assert p == min
- assert bool(p) is bool(min)
- assert int(p) == min
- p = ffi.cast(c_decl, max)
- assert int(p) == max
- p = ffi.cast(c_decl, long(max))
- assert int(p) == max
- q = ffi.cast(c_decl, min - 1)
- assert ffi.typeof(q) is ffi.typeof(p) and int(q) == max
- q = ffi.cast(c_decl, long(min - 1))
- assert ffi.typeof(q) is ffi.typeof(p) and int(q) == max
- assert q == p
- assert int(q) == int(p)
- assert hash(q) == hash(p)
- c_decl_ptr = '%s *' % c_decl
- py.test.raises(OverflowError, ffi.new, c_decl_ptr, min - 1)
- py.test.raises(OverflowError, ffi.new, c_decl_ptr, max + 1)
- py.test.raises(OverflowError, ffi.new, c_decl_ptr, long(min - 1))
- py.test.raises(OverflowError, ffi.new, c_decl_ptr, long(max + 1))
- assert ffi.new(c_decl_ptr, min)[0] == min
- assert ffi.new(c_decl_ptr, max)[0] == max
- assert ffi.new(c_decl_ptr, long(min))[0] == min
- assert ffi.new(c_decl_ptr, long(max))[0] == max
-
- def test_new_unsupported_type(self):
- e = py.test.raises(TypeError, ffi.new, "int")
- assert str(e.value) == "expected a pointer or array ctype, got 'int'"
-
- def test_new_single_integer(self):
- p = ffi.new("int *") # similar to ffi.new("int[1]")
- assert p[0] == 0
- p[0] = -123
- assert p[0] == -123
- p = ffi.new("int *", -42)
- assert p[0] == -42
- assert repr(p) == "<cdata 'int *' owning %d bytes>" % SIZE_OF_INT
-
- def test_new_array_no_arg(self):
- p = ffi.new("int[10]")
- # the object was zero-initialized:
- for i in range(10):
- assert p[i] == 0
-
- def test_array_indexing(self):
- p = ffi.new("int[10]")
- p[0] = 42
- p[9] = 43
- assert p[0] == 42
- assert p[9] == 43
- with pytest.raises(IndexError):
- p[10]
- with pytest.raises(IndexError):
- p[10] = 44
- with pytest.raises(IndexError):
- p[-1]
- with pytest.raises(IndexError):
- p[-1] = 44
-
- def test_new_array_args(self):
- # this tries to be closer to C: where we say "int x[5] = {10, 20, ..}"
- # then here we must enclose the items in a list
- p = ffi.new("int[5]", [10, 20, 30, 40, 50])
- assert p[0] == 10
- assert p[1] == 20
- assert p[2] == 30
- assert p[3] == 40
- assert p[4] == 50
- p = ffi.new("int[4]", [25])
- assert p[0] == 25
- assert p[1] == 0 # follow C convention rather than LuaJIT's
- assert p[2] == 0
- assert p[3] == 0
- p = ffi.new("int[4]", [ffi.cast("int", -5)])
- assert p[0] == -5
- assert repr(p) == "<cdata 'int[4]' owning %d bytes>" % (4*SIZE_OF_INT)
-
- def test_new_array_varsize(self):
- p = ffi.new("int[]", 10) # a single integer is the length
- assert p[9] == 0
- with pytest.raises(IndexError):
- p[10]
- #
- py.test.raises(TypeError, ffi.new, "int[]")
- #
- p = ffi.new("int[]", [-6, -7]) # a list is all the items, like C
- assert p[0] == -6
- assert p[1] == -7
- with pytest.raises(IndexError):
- p[2]
- assert repr(p) == "<cdata 'int[]' owning %d bytes>" % (2*SIZE_OF_INT)
- #
- p = ffi.new("int[]", 0)
- with pytest.raises(IndexError):
- p[0]
- py.test.raises(ValueError, ffi.new, "int[]", -1)
- assert repr(p) == "<cdata 'int[]' owning 0 bytes>"
-
- def test_pointer_init(self):
- n = ffi.new("int *", 24)
- a = ffi.new("int *[10]", [ffi.NULL, ffi.NULL, n, n, ffi.NULL])
- for i in range(10):
- if i not in (2, 3):
- assert a[i] == ffi.NULL
- assert a[2] == a[3] == n
-
- def test_cannot_cast(self):
- a = ffi.new("short int[10]")
- e = py.test.raises(TypeError, ffi.new, "long int **", a)
- msg = str(e.value)
- assert "'short[10]'" in msg and "'long *'" in msg
-
- def test_new_pointer_to_array(self):
- a = ffi.new("int[4]", [100, 102, 104, 106])
- p = ffi.new("int **", a)
- assert p[0] == ffi.cast("int *", a)
- assert p[0][2] == 104
- p = ffi.cast("int *", a)
- assert p[0] == 100
- assert p[1] == 102
- assert p[2] == 104
- assert p[3] == 106
- # keepalive: a
-
- def test_pointer_direct(self):
- p = ffi.cast("int*", 0)
- assert p is not None
- assert bool(p) is False
- assert p == ffi.cast("int*", 0)
- assert p != None
- assert repr(p) == "<cdata 'int *' NULL>"
- a = ffi.new("int[]", [123, 456])
- p = ffi.cast("int*", a)
- assert bool(p) is True
- assert p == ffi.cast("int*", a)
- assert p != ffi.cast("int*", 0)
- assert p[0] == 123
- assert p[1] == 456
-
- def test_repr(self):
- typerepr = "<ctype '%s'>"
- p = ffi.cast("short unsigned int", 0)
- assert repr(p) == "<cdata 'unsigned short' 0>"
- assert repr(ffi.typeof(p)) == typerepr % "unsigned short"
- p = ffi.cast("unsigned short int", 0)
- assert repr(p) == "<cdata 'unsigned short' 0>"
- assert repr(ffi.typeof(p)) == typerepr % "unsigned short"
- p = ffi.cast("int*", 0)
- assert repr(p) == "<cdata 'int *' NULL>"
- assert repr(ffi.typeof(p)) == typerepr % "int *"
- #
- p = ffi.new("int*")
- assert repr(p) == "<cdata 'int *' owning %d bytes>" % SIZE_OF_INT
- assert repr(ffi.typeof(p)) == typerepr % "int *"
- p = ffi.new("int**")
- assert repr(p) == "<cdata 'int * *' owning %d bytes>" % SIZE_OF_PTR
- assert repr(ffi.typeof(p)) == typerepr % "int * *"
- p = ffi.new("int [2]")
- assert repr(p) == "<cdata 'int[2]' owning %d bytes>" % (2*SIZE_OF_INT)
- assert repr(ffi.typeof(p)) == typerepr % "int[2]"
- p = ffi.new("int*[2][3]")
- assert repr(p) == "<cdata 'int *[2][3]' owning %d bytes>" % (
- 6*SIZE_OF_PTR)
- assert repr(ffi.typeof(p)) == typerepr % "int *[2][3]"
- p = ffi.new("struct repr *")
- assert repr(p) == "<cdata 'struct repr *' owning %d bytes>" % (
- 3*SIZE_OF_SHORT)
- assert repr(ffi.typeof(p)) == typerepr % "struct repr *"
- #
- q = ffi.cast("short", -123)
- assert repr(q) == "<cdata 'short' -123>"
- assert repr(ffi.typeof(q)) == typerepr % "short"
- p = ffi.new("int*")
- q = ffi.cast("short*", p)
- assert repr(q).startswith("<cdata 'short *' 0x")
- assert repr(ffi.typeof(q)) == typerepr % "short *"
- p = ffi.new("int [2]")
- q = ffi.cast("int*", p)
- assert repr(q).startswith("<cdata 'int *' 0x")
- assert repr(ffi.typeof(q)) == typerepr % "int *"
- p = ffi.new("struct repr*")
- q = ffi.cast("struct repr *", p)
- assert repr(q).startswith("<cdata 'struct repr *' 0x")
- assert repr(ffi.typeof(q)) == typerepr % "struct repr *"
- prevrepr = repr(q)
- q = q[0]
- assert repr(q) == prevrepr.replace(' *', ' &')
- assert repr(ffi.typeof(q)) == typerepr % "struct repr"
-
- def test_new_array_of_array(self):
- p = ffi.new("int[3][4]")
- p[0][0] = 10
- p[2][3] = 33
- assert p[0][0] == 10
- assert p[2][3] == 33
- with pytest.raises(IndexError):
- p[1][-1]
-
- def test_constructor_array_of_array(self):
- p = ffi.new("int[3][2]", [[10, 11], [12, 13], [14, 15]])
- assert p[2][1] == 15
-
- def test_new_array_of_pointer_1(self):
- n = ffi.new("int*", 99)
- p = ffi.new("int*[4]")
- p[3] = n
- a = p[3]
- assert repr(a).startswith("<cdata 'int *' 0x")
- assert a[0] == 99
-
- def test_new_array_of_pointer_2(self):
- n = ffi.new("int[1]", [99])
- p = ffi.new("int*[4]")
- p[3] = n
- a = p[3]
- assert repr(a).startswith("<cdata 'int *' 0x")
- assert a[0] == 99
-
- def test_char(self):
- assert ffi.new("char*", b"\xff")[0] == b'\xff'
- assert ffi.new("char*")[0] == b'\x00'
- assert int(ffi.cast("char", 300)) == 300 - 256
- assert not bool(ffi.cast("char", 0))
- assert bool(ffi.cast("char", 1))
- assert bool(ffi.cast("char", 255))
- py.test.raises(TypeError, ffi.new, "char*", 32)
- py.test.raises(TypeError, ffi.new, "char*", u+"x")
- py.test.raises(TypeError, ffi.new, "char*", b"foo")
- #
- p = ffi.new("char[]", [b'a', b'b', b'\x9c'])
- assert len(p) == 3
- assert p[0] == b'a'
- assert p[1] == b'b'
- assert p[2] == b'\x9c'
- p[0] = b'\xff'
- assert p[0] == b'\xff'
- p = ffi.new("char[]", b"abcd")
- assert len(p) == 5
- assert p[4] == b'\x00' # like in C, with: char[] p = "abcd";
- #
- p = ffi.new("char[4]", b"ab")
- assert len(p) == 4
- assert [p[i] for i in range(4)] == [b'a', b'b', b'\x00', b'\x00']
- p = ffi.new("char[2]", b"ab")
- assert len(p) == 2
- assert [p[i] for i in range(2)] == [b'a', b'b']
- py.test.raises(IndexError, ffi.new, "char[2]", b"abc")
-
- def check_wchar_t(self, ffi):
- try:
- ffi.cast("wchar_t", 0)
- except NotImplementedError:
- py.test.skip("NotImplementedError: wchar_t")
-
- def test_wchar_t(self):
- self.check_wchar_t(ffi)
- assert ffi.new("wchar_t*", u+'x')[0] == u+'x'
- assert ffi.new("wchar_t*", u+'\u1234')[0] == u+'\u1234'
- if SIZE_OF_WCHAR > 2:
- assert ffi.new("wchar_t*", u+'\U00012345')[0] == u+'\U00012345'
- else:
- py.test.raises(TypeError, ffi.new, "wchar_t*", u+'\U00012345')
- assert ffi.new("wchar_t*")[0] == u+'\x00'
- assert int(ffi.cast("wchar_t", 300)) == 300
- assert not bool(ffi.cast("wchar_t", 0))
- assert bool(ffi.cast("wchar_t", 1))
- assert bool(ffi.cast("wchar_t", 65535))
- if SIZE_OF_WCHAR > 2:
- assert bool(ffi.cast("wchar_t", 65536))
- py.test.raises(TypeError, ffi.new, "wchar_t*", 32)
- py.test.raises(TypeError, ffi.new, "wchar_t*", "foo")
- #
- p = ffi.new("wchar_t[]", [u+'a', u+'b', u+'\u1234'])
- assert len(p) == 3
- assert p[0] == u+'a'
- assert p[1] == u+'b' and type(p[1]) is unicode
- assert p[2] == u+'\u1234'
- p[0] = u+'x'
- assert p[0] == u+'x' and type(p[0]) is unicode
- p[1] = u+'\u1357'
- assert p[1] == u+'\u1357'
- p = ffi.new("wchar_t[]", u+"abcd")
- assert len(p) == 5
- assert p[4] == u+'\x00'
- p = ffi.new("wchar_t[]", u+"a\u1234b")
- assert len(p) == 4
- assert p[1] == u+'\u1234'
- #
- p = ffi.new("wchar_t[]", u+'\U00023456')
- if SIZE_OF_WCHAR == 2:
- assert len(p) == 3
- assert p[0] == u+'\ud84d'
- assert p[1] == u+'\udc56'
- assert p[2] == u+'\x00'
- else:
- assert len(p) == 2
- assert p[0] == u+'\U00023456'
- assert p[1] == u+'\x00'
- #
- p = ffi.new("wchar_t[4]", u+"ab")
- assert len(p) == 4
- assert [p[i] for i in range(4)] == [u+'a', u+'b', u+'\x00', u+'\x00']
- p = ffi.new("wchar_t[2]", u+"ab")
- assert len(p) == 2
- assert [p[i] for i in range(2)] == [u+'a', u+'b']
- py.test.raises(IndexError, ffi.new, "wchar_t[2]", u+"abc")
-
- def test_none_as_null_doesnt_work(self):
- p = ffi.new("int*[1]")
- assert p[0] is not None
- assert p[0] != None
- assert p[0] == ffi.NULL
- assert repr(p[0]) == "<cdata 'int *' NULL>"
- #
- n = ffi.new("int*", 99)
- p = ffi.new("int*[]", [n])
- assert p[0][0] == 99
- with pytest.raises(TypeError):
- p[0] = None
- p[0] = ffi.NULL
- assert p[0] == ffi.NULL
-
- def test_float(self):
- p = ffi.new("float[]", [-2, -2.5])
- assert p[0] == -2.0
- assert p[1] == -2.5
- p[1] += 17.75
- assert p[1] == 15.25
- #
- p = ffi.new("float*", 15.75)
- assert p[0] == 15.75
- py.test.raises(TypeError, int, p)
- py.test.raises(TypeError, float, p)
- p[0] = 0.0
- assert bool(p) is True
- #
- p = ffi.new("float*", 1.1)
- f = p[0]
- assert f != 1.1 # because of rounding effect
- assert abs(f - 1.1) < 1E-7
- #
- INF = 1E200 * 1E200
- assert 1E200 != INF
- p[0] = 1E200
- assert p[0] == INF # infinite, not enough precision
-
- def test_struct_simple(self):
- s = ffi.new("struct simple*")
- assert s.a == s.b == s.c == 0
- s.b = -23
- assert s.b == -23
- with pytest.raises(OverflowError):
- s.b = 32768
- #
- s = ffi.new("struct simple*", [-2, -3])
- assert s.a == -2
- assert s.b == -3
- assert s.c == 0
- with pytest.raises((AttributeError, TypeError)):
- del s.a
- assert repr(s) == "<cdata 'struct simple *' owning %d bytes>" % (
- SIZE_OF_INT + 2 * SIZE_OF_SHORT)
- #
- py.test.raises(ValueError, ffi.new, "struct simple*", [1, 2, 3, 4])
-
- def test_constructor_struct_from_dict(self):
- s = ffi.new("struct simple*", {'b': 123, 'c': 456})
- assert s.a == 0
- assert s.b == 123
- assert s.c == 456
- py.test.raises(KeyError, ffi.new, "struct simple*", {'d': 456})
-
- def test_struct_pointer(self):
- s = ffi.new("struct simple*")
- assert s[0].a == s[0].b == s[0].c == 0
- s[0].b = -23
- assert s[0].b == s.b == -23
- with pytest.raises(OverflowError):
- s[0].b = -32769
- with pytest.raises(IndexError):
- s[1]
-
- def test_struct_opaque(self):
- py.test.raises(ffi.error, ffi.new, "struct baz*")
- # should 'ffi.new("struct baz **") work? it used to, but it was
- # not particularly useful...
- py.test.raises(ffi.error, ffi.new, "struct baz**")
-
- def test_pointer_to_struct(self):
- s = ffi.new("struct simple *")
- s.a = -42
- assert s[0].a == -42
- p = ffi.new("struct simple **", s)
- assert p[0].a == -42
- assert p[0][0].a == -42
- p[0].a = -43
- assert s.a == -43
- assert s[0].a == -43
- p[0][0].a = -44
- assert s.a == -44
- assert s[0].a == -44
- s.a = -45
- assert p[0].a == -45
- assert p[0][0].a == -45
- s[0].a = -46
- assert p[0].a == -46
- assert p[0][0].a == -46
-
- def test_constructor_struct_of_array(self):
- s = ffi.new("struct array *", [[10, 11], [b'a', b'b', b'c']])
- assert s.a[1] == 11
- assert s.b[2] == b'c'
- s.b[1] = b'X'
- assert s.b[0] == b'a'
- assert s.b[1] == b'X'
- assert s.b[2] == b'c'
-
- def test_recursive_struct(self):
- s = ffi.new("struct recursive*")
- t = ffi.new("struct recursive*")
- s.value = 123
- s.next = t
- t.value = 456
- assert s.value == 123
- assert s.next.value == 456
-
- def test_union_simple(self):
- u = ffi.new("union simple_u*")
- assert u.a == u.b == u.c == 0
- u.b = -23
- assert u.b == -23
- assert u.a != 0
- with pytest.raises(OverflowError):
- u.b = 32768
- #
- u = ffi.new("union simple_u*", [-2])
- assert u.a == -2
- with pytest.raises((AttributeError, TypeError)):
- del u.a
- assert repr(u) == "<cdata 'union simple_u *' owning %d bytes>" % (
- SIZE_OF_INT,)
-
- def test_union_opaque(self):
- py.test.raises(ffi.error, ffi.new, "union baz*")
- # should 'ffi.new("union baz **") work? it used to, but it was
- # not particularly useful...
- py.test.raises(ffi.error, ffi.new, "union baz**")
-
- def test_union_initializer(self):
- py.test.raises(TypeError, ffi.new, "union init_u*", b'A')
- py.test.raises(TypeError, ffi.new, "union init_u*", 5)
- py.test.raises(ValueError, ffi.new, "union init_u*", [b'A', 5])
- u = ffi.new("union init_u*", [b'A'])
- assert u.a == b'A'
- py.test.raises(TypeError, ffi.new, "union init_u*", [1005])
- u = ffi.new("union init_u*", {'b': 12345})
- assert u.b == 12345
- u = ffi.new("union init_u*", [])
- assert u.a == b'\x00'
- assert u.b == 0
-
- def test_sizeof_type(self):
- for c_type, expected_size in [
- ('char', 1),
- ('unsigned int', 4),
- ('char *', SIZE_OF_PTR),
- ('int[5]', 20),
- ('struct four_s', 12),
- ('union four_u', 4),
- ]:
- size = ffi.sizeof(c_type)
- assert size == expected_size, (size, expected_size, ctype)
-
- def test_sizeof_cdata(self):
- assert ffi.sizeof(ffi.new("short*")) == SIZE_OF_PTR
- assert ffi.sizeof(ffi.cast("short", 123)) == SIZE_OF_SHORT
- #
- a = ffi.new("int[]", [10, 11, 12, 13, 14])
- assert len(a) == 5
- assert ffi.sizeof(a) == 5 * SIZE_OF_INT
-
- def test_string_from_char_pointer(self):
- x = ffi.new("char*", b"x")
- assert str(x) == repr(x)
- assert ffi.string(x) == b"x"
- assert ffi.string(ffi.new("char*", b"\x00")) == b""
- py.test.raises(TypeError, ffi.new, "char*", unicode("foo"))
-
- def test_unicode_from_wchar_pointer(self):
- self.check_wchar_t(ffi)
- x = ffi.new("wchar_t*", u+"x")
- assert unicode(x) == unicode(repr(x))
- assert ffi.string(x) == u+"x"
- assert ffi.string(ffi.new("wchar_t*", u+"\x00")) == u+""
-
- def test_string_from_char_array(self):
- p = ffi.new("char[]", b"hello.")
- p[5] = b'!'
- assert ffi.string(p) == b"hello!"
- p[6] = b'?'
- assert ffi.string(p) == b"hello!?"
- p[3] = b'\x00'
- assert ffi.string(p) == b"hel"
- assert ffi.string(p, 2) == b"he"
- with pytest.raises(IndexError):
- p[7] = b'X'
- #
- a = ffi.new("char[]", b"hello\x00world")
- assert len(a) == 12
- p = ffi.cast("char *", a)
- assert ffi.string(p) == b'hello'
-
- def test_string_from_wchar_array(self):
- self.check_wchar_t(ffi)
- assert ffi.string(ffi.cast("wchar_t", "x")) == u+"x"
- assert ffi.string(ffi.cast("wchar_t", u+"x")) == u+"x"
- x = ffi.cast("wchar_t", "x")
- assert str(x) == repr(x)
- assert ffi.string(x) == u+"x"
- #
- p = ffi.new("wchar_t[]", u+"hello.")
- p[5] = u+'!'
- assert ffi.string(p) == u+"hello!"
- p[6] = u+'\u04d2'
- assert ffi.string(p) == u+"hello!\u04d2"
- p[3] = u+'\x00'
- assert ffi.string(p) == u+"hel"
- assert ffi.string(p, 123) == u+"hel"
- with pytest.raises(IndexError):
- p[7] = u+'X'
- #
- a = ffi.new("wchar_t[]", u+"hello\x00world")
- assert len(a) == 12
- p = ffi.cast("wchar_t *", a)
- assert ffi.string(p) == u+'hello'
- assert ffi.string(p, 123) == u+'hello'
- assert ffi.string(p, 5) == u+'hello'
- assert ffi.string(p, 2) == u+'he'
-
- def test_fetch_const_char_p_field(self):
- # 'const' is ignored so far, in the declaration of 'struct string'
- t = ffi.new("const char[]", b"testing")
- s = ffi.new("struct string*", [t])
- assert type(s.name) not in (bytes, str, unicode)
- assert ffi.string(s.name) == b"testing"
- with pytest.raises(TypeError):
- s.name = None
- s.name = ffi.NULL
- assert s.name == ffi.NULL
-
- def test_fetch_const_wchar_p_field(self):
- # 'const' is ignored so far
- self.check_wchar_t(ffi)
- t = ffi.new("const wchar_t[]", u+"testing")
- s = ffi.new("struct ustring*", [t])
- assert type(s.name) not in (bytes, str, unicode)
- assert ffi.string(s.name) == u+"testing"
- s.name = ffi.NULL
- assert s.name == ffi.NULL
-
- def test_voidp(self):
- py.test.raises(TypeError, ffi.new, "void*")
- p = ffi.new("void **")
- assert p[0] == ffi.NULL
- a = ffi.new("int[]", [10, 11, 12])
- p = ffi.new("void **", a)
- vp = p[0]
- with pytest.raises(TypeError):
- vp[0]
- py.test.raises(TypeError, ffi.new, "short **", a)
- #
- s = ffi.new("struct voidp *")
- s.p = a # works
- s.q = a # works
- with pytest.raises(TypeError):
- s.r = a # fails
- b = ffi.cast("int *", a)
- s.p = b # works
- s.q = b # works
- with pytest.raises(TypeError):
- s.r = b # fails
-
- def test_functionptr_simple(self):
- py.test.raises(TypeError, ffi.callback, "int(*)(int)", 0)
- def cb(n):
- return n + 1
- cb.__qualname__ = 'cb'
- p = ffi.callback("int(*)(int)", cb)
- res = p(41) # calling an 'int(*)(int)', i.e. a function pointer
- assert res == 42 and type(res) is int
- res = p(ffi.cast("int", -41))
- assert res == -40 and type(res) is int
- assert repr(p).startswith(
- "<cdata 'int(*)(int)' calling <function cb at 0x")
- assert ffi.typeof(p) is ffi.typeof("int(*)(int)")
- q = ffi.new("int(**)(int)", p)
- assert repr(q) == "<cdata 'int(* *)(int)' owning %d bytes>" % (
- SIZE_OF_PTR)
- with pytest.raises(TypeError):
- q(43)
- res = q[0](43)
- assert res == 44
- q = ffi.cast("int(*)(int)", p)
- assert repr(q).startswith("<cdata 'int(*)(int)' 0x")
- res = q(45)
- assert res == 46
-
- def test_functionptr_advanced(self):
- t = ffi.typeof("int(*(*)(int))(int)")
- assert repr(t) == "<ctype '%s'>" % "int(*(*)(int))(int)"
-
- def test_functionptr_voidptr_return(self):
- def cb():
- return ffi.NULL
- p = ffi.callback("void*(*)()", cb)
- res = p()
- assert res is not None
- assert res == ffi.NULL
- int_ptr = ffi.new('int*')
- void_ptr = ffi.cast('void*', int_ptr)
- def cb():
- return void_ptr
- p = ffi.callback("void*(*)()", cb)
- res = p()
- assert res == void_ptr
-
- def test_functionptr_intptr_return(self):
- def cb():
- return ffi.NULL
- p = ffi.callback("int*(*)()", cb)
- res = p()
- assert res == ffi.NULL
- int_ptr = ffi.new('int*')
- def cb():
- return int_ptr
- p = ffi.callback("int*(*)()", cb)
- res = p()
- assert repr(res).startswith("<cdata 'int *' 0x")
- assert res == int_ptr
- int_array_ptr = ffi.new('int[1]')
- def cb():
- return int_array_ptr
- p = ffi.callback("int*(*)()", cb)
- res = p()
- assert repr(res).startswith("<cdata 'int *' 0x")
- assert res == int_array_ptr
-
- def test_functionptr_void_return(self):
- def foo():
- pass
- foo_cb = ffi.callback("void foo()", foo)
- result = foo_cb()
- assert result is None
-
- def test_char_cast(self):
- p = ffi.cast("int", b'\x01')
- assert ffi.typeof(p) is ffi.typeof("int")
- assert int(p) == 1
- p = ffi.cast("int", ffi.cast("char", b"a"))
- assert int(p) == ord("a")
- p = ffi.cast("int", ffi.cast("char", b"\x80"))
- assert int(p) == 0x80 # "char" is considered unsigned in this case
- p = ffi.cast("int", b"\x81")
- assert int(p) == 0x81
-
- def test_wchar_cast(self):
- self.check_wchar_t(ffi)
- p = ffi.cast("int", ffi.cast("wchar_t", u+'\u1234'))
- assert int(p) == 0x1234
- p = ffi.cast("long long", ffi.cast("wchar_t", -1))
- if SIZE_OF_WCHAR == 2: # 2 bytes, unsigned
- assert int(p) == 0xffff
- elif (sys.platform.startswith('linux') and
- platform.machine().startswith('x86')): # known to be signed
- assert int(p) == -1
- else: # in general, it can be either signed or not
- assert int(p) in [-1, 0xffffffff] # e.g. on arm, both cases occur
- p = ffi.cast("int", u+'\u1234')
- assert int(p) == 0x1234
-
- def test_cast_array_to_charp(self):
- a = ffi.new("short int[]", [0x1234, 0x5678])
- p = ffi.cast("char*", a)
- data = b''.join([p[i] for i in range(4)])
- if sys.byteorder == 'little':
- assert data == b'\x34\x12\x78\x56'
- else:
- assert data == b'\x12\x34\x56\x78'
-
- def test_cast_between_pointers(self):
- a = ffi.new("short int[]", [0x1234, 0x5678])
- p = ffi.cast("short*", a)
- p2 = ffi.cast("int*", p)
- q = ffi.cast("char*", p2)
- data = b''.join([q[i] for i in range(4)])
- if sys.byteorder == 'little':
- assert data == b'\x34\x12\x78\x56'
- else:
- assert data == b'\x12\x34\x56\x78'
-
- def test_cast_pointer_and_int(self):
- a = ffi.new("short int[]", [0x1234, 0x5678])
- l1 = ffi.cast("intptr_t", a)
- p = ffi.cast("short*", a)
- l2 = ffi.cast("intptr_t", p)
- assert int(l1) == int(l2) != 0
- q = ffi.cast("short*", l1)
- assert q == ffi.cast("short*", int(l1))
- assert q[0] == 0x1234
- assert int(ffi.cast("intptr_t", ffi.NULL)) == 0
-
- def test_cast_functionptr_and_int(self):
- def cb(n):
- return n + 1
- a = ffi.callback("int(*)(int)", cb)
- p = ffi.cast("void *", a)
- assert p
- b = ffi.cast("int(*)(int)", p)
- assert b(41) == 42
- assert a == b
- assert hash(a) == hash(b)
-
- def test_callback_crash(self):
- def cb(n):
- raise Exception
- a = ffi.callback("int(*)(int)", cb, error=42)
- res = a(1) # and the error reported to stderr
- assert res == 42
-
- def test_structptr_argument(self):
- def cb(p):
- return p[0].a * 1000 + p[0].b * 100 + p[1].a * 10 + p[1].b
- a = ffi.callback("int(*)(struct ab[])", cb)
- res = a([[5, 6], {'a': 7, 'b': 8}])
- assert res == 5678
- res = a([[5], {'b': 8}])
- assert res == 5008
-
- def test_array_argument_as_list(self):
- seen = []
- def cb(argv):
- seen.append(ffi.string(argv[0]))
- seen.append(ffi.string(argv[1]))
- a = ffi.callback("void(*)(char *[])", cb)
- a([ffi.new("char[]", b"foobar"), ffi.new("char[]", b"baz")])
- assert seen == [b"foobar", b"baz"]
-
- def test_cast_float(self):
- a = ffi.cast("float", 12)
- assert float(a) == 12.0
- a = ffi.cast("float", 12.5)
- assert float(a) == 12.5
- a = ffi.cast("float", b"A")
- assert float(a) == ord("A")
- a = ffi.cast("int", 12.9)
- assert int(a) == 12
- a = ffi.cast("char", 66.9 + 256)
- assert ffi.string(a) == b"B"
- #
- a = ffi.cast("float", ffi.cast("int", 12))
- assert float(a) == 12.0
- a = ffi.cast("float", ffi.cast("double", 12.5))
- assert float(a) == 12.5
- a = ffi.cast("float", ffi.cast("char", b"A"))
- assert float(a) == ord("A")
- a = ffi.cast("int", ffi.cast("double", 12.9))
- assert int(a) == 12
- a = ffi.cast("char", ffi.cast("double", 66.9 + 256))
- assert ffi.string(a) == b"B"
-
- def test_enum(self):
- # enum foq { A0, B0, CC0, D0 };
- assert ffi.string(ffi.cast("enum foq", 0)) == "cffiA0"
- assert ffi.string(ffi.cast("enum foq", 2)) == "cffiCC0"
- assert ffi.string(ffi.cast("enum foq", 3)) == "cffiD0"
- assert ffi.string(ffi.cast("enum foq", 4)) == "4"
- # enum bar { A1, B1=-2, CC1, D1, E1 };
- assert ffi.string(ffi.cast("enum bar", 0)) == "A1"
- assert ffi.string(ffi.cast("enum bar", -2)) == "B1"
- assert ffi.string(ffi.cast("enum bar", -1)) == "CC1"
- assert ffi.string(ffi.cast("enum bar", 1)) == "E1"
- assert ffi.cast("enum bar", -2) == ffi.cast("enum bar", -2)
- assert ffi.cast("enum foq", 0) == ffi.cast("enum bar", 0)
- assert ffi.cast("enum bar", 0) == ffi.cast("int", 0)
- assert repr(ffi.cast("enum bar", -1)) == "<cdata 'enum bar' -1: CC1>"
- assert repr(ffi.cast("enum foq", -1)) == ( # enums are unsigned, if
- "<cdata 'enum foq' 4294967295>") or ( # they contain no neg value
- sys.platform == "win32") # (but not on msvc)
- # enum baz { A2=0x1000, B2=0x2000 };
- assert ffi.string(ffi.cast("enum baz", 0x1000)) == "A2"
- assert ffi.string(ffi.cast("enum baz", 0x2000)) == "B2"
-
- def test_enum_in_struct(self):
- # enum foo2 { A3, B3, C3, D3 };
- # struct bar_with_e { enum foo2 e; };
- s = ffi.new("struct bar_with_e *")
- s.e = 0
- assert s.e == 0
- s.e = 3
- assert s.e == 3
- assert s[0].e == 3
- s[0].e = 2
- assert s.e == 2
- assert s[0].e == 2
- s.e = ffi.cast("enum foo2", -1)
- assert s.e in (4294967295, -1) # two choices
- assert s[0].e in (4294967295, -1)
- s.e = s.e
- with pytest.raises(TypeError):
- s.e = 'B3'
- with pytest.raises(TypeError):
- s.e = '2'
- with pytest.raises(TypeError):
- s.e = '#2'
- with pytest.raises(TypeError):
- s.e = '#7'
-
- def test_enum_non_contiguous(self):
- # enum noncont { A4, B4=42, C4 };
- assert ffi.string(ffi.cast("enum noncont", 0)) == "A4"
- assert ffi.string(ffi.cast("enum noncont", 42)) == "B4"
- assert ffi.string(ffi.cast("enum noncont", 43)) == "C4"
- invalid_value = ffi.cast("enum noncont", 2)
- assert int(invalid_value) == 2
- assert ffi.string(invalid_value) == "2"
-
- def test_enum_char_hex_oct(self):
- # enum etypes {A5='!', B5='\'', C5=0x10, D5=010, E5=- 0x10, F5=-010};
- assert ffi.string(ffi.cast("enum etypes", ord('!'))) == "A5"
- assert ffi.string(ffi.cast("enum etypes", ord("'"))) == "B5"
- assert ffi.string(ffi.cast("enum etypes", 16)) == "C5"
- assert ffi.string(ffi.cast("enum etypes", 8)) == "D5"
- assert ffi.string(ffi.cast("enum etypes", -16)) == "E5"
- assert ffi.string(ffi.cast("enum etypes", -8)) == "F5"
-
- def test_array_of_struct(self):
- s = ffi.new("struct ab[1]")
- with pytest.raises(AttributeError):
- s.b
- with pytest.raises(AttributeError):
- s.b = 412
- s[0].b = 412
- assert s[0].b == 412
- with pytest.raises(IndexError):
- s[1]
-
- def test_pointer_to_array(self):
- p = ffi.new("int(**)[5]")
- assert repr(p) == "<cdata 'int(* *)[5]' owning %d bytes>" % SIZE_OF_PTR
-
- def test_iterate_array(self):
- a = ffi.new("char[]", b"hello")
- assert list(a) == [b"h", b"e", b"l", b"l", b"o", b"\0"]
- assert list(iter(a)) == [b"h", b"e", b"l", b"l", b"o", b"\0"]
- #
- py.test.raises(TypeError, iter, ffi.cast("char *", a))
- py.test.raises(TypeError, list, ffi.cast("char *", a))
- py.test.raises(TypeError, iter, ffi.new("int *"))
- py.test.raises(TypeError, list, ffi.new("int *"))
-
- def test_offsetof(self):
- # struct abc { int a, b, c; };
- assert ffi.offsetof("struct abc", "a") == 0
- assert ffi.offsetof("struct abc", "b") == 4
- assert ffi.offsetof("struct abc", "c") == 8
-
- def test_offsetof_nested(self):
- # struct nesting { struct abc d, e; };
- assert ffi.offsetof("struct nesting", "e") == 12
- py.test.raises(KeyError, ffi.offsetof, "struct nesting", "e.a")
- assert ffi.offsetof("struct nesting", "e", "a") == 12
- assert ffi.offsetof("struct nesting", "e", "b") == 16
- assert ffi.offsetof("struct nesting", "e", "c") == 20
-
- def test_offsetof_array(self):
- assert ffi.offsetof("int[]", 51) == 51 * ffi.sizeof("int")
- assert ffi.offsetof("int *", 51) == 51 * ffi.sizeof("int")
- # struct array2 { int a, b; int c[99]; };
- assert ffi.offsetof("struct array2", "c") == 2 * ffi.sizeof("int")
- assert ffi.offsetof("struct array2", "c", 0) == 2 * ffi.sizeof("int")
- assert ffi.offsetof("struct array2", "c", 51) == 53 * ffi.sizeof("int")
-
- def test_alignof(self):
- # struct align { char a; short b; char c; };
- assert ffi.alignof("int") == 4
- assert ffi.alignof("double") in (4, 8)
- assert ffi.alignof("struct align") == 2
-
- def test_bitfield(self):
- # struct bitfield { int a:10, b:20, c:3; };
- assert ffi.sizeof("struct bitfield") == 8
- s = ffi.new("struct bitfield *")
- s.a = 511
- with pytest.raises(OverflowError):
- s.a = 512
- with pytest.raises(OverflowError):
- s[0].a = 512
- assert s.a == 511
- s.a = -512
- with pytest.raises(OverflowError):
- s.a = -513
- with pytest.raises(OverflowError):
- s[0].a = -513
- assert s.a == -512
- s.c = 3
- assert s.c == 3
- with pytest.raises(OverflowError):
- s.c = 4
- with pytest.raises(OverflowError):
- s[0].c = 4
- s.c = -4
- assert s.c == -4
-
- def test_bitfield_enum(self):
- # typedef enum { AA1, BB1, CC1 } foo_e_t;
- # typedef struct { foo_e_t f:2; } bfenum_t;
- if sys.platform == "win32":
- py.test.skip("enums are not unsigned")
- s = ffi.new("bfenum_t *")
- s.f = 2
- assert s.f == 2
-
- def test_anonymous_struct(self):
- # typedef struct { int a; } anon_foo_t;
- # typedef struct { char b, c; } anon_bar_t;
- f = ffi.new("anon_foo_t *", [12345])
- b = ffi.new("anon_bar_t *", [b"B", b"C"])
- assert f.a == 12345
- assert b.b == b"B"
- assert b.c == b"C"
- assert repr(b).startswith("<cdata 'anon_bar_t *'")
-
- def test_struct_with_two_usages(self):
- # typedef struct named_foo_s { int a; } named_foo_t, *named_foo_p;
- # typedef struct { int a; } unnamed_foo_t, *unnamed_foo_p;
- f = ffi.new("named_foo_t *", [12345])
- ps = ffi.new("named_foo_p[]", [f])
- f = ffi.new("unnamed_foo_t *", [12345])
- ps = ffi.new("unnamed_foo_p[]", [f])
-
- def test_pointer_arithmetic(self):
- s = ffi.new("short[]", list(range(100, 110)))
- p = ffi.cast("short *", s)
- assert p[2] == 102
- assert p+1 == p+1
- assert p+1 != p+0
- assert p == p+0 == p-0
- assert (p+1)[0] == 101
- assert (p+19)[-10] == 109
- assert (p+5) - (p+1) == 4
- assert p == s+0
- assert p+1 == s+1
-
- def test_pointer_comparison(self):
- s = ffi.new("short[]", list(range(100)))
- p = ffi.cast("short *", s)
- assert (p < s) is False
- assert (p <= s) is True
- assert (p == s) is True
- assert (p != s) is False
- assert (p > s) is False
- assert (p >= s) is True
- assert (s < p) is False
- assert (s <= p) is True
- assert (s == p) is True
- assert (s != p) is False
- assert (s > p) is False
- assert (s >= p) is True
- q = p + 1
- assert (q < s) is False
- assert (q <= s) is False
- assert (q == s) is False
- assert (q != s) is True
- assert (q > s) is True
- assert (q >= s) is True
- assert (s < q) is True
- assert (s <= q) is True
- assert (s == q) is False
- assert (s != q) is True
- assert (s > q) is False
- assert (s >= q) is False
- assert (q < p) is False
- assert (q <= p) is False
- assert (q == p) is False
- assert (q != p) is True
- assert (q > p) is True
- assert (q >= p) is True
- assert (p < q) is True
- assert (p <= q) is True
- assert (p == q) is False
- assert (p != q) is True
- assert (p > q) is False
- assert (p >= q) is False
- #
- assert (None == s) is False
- assert (None != s) is True
- assert (s == None) is False
- assert (s != None) is True
- assert (None == q) is False
- assert (None != q) is True
- assert (q == None) is False
- assert (q != None) is True
-
- def test_integer_comparison(self):
- x = ffi.cast("int", 123)
- y = ffi.cast("int", 456)
- assert x < y
- #
- z = ffi.cast("double", 78.9)
- assert x > z
- assert y > z
-
- def test_ffi_buffer_ptr(self):
- a = ffi.new("short *", 100)
- try:
- b = ffi.buffer(a)
- except NotImplementedError as e:
- py.test.skip(str(e))
- content = b[:]
- assert len(content) == len(b) == 2
- if sys.byteorder == 'little':
- assert content == b'\x64\x00'
- assert b[0] == b'\x64'
- b[0] = b'\x65'
- else:
- assert content == b'\x00\x64'
- assert b[1] == b'\x64'
- b[1] = b'\x65'
- assert a[0] == 101
-
- def test_ffi_buffer_array(self):
- a = ffi.new("int[]", list(range(100, 110)))
- try:
- b = ffi.buffer(a)
- except NotImplementedError as e:
- py.test.skip(str(e))
- content = b[:]
- if sys.byteorder == 'little':
- assert content.startswith(b'\x64\x00\x00\x00\x65\x00\x00\x00')
- b[4] = b'\x45'
- else:
- assert content.startswith(b'\x00\x00\x00\x64\x00\x00\x00\x65')
- b[7] = b'\x45'
- assert len(content) == 4 * 10
- assert a[1] == 0x45
-
- def test_ffi_buffer_ptr_size(self):
- a = ffi.new("short *", 0x4243)
- try:
- b = ffi.buffer(a, 1)
- except NotImplementedError as e:
- py.test.skip(str(e))
- content = b[:]
- assert len(content) == 1
- if sys.byteorder == 'little':
- assert content == b'\x43'
- b[0] = b'\x62'
- assert a[0] == 0x4262
- else:
- assert content == b'\x42'
- b[0] = b'\x63'
- assert a[0] == 0x6343
-
- def test_ffi_buffer_array_size(self):
- a1 = ffi.new("int[]", list(range(100, 110)))
- a2 = ffi.new("int[]", list(range(100, 115)))
- try:
- ffi.buffer(a1)
- except NotImplementedError as e:
- py.test.skip(str(e))
- assert ffi.buffer(a1)[:] == ffi.buffer(a2, 4*10)[:]
-
- def test_ffi_buffer_with_file(self):
- import tempfile, os, array
- fd, filename = tempfile.mkstemp()
- f = os.fdopen(fd, 'r+b')
- a = ffi.new("int[]", list(range(1005)))
- try:
- ffi.buffer(a, 512)
- except NotImplementedError as e:
- py.test.skip(str(e))
- f.write(ffi.buffer(a, 1000 * ffi.sizeof("int")))
- f.seek(0)
- assert f.read() == arraytostring(array.array('i', range(1000)))
- f.seek(0)
- b = ffi.new("int[]", 1005)
- f.readinto(ffi.buffer(b, 1000 * ffi.sizeof("int")))
- assert list(a)[:1000] + [0] * (len(a)-1000) == list(b)
- f.close()
- os.unlink(filename)
-
- def test_ffi_buffer_with_io(self):
- import io, array
- f = io.BytesIO()
- a = ffi.new("int[]", list(range(1005)))
- try:
- ffi.buffer(a, 512)
- except NotImplementedError as e:
- py.test.skip(str(e))
- f.write(ffi.buffer(a, 1000 * ffi.sizeof("int")))
- f.seek(0)
- assert f.read() == arraytostring(array.array('i', range(1000)))
- f.seek(0)
- b = ffi.new("int[]", 1005)
- f.readinto(ffi.buffer(b, 1000 * ffi.sizeof("int")))
- assert list(a)[:1000] + [0] * (len(a)-1000) == list(b)
- f.close()
-
- def test_array_in_struct(self):
- # struct array { int a[2]; char b[3]; };
- p = ffi.new("struct array *")
- p.a[1] = 5
- assert p.a[1] == 5
- assert repr(p.a).startswith("<cdata 'int[2]' 0x")
-
- def test_struct_containing_array_varsize_workaround(self):
- if sys.platform == "win32":
- py.test.skip("array of length 0 not supported")
- # struct array0 { int len; short data[0]; };
- p = ffi.new("char[]", ffi.sizeof("struct array0") + 7 * SIZE_OF_SHORT)
- q = ffi.cast("struct array0 *", p)
- assert q.len == 0
- # 'q.data' gets not a 'short[0]', but just a 'short *' instead
- assert repr(q.data).startswith("<cdata 'short *' 0x")
- assert q.data[6] == 0
- q.data[6] = 15
- assert q.data[6] == 15
-
- def test_new_struct_containing_array_varsize(self):
- py.test.skip("later?")
- ffi.cdef("struct foo_s { int len; short data[]; };")
- p = ffi.new("struct foo_s *", 10) # a single integer is the length
- assert p.len == 0
- assert p.data[9] == 0
- with pytest.raises(IndexError):
- p.data[10]
-
- def test_ffi_typeof_getcname(self):
- assert ffi.getctype("int") == "int"
- assert ffi.getctype("int", 'x') == "int x"
- assert ffi.getctype("int*") == "int *"
- assert ffi.getctype("int*", '') == "int *"
- assert ffi.getctype("int*", 'x') == "int * x"
- assert ffi.getctype("int", '*') == "int *"
- assert ffi.getctype("int", ' * x ') == "int * x"
- assert ffi.getctype(ffi.typeof("int*"), '*') == "int * *"
- assert ffi.getctype("int", '[5]') == "int[5]"
- assert ffi.getctype("int[5]", '[6]') == "int[6][5]"
- assert ffi.getctype("int[5]", '(*)') == "int(*)[5]"
- # special-case for convenience: automatically put '()' around '*'
- assert ffi.getctype("int[5]", '*') == "int(*)[5]"
- assert ffi.getctype("int[5]", '*foo') == "int(*foo)[5]"
- assert ffi.getctype("int[5]", ' ** foo ') == "int(** foo)[5]"
-
- def test_array_of_func_ptr(self):
- f = ffi.cast("int(*)(int)", 42)
- assert f != ffi.NULL
- py.test.raises(ffi.error, ffi.cast, "int(int)", 42)
- py.test.raises(ffi.error, ffi.new, "int([5])(int)")
- a = ffi.new("int(*[5])(int)", [f])
- assert ffi.getctype(ffi.typeof(a)) == "int(*[5])(int)"
- assert len(a) == 5
- assert a[0] == f
- assert a[1] == ffi.NULL
- py.test.raises(TypeError, ffi.cast, "int(*)(int)[5]", 0)
- #
- def cb(n):
- return n + 1
- f = ffi.callback("int(*)(int)", cb)
- a = ffi.new("int(*[5])(int)", [f, f])
- assert a[1](42) == 43
-
- def test_callback_as_function_argument(self):
- # In C, function arguments can be declared with a function type,
- # which is automatically replaced with the ptr-to-function type.
- def cb(a, b):
- return chr(ord(a) + ord(b)).encode()
- f = ffi.callback("char cb(char, char)", cb)
- assert f(b'A', b'\x01') == b'B'
- def g(callback):
- return callback(b'A', b'\x01')
- g = ffi.callback("char g(char cb(char, char))", g)
- assert g(f) == b'B'
-
- def test_vararg_callback(self):
- py.test.skip("callback with '...'")
- def cb(i, va_list):
- j = ffi.va_arg(va_list, "int")
- k = ffi.va_arg(va_list, "long long")
- return i * 2 + j * 3 + k * 5
- f = ffi.callback("long long cb(long i, ...)", cb)
- res = f(10, ffi.cast("int", 100), ffi.cast("long long", 1000))
- assert res == 20 + 300 + 5000
-
- def test_callback_decorator(self):
- #
- @ffi.callback("long(long, long)", error=42)
- def cb(a, b):
- return a - b
- #
- assert cb(-100, -10) == -90
- sz = ffi.sizeof("long")
- assert cb((1 << (sz*8-1)) - 1, -10) == 42
-
- def test_anonymous_enum(self):
- # typedef enum { Value0 = 0 } e_t, *pe_t;
- assert ffi.getctype("e_t*") == 'e_t *'
- assert ffi.getctype("pe_t") == 'e_t *'
- assert ffi.getctype("foo_e_t*") == 'foo_e_t *'
-
- def test_new_ctype(self):
- p = ffi.new("int *")
- py.test.raises(TypeError, ffi.new, p)
- p = ffi.new(ffi.typeof("int *"), 42)
- assert p[0] == 42
-
- def test_enum_with_non_injective_mapping(self):
- # enum e_noninj { AA3=0, BB3=0, CC3=0, DD3=0 };
- e = ffi.cast("enum e_noninj", 0)
- assert ffi.string(e) == "AA3" # pick the first one arbitrarily
-
- def test_enum_refer_previous_enum_value(self):
- # enum e_prev { AA4, BB4=2, CC4=4, DD4=BB4, EE4, FF4=CC4, GG4=FF4 };
- assert ffi.string(ffi.cast("enum e_prev", 2)) == "BB4"
- assert ffi.string(ffi.cast("enum e_prev", 3)) == "EE4"
- assert ffi.sizeof("char[DD4]") == 2
- assert ffi.sizeof("char[EE4]") == 3
- assert ffi.sizeof("char[FF4]") == 4
- assert ffi.sizeof("char[GG4]") == 4
-
- def test_nested_anonymous_struct(self):
- # struct nested_anon {
- # struct { int a, b; };
- # union { int c, d; };
- # };
- assert ffi.sizeof("struct nested_anon") == 3 * SIZE_OF_INT
- p = ffi.new("struct nested_anon *", [1, 2, 3])
- assert p.a == 1
- assert p.b == 2
- assert p.c == 3
- assert p.d == 3
- p.d = 17
- assert p.c == 17
- p.b = 19
- assert p.a == 1
- assert p.b == 19
- assert p.c == 17
- assert p.d == 17
- p = ffi.new("struct nested_anon *", {'b': 12, 'd': 14})
- assert p.a == 0
- assert p.b == 12
- assert p.c == 14
- assert p.d == 14
-
- def test_nested_field_offset_align(self):
- # struct nested_field_ofs_s {
- # struct { int a; char b; };
- # union { char c; };
- # };
- assert ffi.offsetof("struct nested_field_ofs_s", "c") == 2 * SIZE_OF_INT
- assert ffi.sizeof("struct nested_field_ofs_s") == 3 * SIZE_OF_INT
-
- def test_nested_anonymous_union(self):
- # union nested_anon_u {
- # struct { int a, b; };
- # union { int c, d; };
- # };
- assert ffi.sizeof("union nested_anon_u") == 2 * SIZE_OF_INT
- p = ffi.new("union nested_anon_u *", [5])
- assert p.a == 5
- assert p.b == 0
- assert p.c == 5
- assert p.d == 5
- p.d = 17
- assert p.c == 17
- assert p.a == 17
- p.b = 19
- assert p.a == 17
- assert p.b == 19
- assert p.c == 17
- assert p.d == 17
- p = ffi.new("union nested_anon_u *", {'d': 14})
- assert p.a == 14
- assert p.b == 0
- assert p.c == 14
- assert p.d == 14
- p = ffi.new("union nested_anon_u *", {'b': 12})
- assert p.a == 0
- assert p.b == 12
- assert p.c == 0
- assert p.d == 0
- # we cannot specify several items in the dict, even though
- # in theory in this particular case it would make sense
- # to give both 'a' and 'b'
-
- def test_cast_to_array_type(self):
- p = ffi.new("int[4]", [-5])
- q = ffi.cast("int[3]", p)
- assert q[0] == -5
- assert repr(q).startswith("<cdata 'int[3]' 0x")
-
- def test_gc(self):
- p = ffi.new("int *", 123)
- seen = []
- def destructor(p1):
- assert p1 is p
- assert p1[0] == 123
- seen.append(1)
- q = ffi.gc(p, destructor=destructor)
- import gc; gc.collect()
- assert seen == []
- del q
- import gc; gc.collect(); gc.collect(); gc.collect()
- assert seen == [1]
-
- def test_gc_2(self):
- p = ffi.new("int *", 123)
- seen = []
- q1 = ffi.gc(p, lambda p: seen.append(1))
- q2 = ffi.gc(q1, lambda p: seen.append(2))
- import gc; gc.collect()
- assert seen == []
- del q1, q2
- import gc; gc.collect(); gc.collect(); gc.collect(); gc.collect()
- assert seen == [2, 1]
-
- def test_gc_3(self):
- p = ffi.new("int *", 123)
- r = ffi.new("int *", 123)
- seen = []
- seen_r = []
- q1 = ffi.gc(p, lambda p: seen.append(1))
- s1 = ffi.gc(r, lambda r: seen_r.append(4))
- q2 = ffi.gc(q1, lambda p: seen.append(2))
- s2 = ffi.gc(s1, lambda r: seen_r.append(5))
- q3 = ffi.gc(q2, lambda p: seen.append(3))
- import gc; gc.collect()
- assert seen == []
- assert seen_r == []
- del q1, q2, q3, s2, s1
- import gc; gc.collect(); gc.collect(); gc.collect(); gc.collect()
- assert seen == [3, 2, 1]
- assert seen_r == [5, 4]
-
- def test_gc_4(self):
- p = ffi.new("int *", 123)
- seen = []
- q1 = ffi.gc(p, lambda p: seen.append(1))
- q2 = ffi.gc(q1, lambda p: seen.append(2))
- q3 = ffi.gc(q2, lambda p: seen.append(3))
- import gc; gc.collect()
- assert seen == []
- del q1, q3 # q2 remains, and has a hard ref to q1
- import gc; gc.collect(); gc.collect(); gc.collect()
- assert seen == [3]
-
- def test_release(self):
- p = ffi.new("int[]", 123)
- ffi.release(p)
- # here, reading p[0] might give garbage or segfault...
- ffi.release(p) # no effect
-
- def test_release_new_allocator(self):
- seen = []
- def myalloc(size):
- seen.append(size)
- return ffi.new("char[]", b"X" * size)
- def myfree(raw):
- seen.append(raw)
- alloc2 = ffi.new_allocator(alloc=myalloc, free=myfree)
- p = alloc2("int[]", 15)
- assert seen == [15 * 4]
- ffi.release(p)
- assert seen == [15 * 4, p]
- ffi.release(p) # no effect
- assert seen == [15 * 4, p]
- #
- del seen[:]
- p = alloc2("struct ab *")
- assert seen == [2 * 4]
- ffi.release(p)
- assert seen == [2 * 4, p]
- ffi.release(p) # no effect
- assert seen == [2 * 4, p]
-
- def test_CData_CType(self):
- assert isinstance(ffi.cast("int", 0), ffi.CData)
- assert isinstance(ffi.new("int *"), ffi.CData)
- assert not isinstance(ffi.typeof("int"), ffi.CData)
- assert not isinstance(ffi.cast("int", 0), ffi.CType)
- assert not isinstance(ffi.new("int *"), ffi.CType)
-
- def test_CData_CType_2(self):
- assert isinstance(ffi.typeof("int"), ffi.CType)
-
- def test_bool(self):
- assert int(ffi.cast("_Bool", 0.1)) == 1
- assert int(ffi.cast("_Bool", -0.0)) == 0
- assert int(ffi.cast("_Bool", b'\x02')) == 1
- assert int(ffi.cast("_Bool", b'\x00')) == 0
- assert int(ffi.cast("_Bool", b'\x80')) == 1
- assert ffi.new("_Bool *", False)[0] == 0
- assert ffi.new("_Bool *", 1)[0] == 1
- py.test.raises(OverflowError, ffi.new, "_Bool *", 2)
- py.test.raises(TypeError, ffi.string, ffi.cast("_Bool", 2))
-
- def test_addressof(self):
- p = ffi.new("struct ab *")
- a = ffi.addressof(p[0])
- assert repr(a).startswith("<cdata 'struct ab *' 0x")
- assert a == p
- py.test.raises(TypeError, ffi.addressof, p)
- py.test.raises((AttributeError, TypeError), ffi.addressof, 5)
- py.test.raises(TypeError, ffi.addressof, ffi.cast("int", 5))
-
- def test_addressof_field(self):
- p = ffi.new("struct ab *")
- b = ffi.addressof(p[0], 'b')
- assert repr(b).startswith("<cdata 'int *' 0x")
- assert int(ffi.cast("uintptr_t", b)) == (
- int(ffi.cast("uintptr_t", p)) + ffi.sizeof("int"))
- assert b == ffi.addressof(p, 'b')
- assert b != ffi.addressof(p, 'a')
-
- def test_addressof_field_nested(self):
- # struct nesting { struct abc d, e; };
- p = ffi.new("struct nesting *")
- py.test.raises(KeyError, ffi.addressof, p[0], 'e.b')
- a = ffi.addressof(p[0], 'e', 'b')
- assert int(ffi.cast("uintptr_t", a)) == (
- int(ffi.cast("uintptr_t", p)) +
- ffi.sizeof("struct abc") + ffi.sizeof("int"))
-
- def test_addressof_anonymous_struct(self):
- # typedef struct { int a; } anon_foo_t;
- p = ffi.new("anon_foo_t *")
- a = ffi.addressof(p[0])
- assert a == p
-
- def test_addressof_array(self):
- p = ffi.new("int[52]")
- p0 = ffi.addressof(p)
- assert p0 == p
- assert ffi.typeof(p0) is ffi.typeof("int(*)[52]")
- py.test.raises(TypeError, ffi.addressof, p0)
- #
- p1 = ffi.addressof(p, 25)
- assert ffi.typeof(p1) is ffi.typeof("int *")
- assert (p1 - p) == 25
- assert ffi.addressof(p, 0) == p
-
- def test_addressof_pointer(self):
- array = ffi.new("int[50]")
- p = ffi.cast("int *", array)
- py.test.raises(TypeError, ffi.addressof, p)
- assert ffi.addressof(p, 0) == p
- assert ffi.addressof(p, 25) == p + 25
- assert ffi.typeof(ffi.addressof(p, 25)) == ffi.typeof(p)
- #
- array = ffi.new("struct ab[50]")
- p = ffi.cast("int *", array)
- py.test.raises(TypeError, ffi.addressof, p)
- assert ffi.addressof(p, 0) == p
- assert ffi.addressof(p, 25) == p + 25
- assert ffi.typeof(ffi.addressof(p, 25)) == ffi.typeof(p)
-
- def test_addressof_array_in_struct(self):
- # struct abc50 { int a, b; int c[50]; };
- p = ffi.new("struct abc50 *")
- p1 = ffi.addressof(p, "c", 25)
- assert ffi.typeof(p1) is ffi.typeof("int *")
- assert p1 == ffi.cast("int *", p) + 27
- assert ffi.addressof(p, "c") == ffi.cast("int *", p) + 2
- assert ffi.addressof(p, "c", 0) == ffi.cast("int *", p) + 2
- p2 = ffi.addressof(p, 1)
- assert ffi.typeof(p2) is ffi.typeof("struct abc50 *")
- assert p2 == p + 1
-
- def test_multiple_independent_structs(self):
- CDEF2 = "struct ab { int x; };"
- ffi2 = cffi.FFI(); ffi2.cdef(CDEF2)
- outputfilename = recompile(ffi2, "test_multiple_independent_structs",
- CDEF2, tmpdir=str(udir))
- module = imp.load_dynamic("test_multiple_independent_structs",
- outputfilename)
- ffi1 = module.ffi
- foo1 = ffi1.new("struct ab *", [10])
- foo2 = ffi .new("struct ab *", [20, 30])
- assert foo1.x == 10
- assert foo2.a == 20
- assert foo2.b == 30
-
- def test_include_struct_union_enum_typedef(self):
- ffi1, CCODE = construction_params
- ffi2 = cffi.FFI()
- ffi2.include(ffi1)
- outputfilename = recompile(ffi2,
- "test_include_struct_union_enum_typedef",
- CCODE, tmpdir=str(udir))
- module = imp.load_dynamic("test_include_struct_union_enum_typedef",
- outputfilename)
- ffi2 = module.ffi
- #
- p = ffi2.new("struct nonpacked *", [b'A', -43141])
- assert p.a == b'A'
- assert p.b == -43141
- #
- p = ffi.new("union simple_u *", [-52525])
- assert p.a == -52525
- #
- p = ffi.cast("enum foq", 2)
- assert ffi.string(p) == "cffiCC0"
- assert ffi2.sizeof("char[cffiCC0]") == 2
- #
- p = ffi.new("anon_foo_t *", [-52526])
- assert p.a == -52526
- p = ffi.new("named_foo_p", [-52527])
- assert p.a == -52527
-
- def test_struct_packed(self):
- # struct nonpacked { char a; int b; };
- # struct is_packed { char a; int b; } __attribute__((packed));
- assert ffi.sizeof("struct nonpacked") == 8
- assert ffi.sizeof("struct is_packed") == 5
- assert ffi.alignof("struct nonpacked") == 4
- assert ffi.alignof("struct is_packed") == 1
- s = ffi.new("struct is_packed[2]")
- s[0].b = 42623381
- s[0].a = b'X'
- s[1].b = -4892220
- s[1].a = b'Y'
- assert s[0].b == 42623381
- assert s[0].a == b'X'
- assert s[1].b == -4892220
- assert s[1].a == b'Y'
-
- def test_not_supported_bitfield_in_result(self):
- # struct ints_and_bitfield { int a,b,c,d,e; int x:1; };
- e = py.test.raises(NotImplementedError, ffi.callback,
- "struct ints_and_bitfield foo(void)", lambda: 42)
- assert str(e.value) == ("struct ints_and_bitfield(*)(): "
- "callback with unsupported argument or return type or with '...'")
-
- def test_inspecttype(self):
- assert ffi.typeof("long").kind == "primitive"
- assert ffi.typeof("long(*)(long, long**, ...)").cname == (
- "long(*)(long, long * *, ...)")
- assert ffi.typeof("long(*)(long, long**, ...)").ellipsis is True
-
- def test_new_handle(self):
- o = [2, 3, 4]
- p = ffi.new_handle(o)
- assert ffi.typeof(p) == ffi.typeof("void *")
- assert ffi.from_handle(p) is o
- assert ffi.from_handle(ffi.cast("char *", p)) is o
- py.test.raises(RuntimeError, ffi.from_handle, ffi.NULL)
-
- def test_struct_array_no_length(self):
- # struct array_no_length { int x; int a[]; };
- p = ffi.new("struct array_no_length *", [100, [200, 300, 400]])
- assert p.x == 100
- assert ffi.typeof(p.a) is ffi.typeof("int[]") # length available
- assert p.a[0] == 200
- assert p.a[1] == 300
- assert p.a[2] == 400
- assert len(p.a) == 3
- assert list(p.a) == [200, 300, 400]
- q = ffi.cast("struct array_no_length *", p)
- assert ffi.typeof(q.a) is ffi.typeof("int *") # no length available
- assert q.a[0] == 200
- assert q.a[1] == 300
- assert q.a[2] == 400
- py.test.raises(TypeError, len, q.a)
- py.test.raises(TypeError, list, q.a)
-
- def test_all_primitives(self):
- assert set(PRIMITIVE_TO_INDEX) == set([
- "char",
- "short",
- "int",
- "long",
- "long long",
- "signed char",
- "unsigned char",
- "unsigned short",
- "unsigned int",
- "unsigned long",
- "unsigned long long",
- "float",
- "double",
- "long double",
- "wchar_t",
- "char16_t",
- "char32_t",
- "_Bool",
- "int8_t",
- "uint8_t",
- "int16_t",
- "uint16_t",
- "int32_t",
- "uint32_t",
- "int64_t",
- "uint64_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",
- "intptr_t",
- "uintptr_t",
- "intmax_t",
- "uintmax_t",
- "ptrdiff_t",
- "size_t",
- "ssize_t",
- 'float _Complex',
- 'double _Complex',
- ])
- for name in PRIMITIVE_TO_INDEX:
- x = ffi.sizeof(name)
- assert 1 <= x <= 16
-
- def test_emit_c_code(self):
- ffi = cffi.FFI()
- ffi.set_source("foobar", "??")
- c_file = str(udir.join('test_emit_c_code'))
- ffi.emit_c_code(c_file)
- assert os.path.isfile(c_file)
-
- def test_import_from_lib(self):
- ffi2 = cffi.FFI()
- ffi2.cdef("int myfunc(int); extern int myvar;\n#define MYFOO ...\n")
- outputfilename = recompile(ffi2, "_test_import_from_lib",
- "int myfunc(int x) { return x + 1; }\n"
- "int myvar = -5;\n"
- "#define MYFOO 42", tmpdir=str(udir))
- imp.load_dynamic("_test_import_from_lib", outputfilename)
- from _test_import_from_lib.lib import myfunc, myvar, MYFOO
- assert MYFOO == 42
- assert myfunc(43) == 44
- assert myvar == -5 # but can't be changed, so not very useful
- with pytest.raises(ImportError):
- from _test_import_from_lib.lib import bar
- d = {}
- exec("from _test_import_from_lib.lib import *", d)
- assert (set(key for key in d if not key.startswith('_')) ==
- set(['myfunc', 'MYFOO']))
- #
- # also test "import *" on the module itself, which should be
- # equivalent to "import ffi, lib"
- d = {}
- exec("from _test_import_from_lib import *", d)
- assert (sorted([x for x in d.keys() if not x.startswith('__')]) ==
- ['ffi', 'lib'])
-
- def test_char16_t(self):
- x = ffi.new("char16_t[]", 5)
- assert len(x) == 5 and ffi.sizeof(x) == 10
- x[2] = u+'\u1324'
- assert x[2] == u+'\u1324'
- y = ffi.new("char16_t[]", u+'\u1234\u5678')
- assert len(y) == 3
- assert list(y) == [u+'\u1234', u+'\u5678', u+'\x00']
- assert ffi.string(y) == u+'\u1234\u5678'
- z = ffi.new("char16_t[]", u+'\U00012345')
- assert len(z) == 3
- assert list(z) == [u+'\ud808', u+'\udf45', u+'\x00']
- assert ffi.string(z) == u+'\U00012345'
-
- def test_char32_t(self):
- x = ffi.new("char32_t[]", 5)
- assert len(x) == 5 and ffi.sizeof(x) == 20
- x[3] = u+'\U00013245'
- assert x[3] == u+'\U00013245'
- y = ffi.new("char32_t[]", u+'\u1234\u5678')
- assert len(y) == 3
- assert list(y) == [u+'\u1234', u+'\u5678', u+'\x00']
- z = ffi.new("char32_t[]", u+'\U00012345')
- assert len(z) == 2
- assert list(z) == [u+'\U00012345', u+'\x00'] # maybe a 2-unichars strin
- assert ffi.string(z) == u+'\U00012345'
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-31 23:37:13 +0000