Explorar el Código

HUE-3501 [desktop] Upgrade cffi and cryptography deps to fix OS X

Erick Tryzelaar hace 10 años
padre
commit
703129c
Se han modificado 100 ficheros con 1869 adiciones y 14432 borrados
  1. 0 23
      desktop/core/ext-py/cffi-1.3.1/c/misc_thread.h
  2. 0 1811
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/backend_tests.py
  3. 0 42
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/callback_in_thread.py
  4. 0 7
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/distutils_module/setup.py
  5. 0 17
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/distutils_module/snip_basic_verify.py
  6. 0 7
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/distutils_package_1/setup.py
  7. 0 17
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/distutils_package_1/snip_basic_verify1/__init__.py
  8. 0 8
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/distutils_package_2/setup.py
  9. 0 18
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/distutils_package_2/snip_basic_verify2/__init__.py
  10. 0 5
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/infrastructure/setup.py
  11. 0 3
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/infrastructure/snip_infrastructure/__init__.py
  12. 0 8
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/setuptools_module/setup.py
  13. 0 17
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/setuptools_module/snip_setuptools_verify.py
  14. 0 8
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/setuptools_package_1/setup.py
  15. 0 17
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/setuptools_package_1/snip_setuptools_verify1/__init__.py
  16. 0 9
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/setuptools_package_2/setup.py
  17. 0 18
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/setuptools_package_2/snip_setuptools_verify2/__init__.py
  18. 0 39
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_cdata.py
  19. 0 40
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_ctypes.py
  20. 0 421
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_ffi_backend.py
  21. 0 495
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_function.py
  22. 0 111
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_model.py
  23. 0 284
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_ownlib.py
  24. 0 407
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_parsing.py
  25. 0 25
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_platform.py
  26. 0 79
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_unicode_literals.py
  27. 0 2420
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_verify.py
  28. 0 9
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_verify2.py
  29. 0 55
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_version.py
  30. 0 12
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_vgen.py
  31. 0 13
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_vgen2.py
  32. 0 288
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_zdistutils.py
  33. 0 145
      desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_zintegration.py
  34. 0 20
      desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_cffi_binary.py
  35. 0 34
      desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_commontypes.py
  36. 0 225
      desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_dlopen.py
  37. 0 9
      desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_dlopen_unicode_literals.py
  38. 0 417
      desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_ffi_obj.py
  39. 0 1720
      desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_new_ffi_1.py
  40. 0 360
      desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_parse_c_type.py
  41. 0 212
      desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_re_python.py
  42. 0 74
      desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_realize_c_type.py
  43. 0 1486
      desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_recompiler.py
  44. 0 43
      desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_unicode_literals.py
  45. 0 2271
      desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_verify1.py
  46. 0 367
      desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_zdist.py
  47. 0 19
      desktop/core/ext-py/cffi-1.3.1/testing/support.py
  48. 0 3
      desktop/core/ext-py/cffi-1.3.1/testing/udir.py
  49. 0 0
      desktop/core/ext-py/cffi-1.5.2/AUTHORS
  50. 0 0
      desktop/core/ext-py/cffi-1.5.2/LICENSE
  51. 2 2
      desktop/core/ext-py/cffi-1.5.2/MANIFEST.in
  52. 1 1
      desktop/core/ext-py/cffi-1.5.2/PKG-INFO
  53. 131 80
      desktop/core/ext-py/cffi-1.5.2/c/_cffi_backend.c
  54. 230 0
      desktop/core/ext-py/cffi-1.5.2/c/call_python.c
  55. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/cdlopen.c
  56. 24 9
      desktop/core/ext-py/cffi-1.5.2/c/cffi1_module.c
  57. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/cglob.c
  58. 2 1
      desktop/core/ext-py/cffi-1.5.2/c/commontypes.c
  59. 191 60
      desktop/core/ext-py/cffi-1.5.2/c/ffi_obj.c
  60. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/file_emulator.h
  61. 23 3
      desktop/core/ext-py/cffi-1.5.2/c/lib_obj.c
  62. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/ffi.c
  63. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/ffi.h
  64. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/ffi_common.h
  65. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/fficonfig.h
  66. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/ffitarget.h
  67. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/prep_cif.c
  68. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/types.c
  69. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/win32.c
  70. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/win64.asm
  71. BIN
      desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/win64.obj
  72. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/malloc_closure.h
  73. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/minibuffer.h
  74. 136 0
      desktop/core/ext-py/cffi-1.5.2/c/misc_thread_common.h
  75. 49 0
      desktop/core/ext-py/cffi-1.5.2/c/misc_thread_posix.h
  76. 42 42
      desktop/core/ext-py/cffi-1.5.2/c/misc_win32.h
  77. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/parse_c_type.c
  78. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/realize_c_type.c
  79. 1 1
      desktop/core/ext-py/cffi-1.5.2/c/test_c.py
  80. 0 0
      desktop/core/ext-py/cffi-1.5.2/c/wchar_helper.h
  81. 2 2
      desktop/core/ext-py/cffi-1.5.2/cffi/__init__.py
  82. 15 2
      desktop/core/ext-py/cffi-1.5.2/cffi/_cffi_include.h
  83. 517 0
      desktop/core/ext-py/cffi-1.5.2/cffi/_embedding.h
  84. 181 57
      desktop/core/ext-py/cffi-1.5.2/cffi/api.py
  85. 0 0
      desktop/core/ext-py/cffi-1.5.2/cffi/backend_ctypes.py
  86. 1 0
      desktop/core/ext-py/cffi-1.5.2/cffi/cffi_opcode.py
  87. 0 0
      desktop/core/ext-py/cffi-1.5.2/cffi/commontypes.py
  88. 85 18
      desktop/core/ext-py/cffi-1.5.2/cffi/cparser.py
  89. 14 8
      desktop/core/ext-py/cffi-1.5.2/cffi/ffiplatform.py
  90. 0 0
      desktop/core/ext-py/cffi-1.5.2/cffi/gc_weakref.py
  91. 0 0
      desktop/core/ext-py/cffi-1.5.2/cffi/lock.py
  92. 0 0
      desktop/core/ext-py/cffi-1.5.2/cffi/model.py
  93. 9 1
      desktop/core/ext-py/cffi-1.5.2/cffi/parse_c_type.h
  94. 204 7
      desktop/core/ext-py/cffi-1.5.2/cffi/recompiler.py
  95. 0 0
      desktop/core/ext-py/cffi-1.5.2/cffi/setuptools_ext.py
  96. 3 0
      desktop/core/ext-py/cffi-1.5.2/cffi/vengine_cpy.py
  97. 3 0
      desktop/core/ext-py/cffi-1.5.2/cffi/vengine_gen.py
  98. 3 0
      desktop/core/ext-py/cffi-1.5.2/cffi/verifier.py
  99. 0 0
      desktop/core/ext-py/cffi-1.5.2/demo/_curses.py
  100. 0 0
      desktop/core/ext-py/cffi-1.5.2/demo/_curses_build.py

+ 0 - 23
desktop/core/ext-py/cffi-1.3.1/c/misc_thread.h

@@ -1,23 +0,0 @@
-#include <pthread.h>
-
-/* This is only included if GCC doesn't support "__thread" global variables.
- * See USE__THREAD in _ffi_backend.c.
- */
-
-static pthread_key_t cffi_tls_key;
-
-static void init_errno(void)
-{
-    (void) pthread_key_create(&cffi_tls_key, NULL);
-}
-
-static void save_errno(void)
-{
-    intptr_t value = errno;
-    (void) pthread_setspecific(cffi_tls_key, (void *)value);
-}
-
-static void restore_errno(void) {
-    intptr_t value = (intptr_t)pthread_getspecific(cffi_tls_key);
-    errno = value;
-}

+ 0 - 1811
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/backend_tests.py

@@ -1,1811 +0,0 @@
-import py
-import platform
-import sys, ctypes
-from cffi import FFI, CDefError, FFIError, VerificationMissing
-from testing.support import *
-
-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)
-
-
-class BackendTests:
-
-    def test_integer_ranges(self):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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       # no __eq__(int)
-        assert bool(p) is True
-        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)   # unlikely
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        p = ffi.new("int[10]")
-        # the object was zero-initialized:
-        for i in range(10):
-            assert p[i] == 0
-
-    def test_array_indexing(self):
-        ffi = FFI(backend=self.Backend())
-        p = ffi.new("int[10]")
-        p[0] = 42
-        p[9] = 43
-        assert p[0] == 42
-        assert p[9] == 43
-        py.test.raises(IndexError, "p[10]")
-        py.test.raises(IndexError, "p[10] = 44")
-        py.test.raises(IndexError, "p[-1]")
-        py.test.raises(IndexError, "p[-1] = 44")
-
-    def test_new_array_args(self):
-        ffi = FFI(backend=self.Backend())
-        # 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):
-        ffi = FFI(backend=self.Backend())
-        p = ffi.new("int[]", 10)     # a single integer is the length
-        assert p[9] == 0
-        py.test.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
-        py.test.raises(IndexError, "p[2]")
-        assert repr(p) == "<cdata 'int[]' owning %d bytes>" % (2*SIZE_OF_INT)
-        #
-        p = ffi.new("int[]", 0)
-        py.test.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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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 = self.TypeRepr
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo { short a, b, c; };")
-        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 foo *")
-        assert repr(p) == "<cdata 'struct foo *' owning %d bytes>" % (
-            3*SIZE_OF_SHORT)
-        assert repr(ffi.typeof(p)) == typerepr % "struct foo *"
-        #
-        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 foo*")
-        q = ffi.cast("struct foo *", p)
-        assert repr(q).startswith("<cdata 'struct foo *' 0x")
-        assert repr(ffi.typeof(q)) == typerepr % "struct foo *"
-        prevrepr = repr(q)
-        q = q[0]
-        assert repr(q) == prevrepr.replace(' *', ' &')
-        assert repr(ffi.typeof(q)) == typerepr % "struct foo"
-
-    def test_new_array_of_array(self):
-        ffi = FFI(backend=self.Backend())
-        p = ffi.new("int[3][4]")
-        p[0][0] = 10
-        p[2][3] = 33
-        assert p[0][0] == 10
-        assert p[2][3] == 33
-        py.test.raises(IndexError, "p[1][-1]")
-
-    def test_constructor_array_of_array(self):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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 bool(ffi.cast("char", 0))
-        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):
-        ffi = FFI(backend=self.Backend())
-        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 bool(ffi.cast("wchar_t", 0))
-        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 sys.maxunicode == 0xffff
-            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):
-        ffi = FFI(backend=self.Backend())
-        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
-        py.test.raises(TypeError, "p[0] = None")
-        p[0] = ffi.NULL
-        assert p[0] == ffi.NULL
-
-    def test_float(self):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo { int a; short b, c; };")
-        s = ffi.new("struct foo*")
-        assert s.a == s.b == s.c == 0
-        s.b = -23
-        assert s.b == -23
-        py.test.raises(OverflowError, "s.b = 32768")
-        #
-        s = ffi.new("struct foo*", [-2, -3])
-        assert s.a == -2
-        assert s.b == -3
-        assert s.c == 0
-        py.test.raises((AttributeError, TypeError), "del s.a")
-        assert repr(s) == "<cdata 'struct foo *' owning %d bytes>" % (
-            SIZE_OF_INT + 2 * SIZE_OF_SHORT)
-        #
-        py.test.raises(ValueError, ffi.new, "struct foo*", [1, 2, 3, 4])
-
-    def test_constructor_struct_from_dict(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo { int a; short b, c; };")
-        s = ffi.new("struct foo*", {'b': 123, 'c': 456})
-        assert s.a == 0
-        assert s.b == 123
-        assert s.c == 456
-        py.test.raises(KeyError, ffi.new, "struct foo*", {'d': 456})
-
-    def test_struct_pointer(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo { int a; short b, c; };")
-        s = ffi.new("struct foo*")
-        assert s[0].a == s[0].b == s[0].c == 0
-        s[0].b = -23
-        assert s[0].b == s.b == -23
-        py.test.raises(OverflowError, "s[0].b = -32769")
-        py.test.raises(IndexError, "s[1]")
-
-    def test_struct_opaque(self):
-        ffi = FFI(backend=self.Backend())
-        py.test.raises(TypeError, ffi.new, "struct baz*")
-        p = ffi.new("struct baz **")    # this works
-        assert p[0] == ffi.NULL
-
-    def test_pointer_to_struct(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo { int a; short b, c; };")
-        s = ffi.new("struct foo *")
-        s.a = -42
-        assert s[0].a == -42
-        p = ffi.new("struct foo **", 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):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo { int a[2]; char b[3]; };")
-        s = ffi.new("struct foo *", [[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):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo { int value; struct foo *next; };")
-        s = ffi.new("struct foo*")
-        t = ffi.new("struct foo*")
-        s.value = 123
-        s.next = t
-        t.value = 456
-        assert s.value == 123
-        assert s.next.value == 456
-
-    def test_union_simple(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("union foo { int a; short b, c; };")
-        u = ffi.new("union foo*")
-        assert u.a == u.b == u.c == 0
-        u.b = -23
-        assert u.b == -23
-        assert u.a != 0
-        py.test.raises(OverflowError, "u.b = 32768")
-        #
-        u = ffi.new("union foo*", [-2])
-        assert u.a == -2
-        py.test.raises((AttributeError, TypeError), "del u.a")
-        assert repr(u) == "<cdata 'union foo *' owning %d bytes>" % SIZE_OF_INT
-
-    def test_union_opaque(self):
-        ffi = FFI(backend=self.Backend())
-        py.test.raises(TypeError, ffi.new, "union baz *")
-        u = ffi.new("union baz **")   # this works
-        assert u[0] == ffi.NULL
-
-    def test_union_initializer(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("union foo { char a; int b; };")
-        py.test.raises(TypeError, ffi.new, "union foo*", b'A')
-        py.test.raises(TypeError, ffi.new, "union foo*", 5)
-        py.test.raises(ValueError, ffi.new, "union foo*", [b'A', 5])
-        u = ffi.new("union foo*", [b'A'])
-        assert u.a == b'A'
-        py.test.raises(TypeError, ffi.new, "union foo*", [1005])
-        u = ffi.new("union foo*", {'b': 12345})
-        assert u.b == 12345
-        u = ffi.new("union foo*", [])
-        assert u.a == b'\x00'
-        assert u.b == 0
-
-    def test_sizeof_type(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            struct foo { int a; short b, c, d; };
-            union foo { int a; short b, c, d; };
-        """)
-        for c_type, expected_size in [
-            ('char', 1),
-            ('unsigned int', 4),
-            ('char *', SIZE_OF_PTR),
-            ('int[5]', 20),
-            ('struct foo', 12),
-            ('union foo', 4),
-            ]:
-            size = ffi.sizeof(c_type)
-            assert size == expected_size, (size, expected_size, ctype)
-
-    def test_sizeof_cdata(self):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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"
-        py.test.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):
-        ffi = FFI(backend=self.Backend())
-        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"
-        py.test.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
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo { const char *name; };")
-        t = ffi.new("const char[]", b"testing")
-        s = ffi.new("struct foo*", [t])
-        assert type(s.name) not in (bytes, str, unicode)
-        assert ffi.string(s.name) == b"testing"
-        py.test.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
-        ffi = FFI(backend=self.Backend())
-        self.check_wchar_t(ffi)
-        ffi.cdef("struct foo { const wchar_t *name; };")
-        t = ffi.new("const wchar_t[]", u+"testing")
-        s = ffi.new("struct foo*", [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):
-        ffi = FFI(backend=self.Backend())
-        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]
-        py.test.raises(TypeError, "vp[0]")
-        py.test.raises(TypeError, ffi.new, "short **", a)
-        #
-        ffi.cdef("struct foo { void *p; int *q; short *r; };")
-        s = ffi.new("struct foo *")
-        s.p = a    # works
-        s.q = a    # works
-        py.test.raises(TypeError, "s.r = a")    # fails
-        b = ffi.cast("int *", a)
-        s.p = b    # works
-        s.q = b    # works
-        py.test.raises(TypeError, "s.r = b")    # fails
-
-    def test_functionptr_simple(self):
-        ffi = FFI(backend=self.Backend())
-        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)
-        py.test.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):
-        ffi = FFI(backend=self.Backend())
-        t = ffi.typeof("int(*(*)(int))(int)")
-        assert repr(t) == self.TypeRepr % "int(*(*)(int))(int)"
-
-    def test_functionptr_voidptr_return(self):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        def foo():
-            pass
-        foo_cb = ffi.callback("void foo()", foo)
-        result = foo_cb()
-        assert result is None
-
-    def test_char_cast(self):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo_s { int a, b; };")
-        def cb(p):
-            return p[0].a * 1000 + p[0].b * 100 + p[1].a * 10 + p[1].b
-        a = ffi.callback("int(*)(struct foo_s[])", 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):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo_s { int a, b; };")
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("enum foo { A0, B0, CC0, D0 };")
-        assert ffi.string(ffi.cast("enum foo", 0)) == "A0"
-        assert ffi.string(ffi.cast("enum foo", 2)) == "CC0"
-        assert ffi.string(ffi.cast("enum foo", 3)) == "D0"
-        assert ffi.string(ffi.cast("enum foo", 4)) == "4"
-        ffi.cdef("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 foo", 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 foo", -1)) == (  # enums are unsigned, if
-            "<cdata 'enum foo' 4294967295>")        # they contain no neg value
-        ffi.cdef("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):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("enum foo { A, B, C, D }; struct bar { enum foo e; };")
-        s = ffi.new("struct bar *")
-        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 foo", -1)
-        assert s.e == 4294967295
-        assert s[0].e == 4294967295
-        s.e = s.e
-        py.test.raises(TypeError, "s.e = 'B'")
-        py.test.raises(TypeError, "s.e = '2'")
-        py.test.raises(TypeError, "s.e = '#2'")
-        py.test.raises(TypeError, "s.e = '#7'")
-
-    def test_enum_non_contiguous(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("enum foo { A, B=42, C };")
-        assert ffi.string(ffi.cast("enum foo", 0)) == "A"
-        assert ffi.string(ffi.cast("enum foo", 42)) == "B"
-        assert ffi.string(ffi.cast("enum foo", 43)) == "C"
-        invalid_value = ffi.cast("enum foo", 2)
-        assert int(invalid_value) == 2
-        assert ffi.string(invalid_value) == "2"
-
-    def test_enum_char_hex_oct(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef(r"enum foo{A='!', B='\'', C=0x10, D=010, E=- 0x10, F=-010};")
-        assert ffi.string(ffi.cast("enum foo", ord('!'))) == "A"
-        assert ffi.string(ffi.cast("enum foo", ord("'"))) == "B"
-        assert ffi.string(ffi.cast("enum foo", 16)) == "C"
-        assert ffi.string(ffi.cast("enum foo", 8)) == "D"
-        assert ffi.string(ffi.cast("enum foo", -16)) == "E"
-        assert ffi.string(ffi.cast("enum foo", -8)) == "F"
-
-    def test_enum_partial(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef(r"enum foo {A, ...}; enum bar { B, C };")
-        lib = ffi.dlopen(None)
-        assert lib.B == 0
-        py.test.raises(VerificationMissing, getattr, lib, "A")
-        assert lib.C == 1
-
-    def test_array_of_struct(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo { int a, b; };")
-        s = ffi.new("struct foo[1]")
-        py.test.raises(AttributeError, 's.b')
-        py.test.raises(AttributeError, 's.b = 412')
-        s[0].b = 412
-        assert s[0].b == 412
-        py.test.raises(IndexError, 's[1]')
-
-    def test_pointer_to_array(self):
-        ffi = FFI(backend=self.Backend())
-        p = ffi.new("int(**)[5]")
-        assert repr(p) == "<cdata 'int(* *)[5]' owning %d bytes>" % SIZE_OF_PTR
-
-    def test_iterate_array(self):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo { int a, b, c; };")
-        assert ffi.offsetof("struct foo", "a") == 0
-        assert ffi.offsetof("struct foo", "b") == 4
-        assert ffi.offsetof("struct foo", "c") == 8
-
-    def test_offsetof_nested(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo { int a, b, c; };"
-                 "struct bar { struct foo d, e; };")
-        assert ffi.offsetof("struct bar", "e") == 12
-        py.test.raises(KeyError, ffi.offsetof, "struct bar", "e.a")
-        assert ffi.offsetof("struct bar", "e", "a") == 12
-        assert ffi.offsetof("struct bar", "e", "b") == 16
-        assert ffi.offsetof("struct bar", "e", "c") == 20
-
-    def test_offsetof_array(self):
-        ffi = FFI(backend=self.Backend())
-        assert ffi.offsetof("int[]", 51) == 51 * ffi.sizeof("int")
-        assert ffi.offsetof("int *", 51) == 51 * ffi.sizeof("int")
-        ffi.cdef("struct bar { int a, b; int c[99]; };")
-        assert ffi.offsetof("struct bar", "c") == 2 * ffi.sizeof("int")
-        assert ffi.offsetof("struct bar", "c", 0) == 2 * ffi.sizeof("int")
-        assert ffi.offsetof("struct bar", "c", 51) == 53 * ffi.sizeof("int")
-
-    def test_alignof(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo { char a; short b; char c; };")
-        assert ffi.alignof("int") == 4
-        assert ffi.alignof("double") in (4, 8)
-        assert ffi.alignof("struct foo") == 2
-
-    def test_bitfield(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo { int a:10, b:20, c:3; };")
-        assert ffi.sizeof("struct foo") == 8
-        s = ffi.new("struct foo *")
-        s.a = 511
-        py.test.raises(OverflowError, "s.a = 512")
-        py.test.raises(OverflowError, "s[0].a = 512")
-        assert s.a == 511
-        s.a = -512
-        py.test.raises(OverflowError, "s.a = -513")
-        py.test.raises(OverflowError, "s[0].a = -513")
-        assert s.a == -512
-        s.c = 3
-        assert s.c == 3
-        py.test.raises(OverflowError, "s.c = 4")
-        py.test.raises(OverflowError, "s[0].c = 4")
-        s.c = -4
-        assert s.c == -4
-
-    def test_bitfield_enum(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            typedef enum { AA, BB, CC } foo_e;
-            typedef struct { foo_e f:2; } foo_s;
-        """)
-        s = ffi.new("foo_s *")
-        s.f = 2
-        assert s.f == 2
-
-    def test_anonymous_struct(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("typedef struct { int a; } foo_t;")
-        ffi.cdef("typedef struct { char b, c; } bar_t;")
-        f = ffi.new("foo_t *", [12345])
-        b = ffi.new("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 'bar_t *'")
-
-    def test_struct_with_two_usages(self):
-        for name in ['foo_s', '']:    # anonymous or not
-            ffi = FFI(backend=self.Backend())
-            ffi.cdef("typedef struct %s { int a; } foo_t, *foo_p;" % name)
-            f = ffi.new("foo_t *", [12345])
-            ps = ffi.new("foo_p[]", [f])
-
-    def test_pointer_arithmetic(self):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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_no_integer_comparison(self):
-        ffi = FFI(backend=self.Backend())
-        x = ffi.cast("int", 123)
-        y = ffi.cast("int", 456)
-        py.test.raises(TypeError, "x < y")
-        #
-        z = ffi.cast("double", 78.9)
-        py.test.raises(TypeError, "x < z")
-        py.test.raises(TypeError, "z < y")
-
-    def test_ffi_buffer_ptr(self):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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() == array.array('i', range(1000)).tostring()
-        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):
-        ffi = FFI(backend=self.Backend())
-        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() == array.array('i', range(1000)).tostring()
-        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):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo_s { int len; short data[5]; };")
-        p = ffi.new("struct foo_s *")
-        p.data[3] = 5
-        assert p.data[3] == 5
-        assert repr(p.data).startswith("<cdata 'short[5]' 0x")
-
-    def test_struct_containing_array_varsize_workaround(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo_s { int len; short data[0]; };")
-        p = ffi.new("char[]", ffi.sizeof("struct foo_s") + 7 * SIZE_OF_SHORT)
-        q = ffi.cast("struct foo_s *", 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 = FFI(backend=self.Backend())
-        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
-        py.test.raises(IndexError, "p.data[10]")
-
-    def test_ffi_typeof_getcname(self):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        f = ffi.cast("int(*)(int)", 42)
-        assert f != ffi.NULL
-        py.test.raises(CDefError, ffi.cast, "int(int)", 42)
-        py.test.raises(CDefError, 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.
-        ffi = FFI(backend=self.Backend())
-        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 '...'")
-        ffi = FFI(backend=self.Backend())
-        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 = FFI(backend=self.Backend())
-        #
-        @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_unique_types(self):
-        ffi1 = FFI(backend=self.Backend())
-        ffi2 = FFI(backend=self.Backend())
-        assert ffi1.typeof("char") is ffi2.typeof("char ")
-        assert ffi1.typeof("long") is ffi2.typeof("signed long int")
-        assert ffi1.typeof("double *") is ffi2.typeof("double*")
-        assert ffi1.typeof("int ***") is ffi2.typeof(" int * * *")
-        assert ffi1.typeof("int[]") is ffi2.typeof("signed int[]")
-        assert ffi1.typeof("signed int*[17]") is ffi2.typeof("int *[17]")
-        assert ffi1.typeof("void") is ffi2.typeof("void")
-        assert ffi1.typeof("int(*)(int,int)") is ffi2.typeof("int(*)(int,int)")
-        #
-        # these depend on user-defined data, so should not be shared
-        assert ffi1.typeof("struct foo") is not ffi2.typeof("struct foo")
-        assert ffi1.typeof("union foo *") is not ffi2.typeof("union foo*")
-        # the following test is an opaque enum, which we no longer support
-        #assert ffi1.typeof("enum foo") is not ffi2.typeof("enum foo")
-        # sanity check: twice 'ffi1'
-        assert ffi1.typeof("struct foo*") is ffi1.typeof("struct foo *")
-
-    def test_anonymous_enum(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("typedef enum { Value0 = 0 } e, *pe;\n"
-                 "typedef enum { Value1 = 1 } e1;")
-        assert ffi.getctype("e*") == 'e *'
-        assert ffi.getctype("pe") == 'e *'
-        assert ffi.getctype("e1*") == 'e1 *'
-
-    def test_opaque_enum(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("enum foo;")
-        from cffi import __version_info__
-        if __version_info__ < (1, 4):
-            py.test.skip("re-enable me in version 1.4")
-        e = py.test.raises(CDefError, ffi.cast, "enum foo", -1)
-        assert str(e.value) == (
-            "'enum foo' has no values explicitly defined: refusing to guess "
-            "which integer type it is meant to be (unsigned/signed, int/long)")
-
-    def test_new_ctype(self):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("enum e { AA=0, BB=0, CC=0, DD=0 };")
-        e = ffi.cast("enum e", 0)
-        assert ffi.string(e) == "AA"     # pick the first one arbitrarily
-
-    def test_enum_refer_previous_enum_value(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("enum e { AA, BB=2, CC=4, DD=BB, EE, FF=CC, GG=FF };")
-        assert ffi.string(ffi.cast("enum e", 2)) == "BB"
-        assert ffi.string(ffi.cast("enum e", 3)) == "EE"
-        assert ffi.sizeof("char[DD]") == 2
-        assert ffi.sizeof("char[EE]") == 3
-        assert ffi.sizeof("char[FF]") == 4
-        assert ffi.sizeof("char[GG]") == 4
-
-    def test_nested_anonymous_struct(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            struct foo_s {
-                struct { int a, b; };
-                union { int c, d; };
-            };
-        """)
-        assert ffi.sizeof("struct foo_s") == 3 * SIZE_OF_INT
-        p = ffi.new("struct foo_s *", [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 foo_s *", {'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):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            struct foo_s {
-                struct { int a; char b; };
-                union { char c; };
-            };
-        """)
-        assert ffi.offsetof("struct foo_s", "c") == 2 * SIZE_OF_INT
-        assert ffi.sizeof("struct foo_s") == 3 * SIZE_OF_INT
-
-    def test_nested_anonymous_union(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            union foo_u {
-                struct { int a, b; };
-                union { int c, d; };
-            };
-        """)
-        assert ffi.sizeof("union foo_u") == 2 * SIZE_OF_INT
-        p = ffi.new("union foo_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 foo_u *", {'d': 14})
-        assert p.a == 14
-        assert p.b == 0
-        assert p.c == 14
-        assert p.d == 14
-        p = ffi.new("union foo_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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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)
-        import gc; gc.collect()
-        assert seen == []
-        del q
-        import gc; gc.collect(); gc.collect(); gc.collect()
-        assert seen == [1]
-
-    def test_gc_2(self):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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_gc_finite_list(self):
-        ffi = FFI(backend=self.Backend())
-        public = not hasattr(ffi._backend, 'gcp')
-        p = ffi.new("int *", 123)
-        keepalive = []
-        for i in range(10):
-            keepalive.append(ffi.gc(p, lambda p: None))
-            if public:
-                assert len(ffi.gc_weakrefs.data) == i + 1
-        del keepalive[:]
-        import gc; gc.collect(); gc.collect()
-        for i in range(10):
-            keepalive.append(ffi.gc(p, lambda p: None))
-        if public:
-            assert len(ffi.gc_weakrefs.data) == 10
-
-    def test_CData_CType(self):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        assert isinstance(ffi.typeof("int"), ffi.CType)
-
-    def test_bool(self):
-        ffi = FFI(backend=self.Backend())
-        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_use_own_bool(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""typedef int bool;""")
-
-    def test_ordering_bug1(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            struct foo_s {
-                struct bar_s *p;
-            };
-            struct bar_s {
-                struct foo_s foo;
-            };
-        """)
-        q = ffi.new("struct foo_s *")
-        bar = ffi.new("struct bar_s *")
-        q.p = bar
-        assert q.p.foo.p == ffi.NULL
-
-    def test_ordering_bug2(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            struct bar_s;
-
-            struct foo_s {
-                void (*foo)(struct bar_s[]);
-            };
-
-            struct bar_s {
-                struct foo_s foo;
-            };
-        """)
-        q = ffi.new("struct foo_s *")
-
-    def test_addressof(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo_s { int x, y; };")
-        p = ffi.new("struct foo_s *")
-        a = ffi.addressof(p[0])
-        assert repr(a).startswith("<cdata 'struct foo_s *' 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):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo_s { int x, y; };")
-        p = ffi.new("struct foo_s *")
-        a = ffi.addressof(p[0], 'y')
-        assert repr(a).startswith("<cdata 'int *' 0x")
-        assert int(ffi.cast("uintptr_t", a)) == (
-            int(ffi.cast("uintptr_t", p)) + ffi.sizeof("int"))
-        assert a == ffi.addressof(p, 'y')
-        assert a != ffi.addressof(p, 'x')
-
-    def test_addressof_field_nested(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo_s { int x, y; };"
-                 "struct bar_s { struct foo_s a, b; };")
-        p = ffi.new("struct bar_s *")
-        py.test.raises(KeyError, ffi.addressof, p[0], 'b.y')
-        a = ffi.addressof(p[0], 'b', 'y')
-        assert int(ffi.cast("uintptr_t", a)) == (
-            int(ffi.cast("uintptr_t", p)) +
-            ffi.sizeof("struct foo_s") + ffi.sizeof("int"))
-
-    def test_addressof_anonymous_struct(self):
-        ffi = FFI()
-        ffi.cdef("typedef struct { int x; } foo_t;")
-        p = ffi.new("foo_t *")
-        a = ffi.addressof(p[0])
-        assert a == p
-
-    def test_addressof_array(self):
-        ffi = FFI()
-        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):
-        ffi = FFI()
-        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)
-        #
-        ffi.cdef("struct foo { int a, b; };")
-        array = ffi.new("struct foo[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):
-        ffi = FFI()
-        ffi.cdef("struct foo { int a, b; int c[50]; };")
-        p = ffi.new("struct foo *")
-        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 foo *")
-        assert p2 == p + 1
-
-    def test_multiple_independent_structs(self):
-        ffi1 = FFI(); ffi1.cdef("struct foo { int x; };")
-        ffi2 = FFI(); ffi2.cdef("struct foo { int y, z; };")
-        foo1 = ffi1.new("struct foo *", [10])
-        foo2 = ffi2.new("struct foo *", [20, 30])
-        assert foo1.x == 10
-        assert foo2.y == 20
-        assert foo2.z == 30
-
-    def test_missing_include(self):
-        backend = self.Backend()
-        ffi1 = FFI(backend=backend)
-        ffi2 = FFI(backend=backend)
-        ffi1.cdef("typedef signed char schar_t;")
-        py.test.raises(CDefError, ffi2.cast, "schar_t", 142)
-
-    def test_include_typedef(self):
-        backend = self.Backend()
-        ffi1 = FFI(backend=backend)
-        ffi2 = FFI(backend=backend)
-        ffi1.cdef("typedef signed char schar_t;")
-        ffi2.include(ffi1)
-        p = ffi2.cast("schar_t", 142)
-        assert int(p) == 142 - 256
-
-    def test_include_struct(self):
-        backend = self.Backend()
-        ffi1 = FFI(backend=backend)
-        ffi2 = FFI(backend=backend)
-        ffi1.cdef("struct foo { int x; };")
-        ffi2.include(ffi1)
-        p = ffi2.new("struct foo *", [142])
-        assert p.x == 142
-
-    def test_include_union(self):
-        backend = self.Backend()
-        ffi1 = FFI(backend=backend)
-        ffi2 = FFI(backend=backend)
-        ffi1.cdef("union foo { int x; };")
-        ffi2.include(ffi1)
-        p = ffi2.new("union foo *", [142])
-        assert p.x == 142
-
-    def test_include_enum(self):
-        backend = self.Backend()
-        ffi1 = FFI(backend=backend)
-        ffi2 = FFI(backend=backend)
-        ffi1.cdef("enum foo { FA, FB, FC };")
-        ffi2.include(ffi1)
-        p = ffi2.cast("enum foo", 1)
-        assert ffi2.string(p) == "FB"
-        assert ffi2.sizeof("char[FC]") == 2
-
-    def test_include_typedef_2(self):
-        backend = self.Backend()
-        ffi1 = FFI(backend=backend)
-        ffi2 = FFI(backend=backend)
-        ffi1.cdef("typedef struct { int x; } *foo_p;")
-        ffi2.include(ffi1)
-        p = ffi2.new("foo_p", [142])
-        assert p.x == 142
-
-    def test_ignore_multiple_declarations_of_constant(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("#define FOO 42")
-        ffi.cdef("#define FOO 42")
-        py.test.raises(FFIError, ffi.cdef, "#define FOO 43")
-
-    def test_struct_packed(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct nonpacked { char a; int b; };")
-        ffi.cdef("struct is_packed { char a; int b; };", packed=True)
-        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_define_integer_constant(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            #define DOT_0 0
-            #define DOT 100
-            #define DOT_OCT 0100l
-            #define DOT_HEX 0x100u
-            #define DOT_HEX2 0X10
-            #define DOT_UL 1000UL
-            enum foo {AA, BB=DOT, CC};
-        """)
-        lib = ffi.dlopen(None)
-        assert ffi.string(ffi.cast("enum foo", 100)) == "BB"
-        assert lib.DOT_0 == 0
-        assert lib.DOT == 100
-        assert lib.DOT_OCT == 0o100
-        assert lib.DOT_HEX == 0x100
-        assert lib.DOT_HEX2 == 0x10
-        assert lib.DOT_UL == 1000
-
-    def test_opaque_struct_becomes_nonopaque(self):
-        # Issue #193: if we use a struct between the first cdef() where it is
-        # declared and another cdef() where its fields are defined, then the
-        # definition was ignored.
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo_s;")
-        py.test.raises(TypeError, ffi.new, "struct foo_s *")
-        ffi.cdef("struct foo_s { int x; };")
-        ffi.new("struct foo_s *")
-
-    def test_ffi_self_include(self):
-        ffi = FFI(backend=self.Backend())
-        py.test.raises(ValueError, ffi.include, ffi)
-
-    def test_anonymous_enum_include(self):
-        ffi1 = FFI()
-        ffi1.cdef("enum { EE1 };")
-        ffi = FFI()
-        ffi.include(ffi1)
-        ffi.cdef("enum { EE2, EE3 };")
-        lib = ffi.dlopen(None)
-        assert lib.EE1 == 0
-        assert lib.EE2 == 0
-        assert lib.EE3 == 1

+ 0 - 42
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/callback_in_thread.py

@@ -1,42 +0,0 @@
-import sys, time
-sys.path.insert(0, sys.argv[1])
-from cffi import FFI
-
-def _run_callback_in_thread():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef int (*mycallback_func_t)(int, int);
-        int threaded_ballback_test(mycallback_func_t mycb);
-    """)
-    lib = ffi.verify("""
-        #include <pthread.h>
-        typedef int (*mycallback_func_t)(int, int);
-        void *my_wait_function(void *ptr) {
-            mycallback_func_t cbfunc = (mycallback_func_t)ptr;
-            cbfunc(10, 10);
-            cbfunc(12, 15);
-            return NULL;
-        }
-        int threaded_ballback_test(mycallback_func_t mycb) {
-            pthread_t thread;
-            pthread_create(&thread, NULL, my_wait_function, (void*)mycb);
-            return 0;
-        }
-    """, extra_compile_args=['-pthread'])
-    seen = []
-    @ffi.callback('int(*)(int,int)')
-    def mycallback(x, y):
-        time.sleep(0.022)
-        seen.append((x, y))
-        return 0
-    lib.threaded_ballback_test(mycallback)
-    count = 300
-    while len(seen) != 2:
-        time.sleep(0.01)
-        count -= 1
-        assert count > 0, "timeout"
-    assert seen == [(10, 10), (12, 15)]
-
-print('STARTING')
-_run_callback_in_thread()
-print('DONE')

+ 0 - 7
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/distutils_module/setup.py

@@ -1,7 +0,0 @@
-
-from distutils.core import setup
-import snip_basic_verify
-
-setup(
-    py_modules=['snip_basic_verify'],
-    ext_modules=[snip_basic_verify.ffi.verifier.get_extension()])

+ 0 - 17
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/distutils_module/snip_basic_verify.py

@@ -1,17 +0,0 @@
-
-from cffi import FFI
-import sys
-
-ffi = FFI()
-ffi.cdef("""     // some declarations from the man page
-    struct passwd {
-        char *pw_name;
-        ...;
-    };
-    struct passwd *getpwuid(int uid);
-""")
-C = ffi.verify("""   // passed to the real C compiler
-#include <sys/types.h>
-#include <pwd.h>
-""", libraries=[],    # or a list of libraries to link with
-     force_generic_engine=hasattr(sys, '_force_generic_engine_'))

+ 0 - 7
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/distutils_package_1/setup.py

@@ -1,7 +0,0 @@
-
-from distutils.core import setup
-import snip_basic_verify1
-
-setup(
-    packages=['snip_basic_verify1'],
-    ext_modules=[snip_basic_verify1.ffi.verifier.get_extension()])

+ 0 - 17
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/distutils_package_1/snip_basic_verify1/__init__.py

@@ -1,17 +0,0 @@
-
-from cffi import FFI
-import sys
-
-ffi = FFI()
-ffi.cdef("""     // some declarations from the man page
-    struct passwd {
-        char *pw_name;
-        ...;
-    };
-    struct passwd *getpwuid(int uid);
-""")
-C = ffi.verify("""   // passed to the real C compiler
-#include <sys/types.h>
-#include <pwd.h>
-""", libraries=[],    # or a list of libraries to link with
-     force_generic_engine=hasattr(sys, '_force_generic_engine_'))

+ 0 - 8
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/distutils_package_2/setup.py

@@ -1,8 +0,0 @@
-
-from distutils.core import setup
-import snip_basic_verify2
-
-setup(
-    packages=['snip_basic_verify2'],
-    ext_package='snip_basic_verify2',
-    ext_modules=[snip_basic_verify2.ffi.verifier.get_extension()])

+ 0 - 18
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/distutils_package_2/snip_basic_verify2/__init__.py

@@ -1,18 +0,0 @@
-
-from cffi import FFI
-import sys
-
-ffi = FFI()
-ffi.cdef("""     // some declarations from the man page
-    struct passwd {
-        char *pw_name;
-        ...;
-    };
-    struct passwd *getpwuid(int uid);
-""")
-C = ffi.verify("""   // passed to the real C compiler
-#include <sys/types.h>
-#include <pwd.h>
-""", libraries=[],    # or a list of libraries to link with
-     ext_package='snip_basic_verify2',
-     force_generic_engine=hasattr(sys, '_force_generic_engine_'))

+ 0 - 5
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/infrastructure/setup.py

@@ -1,5 +0,0 @@
-
-from distutils.core import setup
-
-setup(packages=['snip_infrastructure'],
-      requires=['cffi'])

+ 0 - 3
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/infrastructure/snip_infrastructure/__init__.py

@@ -1,3 +0,0 @@
-
-def func():
-    return 42

+ 0 - 8
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/setuptools_module/setup.py

@@ -1,8 +0,0 @@
-
-from setuptools import setup
-import snip_setuptools_verify
-
-setup(
-    zip_safe=False,
-    py_modules=['snip_setuptools_verify'],
-    ext_modules=[snip_setuptools_verify.ffi.verifier.get_extension()])

+ 0 - 17
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/setuptools_module/snip_setuptools_verify.py

@@ -1,17 +0,0 @@
-
-from cffi import FFI
-import sys
-
-ffi = FFI()
-ffi.cdef("""     // some declarations from the man page
-    struct passwd {
-        char *pw_name;
-        ...;
-    };
-    struct passwd *getpwuid(int uid);
-""")
-C = ffi.verify("""   // passed to the real C compiler
-#include <sys/types.h>
-#include <pwd.h>
-""", libraries=[],    # or a list of libraries to link with
-     force_generic_engine=hasattr(sys, '_force_generic_engine_'))

+ 0 - 8
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/setuptools_package_1/setup.py

@@ -1,8 +0,0 @@
-
-from setuptools import setup
-import snip_setuptools_verify1
-
-setup(
-    zip_safe=False,
-    packages=['snip_setuptools_verify1'],
-    ext_modules=[snip_setuptools_verify1.ffi.verifier.get_extension()])

+ 0 - 17
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/setuptools_package_1/snip_setuptools_verify1/__init__.py

@@ -1,17 +0,0 @@
-
-from cffi import FFI
-import sys
-
-ffi = FFI()
-ffi.cdef("""     // some declarations from the man page
-    struct passwd {
-        char *pw_name;
-        ...;
-    };
-    struct passwd *getpwuid(int uid);
-""")
-C = ffi.verify("""   // passed to the real C compiler
-#include <sys/types.h>
-#include <pwd.h>
-""", libraries=[],    # or a list of libraries to link with
-     force_generic_engine=hasattr(sys, '_force_generic_engine_'))

+ 0 - 9
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/setuptools_package_2/setup.py

@@ -1,9 +0,0 @@
-
-from setuptools import setup
-import snip_setuptools_verify2
-
-setup(
-    zip_safe=False,
-    packages=['snip_setuptools_verify2'],
-    ext_package='snip_setuptools_verify2',
-    ext_modules=[snip_setuptools_verify2.ffi.verifier.get_extension()])

+ 0 - 18
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/snippets/setuptools_package_2/snip_setuptools_verify2/__init__.py

@@ -1,18 +0,0 @@
-
-from cffi import FFI
-import sys
-
-ffi = FFI()
-ffi.cdef("""     // some declarations from the man page
-    struct passwd {
-        char *pw_name;
-        ...;
-    };
-    struct passwd *getpwuid(int uid);
-""")
-C = ffi.verify("""   // passed to the real C compiler
-#include <sys/types.h>
-#include <pwd.h>
-""", libraries=[],    # or a list of libraries to link with
-     ext_package='snip_setuptools_verify2',
-     force_generic_engine=hasattr(sys, '_force_generic_engine_'))

+ 0 - 39
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_cdata.py

@@ -1,39 +0,0 @@
-import py
-from cffi import FFI
-
-class FakeBackend(object):
-
-    def nonstandard_integer_types(self):
-        return {}
-
-    def sizeof(self, name):
-        return 1
-
-    def load_library(self, path):
-        return "fake library"
-
-    def new_primitive_type(self, name):
-        return FakeType("primitive " + name)
-
-    def new_void_type(self):
-        return FakeType("void")
-    def new_pointer_type(self, x):
-        return FakeType('ptr-to-%r' % (x,))
-    def new_array_type(self, x, y):
-        return FakeType('array-from-%r-len-%r' % (x, y))
-    def cast(self, x, y):
-        return 'casted!'
-    def _get_types(self):
-        return "CData", "CType"
-
-
-class FakeType(object):
-    def __init__(self, cdecl):
-        self.cdecl = cdecl
-
-
-def test_typeof():
-    ffi = FFI(backend=FakeBackend())
-    clong = ffi.typeof("signed long int")
-    assert isinstance(clong, FakeType)
-    assert clong.cdecl == 'primitive long'

+ 0 - 40
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_ctypes.py

@@ -1,40 +0,0 @@
-import py, sys
-from testing.cffi0 import backend_tests
-from cffi.backend_ctypes import CTypesBackend
-
-
-class TestCTypes(backend_tests.BackendTests):
-    # for individual tests see
-    # ====> backend_tests.py
-    
-    Backend = CTypesBackend
-    TypeRepr = "<class 'ffi.CData<%s>'>"
-
-    def test_array_of_func_ptr(self):
-        py.test.skip("ctypes backend: not supported: "
-                     "initializers for function pointers")
-
-    def test_structptr_argument(self):
-        py.test.skip("ctypes backend: not supported: passing a list "
-                     "for a pointer argument")
-
-    def test_array_argument_as_list(self):
-        py.test.skip("ctypes backend: not supported: passing a list "
-                     "for a pointer argument")
-
-    def test_cast_to_array_type(self):
-        py.test.skip("ctypes backend: not supported: casting to array")
-
-    def test_nested_anonymous_struct(self):
-        py.test.skip("ctypes backend: not supported: nested anonymous struct")
-
-    def test_nested_field_offset_align(self):
-        py.test.skip("ctypes backend: not supported: nested anonymous struct")
-
-    def test_nested_anonymous_union(self):
-        py.test.skip("ctypes backend: not supported: nested anonymous union")
-
-    def test_CData_CType_2(self):
-        if sys.version_info >= (3,):
-            py.test.skip("ctypes backend: not supported in Python 3: CType")
-        backend_tests.BackendTests.test_CData_CType_2(self)

+ 0 - 421
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_ffi_backend.py

@@ -1,421 +0,0 @@
-import py, sys, platform
-import pytest
-from testing.cffi0 import backend_tests, test_function, test_ownlib
-from cffi import FFI
-import _cffi_backend
-
-
-class TestFFI(backend_tests.BackendTests,
-              test_function.TestFunction,
-              test_ownlib.TestOwnLib):
-    TypeRepr = "<ctype '%s'>"
-
-    @staticmethod
-    def Backend():
-        return _cffi_backend
-
-    def test_not_supported_bitfield_in_result(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("struct foo_s { int a,b,c,d,e; int x:1; };")
-        e = py.test.raises(NotImplementedError, ffi.callback,
-                           "struct foo_s foo(void)", lambda: 42)
-        assert str(e.value) == ("struct foo_s(*)(): "
-            "callback with unsupported argument or return type or with '...'")
-
-    def test_inspecttype(self):
-        ffi = FFI(backend=self.Backend())
-        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):
-        ffi = FFI(backend=self.Backend())
-        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_callback_onerror(self):
-        ffi = FFI(backend=self.Backend())
-        seen = []
-        def oops(*args):
-            seen.append(args)
-        def otherfunc():
-            raise LookupError
-        def cb(n):
-            otherfunc()
-        a = ffi.callback("int(*)(int)", cb, error=42, onerror=oops)
-        res = a(234)
-        assert res == 42
-        assert len(seen) == 1
-        exc, val, tb = seen[0]
-        assert exc is LookupError
-        assert isinstance(val, LookupError)
-        assert tb.tb_frame.f_code.co_name == 'cb'
-        assert tb.tb_frame.f_locals['n'] == 234
-
-    def test_ffi_new_allocator_2(self):
-        ffi = FFI(backend=self.Backend())
-        seen = []
-        def myalloc(size):
-            seen.append(size)
-            return ffi.new("char[]", b"X" * size)
-        def myfree(raw):
-            seen.append(raw)
-        alloc1 = ffi.new_allocator(myalloc, myfree)
-        alloc2 = ffi.new_allocator(alloc=myalloc, free=myfree,
-                                   should_clear_after_alloc=False)
-        p1 = alloc1("int[10]")
-        p2 = alloc2("int[]", 10)
-        assert seen == [40, 40]
-        assert ffi.typeof(p1) == ffi.typeof("int[10]")
-        assert ffi.sizeof(p1) == 40
-        assert ffi.typeof(p2) == ffi.typeof("int[]")
-        assert ffi.sizeof(p2) == 40
-        assert p1[5] == 0
-        assert p2[6] == ord('X') * 0x01010101
-        raw1 = ffi.cast("char *", p1)
-        raw2 = ffi.cast("char *", p2)
-        del p1, p2
-        retries = 0
-        while len(seen) != 4:
-            retries += 1
-            assert retries <= 5
-            import gc; gc.collect()
-        assert seen == [40, 40, raw1, raw2]
-        assert repr(seen[2]) == "<cdata 'char[]' owning 41 bytes>"
-        assert repr(seen[3]) == "<cdata 'char[]' owning 41 bytes>"
-
-    def test_ffi_new_allocator_3(self):
-        ffi = FFI(backend=self.Backend())
-        seen = []
-        def myalloc(size):
-            seen.append(size)
-            return ffi.new("char[]", b"X" * size)
-        alloc1 = ffi.new_allocator(myalloc)    # no 'free'
-        p1 = alloc1("int[10]")
-        assert seen == [40]
-        assert ffi.typeof(p1) == ffi.typeof("int[10]")
-        assert ffi.sizeof(p1) == 40
-        assert p1[5] == 0
-
-    def test_ffi_new_allocator_4(self):
-        ffi = FFI(backend=self.Backend())
-        py.test.raises(TypeError, ffi.new_allocator, free=lambda x: None)
-        #
-        def myalloc2(size):
-            raise LookupError
-        alloc2 = ffi.new_allocator(myalloc2)
-        py.test.raises(LookupError, alloc2, "int[5]")
-        #
-        def myalloc3(size):
-            return 42
-        alloc3 = ffi.new_allocator(myalloc3)
-        e = py.test.raises(TypeError, alloc3, "int[5]")
-        assert str(e.value) == "alloc() must return a cdata object (got int)"
-        #
-        def myalloc4(size):
-            return ffi.cast("int", 42)
-        alloc4 = ffi.new_allocator(myalloc4)
-        e = py.test.raises(TypeError, alloc4, "int[5]")
-        assert str(e.value) == "alloc() must return a cdata pointer, not 'int'"
-        #
-        def myalloc5(size):
-            return ffi.NULL
-        alloc5 = ffi.new_allocator(myalloc5)
-        py.test.raises(MemoryError, alloc5, "int[5]")
-
-
-class TestBitfield:
-    def check(self, source, expected_ofs_y, expected_align, expected_size):
-        # NOTE: 'expected_*' is the numbers expected from GCC.
-        # The numbers expected from MSVC are not explicitly written
-        # in this file, and will just be taken from the compiler.
-        ffi = FFI()
-        ffi.cdef("struct s1 { %s };" % source)
-        ctype = ffi.typeof("struct s1")
-        # verify the information with gcc
-        ffi1 = FFI()
-        ffi1.cdef("""
-            static const int Gofs_y, Galign, Gsize;
-            struct s1 *try_with_value(int fieldnum, long long value);
-        """)
-        fnames = [name for name, cfield in ctype.fields
-                       if name and cfield.bitsize > 0]
-        setters = ['case %d: s.%s = value; break;' % iname
-                   for iname in enumerate(fnames)]
-        lib = ffi1.verify("""
-            struct s1 { %s };
-            struct sa { char a; struct s1 b; };
-            #define Gofs_y  offsetof(struct s1, y)
-            #define Galign  offsetof(struct sa, b)
-            #define Gsize   sizeof(struct s1)
-            struct s1 *try_with_value(int fieldnum, long long value)
-            {
-                static struct s1 s;
-                memset(&s, 0, sizeof(s));
-                switch (fieldnum) { %s }
-                return &s;
-            }
-        """ % (source, ' '.join(setters)))
-        if sys.platform == 'win32':
-            expected_ofs_y = lib.Gofs_y
-            expected_align = lib.Galign
-            expected_size  = lib.Gsize
-        else:
-            assert (lib.Gofs_y, lib.Galign, lib.Gsize) == (
-                expected_ofs_y, expected_align, expected_size)
-        # the real test follows
-        assert ffi.offsetof("struct s1", "y") == expected_ofs_y
-        assert ffi.alignof("struct s1") == expected_align
-        assert ffi.sizeof("struct s1") == expected_size
-        # compare the actual storage of the two
-        for name, cfield in ctype.fields:
-            if cfield.bitsize < 0 or not name:
-                continue
-            if int(ffi.cast(cfield.type, -1)) == -1:   # signed
-                min_value = -(1 << (cfield.bitsize-1))
-                max_value = (1 << (cfield.bitsize-1)) - 1
-            else:
-                min_value = 0
-                max_value = (1 << cfield.bitsize) - 1
-            for t in [1, 2, 4, 8, 16, 128, 2813, 89728, 981729,
-                     -1,-2,-4,-8,-16,-128,-2813,-89728,-981729]:
-                if min_value <= t <= max_value:
-                    self._fieldcheck(ffi, lib, fnames, name, t)
-
-    def _fieldcheck(self, ffi, lib, fnames, name, value):
-        s = ffi.new("struct s1 *")
-        setattr(s, name, value)
-        assert getattr(s, name) == value
-        raw1 = ffi.buffer(s)[:]
-        t = lib.try_with_value(fnames.index(name), value)
-        raw2 = ffi.buffer(t, len(raw1))[:]
-        assert raw1 == raw2
-
-    def test_bitfield_basic(self):
-        self.check("int a; int b:9; int c:20; int y;", 8, 4, 12)
-        self.check("int a; short b:9; short c:7; int y;", 8, 4, 12)
-        self.check("int a; short b:9; short c:9; int y;", 8, 4, 12)
-
-    def test_bitfield_reuse_if_enough_space(self):
-        self.check("int a:2; char y;", 1, 4, 4)
-        self.check("int a:1; char b  ; int c:1; char y;", 3, 4, 4)
-        self.check("int a:1; char b:8; int c:1; char y;", 3, 4, 4)
-        self.check("char a; int b:9; char y;", 3, 4, 4)
-        self.check("char a; short b:9; char y;", 4, 2, 6)
-        self.check("int a:2; char b:6; char y;", 1, 4, 4)
-        self.check("int a:2; char b:7; char y;", 2, 4, 4)
-        self.check("int a:2; short b:15; char c:2; char y;", 5, 4, 8)
-        self.check("int a:2; char b:1; char c:1; char y;", 1, 4, 4)
-
-    @pytest.mark.skipif("platform.machine().startswith(('arm', 'aarch64'))")
-    def test_bitfield_anonymous_no_align(self):
-        L = FFI().alignof("long long")
-        self.check("char y; int :1;", 0, 1, 2)
-        self.check("char x; int z:1; char y;", 2, 4, 4)
-        self.check("char x; int  :1; char y;", 2, 1, 3)
-        self.check("char x; long long z:48; char y;", 7, L, 8)
-        self.check("char x; long long  :48; char y;", 7, 1, 8)
-        self.check("char x; long long z:56; char y;", 8, L, 8 + L)
-        self.check("char x; long long  :56; char y;", 8, 1, 9)
-        self.check("char x; long long z:57; char y;", L + 8, L, L + 8 + L)
-        self.check("char x; long long  :57; char y;", L + 8, 1, L + 9)
-
-    @pytest.mark.skipif(
-        "not platform.machine().startswith(('arm', 'aarch64'))")
-    def test_bitfield_anonymous_align_arm(self):
-        L = FFI().alignof("long long")
-        self.check("char y; int :1;", 0, 4, 4)
-        self.check("char x; int z:1; char y;", 2, 4, 4)
-        self.check("char x; int  :1; char y;", 2, 4, 4)
-        self.check("char x; long long z:48; char y;", 7, L, 8)
-        self.check("char x; long long  :48; char y;", 7, 8, 8)
-        self.check("char x; long long z:56; char y;", 8, L, 8 + L)
-        self.check("char x; long long  :56; char y;", 8, L, 8 + L)
-        self.check("char x; long long z:57; char y;", L + 8, L, L + 8 + L)
-        self.check("char x; long long  :57; char y;", L + 8, L, L + 8 + L)
-
-    @pytest.mark.skipif("platform.machine().startswith(('arm', 'aarch64'))")
-    def test_bitfield_zero(self):
-        L = FFI().alignof("long long")
-        self.check("char y; int :0;", 0, 1, 4)
-        self.check("char x; int :0; char y;", 4, 1, 5)
-        self.check("char x; int :0; int :0; char y;", 4, 1, 5)
-        self.check("char x; long long :0; char y;", L, 1, L + 1)
-        self.check("short x, y; int :0; int :0;", 2, 2, 4)
-        self.check("char x; int :0; short b:1; char y;", 5, 2, 6)
-        self.check("int a:1; int :0; int b:1; char y;", 5, 4, 8)
-
-    @pytest.mark.skipif(
-        "not platform.machine().startswith(('arm', 'aarch64'))")
-    def test_bitfield_zero_arm(self):
-        L = FFI().alignof("long long")
-        self.check("char y; int :0;", 0, 4, 4)
-        self.check("char x; int :0; char y;", 4, 4, 8)
-        self.check("char x; int :0; int :0; char y;", 4, 4, 8)
-        self.check("char x; long long :0; char y;", L, 8, L + 8)
-        self.check("short x, y; int :0; int :0;", 2, 4, 4)
-        self.check("char x; int :0; short b:1; char y;", 5, 4, 8)
-        self.check("int a:1; int :0; int b:1; char y;", 5, 4, 8)
-
-    def test_error_cases(self):
-        ffi = FFI()
-        py.test.raises(TypeError,
-            'ffi.cdef("struct s1 { float x:1; };"); ffi.new("struct s1 *")')
-        py.test.raises(TypeError,
-            'ffi.cdef("struct s2 { char x:0; };"); ffi.new("struct s2 *")')
-        py.test.raises(TypeError,
-            'ffi.cdef("struct s3 { char x:9; };"); ffi.new("struct s3 *")')
-
-    def test_struct_with_typedef(self):
-        ffi = FFI()
-        ffi.cdef("typedef struct { float x; } foo_t;")
-        p = ffi.new("foo_t *", [5.2])
-        assert repr(p).startswith("<cdata 'foo_t *' ")
-
-    def test_struct_array_no_length(self):
-        ffi = FFI()
-        ffi.cdef("struct foo_s { int x; int a[]; };")
-        p = ffi.new("struct foo_s *", [100, [200, 300, 400]])
-        assert p.x == 100
-        assert ffi.typeof(p.a) is ffi.typeof("int *")   # no length available
-        assert p.a[0] == 200
-        assert p.a[1] == 300
-        assert p.a[2] == 400
-
-    @pytest.mark.skipif("sys.platform != 'win32'")
-    def test_getwinerror(self):
-        ffi = FFI()
-        code, message = ffi.getwinerror(1155)
-        assert code == 1155
-        assert message == ("No application is associated with the "
-                           "specified file for this operation")
-        ffi.cdef("void SetLastError(int);")
-        lib = ffi.dlopen("Kernel32.dll")
-        lib.SetLastError(2)
-        code, message = ffi.getwinerror()
-        assert code == 2
-        assert message == "The system cannot find the file specified"
-        code, message = ffi.getwinerror(-1)
-        assert code == 2
-        assert message == "The system cannot find the file specified"
-
-    def test_from_buffer(self):
-        import array
-        ffi = FFI()
-        a = array.array('H', [10000, 20000, 30000])
-        c = ffi.from_buffer(a)
-        assert ffi.typeof(c) is ffi.typeof("char[]")
-        ffi.cast("unsigned short *", c)[1] += 500
-        assert list(a) == [10000, 20500, 30000]
-
-    def test_memmove(self):
-        ffi = FFI()
-        p = ffi.new("short[]", [-1234, -2345, -3456, -4567, -5678])
-        ffi.memmove(p, p + 1, 4)
-        assert list(p) == [-2345, -3456, -3456, -4567, -5678]
-        p[2] = 999
-        ffi.memmove(p + 2, p, 6)
-        assert list(p) == [-2345, -3456, -2345, -3456, 999]
-        ffi.memmove(p + 4, ffi.new("char[]", 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(self):
-        import array
-        ffi = FFI()
-        a = array.array('H', [10000, 20000, 30000])
-        p = ffi.new("short[]", 5)
-        ffi.memmove(p, a, 6)
-        assert list(p) == [10000, 20000, 30000, 0, 0]
-        ffi.memmove(p + 1, a, 6)
-        assert list(p) == [10000, 10000, 20000, 30000, 0]
-        b = array.array('h', [-1000, -2000, -3000])
-        ffi.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
-        ffi.memmove(b, p, 2)
-        assert b.tolist() == [999, 20000, -3000]
-        ffi.memmove(b, p + 2, 4)
-        assert b.tolist() == [997, 996, -3000]
-        p[2] = -p[2]
-        p[3] = -p[3]
-        ffi.memmove(b, p + 2, 6)
-        assert b.tolist() == [-997, -996, 995]
-
-    def test_memmove_readonly_readwrite(self):
-        ffi = FFI()
-        p = ffi.new("signed char[]", 5)
-        ffi.memmove(p, b"abcde", 3)
-        assert list(p) == [ord("a"), ord("b"), ord("c"), 0, 0]
-        ffi.memmove(p, bytearray(b"ABCDE"), 2)
-        assert list(p) == [ord("A"), ord("B"), ord("c"), 0, 0]
-        py.test.raises((TypeError, BufferError), ffi.memmove, b"abcde", p, 3)
-        ba = bytearray(b"xxxxx")
-        ffi.memmove(dest=ba, src=p, n=3)
-        assert ba == bytearray(b"ABcxx")
-
-    def test_all_primitives(self):
-        ffi = FFI()
-        for name in [
-            "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",
-            "_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",
-            ]:
-            x = ffi.sizeof(name)
-            assert 1 <= x <= 16

+ 0 - 495
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_function.py

@@ -1,495 +0,0 @@
-import py
-from cffi import FFI, CDefError
-import math, os, sys
-import ctypes.util
-from cffi.backend_ctypes import CTypesBackend
-from testing.udir import udir
-
-try:
-    from StringIO import StringIO
-except ImportError:
-    from io import StringIO
-
-
-class FdWriteCapture(object):
-    """xxx limited to capture at most 512 bytes of output, according
-    to the Posix manual."""
-
-    def __init__(self, capture_fd):
-        self.capture_fd = capture_fd
-
-    def __enter__(self):
-        self.read_fd, self.write_fd = os.pipe()
-        self.copy_fd = os.dup(self.capture_fd)
-        os.dup2(self.write_fd, self.capture_fd)
-        return self
-
-    def __exit__(self, *args):
-        os.dup2(self.copy_fd, self.capture_fd)
-        os.close(self.copy_fd)
-        os.close(self.write_fd)
-        self._value = os.read(self.read_fd, 512)
-        os.close(self.read_fd)
-
-    def getvalue(self):
-        return self._value
-
-lib_m = 'm'
-if sys.platform == 'win32':
-    #there is a small chance this fails on Mingw via environ $CC
-    import distutils.ccompiler
-    if distutils.ccompiler.get_default_compiler() == 'msvc':
-        lib_m = 'msvcrt'
-
-class TestFunction(object):
-    Backend = CTypesBackend
-
-    def test_sin(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            double sin(double x);
-        """)
-        m = ffi.dlopen(lib_m)
-        x = m.sin(1.23)
-        assert x == math.sin(1.23)
-
-    def test_sinf(self):
-        if sys.platform == 'win32':
-            py.test.skip("no sinf found in the Windows stdlib")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            float sinf(float x);
-        """)
-        m = ffi.dlopen(lib_m)
-        x = m.sinf(1.23)
-        assert type(x) is float
-        assert x != math.sin(1.23)    # rounding effects
-        assert abs(x - math.sin(1.23)) < 1E-6
-
-    def test_sin_no_return_value(self):
-        # check that 'void'-returning functions work too
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            void sin(double x);
-        """)
-        m = ffi.dlopen(lib_m)
-        x = m.sin(1.23)
-        assert x is None
-
-    def test_dlopen_filename(self):
-        path = ctypes.util.find_library(lib_m)
-        if not path:
-            py.test.skip("%s not found" % lib_m)
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            double cos(double x);
-        """)
-        m = ffi.dlopen(path)
-        x = m.cos(1.23)
-        assert x == math.cos(1.23)
-
-        m = ffi.dlopen(os.path.basename(path))
-        x = m.cos(1.23)
-        assert x == math.cos(1.23)
-
-    def test_dlopen_flags(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            double cos(double x);
-        """)
-        m = ffi.dlopen(lib_m, ffi.RTLD_LAZY | ffi.RTLD_LOCAL)
-        x = m.cos(1.23)
-        assert x == math.cos(1.23)
-
-    def test_dlopen_constant(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            #define FOOBAR 42
-            static const float baz = 42.5;   /* not visible */
-            double sin(double x);
-        """)
-        m = ffi.dlopen(lib_m)
-        assert m.FOOBAR == 42
-        py.test.raises(NotImplementedError, "m.baz")
-
-    def test_tlsalloc(self):
-        if sys.platform != 'win32':
-            py.test.skip("win32 only")
-        if self.Backend is CTypesBackend:
-            py.test.skip("ctypes complains on wrong calling conv")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("long TlsAlloc(void); int TlsFree(long);")
-        lib = ffi.dlopen('KERNEL32.DLL')
-        x = lib.TlsAlloc()
-        assert x != 0
-        y = lib.TlsFree(x)
-        assert y != 0
-
-    def test_fputs(self):
-        if not sys.platform.startswith('linux'):
-            py.test.skip("probably no symbol 'stderr' in the lib")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            int fputs(const char *, void *);
-            void *stderr;
-        """)
-        ffi.C = ffi.dlopen(None)
-        ffi.C.fputs   # fetch before capturing, for easier debugging
-        with FdWriteCapture(2) as fd:
-            ffi.C.fputs(b"hello\n", ffi.C.stderr)
-            ffi.C.fputs(b"  world\n", ffi.C.stderr)
-        res = fd.getvalue()
-        assert res == b'hello\n  world\n'
-
-    def test_fputs_without_const(self):
-        if not sys.platform.startswith('linux'):
-            py.test.skip("probably no symbol 'stderr' in the lib")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            int fputs(char *, void *);
-            void *stderr;
-        """)
-        ffi.C = ffi.dlopen(None)
-        ffi.C.fputs   # fetch before capturing, for easier debugging
-        with FdWriteCapture(2) as fd:
-            ffi.C.fputs(b"hello\n", ffi.C.stderr)
-            ffi.C.fputs(b"  world\n", ffi.C.stderr)
-        res = fd.getvalue()
-        assert res == b'hello\n  world\n'
-
-    def test_vararg(self):
-        if not sys.platform.startswith('linux'):
-            py.test.skip("probably no symbol 'stderr' in the lib")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-           int fprintf(void *, const char *format, ...);
-           void *stderr;
-        """)
-        ffi.C = ffi.dlopen(None)
-        with FdWriteCapture(2) as fd:
-            ffi.C.fprintf(ffi.C.stderr, b"hello with no arguments\n")
-            ffi.C.fprintf(ffi.C.stderr,
-                          b"hello, %s!\n", ffi.new("char[]", b"world"))
-            ffi.C.fprintf(ffi.C.stderr,
-                          ffi.new("char[]", b"hello, %s!\n"),
-                          ffi.new("char[]", b"world2"))
-            ffi.C.fprintf(ffi.C.stderr,
-                          b"hello int %d long %ld long long %lld\n",
-                          ffi.cast("int", 42),
-                          ffi.cast("long", 84),
-                          ffi.cast("long long", 168))
-            ffi.C.fprintf(ffi.C.stderr, b"hello %p\n", ffi.NULL)
-        res = fd.getvalue()
-        assert res == (b"hello with no arguments\n"
-                       b"hello, world!\n"
-                       b"hello, world2!\n"
-                       b"hello int 42 long 84 long long 168\n"
-                       b"hello (nil)\n")
-
-    def test_must_specify_type_of_vararg(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-           int printf(const char *format, ...);
-        """)
-        ffi.C = ffi.dlopen(None)
-        e = py.test.raises(TypeError, ffi.C.printf, b"hello %d\n", 42)
-        assert str(e.value) == ("argument 2 passed in the variadic part "
-                                "needs to be a cdata object (got int)")
-
-    def test_function_has_a_c_type(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            int puts(const char *);
-        """)
-        ffi.C = ffi.dlopen(None)
-        fptr = ffi.C.puts
-        assert ffi.typeof(fptr) == ffi.typeof("int(*)(const char*)")
-        if self.Backend is CTypesBackend:
-            assert repr(fptr).startswith("<cdata 'int puts(char *)' 0x")
-
-    def test_function_pointer(self):
-        ffi = FFI(backend=self.Backend())
-        def cb(charp):
-            assert repr(charp).startswith("<cdata 'char *' 0x")
-            return 42
-        fptr = ffi.callback("int(*)(const char *txt)", cb)
-        assert fptr != ffi.callback("int(*)(const char *)", cb)
-        assert repr(fptr) == "<cdata 'int(*)(char *)' calling %r>" % (cb,)
-        res = fptr(b"Hello")
-        assert res == 42
-        #
-        if not sys.platform.startswith('linux'):
-            py.test.skip("probably no symbol 'stderr' in the lib")
-        ffi.cdef("""
-            int fputs(const char *, void *);
-            void *stderr;
-        """)
-        ffi.C = ffi.dlopen(None)
-        fptr = ffi.cast("int(*)(const char *txt, void *)", ffi.C.fputs)
-        assert fptr == ffi.C.fputs
-        assert repr(fptr).startswith("<cdata 'int(*)(char *, void *)' 0x")
-        with FdWriteCapture(2) as fd:
-            fptr(b"world\n", ffi.C.stderr)
-        res = fd.getvalue()
-        assert res == b'world\n'
-
-    def test_callback_returning_void(self):
-        ffi = FFI(backend=self.Backend())
-        for returnvalue in [None, 42]:
-            def cb():
-                return returnvalue
-            fptr = ffi.callback("void(*)(void)", cb)
-            old_stderr = sys.stderr
-            try:
-                sys.stderr = StringIO()
-                returned = fptr()
-                printed = sys.stderr.getvalue()
-            finally:
-                sys.stderr = old_stderr
-            assert returned is None
-            if returnvalue is None:
-                assert printed == ''
-            else:
-                assert "None" in printed
-
-    def test_passing_array(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            int strlen(char[]);
-        """)
-        ffi.C = ffi.dlopen(None)
-        p = ffi.new("char[]", b"hello")
-        res = ffi.C.strlen(p)
-        assert res == 5
-
-    def test_write_variable(self):
-        if not sys.platform.startswith('linux'):
-            py.test.skip("probably no symbol 'stdout' in the lib")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            void *stdout;
-        """)
-        C = ffi.dlopen(None)
-        pout = C.stdout
-        C.stdout = ffi.NULL
-        assert C.stdout == ffi.NULL
-        C.stdout = pout
-        assert C.stdout == pout
-
-    def test_strchr(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            char *strchr(const char *s, int c);
-        """)
-        ffi.C = ffi.dlopen(None)
-        p = ffi.new("char[]", b"hello world!")
-        q = ffi.C.strchr(p, ord('w'))
-        assert ffi.string(q) == b"world!"
-
-    def test_function_with_struct_argument(self):
-        if sys.platform == 'win32':
-            py.test.skip("no 'inet_ntoa'")
-        if (self.Backend is CTypesBackend and
-            '__pypy__' in sys.builtin_module_names):
-            py.test.skip("ctypes limitation on pypy")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            struct in_addr { unsigned int s_addr; };
-            char *inet_ntoa(struct in_addr in);
-        """)
-        ffi.C = ffi.dlopen(None)
-        ina = ffi.new("struct in_addr *", [0x04040404])
-        a = ffi.C.inet_ntoa(ina[0])
-        assert ffi.string(a) == b'4.4.4.4'
-
-    def test_function_typedef(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            typedef double func_t(double);
-            func_t sin;
-        """)
-        m = ffi.dlopen(lib_m)
-        x = m.sin(1.23)
-        assert x == math.sin(1.23)
-
-    def test_fputs_custom_FILE(self):
-        if self.Backend is CTypesBackend:
-            py.test.skip("FILE not supported with the ctypes backend")
-        filename = str(udir.join('fputs_custom_FILE'))
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("int fputs(const char *, FILE *);")
-        C = ffi.dlopen(None)
-        with open(filename, 'wb') as f:
-            f.write(b'[')
-            C.fputs(b"hello from custom file", f)
-            f.write(b'][')
-            C.fputs(b"some more output", f)
-            f.write(b']')
-        with open(filename, 'rb') as f:
-            res = f.read()
-        assert res == b'[hello from custom file][some more output]'
-
-    def test_constants_on_lib(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""enum foo_e { AA, BB, CC=5, DD };
-                    typedef enum { EE=-5, FF } some_enum_t;""")
-        lib = ffi.dlopen(None)
-        assert lib.AA == 0
-        assert lib.BB == 1
-        assert lib.CC == 5
-        assert lib.DD == 6
-        assert lib.EE == -5
-        assert lib.FF == -4
-
-    def test_void_star_accepts_string(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""int strlen(const void *);""")
-        lib = ffi.dlopen(None)
-        res = lib.strlen(b"hello")
-        assert res == 5
-
-    def test_signed_char_star_accepts_string(self):
-        if self.Backend is CTypesBackend:
-            py.test.skip("not supported by the ctypes backend")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""int strlen(signed char *);""")
-        lib = ffi.dlopen(None)
-        res = lib.strlen(b"hello")
-        assert res == 5
-
-    def test_unsigned_char_star_accepts_string(self):
-        if self.Backend is CTypesBackend:
-            py.test.skip("not supported by the ctypes backend")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""int strlen(unsigned char *);""")
-        lib = ffi.dlopen(None)
-        res = lib.strlen(b"hello")
-        assert res == 5
-
-    def test_missing_function(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            int nonexistent();
-        """)
-        m = ffi.dlopen(lib_m)
-        assert not hasattr(m, 'nonexistent')
-
-    def test_wraps_from_stdlib(self):
-        import functools
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            double sin(double x);
-        """)
-        def my_decorator(f):
-            @functools.wraps(f)
-            def wrapper(*args):
-                return f(*args) + 100
-            return wrapper
-        m = ffi.dlopen(lib_m)
-        sin100 = my_decorator(m.sin)
-        x = sin100(1.23)
-        assert x == math.sin(1.23) + 100
-
-    def test_free_callback_cycle(self):
-        if self.Backend is CTypesBackend:
-            py.test.skip("seems to fail with the ctypes backend on windows")
-        import weakref
-        def make_callback(data):
-            container = [data]
-            callback = ffi.callback('int()', lambda: len(container))
-            container.append(callback)
-            # Ref cycle: callback -> lambda (closure) -> container -> callback
-            return callback
-
-        class Data(object):
-            pass
-        ffi = FFI(backend=self.Backend())
-        data = Data()
-        callback = make_callback(data)
-        wr = weakref.ref(data)
-        del callback, data
-        for i in range(3):
-            if wr() is not None:
-                import gc; gc.collect()
-        assert wr() is None    # 'data' does not leak
-
-    def test_windows_stdcall(self):
-        if sys.platform != 'win32':
-            py.test.skip("Windows-only test")
-        if self.Backend is CTypesBackend:
-            py.test.skip("not with the ctypes backend")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            BOOL QueryPerformanceFrequency(LONGLONG *lpFrequency);
-        """)
-        m = ffi.dlopen("Kernel32.dll")
-        p_freq = ffi.new("LONGLONG *")
-        res = m.QueryPerformanceFrequency(p_freq)
-        assert res != 0
-        assert p_freq[0] != 0
-
-    def test_explicit_cdecl_stdcall(self):
-        if sys.platform != 'win32':
-            py.test.skip("Windows-only test")
-        if self.Backend is CTypesBackend:
-            py.test.skip("not with the ctypes backend")
-        win64 = (sys.maxsize > 2**32)
-        #
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            BOOL QueryPerformanceFrequency(LONGLONG *lpFrequency);
-        """)
-        m = ffi.dlopen("Kernel32.dll")
-        tp = ffi.typeof(m.QueryPerformanceFrequency)
-        assert str(tp) == "<ctype 'int(*)(long long *)'>"
-        #
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            BOOL __cdecl QueryPerformanceFrequency(LONGLONG *lpFrequency);
-        """)
-        m = ffi.dlopen("Kernel32.dll")
-        tpc = ffi.typeof(m.QueryPerformanceFrequency)
-        assert tpc is tp
-        #
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            BOOL WINAPI QueryPerformanceFrequency(LONGLONG *lpFrequency);
-        """)
-        m = ffi.dlopen("Kernel32.dll")
-        tps = ffi.typeof(m.QueryPerformanceFrequency)
-        if win64:
-            assert tps is tpc
-        else:
-            assert tps is not tpc
-            assert str(tps) == "<ctype 'int(__stdcall *)(long long *)'>"
-        #
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("typedef int (__cdecl *fnc_t)(int);")
-        ffi.cdef("typedef int (__stdcall *fns_t)(int);")
-        tpc = ffi.typeof("fnc_t")
-        tps = ffi.typeof("fns_t")
-        assert str(tpc) == "<ctype 'int(*)(int)'>"
-        if win64:
-            assert tps is tpc
-        else:
-            assert str(tps) == "<ctype 'int(__stdcall *)(int)'>"
-        #
-        fnc = ffi.cast("fnc_t", 0)
-        fns = ffi.cast("fns_t", 0)
-        ffi.new("fnc_t[]", [fnc])
-        if not win64:
-            py.test.raises(TypeError, ffi.new, "fnc_t[]", [fns])
-            py.test.raises(TypeError, ffi.new, "fns_t[]", [fnc])
-        ffi.new("fns_t[]", [fns])
-
-    def test_stdcall_only_on_windows(self):
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("double __stdcall sin(double x);")     # stdcall ignored
-        m = ffi.dlopen(lib_m)
-        if (sys.platform == 'win32' and sys.maxsize < 2**32 and 
-                self.Backend is not CTypesBackend):
-            assert "double(__stdcall *)(double)" in str(ffi.typeof(m.sin))
-        else:
-            assert "double(*)(double)" in str(ffi.typeof(m.sin))
-        x = m.sin(1.23)
-        assert x == math.sin(1.23)

+ 0 - 111
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_model.py

@@ -1,111 +0,0 @@
-from cffi.model import *
-
-
-def test_void_type():
-    assert void_type.get_c_name() == "void"
-    assert void_type.get_c_name("foo") == "void foo"
-    assert void_type.get_c_name("*foo") == "void *foo"
-
-def test_primitive_type():
-    int_type = PrimitiveType("int")
-    assert int_type.get_c_name() == "int"
-    assert int_type.get_c_name("foo") == "int foo"
-    assert int_type.get_c_name("*foo") == "int *foo"
-    assert int_type.get_c_name("[5]") == "int[5]"
-
-def test_raw_function_type():
-    int_type = PrimitiveType("int")
-    fn_type = RawFunctionType([], int_type, False)
-    assert fn_type.get_c_name() == "int()(void)"
-    assert fn_type.get_c_name("*") == "int( *)(void)"
-    assert fn_type.get_c_name("*foo") == "int( *foo)(void)"
-    fn_type = RawFunctionType([int_type], int_type, False)
-    assert fn_type.get_c_name() == "int()(int)"
-    fn_type = RawFunctionType([int_type] * 2, int_type, False)
-    assert fn_type.get_c_name() == "int()(int, int)"
-    #
-    fn_type = RawFunctionType([int_type], int_type, True)
-    assert fn_type.get_c_name() == "int()(int, ...)"
-    assert fn_type.get_c_name("*foo") == "int( *foo)(int, ...)"
-    #
-    res_type = FunctionPtrType([int_type], int_type, True)
-    fn_type = RawFunctionType([int_type], res_type, True)
-    assert fn_type.get_c_name("x") == "int(*( x)(int, ...))(int, ...)"
-
-def test_function_ptr_type():
-    int_type = PrimitiveType("int")
-    fn_type = FunctionPtrType([], int_type, False)
-    assert fn_type.get_c_name() == "int(*)(void)"
-    assert fn_type.get_c_name("*") == "int(* *)(void)"
-    assert fn_type.get_c_name("*foo") == "int(* *foo)(void)"
-    fn_type = FunctionPtrType([int_type], int_type, False)
-    assert fn_type.get_c_name() == "int(*)(int)"
-    fn_type = FunctionPtrType([int_type] * 2, int_type, False)
-    assert fn_type.get_c_name() == "int(*)(int, int)"
-    #
-    fn_type = FunctionPtrType([int_type], int_type, True)
-    assert fn_type.get_c_name() == "int(*)(int, ...)"
-
-def test_pointer_type():
-    ptr_type = PointerType(PrimitiveType("int"))
-    assert ptr_type.get_c_name("x") == "int * x"
-
-def test_const_pointer_type():
-    ptr_type = ConstPointerType(PrimitiveType("int"))
-    assert ptr_type.get_c_name("x") == "int const * x"
-    ptr_type = ConstPointerType(ArrayType(PrimitiveType("int"), 5))
-    assert ptr_type.get_c_name("") == "int(const *)[5]"
-    assert ptr_type.get_c_name("*x") == "int(const * *x)[5]"
-
-def test_qual_pointer_type():
-    ptr_type = PointerType(PrimitiveType("long long"), Q_RESTRICT)
-    assert ptr_type.get_c_name("") == "long long __restrict *"
-    assert const_voidp_type.get_c_name("") == "void const *"
-
-def test_unknown_pointer_type():
-    ptr_type = unknown_ptr_type("foo_p")
-    assert ptr_type.get_c_name("") == "foo_p"
-    assert ptr_type.get_c_name("x") == "foo_p x"
-
-def test_unknown_type():
-    u_type = unknown_type("foo_t")
-    assert u_type.get_c_name("") == "foo_t"
-    assert u_type.get_c_name("x") == "foo_t x"
-
-def test_array_type():
-    a_type = ArrayType(PrimitiveType("int"), None)
-    assert a_type.get_c_name("") == "int[]"
-    assert a_type.get_c_name("x") == "int x[]"
-    assert a_type.get_c_name("*x") == "int(*x)[]"
-    assert a_type.get_c_name(" *x") == "int(*x)[]"
-    assert a_type.get_c_name("[5]") == "int[5][]"
-    a_type = ArrayType(unknown_type("foo_t"), 5)
-    assert a_type.get_c_name("") == "foo_t[5]"
-    assert a_type.get_c_name("x") == "foo_t x[5]"
-    assert a_type.get_c_name("*x") == "foo_t(*x)[5]"
-    a_type = ArrayType(unknown_ptr_type("foo_p"), None)
-    assert a_type.get_c_name("") == "foo_p[]"
-    assert a_type.get_c_name("x") == "foo_p x[]"
-    assert a_type.get_c_name("*x") == "foo_p(*x)[]"
-    a_type = ArrayType(ConstPointerType(PrimitiveType("int")), None)
-    assert a_type.get_c_name("") == "int const *[]"
-    assert a_type.get_c_name("x") == "int const * x[]"
-    assert a_type.get_c_name("*x") == "int const *(*x)[]"
-    fn_type = FunctionPtrType([], PrimitiveType("int"), False)
-    a_type = ArrayType(fn_type, 5)
-    assert a_type.get_c_name("") == "int(*[5])(void)"
-    assert a_type.get_c_name("x") == "int(* x[5])(void)"
-    assert a_type.get_c_name("*x") == "int(*(*x)[5])(void)"
-
-def test_struct_type():
-    struct_type = StructType("foo_s", None, None, None)
-    assert struct_type.get_c_name() == "struct foo_s"
-    assert struct_type.get_c_name("*x") == "struct foo_s *x"
-
-def test_union_type():
-    union_type = UnionType("foo_s", None, None, None)
-    assert union_type.get_c_name() == "union foo_s"
-
-def test_enum_type():
-    enum_type = EnumType("foo_e", [], [])
-    assert enum_type.get_c_name() == "enum foo_e"

+ 0 - 284
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_ownlib.py

@@ -1,284 +0,0 @@
-import py, sys
-import subprocess, weakref
-from cffi import FFI
-from cffi.backend_ctypes import CTypesBackend
-
-
-SOURCE = """\
-#include <errno.h>
-
-#ifdef _WIN32
-#define EXPORT __declspec(dllexport)
-#else
-#define EXPORT
-#endif
-
-EXPORT int test_getting_errno(void) {
-    errno = 123;
-    return -1;
-}
-
-EXPORT int test_setting_errno(void) {
-    return errno;
-};
-
-typedef struct {
-    long x;
-    long y;
-} POINT;
-
-typedef struct {
-    long left;
-    long top;
-    long right;
-    long bottom;
-} RECT;
-
-
-EXPORT int PointInRect(RECT *prc, POINT pt)
-{
-    if (pt.x < prc->left)
-        return 0;
-    if (pt.x > prc->right)
-        return 0;
-    if (pt.y < prc->top)
-        return 0;
-    if (pt.y > prc->bottom)
-        return 0;
-    return 1;
-};
-
-EXPORT long left = 10;
-EXPORT long top = 20;
-EXPORT long right = 30;
-EXPORT long bottom = 40;
-
-EXPORT RECT ReturnRect(int i, RECT ar, RECT* br, POINT cp, RECT dr,
-                        RECT *er, POINT fp, RECT gr)
-{
-    /*Check input */
-    if (ar.left + br->left + dr.left + er->left + gr.left != left * 5)
-    {
-        ar.left = 100;
-        return ar;
-    }
-    if (ar.right + br->right + dr.right + er->right + gr.right != right * 5)
-    {
-        ar.right = 100;
-        return ar;
-    }
-    if (cp.x != fp.x)
-    {
-        ar.left = -100;
-    }
-    if (cp.y != fp.y)
-    {
-        ar.left = -200;
-    }
-    switch(i)
-    {
-    case 0:
-        return ar;
-        break;
-    case 1:
-        return dr;
-        break;
-    case 2:
-        return gr;
-        break;
-
-    }
-    return ar;
-}
-
-EXPORT int my_array[7] = {0, 1, 2, 3, 4, 5, 6};
-"""
-
-class TestOwnLib(object):
-    Backend = CTypesBackend
-
-    def setup_class(cls):
-        cls.module = None
-        from testing.udir import udir
-        udir.join('testownlib.c').write(SOURCE)
-        if sys.platform == 'win32':
-            import os
-            # did we already build it?
-            if os.path.exists(str(udir.join('testownlib.dll'))):
-                cls.module = str(udir.join('testownlib.dll'))
-                return
-            # try (not too hard) to find the version used to compile this python
-            # no mingw
-            from distutils.msvc9compiler import get_build_version
-            version = get_build_version()
-            toolskey = "VS%0.f0COMNTOOLS" % version
-            toolsdir = os.environ.get(toolskey, None)
-            if toolsdir is None:
-                return
-            productdir = os.path.join(toolsdir, os.pardir, os.pardir, "VC")
-            productdir = os.path.abspath(productdir)
-            vcvarsall = os.path.join(productdir, "vcvarsall.bat")
-            # 64?
-            arch = 'x86'
-            if sys.maxsize > 2**32:
-                arch = 'amd64'
-            if os.path.isfile(vcvarsall):
-                cmd = '"%s" %s' % (vcvarsall, arch) + ' & cl.exe testownlib.c ' \
-                        ' /LD /Fetestownlib.dll'
-                subprocess.check_call(cmd, cwd = str(udir), shell=True)    
-                cls.module = str(udir.join('testownlib.dll'))
-        else:
-            subprocess.check_call(
-                'gcc testownlib.c -shared -fPIC -o testownlib.so',
-                cwd=str(udir), shell=True)
-            cls.module = str(udir.join('testownlib.so'))
-
-    def test_getting_errno(self):
-        if self.module is None:
-            py.test.skip("fix the auto-generation of the tiny test lib")
-        if sys.platform == 'win32':
-            py.test.skip("fails, errno at multiple addresses")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            int test_getting_errno(void);
-        """)
-        ownlib = ffi.dlopen(self.module)
-        res = ownlib.test_getting_errno()
-        assert res == -1
-        assert ffi.errno == 123
-
-    def test_setting_errno(self):
-        if self.module is None:
-            py.test.skip("fix the auto-generation of the tiny test lib")
-        if sys.platform == 'win32':
-            py.test.skip("fails, errno at multiple addresses")
-        if self.Backend is CTypesBackend and '__pypy__' in sys.modules:
-            py.test.skip("XXX errno issue with ctypes on pypy?")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            int test_setting_errno(void);
-        """)
-        ownlib = ffi.dlopen(self.module)
-        ffi.errno = 42
-        res = ownlib.test_setting_errno()
-        assert res == 42
-        assert ffi.errno == 42
-
-    def test_my_array_7(self):
-        if self.module is None:
-            py.test.skip("fix the auto-generation of the tiny test lib")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            int my_array[7];
-        """)
-        ownlib = ffi.dlopen(self.module)
-        for i in range(7):
-            assert ownlib.my_array[i] == i
-        assert len(ownlib.my_array) == 7
-        if self.Backend is CTypesBackend:
-            py.test.skip("not supported by the ctypes backend")
-        ownlib.my_array = list(range(10, 17))
-        for i in range(7):
-            assert ownlib.my_array[i] == 10 + i
-        ownlib.my_array = list(range(7))
-        for i in range(7):
-            assert ownlib.my_array[i] == i
-
-    def test_my_array_no_length(self):
-        if self.module is None:
-            py.test.skip("fix the auto-generation of the tiny test lib")
-        if self.Backend is CTypesBackend:
-            py.test.skip("not supported by the ctypes backend")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            int my_array[];
-        """)
-        ownlib = ffi.dlopen(self.module)
-        for i in range(7):
-            assert ownlib.my_array[i] == i
-        py.test.raises(TypeError, len, ownlib.my_array)
-        ownlib.my_array = list(range(10, 17))
-        for i in range(7):
-            assert ownlib.my_array[i] == 10 + i
-        ownlib.my_array = list(range(7))
-        for i in range(7):
-            assert ownlib.my_array[i] == i
-
-    def test_keepalive_lib(self):
-        if self.module is None:
-            py.test.skip("fix the auto-generation of the tiny test lib")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            int test_getting_errno(void);
-        """)
-        ownlib = ffi.dlopen(self.module)
-        ffi_r = weakref.ref(ffi)
-        ownlib_r = weakref.ref(ownlib)
-        func = ownlib.test_getting_errno
-        del ffi
-        import gc; gc.collect()       # ownlib stays alive
-        assert ownlib_r() is not None
-        assert ffi_r() is not None    # kept alive by ownlib
-        res = func()
-        assert res == -1
-
-    def test_keepalive_ffi(self):
-        if self.module is None:
-            py.test.skip("fix the auto-generation of the tiny test lib")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            int test_getting_errno(void);
-        """)
-        ownlib = ffi.dlopen(self.module)
-        ffi_r = weakref.ref(ffi)
-        ownlib_r = weakref.ref(ownlib)
-        func = ownlib.test_getting_errno
-        del ownlib
-        import gc; gc.collect()       # ffi stays alive
-        assert ffi_r() is not None
-        assert ownlib_r() is not None # kept alive by ffi
-        res = func()
-        assert res == -1
-        if sys.platform != 'win32':  # else, errno at multiple addresses
-            assert ffi.errno == 123
-
-    def test_struct_by_value(self):
-        if self.module is None:
-            py.test.skip("fix the auto-generation of the tiny test lib")
-        ffi = FFI(backend=self.Backend())
-        ffi.cdef("""
-            typedef struct {
-                long x;
-                long y;
-            } POINT;
-
-            typedef struct {
-                long left;
-                long top;
-                long right;
-                long bottom;
-            } RECT;
-            
-            long left, top, right, bottom;
-
-            RECT ReturnRect(int i, RECT ar, RECT* br, POINT cp, RECT dr,
-                        RECT *er, POINT fp, RECT gr);
-        """)
-        ownlib = ffi.dlopen(self.module)
-
-        rect = ffi.new('RECT[1]')
-        pt = ffi.new('POINT[1]')
-        pt[0].x = 15
-        pt[0].y = 25
-        rect[0].left = ownlib.left
-        rect[0].right = ownlib.right
-        rect[0].top = ownlib.top
-        rect[0].bottom = ownlib.bottom
-        
-        for i in range(4):
-            ret = ownlib.ReturnRect(i, rect[0], rect, pt[0], rect[0],
-                                    rect, pt[0], rect[0])
-            assert ret.left == ownlib.left
-            assert ret.right == ownlib.right
-            assert ret.top == ownlib.top
-            assert ret.bottom == ownlib.bottom

+ 0 - 407
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_parsing.py

@@ -1,407 +0,0 @@
-import py, sys, re
-from cffi import FFI, FFIError, CDefError, VerificationError
-
-class FakeBackend(object):
-
-    def nonstandard_integer_types(self):
-        return {}
-
-    def sizeof(self, name):
-        return 1
-
-    def load_library(self, name, flags):
-        if sys.platform == 'win32':
-            assert name is None or "msvcr" in name
-        else:
-            assert name is None or "libc" in name or "libm" in name
-        return FakeLibrary()
-
-    def new_function_type(self, args, result, has_varargs):
-        args = [arg.cdecl for arg in args]
-        result = result.cdecl
-        return FakeType(
-            '<func (%s), %s, %s>' % (', '.join(args), result, has_varargs))
-
-    def new_primitive_type(self, name):
-        assert name == name.lower()
-        return FakeType('<%s>' % name)
-
-    def new_pointer_type(self, itemtype):
-        return FakeType('<pointer to %s>' % (itemtype,))
-
-    def new_struct_type(self, name):
-        return FakeStruct(name)
-
-    def complete_struct_or_union(self, s, fields, tp=None,
-                                 totalsize=-1, totalalignment=-1, sflags=0):
-        assert isinstance(s, FakeStruct)
-        s.fields = fields
-
-    def new_array_type(self, ptrtype, length):
-        return FakeType('<array %s x %s>' % (ptrtype, length))
-
-    def new_void_type(self):
-        return FakeType("<void>")
-    def cast(self, x, y):
-        return 'casted!'
-    def _get_types(self):
-        return "CData", "CType"
-
-class FakeType(object):
-    def __init__(self, cdecl):
-        self.cdecl = cdecl
-    def __str__(self):
-        return self.cdecl
-
-class FakeStruct(object):
-    def __init__(self, name):
-        self.name = name
-    def __str__(self):
-        return ', '.join([str(y) + str(x) for x, y, z in self.fields])
-
-class FakeLibrary(object):
-
-    def load_function(self, BType, name):
-        return FakeFunction(BType, name)
-
-class FakeFunction(object):
-
-    def __init__(self, BType, name):
-        self.BType = str(BType)
-        self.name = name
-
-lib_m = "m"
-if sys.platform == 'win32':
-    #there is a small chance this fails on Mingw via environ $CC
-    import distutils.ccompiler
-    if distutils.ccompiler.get_default_compiler() == 'msvc':
-        lib_m = 'msvcrt'
-
-def test_simple():
-    ffi = FFI(backend=FakeBackend())
-    ffi.cdef("double sin(double x);")
-    m = ffi.dlopen(lib_m)
-    func = m.sin    # should be a callable on real backends
-    assert func.name == 'sin'
-    assert func.BType == '<func (<double>), <double>, False>'
-
-def test_pipe():
-    ffi = FFI(backend=FakeBackend())
-    ffi.cdef("int pipe(int pipefd[2]);")
-    C = ffi.dlopen(None)
-    func = C.pipe
-    assert func.name == 'pipe'
-    assert func.BType == '<func (<pointer to <int>>), <int>, False>'
-
-def test_vararg():
-    ffi = FFI(backend=FakeBackend())
-    ffi.cdef("short foo(int, ...);")
-    C = ffi.dlopen(None)
-    func = C.foo
-    assert func.name == 'foo'
-    assert func.BType == '<func (<int>), <short>, True>'
-
-def test_no_args():
-    ffi = FFI(backend=FakeBackend())
-    ffi.cdef("""
-        int foo(void);
-        """)
-    C = ffi.dlopen(None)
-    assert C.foo.BType == '<func (), <int>, False>'
-
-def test_typedef():
-    ffi = FFI(backend=FakeBackend())
-    ffi.cdef("""
-        typedef unsigned int UInt;
-        typedef UInt UIntReally;
-        UInt foo(void);
-        """)
-    C = ffi.dlopen(None)
-    assert str(ffi.typeof("UIntReally")) == '<unsigned int>'
-    assert C.foo.BType == '<func (), <unsigned int>, False>'
-
-def test_typedef_more_complex():
-    ffi = FFI(backend=FakeBackend())
-    ffi.cdef("""
-        typedef struct { int a, b; } foo_t, *foo_p;
-        int foo(foo_p[]);
-        """)
-    C = ffi.dlopen(None)
-    assert str(ffi.typeof("foo_t")) == '<int>a, <int>b'
-    assert str(ffi.typeof("foo_p")) == '<pointer to <int>a, <int>b>'
-    assert C.foo.BType == ('<func (<pointer to <pointer to '
-                           '<int>a, <int>b>>), <int>, False>')
-
-def test_typedef_array_convert_array_to_pointer():
-    ffi = FFI(backend=FakeBackend())
-    ffi.cdef("""
-        typedef int (*fn_t)(int[5]);
-        """)
-    with ffi._lock:
-        type = ffi._parser.parse_type("fn_t")
-        BType = ffi._get_cached_btype(type)
-    assert str(BType) == '<func (<pointer to <int>>), <int>, False>'
-
-def test_remove_comments():
-    ffi = FFI(backend=FakeBackend())
-    ffi.cdef("""
-        double /*comment here*/ sin   // blah blah
-        /* multi-
-           line-
-           //comment */  (
-        // foo
-        double // bar      /* <- ignored, because it's in a comment itself
-        x, double/*several*//*comment*/y) /*on the same line*/
-        ;
-    """)
-    m = ffi.dlopen(lib_m)
-    func = m.sin
-    assert func.name == 'sin'
-    assert func.BType == '<func (<double>, <double>), <double>, False>'
-
-def test_remove_line_continuation_comments():
-    ffi = FFI(backend=FakeBackend())
-    ffi.cdef("""
-        double // blah \\
-                  more comments
-        x(void);
-        double // blah\\\\
-        y(void);
-        double // blah\\ \
-                  etc
-        z(void);
-    """)
-    m = ffi.dlopen(lib_m)
-    m.x
-    m.y
-    m.z
-
-def test_line_continuation_in_defines():
-    ffi = FFI(backend=FakeBackend())
-    ffi.cdef("""
-        #define ABC\\
-            42
-        #define BCD   \\
-            43
-    """)
-    m = ffi.dlopen(lib_m)
-    assert m.ABC == 42
-    assert m.BCD == 43
-
-def test_define_not_supported_for_now():
-    ffi = FFI(backend=FakeBackend())
-    e = py.test.raises(CDefError, ffi.cdef, '#define FOO "blah"')
-    assert str(e.value) == (
-        'only supports one of the following syntax:\n'
-        '  #define FOO ...     (literally dot-dot-dot)\n'
-        '  #define FOO NUMBER  (with NUMBER an integer'
-                                    ' constant, decimal/hex/octal)\n'
-        'got:\n'
-        '  #define FOO "blah"')
-
-def test_unnamed_struct():
-    ffi = FFI(backend=FakeBackend())
-    ffi.cdef("typedef struct { int x; } foo_t;\n"
-             "typedef struct { int y; } *bar_p;\n")
-    assert 'typedef foo_t' in ffi._parser._declarations
-    assert 'typedef bar_p' in ffi._parser._declarations
-    assert 'anonymous foo_t' in ffi._parser._declarations
-    type_foo = ffi._parser.parse_type("foo_t")
-    type_bar = ffi._parser.parse_type("bar_p").totype
-    assert repr(type_foo) == "<foo_t>"
-    assert repr(type_bar) == "<struct $1>"
-    py.test.raises(VerificationError, type_bar.get_c_name)
-    assert type_foo.get_c_name() == "foo_t"
-
-def test_override():
-    ffi = FFI(backend=FakeBackend())
-    C = ffi.dlopen(None)
-    ffi.cdef("int foo(void);")
-    py.test.raises(FFIError, ffi.cdef, "long foo(void);")
-    assert C.foo.BType == '<func (), <int>, False>'
-    ffi.cdef("long foo(void);", override=True)
-    assert C.foo.BType == '<func (), <long>, False>'
-
-def test_cannot_have_only_variadic_part():
-    # this checks that we get a sensible error if we try "int foo(...);"
-    ffi = FFI()
-    e = py.test.raises(CDefError, ffi.cdef, "int foo(...);")
-    assert str(e.value) == \
-           "foo: a function with only '(...)' as argument is not correct C"
-
-def test_parse_error():
-    ffi = FFI()
-    e = py.test.raises(CDefError, ffi.cdef, " x y z ")
-    assert re.match(r'cannot parse "x y z"\n:\d+:', str(e.value))
-
-def test_cannot_declare_enum_later():
-    ffi = FFI()
-    e = py.test.raises(NotImplementedError, ffi.cdef,
-                       "typedef enum foo_e foo_t; enum foo_e { AA, BB };")
-    assert str(e.value) == (
-           "enum foo_e: the '{}' declaration should appear on the "
-           "first time the enum is mentioned, not later")
-
-def test_unknown_name():
-    ffi = FFI()
-    e = py.test.raises(CDefError, ffi.cast, "foobarbazunknown", 0)
-    assert str(e.value) == "unknown identifier 'foobarbazunknown'"
-    e = py.test.raises(CDefError, ffi.cast, "foobarbazunknown*", 0)
-    assert str(e.value).startswith('cannot parse "foobarbazunknown*"')
-    e = py.test.raises(CDefError, ffi.cast, "int(*)(foobarbazunknown)", 0)
-    assert str(e.value).startswith('cannot parse "int(*)(foobarbazunknown)"')
-
-def test_redefine_common_type():
-    prefix = "" if sys.version_info < (3,) else "b"
-    ffi = FFI()
-    ffi.cdef("typedef char FILE;")
-    assert repr(ffi.cast("FILE", 123)) == "<cdata 'char' %s'{'>" % prefix
-    ffi.cdef("typedef char int32_t;")
-    assert repr(ffi.cast("int32_t", 123)) == "<cdata 'char' %s'{'>" % prefix
-    ffi = FFI()
-    ffi.cdef("typedef int bool, *FILE;")
-    assert repr(ffi.cast("bool", 123)) == "<cdata 'int' 123>"
-    assert re.match(r"<cdata 'int [*]' 0[xX]?0*7[bB]>",
-                    repr(ffi.cast("FILE", 123)))
-    ffi = FFI()
-    ffi.cdef("typedef bool (*fn_t)(bool, bool);")   # "bool," but within "( )"
-
-def test_bool():
-    ffi = FFI()
-    ffi.cdef("void f(bool);")
-    #
-    ffi = FFI()
-    ffi.cdef("typedef _Bool bool; void f(bool);")
-
-def test_unknown_argument_type():
-    ffi = FFI()
-    e = py.test.raises(CDefError, ffi.cdef, "void f(foobarbazzz);")
-    assert str(e.value) == ("f arg 1: unknown type 'foobarbazzz' (if you meant"
-                            " to use the old C syntax of giving untyped"
-                            " arguments, it is not supported)")
-
-def test_void_renamed_as_only_arg():
-    ffi = FFI()
-    ffi.cdef("typedef void void_t1;"
-             "typedef void_t1 void_t;"
-             "typedef int (*func_t)(void_t);")
-    assert ffi.typeof("func_t").args == ()
-
-def test_WPARAM_on_windows():
-    if sys.platform != 'win32':
-        py.test.skip("Only for Windows")
-    ffi = FFI()
-    ffi.cdef("void f(WPARAM);")
-    #
-    # WPARAM -> UINT_PTR -> unsigned 32/64-bit integer
-    ffi = FFI()
-    value = int(ffi.cast("WPARAM", -42))
-    assert value == sys.maxsize * 2 - 40
-
-def test__is_constant_globalvar():
-    for input, expected_output in [
-        ("int a;",          False),
-        ("const int a;",    True),
-        ("int *a;",         False),
-        ("const int *a;",   False),
-        ("int const *a;",   False),
-        ("int *const a;",   True),
-        ("int a[5];",       False),
-        ("const int a[5];", False),
-        ("int *a[5];",      False),
-        ("const int *a[5];", False),
-        ("int const *a[5];", False),
-        ("int *const a[5];", False),
-        ("int a[5][6];",       False),
-        ("const int a[5][6];", False),
-        ]:
-        ffi = FFI()
-        ffi.cdef(input)
-        declarations = ffi._parser._declarations
-        assert ('constant a' in declarations) == expected_output
-        assert ('variable a' in declarations) == (not expected_output)
-
-def test_restrict():
-    from cffi import model
-    for input, expected_output in [
-        ("int a;",             False),
-        ("restrict int a;",    True),
-        ("int *a;",            False),
-        ]:
-        ffi = FFI()
-        ffi.cdef(input)
-        tp, quals = ffi._parser._declarations['variable a']
-        assert bool(quals & model.Q_RESTRICT) == expected_output
-
-def test_different_const_funcptr_types():
-    lst = []
-    for input in [
-        "int(*)(int *a)",
-        "int(*)(int const *a)",
-        "int(*)(int * const a)",
-        "int(*)(int const a[])"]:
-        ffi = FFI(backend=FakeBackend())
-        lst.append(ffi._parser.parse_type(input))
-    assert lst[0] != lst[1]
-    assert lst[0] == lst[2]
-    assert lst[1] == lst[3]
-
-def test_const_pointer_to_pointer():
-    from cffi import model
-    ffi = FFI(backend=FakeBackend())
-    #
-    tp, qual = ffi._parser.parse_type_and_quals("char * * (* const)")
-    assert (str(tp), qual) == ("<char * * *>", model.Q_CONST)
-    tp, qual = ffi._parser.parse_type_and_quals("char * (* const (*))")
-    assert (str(tp), qual) == ("<char * * const *>", 0)
-    tp, qual = ffi._parser.parse_type_and_quals("char (* const (* (*)))")
-    assert (str(tp), qual) == ("<char * const * *>", 0)
-    tp, qual = ffi._parser.parse_type_and_quals("char const * * *")
-    assert (str(tp), qual) == ("<char const * * *>", 0)
-    tp, qual = ffi._parser.parse_type_and_quals("const char * * *")
-    assert (str(tp), qual) == ("<char const * * *>", 0)
-    #
-    tp, qual = ffi._parser.parse_type_and_quals("char * * * const const")
-    assert (str(tp), qual) == ("<char * * *>", model.Q_CONST)
-    tp, qual = ffi._parser.parse_type_and_quals("char * * volatile *")
-    assert (str(tp), qual) == ("<char * * volatile *>", 0)
-    tp, qual = ffi._parser.parse_type_and_quals("char * volatile restrict * *")
-    assert (str(tp), qual) == ("<char * __restrict volatile * *>", 0)
-    tp, qual = ffi._parser.parse_type_and_quals("char const volatile * * *")
-    assert (str(tp), qual) == ("<char volatile const * * *>", 0)
-    tp, qual = ffi._parser.parse_type_and_quals("const char * * *")
-    assert (str(tp), qual) == ("<char const * * *>", 0)
-    #
-    tp, qual = ffi._parser.parse_type_and_quals(
-        "int(char*const*, short****const*)")
-    assert (str(tp), qual) == (
-        "<int()(char * const *, short * * * * const *)>", 0)
-    tp, qual = ffi._parser.parse_type_and_quals(
-        "char*const*(short*const****)")
-    assert (str(tp), qual) == (
-        "<char * const *()(short * const * * * *)>", 0)
-
-def test_enum():
-    ffi = FFI()
-    ffi.cdef("""
-        enum Enum { POS = +1, TWO = 2, NIL = 0, NEG = -1};
-        """)
-    C = ffi.dlopen(None)
-    assert C.POS == 1
-    assert C.TWO == 2
-    assert C.NIL == 0
-    assert C.NEG == -1
-
-def test_stdcall():
-    ffi = FFI()
-    tp = ffi.typeof("int(*)(int __stdcall x(int),"
-                    "       long (__cdecl*y)(void),"
-                    "       short(WINAPI *z)(short))")
-    if sys.platform == 'win32' and sys.maxsize < 2**32:
-        stdcall = '__stdcall '
-    else:
-        stdcall = ''
-    assert str(tp) == (
-        "<ctype 'int(*)(int(%s*)(int), "
-                        "long(*)(), "
-                        "short(%s*)(short))'>" % (stdcall, stdcall))

+ 0 - 25
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_platform.py

@@ -1,25 +0,0 @@
-import os
-from cffi.ffiplatform import maybe_relative_path, flatten
-
-
-def test_not_absolute():
-    assert maybe_relative_path('foo/bar') == 'foo/bar'
-    assert maybe_relative_path('test_platform.py') == 'test_platform.py'
-
-def test_different_absolute():
-    p = os.path.join('..', 'baz.py')
-    assert maybe_relative_path(p) == p
-
-def test_absolute_mapping():
-    p = os.path.abspath('baz.py')
-    assert maybe_relative_path(p) == 'baz.py'
-    foobaz = os.path.join('foo', 'baz.py')
-    assert maybe_relative_path(os.path.abspath(foobaz)) == foobaz
-
-def test_flatten():
-    assert flatten("foo") == "3sfoo"
-    assert flatten(-10000000000000000000000000000) == \
-           "-10000000000000000000000000000i"
-    assert flatten([4, 5]) == "2l4i5i"
-    assert flatten({4: 5}) == "1d4i5i"
-    assert flatten({"foo": ("bar", "baaz")}) == "1d3sfoo2l3sbar4sbaaz"

+ 0 - 79
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_unicode_literals.py

@@ -1,79 +0,0 @@
-#
-# ----------------------------------------------
-# WARNING, ALL LITERALS IN THIS FILE ARE UNICODE
-# ----------------------------------------------
-#
-from __future__ import unicode_literals
-#
-#
-#
-import sys, math
-from cffi import FFI
-
-lib_m = "m"
-if sys.platform == 'win32':
-    #there is a small chance this fails on Mingw via environ $CC
-    import distutils.ccompiler
-    if distutils.ccompiler.get_default_compiler() == 'msvc':
-        lib_m = 'msvcrt'
-
-
-def test_cast():
-    ffi = FFI()
-    assert int(ffi.cast("int", 3.14)) == 3        # unicode literal
-
-def test_new():
-    ffi = FFI()
-    assert ffi.new("int[]", [3, 4, 5])[2] == 5    # unicode literal
-
-def test_typeof():
-    ffi = FFI()
-    tp = ffi.typeof("int[51]")                    # unicode literal
-    assert tp.length == 51
-
-def test_sizeof():
-    ffi = FFI()
-    assert ffi.sizeof("int[51]") == 51 * 4        # unicode literal
-
-def test_alignof():
-    ffi = FFI()
-    assert ffi.alignof("int[51]") == 4            # unicode literal
-
-def test_getctype():
-    ffi = FFI()
-    assert ffi.getctype("int**") == "int * *"     # unicode literal
-    assert type(ffi.getctype("int**")) is str
-
-def test_cdef():
-    ffi = FFI()
-    ffi.cdef("typedef int foo_t[50];")            # unicode literal
-
-def test_offsetof():
-    ffi = FFI()
-    ffi.cdef("typedef struct { int x, y; } foo_t;")
-    assert ffi.offsetof("foo_t", "y") == 4        # unicode literal
-
-def test_enum():
-    ffi = FFI()
-    ffi.cdef("enum foo_e { AA, BB, CC };")        # unicode literal
-    x = ffi.cast("enum foo_e", 1)
-    assert int(ffi.cast("int", x)) == 1
-
-def test_dlopen():
-    ffi = FFI()
-    ffi.cdef("double sin(double x);")
-    m = ffi.dlopen(lib_m)                           # unicode literal
-    x = m.sin(1.23)
-    assert x == math.sin(1.23)
-
-def test_verify():
-    ffi = FFI()
-    ffi.cdef("double test_verify_1(double x);")   # unicode literal
-    lib = ffi.verify("double test_verify_1(double x) { return x * 42.0; }")
-    assert lib.test_verify_1(-1.5) == -63.0
-
-def test_callback():
-    ffi = FFI()
-    cb = ffi.callback("int(int)",                 # unicode literal
-                      lambda x: x + 42)
-    assert cb(5) == 47

+ 0 - 2420
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_verify.py

@@ -1,2420 +0,0 @@
-import py, re
-import sys, os, math, weakref
-from cffi import FFI, VerificationError, VerificationMissing, model, FFIError
-from testing.support import *
-
-
-lib_m = ['m']
-if sys.platform == 'win32':
-    #there is a small chance this fails on Mingw via environ $CC
-    import distutils.ccompiler
-    if distutils.ccompiler.get_default_compiler() == 'msvc':
-        lib_m = ['msvcrt']
-    pass      # no obvious -Werror equivalent on MSVC
-else:
-    if (sys.platform == 'darwin' and
-          [int(x) for x in os.uname()[2].split('.')] >= [11, 0, 0]):
-        # assume a standard clang or gcc
-        extra_compile_args = ['-Werror', '-Wall', '-Wextra', '-Wconversion']
-        # special things for clang
-        extra_compile_args.append('-Qunused-arguments')
-    else:
-        # assume a standard gcc
-        extra_compile_args = ['-Werror', '-Wall', '-Wextra', '-Wconversion']
-
-    class FFI(FFI):
-        def verify(self, *args, **kwds):
-            return super(FFI, self).verify(
-                *args, extra_compile_args=extra_compile_args, **kwds)
-
-def setup_module():
-    import cffi.verifier
-    cffi.verifier.cleanup_tmpdir()
-    #
-    # check that no $ sign is produced in the C file; it used to be the
-    # case that anonymous enums would produce '$enum_$1', which was
-    # used as part of a function name.  GCC accepts such names, but it's
-    # apparently non-standard.
-    _r_comment = re.compile(r"/\*.*?\*/|//.*?$", re.DOTALL | re.MULTILINE)
-    _r_string = re.compile(r'\".*?\"')
-    def _write_source_and_check(self, file=None):
-        base_write_source(self, file)
-        if file is None:
-            f = open(self.sourcefilename)
-            data = f.read()
-            f.close()
-            data = _r_comment.sub(' ', data)
-            data = _r_string.sub('"skipped"', data)
-            assert '$' not in data
-    base_write_source = cffi.verifier.Verifier._write_source
-    cffi.verifier.Verifier._write_source = _write_source_and_check
-
-
-def test_module_type():
-    import cffi.verifier
-    ffi = FFI()
-    lib = ffi.verify()
-    if hasattr(lib, '_cffi_python_module'):
-        print('verify got a PYTHON module')
-    if hasattr(lib, '_cffi_generic_module'):
-        print('verify got a GENERIC module')
-    expected_generic = (cffi.verifier._FORCE_GENERIC_ENGINE or
-                        '__pypy__' in sys.builtin_module_names)
-    assert hasattr(lib, '_cffi_python_module') == (not expected_generic)
-    assert hasattr(lib, '_cffi_generic_module') == expected_generic
-
-def test_missing_function(ffi=None):
-    # uses the FFI hacked above with '-Werror'
-    if ffi is None:
-        ffi = FFI()
-    ffi.cdef("void some_completely_unknown_function();")
-    try:
-        lib = ffi.verify()
-    except (VerificationError, OSError):
-        pass     # expected case: we get a VerificationError
-    else:
-        # but depending on compiler and loader details, maybe
-        # 'lib' could actually be imported but will fail if we
-        # actually try to call the unknown function...  Hard
-        # to test anything more.
-        pass
-
-def test_missing_function_import_error():
-    # uses the original FFI that just gives a warning during compilation
-    import cffi
-    test_missing_function(ffi=cffi.FFI())
-
-def test_simple_case():
-    ffi = FFI()
-    ffi.cdef("double sin(double x);")
-    lib = ffi.verify('#include <math.h>', libraries=lib_m)
-    assert lib.sin(1.23) == math.sin(1.23)
-
-def _Wconversion(cdef, source, **kargs):
-    if sys.platform == 'win32':
-        py.test.skip("needs GCC or Clang")
-    ffi = FFI()
-    ffi.cdef(cdef)
-    py.test.raises(VerificationError, ffi.verify, source, **kargs)
-    extra_compile_args_orig = extra_compile_args[:]
-    extra_compile_args.remove('-Wconversion')
-    try:
-        lib = ffi.verify(source, **kargs)
-    finally:
-        extra_compile_args[:] = extra_compile_args_orig
-    return lib
-
-def test_Wconversion_unsigned():
-    _Wconversion("unsigned foo(void);",
-                 "int foo(void) { return -1;}")
-
-def test_Wconversion_integer():
-    _Wconversion("short foo(void);",
-                 "long long foo(void) { return 1<<sizeof(short);}")
-
-def test_Wconversion_floating():
-    lib = _Wconversion("float sin(double);",
-                       "#include <math.h>", libraries=lib_m)
-    res = lib.sin(1.23)
-    assert res != math.sin(1.23)     # not exact, because of double->float
-    assert abs(res - math.sin(1.23)) < 1E-5
-
-def test_Wconversion_float2int():
-    _Wconversion("int sinf(float);",
-                 "#include <math.h>", libraries=lib_m)
-
-def test_Wconversion_double2int():
-    _Wconversion("int sin(double);",
-                 "#include <math.h>", libraries=lib_m)
-
-def test_rounding_1():
-    ffi = FFI()
-    ffi.cdef("double sinf(float x);")
-    lib = ffi.verify('#include <math.h>', libraries=lib_m)
-    res = lib.sinf(1.23)
-    assert res != math.sin(1.23)     # not exact, because of double->float
-    assert abs(res - math.sin(1.23)) < 1E-5
-
-def test_rounding_2():
-    ffi = FFI()
-    ffi.cdef("double sin(float x);")
-    lib = ffi.verify('#include <math.h>', libraries=lib_m)
-    res = lib.sin(1.23)
-    assert res != math.sin(1.23)     # not exact, because of double->float
-    assert abs(res - math.sin(1.23)) < 1E-5
-
-def test_strlen_exact():
-    ffi = FFI()
-    ffi.cdef("size_t strlen(const char *s);")
-    lib = ffi.verify("#include <string.h>")
-    assert lib.strlen(b"hi there!") == 9
-
-def test_strlen_approximate():
-    lib = _Wconversion("int strlen(char *s);",
-                       "#include <string.h>")
-    assert lib.strlen(b"hi there!") == 9
-
-def test_return_approximate():
-    for typename in ['short', 'int', 'long', 'long long']:
-        ffi = FFI()
-        ffi.cdef("%s foo(signed char x);" % typename)
-        lib = ffi.verify("signed char foo(signed char x) { return x;}")
-        assert lib.foo(-128) == -128
-        assert lib.foo(+127) == +127
-
-def test_strlen_array_of_char():
-    ffi = FFI()
-    ffi.cdef("size_t strlen(char[]);")
-    lib = ffi.verify("#include <string.h>")
-    assert lib.strlen(b"hello") == 5
-
-def test_longdouble():
-    ffi = FFI()
-    ffi.cdef("long double sinl(long double x);")
-    lib = ffi.verify('#include <math.h>', libraries=lib_m)
-    for input in [1.23,
-                  ffi.cast("double", 1.23),
-                  ffi.cast("long double", 1.23)]:
-        x = lib.sinl(input)
-        assert repr(x).startswith("<cdata 'long double'")
-        assert (float(x) - math.sin(1.23)) < 1E-10
-
-def test_longdouble_precision():
-    # Test that we don't loose any precision of 'long double' when
-    # passing through Python and CFFI.
-    ffi = FFI()
-    ffi.cdef("long double step1(long double x);")
-    SAME_SIZE = ffi.sizeof("long double") == ffi.sizeof("double")
-    lib = ffi.verify("""
-        long double step1(long double x)
-        {
-            return 4*x-x*x;
-        }
-    """)
-    def do(cast_to_double):
-        x = 0.9789
-        for i in range(10000):
-            x = lib.step1(x)
-            if cast_to_double:
-                x = float(x)
-        return float(x)
-
-    more_precise = do(False)
-    less_precise = do(True)
-    if SAME_SIZE:
-        assert more_precise == less_precise
-    else:
-        assert abs(more_precise - less_precise) > 0.1
-        # Check the particular results on Intel
-        import platform
-        if (platform.machine().startswith('i386') or
-            platform.machine().startswith('i486') or
-            platform.machine().startswith('i586') or
-            platform.machine().startswith('i686') or
-            platform.machine().startswith('x86')):
-            assert abs(more_precise - 0.656769) < 0.001
-            assert abs(less_precise - 3.99091) < 0.001
-        else:
-            py.test.skip("don't know the very exact precision of 'long double'")
-
-
-all_primitive_types = model.PrimitiveType.ALL_PRIMITIVE_TYPES
-if sys.platform == 'win32':
-    all_primitive_types = all_primitive_types.copy()
-    del all_primitive_types['ssize_t']
-all_integer_types = sorted(tp for tp in all_primitive_types
-                           if all_primitive_types[tp] == 'i')
-all_float_types = sorted(tp for tp in all_primitive_types
-                            if all_primitive_types[tp] == 'f')
-
-def all_signed_integer_types(ffi):
-    return [x for x in all_integer_types if int(ffi.cast(x, -1)) < 0]
-
-def all_unsigned_integer_types(ffi):
-    return [x for x in all_integer_types if int(ffi.cast(x, -1)) > 0]
-
-
-def test_primitive_category():
-    for typename in all_primitive_types:
-        tp = model.PrimitiveType(typename)
-        C = tp.is_char_type()
-        F = tp.is_float_type()
-        I = tp.is_integer_type()
-        assert C == (typename in ('char', 'wchar_t'))
-        assert F == (typename in ('float', 'double', 'long double'))
-        assert I + F + C == 1      # one and only one of them is true
-
-def test_all_integer_and_float_types():
-    typenames = []
-    for typename in all_primitive_types:
-        if (all_primitive_types[typename] == 'c' or
-            typename == '_Bool' or typename == 'long double'):
-            pass
-        else:
-            typenames.append(typename)
-    #
-    ffi = FFI()
-    ffi.cdef('\n'.join(["%s foo_%s(%s);" % (tp, tp.replace(' ', '_'), tp)
-                       for tp in typenames]))
-    lib = ffi.verify('\n'.join(["%s foo_%s(%s x) { return (%s)(x+1); }" %
-                                (tp, tp.replace(' ', '_'), tp, tp)
-                                for tp in typenames]))
-    for typename in typenames:
-        foo = getattr(lib, 'foo_%s' % typename.replace(' ', '_'))
-        assert foo(42) == 43
-        if sys.version < '3':
-            assert foo(long(44)) == 45
-        assert foo(ffi.cast(typename, 46)) == 47
-        py.test.raises(TypeError, foo, ffi.NULL)
-        #
-        # check for overflow cases
-        if all_primitive_types[typename] == 'f':
-            continue
-        for value in [-2**80, -2**40, -2**20, -2**10, -2**5, -1,
-                      2**5, 2**10, 2**20, 2**40, 2**80]:
-            overflows = int(ffi.cast(typename, value)) != value
-            if overflows:
-                py.test.raises(OverflowError, foo, value)
-            else:
-                assert foo(value) == value + 1
-
-def test_var_signed_integer_types():
-    ffi = FFI()
-    lst = all_signed_integer_types(ffi)
-    csource = "\n".join(["%s somevar_%s;" % (tp, tp.replace(' ', '_'))
-                         for tp in lst])
-    ffi.cdef(csource)
-    lib = ffi.verify(csource)
-    for tp in lst:
-        varname = 'somevar_%s' % tp.replace(' ', '_')
-        sz = ffi.sizeof(tp)
-        max = (1 << (8*sz-1)) - 1
-        min = -(1 << (8*sz-1))
-        setattr(lib, varname, max)
-        assert getattr(lib, varname) == max
-        setattr(lib, varname, min)
-        assert getattr(lib, varname) == min
-        py.test.raises(OverflowError, setattr, lib, varname, max+1)
-        py.test.raises(OverflowError, setattr, lib, varname, min-1)
-
-def test_var_unsigned_integer_types():
-    ffi = FFI()
-    lst = all_unsigned_integer_types(ffi)
-    csource = "\n".join(["%s somevar_%s;" % (tp, tp.replace(' ', '_'))
-                         for tp in lst])
-    ffi.cdef(csource)
-    lib = ffi.verify(csource)
-    for tp in lst:
-        varname = 'somevar_%s' % tp.replace(' ', '_')
-        sz = ffi.sizeof(tp)
-        if tp != '_Bool':
-            max = (1 << (8*sz)) - 1
-        else:
-            max = 1
-        setattr(lib, varname, max)
-        assert getattr(lib, varname) == max
-        setattr(lib, varname, 0)
-        assert getattr(lib, varname) == 0
-        py.test.raises(OverflowError, setattr, lib, varname, max+1)
-        py.test.raises(OverflowError, setattr, lib, varname, -1)
-
-def test_fn_signed_integer_types():
-    ffi = FFI()
-    lst = all_signed_integer_types(ffi)
-    cdefsrc = "\n".join(["%s somefn_%s(%s);" % (tp, tp.replace(' ', '_'), tp)
-                         for tp in lst])
-    ffi.cdef(cdefsrc)
-    verifysrc = "\n".join(["%s somefn_%s(%s x) { return x; }" %
-                           (tp, tp.replace(' ', '_'), tp) for tp in lst])
-    lib = ffi.verify(verifysrc)
-    for tp in lst:
-        fnname = 'somefn_%s' % tp.replace(' ', '_')
-        sz = ffi.sizeof(tp)
-        max = (1 << (8*sz-1)) - 1
-        min = -(1 << (8*sz-1))
-        fn = getattr(lib, fnname)
-        assert fn(max) == max
-        assert fn(min) == min
-        py.test.raises(OverflowError, fn, max + 1)
-        py.test.raises(OverflowError, fn, min - 1)
-
-def test_fn_unsigned_integer_types():
-    ffi = FFI()
-    lst = all_unsigned_integer_types(ffi)
-    cdefsrc = "\n".join(["%s somefn_%s(%s);" % (tp, tp.replace(' ', '_'), tp)
-                         for tp in lst])
-    ffi.cdef(cdefsrc)
-    verifysrc = "\n".join(["%s somefn_%s(%s x) { return x; }" %
-                           (tp, tp.replace(' ', '_'), tp) for tp in lst])
-    lib = ffi.verify(verifysrc)
-    for tp in lst:
-        fnname = 'somefn_%s' % tp.replace(' ', '_')
-        sz = ffi.sizeof(tp)
-        if tp != '_Bool':
-            max = (1 << (8*sz)) - 1
-        else:
-            max = 1
-        fn = getattr(lib, fnname)
-        assert fn(max) == max
-        assert fn(0) == 0
-        py.test.raises(OverflowError, fn, max + 1)
-        py.test.raises(OverflowError, fn, -1)
-
-def test_char_type():
-    ffi = FFI()
-    ffi.cdef("char foo(char);")
-    lib = ffi.verify("char foo(char x) { return ++x; }")
-    assert lib.foo(b"A") == b"B"
-    py.test.raises(TypeError, lib.foo, b"bar")
-    py.test.raises(TypeError, lib.foo, "bar")
-
-def test_wchar_type():
-    ffi = FFI()
-    if ffi.sizeof('wchar_t') == 2:
-        uniexample1 = u+'\u1234'
-        uniexample2 = u+'\u1235'
-    else:
-        uniexample1 = u+'\U00012345'
-        uniexample2 = u+'\U00012346'
-    #
-    ffi.cdef("wchar_t foo(wchar_t);")
-    lib = ffi.verify("wchar_t foo(wchar_t x) { return x+1; }")
-    assert lib.foo(uniexample1) == uniexample2
-
-def test_no_argument():
-    ffi = FFI()
-    ffi.cdef("int foo(void);")
-    lib = ffi.verify("int foo(void) { return 42; }")
-    assert lib.foo() == 42
-
-def test_two_arguments():
-    ffi = FFI()
-    ffi.cdef("int foo(int, int);")
-    lib = ffi.verify("int foo(int a, int b) { return a - b; }")
-    assert lib.foo(40, -2) == 42
-
-def test_macro():
-    ffi = FFI()
-    ffi.cdef("int foo(int, int);")
-    lib = ffi.verify("#define foo(a, b) ((a) * (b))")
-    assert lib.foo(-6, -7) == 42
-
-def test_ptr():
-    ffi = FFI()
-    ffi.cdef("int *foo(int *);")
-    lib = ffi.verify("int *foo(int *a) { return a; }")
-    assert lib.foo(ffi.NULL) == ffi.NULL
-    p = ffi.new("int *", 42)
-    q = ffi.new("int *", 42)
-    assert lib.foo(p) == p
-    assert lib.foo(q) != p
-
-def test_bogus_ptr():
-    ffi = FFI()
-    ffi.cdef("int *foo(int *);")
-    lib = ffi.verify("int *foo(int *a) { return a; }")
-    py.test.raises(TypeError, lib.foo, ffi.new("short *", 42))
-
-
-def test_verify_typedefs():
-    py.test.skip("ignored so far")
-    types = ['signed char', 'unsigned char', 'int', 'long']
-    for cdefed in types:
-        for real in types:
-            ffi = FFI()
-            ffi.cdef("typedef %s foo_t;" % cdefed)
-            if cdefed == real:
-                ffi.verify("typedef %s foo_t;" % real)
-            else:
-                py.test.raises(VerificationError, ffi.verify,
-                               "typedef %s foo_t;" % real)
-
-def test_nondecl_struct():
-    ffi = FFI()
-    ffi.cdef("typedef struct foo_s foo_t; int bar(foo_t *);")
-    lib = ffi.verify("typedef struct foo_s foo_t;\n"
-                     "int bar(foo_t *f) { (void)f; return 42; }\n")
-    assert lib.bar(ffi.NULL) == 42
-
-def test_ffi_full_struct():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { char x; int y; long *z; };")
-    ffi.verify("struct foo_s { char x; int y; long *z; };")
-    #
-    if sys.platform != 'win32':  # XXX fixme: only gives warnings
-        py.test.raises(VerificationError, ffi.verify,
-            "struct foo_s { char x; int y; int *z; };")
-    #
-    py.test.raises(VerificationError, ffi.verify,
-        "struct foo_s { int y; long *z; };")
-    #
-    e = py.test.raises(VerificationError, ffi.verify,
-        "struct foo_s { int y; char x; long *z; };")
-    assert str(e.value) == (
-        "struct foo_s: wrong offset for field 'x'"
-        " (we have 0, but C compiler says 4)")
-    #
-    e = py.test.raises(VerificationError, ffi.verify,
-        "struct foo_s { char x; int y; long *z; char extra; };")
-    assert str(e.value) == (
-        "struct foo_s: wrong total size"
-        " (we have %d, but C compiler says %d)" % (
-            ffi.sizeof("struct foo_s"),
-            ffi.sizeof("struct foo_s") + ffi.sizeof("long*")))
-    #
-    # a corner case that we cannot really detect, but where it has no
-    # bad consequences: the size is the same, but there is an extra field
-    # that replaces what is just padding in our declaration above
-    ffi.verify("struct foo_s { char x, extra; int y; long *z; };")
-    #
-    e = py.test.raises(VerificationError, ffi.verify,
-        "struct foo_s { char x; short pad; short y; long *z; };")
-    assert str(e.value) == (
-        "struct foo_s: wrong size for field 'y'"
-        " (we have 4, but C compiler says 2)")
-
-def test_ffi_nonfull_struct():
-    ffi = FFI()
-    ffi.cdef("""
-    struct foo_s {
-       int x;
-       ...;
-    };
-    """)
-    py.test.raises(VerificationMissing, ffi.sizeof, 'struct foo_s')
-    py.test.raises(VerificationMissing, ffi.offsetof, 'struct foo_s', 'x')
-    py.test.raises(VerificationMissing, ffi.new, 'struct foo_s *')
-    ffi.verify("""
-    struct foo_s {
-       int a, b, x, c, d, e;
-    };
-    """)
-    assert ffi.sizeof('struct foo_s') == 6 * ffi.sizeof('int')
-    assert ffi.offsetof('struct foo_s', 'x') == 2 * ffi.sizeof('int')
-
-def test_ffi_nonfull_alignment():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { char x; ...; };")
-    ffi.verify("struct foo_s { int a, b; char x; };")
-    assert ffi.sizeof('struct foo_s') == 3 * ffi.sizeof('int')
-    assert ffi.alignof('struct foo_s') == ffi.sizeof('int')
-
-def _check_field_match(typename, real, expect_mismatch):
-    ffi = FFI()
-    testing_by_size = (expect_mismatch == 'by_size')
-    if testing_by_size:
-        expect_mismatch = ffi.sizeof(typename) != ffi.sizeof(real)
-    ffi.cdef("struct foo_s { %s x; ...; };" % typename)
-    try:
-        ffi.verify("struct foo_s { %s x; };" % real)
-    except VerificationError:
-        if not expect_mismatch:
-            if testing_by_size and typename != real:
-                print("ignoring mismatch between %s* and %s* even though "
-                      "they have the same size" % (typename, real))
-                return
-            raise AssertionError("unexpected mismatch: %s should be accepted "
-                                 "as equal to %s" % (typename, real))
-    else:
-        if expect_mismatch:
-            raise AssertionError("mismatch not detected: "
-                                 "%s != %s" % (typename, real))
-
-def test_struct_bad_sized_integer():
-    for typename in ['int8_t', 'int16_t', 'int32_t', 'int64_t']:
-        for real in ['int8_t', 'int16_t', 'int32_t', 'int64_t']:
-            _check_field_match(typename, real, "by_size")
-
-def test_struct_bad_sized_float():
-    for typename in all_float_types:
-        for real in all_float_types:
-            _check_field_match(typename, real, "by_size")
-
-def test_struct_signedness_ignored():
-    _check_field_match("int", "unsigned int", expect_mismatch=False)
-    _check_field_match("unsigned short", "signed short", expect_mismatch=False)
-
-def test_struct_float_vs_int():
-    if sys.platform == 'win32':
-        py.test.skip("XXX fixme: only gives warnings")
-    ffi = FFI()
-    for typename in all_signed_integer_types(ffi):
-        for real in all_float_types:
-            _check_field_match(typename, real, expect_mismatch=True)
-    for typename in all_float_types:
-        for real in all_signed_integer_types(ffi):
-            _check_field_match(typename, real, expect_mismatch=True)
-
-def test_struct_array_field():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int a[17]; ...; };")
-    ffi.verify("struct foo_s { int x; int a[17]; int y; };")
-    assert ffi.sizeof('struct foo_s') == 19 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *")
-    assert ffi.sizeof(s.a) == 17 * ffi.sizeof('int')
-
-def test_struct_array_no_length():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int a[]; int y; ...; };\n"
-             "int bar(struct foo_s *);\n")
-    lib = ffi.verify("struct foo_s { int x; int a[17]; int y; };\n"
-                     "int bar(struct foo_s *f) { return f->a[14]; }\n")
-    assert ffi.sizeof('struct foo_s') == 19 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *")
-    assert ffi.typeof(s.a) is ffi.typeof('int *')   # because no length
-    s.a[14] = 4242
-    assert lib.bar(s) == 4242
-    # with no declared length, out-of-bound accesses are not detected
-    s.a[17] = -521
-    assert s.y == s.a[17] == -521
-    #
-    s = ffi.new("struct foo_s *", {'a': list(range(17))})
-    assert s.a[16] == 16
-    # overflows at construction time not detected either
-    s = ffi.new("struct foo_s *", {'a': list(range(18))})
-    assert s.y == s.a[17] == 17
-
-def test_struct_array_guess_length():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int a[...]; };")
-    ffi.verify("struct foo_s { int x; int a[17]; int y; };")
-    assert ffi.sizeof('struct foo_s') == 19 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *")
-    assert ffi.sizeof(s.a) == 17 * ffi.sizeof('int')
-    py.test.raises(IndexError, 's.a[17]')
-
-def test_struct_array_c99_1():
-    if sys.platform == 'win32':
-        py.test.skip("requires C99")
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int x; int a[]; };")
-    ffi.verify("struct foo_s { int x; int a[]; };")
-    assert ffi.sizeof('struct foo_s') == 1 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *", [424242, 4])
-    assert ffi.sizeof(s[0]) == 1 * ffi.sizeof('int')   # the same in C
-    assert s.a[3] == 0
-    s = ffi.new("struct foo_s *", [424242, [-40, -30, -20, -10]])
-    assert ffi.sizeof(s[0]) == 1 * ffi.sizeof('int')
-    assert s.a[3] == -10
-    s = ffi.new("struct foo_s *")
-    assert ffi.sizeof(s[0]) == 1 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *", [424242])
-    assert ffi.sizeof(s[0]) == 1 * ffi.sizeof('int')
-
-def test_struct_array_c99_2():
-    if sys.platform == 'win32':
-        py.test.skip("requires C99")
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int x; int a[]; ...; };")
-    ffi.verify("struct foo_s { int x, y; int a[]; };")
-    assert ffi.sizeof('struct foo_s') == 2 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *", [424242, 4])
-    assert ffi.sizeof(s[0]) == 2 * ffi.sizeof('int')
-    assert s.a[3] == 0
-    s = ffi.new("struct foo_s *", [424242, [-40, -30, -20, -10]])
-    assert ffi.sizeof(s[0]) == 2 * ffi.sizeof('int')
-    assert s.a[3] == -10
-    s = ffi.new("struct foo_s *")
-    assert ffi.sizeof(s[0]) == 2 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *", [424242])
-    assert ffi.sizeof(s[0]) == 2 * ffi.sizeof('int')
-
-def test_struct_ptr_to_array_field():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int (*a)[17]; ...; }; struct bar_s { ...; };")
-    ffi.verify("struct foo_s { int x; int (*a)[17]; int y; };\n"
-               "struct bar_s { int x; int *a; int y; };")
-    assert ffi.sizeof('struct foo_s') == ffi.sizeof("struct bar_s")
-    s = ffi.new("struct foo_s *")
-    assert ffi.sizeof(s.a) == ffi.sizeof('int(*)[17]') == ffi.sizeof("int *")
-
-def test_struct_with_bitfield_exact():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int a:2, b:3; };")
-    ffi.verify("struct foo_s { int a:2, b:3; };")
-    s = ffi.new("struct foo_s *")
-    s.b = 3
-    py.test.raises(OverflowError, "s.b = 4")
-    assert s.b == 3
-
-def test_struct_with_bitfield_enum():
-    ffi = FFI()
-    code = """
-        typedef enum { AA, BB, CC } foo_e;
-        typedef struct { foo_e f:2; } foo_s;
-    """
-    ffi.cdef(code)
-    ffi.verify(code)
-    s = ffi.new("foo_s *")
-    s.f = 2
-    assert s.f == 2
-
-def test_unsupported_struct_with_bitfield_ellipsis():
-    ffi = FFI()
-    py.test.raises(NotImplementedError, ffi.cdef,
-                   "struct foo_s { int a:2, b:3; ...; };")
-
-def test_global_constants():
-    ffi = FFI()
-    # use 'static const int', as generally documented, although in this
-    # case the 'static' is completely ignored.
-    ffi.cdef("static const int AA, BB, CC, DD;")
-    lib = ffi.verify("#define AA 42\n"
-                     "#define BB (-43)   // blah\n"
-                     "#define CC (22*2)  /* foobar */\n"
-                     "#define DD ((unsigned int)142)  /* foo\nbar */\n")
-    assert lib.AA == 42
-    assert lib.BB == -43
-    assert lib.CC == 44
-    assert lib.DD == 142
-
-def test_global_const_int_size():
-    # integer constants: ignore the declared type, always just use the value
-    for value in [-2**63, -2**31, -2**15,
-                  2**15-1, 2**15, 2**31-1, 2**31, 2**32-1, 2**32,
-                  2**63-1, 2**63, 2**64-1]:
-        ffi = FFI()
-        if value == int(ffi.cast("long long", value)):
-            if value < 0:
-                vstr = '(-%dLL-1)' % (~value,)
-            else:
-                vstr = '%dLL' % value
-        elif value == int(ffi.cast("unsigned long long", value)):
-            vstr = '%dULL' % value
-        else:
-            raise AssertionError(value)
-        ffi.cdef("static const unsigned short AA;")
-        lib = ffi.verify("#define AA %s\n" % vstr)
-        assert lib.AA == value
-        assert type(lib.AA) is type(int(lib.AA))
-
-def test_global_constants_non_int():
-    ffi = FFI()
-    ffi.cdef("static char *const PP;")
-    lib = ffi.verify('static char *const PP = "testing!";\n')
-    assert ffi.typeof(lib.PP) == ffi.typeof("char *")
-    assert ffi.string(lib.PP) == b"testing!"
-
-def test_nonfull_enum():
-    ffi = FFI()
-    ffi.cdef("enum ee { EE1, EE2, EE3, ... \n \t };")
-    py.test.raises(VerificationMissing, ffi.cast, 'enum ee', 'EE2')
-    ffi.verify("enum ee { EE1=10, EE2, EE3=-10, EE4 };")
-    assert ffi.string(ffi.cast('enum ee', 11)) == "EE2"
-    assert ffi.string(ffi.cast('enum ee', -10)) == "EE3"
-    #
-    # try again
-    ffi.verify("enum ee { EE1=10, EE2, EE3=-10, EE4 };")
-    assert ffi.string(ffi.cast('enum ee', 11)) == "EE2"
-    #
-    assert ffi.typeof("enum ee").relements == {'EE1': 10, 'EE2': 11, 'EE3': -10}
-    assert ffi.typeof("enum ee").elements == {10: 'EE1', 11: 'EE2', -10: 'EE3'}
-
-def test_full_enum():
-    ffi = FFI()
-    ffi.cdef("enum ee { EE1, EE2, EE3 };")
-    ffi.verify("enum ee { EE1, EE2, EE3 };")
-    py.test.raises(VerificationError, ffi.verify, "enum ee { EE1, EE2 };")
-    e = py.test.raises(VerificationError, ffi.verify,
-                       "enum ee { EE1, EE3, EE2 };")
-    assert str(e.value) == 'enum ee: EE2 has the real value 2, not 1'
-    # extra items cannot be seen and have no bad consequence anyway
-    lib = ffi.verify("enum ee { EE1, EE2, EE3, EE4 };")
-    assert lib.EE3 == 2
-
-def test_enum_usage():
-    ffi = FFI()
-    ffi.cdef("enum ee { EE1,EE2 }; typedef struct { enum ee x; } *sp;")
-    lib = ffi.verify("enum ee { EE1,EE2 }; typedef struct { enum ee x; } *sp;")
-    assert lib.EE2 == 1
-    s = ffi.new("sp", [lib.EE2])
-    assert s.x == 1
-    s.x = 17
-    assert s.x == 17
-
-def test_anonymous_enum():
-    ffi = FFI()
-    ffi.cdef("enum { EE1 }; enum { EE2, EE3 };")
-    lib = ffi.verify("enum { EE1 }; enum { EE2, EE3 };")
-    assert lib.EE1 == 0
-    assert lib.EE2 == 0
-    assert lib.EE3 == 1
-
-def test_nonfull_anonymous_enum():
-    ffi = FFI()
-    ffi.cdef("enum { EE1, ... }; enum { EE3, ... };")
-    lib = ffi.verify("enum { EE2, EE1 }; enum { EE3 };")
-    assert lib.EE1 == 1
-    assert lib.EE3 == 0
-
-def test_nonfull_enum_syntax2():
-    ffi = FFI()
-    ffi.cdef("enum ee { EE1, EE2=\t..., EE3 };")
-    py.test.raises(VerificationMissing, ffi.cast, 'enum ee', 'EE1')
-    ffi.verify("enum ee { EE1=10, EE2, EE3=-10, EE4 };")
-    assert ffi.string(ffi.cast('enum ee', 11)) == 'EE2'
-    assert ffi.string(ffi.cast('enum ee', -10)) == 'EE3'
-    #
-    ffi = FFI()
-    ffi.cdef("enum ee { EE1, EE2=\t... };")
-    py.test.raises(VerificationMissing, ffi.cast, 'enum ee', 'EE1')
-    ffi.verify("enum ee { EE1=10, EE2, EE3=-10, EE4 };")
-    assert ffi.string(ffi.cast('enum ee', 11)) == 'EE2'
-    #
-    ffi = FFI()
-    ffi.cdef("enum ee2 { EE4=..., EE5=..., ... };")
-    ffi.verify("enum ee2 { EE4=-1234-5, EE5 }; ")
-    assert ffi.string(ffi.cast('enum ee2', -1239)) == 'EE4'
-    assert ffi.string(ffi.cast('enum ee2', -1238)) == 'EE5'
-
-def test_nonfull_enum_bug3():
-    ffi = FFI()
-    ffi.cdef("enum ee2 { EE4=..., EE5=... };")
-    ffi.cdef("enum ee6 { EE7=10, EE8=..., EE9=... };")
-
-def test_get_set_errno():
-    ffi = FFI()
-    ffi.cdef("int foo(int);")
-    lib = ffi.verify("""
-        static int foo(int x)
-        {
-            errno += 1;
-            return x * 7;
-        }
-    """)
-    ffi.errno = 15
-    assert lib.foo(6) == 42
-    assert ffi.errno == 16
-
-def test_define_int():
-    ffi = FFI()
-    ffi.cdef("#define FOO ...\n"
-             "\t#\tdefine\tBAR\t...\t\n"
-             "#define BAZ ...\n")
-    lib = ffi.verify("#define FOO 42\n"
-                     "#define BAR (-44)\n"
-                     "#define BAZ 0xffffffffffffffffULL\n")
-    assert lib.FOO == 42
-    assert lib.BAR == -44
-    assert lib.BAZ == 0xffffffffffffffff
-
-def test_access_variable():
-    ffi = FFI()
-    ffi.cdef("int foo(void);\n"
-             "int somenumber;")
-    lib = ffi.verify("""
-        static int somenumber = 2;
-        static int foo(void) {
-            return somenumber * 7;
-        }
-    """)
-    assert lib.somenumber == 2
-    assert lib.foo() == 14
-    lib.somenumber = -6
-    assert lib.foo() == -42
-    assert lib.somenumber == -6
-    lib.somenumber = 2   # reset for the next run, if any
-
-def test_access_address_of_variable():
-    # access the address of 'somenumber': need a trick
-    ffi = FFI()
-    ffi.cdef("int somenumber; static int *const somenumberptr;")
-    lib = ffi.verify("""
-        static int somenumber = 2;
-        #define somenumberptr (&somenumber)
-    """)
-    assert lib.somenumber == 2
-    lib.somenumberptr[0] = 42
-    assert lib.somenumber == 42
-    lib.somenumber = 2    # reset for the next run, if any
-
-def test_access_array_variable(length=5):
-    ffi = FFI()
-    ffi.cdef("int foo(int);\n"
-             "int somenumber[%s];" % (length,))
-    lib = ffi.verify("""
-        static int somenumber[] = {2, 2, 3, 4, 5};
-        static int foo(int i) {
-            return somenumber[i] * 7;
-        }
-    """)
-    if length == '':
-        # a global variable of an unknown array length is implicitly
-        # transformed into a global pointer variable, because we can only
-        # work with array instances whose length we know.  using a pointer
-        # instead of an array gives the correct effects.
-        assert repr(lib.somenumber).startswith("<cdata 'int *' 0x")
-        py.test.raises(TypeError, len, lib.somenumber)
-    else:
-        assert repr(lib.somenumber).startswith("<cdata 'int[%s]' 0x" % length)
-        assert len(lib.somenumber) == 5
-    assert lib.somenumber[3] == 4
-    assert lib.foo(3) == 28
-    lib.somenumber[3] = -6
-    assert lib.foo(3) == -42
-    assert lib.somenumber[3] == -6
-    assert lib.somenumber[4] == 5
-    lib.somenumber[3] = 4    # reset for the next run, if any
-
-def test_access_array_variable_length_hidden():
-    test_access_array_variable(length='')
-
-def test_access_struct_variable():
-    ffi = FFI()
-    ffi.cdef("struct foo { int x; ...; };\n"
-             "int foo(int);\n"
-             "struct foo stuff;")
-    lib = ffi.verify("""
-        struct foo { int x, y, z; };
-        static struct foo stuff = {2, 5, 8};
-        static int foo(int i) {
-            switch (i) {
-            case 0: return stuff.x * 7;
-            case 1: return stuff.y * 7;
-            case 2: return stuff.z * 7;
-            }
-            return -1;
-        }
-    """)
-    assert lib.stuff.x == 2
-    assert lib.foo(0) == 14
-    assert lib.foo(1) == 35
-    assert lib.foo(2) == 56
-    lib.stuff.x = -6
-    assert lib.foo(0) == -42
-    assert lib.foo(1) == 35
-    lib.stuff.x = 2      # reset for the next run, if any
-
-def test_access_callback():
-    ffi = FFI()
-    ffi.cdef("int (*cb)(int);\n"
-             "int foo(int);\n"
-             "void reset_cb(void);")
-    lib = ffi.verify("""
-        static int g(int x) { return x * 7; }
-        static int (*cb)(int);
-        static int foo(int i) { return cb(i) - 1; }
-        static void reset_cb(void) { cb = g; }
-    """)
-    lib.reset_cb()
-    assert lib.foo(6) == 41
-    my_callback = ffi.callback("int(*)(int)", lambda n: n * 222)
-    lib.cb = my_callback
-    assert lib.foo(4) == 887
-
-def test_access_callback_function_typedef():
-    ffi = FFI()
-    ffi.cdef("typedef int mycallback_t(int);\n"
-             "mycallback_t *cb;\n"
-             "int foo(int);\n"
-             "void reset_cb(void);")
-    lib = ffi.verify("""
-        static int g(int x) { return x * 7; }
-        static int (*cb)(int);
-        static int foo(int i) { return cb(i) - 1; }
-        static void reset_cb(void) { cb = g; }
-    """)
-    lib.reset_cb()
-    assert lib.foo(6) == 41
-    my_callback = ffi.callback("int(*)(int)", lambda n: n * 222)
-    lib.cb = my_callback
-    assert lib.foo(4) == 887
-
-def test_ctypes_backend_forces_generic_engine():
-    from cffi.backend_ctypes import CTypesBackend
-    ffi = FFI(backend=CTypesBackend())
-    ffi.cdef("int func(int a);")
-    lib = ffi.verify("int func(int a) { return a * 42; }")
-    assert not hasattr(lib, '_cffi_python_module')
-    assert hasattr(lib, '_cffi_generic_module')
-    assert lib.func(100) == 4200
-
-def test_call_with_struct_ptr():
-    ffi = FFI()
-    ffi.cdef("typedef struct { int x; ...; } foo_t; int foo(foo_t *);")
-    lib = ffi.verify("""
-        typedef struct { int y, x; } foo_t;
-        static int foo(foo_t *f) { return f->x * 7; }
-    """)
-    f = ffi.new("foo_t *")
-    f.x = 6
-    assert lib.foo(f) == 42
-
-def test_unknown_type():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef ... token_t;
-        int foo(token_t *);
-        #define TOKEN_SIZE ...
-    """)
-    lib = ffi.verify("""
-        typedef float token_t;
-        static int foo(token_t *tk) {
-            if (!tk)
-                return -42;
-            *tk += 1.601f;
-            return (int)*tk;
-        }
-        #define TOKEN_SIZE sizeof(token_t)
-    """)
-    # we cannot let ffi.new("token_t *") work, because we don't know ahead of
-    # time if it's ok to ask 'sizeof(token_t)' in the C code or not.
-    # See test_unknown_type_2.  Workaround.
-    tkmem = ffi.new("char[]", lib.TOKEN_SIZE)    # zero-initialized
-    tk = ffi.cast("token_t *", tkmem)
-    results = [lib.foo(tk) for i in range(6)]
-    assert results == [1, 3, 4, 6, 8, 9]
-    assert lib.foo(ffi.NULL) == -42
-
-def test_unknown_type_2():
-    ffi = FFI()
-    ffi.cdef("typedef ... token_t;")
-    lib = ffi.verify("typedef struct token_s token_t;")
-    # assert did not crash, even though 'sizeof(token_t)' is not valid in C.
-
-def test_unknown_type_3():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef ... *token_p;
-        token_p foo(token_p);
-    """)
-    lib = ffi.verify("""
-        typedef struct _token_s *token_p;
-        token_p foo(token_p arg) {
-            if (arg)
-                return (token_p)0x12347;
-            else
-                return (token_p)0x12345;
-        }
-    """)
-    p = lib.foo(ffi.NULL)
-    assert int(ffi.cast("intptr_t", p)) == 0x12345
-    q = lib.foo(p)
-    assert int(ffi.cast("intptr_t", q)) == 0x12347
-
-def test_varargs():
-    ffi = FFI()
-    ffi.cdef("int foo(int x, ...);")
-    lib = ffi.verify("""
-        int foo(int x, ...) {
-            va_list vargs;
-            va_start(vargs, x);
-            x -= va_arg(vargs, int);
-            x -= va_arg(vargs, int);
-            va_end(vargs);
-            return x;
-        }
-    """)
-    assert lib.foo(50, ffi.cast("int", 5), ffi.cast("int", 3)) == 42
-
-def test_varargs_exact():
-    if sys.platform == 'win32':
-        py.test.skip("XXX fixme: only gives warnings")
-    ffi = FFI()
-    ffi.cdef("int foo(int x, ...);")
-    py.test.raises(VerificationError, ffi.verify, """
-        int foo(long long x, ...) {
-            return x;
-        }
-    """)
-
-def test_varargs_struct():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { char a; int b; }; int foo(int x, ...);")
-    lib = ffi.verify("""
-        struct foo_s {
-            char a; int b;
-        };
-        int foo(int x, ...) {
-            va_list vargs;
-            struct foo_s s;
-            va_start(vargs, x);
-            s = va_arg(vargs, struct foo_s);
-            va_end(vargs);
-            return s.a - s.b;
-        }
-    """)
-    s = ffi.new("struct foo_s *", [b'B', 1])
-    assert lib.foo(50, s[0]) == ord('A')
-
-def test_autofilled_struct_as_argument():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { long a; double b; ...; };\n"
-             "int foo(struct foo_s);")
-    lib = ffi.verify("""
-        struct foo_s {
-            double b;
-            long a;
-        };
-        int foo(struct foo_s s) {
-            return (int)s.a - (int)s.b;
-        }
-    """)
-    s = ffi.new("struct foo_s *", [100, 1])
-    assert lib.foo(s[0]) == 99
-    assert lib.foo([100, 1]) == 99
-
-def test_autofilled_struct_as_argument_dynamic():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { long a; ...; };\n"
-             "int (*foo)(struct foo_s);")
-    lib = ffi.verify("""
-        struct foo_s {
-            double b;
-            long a;
-        };
-        int foo1(struct foo_s s) {
-            return (int)s.a - (int)s.b;
-        }
-        int (*foo)(struct foo_s s) = &foo1;
-    """)
-    e = py.test.raises(NotImplementedError, lib.foo, "?")
-    msg = ("ctype 'struct foo_s' not supported as argument (it is a struct "
-           'declared with "...;", but the C calling convention may depend '
-           'on the missing fields)')
-    assert str(e.value) == msg
-
-def test_func_returns_struct():
-    ffi = FFI()
-    ffi.cdef("""
-        struct foo_s { int aa, bb; };
-        struct foo_s foo(int a, int b);
-    """)
-    lib = ffi.verify("""
-        struct foo_s { int aa, bb; };
-        struct foo_s foo(int a, int b) {
-            struct foo_s r;
-            r.aa = a*a;
-            r.bb = b*b;
-            return r;
-        }
-    """)
-    s = lib.foo(6, 7)
-    assert repr(s) == "<cdata 'struct foo_s' owning 8 bytes>"
-    assert s.aa == 36
-    assert s.bb == 49
-
-def test_func_as_funcptr():
-    ffi = FFI()
-    ffi.cdef("int *(*const fooptr)(void);")
-    lib = ffi.verify("""
-        int *foo(void) {
-            return (int*)"foobar";
-        }
-        int *(*fooptr)(void) = foo;
-    """)
-    foochar = ffi.cast("char *(*)(void)", lib.fooptr)
-    s = foochar()
-    assert ffi.string(s) == b"foobar"
-
-def test_funcptr_as_argument():
-    ffi = FFI()
-    ffi.cdef("""
-        void qsort(void *base, size_t nel, size_t width,
-            int (*compar)(const void *, const void *));
-    """)
-    ffi.verify("#include <stdlib.h>")
-
-def test_func_as_argument():
-    ffi = FFI()
-    ffi.cdef("""
-        void qsort(void *base, size_t nel, size_t width,
-            int compar(const void *, const void *));
-    """)
-    ffi.verify("#include <stdlib.h>")
-
-def test_array_as_argument():
-    ffi = FFI()
-    ffi.cdef("""
-        size_t strlen(char string[]);
-    """)
-    ffi.verify("#include <string.h>")
-
-def test_enum_as_argument():
-    ffi = FFI()
-    ffi.cdef("""
-        enum foo_e { AA, BB, ... };
-        int foo_func(enum foo_e);
-    """)
-    lib = ffi.verify("""
-        enum foo_e { AA, CC, BB };
-        int foo_func(enum foo_e e) { return (int)e; }
-    """)
-    assert lib.foo_func(lib.BB) == 2
-    py.test.raises(TypeError, lib.foo_func, "BB")
-
-def test_enum_as_function_result():
-    ffi = FFI()
-    ffi.cdef("""
-        enum foo_e { AA, BB, ... };
-        enum foo_e foo_func(int x);
-    """)
-    lib = ffi.verify("""
-        enum foo_e { AA, CC, BB };
-        enum foo_e foo_func(int x) { return (enum foo_e)x; }
-    """)
-    assert lib.foo_func(lib.BB) == lib.BB == 2
-
-def test_enum_values():
-    ffi = FFI()
-    ffi.cdef("enum enum1_e { AA, BB };")
-    lib = ffi.verify("enum enum1_e { AA, BB };")
-    assert lib.AA == 0
-    assert lib.BB == 1
-    assert ffi.string(ffi.cast("enum enum1_e", 1)) == 'BB'
-
-def test_typedef_complete_enum():
-    ffi = FFI()
-    ffi.cdef("typedef enum { AA, BB } enum1_t;")
-    lib = ffi.verify("typedef enum { AA, BB } enum1_t;")
-    assert ffi.string(ffi.cast("enum1_t", 1)) == 'BB'
-    assert lib.AA == 0
-    assert lib.BB == 1
-
-def test_typedef_broken_complete_enum():
-    ffi = FFI()
-    ffi.cdef("typedef enum { AA, BB } enum1_t;")
-    py.test.raises(VerificationError, ffi.verify,
-                   "typedef enum { AA, CC, BB } enum1_t;")
-
-def test_typedef_incomplete_enum():
-    ffi = FFI()
-    ffi.cdef("typedef enum { AA, BB, ... } enum1_t;")
-    lib = ffi.verify("typedef enum { AA, CC, BB } enum1_t;")
-    assert ffi.string(ffi.cast("enum1_t", 1)) == '1'
-    assert ffi.string(ffi.cast("enum1_t", 2)) == 'BB'
-    assert lib.AA == 0
-    assert lib.BB == 2
-
-def test_typedef_enum_as_argument():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef enum { AA, BB, ... } foo_t;
-        int foo_func(foo_t);
-    """)
-    lib = ffi.verify("""
-        typedef enum { AA, CC, BB } foo_t;
-        int foo_func(foo_t e) { return (int)e; }
-    """)
-    assert lib.foo_func(lib.BB) == lib.BB == 2
-    py.test.raises(TypeError, lib.foo_func, "BB")
-
-def test_typedef_enum_as_function_result():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef enum { AA, BB, ... } foo_t;
-        foo_t foo_func(int x);
-    """)
-    lib = ffi.verify("""
-        typedef enum { AA, CC, BB } foo_t;
-        foo_t foo_func(int x) { return (foo_t)x; }
-    """)
-    assert lib.foo_func(lib.BB) == lib.BB == 2
-
-def test_function_typedef():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef double func_t(double);
-        func_t sin;
-    """)
-    lib = ffi.verify('#include <math.h>', libraries=lib_m)
-    assert lib.sin(1.23) == math.sin(1.23)
-
-def test_opaque_integer_as_function_result():
-    #import platform
-    #if platform.machine().startswith('sparc'):
-    #    py.test.skip('Breaks horribly on sparc (SIGILL + corrupted stack)')
-    #elif platform.machine() == 'mips64' and sys.maxsize > 2**32:
-    #    py.test.skip('Segfaults on mips64el')
-    # XXX bad abuse of "struct { ...; }".  It only works a bit by chance
-    # anyway.  XXX think about something better :-(
-    ffi = FFI()
-    ffi.cdef("""
-        typedef struct { ...; } myhandle_t;
-        myhandle_t foo(void);
-    """)
-    lib = ffi.verify("""
-        typedef short myhandle_t;
-        myhandle_t foo(void) { return 42; }
-    """)
-    h = lib.foo()
-    assert ffi.sizeof(h) == ffi.sizeof("short")
-
-def test_return_partial_struct():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef struct { int x; ...; } foo_t;
-        foo_t foo(void);
-    """)
-    lib = ffi.verify("""
-        typedef struct { int y, x; } foo_t;
-        foo_t foo(void) { foo_t r = { 45, 81 }; return r; }
-    """)
-    h = lib.foo()
-    assert ffi.sizeof(h) == 2 * ffi.sizeof("int")
-    assert h.x == 81
-
-def test_take_and_return_partial_structs():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef struct { int x; ...; } foo_t;
-        foo_t foo(foo_t, foo_t);
-    """)
-    lib = ffi.verify("""
-        typedef struct { int y, x; } foo_t;
-        foo_t foo(foo_t a, foo_t b) {
-            foo_t r = { 100, a.x * 5 + b.x * 7 };
-            return r;
-        }
-    """)
-    args = ffi.new("foo_t[3]")
-    args[0].x = 1000
-    args[2].x = -498
-    h = lib.foo(args[0], args[2])
-    assert ffi.sizeof(h) == 2 * ffi.sizeof("int")
-    assert h.x == 1000 * 5 - 498 * 7
-
-def test_cannot_name_struct_type():
-    ffi = FFI()
-    ffi.cdef("typedef struct { int x; } **sp; void foo(sp);")
-    e = py.test.raises(VerificationError, ffi.verify,
-                       "typedef struct { int x; } **sp; void foo(sp x) { }")
-    assert 'in argument of foo: unknown type name' in str(e.value)
-
-def test_dont_check_unnamable_fields():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { struct { int x; } someone; };")
-    ffi.verify("struct foo_s { struct { int x; } someone; };")
-    # assert did not crash
-
-def test_nested_anonymous_struct_exact():
-    if sys.platform == 'win32':
-        py.test.skip("nested anonymous struct/union")
-    ffi = FFI()
-    ffi.cdef("""
-        struct foo_s { struct { int a; char b; }; union { char c, d; }; };
-    """)
-    ffi.verify("""
-        struct foo_s { struct { int a; char b; }; union { char c, d; }; };
-    """)
-    p = ffi.new("struct foo_s *")
-    assert ffi.sizeof(p[0]) == 3 * ffi.sizeof("int")    # with alignment
-    p.a = 1234567
-    p.b = b'X'
-    p.c = b'Y'
-    assert p.a == 1234567
-    assert p.b == b'X'
-    assert p.c == b'Y'
-    assert p.d == b'Y'
-
-def test_nested_anonymous_struct_exact_error():
-    if sys.platform == 'win32':
-        py.test.skip("nested anonymous struct/union")
-    ffi = FFI()
-    ffi.cdef("""
-        struct foo_s { struct { int a; char b; }; union { char c, d; }; };
-    """)
-    py.test.raises(VerificationError, ffi.verify, """
-        struct foo_s { struct { int a; short b; }; union { char c, d; }; };
-    """)
-    py.test.raises(VerificationError, ffi.verify, """
-        struct foo_s { struct { int a; char e, b; }; union { char c, d; }; };
-    """)
-
-def test_nested_anonymous_struct_inexact_1():
-    ffi = FFI()
-    ffi.cdef("""
-        struct foo_s { struct { char b; ...; }; union { char c, d; }; };
-    """)
-    ffi.verify("""
-        struct foo_s { int a, padding; char c, d, b; };
-    """)
-    assert ffi.sizeof("struct foo_s") == 3 * ffi.sizeof("int")
-
-def test_nested_anonymous_struct_inexact_2():
-    ffi = FFI()
-    ffi.cdef("""
-        struct foo_s { union { char c, d; }; struct { int a; char b; }; ...; };
-    """)
-    ffi.verify("""
-        struct foo_s { int a, padding; char c, d, b; };
-    """)
-    assert ffi.sizeof("struct foo_s") == 3 * ffi.sizeof("int")
-
-def test_ffi_union():
-    ffi = FFI()
-    ffi.cdef("union foo_u { char x; long *z; };")
-    ffi.verify("union foo_u { char x; int y; long *z; };")
-
-def test_ffi_union_partial():
-    ffi = FFI()
-    ffi.cdef("union foo_u { char x; ...; };")
-    ffi.verify("union foo_u { char x; int y; };")
-    assert ffi.sizeof("union foo_u") == 4
-
-def test_ffi_union_with_partial_struct():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int x; ...; }; union foo_u { struct foo_s s; };")
-    ffi.verify("struct foo_s { int a; int x; }; "
-               "union foo_u { char b[32]; struct foo_s s; };")
-    assert ffi.sizeof("struct foo_s") == 8
-    assert ffi.sizeof("union foo_u") == 32
-
-def test_ffi_union_partial_2():
-    ffi = FFI()
-    ffi.cdef("typedef union { char x; ...; } u1;")
-    ffi.verify("typedef union { char x; int y; } u1;")
-    assert ffi.sizeof("u1") == 4
-
-def test_ffi_union_with_partial_struct_2():
-    ffi = FFI()
-    ffi.cdef("typedef struct { int x; ...; } s1;"
-             "typedef union { s1 s; } u1;")
-    ffi.verify("typedef struct { int a; int x; } s1; "
-               "typedef union { char b[32]; s1 s; } u1;")
-    assert ffi.sizeof("s1") == 8
-    assert ffi.sizeof("u1") == 32
-    assert ffi.offsetof("u1", "s") == 0
-
-def test_ffi_struct_packed():
-    if sys.platform == 'win32':
-        py.test.skip("needs a GCC extension")
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int b; ...; };")
-    ffi.verify("""
-        struct foo_s {
-            char a;
-            int b;
-        } __attribute__((packed));
-    """)
-
-def test_tmpdir():
-    import tempfile, os
-    from testing.udir import udir
-    tmpdir = tempfile.mkdtemp(dir=str(udir))
-    ffi = FFI()
-    ffi.cdef("int foo(int);")
-    lib = ffi.verify("int foo(int a) { return a + 42; }", tmpdir=tmpdir)
-    assert os.listdir(tmpdir)
-    assert lib.foo(100) == 142
-
-def test_relative_to():
-    import tempfile, os
-    from testing.udir import udir
-    tmpdir = tempfile.mkdtemp(dir=str(udir))
-    ffi = FFI()
-    ffi.cdef("int foo(int);")
-    f = open(os.path.join(tmpdir, 'foo.h'), 'w')
-    f.write("int foo(int a) { return a + 42; }\n")
-    f.close()
-    lib = ffi.verify('#include "foo.h"',
-                     include_dirs=['.'],
-                     relative_to=os.path.join(tmpdir, 'x'))
-    assert lib.foo(100) == 142
-
-def test_bug1():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef struct tdlhandle_s { ...; } *tdl_handle_t;
-        typedef struct my_error_code_ {
-            tdl_handle_t *rh;
-        } my_error_code_t;
-    """)
-    ffi.verify("""
-        typedef struct tdlhandle_s { int foo; } *tdl_handle_t;
-        typedef struct my_error_code_ {
-            tdl_handle_t *rh;
-        } my_error_code_t;
-    """)
-
-def test_bool():
-    if sys.platform == 'win32':
-        py.test.skip("_Bool not in MSVC")
-    ffi = FFI()
-    ffi.cdef("struct foo_s { _Bool x; };"
-             "_Bool foo(_Bool);")
-    lib = ffi.verify("""
-        struct foo_s { _Bool x; };
-        int foo(int arg) {
-            return !arg;
-        }
-    """)
-    p = ffi.new("struct foo_s *")
-    p.x = 1
-    assert p.x == 1
-    py.test.raises(OverflowError, "p.x = -1")
-    py.test.raises(TypeError, "p.x = 0.0")
-    assert lib.foo(1) == 0
-    assert lib.foo(0) == 1
-    py.test.raises(OverflowError, lib.foo, 42)
-    py.test.raises(TypeError, lib.foo, 0.0)
-    assert int(ffi.cast("_Bool", long(1))) == 1
-    assert int(ffi.cast("_Bool", long(0))) == 0
-    assert int(ffi.cast("_Bool", long(-1))) == 1
-    assert int(ffi.cast("_Bool", 10**200)) == 1
-    assert int(ffi.cast("_Bool", 10**40000)) == 1
-    #
-    class Foo(object):
-        def __int__(self):
-            self.seen = 1
-            return result
-    f = Foo()
-    f.seen = 0
-    result = 42
-    assert int(ffi.cast("_Bool", f)) == 1
-    assert f.seen
-    f.seen = 0
-    result = 0
-    assert int(ffi.cast("_Bool", f)) == 0
-    assert f.seen
-    #
-    py.test.raises(TypeError, ffi.cast, "_Bool", [])
-
-def test_bool_on_long_double():
-    if sys.platform == 'win32':
-        py.test.skip("_Bool not in MSVC")
-    f = 1E-250
-    if f == 0.0 or f*f != 0.0:
-        py.test.skip("unexpected precision")
-    ffi = FFI()
-    ffi.cdef("long double square(long double f); _Bool opposite(_Bool);")
-    lib = ffi.verify("long double square(long double f) { return f*f; }\n"
-                     "_Bool opposite(_Bool x) { return !x; }")
-    f0 = lib.square(0.0)
-    f2 = lib.square(f)
-    f3 = lib.square(f * 2.0)
-    if repr(f2) == repr(f3):
-        py.test.skip("long double doesn't have enough precision")
-    assert float(f0) == float(f2) == float(f3) == 0.0  # too tiny for 'double'
-    assert int(ffi.cast("_Bool", f2)) == 1
-    assert int(ffi.cast("_Bool", f3)) == 1
-    assert int(ffi.cast("_Bool", f0)) == 0
-    py.test.raises(TypeError, lib.opposite, f2)
-
-def test_cannot_pass_float():
-    for basetype in ['char', 'short', 'int', 'long', 'long long']:
-        for sign in ['signed', 'unsigned']:
-            type = '%s %s' % (sign, basetype)
-            ffi = FFI()
-            ffi.cdef("struct foo_s { %s x; };\n"
-                     "int foo(%s);" % (type, type))
-            lib = ffi.verify("""
-                struct foo_s { %s x; };
-                int foo(%s arg) {
-                    return !arg;
-                }
-            """ % (type, type))
-            p = ffi.new("struct foo_s *")
-            py.test.raises(TypeError, "p.x = 0.0")
-            assert lib.foo(42) == 0
-            assert lib.foo(0) == 1
-            py.test.raises(TypeError, lib.foo, 0.0)
-
-def test_cast_from_int_type_to_bool():
-    ffi = FFI()
-    for basetype in ['char', 'short', 'int', 'long', 'long long']:
-        for sign in ['signed', 'unsigned']:
-            type = '%s %s' % (sign, basetype)
-            assert int(ffi.cast("_Bool", ffi.cast(type, 42))) == 1
-            assert int(ffi.cast("bool", ffi.cast(type, 42))) == 1
-            assert int(ffi.cast("_Bool", ffi.cast(type, 0))) == 0
-
-def test_addressof():
-    ffi = FFI()
-    ffi.cdef("""
-        struct point_s { int x, y; };
-        struct foo_s { int z; struct point_s point; };
-        struct point_s sum_coord(struct point_s *);
-    """)
-    lib = ffi.verify("""
-        struct point_s { int x, y; };
-        struct foo_s { int z; struct point_s point; };
-        struct point_s sum_coord(struct point_s *point) {
-            struct point_s r;
-            r.x = point->x + point->y;
-            r.y = point->x - point->y;
-            return r;
-        }
-    """)
-    p = ffi.new("struct foo_s *")
-    p.point.x = 16
-    p.point.y = 9
-    py.test.raises(TypeError, lib.sum_coord, p.point)
-    res = lib.sum_coord(ffi.addressof(p.point))
-    assert res.x == 25
-    assert res.y == 7
-    res2 = lib.sum_coord(ffi.addressof(res))
-    assert res2.x == 32
-    assert res2.y == 18
-    py.test.raises(TypeError, lib.sum_coord, res2)
-
-def test_callback_in_thread():
-    if sys.platform == 'win32':
-        py.test.skip("pthread only")
-    import os, subprocess, imp
-    arg = os.path.join(os.path.dirname(__file__), 'callback_in_thread.py')
-    g = subprocess.Popen([sys.executable, arg,
-                          os.path.dirname(imp.find_module('cffi')[1])])
-    result = g.wait()
-    assert result == 0
-
-def test_keepalive_lib():
-    ffi = FFI()
-    ffi.cdef("int foobar(void);")
-    lib = ffi.verify("int foobar(void) { return 42; }")
-    func = lib.foobar
-    ffi_r = weakref.ref(ffi)
-    lib_r = weakref.ref(lib)
-    del ffi
-    import gc; gc.collect()       # lib stays alive
-    assert lib_r() is not None
-    assert ffi_r() is not None
-    assert func() == 42
-
-def test_keepalive_ffi():
-    ffi = FFI()
-    ffi.cdef("int foobar(void);")
-    lib = ffi.verify("int foobar(void) { return 42; }")
-    func = lib.foobar
-    ffi_r = weakref.ref(ffi)
-    lib_r = weakref.ref(lib)
-    del lib
-    import gc; gc.collect()       # ffi stays alive
-    assert ffi_r() is not None
-    assert lib_r() is not None
-    assert func() == 42
-
-def test_FILE_stored_in_stdout():
-    if not sys.platform.startswith('linux'):
-        py.test.skip("likely, we cannot assign to stdout")
-    ffi = FFI()
-    ffi.cdef("int printf(const char *, ...); FILE *setstdout(FILE *);")
-    lib = ffi.verify("""
-        #include <stdio.h>
-        FILE *setstdout(FILE *f) {
-            FILE *result = stdout;
-            stdout = f;
-            return result;
-        }
-    """)
-    import os
-    fdr, fdw = os.pipe()
-    fw1 = os.fdopen(fdw, 'wb', 256)
-    old_stdout = lib.setstdout(fw1)
-    try:
-        #
-        fw1.write(b"X")
-        r = lib.printf(b"hello, %d!\n", ffi.cast("int", 42))
-        fw1.close()
-        assert r == len("hello, 42!\n")
-        #
-    finally:
-        lib.setstdout(old_stdout)
-    #
-    result = os.read(fdr, 256)
-    os.close(fdr)
-    # the 'X' might remain in the user-level buffer of 'fw1' and
-    # end up showing up after the 'hello, 42!\n'
-    assert result == b"Xhello, 42!\n" or result == b"hello, 42!\nX"
-
-def test_FILE_stored_explicitly():
-    ffi = FFI()
-    ffi.cdef("int myprintf11(const char *, int); FILE *myfile;")
-    lib = ffi.verify("""
-        #include <stdio.h>
-        FILE *myfile;
-        int myprintf11(const char *out, int value) {
-            return fprintf(myfile, out, value);
-        }
-    """)
-    import os
-    fdr, fdw = os.pipe()
-    fw1 = os.fdopen(fdw, 'wb', 256)
-    lib.myfile = ffi.cast("FILE *", fw1)
-    #
-    fw1.write(b"X")
-    r = lib.myprintf11(b"hello, %d!\n", ffi.cast("int", 42))
-    fw1.close()
-    assert r == len("hello, 42!\n")
-    #
-    result = os.read(fdr, 256)
-    os.close(fdr)
-    # the 'X' might remain in the user-level buffer of 'fw1' and
-    # end up showing up after the 'hello, 42!\n'
-    assert result == b"Xhello, 42!\n" or result == b"hello, 42!\nX"
-
-def test_global_array_with_missing_length():
-    ffi = FFI()
-    ffi.cdef("int fooarray[];")
-    lib = ffi.verify("int fooarray[50];")
-    assert repr(lib.fooarray).startswith("<cdata 'int *'")
-
-def test_global_array_with_dotdotdot_length():
-    ffi = FFI()
-    ffi.cdef("int fooarray[...];")
-    lib = ffi.verify("int fooarray[50];")
-    assert repr(lib.fooarray).startswith("<cdata 'int[50]'")
-
-def test_bad_global_array_with_dotdotdot_length():
-    ffi = FFI()
-    ffi.cdef("int fooarray[...];")
-    py.test.raises(VerificationError, ffi.verify, "char fooarray[23];")
-
-def test_struct_containing_struct():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { ...; }; struct bar_s { struct foo_s f; ...; };")
-    ffi.verify("struct foo_s { int x; }; struct bar_s { struct foo_s f; };")
-    #
-    ffi = FFI()
-    ffi.cdef("struct foo_s { struct bar_s f; ...; }; struct bar_s { ...; };")
-    ffi.verify("struct bar_s { int x; }; struct foo_s { struct bar_s f; };")
-
-def test_struct_returned_by_func():
-    ffi = FFI()
-    ffi.cdef("typedef ... foo_t; foo_t myfunc(void);")
-    e = py.test.raises(TypeError, ffi.verify,
-                       "typedef struct { int x; } foo_t; "
-                       "foo_t myfunc(void) { foo_t x = { 42 }; return x; }")
-    assert str(e.value) == (
-        "function myfunc: 'foo_t' is used as result type, but is opaque")
-
-def test_include():
-    ffi1 = FFI()
-    ffi1.cdef("typedef struct { int x; ...; } foo_t;")
-    ffi1.verify("typedef struct { int y, x; } foo_t;")
-    ffi2 = FFI()
-    ffi2.include(ffi1)
-    ffi2.cdef("int myfunc(foo_t *);")
-    lib = ffi2.verify("typedef struct { int y, x; } foo_t;"
-                      "int myfunc(foo_t *p) { return 42 * p->x; }")
-    res = lib.myfunc(ffi2.new("foo_t *", {'x': 10}))
-    assert res == 420
-    res = lib.myfunc(ffi1.new("foo_t *", {'x': -10}))
-    assert res == -420
-
-def test_include_enum():
-    ffi1 = FFI()
-    ffi1.cdef("enum foo_e { AA, ... };")
-    lib1 = ffi1.verify("enum foo_e { CC, BB, AA };")
-    ffi2 = FFI()
-    ffi2.include(ffi1)
-    ffi2.cdef("int myfunc(enum foo_e);")
-    lib2 = ffi2.verify("enum foo_e { CC, BB, AA };"
-                       "int myfunc(enum foo_e x) { return (int)x; }")
-    res = lib2.myfunc(lib2.AA)
-    assert res == 2
-
-def test_named_pointer_as_argument():
-    ffi = FFI()
-    ffi.cdef("typedef struct { int x; } *mystruct_p;\n"
-             "mystruct_p ff5a(mystruct_p);")
-    lib = ffi.verify("typedef struct { int x; } *mystruct_p;\n"
-                     "mystruct_p ff5a(mystruct_p p) { p->x += 40; return p; }")
-    p = ffi.new("mystruct_p", [-2])
-    q = lib.ff5a(p)
-    assert q == p
-    assert p.x == 38
-
-def test_enum_size():
-    cases = [('123',           4, 4294967295),
-             ('4294967295U',   4, 4294967295),
-             ('-123',          4, -1),
-             ('-2147483647-1', 4, -1),
-             ]
-    if FFI().sizeof("long") == 8:
-        cases += [('4294967296L',        8, 2**64-1),
-                  ('%dUL' % (2**64-1),   8, 2**64-1),
-                  ('-2147483649L',       8, -1),
-                  ('%dL-1L' % (1-2**63), 8, -1)]
-    for hidden_value, expected_size, expected_minus1 in cases:
-        if sys.platform == 'win32' and 'U' in hidden_value:
-            continue   # skipped on Windows
-        ffi = FFI()
-        ffi.cdef("enum foo_e { AA, BB, ... };")
-        lib = ffi.verify("enum foo_e { AA, BB=%s };" % hidden_value)
-        assert lib.AA == 0
-        assert lib.BB == eval(hidden_value.replace('U', '').replace('L', ''))
-        assert ffi.sizeof("enum foo_e") == expected_size
-        assert int(ffi.cast("enum foo_e", -1)) == expected_minus1
-    # test with the large value hidden:
-    # disabled so far, doesn't work
-##    for hidden_value, expected_size, expected_minus1 in cases:
-##        ffi = FFI()
-##        ffi.cdef("enum foo_e { AA, BB, ... };")
-##        lib = ffi.verify("enum foo_e { AA, BB=%s };" % hidden_value)
-##        assert lib.AA == 0
-##        assert ffi.sizeof("enum foo_e") == expected_size
-##        assert int(ffi.cast("enum foo_e", -1)) == expected_minus1
-
-def test_enum_bug118():
-    maxulong = 256 ** FFI().sizeof("unsigned long") - 1
-    for c1, c2, c2c in [(0xffffffff, -1, ''),
-                        (maxulong, -1, ''),
-                        (-1, 0xffffffff, 'U'),
-                        (-1, maxulong, 'UL')]:
-        if c2c and sys.platform == 'win32':
-            continue     # enums may always be signed with MSVC
-        ffi = FFI()
-        ffi.cdef("enum foo_e { AA=%s };" % c1)
-        e = py.test.raises(VerificationError, ffi.verify,
-                           "enum foo_e { AA=%s%s };" % (c2, c2c))
-        assert str(e.value) == ('enum foo_e: AA has the real value %d, not %d'
-                                % (c2, c1))
-
-def test_string_to_voidp_arg():
-    ffi = FFI()
-    ffi.cdef("int myfunc(void *);")
-    lib = ffi.verify("int myfunc(void *p) { return ((signed char *)p)[0]; }")
-    res = lib.myfunc(b"hi!")
-    assert res == ord(b"h")
-    p = ffi.new("char[]", b"gah")
-    res = lib.myfunc(p)
-    assert res == ord(b"g")
-    res = lib.myfunc(ffi.cast("void *", p))
-    assert res == ord(b"g")
-    res = lib.myfunc(ffi.cast("int *", p))
-    assert res == ord(b"g")
-
-def test_callback_indirection():
-    ffi = FFI()
-    ffi.cdef("""
-        int (*python_callback)(int how_many, int *values);
-        int (*const c_callback)(int,...);   /* pass this ptr to C routines */
-        int some_c_function(int(*cb)(int,...));
-    """)
-    lib = ffi.verify("""
-        #include <stdarg.h>
-        #ifdef _WIN32
-        #include <malloc.h>
-        #define alloca _alloca
-        #else
-        # ifdef __FreeBSD__
-        #  include <stdlib.h>
-        # else
-        #  include <alloca.h>
-        # endif
-        #endif
-        static int (*python_callback)(int how_many, int *values);
-        static int c_callback(int how_many, ...) {
-            va_list ap;
-            /* collect the "..." arguments into the values[] array */
-            int i, *values = alloca((size_t)how_many * sizeof(int));
-            va_start(ap, how_many);
-            for (i=0; i<how_many; i++)
-                values[i] = va_arg(ap, int);
-            va_end(ap);
-            return python_callback(how_many, values);
-        }
-        int some_c_function(int(*cb)(int,...)) {
-            int result = cb(2, 10, 20);
-            result += cb(3, 30, 40, 50);
-            return result;
-        }
-    """)
-    seen = []
-    @ffi.callback("int(int, int*)")
-    def python_callback(how_many, values):
-        seen.append([values[i] for i in range(how_many)])
-        return 42
-    lib.python_callback = python_callback
-
-    res = lib.some_c_function(lib.c_callback)
-    assert res == 84
-    assert seen == [[10, 20], [30, 40, 50]]
-
-def test_floatstar_argument():
-    ffi = FFI()
-    ffi.cdef("float sum3floats(float *);")
-    lib = ffi.verify("""
-        float sum3floats(float *f) {
-            return f[0] + f[1] + f[2];
-        }
-    """)
-    assert lib.sum3floats((1.5, 2.5, 3.5)) == 7.5
-    p = ffi.new("float[]", (1.5, 2.5, 3.5))
-    assert lib.sum3floats(p) == 7.5
-
-def test_charstar_argument():
-    ffi = FFI()
-    ffi.cdef("char sum3chars(char *);")
-    lib = ffi.verify("""
-        char sum3chars(char *f) {
-            return (char)(f[0] + f[1] + f[2]);
-        }
-    """)
-    assert lib.sum3chars((b'\x10', b'\x20', b'\x30')) == b'\x60'
-    p = ffi.new("char[]", b'\x10\x20\x30')
-    assert lib.sum3chars(p) == b'\x60'
-
-def test_passing_string_or_NULL():
-    ffi = FFI()
-    ffi.cdef("int seeme1(char *); int seeme2(int *);")
-    lib = ffi.verify("""
-        int seeme1(char *x) {
-            return (x == NULL);
-        }
-        int seeme2(int *x) {
-            return (x == NULL);
-        }
-    """)
-    assert lib.seeme1(b"foo") == 0
-    assert lib.seeme1(ffi.NULL) == 1
-    assert lib.seeme2([42, 43]) == 0
-    assert lib.seeme2(ffi.NULL) == 1
-    py.test.raises(TypeError, lib.seeme1, None)
-    py.test.raises(TypeError, lib.seeme2, None)
-    py.test.raises(TypeError, lib.seeme1, 0.0)
-    py.test.raises(TypeError, lib.seeme2, 0.0)
-    py.test.raises(TypeError, lib.seeme1, 0)
-    py.test.raises(TypeError, lib.seeme2, 0)
-    zeroL  = 99999999999999999999
-    zeroL -= 99999999999999999999
-    py.test.raises(TypeError, lib.seeme2, zeroL)
-
-def test_typeof_function():
-    ffi = FFI()
-    ffi.cdef("int foo(int, char);")
-    lib = ffi.verify("int foo(int x, char y) { (void)x; (void)y; return 42; }")
-    ctype = ffi.typeof(lib.foo)
-    assert len(ctype.args) == 2
-    assert ctype.result == ffi.typeof("int")
-
-def test_call_with_voidstar_arg():
-    ffi = FFI()
-    ffi.cdef("int f(void *);")
-    lib = ffi.verify("int f(void *x) { return ((char*)x)[0]; }")
-    assert lib.f(b"foobar") == ord(b"f")
-
-def test_dir():
-    ffi = FFI()
-    ffi.cdef("""void somefunc(void);
-                extern int somevar, somearray[2];
-                static char *const sv2;
-                enum my_e { AA, BB, ... };
-                #define FOO ...""")
-    lib = ffi.verify("""void somefunc(void) { }
-                        int somevar, somearray[2];
-                        #define sv2 "text"
-                        enum my_e { AA, BB };
-                        #define FOO 42""")
-    assert dir(lib) == ['AA', 'BB', 'FOO', 'somearray',
-                        'somefunc', 'somevar', 'sv2']
-
-def test_typeof_func_with_struct_argument():
-    ffi = FFI()
-    ffi.cdef("""struct s { int a; }; int foo(struct s);""")
-    lib = ffi.verify("""struct s { int a; };
-                        int foo(struct s x) { return x.a; }""")
-    s = ffi.new("struct s *", [-1234])
-    m = lib.foo(s[0])
-    assert m == -1234
-    assert repr(ffi.typeof(lib.foo)) == "<ctype 'int(*)(struct s)'>"
-
-def test_bug_const_char_ptr_array_1():
-    ffi = FFI()
-    ffi.cdef("""const char *a[...];""")
-    lib = ffi.verify("""const char *a[5];""")
-    assert repr(ffi.typeof(lib.a)) == "<ctype 'char *[5]'>"
-
-def test_bug_const_char_ptr_array_2():
-    from cffi import FFI     # ignore warnings
-    ffi = FFI()
-    ffi.cdef("""const int a[];""")
-    lib = ffi.verify("""const int a[5];""")
-    assert repr(ffi.typeof(lib.a)) == "<ctype 'int *'>"
-
-def _test_various_calls(force_libffi):
-    cdef_source = """
-    int xvalue;
-    long long ivalue, rvalue;
-    float fvalue;
-    double dvalue;
-    long double Dvalue;
-    signed char tf_bb(signed char x, signed char c);
-    unsigned char tf_bB(signed char x, unsigned char c);
-    short tf_bh(signed char x, short c);
-    unsigned short tf_bH(signed char x, unsigned short c);
-    int tf_bi(signed char x, int c);
-    unsigned int tf_bI(signed char x, unsigned int c);
-    long tf_bl(signed char x, long c);
-    unsigned long tf_bL(signed char x, unsigned long c);
-    long long tf_bq(signed char x, long long c);
-    unsigned long long tf_bQ(signed char x, unsigned long long c);
-    float tf_bf(signed char x, float c);
-    double tf_bd(signed char x, double c);
-    long double tf_bD(signed char x, long double c);
-    """
-    if force_libffi:
-        cdef_source = (cdef_source
-            .replace('tf_', '(*const tf_')
-            .replace('(signed char x', ')(signed char x'))
-    ffi = FFI()
-    ffi.cdef(cdef_source)
-    lib = ffi.verify("""
-    int xvalue;
-    long long ivalue, rvalue;
-    float fvalue;
-    double dvalue;
-    long double Dvalue;
-
-    typedef signed char b_t;
-    typedef unsigned char B_t;
-    typedef short h_t;
-    typedef unsigned short H_t;
-    typedef int i_t;
-    typedef unsigned int I_t;
-    typedef long l_t;
-    typedef unsigned long L_t;
-    typedef long long q_t;
-    typedef unsigned long long Q_t;
-    typedef float f_t;
-    typedef double d_t;
-    typedef long double D_t;
-    #define S(letter)  xvalue = (int)x; letter##value = (letter##_t)c;
-    #define R(letter)  return (letter##_t)rvalue;
-
-    signed char tf_bb(signed char x, signed char c) { S(i) R(b) }
-    unsigned char tf_bB(signed char x, unsigned char c) { S(i) R(B) }
-    short tf_bh(signed char x, short c) { S(i) R(h) }
-    unsigned short tf_bH(signed char x, unsigned short c) { S(i) R(H) }
-    int tf_bi(signed char x, int c) { S(i) R(i) }
-    unsigned int tf_bI(signed char x, unsigned int c) { S(i) R(I) }
-    long tf_bl(signed char x, long c) { S(i) R(l) }
-    unsigned long tf_bL(signed char x, unsigned long c) { S(i) R(L) }
-    long long tf_bq(signed char x, long long c) { S(i) R(q) }
-    unsigned long long tf_bQ(signed char x, unsigned long long c) { S(i) R(Q) }
-    float tf_bf(signed char x, float c) { S(f) R(f) }
-    double tf_bd(signed char x, double c) { S(d) R(d) }
-    long double tf_bD(signed char x, long double c) { S(D) R(D) }
-    """)
-    lib.rvalue = 0x7182838485868788
-    for kind, cname in [('b', 'signed char'),
-                        ('B', 'unsigned char'),
-                        ('h', 'short'),
-                        ('H', 'unsigned short'),
-                        ('i', 'int'),
-                        ('I', 'unsigned int'),
-                        ('l', 'long'),
-                        ('L', 'unsigned long'),
-                        ('q', 'long long'),
-                        ('Q', 'unsigned long long'),
-                        ('f', 'float'),
-                        ('d', 'double'),
-                        ('D', 'long double')]:
-        sign = +1 if 'unsigned' in cname else -1
-        lib.xvalue = 0
-        lib.ivalue = 0
-        lib.fvalue = 0
-        lib.dvalue = 0
-        lib.Dvalue = 0
-        fun = getattr(lib, 'tf_b' + kind)
-        res = fun(-42, sign * 99)
-        if kind == 'D':
-            res = float(res)
-        assert res == int(ffi.cast(cname, 0x7182838485868788))
-        assert lib.xvalue == -42
-        if kind in 'fdD':
-            assert float(getattr(lib, kind + 'value')) == -99.0
-        else:
-            assert lib.ivalue == sign * 99
-
-def test_various_calls_direct():
-    _test_various_calls(force_libffi=False)
-
-def test_various_calls_libffi():
-    _test_various_calls(force_libffi=True)
-
-def test_ptr_to_opaque():
-    ffi = FFI()
-    ffi.cdef("typedef ... foo_t; int f1(foo_t*); foo_t *f2(int);")
-    lib = ffi.verify("""
-        #include <stdlib.h>
-        typedef struct { int x; } foo_t;
-        int f1(foo_t* p) {
-            int x = p->x;
-            free(p);
-            return x;
-        }
-        foo_t *f2(int x) {
-            foo_t *p = malloc(sizeof(foo_t));
-            p->x = x;
-            return p;
-        }
-    """)
-    p = lib.f2(42)
-    x = lib.f1(p)
-    assert x == 42
-
-def _run_in_multiple_threads(test1):
-    test1()
-    import sys
-    try:
-        import thread
-    except ImportError:
-        import _thread as thread
-    errors = []
-    def wrapper(lock):
-        try:
-            test1()
-        except:
-            errors.append(sys.exc_info())
-        lock.release()
-    locks = []
-    for i in range(10):
-        _lock = thread.allocate_lock()
-        _lock.acquire()
-        thread.start_new_thread(wrapper, (_lock,))
-        locks.append(_lock)
-    for _lock in locks:
-        _lock.acquire()
-        if errors:
-            raise errors[0][1]
-
-def test_errno_working_even_with_pypys_jit():
-    ffi = FFI()
-    ffi.cdef("int f(int);")
-    lib = ffi.verify("""
-        #include <errno.h>
-        int f(int x) { return (errno = errno + x); }
-    """)
-    @_run_in_multiple_threads
-    def test1():
-        ffi.errno = 0
-        for i in range(10000):
-            e = lib.f(1)
-            assert e == i + 1
-            assert ffi.errno == e
-        for i in range(10000):
-            ffi.errno = i
-            e = lib.f(42)
-            assert e == i + 42
-
-def test_getlasterror_working_even_with_pypys_jit():
-    if sys.platform != 'win32':
-        py.test.skip("win32-only test")
-    ffi = FFI()
-    ffi.cdef("void SetLastError(DWORD);")
-    lib = ffi.dlopen("Kernel32.dll")
-    @_run_in_multiple_threads
-    def test1():
-        for i in range(10000):
-            n = (1 << 29) + i
-            lib.SetLastError(n)
-            assert ffi.getwinerror()[0] == n
-
-def test_verify_dlopen_flags():
-    # Careful with RTLD_GLOBAL.  If by chance the FFI is not deleted
-    # promptly, like on PyPy, then other tests may see the same
-    # exported symbols as well.  So we must not export a simple name
-    # like 'foo'!
-    ffi1 = FFI()
-    ffi1.cdef("int foo_verify_dlopen_flags;")
-
-    lib1 = ffi1.verify("int foo_verify_dlopen_flags;",
-                       flags=ffi1.RTLD_GLOBAL | ffi1.RTLD_LAZY)
-    lib2 = get_second_lib()
-
-    lib1.foo_verify_dlopen_flags = 42
-    assert lib2.foo_verify_dlopen_flags == 42
-    lib2.foo_verify_dlopen_flags += 1
-    assert lib1.foo_verify_dlopen_flags == 43
-
-def get_second_lib():
-    # Hack, using modulename makes the test fail
-    ffi2 = FFI()
-    ffi2.cdef("int foo_verify_dlopen_flags;")
-    lib2 = ffi2.verify("int foo_verify_dlopen_flags;",
-                       flags=ffi2.RTLD_GLOBAL | ffi2.RTLD_LAZY)
-    return lib2
-
-def test_consider_not_implemented_function_type():
-    ffi = FFI()
-    ffi.cdef("typedef union { int a; float b; } Data;"
-             "typedef struct { int a:2; } MyStr;"
-             "typedef void (*foofunc_t)(Data);"
-             "typedef Data (*bazfunc_t)(void);"
-             "typedef MyStr (*barfunc_t)(void);")
-    fooptr = ffi.cast("foofunc_t", 123)
-    bazptr = ffi.cast("bazfunc_t", 123)
-    barptr = ffi.cast("barfunc_t", 123)
-    # assert did not crash so far
-    e = py.test.raises(NotImplementedError, fooptr, ffi.new("Data *"))
-    assert str(e.value) == (
-        "ctype 'Data' (size 4) not supported as argument")
-    e = py.test.raises(NotImplementedError, bazptr)
-    assert str(e.value) == (
-        "ctype 'Data' (size 4) not supported as return value")
-    e = py.test.raises(NotImplementedError, barptr)
-    assert str(e.value) == (
-        "ctype 'MyStr' not supported as return value "
-        "(it is a struct with bit fields)")
-
-def test_verify_extra_arguments():
-    ffi = FFI()
-    ffi.cdef("#define ABA ...")
-    lib = ffi.verify("", define_macros=[('ABA', '42')])
-    assert lib.ABA == 42
-
-def test_implicit_unicode_on_windows():
-    if sys.platform != 'win32':
-        py.test.skip("win32-only test")
-    ffi = FFI()
-    e = py.test.raises(FFIError, ffi.cdef, "int foo(LPTSTR);")
-    assert str(e.value) == ("The Windows type 'LPTSTR' is only available after"
-                            " you call ffi.set_unicode()")
-    for with_unicode in [True, False]:
-        ffi = FFI()
-        ffi.set_unicode(with_unicode)
-        ffi.cdef("""
-            DWORD GetModuleFileName(HMODULE hModule, LPTSTR lpFilename,
-                                    DWORD nSize);
-        """)
-        lib = ffi.verify("""
-            #include <windows.h>
-        """, libraries=['Kernel32'])
-        outbuf = ffi.new("TCHAR[]", 200)
-        n = lib.GetModuleFileName(ffi.NULL, outbuf, 500)
-        assert 0 < n < 500
-        for i in range(n):
-            #print repr(outbuf[i])
-            assert ord(outbuf[i]) != 0
-        assert ord(outbuf[n]) == 0
-        assert ord(outbuf[0]) < 128     # should be a letter, or '\'
-
-def test_use_local_dir():
-    ffi = FFI()
-    lib = ffi.verify("", modulename="test_use_local_dir")
-    this_dir = os.path.dirname(__file__)
-    pycache_files = os.listdir(os.path.join(this_dir, '__pycache__'))
-    assert any('test_use_local_dir' in s for s in pycache_files)
-
-def test_define_known_value():
-    ffi = FFI()
-    ffi.cdef("#define FOO 0x123")
-    lib = ffi.verify("#define FOO 0x123")
-    assert lib.FOO == 0x123
-
-def test_define_wrong_value():
-    ffi = FFI()
-    ffi.cdef("#define FOO 123")
-    e = py.test.raises(VerificationError, ffi.verify, "#define FOO 124")
-    assert str(e.value).endswith("FOO has the real value 124, not 123")
-
-def test_static_const_int_known_value():
-    ffi = FFI()
-    ffi.cdef("static const int FOO = 0x123;")
-    lib = ffi.verify("#define FOO 0x123")
-    assert lib.FOO == 0x123
-
-def test_static_const_int_wrong_value():
-    ffi = FFI()
-    ffi.cdef("static const int FOO = 123;")
-    e = py.test.raises(VerificationError, ffi.verify, "#define FOO 124")
-    assert str(e.value).endswith("FOO has the real value 124, not 123")
-
-def test_const_struct_global():
-    ffi = FFI()
-    ffi.cdef("typedef struct { int x; ...; } T; const T myglob;")
-    lib = ffi.verify("typedef struct { double y; int x; } T;"
-                     "const T myglob = { 0.1, 42 };")
-    assert ffi.typeof(lib.myglob) == ffi.typeof("T")
-    assert lib.myglob.x == 42
-
-def test_dont_support_int_dotdotdot():
-    ffi = FFI()
-    ffi.cdef("typedef int... t1;")
-    e = py.test.raises(VerificationError, ffi.verify, "")
-    assert str(e.value) == ("feature not supported with ffi.verify(), but only "
-                            "with ffi.set_source(): 'typedef int... t1'")
-    ffi = FFI()
-    ffi.cdef("typedef unsigned long... t1;")
-    e = py.test.raises(VerificationError, ffi.verify, "")
-    assert str(e.value) == ("feature not supported with ffi.verify(), but only "
-                         "with ffi.set_source(): 'typedef unsigned long... t1'")
-
-def test_const_fields():
-    ffi = FFI()
-    ffi.cdef("""struct foo_s { const int a; void *const b; };""")
-    ffi.verify("""struct foo_s { const int a; void *const b; };""")
-    foo_s = ffi.typeof("struct foo_s")
-    assert foo_s.fields[0][0] == 'a'
-    assert foo_s.fields[0][1].type is ffi.typeof("int")
-    assert foo_s.fields[1][0] == 'b'
-    assert foo_s.fields[1][1].type is ffi.typeof("void *")
-
-def test_win32_calling_convention_0():
-    ffi = FFI()
-    ffi.cdef("""
-        int call1(int(__cdecl   *cb)(int));
-        int (*const call2)(int(__stdcall *cb)(int));
-    """)
-    lib = ffi.verify(r"""
-        #ifndef _MSC_VER
-        #  define __stdcall  /* nothing */
-        #endif
-        int call1(int(*cb)(int)) {
-            int i, result = 0;
-            //printf("call1: cb = %p\n", cb);
-            for (i = 0; i < 1000; i++)
-                result += cb(i);
-            //printf("result = %d\n", result);
-            return result;
-        }
-        int call2(int(__stdcall *cb)(int)) {
-            int i, result = 0;
-            //printf("call2: cb = %p\n", cb);
-            for (i = 0; i < 1000; i++)
-                result += cb(-i);
-            //printf("result = %d\n", result);
-            return result;
-        }
-    """)
-    @ffi.callback("int(int)")
-    def cb1(x):
-        return x * 2
-    @ffi.callback("int __stdcall(int)")
-    def cb2(x):
-        return x * 3
-    #print 'cb1 =', cb1
-    res = lib.call1(cb1)
-    assert res == 500*999*2
-    #print 'cb2 =', cb2
-    #print ffi.typeof(lib.call2)
-    #print 'call2 =', lib.call2
-    res = lib.call2(cb2)
-    #print '...'
-    assert res == -500*999*3
-    #print 'done'
-    if sys.platform == 'win32' and sys.maxsize < 2**32:
-        assert '__stdcall' in str(ffi.typeof(cb2))
-        assert '__stdcall' not in str(ffi.typeof(cb1))
-        py.test.raises(TypeError, lib.call1, cb2)
-        py.test.raises(TypeError, lib.call2, cb1)
-    else:
-        assert '__stdcall' not in str(ffi.typeof(cb2))
-        assert ffi.typeof(cb2) is ffi.typeof(cb1)
-
-def test_win32_calling_convention_1():
-    ffi = FFI()
-    ffi.cdef("""
-        int __cdecl   call1(int(__cdecl   *cb)(int));
-        int __stdcall call2(int(__stdcall *cb)(int));
-        int (__cdecl   *const cb1)(int);
-        int (__stdcall *const cb2)(int);
-    """)
-    lib = ffi.verify(r"""
-        #ifndef _MSC_VER
-        #  define __cdecl
-        #  define __stdcall
-        #endif
-        int __cdecl   cb1(int x) { return x * 2; }
-        int __stdcall cb2(int x) { return x * 3; }
-
-        int __cdecl call1(int(__cdecl *cb)(int)) {
-            int i, result = 0;
-            //printf("here1\n");
-            //printf("cb = %p, cb1 = %p\n", cb, (void *)cb1);
-            for (i = 0; i < 1000; i++)
-                result += cb(i);
-            //printf("result = %d\n", result);
-            return result;
-        }
-        int __stdcall call2(int(__stdcall *cb)(int)) {
-            int i, result = 0;
-            //printf("here1\n");
-            //printf("cb = %p, cb2 = %p\n", cb, (void *)cb2);
-            for (i = 0; i < 1000; i++)
-                result += cb(-i);
-            //printf("result = %d\n", result);
-            return result;
-        }
-    """)
-    assert lib.call1(lib.cb1) == 500*999*2
-    assert lib.call2(lib.cb2) == -500*999*3
-
-def test_win32_calling_convention_2():
-    # any mistake in the declaration of plain function (including the
-    # precise argument types and, here, the calling convention) are
-    # automatically corrected.  But this does not apply to the 'cb'
-    # function pointer argument.
-    ffi = FFI()
-    ffi.cdef("""
-        int __stdcall call1(int(__cdecl   *cb)(int));
-        int __cdecl   call2(int(__stdcall *cb)(int));
-        int (__cdecl   *const cb1)(int);
-        int (__stdcall *const cb2)(int);
-    """)
-    lib = ffi.verify(r"""
-        #ifndef _MSC_VER
-        #  define __cdecl
-        #  define __stdcall
-        #endif
-        int __cdecl call1(int(__cdecl *cb)(int)) {
-            int i, result = 0;
-            for (i = 0; i < 1000; i++)
-                result += cb(i);
-            return result;
-        }
-        int __stdcall call2(int(__stdcall *cb)(int)) {
-            int i, result = 0;
-            for (i = 0; i < 1000; i++)
-                result += cb(-i);
-            return result;
-        }
-        int __cdecl   cb1(int x) { return x * 2; }
-        int __stdcall cb2(int x) { return x * 3; }
-    """)
-    assert lib.call1(lib.cb1) == 500*999*2
-    assert lib.call2(lib.cb2) == -500*999*3
-
-def test_win32_calling_convention_3():
-    ffi = FFI()
-    ffi.cdef("""
-        struct point { int x, y; };
-
-        int (*const cb1)(struct point);
-        int (__stdcall *const cb2)(struct point);
-
-        struct point __stdcall call1(int(*cb)(struct point));
-        struct point call2(int(__stdcall *cb)(struct point));
-    """)
-    lib = ffi.verify(r"""
-        #ifndef _MSC_VER
-        #  define __cdecl
-        #  define __stdcall
-        #endif
-        struct point { int x, y; };
-        int           cb1(struct point pt) { return pt.x + 10 * pt.y; }
-        int __stdcall cb2(struct point pt) { return pt.x + 100 * pt.y; }
-        struct point __stdcall call1(int(__cdecl *cb)(struct point)) {
-            int i;
-            struct point result = { 0, 0 };
-            //printf("here1\n");
-            //printf("cb = %p, cb1 = %p\n", cb, (void *)cb1);
-            for (i = 0; i < 1000; i++) {
-                struct point p = { i, -i };
-                int r = cb(p);
-                result.x += r;
-                result.y -= r;
-            }
-            return result;
-        }
-        struct point __cdecl call2(int(__stdcall *cb)(struct point)) {
-            int i;
-            struct point result = { 0, 0 };
-            for (i = 0; i < 1000; i++) {
-                struct point p = { -i, i };
-                int r = cb(p);
-                result.x += r;
-                result.y -= r;
-            }
-            return result;
-        }
-    """)
-    if sys.platform == 'win32' and sys.maxsize < 2**32:
-        py.test.raises(TypeError, lib.call1, lib.cb2)
-        py.test.raises(TypeError, lib.call2, lib.cb1)
-    pt = lib.call1(lib.cb1)
-    assert (pt.x, pt.y) == (-9*500*999, 9*500*999)
-    pt = lib.call2(lib.cb2)
-    assert (pt.x, pt.y) == (99*500*999, -99*500*999)

+ 0 - 9
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_verify2.py

@@ -1,9 +0,0 @@
-from .test_verify import *
-
-# This test file runs normally after test_verify.  We only clean up the .c
-# sources, to check that it also works when we have only the .so.  The
-# tests should run much faster than test_verify.
-
-def setup_module():
-    import cffi.verifier
-    cffi.verifier.cleanup_tmpdir(keep_so=True)

+ 0 - 55
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_version.py

@@ -1,55 +0,0 @@
-import py, os, sys
-import cffi, _cffi_backend
-
-def setup_module(mod):
-    if '_cffi_backend' in sys.builtin_module_names:
-        py.test.skip("this is embedded version")
-
-#BACKEND_VERSIONS = {
-#    '0.4.2': '0.4',     # did not change
-#    '0.7.1': '0.7',     # did not change
-#    '0.7.2': '0.7',     # did not change
-#    '0.8.1': '0.8',     # did not change (essentially)
-#    '0.8.4': '0.8.3',   # did not change
-#    }
-
-def test_version():
-    v = cffi.__version__
-    version_info = '.'.join(str(i) for i in cffi.__version_info__)
-    version_info = version_info.replace('.beta.', 'b')
-    version_info = version_info.replace('.plus', '+')
-    assert v == version_info
-    #v = BACKEND_VERSIONS.get(v, v)
-    assert v == _cffi_backend.__version__
-
-def test_doc_version():
-    parent = os.path.dirname(os.path.dirname(cffi.__file__))
-    p = os.path.join(parent, 'doc', 'source', 'conf.py')
-    content = open(p).read()
-    #
-    v = cffi.__version__
-    assert ("version = '%s'\n" % v[:3]) in content
-    assert ("release = '%s'\n" % v) in content
-
-def test_doc_version_file():
-    parent = os.path.dirname(os.path.dirname(cffi.__file__))
-    v = cffi.__version__.replace('+', '')
-    p = os.path.join(parent, 'doc', 'source', 'installation.rst')
-    content = open(p).read()
-    assert ("cffi/cffi-%s.tar.gz" % v) in content
-
-def test_setup_version():
-    parent = os.path.dirname(os.path.dirname(cffi.__file__))
-    p = os.path.join(parent, 'setup.py')
-    content = open(p).read()
-    #
-    v = cffi.__version__.replace('+', '')
-    assert ("version='%s'" % v) in content
-
-def test_c_version():
-    parent = os.path.dirname(os.path.dirname(cffi.__file__))
-    v = cffi.__version__
-    p = os.path.join(parent, 'c', 'test_c.py')
-    content = open(p).read()
-    #v = BACKEND_VERSIONS.get(v, v)
-    assert (('assert __version__ == "%s"' % v) in content)

+ 0 - 12
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_vgen.py

@@ -1,12 +0,0 @@
-import cffi.verifier
-from .test_verify import *
-
-
-def setup_module():
-    cffi.verifier.cleanup_tmpdir()
-    cffi.verifier._FORCE_GENERIC_ENGINE = True
-    # Runs all tests with _FORCE_GENERIC_ENGINE = True, to make sure we
-    # also test vengine_gen.py.
-
-def teardown_module():
-    cffi.verifier._FORCE_GENERIC_ENGINE = False

+ 0 - 13
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_vgen2.py

@@ -1,13 +0,0 @@
-import cffi.verifier
-from .test_vgen import *
-
-# This test file runs normally after test_vgen.  We only clean up the .c
-# sources, to check that it also works when we have only the .so.  The
-# tests should run much faster than test_vgen.
-
-def setup_module():
-    cffi.verifier.cleanup_tmpdir(keep_so=True)
-    cffi.verifier._FORCE_GENERIC_ENGINE = True
-
-def teardown_module():
-    cffi.verifier._FORCE_GENERIC_ENGINE = False

+ 0 - 288
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_zdistutils.py

@@ -1,288 +0,0 @@
-import sys, os, imp, math, shutil
-import py
-from cffi import FFI, FFIError
-from cffi.verifier import Verifier, _locate_engine_class, _get_so_suffixes
-from cffi.ffiplatform import maybe_relative_path
-from testing.udir import udir
-
-
-class DistUtilsTest(object):
-    def setup_class(self):
-        self.lib_m = "m"
-        if sys.platform == 'win32':
-            #there is a small chance this fails on Mingw via environ $CC
-            import distutils.ccompiler
-            if distutils.ccompiler.get_default_compiler() == 'msvc':
-                self.lib_m = 'msvcrt'
-
-    def teardown_class(self):
-        if udir.isdir():
-            udir.remove(ignore_errors=True)
-        udir.ensure(dir=1)
-
-    def test_locate_engine_class(self):
-        cls = _locate_engine_class(FFI(), self.generic)
-        if self.generic:
-            # asked for the generic engine, which must not generate a
-            # CPython extension module
-            assert not cls._gen_python_module
-        else:
-            # asked for the CPython engine: check that we got it, unless
-            # we are running on top of PyPy, where the generic engine is
-            # always better
-            if '__pypy__' not in sys.builtin_module_names:
-                assert cls._gen_python_module
-
-    def test_write_source(self):
-        ffi = FFI()
-        ffi.cdef("double sin(double x);")
-        csrc = '/*hi there %s!*/\n#include <math.h>\n' % self
-        v = Verifier(ffi, csrc, force_generic_engine=self.generic,
-                     libraries=[self.lib_m])
-        v.write_source()
-        with open(v.sourcefilename, 'r') as f:
-            data = f.read()
-        assert csrc in data
-
-    def test_write_source_explicit_filename(self):
-        ffi = FFI()
-        ffi.cdef("double sin(double x);")
-        csrc = '/*hi there %s!*/\n#include <math.h>\n' % self
-        v = Verifier(ffi, csrc, force_generic_engine=self.generic,
-                     libraries=[self.lib_m])
-        v.sourcefilename = filename = str(udir.join('write_source.c'))
-        v.write_source()
-        assert filename == v.sourcefilename
-        with open(filename, 'r') as f:
-            data = f.read()
-        assert csrc in data
-
-    def test_write_source_to_file_obj(self):
-        ffi = FFI()
-        ffi.cdef("double sin(double x);")
-        csrc = '/*hi there %s!*/\n#include <math.h>\n' % self
-        v = Verifier(ffi, csrc, force_generic_engine=self.generic,
-                     libraries=[self.lib_m])
-        try:
-            from StringIO import StringIO
-        except ImportError:
-            from io import StringIO
-        f = StringIO()
-        v.write_source(file=f)
-        assert csrc in f.getvalue()
-
-    def test_compile_module(self):
-        ffi = FFI()
-        ffi.cdef("double sin(double x);")
-        csrc = '/*hi there %s!*/\n#include <math.h>\n' % self
-        v = Verifier(ffi, csrc, force_generic_engine=self.generic,
-                     libraries=[self.lib_m])
-        v.compile_module()
-        assert v.get_module_name().startswith('_cffi_')
-        if v.generates_python_module():
-            mod = imp.load_dynamic(v.get_module_name(), v.modulefilename)
-            assert hasattr(mod, '_cffi_setup')
-
-    def test_compile_module_explicit_filename(self):
-        ffi = FFI()
-        ffi.cdef("double sin(double x);")
-        csrc = '/*hi there %s!2*/\n#include <math.h>\n' % self
-        v = Verifier(ffi, csrc, force_generic_engine=self.generic,
-                     libraries=[self.lib_m])
-        basename = self.__class__.__name__ + 'test_compile_module'
-        v.modulefilename = filename = str(udir.join(basename + '.so'))
-        v.compile_module()
-        assert filename == v.modulefilename
-        assert v.get_module_name() == basename
-        if v.generates_python_module():
-            mod = imp.load_dynamic(v.get_module_name(), v.modulefilename)
-            assert hasattr(mod, '_cffi_setup')
-
-    def test_name_from_checksum_of_cdef(self):
-        names = []
-        for csrc in ['double', 'double', 'float']:
-            ffi = FFI()
-            ffi.cdef("%s sin(double x);" % csrc)
-            v = Verifier(ffi, "#include <math.h>",
-                         force_generic_engine=self.generic,
-                         libraries=[self.lib_m])
-            names.append(v.get_module_name())
-        assert names[0] == names[1] != names[2]
-
-    def test_name_from_checksum_of_csrc(self):
-        names = []
-        for csrc in ['123', '123', '1234']:
-            ffi = FFI()
-            ffi.cdef("double sin(double x);")
-            v = Verifier(ffi, csrc, force_generic_engine=self.generic)
-            names.append(v.get_module_name())
-        assert names[0] == names[1] != names[2]
-
-    def test_load_library(self):
-        ffi = FFI()
-        ffi.cdef("double sin(double x);")
-        csrc = '/*hi there %s!3*/\n#include <math.h>\n' % self
-        v = Verifier(ffi, csrc, force_generic_engine=self.generic,
-                     libraries=[self.lib_m])
-        library = v.load_library()
-        assert library.sin(12.3) == math.sin(12.3)
-
-    def test_verifier_args(self):
-        ffi = FFI()
-        ffi.cdef("double sin(double x);")
-        csrc = '/*hi there %s!4*/#include "test_verifier_args.h"\n' % self
-        udir.join('test_verifier_args.h').write('#include <math.h>\n')
-        v = Verifier(ffi, csrc, include_dirs=[str(udir)],
-                     force_generic_engine=self.generic,
-                     libraries=[self.lib_m])
-        library = v.load_library()
-        assert library.sin(12.3) == math.sin(12.3)
-
-    def test_verifier_object_from_ffi(self):
-        ffi = FFI()
-        ffi.cdef("double sin(double x);")
-        csrc = "/*6%s*/\n#include <math.h>" % self
-        lib = ffi.verify(csrc, force_generic_engine=self.generic,
-                         libraries=[self.lib_m])
-        assert lib.sin(12.3) == math.sin(12.3)
-        assert isinstance(ffi.verifier, Verifier)
-        with open(ffi.verifier.sourcefilename, 'r') as f:
-            data = f.read()
-        assert csrc in data
-
-    def test_extension_object(self):
-        ffi = FFI()
-        ffi.cdef("double sin(double x);")
-        csrc = '/*7%s*/' % self + '''
-    #include <math.h>
-    #ifndef TEST_EXTENSION_OBJECT
-    # error "define_macros missing"
-    #endif
-    '''
-        lib = ffi.verify(csrc, define_macros=[('TEST_EXTENSION_OBJECT', '1')],
-                         force_generic_engine=self.generic,
-                         libraries=[self.lib_m])
-        assert lib.sin(12.3) == math.sin(12.3)
-        v = ffi.verifier
-        ext = v.get_extension()
-        assert 'distutils.extension.Extension' in str(ext.__class__) or \
-               'setuptools.extension.Extension' in str(ext.__class__)
-        assert ext.sources == [maybe_relative_path(v.sourcefilename)]
-        assert ext.name == v.get_module_name()
-        assert ext.define_macros == [('TEST_EXTENSION_OBJECT', '1')]
-
-    def test_extension_forces_write_source(self):
-        ffi = FFI()
-        ffi.cdef("double sin(double x);")
-        csrc = '/*hi there9!%s*/\n#include <math.h>\n' % self
-        v = Verifier(ffi, csrc, force_generic_engine=self.generic,
-                     libraries=[self.lib_m])
-        assert not os.path.exists(v.sourcefilename)
-        v.get_extension()
-        assert os.path.exists(v.sourcefilename)
-
-    def test_extension_object_extra_sources(self):
-        ffi = FFI()
-        ffi.cdef("double test1eoes(double x);")
-        extra_source = str(udir.join('extension_extra_sources.c'))
-        with open(extra_source, 'w') as f:
-            f.write('double test1eoes(double x) { return x * 6.0; }\n')
-        csrc = '/*9%s*/' % self + '''
-        double test1eoes(double x);   /* or #include "extra_sources.h" */
-        '''
-        lib = ffi.verify(csrc, sources=[extra_source],
-                         force_generic_engine=self.generic)
-        assert lib.test1eoes(7.0) == 42.0
-        v = ffi.verifier
-        ext = v.get_extension()
-        assert 'distutils.extension.Extension' in str(ext.__class__) or \
-               'setuptools.extension.Extension' in str(ext.__class__)
-        assert ext.sources == [maybe_relative_path(v.sourcefilename),
-                               extra_source]
-        assert ext.name == v.get_module_name()
-
-    def test_install_and_reload_module(self, targetpackage='', ext_package=''):
-        KEY = repr(self)
-        if not hasattr(os, 'fork'):
-            py.test.skip("test requires os.fork()")
-
-        if targetpackage:
-            udir.ensure(targetpackage, dir=1).ensure('__init__.py')
-        sys.path.insert(0, str(udir))
-
-        def make_ffi(**verifier_args):
-            ffi = FFI()
-            ffi.cdef("/* %s, %s, %s */" % (KEY, targetpackage, ext_package))
-            ffi.cdef("double test1iarm(double x);")
-            csrc = "double test1iarm(double x) { return x * 42.0; }"
-            lib = ffi.verify(csrc, force_generic_engine=self.generic,
-                             ext_package=ext_package,
-                             **verifier_args)
-            return ffi, lib
-
-        childpid = os.fork()
-        if childpid == 0:
-            # in the child
-            ffi, lib = make_ffi()
-            assert lib.test1iarm(1.5) == 63.0
-            # "install" the module by moving it into udir (/targetpackage)
-            if targetpackage:
-                target = udir.join(targetpackage)
-            else:
-                target = udir
-            shutil.move(ffi.verifier.modulefilename, str(target))
-            os._exit(0)
-        # in the parent
-        _, status = os.waitpid(childpid, 0)
-        if not (os.WIFEXITED(status) and os.WEXITSTATUS(status) == 0):
-            raise AssertionError   # see error above in subprocess
-
-        from cffi import ffiplatform
-        prev_compile = ffiplatform.compile
-        try:
-            if targetpackage == ext_package:
-                ffiplatform.compile = lambda *args: dont_call_me_any_more
-            # won't find it in tmpdir, but should find it correctly
-            # installed in udir
-            ffi, lib = make_ffi()
-            assert lib.test1iarm(0.5) == 21.0
-        finally:
-            ffiplatform.compile = prev_compile
-
-    def test_install_and_reload_module_package(self):
-        self.test_install_and_reload_module(targetpackage='foo_iarmp',
-                                            ext_package='foo_iarmp')
-
-    def test_install_and_reload_module_ext_package_not_found(self):
-        self.test_install_and_reload_module(targetpackage='foo_epnf',
-                                            ext_package='not_found')
-
-    def test_tag(self):
-        ffi = FFI()
-        ffi.cdef("/* %s test_tag */ double test1tag(double x);" % self)
-        csrc = "double test1tag(double x) { return x - 42.0; }"
-        lib = ffi.verify(csrc, force_generic_engine=self.generic,
-                         tag='xxtest_tagxx')
-        assert lib.test1tag(143) == 101.0
-        assert '_cffi_xxtest_tagxx_' in ffi.verifier.modulefilename
-
-    def test_modulename(self):
-        ffi = FFI()
-        ffi.cdef("/* %s test_modulename */ double test1foo(double x);" % self)
-        csrc = "double test1foo(double x) { return x - 63.0; }"
-        modname = 'xxtest_modulenamexx%d' % (self.generic,)
-        lib = ffi.verify(csrc, force_generic_engine=self.generic,
-                         modulename=modname)
-        assert lib.test1foo(143) == 80.0
-        suffix = _get_so_suffixes()[0]
-        fn1 = os.path.join(ffi.verifier.tmpdir, modname + '.c')
-        fn2 = os.path.join(ffi.verifier.tmpdir, modname + suffix)
-        assert ffi.verifier.sourcefilename == fn1
-        assert ffi.verifier.modulefilename == fn2
-
-
-class TestDistUtilsCPython(DistUtilsTest):
-    generic = False
-
-class TestDistUtilsGeneric(DistUtilsTest):
-    generic = True

+ 0 - 145
desktop/core/ext-py/cffi-1.3.1/testing/cffi0/test_zintegration.py

@@ -1,145 +0,0 @@
-import py, os, sys, shutil
-import subprocess
-from testing.udir import udir
-
-if sys.platform == 'win32':
-    py.test.skip('snippets do not run on win32')
-
-def create_venv(name):
-    tmpdir = udir.join(name)
-    try:
-        subprocess.check_call(['virtualenv', '--distribute',
-                               '-p', os.path.abspath(sys.executable),
-                               str(tmpdir)])
-    except OSError as e:
-        py.test.skip("Cannot execute virtualenv: %s" % (e,))
-
-    site_packages = None
-    for dirpath, dirnames, filenames in os.walk(str(tmpdir)):
-        if os.path.basename(dirpath) == 'site-packages':
-            site_packages = dirpath
-            break
-    paths = ""
-    if site_packages:
-        try:
-            from cffi import _pycparser
-            modules = ('cffi', '_cffi_backend')
-        except ImportError:
-            modules = ('cffi', '_cffi_backend', 'pycparser')
-            try:
-                import ply
-            except ImportError:
-                pass
-            else:
-                modules += ('ply',)   # needed for older versions of pycparser
-        paths = []
-        for module in modules:
-            target = __import__(module, None, None, [])
-            if not hasattr(target, '__file__'):   # for _cffi_backend on pypy
-                continue
-            src = os.path.abspath(target.__file__)
-            for end in ['__init__.pyc', '__init__.pyo', '__init__.py']:
-                if src.lower().endswith(end):
-                    src = src[:-len(end)-1]
-                    break
-            paths.append(os.path.dirname(src))
-        paths = os.pathsep.join(paths)
-    return tmpdir, paths
-
-SNIPPET_DIR = py.path.local(__file__).join('..', 'snippets')
-
-def really_run_setup_and_program(dirname, venv_dir_and_paths, python_snippet):
-    venv_dir, paths = venv_dir_and_paths
-    def remove(dir):
-        dir = str(SNIPPET_DIR.join(dirname, dir))
-        shutil.rmtree(dir, ignore_errors=True)
-    remove('build')
-    remove('__pycache__')
-    for basedir in os.listdir(str(SNIPPET_DIR.join(dirname))):
-        remove(os.path.join(basedir, '__pycache__'))
-    olddir = os.getcwd()
-    python_f = udir.join('x.py')
-    python_f.write(py.code.Source(python_snippet))
-    try:
-        os.chdir(str(SNIPPET_DIR.join(dirname)))
-        if os.name == 'nt':
-            bindir = 'Scripts'
-        else:
-            bindir = 'bin'
-        vp = str(venv_dir.join(bindir).join('python'))
-        env = os.environ.copy()
-        env['PYTHONPATH'] = paths
-        subprocess.check_call((vp, 'setup.py', 'clean'), env=env)
-        subprocess.check_call((vp, 'setup.py', 'install'), env=env)
-        subprocess.check_call((vp, str(python_f)), env=env)
-    finally:
-        os.chdir(olddir)
-
-def run_setup_and_program(dirname, python_snippet):
-    venv_dir = create_venv(dirname + '-cpy')
-    really_run_setup_and_program(dirname, venv_dir, python_snippet)
-    #
-    sys._force_generic_engine_ = True
-    try:
-        venv_dir = create_venv(dirname + '-gen')
-        really_run_setup_and_program(dirname, venv_dir, python_snippet)
-    finally:
-        del sys._force_generic_engine_
-    # the two files lextab.py and yacctab.py are created by not-correctly-
-    # installed versions of pycparser.
-    assert not os.path.exists(str(SNIPPET_DIR.join(dirname, 'lextab.py')))
-    assert not os.path.exists(str(SNIPPET_DIR.join(dirname, 'yacctab.py')))
-
-class TestZIntegration(object):
-    def teardown_class(self):
-        if udir.isdir():
-            udir.remove(ignore_errors=True)
-        udir.ensure(dir=1)
-
-    def test_infrastructure(self):
-        run_setup_and_program('infrastructure', '''
-        import snip_infrastructure
-        assert snip_infrastructure.func() == 42
-        ''')
-
-    def test_distutils_module(self):
-        run_setup_and_program("distutils_module", '''
-        import snip_basic_verify
-        p = snip_basic_verify.C.getpwuid(0)
-        assert snip_basic_verify.ffi.string(p.pw_name) == b"root"
-        ''')
-
-    def test_distutils_package_1(self):
-        run_setup_and_program("distutils_package_1", '''
-        import snip_basic_verify1
-        p = snip_basic_verify1.C.getpwuid(0)
-        assert snip_basic_verify1.ffi.string(p.pw_name) == b"root"
-        ''')
-
-    def test_distutils_package_2(self):
-        run_setup_and_program("distutils_package_2", '''
-        import snip_basic_verify2
-        p = snip_basic_verify2.C.getpwuid(0)
-        assert snip_basic_verify2.ffi.string(p.pw_name) == b"root"
-        ''')
-
-    def test_setuptools_module(self):
-        run_setup_and_program("setuptools_module", '''
-        import snip_setuptools_verify
-        p = snip_setuptools_verify.C.getpwuid(0)
-        assert snip_setuptools_verify.ffi.string(p.pw_name) == b"root"
-        ''')
-
-    def test_setuptools_package_1(self):
-        run_setup_and_program("setuptools_package_1", '''
-        import snip_setuptools_verify1
-        p = snip_setuptools_verify1.C.getpwuid(0)
-        assert snip_setuptools_verify1.ffi.string(p.pw_name) == b"root"
-        ''')
-
-    def test_setuptools_package_2(self):
-        run_setup_and_program("setuptools_package_2", '''
-        import snip_setuptools_verify2
-        p = snip_setuptools_verify2.C.getpwuid(0)
-        assert snip_setuptools_verify2.ffi.string(p.pw_name) == b"root"
-        ''')

+ 0 - 20
desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_cffi_binary.py

@@ -1,20 +0,0 @@
-import py, sys, os
-import _cffi_backend
-
-def test_no_unknown_exported_symbols():
-    if not hasattr(_cffi_backend, '__file__'):
-        py.test.skip("_cffi_backend module is built-in")
-    if not sys.platform.startswith('linux'):
-        py.test.skip("linux-only")
-    g = os.popen("objdump -T '%s'" % _cffi_backend.__file__, 'r')
-    for line in g:
-        if not line.startswith('0'):
-            continue
-        if '*UND*' in line:
-            continue
-        name = line.split()[-1]
-        if name.startswith('_') or name.startswith('.'):
-            continue
-        if name not in ('init_cffi_backend', 'PyInit__cffi_backend'):
-            raise Exception("Unexpected exported name %r" % (name,))
-    g.close()

+ 0 - 34
desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_commontypes.py

@@ -1,34 +0,0 @@
-import py, os, cffi, re
-import _cffi_backend
-
-
-def getlines():
-    try:
-        f = open(os.path.join(os.path.dirname(cffi.__file__),
-                              '..', 'c', 'commontypes.c'))
-    except IOError:
-        py.test.skip("cannot find ../c/commontypes.c")
-    lines = [line for line in f.readlines() if line.strip().startswith('EQ(')]
-    f.close()
-    return lines
-
-def test_alphabetical_order():
-    lines = getlines()
-    assert lines == sorted(lines)
-
-def test_dependencies():
-    r = re.compile(r'EQ[(]"([^"]+)",(?:\s*"([A-Z0-9_]+)\s*[*]*"[)])?')
-    lines = getlines()
-    d = {}
-    for line in lines:
-        match = r.search(line)
-        if match is not None:
-            d[match.group(1)] = match.group(2)
-    for value in d.values():
-        if value:
-            assert value in d
-
-def test_get_common_types():
-    d = {}
-    _cffi_backend._get_common_types(d)
-    assert d["bool"] == "_Bool"

+ 0 - 225
desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_dlopen.py

@@ -1,225 +0,0 @@
-import py
-from cffi import FFI, VerificationError, CDefError
-from cffi.recompiler import make_py_source
-from testing.udir import udir
-
-
-def test_simple():
-    ffi = FFI()
-    ffi.cdef("int close(int); static const int BB = 42; int somevar;")
-    target = udir.join('test_simple.py')
-    make_py_source(ffi, 'test_simple', str(target))
-    assert target.read() == r"""# auto-generated file
-import _cffi_backend
-
-ffi = _cffi_backend.FFI('test_simple',
-    _version = 0x2601,
-    _types = b'\x00\x00\x01\x0D\x00\x00\x07\x01\x00\x00\x00\x0F',
-    _globals = (b'\xFF\xFF\xFF\x1FBB',42,b'\x00\x00\x00\x23close',0,b'\x00\x00\x01\x21somevar',0),
-)
-"""
-
-def test_global_constant():
-    ffi = FFI()
-    ffi.cdef("static const long BB; static const float BF = 12;")
-    target = udir.join('test_valid_global_constant.py')
-    make_py_source(ffi, 'test_valid_global_constant', str(target))
-    assert target.read() == r"""# auto-generated file
-import _cffi_backend
-
-ffi = _cffi_backend.FFI('test_valid_global_constant',
-    _version = 0x2601,
-    _types = b'\x00\x00\x0D\x01\x00\x00\x09\x01',
-    _globals = (b'\x00\x00\x01\x25BB',0,b'\x00\x00\x00\x25BF',0),
-)
-"""
-
-def test_invalid_global_constant_3():
-    ffi = FFI()
-    e = py.test.raises(CDefError, ffi.cdef, "#define BB 12.34")
-    assert str(e.value).startswith(
-        "only supports one of the following syntax:")
-
-def test_invalid_dotdotdot_in_macro():
-    ffi = FFI()
-    ffi.cdef("#define FOO ...")
-    target = udir.join('test_invalid_dotdotdot_in_macro.py')
-    e = py.test.raises(VerificationError, make_py_source, ffi,
-                       'test_invalid_dotdotdot_in_macro', str(target))
-    assert str(e.value) == ("macro FOO: cannot use the syntax '...' in "
-                            "'#define FOO ...' when using the ABI mode")
-
-def test_typename():
-    ffi = FFI()
-    ffi.cdef("typedef int foobar_t;")
-    target = udir.join('test_typename.py')
-    make_py_source(ffi, 'test_typename', str(target))
-    assert target.read() == r"""# auto-generated file
-import _cffi_backend
-
-ffi = _cffi_backend.FFI('test_typename',
-    _version = 0x2601,
-    _types = b'\x00\x00\x07\x01',
-    _typenames = (b'\x00\x00\x00\x00foobar_t',),
-)
-"""
-
-def test_enum():
-    ffi = FFI()
-    ffi.cdef("enum myenum_e { AA, BB, CC=-42 };")
-    target = udir.join('test_enum.py')
-    make_py_source(ffi, 'test_enum', str(target))
-    assert target.read() == r"""# auto-generated file
-import _cffi_backend
-
-ffi = _cffi_backend.FFI('test_enum',
-    _version = 0x2601,
-    _types = b'\x00\x00\x00\x0B',
-    _globals = (b'\xFF\xFF\xFF\x0BAA',0,b'\xFF\xFF\xFF\x0BBB',1,b'\xFF\xFF\xFF\x0BCC',-42),
-    _enums = (b'\x00\x00\x00\x00\x00\x00\x00\x15myenum_e\x00AA,BB,CC',),
-)
-"""
-
-def test_struct():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int a; signed char b[]; }; struct bar_s;")
-    target = udir.join('test_struct.py')
-    make_py_source(ffi, 'test_struct', str(target))
-    assert target.read() == r"""# auto-generated file
-import _cffi_backend
-
-ffi = _cffi_backend.FFI('test_struct',
-    _version = 0x2601,
-    _types = b'\x00\x00\x07\x01\x00\x00\x03\x01\x00\x00\x01\x07\x00\x00\x00\x09\x00\x00\x01\x09',
-    _struct_unions = ((b'\x00\x00\x00\x03\x00\x00\x00\x10bar_s',),(b'\x00\x00\x00\x04\x00\x00\x00\x02foo_s',b'\x00\x00\x00\x11a',b'\x00\x00\x02\x11b')),
-)
-"""
-
-def test_include():
-    ffi = FFI()
-    ffi.cdef("#define ABC 123")
-    ffi.set_source('test_include', None)
-    target = udir.join('test_include.py')
-    make_py_source(ffi, 'test_include', str(target))
-    assert target.read() == r"""# auto-generated file
-import _cffi_backend
-
-ffi = _cffi_backend.FFI('test_include',
-    _version = 0x2601,
-    _types = b'',
-    _globals = (b'\xFF\xFF\xFF\x1FABC',123,),
-)
-"""
-    #
-    ffi2 = FFI()
-    ffi2.include(ffi)
-    target2 = udir.join('test2_include.py')
-    make_py_source(ffi2, 'test2_include', str(target2))
-    assert target2.read() == r"""# auto-generated file
-import _cffi_backend
-from test_include import ffi as _ffi0
-
-ffi = _cffi_backend.FFI('test2_include',
-    _version = 0x2601,
-    _types = b'',
-    _includes = (_ffi0,),
-)
-"""
-
-def test_negative_constant():
-    ffi = FFI()
-    ffi.cdef("static const int BB = -42;")
-    target = udir.join('test_negative_constant.py')
-    make_py_source(ffi, 'test_negative_constant', str(target))
-    assert target.read() == r"""# auto-generated file
-import _cffi_backend
-
-ffi = _cffi_backend.FFI('test_negative_constant',
-    _version = 0x2601,
-    _types = b'',
-    _globals = (b'\xFF\xFF\xFF\x1FBB',-42,),
-)
-"""
-
-def test_struct_included():
-    baseffi = FFI()
-    baseffi.cdef("struct foo_s { int x; };")
-    baseffi.set_source('test_struct_included_base', None)
-    #
-    ffi = FFI()
-    ffi.include(baseffi)
-    target = udir.join('test_struct_included.py')
-    make_py_source(ffi, 'test_struct_included', str(target))
-    assert target.read() == r"""# auto-generated file
-import _cffi_backend
-from test_struct_included_base import ffi as _ffi0
-
-ffi = _cffi_backend.FFI('test_struct_included',
-    _version = 0x2601,
-    _types = b'\x00\x00\x00\x09',
-    _struct_unions = ((b'\x00\x00\x00\x00\x00\x00\x00\x08foo_s',),),
-    _includes = (_ffi0,),
-)
-"""
-
-def test_no_cross_include():
-    baseffi = FFI()
-    baseffi.set_source('test_no_cross_include_base', "..source..")
-    #
-    ffi = FFI()
-    ffi.include(baseffi)
-    target = udir.join('test_no_cross_include.py')
-    py.test.raises(VerificationError, make_py_source,
-                   ffi, 'test_no_cross_include', str(target))
-
-def test_array():
-    ffi = FFI()
-    ffi.cdef("typedef int32_t my_array_t[42];")
-    target = udir.join('test_array.py')
-    make_py_source(ffi, 'test_array', str(target))
-    assert target.read() == r"""# auto-generated file
-import _cffi_backend
-
-ffi = _cffi_backend.FFI('test_array',
-    _version = 0x2601,
-    _types = b'\x00\x00\x15\x01\x00\x00\x00\x05\x00\x00\x00\x2A',
-    _typenames = (b'\x00\x00\x00\x01my_array_t',),
-)
-"""
-
-def test_array_overflow():
-    ffi = FFI()
-    ffi.cdef("typedef int32_t my_array_t[3000000000];")
-    target = udir.join('test_array_overflow.py')
-    py.test.raises(OverflowError, make_py_source,
-                   ffi, 'test_array_overflow', str(target))
-
-def test_global_var():
-    ffi = FFI()
-    ffi.cdef("int myglob;")
-    target = udir.join('test_global_var.py')
-    make_py_source(ffi, 'test_global_var', str(target))
-    assert target.read() == r"""# auto-generated file
-import _cffi_backend
-
-ffi = _cffi_backend.FFI('test_global_var',
-    _version = 0x2601,
-    _types = b'\x00\x00\x07\x01',
-    _globals = (b'\x00\x00\x00\x21myglob',0,),
-)
-"""
-
-def test_bitfield():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int y:10; short x:5; };")
-    target = udir.join('test_bitfield.py')
-    make_py_source(ffi, 'test_bitfield', str(target))
-    assert target.read() == r"""# auto-generated file
-import _cffi_backend
-
-ffi = _cffi_backend.FFI('test_bitfield',
-    _version = 0x2601,
-    _types = b'\x00\x00\x07\x01\x00\x00\x05\x01\x00\x00\x00\x09',
-    _struct_unions = ((b'\x00\x00\x00\x02\x00\x00\x00\x02foo_s',b'\x00\x00\x00\x13\x00\x00\x00\x0Ay',b'\x00\x00\x01\x13\x00\x00\x00\x05x'),),
-)
-"""

+ 0 - 9
desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_dlopen_unicode_literals.py

@@ -1,9 +0,0 @@
-import py, os
-
-s = """from __future__ import unicode_literals
-"""
-
-with open(os.path.join(os.path.dirname(__file__), 'test_dlopen.py')) as f:
-    s += f.read()
-
-exec(py.code.compile(s))

+ 0 - 417
desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_ffi_obj.py

@@ -1,417 +0,0 @@
-import py, sys
-import _cffi_backend as _cffi1_backend
-
-
-def test_ffi_new():
-    ffi = _cffi1_backend.FFI()
-    p = ffi.new("int *")
-    p[0] = -42
-    assert p[0] == -42
-
-def test_ffi_subclass():
-    class FOO(_cffi1_backend.FFI):
-        def __init__(self, x):
-            self.x = x
-    foo = FOO(42)
-    assert foo.x == 42
-    p = foo.new("int *")
-    assert p[0] == 0
-
-def test_ffi_no_argument():
-    py.test.raises(TypeError, _cffi1_backend.FFI, 42)
-
-def test_ffi_cache_type():
-    ffi = _cffi1_backend.FFI()
-    t1 = ffi.typeof("int **")
-    t2 = ffi.typeof("int *")
-    assert t2.item is t1.item.item
-    assert t2 is t1.item
-    assert ffi.typeof("int[][10]") is ffi.typeof("int[][10]")
-    assert ffi.typeof("int(*)()") is ffi.typeof("int(*)()")
-
-def test_ffi_type_not_immortal():
-    import weakref, gc
-    ffi = _cffi1_backend.FFI()
-    t1 = ffi.typeof("int **")
-    t2 = ffi.typeof("int *")
-    w1 = weakref.ref(t1)
-    w2 = weakref.ref(t2)
-    del t1, ffi
-    gc.collect()
-    assert w1() is None
-    assert w2() is t2
-    ffi = _cffi1_backend.FFI()
-    assert ffi.typeof(ffi.new("int **")[0]) is t2
-    #
-    ffi = _cffi1_backend.FFI()
-    t1 = ffi.typeof("int ***")
-    t2 = ffi.typeof("int **")
-    w1 = weakref.ref(t1)
-    w2 = weakref.ref(t2)
-    del t2, ffi
-    gc.collect()
-    assert w1() is t1
-    assert w2() is not None   # kept alive by t1
-    ffi = _cffi1_backend.FFI()
-    assert ffi.typeof("int * *") is t1.item
-
-def test_ffi_cache_type_globally():
-    ffi1 = _cffi1_backend.FFI()
-    ffi2 = _cffi1_backend.FFI()
-    t1 = ffi1.typeof("int *")
-    t2 = ffi2.typeof("int *")
-    assert t1 is t2
-
-def test_ffi_invalid():
-    ffi = _cffi1_backend.FFI()
-    # array of 10 times an "int[]" is invalid
-    py.test.raises(ValueError, ffi.typeof, "int[10][]")
-
-def test_ffi_docstrings():
-    # check that all methods of the FFI class have a docstring.
-    check_type = type(_cffi1_backend.FFI.new)
-    for methname in dir(_cffi1_backend.FFI):
-        if not methname.startswith('_'):
-            method = getattr(_cffi1_backend.FFI, methname)
-            if isinstance(method, check_type):
-                assert method.__doc__, "method FFI.%s() has no docstring" % (
-                    methname,)
-
-def test_ffi_NULL():
-    NULL = _cffi1_backend.FFI.NULL
-    assert _cffi1_backend.FFI().typeof(NULL).cname == "void *"
-
-def test_ffi_no_attr():
-    ffi = _cffi1_backend.FFI()
-    py.test.raises(AttributeError, "ffi.no_such_name")
-    py.test.raises(AttributeError, "ffi.no_such_name = 42")
-    py.test.raises(AttributeError, "del ffi.no_such_name")
-
-def test_ffi_string():
-    ffi = _cffi1_backend.FFI()
-    p = ffi.new("char[]", init=b"foobar\x00baz")
-    assert ffi.string(p) == b"foobar"
-    assert ffi.string(cdata=p, maxlen=3) == b"foo"
-
-def test_ffi_errno():
-    # xxx not really checking errno, just checking that we can read/write it
-    ffi = _cffi1_backend.FFI()
-    ffi.errno = 42
-    assert ffi.errno == 42
-
-def test_ffi_alignof():
-    ffi = _cffi1_backend.FFI()
-    assert ffi.alignof("int") == 4
-    assert ffi.alignof("int[]") == 4
-    assert ffi.alignof("int[41]") == 4
-    assert ffi.alignof("short[41]") == 2
-    assert ffi.alignof(ffi.new("int[41]")) == 4
-    assert ffi.alignof(ffi.new("int[]", 41)) == 4
-
-def test_ffi_sizeof():
-    ffi = _cffi1_backend.FFI()
-    assert ffi.sizeof("int") == 4
-    py.test.raises(ffi.error, ffi.sizeof, "int[]")
-    assert ffi.sizeof("int[41]") == 41 * 4
-    assert ffi.sizeof(ffi.new("int[41]")) == 41 * 4
-    assert ffi.sizeof(ffi.new("int[]", 41)) == 41 * 4
-
-def test_ffi_callback():
-    ffi = _cffi1_backend.FFI()
-    assert ffi.callback("int(int)", lambda x: x + 42)(10) == 52
-    assert ffi.callback("int(*)(int)", lambda x: x + 42)(10) == 52
-    assert ffi.callback("int(int)", lambda x: x + "", -66)(10) == -66
-    assert ffi.callback("int(int)", lambda x: x + "", error=-66)(10) == -66
-
-def test_ffi_callback_decorator():
-    ffi = _cffi1_backend.FFI()
-    assert ffi.callback(ffi.typeof("int(*)(int)"))(lambda x: x + 42)(10) == 52
-    deco = ffi.callback("int(int)", error=-66)
-    assert deco(lambda x: x + "")(10) == -66
-    assert deco(lambda x: x + 42)(10) == 52
-
-def test_ffi_callback_onerror():
-    ffi = _cffi1_backend.FFI()
-    seen = []
-    def oops(*args):
-        seen.append(args)
-
-    @ffi.callback("int(int)", onerror=oops)
-    def fn1(x):
-        return x + ""
-    assert fn1(10) == 0
-
-    @ffi.callback("int(int)", onerror=oops, error=-66)
-    def fn2(x):
-        return x + ""
-    assert fn2(10) == -66
-
-    assert len(seen) == 2
-    exc, val, tb = seen[0]
-    assert exc is TypeError
-    assert isinstance(val, TypeError)
-    assert tb.tb_frame.f_code.co_name == "fn1"
-    exc, val, tb = seen[1]
-    assert exc is TypeError
-    assert isinstance(val, TypeError)
-    assert tb.tb_frame.f_code.co_name == "fn2"
-    #
-    py.test.raises(TypeError, ffi.callback, "int(int)",
-                   lambda x: x, onerror=42)   # <- not callable
-
-def test_ffi_getctype():
-    ffi = _cffi1_backend.FFI()
-    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", replace_with=' * 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_addressof():
-    ffi = _cffi1_backend.FFI()
-    a = ffi.new("int[10]")
-    b = ffi.addressof(a, 5)
-    b[2] = -123
-    assert a[7] == -123
-
-def test_handle():
-    ffi = _cffi1_backend.FFI()
-    x = [2, 4, 6]
-    xp = ffi.new_handle(x)
-    assert ffi.typeof(xp) == ffi.typeof("void *")
-    assert ffi.from_handle(xp) is x
-    yp = ffi.new_handle([6, 4, 2])
-    assert ffi.from_handle(yp) == [6, 4, 2]
-
-def test_ffi_cast():
-    ffi = _cffi1_backend.FFI()
-    assert ffi.cast("int(*)(int)", 0) == ffi.NULL
-    ffi.callback("int(int)")      # side-effect of registering this string
-    py.test.raises(ffi.error, ffi.cast, "int(int)", 0)
-
-def test_ffi_invalid_type():
-    ffi = _cffi1_backend.FFI()
-    e = py.test.raises(ffi.error, ffi.cast, "", 0)
-    assert str(e.value) == ("identifier expected\n"
-                            "\n"
-                            "^")
-    e = py.test.raises(ffi.error, ffi.cast, "struct struct", 0)
-    assert str(e.value) == ("struct or union name expected\n"
-                            "struct struct\n"
-                            "       ^")
-    e = py.test.raises(ffi.error, ffi.cast, "struct never_heard_of_s", 0)
-    assert str(e.value) == ("undefined struct/union name\n"
-                            "struct never_heard_of_s\n"
-                            "       ^")
-    e = py.test.raises(ffi.error, ffi.cast, "\t\n\x01\x1f~\x7f\x80\xff", 0)
-    marks = "?" if sys.version_info < (3,) else "??"
-    assert str(e.value) == ("identifier expected\n"
-                            "  ??~?%s%s\n"
-                            "  ^" % (marks, marks))
-    e = py.test.raises(ffi.error, ffi.cast, "X" * 600, 0)
-    assert str(e.value) == ("undefined type name")
-
-def test_ffi_buffer():
-    ffi = _cffi1_backend.FFI()
-    a = ffi.new("signed char[]", [5, 6, 7])
-    assert ffi.buffer(a)[:] == b'\x05\x06\x07'
-    assert ffi.buffer(cdata=a, size=2)[:] == b'\x05\x06'
-
-def test_ffi_from_buffer():
-    import array
-    ffi = _cffi1_backend.FFI()
-    a = array.array('H', [10000, 20000, 30000])
-    c = ffi.from_buffer(a)
-    assert ffi.typeof(c) is ffi.typeof("char[]")
-    ffi.cast("unsigned short *", c)[1] += 500
-    assert list(a) == [10000, 20500, 30000]
-
-def test_memmove():
-    ffi = _cffi1_backend.FFI()
-    p = ffi.new("short[]", [-1234, -2345, -3456, -4567, -5678])
-    ffi.memmove(p, p + 1, 4)
-    assert list(p) == [-2345, -3456, -3456, -4567, -5678]
-    p[2] = 999
-    ffi.memmove(p + 2, p, 6)
-    assert list(p) == [-2345, -3456, -2345, -3456, 999]
-    ffi.memmove(p + 4, ffi.new("char[]", 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
-    ffi = _cffi1_backend.FFI()
-    a = array.array('H', [10000, 20000, 30000])
-    p = ffi.new("short[]", 5)
-    ffi.memmove(p, a, 6)
-    assert list(p) == [10000, 20000, 30000, 0, 0]
-    ffi.memmove(p + 1, a, 6)
-    assert list(p) == [10000, 10000, 20000, 30000, 0]
-    b = array.array('h', [-1000, -2000, -3000])
-    ffi.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
-    ffi.memmove(b, p, 2)
-    assert b.tolist() == [999, 20000, -3000]
-    ffi.memmove(b, p + 2, 4)
-    assert b.tolist() == [997, 996, -3000]
-    p[2] = -p[2]
-    p[3] = -p[3]
-    ffi.memmove(b, p + 2, 6)
-    assert b.tolist() == [-997, -996, 995]
-
-def test_memmove_readonly_readwrite():
-    ffi = _cffi1_backend.FFI()
-    p = ffi.new("signed char[]", 5)
-    ffi.memmove(p, b"abcde", 3)
-    assert list(p) == [ord("a"), ord("b"), ord("c"), 0, 0]
-    ffi.memmove(p, bytearray(b"ABCDE"), 2)
-    assert list(p) == [ord("A"), ord("B"), ord("c"), 0, 0]
-    py.test.raises((TypeError, BufferError), ffi.memmove, b"abcde", p, 3)
-    ba = bytearray(b"xxxxx")
-    ffi.memmove(dest=ba, src=p, n=3)
-    assert ba == bytearray(b"ABcxx")
-
-def test_ffi_types():
-    CData = _cffi1_backend.FFI.CData
-    CType = _cffi1_backend.FFI.CType
-    ffi = _cffi1_backend.FFI()
-    assert isinstance(ffi.cast("int", 42), CData)
-    assert isinstance(ffi.typeof("int"), CType)
-
-def test_ffi_getwinerror():
-    if sys.platform != "win32":
-        py.test.skip("for windows")
-    ffi = _cffi1_backend.FFI()
-    n = (1 << 29) + 42
-    code, message = ffi.getwinerror(code=n)
-    assert code == n
-
-def test_ffi_new_allocator_1():
-    ffi = _cffi1_backend.FFI()
-    alloc1 = ffi.new_allocator()
-    alloc2 = ffi.new_allocator(should_clear_after_alloc=False)
-    for retry in range(100):
-        p1 = alloc1("int[10]")
-        p2 = alloc2("int[10]")
-        combination = 0
-        for i in range(10):
-            assert p1[i] == 0
-            combination |= p2[i]
-            p1[i] = -42
-            p2[i] = -43
-        if combination != 0:
-            break
-        del p1, p2
-        import gc; gc.collect()
-    else:
-        raise AssertionError("cannot seem to get an int[10] not "
-                             "completely cleared")
-
-def test_ffi_new_allocator_2():
-    ffi = _cffi1_backend.FFI()
-    seen = []
-    def myalloc(size):
-        seen.append(size)
-        return ffi.new("char[]", b"X" * size)
-    def myfree(raw):
-        seen.append(raw)
-    alloc1 = ffi.new_allocator(myalloc, myfree)
-    alloc2 = ffi.new_allocator(alloc=myalloc, free=myfree,
-                               should_clear_after_alloc=False)
-    p1 = alloc1("int[10]")
-    p2 = alloc2("int[]", 10)
-    assert seen == [40, 40]
-    assert ffi.typeof(p1) == ffi.typeof("int[10]")
-    assert ffi.sizeof(p1) == 40
-    assert ffi.typeof(p2) == ffi.typeof("int[]")
-    assert ffi.sizeof(p2) == 40
-    assert p1[5] == 0
-    assert p2[6] == ord('X') * 0x01010101
-    raw1 = ffi.cast("char *", p1)
-    raw2 = ffi.cast("char *", p2)
-    del p1, p2
-    retries = 0
-    while len(seen) != 4:
-        retries += 1
-        assert retries <= 5
-        import gc; gc.collect()
-    assert seen == [40, 40, raw1, raw2]
-    assert repr(seen[2]) == "<cdata 'char[]' owning 41 bytes>"
-    assert repr(seen[3]) == "<cdata 'char[]' owning 41 bytes>"
-
-def test_ffi_new_allocator_3():
-    ffi = _cffi1_backend.FFI()
-    seen = []
-    def myalloc(size):
-        seen.append(size)
-        return ffi.new("char[]", b"X" * size)
-    alloc1 = ffi.new_allocator(myalloc)    # no 'free'
-    p1 = alloc1("int[10]")
-    assert seen == [40]
-    assert ffi.typeof(p1) == ffi.typeof("int[10]")
-    assert ffi.sizeof(p1) == 40
-    assert p1[5] == 0
-
-def test_ffi_new_allocator_4():
-    ffi = _cffi1_backend.FFI()
-    py.test.raises(TypeError, ffi.new_allocator, free=lambda x: None)
-    #
-    def myalloc2(size):
-        raise LookupError
-    alloc2 = ffi.new_allocator(myalloc2)
-    py.test.raises(LookupError, alloc2, "int[5]")
-    #
-    def myalloc3(size):
-        return 42
-    alloc3 = ffi.new_allocator(myalloc3)
-    e = py.test.raises(TypeError, alloc3, "int[5]")
-    assert str(e.value) == "alloc() must return a cdata object (got int)"
-    #
-    def myalloc4(size):
-        return ffi.cast("int", 42)
-    alloc4 = ffi.new_allocator(myalloc4)
-    e = py.test.raises(TypeError, alloc4, "int[5]")
-    assert str(e.value) == "alloc() must return a cdata pointer, not 'int'"
-    #
-    def myalloc5(size):
-        return ffi.NULL
-    alloc5 = ffi.new_allocator(myalloc5)
-    py.test.raises(MemoryError, alloc5, "int[5]")
-
-def test_bool_issue228():
-    ffi = _cffi1_backend.FFI()
-    fntype = ffi.typeof("int(*callback)(bool is_valid)")
-    assert repr(fntype.args[0]) == "<ctype '_Bool'>"
-
-def test_FILE_issue228():
-    fntype1 = _cffi1_backend.FFI().typeof("FILE *")
-    fntype2 = _cffi1_backend.FFI().typeof("FILE *")
-    assert repr(fntype1) == "<ctype 'FILE *'>"
-    assert fntype1 is fntype2
-
-def test_cast_from_int_type_to_bool():
-    ffi = _cffi1_backend.FFI()
-    for basetype in ['char', 'short', 'int', 'long', 'long long']:
-        for sign in ['signed', 'unsigned']:
-            type = '%s %s' % (sign, basetype)
-            assert int(ffi.cast("_Bool", ffi.cast(type, 42))) == 1
-            assert int(ffi.cast("bool", ffi.cast(type, 42))) == 1
-            assert int(ffi.cast("_Bool", ffi.cast(type, 0))) == 0

+ 0 - 1720
desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_new_ffi_1.py

@@ -1,1720 +0,0 @@
-import py
-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       # no __eq__(int)
-        assert bool(p) is True
-        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)   # unlikely
-        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
-        py.test.raises(IndexError, "p[10]")
-        py.test.raises(IndexError, "p[10] = 44")
-        py.test.raises(IndexError, "p[-1]")
-        py.test.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
-        py.test.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
-        py.test.raises(IndexError, "p[2]")
-        assert repr(p) == "<cdata 'int[]' owning %d bytes>" % (2*SIZE_OF_INT)
-        #
-        p = ffi.new("int[]", 0)
-        py.test.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
-        py.test.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 bool(ffi.cast("char", 0))
-        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 bool(ffi.cast("wchar_t", 0))
-        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 sys.maxunicode == 0xffff
-            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
-        py.test.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
-        py.test.raises(OverflowError, "s.b = 32768")
-        #
-        s = ffi.new("struct simple*", [-2, -3])
-        assert s.a == -2
-        assert s.b == -3
-        assert s.c == 0
-        py.test.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
-        py.test.raises(OverflowError, "s[0].b = -32769")
-        py.test.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
-        py.test.raises(OverflowError, "u.b = 32768")
-        #
-        u = ffi.new("union simple_u*", [-2])
-        assert u.a == -2
-        py.test.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"
-        py.test.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"
-        py.test.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"
-        py.test.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]
-        py.test.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
-        py.test.raises(TypeError, "s.r = a")    # fails
-        b = ffi.cast("int *", a)
-        s.p = b    # works
-        s.q = b    # works
-        py.test.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)
-        py.test.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
-        py.test.raises(TypeError, "s.e = 'B3'")
-        py.test.raises(TypeError, "s.e = '2'")
-        py.test.raises(TypeError, "s.e = '#2'")
-        py.test.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]")
-        py.test.raises(AttributeError, 's.b')
-        py.test.raises(AttributeError, 's.b = 412')
-        s[0].b = 412
-        assert s[0].b == 412
-        py.test.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
-        py.test.raises(OverflowError, "s.a = 512")
-        py.test.raises(OverflowError, "s[0].a = 512")
-        assert s.a == 511
-        s.a = -512
-        py.test.raises(OverflowError, "s.a = -513")
-        py.test.raises(OverflowError, "s[0].a = -513")
-        assert s.a == -512
-        s.c = 3
-        assert s.c == 3
-        py.test.raises(OverflowError, "s.c = 4")
-        py.test.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_no_integer_comparison(self):
-        x = ffi.cast("int", 123)
-        y = ffi.cast("int", 456)
-        py.test.raises(TypeError, "x < y")
-        #
-        z = ffi.cast("double", 78.9)
-        py.test.raises(TypeError, "x < z")
-        py.test.raises(TypeError, "z < y")
-
-    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() == array.array('i', range(1000)).tostring()
-        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() == array.array('i', range(1000)).tostring()
-        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
-        py.test.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_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 *")   # no length available
-        assert p.a[0] == 200
-        assert p.a[1] == 300
-        assert p.a[2] == 400
-
-    def test_from_buffer(self):
-        import array
-        a = array.array('H', [10000, 20000, 30000])
-        c = ffi.from_buffer(a)
-        assert ffi.typeof(c) is ffi.typeof("char[]")
-        ffi.cast("unsigned short *", c)[1] += 500
-        assert list(a) == [10000, 20500, 30000]
-
-    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",
-            "_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",
-            ])
-        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); 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
-        py.test.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']))

+ 0 - 360
desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_parse_c_type.py

@@ -1,360 +0,0 @@
-import sys, re, os, py
-import cffi
-from cffi import cffi_opcode
-
-if '__pypy__' in sys.builtin_module_names:
-    py.test.skip("not available on pypy")
-
-cffi_dir = os.path.dirname(cffi_opcode.__file__)
-
-r_macro = re.compile(r"#define \w+[(][^\n]*|#include [^\n]*")
-r_define = re.compile(r"(#define \w+) [^\n]*")
-r_ifdefs = re.compile(r"(#ifdef |#endif)[^\n]*")
-header = open(os.path.join(cffi_dir, 'parse_c_type.h')).read()
-header = r_macro.sub(r"", header)
-header = r_define.sub(r"\1 ...", header)
-header = r_ifdefs.sub(r"", header)
-
-ffi = cffi.FFI()
-ffi.cdef(header)
-
-lib = ffi.verify(
-        open(os.path.join(cffi_dir, '..', 'c', 'parse_c_type.c')).read() + """
-static const char *get_common_type(const char *search, size_t search_len) {
-    return NULL;
-}
-""",    include_dirs=[cffi_dir])
-
-class ParseError(Exception):
-    pass
-
-struct_names = ["bar_s", "foo", "foo_", "foo_s", "foo_s1", "foo_s12"]
-assert struct_names == sorted(struct_names)
-
-enum_names = ["ebar_s", "efoo", "efoo_", "efoo_s", "efoo_s1", "efoo_s12"]
-assert enum_names == sorted(enum_names)
-
-identifier_names = ["id", "id0", "id05", "id05b", "tail"]
-assert identifier_names == sorted(identifier_names)
-
-global_names = ["FIVE", "NEG", "ZERO"]
-assert global_names == sorted(global_names)
-
-ctx = ffi.new("struct _cffi_type_context_s *")
-c_struct_names = [ffi.new("char[]", _n.encode('ascii')) for _n in struct_names]
-ctx_structs = ffi.new("struct _cffi_struct_union_s[]", len(struct_names))
-for _i in range(len(struct_names)):
-    ctx_structs[_i].name = c_struct_names[_i]
-ctx_structs[3].flags = lib._CFFI_F_UNION
-ctx.struct_unions = ctx_structs
-ctx.num_struct_unions = len(struct_names)
-
-c_enum_names = [ffi.new("char[]", _n.encode('ascii')) for _n in enum_names]
-ctx_enums = ffi.new("struct _cffi_enum_s[]", len(enum_names))
-for _i in range(len(enum_names)):
-    ctx_enums[_i].name = c_enum_names[_i]
-ctx.enums = ctx_enums
-ctx.num_enums = len(enum_names)
-
-c_identifier_names = [ffi.new("char[]", _n.encode('ascii'))
-                      for _n in identifier_names]
-ctx_identifiers = ffi.new("struct _cffi_typename_s[]", len(identifier_names))
-for _i in range(len(identifier_names)):
-    ctx_identifiers[_i].name = c_identifier_names[_i]
-    ctx_identifiers[_i].type_index = 100 + _i
-ctx.typenames = ctx_identifiers
-ctx.num_typenames = len(identifier_names)
-
-@ffi.callback("int(unsigned long long *)")
-def fetch_constant_five(p):
-    p[0] = 5
-    return 0
-@ffi.callback("int(unsigned long long *)")
-def fetch_constant_zero(p):
-    p[0] = 0
-    return 1
-@ffi.callback("int(unsigned long long *)")
-def fetch_constant_neg(p):
-    p[0] = 123321
-    return 1
-
-ctx_globals = ffi.new("struct _cffi_global_s[]", len(global_names))
-c_glob_names = [ffi.new("char[]", _n.encode('ascii')) for _n in global_names]
-for _i, _fn in enumerate([fetch_constant_five,
-                          fetch_constant_neg,
-                          fetch_constant_zero]):
-    ctx_globals[_i].name = c_glob_names[_i]
-    ctx_globals[_i].address = _fn
-    ctx_globals[_i].type_op = ffi.cast("_cffi_opcode_t",
-                                       cffi_opcode.OP_CONSTANT_INT if _i != 1
-                                       else cffi_opcode.OP_ENUM)
-ctx.globals = ctx_globals
-ctx.num_globals = len(global_names)
-
-
-def parse(input):
-    out = ffi.new("_cffi_opcode_t[]", 100)
-    info = ffi.new("struct _cffi_parse_info_s *")
-    info.ctx = ctx
-    info.output = out
-    info.output_size = len(out)
-    for j in range(len(out)):
-        out[j] = ffi.cast("void *", -424242)
-    res = lib.parse_c_type(info, input.encode('ascii'))
-    if res < 0:
-        raise ParseError(ffi.string(info.error_message).decode('ascii'),
-                         info.error_location)
-    assert 0 <= res < len(out)
-    result = []
-    for j in range(len(out)):
-        if out[j] == ffi.cast("void *", -424242):
-            assert res < j
-            break
-        i = int(ffi.cast("intptr_t", out[j]))
-        if j == res:
-            result.append('->')
-        result.append(i)
-    return result
-
-def parsex(input):
-    result = parse(input)
-    def str_if_int(x):
-        if isinstance(x, str):
-            return x
-        return '%d,%d' % (x & 255, x >> 8)
-    return '  '.join(map(str_if_int, result))
-
-def parse_error(input, expected_msg, expected_location):
-    e = py.test.raises(ParseError, parse, input)
-    assert e.value.args[0] == expected_msg
-    assert e.value.args[1] == expected_location
-
-def make_getter(name):
-    opcode = getattr(lib, '_CFFI_OP_' + name)
-    def getter(value):
-        return opcode | (value << 8)
-    return getter
-
-Prim = make_getter('PRIMITIVE')
-Pointer = make_getter('POINTER')
-Array = make_getter('ARRAY')
-OpenArray = make_getter('OPEN_ARRAY')
-NoOp = make_getter('NOOP')
-Func = make_getter('FUNCTION')
-FuncEnd = make_getter('FUNCTION_END')
-Struct = make_getter('STRUCT_UNION')
-Enum = make_getter('ENUM')
-Typename = make_getter('TYPENAME')
-
-
-def test_simple():
-    for simple_type, expected in [
-            ("int", lib._CFFI_PRIM_INT),
-            ("signed int", lib._CFFI_PRIM_INT),
-            ("  long  ", lib._CFFI_PRIM_LONG),
-            ("long int", lib._CFFI_PRIM_LONG),
-            ("unsigned short", lib._CFFI_PRIM_USHORT),
-            ("long double", lib._CFFI_PRIM_LONGDOUBLE),
-            ]:
-        assert parse(simple_type) == ['->', Prim(expected)]
-
-def test_array():
-    assert parse("int[5]") == [Prim(lib._CFFI_PRIM_INT), '->', Array(0), 5]
-    assert parse("int[]") == [Prim(lib._CFFI_PRIM_INT), '->', OpenArray(0)]
-    assert parse("int[5][8]") == [Prim(lib._CFFI_PRIM_INT),
-                                  '->', Array(3),
-                                  5,
-                                  Array(0),
-                                  8]
-    assert parse("int[][8]") == [Prim(lib._CFFI_PRIM_INT),
-                                 '->', OpenArray(2),
-                                 Array(0),
-                                 8]
-
-def test_pointer():
-    assert parse("int*") == [Prim(lib._CFFI_PRIM_INT), '->', Pointer(0)]
-    assert parse("int***") == [Prim(lib._CFFI_PRIM_INT),
-                               Pointer(0), Pointer(1), '->', Pointer(2)]
-
-def test_grouping():
-    assert parse("int*[]") == [Prim(lib._CFFI_PRIM_INT),
-                               Pointer(0), '->', OpenArray(1)]
-    assert parse("int**[][8]") == [Prim(lib._CFFI_PRIM_INT),
-                                   Pointer(0), Pointer(1),
-                                   '->', OpenArray(4), Array(2), 8]
-    assert parse("int(*)[]") == [Prim(lib._CFFI_PRIM_INT),
-                                 NoOp(3), '->', Pointer(1), OpenArray(0)]
-    assert parse("int(*)[][8]") == [Prim(lib._CFFI_PRIM_INT),
-                                    NoOp(3), '->', Pointer(1),
-                                    OpenArray(4), Array(0), 8]
-    assert parse("int**(**)") == [Prim(lib._CFFI_PRIM_INT),
-                                  Pointer(0), Pointer(1),
-                                  NoOp(2), Pointer(3), '->', Pointer(4)]
-    assert parse("int**(**)[]") == [Prim(lib._CFFI_PRIM_INT),
-                                    Pointer(0), Pointer(1),
-                                    NoOp(6), Pointer(3), '->', Pointer(4),
-                                    OpenArray(2)]
-
-def test_simple_function():
-    assert parse("int()") == [Prim(lib._CFFI_PRIM_INT),
-                              '->', Func(0), FuncEnd(0), 0]
-    assert parse("int(int)") == [Prim(lib._CFFI_PRIM_INT),
-                                 '->', Func(0), NoOp(4), FuncEnd(0),
-                                 Prim(lib._CFFI_PRIM_INT)]
-    assert parse("int(long, char)") == [
-                                 Prim(lib._CFFI_PRIM_INT),
-                                 '->', Func(0), NoOp(5), NoOp(6), FuncEnd(0),
-                                 Prim(lib._CFFI_PRIM_LONG),
-                                 Prim(lib._CFFI_PRIM_CHAR)]
-    assert parse("int(int*)") == [Prim(lib._CFFI_PRIM_INT),
-                                  '->', Func(0), NoOp(5), FuncEnd(0),
-                                  Prim(lib._CFFI_PRIM_INT),
-                                  Pointer(4)]
-    assert parse("int*(void)") == [Prim(lib._CFFI_PRIM_INT),
-                                   Pointer(0),
-                                   '->', Func(1), FuncEnd(0), 0]
-    assert parse("int(int, ...)") == [Prim(lib._CFFI_PRIM_INT),
-                                      '->', Func(0), NoOp(5), FuncEnd(1), 0,
-                                      Prim(lib._CFFI_PRIM_INT)]
-
-def test_internal_function():
-    assert parse("int(*)()") == [Prim(lib._CFFI_PRIM_INT),
-                                 NoOp(3), '->', Pointer(1),
-                                 Func(0), FuncEnd(0), 0]
-    assert parse("int(*())[]") == [Prim(lib._CFFI_PRIM_INT),
-                                   NoOp(6), Pointer(1),
-                                   '->', Func(2), FuncEnd(0), 0,
-                                   OpenArray(0)]
-    assert parse("int(char(*)(long, short))") == [
-        Prim(lib._CFFI_PRIM_INT),
-        '->', Func(0), NoOp(6), FuncEnd(0),
-        Prim(lib._CFFI_PRIM_CHAR),
-        NoOp(7), Pointer(5),
-        Func(4), NoOp(11), NoOp(12), FuncEnd(0),
-        Prim(lib._CFFI_PRIM_LONG),
-        Prim(lib._CFFI_PRIM_SHORT)]
-
-def test_fix_arg_types():
-    assert parse("int(char(long, short))") == [
-        Prim(lib._CFFI_PRIM_INT),
-        '->', Func(0), Pointer(5), FuncEnd(0),
-        Prim(lib._CFFI_PRIM_CHAR),
-        Func(4), NoOp(9), NoOp(10), FuncEnd(0),
-        Prim(lib._CFFI_PRIM_LONG),
-        Prim(lib._CFFI_PRIM_SHORT)]
-    assert parse("int(char[])") == [
-        Prim(lib._CFFI_PRIM_INT),
-        '->', Func(0), Pointer(4), FuncEnd(0),
-        Prim(lib._CFFI_PRIM_CHAR),
-        OpenArray(4)]
-
-def test_enum():
-    for i in range(len(enum_names)):
-        assert parse("enum %s" % (enum_names[i],)) == ['->', Enum(i)]
-        assert parse("enum %s*" % (enum_names[i],)) == [Enum(i),
-                                                        '->', Pointer(0)]
-
-def test_error():
-    parse_error("short short int", "'short' after another 'short' or 'long'", 6)
-    parse_error("long long long", "'long long long' is too long", 10)
-    parse_error("short long", "'long' after 'short'", 6)
-    parse_error("signed unsigned int", "multiple 'signed' or 'unsigned'", 7)
-    parse_error("unsigned signed int", "multiple 'signed' or 'unsigned'", 9)
-    parse_error("long char", "invalid combination of types", 5)
-    parse_error("short char", "invalid combination of types", 6)
-    parse_error("signed void", "invalid combination of types", 7)
-    parse_error("unsigned struct", "invalid combination of types", 9)
-    #
-    parse_error("", "identifier expected", 0)
-    parse_error("]", "identifier expected", 0)
-    parse_error("*", "identifier expected", 0)
-    parse_error("int ]**", "unexpected symbol", 4)
-    parse_error("char char", "unexpected symbol", 5)
-    parse_error("int(int]", "expected ')'", 7)
-    parse_error("int(*]", "expected ')'", 5)
-    parse_error("int(]", "identifier expected", 4)
-    parse_error("int[?]", "expected a positive integer constant", 4)
-    parse_error("int[24)", "expected ']'", 6)
-    parse_error("struct", "struct or union name expected", 6)
-    parse_error("struct 24", "struct or union name expected", 7)
-    parse_error("int[5](*)", "unexpected symbol", 6)
-    parse_error("int a(*)", "identifier expected", 6)
-    parse_error("int[123456789012345678901234567890]", "number too large", 4)
-
-def test_number_too_large():
-    num_max = sys.maxsize
-    assert parse("char[%d]" % num_max) == [Prim(lib._CFFI_PRIM_CHAR),
-                                          '->', Array(0), num_max]
-    parse_error("char[%d]" % (num_max + 1), "number too large", 5)
-
-def test_complexity_limit():
-    parse_error("int" + "[]" * 2500, "internal type complexity limit reached",
-                202)
-
-def test_struct():
-    for i in range(len(struct_names)):
-        if i == 3:
-            tag = "union"
-        else:
-            tag = "struct"
-        assert parse("%s %s" % (tag, struct_names[i])) == ['->', Struct(i)]
-        assert parse("%s %s*" % (tag, struct_names[i])) == [Struct(i),
-                                                            '->', Pointer(0)]
-
-def test_exchanging_struct_union():
-    parse_error("union %s" % (struct_names[0],),
-                "wrong kind of tag: struct vs union", 6)
-    parse_error("struct %s" % (struct_names[3],),
-                "wrong kind of tag: struct vs union", 7)
-
-def test_identifier():
-    for i in range(len(identifier_names)):
-        assert parse("%s" % (identifier_names[i])) == ['->', Typename(i)]
-        assert parse("%s*" % (identifier_names[i])) == [Typename(i),
-                                                        '->', Pointer(0)]
-
-def test_cffi_opcode_sync():
-    import cffi.model
-    for name in dir(lib):
-        if name.startswith('_CFFI_'):
-            assert getattr(cffi_opcode, name[6:]) == getattr(lib, name)
-    assert sorted(cffi_opcode.PRIMITIVE_TO_INDEX.keys()) == (
-        sorted(cffi.model.PrimitiveType.ALL_PRIMITIVE_TYPES.keys()))
-
-def test_array_length_from_constant():
-    parse_error("int[UNKNOWN]", "expected a positive integer constant", 4)
-    assert parse("int[FIVE]") == [Prim(lib._CFFI_PRIM_INT), '->', Array(0), 5]
-    assert parse("int[ZERO]") == [Prim(lib._CFFI_PRIM_INT), '->', Array(0), 0]
-    parse_error("int[NEG]", "expected a positive integer constant", 4)
-
-def test_various_constant_exprs():
-    def array(n):
-        return [Prim(lib._CFFI_PRIM_CHAR), '->', Array(0), n]
-    assert parse("char[21]") == array(21)
-    assert parse("char[0x10]") == array(16)
-    assert parse("char[0X21]") == array(33)
-    assert parse("char[0Xb]") == array(11)
-    assert parse("char[0x1C]") == array(0x1C)
-    assert parse("char[0xc6]") == array(0xC6)
-    assert parse("char[010]") == array(8)
-    assert parse("char[021]") == array(17)
-    parse_error("char[08]", "invalid number", 5)
-    parse_error("char[1C]", "invalid number", 5)
-    parse_error("char[0C]", "invalid number", 5)
-    # not supported (really obscure):
-    #    "char[+5]"
-    #    "char['A']"
-
-def test_stdcall_cdecl():
-    assert parse("int __stdcall(int)") == [Prim(lib._CFFI_PRIM_INT),
-                                           '->', Func(0), NoOp(4), FuncEnd(2),
-                                           Prim(lib._CFFI_PRIM_INT)]
-    assert parse("int __stdcall func(int)") == parse("int __stdcall(int)")
-    assert parse("int (__stdcall *)()") == [Prim(lib._CFFI_PRIM_INT),
-                                            NoOp(3), '->', Pointer(1),
-                                            Func(0), FuncEnd(2), 0]
-    assert parse("int (__stdcall *p)()") == parse("int (__stdcall*)()")
-    parse_error("__stdcall int", "identifier expected", 0)
-    parse_error("__cdecl int", "identifier expected", 0)
-    parse_error("int __stdcall", "expected '('", 13)
-    parse_error("int __cdecl", "expected '('", 11)

+ 0 - 212
desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_re_python.py

@@ -1,212 +0,0 @@
-import sys
-import py
-from cffi import FFI
-from cffi import recompiler, ffiplatform, VerificationMissing
-from testing.udir import udir
-
-
-def setup_module(mod):
-    SRC = """
-    #include <string.h>
-    #define FOOBAR (-42)
-    static const int FOOBAZ = -43;
-    #define BIGPOS 420000000000L
-    #define BIGNEG -420000000000L
-    int add42(int x) { return x + 42; }
-    int add43(int x, ...) { return x; }
-    int globalvar42 = 1234;
-    const int globalconst42 = 4321;
-    const char *const globalconsthello = "hello";
-    struct foo_s;
-    typedef struct bar_s { int x; signed char a[]; } bar_t;
-    enum foo_e { AA, BB, CC };
-
-    void init_test_re_python(void) { }      /* windows hack */
-    void PyInit__test_re_python(void) { }   /* windows hack */
-    """
-    tmpdir = udir.join('test_re_python')
-    tmpdir.ensure(dir=1)
-    c_file = tmpdir.join('_test_re_python.c')
-    c_file.write(SRC)
-    ext = ffiplatform.get_extension(
-        str(c_file),
-        '_test_re_python',
-        export_symbols=['add42', 'add43', 'globalvar42',
-                        'globalconst42', 'globalconsthello']
-    )
-    outputfilename = ffiplatform.compile(str(tmpdir), ext)
-    mod.extmod = outputfilename
-    mod.tmpdir = tmpdir
-    #
-    ffi = FFI()
-    ffi.cdef("""
-    #define FOOBAR -42
-    static const int FOOBAZ = -43;
-    #define BIGPOS 420000000000L
-    #define BIGNEG -420000000000L
-    int add42(int);
-    int add43(int, ...);
-    int globalvar42;
-    const int globalconst42;
-    const char *const globalconsthello = "hello";
-    int no_such_function(int);
-    int no_such_globalvar;
-    struct foo_s;
-    typedef struct bar_s { int x; signed char a[]; } bar_t;
-    enum foo_e { AA, BB, CC };
-    int strlen(const char *);
-    """)
-    ffi.set_source('re_python_pysrc', None)
-    ffi.emit_python_code(str(tmpdir.join('re_python_pysrc.py')))
-    mod.original_ffi = ffi
-    #
-    sys.path.insert(0, str(tmpdir))
-
-
-def test_constant():
-    from re_python_pysrc import ffi
-    assert ffi.integer_const('FOOBAR') == -42
-    assert ffi.integer_const('FOOBAZ') == -43
-
-def test_large_constant():
-    from re_python_pysrc import ffi
-    assert ffi.integer_const('BIGPOS') == 420000000000
-    assert ffi.integer_const('BIGNEG') == -420000000000
-
-def test_function():
-    import _cffi_backend
-    from re_python_pysrc import ffi
-    lib = ffi.dlopen(extmod)
-    assert lib.add42(-10) == 32
-    assert type(lib.add42) is _cffi_backend.FFI.CData
-
-def test_function_with_varargs():
-    import _cffi_backend
-    from re_python_pysrc import ffi
-    lib = ffi.dlopen(extmod, 0)
-    assert lib.add43(45, ffi.cast("int", -5)) == 45
-    assert type(lib.add43) is _cffi_backend.FFI.CData
-
-def test_dlopen_none():
-    import _cffi_backend
-    from re_python_pysrc import ffi
-    name = None
-    if sys.platform == 'win32':
-        import ctypes.util
-        name = ctypes.util.find_msvcrt()
-    lib = ffi.dlopen(name)
-    assert lib.strlen(b"hello") == 5
-
-def test_dlclose():
-    import _cffi_backend
-    from re_python_pysrc import ffi
-    lib = ffi.dlopen(extmod)
-    ffi.dlclose(lib)
-    e = py.test.raises(ffi.error, ffi.dlclose, lib)
-    assert str(e.value).startswith(
-        "library '%s' is already closed" % (extmod,))
-    e = py.test.raises(ffi.error, getattr, lib, 'add42')
-    assert str(e.value) == (
-        "library '%s' has been closed" % (extmod,))
-
-def test_constant_via_lib():
-    from re_python_pysrc import ffi
-    lib = ffi.dlopen(extmod)
-    assert lib.FOOBAR == -42
-    assert lib.FOOBAZ == -43
-
-def test_opaque_struct():
-    from re_python_pysrc import ffi
-    ffi.cast("struct foo_s *", 0)
-    py.test.raises(TypeError, ffi.new, "struct foo_s *")
-
-def test_nonopaque_struct():
-    from re_python_pysrc import ffi
-    for p in [ffi.new("struct bar_s *", [5, b"foobar"]),
-              ffi.new("bar_t *", [5, b"foobar"])]:
-        assert p.x == 5
-        assert p.a[0] == ord('f')
-        assert p.a[5] == ord('r')
-
-def test_enum():
-    from re_python_pysrc import ffi
-    assert ffi.integer_const("BB") == 1
-    e = ffi.cast("enum foo_e", 2)
-    assert ffi.string(e) == "CC"
-
-def test_include_1():
-    sub_ffi = FFI()
-    sub_ffi.cdef("static const int k2 = 121212;")
-    sub_ffi.include(original_ffi)
-    assert 'macro FOOBAR' in original_ffi._parser._declarations
-    assert 'macro FOOBAZ' in original_ffi._parser._declarations
-    sub_ffi.set_source('re_python_pysrc', None)
-    sub_ffi.emit_python_code(str(tmpdir.join('_re_include_1.py')))
-    #
-    if sys.version_info[:2] >= (3, 3):
-        import importlib
-        importlib.invalidate_caches()  # issue 197 (but can't reproduce myself)
-    #
-    from _re_include_1 import ffi
-    assert ffi.integer_const('FOOBAR') == -42
-    assert ffi.integer_const('FOOBAZ') == -43
-    assert ffi.integer_const('k2') == 121212
-    lib = ffi.dlopen(extmod)     # <- a random unrelated library would be fine
-    assert lib.FOOBAR == -42
-    assert lib.FOOBAZ == -43
-    assert lib.k2 == 121212
-    #
-    p = ffi.new("bar_t *", [5, b"foobar"])
-    assert p.a[4] == ord('a')
-
-def test_global_var():
-    from re_python_pysrc import ffi
-    lib = ffi.dlopen(extmod)
-    assert lib.globalvar42 == 1234
-    p = ffi.addressof(lib, 'globalvar42')
-    lib.globalvar42 += 5
-    assert p[0] == 1239
-    p[0] -= 1
-    assert lib.globalvar42 == 1238
-
-def test_global_const_int():
-    from re_python_pysrc import ffi
-    lib = ffi.dlopen(extmod)
-    assert lib.globalconst42 == 4321
-    py.test.raises(AttributeError, ffi.addressof, lib, 'globalconst42')
-
-def test_global_const_nonint():
-    from re_python_pysrc import ffi
-    lib = ffi.dlopen(extmod)
-    assert ffi.string(lib.globalconsthello, 8) == b"hello"
-    py.test.raises(AttributeError, ffi.addressof, lib, 'globalconsthello')
-
-def test_rtld_constants():
-    from re_python_pysrc import ffi
-    ffi.RTLD_NOW    # check that we have the attributes
-    ffi.RTLD_LAZY
-    ffi.RTLD_GLOBAL
-
-def test_no_such_function_or_global_var():
-    from re_python_pysrc import ffi
-    lib = ffi.dlopen(extmod)
-    e = py.test.raises(ffi.error, getattr, lib, 'no_such_function')
-    assert str(e.value).startswith(
-        "symbol 'no_such_function' not found in library '")
-    e = py.test.raises(ffi.error, getattr, lib, 'no_such_globalvar')
-    assert str(e.value).startswith(
-        "symbol 'no_such_globalvar' not found in library '")
-
-def test_check_version():
-    import _cffi_backend
-    e = py.test.raises(ImportError, _cffi_backend.FFI,
-                       "foobar", _version=0x2594)
-    assert str(e.value).startswith(
-        "cffi out-of-line Python module 'foobar' has unknown version")
-
-def test_partial_enum():
-    ffi = FFI()
-    ffi.cdef("enum foo { A, B, ... };")
-    ffi.set_source('test_partial_enum', None)
-    py.test.raises(VerificationMissing, ffi.emit_python_code,
-                   str(tmpdir.join('test_partial_enum.py')))

+ 0 - 74
desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_realize_c_type.py

@@ -1,74 +0,0 @@
-import py, sys
-from cffi import cffi_opcode
-
-
-def check(input, expected_output=None, expected_ffi_error=False):
-    import _cffi_backend
-    ffi = _cffi_backend.FFI()
-    if not expected_ffi_error:
-        ct = ffi.typeof(input)
-        assert isinstance(ct, ffi.CType)
-        assert ct.cname == (expected_output or input)
-    else:
-        e = py.test.raises(ffi.error, ffi.typeof, input)
-        if isinstance(expected_ffi_error, str):
-            assert str(e.value) == expected_ffi_error
-
-def test_void():
-    check("void", "void")
-    check("  void  ", "void")
-
-def test_int_star():
-    check("int")
-    check("int *")
-    check("int*", "int *")
-    check("long int", "long")
-    check("long")
-
-def test_noop():
-    check("int(*)", "int *")
-
-def test_array():
-    check("int[6]")
-
-def test_funcptr():
-    check("int(*)(long)")
-    check("int(long)", expected_ffi_error="the type 'int(long)' is a"
-          " function type, not a pointer-to-function type")
-    check("int(void)", expected_ffi_error="the type 'int()' is a"
-          " function type, not a pointer-to-function type")
-
-def test_funcptr_rewrite_args():
-    check("int(*)(int(int))", "int(*)(int(*)(int))")
-    check("int(*)(long[])", "int(*)(long *)")
-    check("int(*)(long[5])", "int(*)(long *)")
-
-def test_all_primitives():
-    for name in cffi_opcode.PRIMITIVE_TO_INDEX:
-        check(name, name)
-
-
-def check_func(input, expected_output=None):
-    import _cffi_backend
-    ffi = _cffi_backend.FFI()
-    ct = ffi.typeof(ffi.callback(input, lambda: None))
-    assert isinstance(ct, ffi.CType)
-    if sys.platform != 'win32' or sys.maxsize > 2**32:
-        expected_output = expected_output.replace('__stdcall *', '*')
-    assert ct.cname == expected_output
-
-def test_funcptr_stdcall():
-    check_func("int(int)", "int(*)(int)")
-    check_func("int foobar(int)", "int(*)(int)")
-    check_func("int __stdcall(int)", "int(__stdcall *)(int)")
-    check_func("int __stdcall foobar(int)", "int(__stdcall *)(int)")
-    check_func("void __cdecl(void)", "void(*)()")
-    check_func("void __cdecl foobar(void)", "void(*)()")
-    check_func("void __stdcall(void)", "void(__stdcall *)()")
-    check_func("void __stdcall foobar(long, short)",
-                   "void(__stdcall *)(long, short)")
-    check_func("void(void __cdecl(void), void __stdcall(void))",
-                   "void(*)(void(*)(), void(__stdcall *)())")
-
-def test_variadic_overrides_stdcall():
-    check("void (__stdcall*)(int, ...)", "void(*)(int, ...)")

+ 0 - 1486
desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_recompiler.py

@@ -1,1486 +0,0 @@
-
-import sys, os, py
-from cffi import FFI, VerificationError, FFIError
-from cffi import recompiler
-from testing.udir import udir
-from testing.support import u
-
-
-def check_type_table(input, expected_output, included=None):
-    ffi = FFI()
-    if included:
-        ffi1 = FFI()
-        ffi1.cdef(included)
-        ffi.include(ffi1)
-    ffi.cdef(input)
-    recomp = recompiler.Recompiler(ffi, 'testmod')
-    recomp.collect_type_table()
-    assert ''.join(map(str, recomp.cffi_types)) == expected_output
-
-def verify(ffi, module_name, source, *args, **kwds):
-    kwds.setdefault('undef_macros', ['NDEBUG'])
-    module_name = '_CFFI_' + module_name
-    ffi.set_source(module_name, source)
-    if not os.environ.get('NO_CPP'):     # test the .cpp mode too
-        kwds.setdefault('source_extension', '.cpp')
-        source = 'extern "C" {\n%s\n}' % (source,)
-    else:
-        kwds['extra_compile_args'] = (kwds.get('extra_compile_args', []) +
-                                      ['-Werror'])
-    return recompiler._verify(ffi, module_name, source, *args, **kwds)
-
-
-def test_type_table_func():
-    check_type_table("double sin(double);",
-                     "(FUNCTION 1)(PRIMITIVE 14)(FUNCTION_END 0)")
-    check_type_table("float sin(double);",
-                     "(FUNCTION 3)(PRIMITIVE 14)(FUNCTION_END 0)(PRIMITIVE 13)")
-    check_type_table("float sin(void);",
-                     "(FUNCTION 2)(FUNCTION_END 0)(PRIMITIVE 13)")
-    check_type_table("double sin(float); double cos(float);",
-                     "(FUNCTION 3)(PRIMITIVE 13)(FUNCTION_END 0)(PRIMITIVE 14)")
-    check_type_table("double sin(float); double cos(double);",
-                     "(FUNCTION 1)(PRIMITIVE 14)(FUNCTION_END 0)"   # cos
-                     "(FUNCTION 1)(PRIMITIVE 13)(FUNCTION_END 0)")  # sin
-    check_type_table("float sin(double); float cos(float);",
-                     "(FUNCTION 4)(PRIMITIVE 14)(FUNCTION_END 0)"   # sin
-                     "(FUNCTION 4)(PRIMITIVE 13)(FUNCTION_END 0)")  # cos
-
-def test_type_table_use_noop_for_repeated_args():
-    check_type_table("double sin(double *, double *);",
-                     "(FUNCTION 4)(POINTER 4)(NOOP 1)(FUNCTION_END 0)"
-                     "(PRIMITIVE 14)")
-    check_type_table("double sin(double *, double *, double);",
-                     "(FUNCTION 3)(POINTER 3)(NOOP 1)(PRIMITIVE 14)"
-                     "(FUNCTION_END 0)")
-
-def test_type_table_dont_use_noop_for_primitives():
-    check_type_table("double sin(double, double);",
-                     "(FUNCTION 1)(PRIMITIVE 14)(PRIMITIVE 14)(FUNCTION_END 0)")
-
-def test_type_table_funcptr_as_argument():
-    check_type_table("int sin(double(float));",
-                     "(FUNCTION 6)(PRIMITIVE 13)(FUNCTION_END 0)"
-                     "(FUNCTION 7)(POINTER 0)(FUNCTION_END 0)"
-                     "(PRIMITIVE 14)(PRIMITIVE 7)")
-
-def test_type_table_variadic_function():
-    check_type_table("int sin(int, ...);",
-                     "(FUNCTION 1)(PRIMITIVE 7)(FUNCTION_END 1)(POINTER 0)")
-
-def test_type_table_array():
-    check_type_table("int a[100];",
-                     "(PRIMITIVE 7)(ARRAY 0)(None 100)")
-
-def test_type_table_typedef():
-    check_type_table("typedef int foo_t;",
-                     "(PRIMITIVE 7)")
-
-def test_type_table_prebuilt_type():
-    check_type_table("int32_t f(void);",
-                     "(FUNCTION 2)(FUNCTION_END 0)(PRIMITIVE 21)")
-
-def test_type_table_struct_opaque():
-    check_type_table("struct foo_s;",
-                     "(STRUCT_UNION 0)")
-
-def test_type_table_struct():
-    check_type_table("struct foo_s { int a; long b; };",
-                     "(PRIMITIVE 7)(PRIMITIVE 9)(STRUCT_UNION 0)")
-
-def test_type_table_union():
-    check_type_table("union foo_u { int a; long b; };",
-                     "(PRIMITIVE 7)(PRIMITIVE 9)(STRUCT_UNION 0)")
-
-def test_type_table_struct_used():
-    check_type_table("struct foo_s { int a; long b; }; int f(struct foo_s*);",
-                     "(FUNCTION 3)(POINTER 5)(FUNCTION_END 0)"
-                     "(PRIMITIVE 7)(PRIMITIVE 9)"
-                     "(STRUCT_UNION 0)")
-
-def test_type_table_anonymous_struct_with_typedef():
-    check_type_table("typedef struct { int a; long b; } foo_t;",
-                     "(STRUCT_UNION 0)(PRIMITIVE 7)(PRIMITIVE 9)")
-
-def test_type_table_enum():
-    check_type_table("enum foo_e { AA, BB, ... };",
-                     "(ENUM 0)")
-
-def test_type_table_include_1():
-    check_type_table("foo_t sin(foo_t);",
-                     "(FUNCTION 1)(PRIMITIVE 14)(FUNCTION_END 0)",
-                     included="typedef double foo_t;")
-
-def test_type_table_include_2():
-    check_type_table("struct foo_s *sin(struct foo_s *);",
-                     "(FUNCTION 1)(POINTER 3)(FUNCTION_END 0)(STRUCT_UNION 0)",
-                     included="struct foo_s { int x, y; };")
-
-
-def test_math_sin():
-    import math
-    ffi = FFI()
-    ffi.cdef("float sin(double); double cos(double);")
-    lib = verify(ffi, 'test_math_sin', '#include <math.h>')
-    assert lib.cos(1.43) == math.cos(1.43)
-
-def test_repr_lib():
-    ffi = FFI()
-    lib = verify(ffi, 'test_repr_lib', '')
-    assert repr(lib) == "<Lib object for '_CFFI_test_repr_lib'>"
-
-def test_funcarg_ptr():
-    ffi = FFI()
-    ffi.cdef("int foo(int *);")
-    lib = verify(ffi, 'test_funcarg_ptr', 'int foo(int *p) { return *p; }')
-    assert lib.foo([-12345]) == -12345
-
-def test_funcres_ptr():
-    ffi = FFI()
-    ffi.cdef("int *foo(void);")
-    lib = verify(ffi, 'test_funcres_ptr',
-                 'int *foo(void) { static int x=-12345; return &x; }')
-    assert lib.foo()[0] == -12345
-
-def test_global_var_array():
-    ffi = FFI()
-    ffi.cdef("int a[100];")
-    lib = verify(ffi, 'test_global_var_array', 'int a[100] = { 9999 };')
-    lib.a[42] = 123456
-    assert lib.a[42] == 123456
-    assert lib.a[0] == 9999
-
-def test_verify_typedef():
-    ffi = FFI()
-    ffi.cdef("typedef int **foo_t;")
-    lib = verify(ffi, 'test_verify_typedef', 'typedef int **foo_t;')
-    assert ffi.sizeof("foo_t") == ffi.sizeof("void *")
-
-def test_verify_typedef_dotdotdot():
-    ffi = FFI()
-    ffi.cdef("typedef ... foo_t;")
-    verify(ffi, 'test_verify_typedef_dotdotdot', 'typedef int **foo_t;')
-
-def test_verify_typedef_star_dotdotdot():
-    ffi = FFI()
-    ffi.cdef("typedef ... *foo_t;")
-    verify(ffi, 'test_verify_typedef_star_dotdotdot', 'typedef int **foo_t;')
-
-def test_global_var_int():
-    ffi = FFI()
-    ffi.cdef("int a, b, c;")
-    lib = verify(ffi, 'test_global_var_int', 'int a = 999, b, c;')
-    assert lib.a == 999
-    lib.a -= 1001
-    assert lib.a == -2
-    lib.a = -2147483648
-    assert lib.a == -2147483648
-    py.test.raises(OverflowError, "lib.a = 2147483648")
-    py.test.raises(OverflowError, "lib.a = -2147483649")
-    lib.b = 525      # try with the first access being in setattr, too
-    assert lib.b == 525
-    py.test.raises(AttributeError, "del lib.a")
-    py.test.raises(AttributeError, "del lib.c")
-    py.test.raises(AttributeError, "del lib.foobarbaz")
-
-def test_macro():
-    ffi = FFI()
-    ffi.cdef("#define FOOBAR ...")
-    lib = verify(ffi, 'test_macro', "#define FOOBAR (-6912)")
-    assert lib.FOOBAR == -6912
-    py.test.raises(AttributeError, "lib.FOOBAR = 2")
-
-def test_macro_check_value():
-    # the value '-0x80000000' in C sources does not have a clear meaning
-    # to me; it appears to have a different effect than '-2147483648'...
-    # Moreover, on 32-bits, -2147483648 is actually equal to
-    # -2147483648U, which in turn is equal to 2147483648U and so positive.
-    vals = ['42', '-42', '0x80000000', '-2147483648',
-            '0', '9223372036854775809ULL',
-            '-9223372036854775807LL']
-    if sys.maxsize <= 2**32 or sys.platform == 'win32':
-        vals.remove('-2147483648')
-    ffi = FFI()
-    cdef_lines = ['#define FOO_%d_%d %s' % (i, j, vals[i])
-                  for i in range(len(vals))
-                  for j in range(len(vals))]
-    ffi.cdef('\n'.join(cdef_lines))
-
-    verify_lines = ['#define FOO_%d_%d %s' % (i, j, vals[j])  # [j], not [i]
-                    for i in range(len(vals))
-                    for j in range(len(vals))]
-    lib = verify(ffi, 'test_macro_check_value_ok',
-                 '\n'.join(verify_lines))
-    #
-    for j in range(len(vals)):
-        c_got = int(vals[j].replace('U', '').replace('L', ''), 0)
-        c_compiler_msg = str(c_got)
-        if c_got > 0:
-            c_compiler_msg += ' (0x%x)' % (c_got,)
-        #
-        for i in range(len(vals)):
-            attrname = 'FOO_%d_%d' % (i, j)
-            if i == j:
-                x = getattr(lib, attrname)
-                assert x == c_got
-            else:
-                e = py.test.raises(ffi.error, getattr, lib, attrname)
-                assert str(e.value) == (
-                    "the C compiler says '%s' is equal to "
-                    "%s, but the cdef disagrees" % (attrname, c_compiler_msg))
-
-def test_constant():
-    ffi = FFI()
-    ffi.cdef("static const int FOOBAR;")
-    lib = verify(ffi, 'test_constant', "#define FOOBAR (-6912)")
-    assert lib.FOOBAR == -6912
-    py.test.raises(AttributeError, "lib.FOOBAR = 2")
-
-def test_check_value_of_static_const():
-    ffi = FFI()
-    ffi.cdef("static const int FOOBAR = 042;")
-    lib = verify(ffi, 'test_check_value_of_static_const',
-                 "#define FOOBAR (-6912)")
-    e = py.test.raises(ffi.error, getattr, lib, 'FOOBAR')
-    assert str(e.value) == (
-       "the C compiler says 'FOOBAR' is equal to -6912, but the cdef disagrees")
-
-def test_constant_nonint():
-    ffi = FFI()
-    ffi.cdef("static const double FOOBAR;")
-    lib = verify(ffi, 'test_constant_nonint', "#define FOOBAR (-6912.5)")
-    assert lib.FOOBAR == -6912.5
-    py.test.raises(AttributeError, "lib.FOOBAR = 2")
-
-def test_constant_ptr():
-    ffi = FFI()
-    ffi.cdef("static double *const FOOBAR;")
-    lib = verify(ffi, 'test_constant_ptr', "#define FOOBAR NULL")
-    assert lib.FOOBAR == ffi.NULL
-    assert ffi.typeof(lib.FOOBAR) == ffi.typeof("double *")
-
-def test_dir():
-    ffi = FFI()
-    ffi.cdef("int ff(int); int aa; static const int my_constant;")
-    lib = verify(ffi, 'test_dir', """
-        #define my_constant  (-45)
-        int aa;
-        int ff(int x) { return x+aa; }
-    """)
-    lib.aa = 5
-    assert dir(lib) == ['aa', 'ff', 'my_constant']
-    #
-    aaobj = lib.__dict__['aa']
-    assert not isinstance(aaobj, int)    # some internal object instead
-    assert lib.__dict__ == {
-        'ff': lib.ff,
-        'aa': aaobj,
-        'my_constant': -45}
-    lib.__dict__['ff'] = "??"
-    assert lib.ff(10) == 15
-
-def test_verify_opaque_struct():
-    ffi = FFI()
-    ffi.cdef("struct foo_s;")
-    lib = verify(ffi, 'test_verify_opaque_struct', "struct foo_s;")
-    assert ffi.typeof("struct foo_s").cname == "struct foo_s"
-
-def test_verify_opaque_union():
-    ffi = FFI()
-    ffi.cdef("union foo_s;")
-    lib = verify(ffi, 'test_verify_opaque_union', "union foo_s;")
-    assert ffi.typeof("union foo_s").cname == "union foo_s"
-
-def test_verify_struct():
-    ffi = FFI()
-    ffi.cdef("""struct foo_s { int b; short a; ...; };
-                struct bar_s { struct foo_s *f; };""")
-    lib = verify(ffi, 'test_verify_struct',
-                 """struct foo_s { short a; int b; };
-                    struct bar_s { struct foo_s *f; };""")
-    ffi.typeof("struct bar_s *")
-    p = ffi.new("struct foo_s *", {'a': -32768, 'b': -2147483648})
-    assert p.a == -32768
-    assert p.b == -2147483648
-    py.test.raises(OverflowError, "p.a -= 1")
-    py.test.raises(OverflowError, "p.b -= 1")
-    q = ffi.new("struct bar_s *", {'f': p})
-    assert q.f == p
-    #
-    assert ffi.offsetof("struct foo_s", "a") == 0
-    assert ffi.offsetof("struct foo_s", "b") == 4
-    assert ffi.offsetof(u+"struct foo_s", u+"b") == 4
-    #
-    py.test.raises(TypeError, ffi.addressof, p)
-    assert ffi.addressof(p[0]) == p
-    assert ffi.typeof(ffi.addressof(p[0])) is ffi.typeof("struct foo_s *")
-    assert ffi.typeof(ffi.addressof(p, "b")) is ffi.typeof("int *")
-    assert ffi.addressof(p, "b")[0] == p.b
-
-def test_verify_exact_field_offset():
-    ffi = FFI()
-    ffi.cdef("""struct foo_s { int b; short a; };""")
-    lib = verify(ffi, 'test_verify_exact_field_offset',
-                 """struct foo_s { short a; int b; };""")
-    e = py.test.raises(ffi.error, ffi.new, "struct foo_s *", [])    # lazily
-    assert str(e.value) == ("struct foo_s: wrong offset for field 'b' (cdef "
-                       'says 0, but C compiler says 4). fix it or use "...;" '
-                       "in the cdef for struct foo_s to make it flexible")
-
-def test_type_caching():
-    ffi1 = FFI(); ffi1.cdef("struct foo_s;")
-    ffi2 = FFI(); ffi2.cdef("struct foo_s;")    # different one!
-    lib1 = verify(ffi1, 'test_type_caching_1', 'struct foo_s;')
-    lib2 = verify(ffi2, 'test_type_caching_2', 'struct foo_s;')
-    # shared types
-    assert ffi1.typeof("long") is ffi2.typeof("long")
-    assert ffi1.typeof("long**") is ffi2.typeof("long * *")
-    assert ffi1.typeof("long(*)(int, ...)") is ffi2.typeof("long(*)(int, ...)")
-    # non-shared types
-    assert ffi1.typeof("struct foo_s") is not ffi2.typeof("struct foo_s")
-    assert ffi1.typeof("struct foo_s *") is not ffi2.typeof("struct foo_s *")
-    assert ffi1.typeof("struct foo_s*(*)()") is not (
-        ffi2.typeof("struct foo_s*(*)()"))
-    assert ffi1.typeof("void(*)(struct foo_s*)") is not (
-        ffi2.typeof("void(*)(struct foo_s*)"))
-
-def test_verify_enum():
-    ffi = FFI()
-    ffi.cdef("""enum e1 { B1, A1, ... }; enum e2 { B2, A2, ... };""")
-    lib = verify(ffi, 'test_verify_enum',
-                 "enum e1 { A1, B1, C1=%d };" % sys.maxsize +
-                 "enum e2 { A2, B2, C2 };")
-    ffi.typeof("enum e1")
-    ffi.typeof("enum e2")
-    assert lib.A1 == 0
-    assert lib.B1 == 1
-    assert lib.A2 == 0
-    assert lib.B2 == 1
-    assert ffi.sizeof("enum e1") == ffi.sizeof("long")
-    assert ffi.sizeof("enum e2") == ffi.sizeof("int")
-    assert repr(ffi.cast("enum e1", 0)) == "<cdata 'enum e1' 0: A1>"
-
-def test_duplicate_enum():
-    ffi = FFI()
-    ffi.cdef("enum e1 { A1, ... }; enum e2 { A1, ... };")
-    py.test.raises(VerificationError, verify, ffi, 'test_duplicate_enum',
-                    "enum e1 { A1 }; enum e2 { B1 };")
-
-def test_dotdotdot_length_of_array_field():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int a[...]; int b[...]; };")
-    verify(ffi, 'test_dotdotdot_length_of_array_field',
-           "struct foo_s { int a[42]; int b[11]; };")
-    assert ffi.sizeof("struct foo_s") == (42 + 11) * 4
-    p = ffi.new("struct foo_s *")
-    assert p.a[41] == p.b[10] == 0
-    py.test.raises(IndexError, "p.a[42]")
-    py.test.raises(IndexError, "p.b[11]")
-
-def test_dotdotdot_global_array():
-    ffi = FFI()
-    ffi.cdef("int aa[...]; int bb[...];")
-    lib = verify(ffi, 'test_dotdotdot_global_array',
-                 "int aa[41]; int bb[12];")
-    assert ffi.sizeof(lib.aa) == 41 * 4
-    assert ffi.sizeof(lib.bb) == 12 * 4
-    assert lib.aa[40] == lib.bb[11] == 0
-    py.test.raises(IndexError, "lib.aa[41]")
-    py.test.raises(IndexError, "lib.bb[12]")
-
-def test_misdeclared_field_1():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int a[5]; };")
-    try:
-        verify(ffi, 'test_misdeclared_field_1',
-               "struct foo_s { int a[6]; };")
-    except VerificationError:
-        pass    # ok, fail during compilation already (e.g. C++)
-    else:
-        assert ffi.sizeof("struct foo_s") == 24  # found by the actual C code
-        p = ffi.new("struct foo_s *")
-        # lazily build the fields and boom:
-        e = py.test.raises(ffi.error, "p.a")
-        assert str(e.value).startswith("struct foo_s: wrong size for field 'a' "
-                                       "(cdef says 20, but C compiler says 24)")
-
-def test_open_array_in_struct():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int b; int a[]; };")
-    verify(ffi, 'test_open_array_in_struct',
-           "struct foo_s { int b; int a[]; };")
-    assert ffi.sizeof("struct foo_s") == 4
-    p = ffi.new("struct foo_s *", [5, [10, 20, 30]])
-    assert p.a[2] == 30
-
-def test_math_sin_type():
-    ffi = FFI()
-    ffi.cdef("double sin(double);")
-    lib = verify(ffi, 'test_math_sin_type', '#include <math.h>')
-    # 'lib.sin' is typed as a <built-in method> object on lib
-    assert ffi.typeof(lib.sin).cname == "double(*)(double)"
-    # 'x' is another <built-in method> object on lib, made very indirectly
-    x = type(lib).__dir__.__get__(lib)
-    py.test.raises(TypeError, ffi.typeof, x)
-    #
-    # present on built-in functions on CPython; must be emulated on PyPy:
-    assert lib.sin.__name__ == 'sin'
-    assert lib.sin.__module__ == '_CFFI_test_math_sin_type'
-    assert lib.sin.__doc__ == 'direct call to the C function of the same name'
-
-def test_verify_anonymous_struct_with_typedef():
-    ffi = FFI()
-    ffi.cdef("typedef struct { int a; long b; ...; } foo_t;")
-    verify(ffi, 'test_verify_anonymous_struct_with_typedef',
-           "typedef struct { long b; int hidden, a; } foo_t;")
-    p = ffi.new("foo_t *", {'b': 42})
-    assert p.b == 42
-    assert repr(p).startswith("<cdata 'foo_t *' ")
-
-def test_verify_anonymous_struct_with_star_typedef():
-    ffi = FFI()
-    ffi.cdef("typedef struct { int a; long b; } *foo_t;")
-    verify(ffi, 'test_verify_anonymous_struct_with_star_typedef',
-           "typedef struct { int a; long b; } *foo_t;")
-    p = ffi.new("foo_t", {'b': 42})
-    assert p.b == 42
-
-def test_verify_anonymous_enum_with_typedef():
-    ffi = FFI()
-    ffi.cdef("typedef enum { AA, ... } e1;")
-    lib = verify(ffi, 'test_verify_anonymous_enum_with_typedef1',
-                 "typedef enum { BB, CC, AA } e1;")
-    assert lib.AA == 2
-    assert ffi.sizeof("e1") == ffi.sizeof("int")
-    assert repr(ffi.cast("e1", 2)) == "<cdata 'e1' 2: AA>"
-    #
-    ffi = FFI()
-    ffi.cdef("typedef enum { AA=%d } e1;" % sys.maxsize)
-    lib = verify(ffi, 'test_verify_anonymous_enum_with_typedef2',
-                 "typedef enum { AA=%d } e1;" % sys.maxsize)
-    assert lib.AA == int(ffi.cast("long", sys.maxsize))
-    assert ffi.sizeof("e1") == ffi.sizeof("long")
-
-def test_unique_types():
-    CDEF = "struct foo_s; union foo_u; enum foo_e { AA };"
-    ffi1 = FFI(); ffi1.cdef(CDEF); verify(ffi1, "test_unique_types_1", CDEF)
-    ffi2 = FFI(); ffi2.cdef(CDEF); verify(ffi2, "test_unique_types_2", CDEF)
-    #
-    assert ffi1.typeof("char") is ffi2.typeof("char ")
-    assert ffi1.typeof("long") is ffi2.typeof("signed long int")
-    assert ffi1.typeof("double *") is ffi2.typeof("double*")
-    assert ffi1.typeof("int ***") is ffi2.typeof(" int * * *")
-    assert ffi1.typeof("int[]") is ffi2.typeof("signed int[]")
-    assert ffi1.typeof("signed int*[17]") is ffi2.typeof("int *[17]")
-    assert ffi1.typeof("void") is ffi2.typeof("void")
-    assert ffi1.typeof("int(*)(int,int)") is ffi2.typeof("int(*)(int,int)")
-    #
-    # these depend on user-defined data, so should not be shared
-    for name in ["struct foo_s",
-                 "union foo_u *",
-                 "enum foo_e",
-                 "struct foo_s *(*)()",
-                 "void(*)(struct foo_s *)",
-                 "struct foo_s *(*[5])[8]",
-                 ]:
-        assert ffi1.typeof(name) is not ffi2.typeof(name)
-    # sanity check: twice 'ffi1'
-    assert ffi1.typeof("struct foo_s*") is ffi1.typeof("struct foo_s *")
-
-def test_module_name_in_package():
-    ffi = FFI()
-    ffi.cdef("int foo(int);")
-    recompiler.recompile(ffi, "test_module_name_in_package.mymod",
-                         "int foo(int x) { return x + 32; }",
-                         tmpdir=str(udir))
-    old_sys_path = sys.path[:]
-    try:
-        package_dir = udir.join('test_module_name_in_package')
-        for name in os.listdir(str(udir)):
-            assert not name.startswith('test_module_name_in_package.')
-        assert os.path.isdir(str(package_dir))
-        assert len(os.listdir(str(package_dir))) > 0
-        assert os.path.exists(str(package_dir.join('mymod.c')))
-        package_dir.join('__init__.py').write('')
-        #
-        sys.path.insert(0, str(udir))
-        import test_module_name_in_package.mymod
-        assert test_module_name_in_package.mymod.lib.foo(10) == 42
-        assert test_module_name_in_package.mymod.__name__ == (
-            'test_module_name_in_package.mymod')
-    finally:
-        sys.path[:] = old_sys_path
-
-def test_bad_size_of_global_1():
-    ffi = FFI()
-    ffi.cdef("short glob;")
-    py.test.raises(VerificationError, verify, ffi,
-                   "test_bad_size_of_global_1", "long glob;")
-
-def test_bad_size_of_global_2():
-    ffi = FFI()
-    ffi.cdef("int glob[10];")
-    py.test.raises(VerificationError, verify, ffi,
-                   "test_bad_size_of_global_2", "int glob[9];")
-
-def test_unspecified_size_of_global_1():
-    ffi = FFI()
-    ffi.cdef("int glob[];")
-    lib = verify(ffi, "test_unspecified_size_of_global_1", "int glob[10];")
-    assert ffi.typeof(lib.glob) == ffi.typeof("int *")
-
-def test_unspecified_size_of_global_2():
-    ffi = FFI()
-    ffi.cdef("int glob[][5];")
-    lib = verify(ffi, "test_unspecified_size_of_global_2", "int glob[10][5];")
-    assert ffi.typeof(lib.glob) == ffi.typeof("int(*)[5]")
-
-def test_unspecified_size_of_global_3():
-    ffi = FFI()
-    ffi.cdef("int glob[][...];")
-    lib = verify(ffi, "test_unspecified_size_of_global_3", "int glob[10][5];")
-    assert ffi.typeof(lib.glob) == ffi.typeof("int(*)[5]")
-
-def test_unspecified_size_of_global_4():
-    ffi = FFI()
-    ffi.cdef("int glob[...][...];")
-    lib = verify(ffi, "test_unspecified_size_of_global_4", "int glob[10][5];")
-    assert ffi.typeof(lib.glob) == ffi.typeof("int[10][5]")
-
-def test_include_1():
-    ffi1 = FFI()
-    ffi1.cdef("typedef double foo_t;")
-    verify(ffi1, "test_include_1_parent", "typedef double foo_t;")
-    ffi = FFI()
-    ffi.include(ffi1)
-    ffi.cdef("foo_t ff1(foo_t);")
-    lib = verify(ffi, "test_include_1", "double ff1(double x) { return 42.5; }")
-    assert lib.ff1(0) == 42.5
-    assert ffi1.typeof("foo_t") is ffi.typeof("foo_t") is ffi.typeof("double")
-
-def test_include_1b():
-    ffi1 = FFI()
-    ffi1.cdef("int foo1(int);")
-    lib1 = verify(ffi1, "test_include_1b_parent",
-                  "int foo1(int x) { return x + 10; }")
-    ffi = FFI()
-    ffi.include(ffi1)
-    ffi.cdef("int foo2(int);")
-    lib = verify(ffi, "test_include_1b", "int foo2(int x) { return x - 5; }")
-    assert lib.foo2(42) == 37
-    assert lib.foo1(42) == 52
-    assert lib.foo1 is lib1.foo1
-
-def test_include_2():
-    ffi1 = FFI()
-    ffi1.cdef("struct foo_s { int x, y; };")
-    verify(ffi1, "test_include_2_parent", "struct foo_s { int x, y; };")
-    ffi = FFI()
-    ffi.include(ffi1)
-    ffi.cdef("struct foo_s *ff2(struct foo_s *);")
-    lib = verify(ffi, "test_include_2",
-                 "struct foo_s { int x, y; }; //usually from a #include\n"
-                 "struct foo_s *ff2(struct foo_s *p) { p->y++; return p; }")
-    p = ffi.new("struct foo_s *")
-    p.y = 41
-    q = lib.ff2(p)
-    assert q == p
-    assert p.y == 42
-    assert ffi1.typeof("struct foo_s") is ffi.typeof("struct foo_s")
-
-def test_include_3():
-    ffi1 = FFI()
-    ffi1.cdef("typedef short sshort_t;")
-    verify(ffi1, "test_include_3_parent", "typedef short sshort_t;")
-    ffi = FFI()
-    ffi.include(ffi1)
-    ffi.cdef("sshort_t ff3(sshort_t);")
-    lib = verify(ffi, "test_include_3",
-                 "typedef short sshort_t; //usually from a #include\n"
-                 "sshort_t ff3(sshort_t x) { return x + 42; }")
-    assert lib.ff3(10) == 52
-    assert ffi.typeof(ffi.cast("sshort_t", 42)) is ffi.typeof("short")
-    assert ffi1.typeof("sshort_t") is ffi.typeof("sshort_t")
-
-def test_include_4():
-    ffi1 = FFI()
-    ffi1.cdef("typedef struct { int x; } mystruct_t;")
-    verify(ffi1, "test_include_4_parent",
-           "typedef struct { int x; } mystruct_t;")
-    ffi = FFI()
-    ffi.include(ffi1)
-    ffi.cdef("mystruct_t *ff4(mystruct_t *);")
-    lib = verify(ffi, "test_include_4",
-           "typedef struct {int x; } mystruct_t; //usually from a #include\n"
-           "mystruct_t *ff4(mystruct_t *p) { p->x += 42; return p; }")
-    p = ffi.new("mystruct_t *", [10])
-    q = lib.ff4(p)
-    assert q == p
-    assert p.x == 52
-    assert ffi1.typeof("mystruct_t") is ffi.typeof("mystruct_t")
-
-def test_include_5():
-    ffi1 = FFI()
-    ffi1.cdef("typedef struct { int x[2]; int y; } *mystruct_p;")
-    verify(ffi1, "test_include_5_parent",
-           "typedef struct { int x[2]; int y; } *mystruct_p;")
-    ffi = FFI()
-    ffi.include(ffi1)
-    ffi.cdef("mystruct_p ff5(mystruct_p);")
-    lib = verify(ffi, "test_include_5",
-        "typedef struct {int x[2]; int y; } *mystruct_p; //usually #include\n"
-        "mystruct_p ff5(mystruct_p p) { p->x[1] += 42; return p; }")
-    assert ffi.alignof(ffi.typeof("mystruct_p").item) == 4
-    assert ffi1.typeof("mystruct_p") is ffi.typeof("mystruct_p")
-    p = ffi.new("mystruct_p", [[5, 10], -17])
-    q = lib.ff5(p)
-    assert q == p
-    assert p.x[0] == 5
-    assert p.x[1] == 52
-    assert p.y == -17
-    assert ffi.alignof(ffi.typeof(p[0])) == 4
-
-def test_include_6():
-    ffi1 = FFI()
-    ffi1.cdef("typedef ... mystruct_t;")
-    verify(ffi1, "test_include_6_parent",
-           "typedef struct _mystruct_s mystruct_t;")
-    ffi = FFI()
-    ffi.include(ffi1)
-    ffi.cdef("mystruct_t *ff6(void); int ff6b(mystruct_t *);")
-    lib = verify(ffi, "test_include_6",
-           "typedef struct _mystruct_s mystruct_t; //usually from a #include\n"
-           "struct _mystruct_s { int x; };\n"
-           "static mystruct_t result_struct = { 42 };\n"
-           "mystruct_t *ff6(void) { return &result_struct; }\n"
-           "int ff6b(mystruct_t *p) { return p->x; }")
-    p = lib.ff6()
-    assert ffi.cast("int *", p)[0] == 42
-    assert lib.ff6b(p) == 42
-
-def test_include_7():
-    ffi1 = FFI()
-    ffi1.cdef("typedef ... mystruct_t;\n"
-              "int ff7b(mystruct_t *);")
-    verify(ffi1, "test_include_7_parent",
-           "typedef struct { int x; } mystruct_t;\n"
-           "int ff7b(mystruct_t *p) { return p->x; }")
-    ffi = FFI()
-    ffi.include(ffi1)
-    ffi.cdef("mystruct_t *ff7(void);")
-    lib = verify(ffi, "test_include_7",
-           "typedef struct { int x; } mystruct_t; //usually from a #include\n"
-           "static mystruct_t result_struct = { 42 };"
-           "mystruct_t *ff7(void) { return &result_struct; }")
-    p = lib.ff7()
-    assert ffi.cast("int *", p)[0] == 42
-    assert lib.ff7b(p) == 42
-
-def test_include_8():
-    ffi1 = FFI()
-    ffi1.cdef("struct foo_s;")
-    verify(ffi1, "test_include_8_parent", "struct foo_s;")
-    ffi = FFI()
-    ffi.include(ffi1)
-    ffi.cdef("struct foo_s { int x, y; };")
-    verify(ffi, "test_include_8", "struct foo_s { int x, y; };")
-    e = py.test.raises(NotImplementedError, ffi.new, "struct foo_s *")
-    assert str(e.value) == (
-        "'struct foo_s' is opaque in the ffi.include(), but no longer in "
-        "the ffi doing the include (workaround: don't use ffi.include() but"
-        " duplicate the declarations of everything using struct foo_s)")
-
-def test_unicode_libraries():
-    try:
-        unicode
-    except NameError:
-        py.test.skip("for python 2.x")
-    #
-    import math
-    lib_m = "m"
-    if sys.platform == 'win32':
-        #there is a small chance this fails on Mingw via environ $CC
-        import distutils.ccompiler
-        if distutils.ccompiler.get_default_compiler() == 'msvc':
-            lib_m = 'msvcrt'
-    ffi = FFI()
-    ffi.cdef(unicode("float sin(double); double cos(double);"))
-    lib = verify(ffi, 'test_math_sin_unicode', unicode('#include <math.h>'),
-                 libraries=[unicode(lib_m)])
-    assert lib.cos(1.43) == math.cos(1.43)
-
-def test_incomplete_struct_as_arg():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int x; ...; }; int f(int, struct foo_s);")
-    lib = verify(ffi, "test_incomplete_struct_as_arg",
-                 "struct foo_s { int a, x, z; };\n"
-                 "int f(int b, struct foo_s s) { return s.x * b; }")
-    s = ffi.new("struct foo_s *", [21])
-    assert s.x == 21
-    assert ffi.sizeof(s[0]) == 12
-    assert ffi.offsetof(ffi.typeof(s), 'x') == 4
-    assert lib.f(2, s[0]) == 42
-    assert ffi.typeof(lib.f) == ffi.typeof("int(*)(int, struct foo_s)")
-
-def test_incomplete_struct_as_result():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int x; ...; }; struct foo_s f(int);")
-    lib = verify(ffi, "test_incomplete_struct_as_result",
-            "struct foo_s { int a, x, z; };\n"
-            "struct foo_s f(int x) { struct foo_s r; r.x = x * 2; return r; }")
-    s = lib.f(21)
-    assert s.x == 42
-    assert ffi.typeof(lib.f) == ffi.typeof("struct foo_s(*)(int)")
-
-def test_incomplete_struct_as_both():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int x; ...; }; struct bar_s { int y; ...; };\n"
-             "struct foo_s f(int, struct bar_s);")
-    lib = verify(ffi, "test_incomplete_struct_as_both",
-            "struct foo_s { int a, x, z; };\n"
-            "struct bar_s { int b, c, y, d; };\n"
-            "struct foo_s f(int x, struct bar_s b) {\n"
-            "  struct foo_s r; r.x = x * b.y; return r;\n"
-            "}")
-    b = ffi.new("struct bar_s *", [7])
-    s = lib.f(6, b[0])
-    assert s.x == 42
-    assert ffi.typeof(lib.f) == ffi.typeof(
-        "struct foo_s(*)(int, struct bar_s)")
-    s = lib.f(14, {'y': -3})
-    assert s.x == -42
-
-def test_name_of_unnamed_struct():
-    ffi = FFI()
-    ffi.cdef("typedef struct { int x; } foo_t;\n"
-             "typedef struct { int y; } *bar_p;\n"
-             "typedef struct { int y; } **baz_pp;\n")
-    verify(ffi, "test_name_of_unnamed_struct",
-             "typedef struct { int x; } foo_t;\n"
-             "typedef struct { int y; } *bar_p;\n"
-             "typedef struct { int y; } **baz_pp;\n")
-    assert repr(ffi.typeof("foo_t")) == "<ctype 'foo_t'>"
-    assert repr(ffi.typeof("bar_p")) == "<ctype 'struct $1 *'>"
-    assert repr(ffi.typeof("baz_pp")) == "<ctype 'struct $2 * *'>"
-
-def test_address_of_global_var():
-    ffi = FFI()
-    ffi.cdef("""
-        long bottom, bottoms[2];
-        long FetchRectBottom(void);
-        long FetchRectBottoms1(void);
-        #define FOOBAR 42
-    """)
-    lib = verify(ffi, "test_address_of_global_var", """
-        long bottom, bottoms[2];
-        long FetchRectBottom(void) { return bottom; }
-        long FetchRectBottoms1(void) { return bottoms[1]; }
-        #define FOOBAR 42
-    """)
-    lib.bottom = 300
-    assert lib.FetchRectBottom() == 300
-    lib.bottom += 1
-    assert lib.FetchRectBottom() == 301
-    lib.bottoms[1] = 500
-    assert lib.FetchRectBottoms1() == 500
-    lib.bottoms[1] += 2
-    assert lib.FetchRectBottoms1() == 502
-    #
-    p = ffi.addressof(lib, 'bottom')
-    assert ffi.typeof(p) == ffi.typeof("long *")
-    assert p[0] == 301
-    p[0] += 1
-    assert lib.FetchRectBottom() == 302
-    p = ffi.addressof(lib, 'bottoms')
-    assert ffi.typeof(p) == ffi.typeof("long(*)[2]")
-    assert p[0] == lib.bottoms
-    #
-    py.test.raises(AttributeError, ffi.addressof, lib, 'unknown_var')
-    py.test.raises(AttributeError, ffi.addressof, lib, "FOOBAR")
-
-def test_defines__CFFI_():
-    # Check that we define the macro _CFFI_ automatically.
-    # It should be done before including Python.h, so that PyPy's Python.h
-    # can check for it.
-    ffi = FFI()
-    ffi.cdef("""
-        #define CORRECT 1
-    """)
-    lib = verify(ffi, "test_defines__CFFI_", """
-    #ifdef _CFFI_
-    #    define CORRECT 1
-    #endif
-    """)
-    assert lib.CORRECT == 1
-
-def test_unpack_args():
-    ffi = FFI()
-    ffi.cdef("void foo0(void); void foo1(int); void foo2(int, int);")
-    lib = verify(ffi, "test_unpack_args", """
-    void foo0(void) { }
-    void foo1(int x) { }
-    void foo2(int x, int y) { }
-    """)
-    assert 'foo0' in repr(lib.foo0)
-    assert 'foo1' in repr(lib.foo1)
-    assert 'foo2' in repr(lib.foo2)
-    lib.foo0()
-    lib.foo1(42)
-    lib.foo2(43, 44)
-    e1 = py.test.raises(TypeError, lib.foo0, 42)
-    e2 = py.test.raises(TypeError, lib.foo0, 43, 44)
-    e3 = py.test.raises(TypeError, lib.foo1)
-    e4 = py.test.raises(TypeError, lib.foo1, 43, 44)
-    e5 = py.test.raises(TypeError, lib.foo2)
-    e6 = py.test.raises(TypeError, lib.foo2, 42)
-    e7 = py.test.raises(TypeError, lib.foo2, 45, 46, 47)
-    assert str(e1.value) == "foo0() takes no arguments (1 given)"
-    assert str(e2.value) == "foo0() takes no arguments (2 given)"
-    assert str(e3.value) == "foo1() takes exactly one argument (0 given)"
-    assert str(e4.value) == "foo1() takes exactly one argument (2 given)"
-    assert str(e5.value) == "foo2() takes exactly 2 arguments (0 given)"
-    assert str(e6.value) == "foo2() takes exactly 2 arguments (1 given)"
-    assert str(e7.value) == "foo2() takes exactly 2 arguments (3 given)"
-
-def test_address_of_function():
-    ffi = FFI()
-    ffi.cdef("long myfunc(long x);")
-    lib = verify(ffi, "test_addressof_function", """
-        char myfunc(char x) { return (char)(x + 42); }
-    """)
-    assert lib.myfunc(5) == 47
-    assert lib.myfunc(0xABC05) == 47
-    assert not isinstance(lib.myfunc, ffi.CData)
-    assert ffi.typeof(lib.myfunc) == ffi.typeof("long(*)(long)")
-    addr = ffi.addressof(lib, 'myfunc')
-    assert addr(5) == 47
-    assert addr(0xABC05) == 47
-    assert isinstance(addr, ffi.CData)
-    assert ffi.typeof(addr) == ffi.typeof("long(*)(long)")
-
-def test_address_of_function_with_struct():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int x; }; long myfunc(struct foo_s);")
-    lib = verify(ffi, "test_addressof_function_with_struct", """
-        struct foo_s { int x; };
-        char myfunc(struct foo_s input) { return (char)(input.x + 42); }
-    """)
-    s = ffi.new("struct foo_s *", [5])[0]
-    assert lib.myfunc(s) == 47
-    assert not isinstance(lib.myfunc, ffi.CData)
-    assert ffi.typeof(lib.myfunc) == ffi.typeof("long(*)(struct foo_s)")
-    addr = ffi.addressof(lib, 'myfunc')
-    assert addr(s) == 47
-    assert isinstance(addr, ffi.CData)
-    assert ffi.typeof(addr) == ffi.typeof("long(*)(struct foo_s)")
-
-def test_issue198():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef struct{...;} opaque_t;
-        const opaque_t CONSTANT;
-        int toint(opaque_t);
-    """)
-    lib = verify(ffi, 'test_issue198', """
-        typedef int opaque_t;
-        #define CONSTANT ((opaque_t)42)
-        static int toint(opaque_t o) { return o; }
-    """)
-    def random_stuff():
-        pass
-    assert lib.toint(lib.CONSTANT) == 42
-    random_stuff()
-    assert lib.toint(lib.CONSTANT) == 42
-
-def test_constant_is_not_a_compiler_constant():
-    ffi = FFI()
-    ffi.cdef("static const float almost_forty_two;")
-    lib = verify(ffi, 'test_constant_is_not_a_compiler_constant', """
-        static float f(void) { return 42.25; }
-        #define almost_forty_two (f())
-    """)
-    assert lib.almost_forty_two == 42.25
-
-def test_constant_of_unknown_size():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef ... opaque_t;
-        const opaque_t CONSTANT;
-    """)
-    lib = verify(ffi, 'test_constant_of_unknown_size',
-                 "typedef int opaque_t;"
-                 "const int CONSTANT = 42;")
-    e = py.test.raises(ffi.error, getattr, lib, 'CONSTANT')
-    assert str(e.value) == ("constant 'CONSTANT' is of "
-                            "type 'opaque_t', whose size is not known")
-
-def test_variable_of_unknown_size():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef ... opaque_t;
-        opaque_t globvar;
-    """)
-    lib = verify(ffi, 'test_variable_of_unknown_size', """
-        typedef char opaque_t[6];
-        opaque_t globvar = "hello";
-    """)
-    # can't read or write it at all
-    e = py.test.raises(TypeError, getattr, lib, 'globvar')
-    assert str(e.value) in ["cdata 'opaque_t' is opaque",
-                            "'opaque_t' is opaque or not completed yet"] #pypy
-    e = py.test.raises(TypeError, setattr, lib, 'globvar', [])
-    assert str(e.value) in ["'opaque_t' is opaque",
-                            "'opaque_t' is opaque or not completed yet"] #pypy
-    # but we can get its address
-    p = ffi.addressof(lib, 'globvar')
-    assert ffi.typeof(p) == ffi.typeof('opaque_t *')
-    assert ffi.string(ffi.cast("char *", p), 8) == b"hello"
-
-def test_constant_of_value_unknown_to_the_compiler():
-    extra_c_source = udir.join(
-        'extra_test_constant_of_value_unknown_to_the_compiler.c')
-    extra_c_source.write('const int external_foo = 42;\n')
-    ffi = FFI()
-    ffi.cdef("const int external_foo;")
-    lib = verify(ffi, 'test_constant_of_value_unknown_to_the_compiler', """
-        extern const int external_foo;
-    """, sources=[str(extra_c_source)])
-    assert lib.external_foo == 42
-
-def test_call_with_incomplete_structs():
-    ffi = FFI()
-    ffi.cdef("typedef struct {...;} foo_t; "
-             "foo_t myglob; "
-             "foo_t increment(foo_t s); "
-             "double getx(foo_t s);")
-    lib = verify(ffi, 'test_call_with_incomplete_structs', """
-        typedef double foo_t;
-        double myglob = 42.5;
-        double getx(double x) { return x; }
-        double increment(double x) { return x + 1; }
-    """)
-    assert lib.getx(lib.myglob) == 42.5
-    assert lib.getx(lib.increment(lib.myglob)) == 43.5
-
-def test_struct_array_guess_length_2():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int a[...][...]; };")
-    lib = verify(ffi, 'test_struct_array_guess_length_2',
-                 "struct foo_s { int x; int a[5][8]; int y; };")
-    assert ffi.sizeof('struct foo_s') == 42 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *")
-    assert ffi.sizeof(s.a) == 40 * ffi.sizeof('int')
-    assert s.a[4][7] == 0
-    py.test.raises(IndexError, 's.a[4][8]')
-    py.test.raises(IndexError, 's.a[5][0]')
-    assert ffi.typeof(s.a) == ffi.typeof("int[5][8]")
-    assert ffi.typeof(s.a[0]) == ffi.typeof("int[8]")
-
-def test_struct_array_guess_length_3():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int a[][...]; };")
-    lib = verify(ffi, 'test_struct_array_guess_length_3',
-                 "struct foo_s { int x; int a[5][7]; int y; };")
-    assert ffi.sizeof('struct foo_s') == 37 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *")
-    assert ffi.typeof(s.a) == ffi.typeof("int(*)[7]")
-    assert s.a[4][6] == 0
-    py.test.raises(IndexError, 's.a[4][7]')
-    assert ffi.typeof(s.a[0]) == ffi.typeof("int[7]")
-
-def test_global_var_array_2():
-    ffi = FFI()
-    ffi.cdef("int a[...][...];")
-    lib = verify(ffi, 'test_global_var_array_2', 'int a[10][8];')
-    lib.a[9][7] = 123456
-    assert lib.a[9][7] == 123456
-    py.test.raises(IndexError, 'lib.a[0][8]')
-    py.test.raises(IndexError, 'lib.a[10][0]')
-    assert ffi.typeof(lib.a) == ffi.typeof("int[10][8]")
-    assert ffi.typeof(lib.a[0]) == ffi.typeof("int[8]")
-
-def test_global_var_array_3():
-    ffi = FFI()
-    ffi.cdef("int a[][...];")
-    lib = verify(ffi, 'test_global_var_array_3', 'int a[10][8];')
-    lib.a[9][7] = 123456
-    assert lib.a[9][7] == 123456
-    py.test.raises(IndexError, 'lib.a[0][8]')
-    assert ffi.typeof(lib.a) == ffi.typeof("int(*)[8]")
-    assert ffi.typeof(lib.a[0]) == ffi.typeof("int[8]")
-
-def test_global_var_array_4():
-    ffi = FFI()
-    ffi.cdef("int a[10][...];")
-    lib = verify(ffi, 'test_global_var_array_4', 'int a[10][8];')
-    lib.a[9][7] = 123456
-    assert lib.a[9][7] == 123456
-    py.test.raises(IndexError, 'lib.a[0][8]')
-    py.test.raises(IndexError, 'lib.a[10][8]')
-    assert ffi.typeof(lib.a) == ffi.typeof("int[10][8]")
-    assert ffi.typeof(lib.a[0]) == ffi.typeof("int[8]")
-
-def test_some_integer_type():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef int... foo_t;
-        typedef unsigned long... bar_t;
-        typedef struct { foo_t a, b; } mystruct_t;
-        foo_t foobar(bar_t, mystruct_t);
-        static const bar_t mu = -20;
-        static const foo_t nu = 20;
-    """)
-    lib = verify(ffi, 'test_some_integer_type', """
-        typedef unsigned long long foo_t;
-        typedef short bar_t;
-        typedef struct { foo_t a, b; } mystruct_t;
-        static foo_t foobar(bar_t x, mystruct_t s) {
-            return (foo_t)x + s.a + s.b;
-        }
-        static const bar_t mu = -20;
-        static const foo_t nu = 20;
-    """)
-    assert ffi.sizeof("foo_t") == ffi.sizeof("unsigned long long")
-    assert ffi.sizeof("bar_t") == ffi.sizeof("short")
-    maxulonglong = 2 ** 64 - 1
-    assert int(ffi.cast("foo_t", -1)) == maxulonglong
-    assert int(ffi.cast("bar_t", -1)) == -1
-    assert lib.foobar(-1, [0, 0]) == maxulonglong
-    assert lib.foobar(2 ** 15 - 1, [0, 0]) == 2 ** 15 - 1
-    assert lib.foobar(10, [20, 31]) == 61
-    assert lib.foobar(0, [0, maxulonglong]) == maxulonglong
-    py.test.raises(OverflowError, lib.foobar, 2 ** 15, [0, 0])
-    py.test.raises(OverflowError, lib.foobar, -(2 ** 15) - 1, [0, 0])
-    py.test.raises(OverflowError, ffi.new, "mystruct_t *", [0, -1])
-    assert lib.mu == -20
-    assert lib.nu == 20
-
-def test_some_float_type():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef double... foo_t;
-        typedef float... bar_t;
-        foo_t sum(foo_t[]);
-        bar_t neg(bar_t);
-        """)
-    lib = verify(ffi, 'test_some_float_type', """
-        typedef float foo_t;
-        static foo_t sum(foo_t x[]) { return x[0] + x[1]; }
-        typedef double bar_t;
-        static double neg(double x) { return -x; }
-    """)
-    assert lib.sum([40.0, 2.25]) == 42.25
-    assert lib.sum([12.3, 45.6]) != 12.3 + 45.6     # precision loss
-    assert lib.neg(12.3) == -12.3                   # no precision loss
-    assert ffi.sizeof("foo_t") == ffi.sizeof("float")
-    assert ffi.sizeof("bar_t") == ffi.sizeof("double")
-
-def test_some_float_invalid_1():
-    ffi = FFI()
-    py.test.raises(FFIError, ffi.cdef, "typedef long double... foo_t;")
-
-def test_some_float_invalid_2():
-    ffi = FFI()
-    ffi.cdef("typedef double... foo_t; foo_t neg(foo_t);")
-    lib = verify(ffi, 'test_some_float_invalid_2', """
-        typedef unsigned long foo_t;
-        foo_t neg(foo_t x) { return -x; }
-    """)
-    e = py.test.raises(ffi.error, getattr, lib, 'neg')
-    assert str(e.value) == ("primitive floating-point type with an unexpected "
-                            "size (or not a float type at all)")
-
-def test_some_float_invalid_3():
-    ffi = FFI()
-    ffi.cdef("typedef double... foo_t; foo_t neg(foo_t);")
-    lib = verify(ffi, 'test_some_float_invalid_3', """
-        typedef long double foo_t;
-        foo_t neg(foo_t x) { return -x; }
-    """)
-    if ffi.sizeof("long double") == ffi.sizeof("double"):
-        assert lib.neg(12.3) == -12.3
-    else:
-        e = py.test.raises(ffi.error, getattr, lib, 'neg')
-        assert str(e.value) == ("primitive floating-point type is "
-                                "'long double', not supported for now with "
-                                "the syntax 'typedef double... xxx;'")
-
-def test_issue200():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef void (function_t)(void*);
-        void function(void *);
-    """)
-    lib = verify(ffi, 'test_issue200', """
-        static void function(void *p) { (void)p; }
-    """)
-    ffi.typeof('function_t*')
-    lib.function(ffi.NULL)
-    # assert did not crash
-
-def test_alignment_of_longlong():
-    ffi = FFI()
-    x1 = ffi.alignof('unsigned long long')
-    assert x1 in [4, 8]
-    ffi.cdef("struct foo_s { unsigned long long x; };")
-    lib = verify(ffi, 'test_alignment_of_longlong',
-                 "struct foo_s { unsigned long long x; };")
-    assert ffi.alignof('unsigned long long') == x1
-    assert ffi.alignof('struct foo_s') == x1
-
-def test_import_from_lib():
-    ffi = FFI()
-    ffi.cdef("int mybar(int); int myvar;\n#define MYFOO ...")
-    lib = verify(ffi, 'test_import_from_lib',
-                 "#define MYFOO 42\n"
-                 "static int mybar(int x) { return x + 1; }\n"
-                 "static int myvar = -5;")
-    assert sys.modules['_CFFI_test_import_from_lib'].lib is lib
-    assert sys.modules['_CFFI_test_import_from_lib.lib'] is lib
-    from _CFFI_test_import_from_lib.lib import MYFOO
-    assert MYFOO == 42
-    assert hasattr(lib, '__dict__')
-    assert lib.__all__ == ['MYFOO', 'mybar']   # but not 'myvar'
-    assert lib.__name__ == repr(lib)
-
-def test_macro_var_callback():
-    ffi = FFI()
-    ffi.cdef("int my_value; int *(*get_my_value)(void);")
-    lib = verify(ffi, 'test_macro_var_callback',
-                 "int *(*get_my_value)(void);\n"
-                 "#define my_value (*get_my_value())")
-    #
-    values = ffi.new("int[50]")
-    def it():
-        for i in range(50):
-            yield i
-    it = it()
-    #
-    @ffi.callback("int *(*)(void)")
-    def get_my_value():
-        for nextvalue in it:
-            return values + nextvalue
-    lib.get_my_value = get_my_value
-    #
-    values[0] = 41
-    assert lib.my_value == 41            # [0]
-    p = ffi.addressof(lib, 'my_value')   # [1]
-    assert p == values + 1
-    assert p[-1] == 41
-    assert p[+1] == 0
-    lib.my_value = 42                    # [2]
-    assert values[2] == 42
-    assert p[-1] == 41
-    assert p[+1] == 42
-    #
-    # if get_my_value raises or returns nonsense, the exception is printed
-    # to stderr like with any callback, but then the C expression 'my_value'
-    # expand to '*NULL'.  We assume here that '&my_value' will return NULL
-    # without segfaulting, and check for NULL when accessing the variable.
-    @ffi.callback("int *(*)(void)")
-    def get_my_value():
-        raise LookupError
-    lib.get_my_value = get_my_value
-    py.test.raises(ffi.error, getattr, lib, 'my_value')
-    py.test.raises(ffi.error, setattr, lib, 'my_value', 50)
-    py.test.raises(ffi.error, ffi.addressof, lib, 'my_value')
-    @ffi.callback("int *(*)(void)")
-    def get_my_value():
-        return "hello"
-    lib.get_my_value = get_my_value
-    py.test.raises(ffi.error, getattr, lib, 'my_value')
-    e = py.test.raises(ffi.error, setattr, lib, 'my_value', 50)
-    assert str(e.value) == "global variable 'my_value' is at address NULL"
-
-def test_const_fields():
-    ffi = FFI()
-    ffi.cdef("""struct foo_s { const int a; void *const b; };""")
-    lib = verify(ffi, 'test_const_fields', """
-        struct foo_s { const int a; void *const b; };""")
-    foo_s = ffi.typeof("struct foo_s")
-    assert foo_s.fields[0][0] == 'a'
-    assert foo_s.fields[0][1].type is ffi.typeof("int")
-    assert foo_s.fields[1][0] == 'b'
-    assert foo_s.fields[1][1].type is ffi.typeof("void *")
-
-def test_restrict_fields():
-    ffi = FFI()
-    ffi.cdef("""struct foo_s { void * restrict b; };""")
-    lib = verify(ffi, 'test_restrict_fields', """
-        struct foo_s { void * __restrict b; };""")
-    foo_s = ffi.typeof("struct foo_s")
-    assert foo_s.fields[0][0] == 'b'
-    assert foo_s.fields[0][1].type is ffi.typeof("void *")
-
-def test_volatile_fields():
-    ffi = FFI()
-    ffi.cdef("""struct foo_s { void * volatile b; };""")
-    lib = verify(ffi, 'test_volatile_fields', """
-        struct foo_s { void * volatile b; };""")
-    foo_s = ffi.typeof("struct foo_s")
-    assert foo_s.fields[0][0] == 'b'
-    assert foo_s.fields[0][1].type is ffi.typeof("void *")
-
-def test_const_array_fields():
-    ffi = FFI()
-    ffi.cdef("""struct foo_s { const int a[4]; };""")
-    lib = verify(ffi, 'test_const_array_fields', """
-        struct foo_s { const int a[4]; };""")
-    foo_s = ffi.typeof("struct foo_s")
-    assert foo_s.fields[0][0] == 'a'
-    assert foo_s.fields[0][1].type is ffi.typeof("int[4]")
-
-def test_const_array_fields_varlength():
-    ffi = FFI()
-    ffi.cdef("""struct foo_s { const int a[]; ...; };""")
-    lib = verify(ffi, 'test_const_array_fields_varlength', """
-        struct foo_s { const int a[4]; };""")
-    foo_s = ffi.typeof("struct foo_s")
-    assert foo_s.fields[0][0] == 'a'
-    assert foo_s.fields[0][1].type is ffi.typeof("int[]")
-
-def test_const_array_fields_unknownlength():
-    ffi = FFI()
-    ffi.cdef("""struct foo_s { const int a[...]; ...; };""")
-    lib = verify(ffi, 'test_const_array_fields_unknownlength', """
-        struct foo_s { const int a[4]; };""")
-    foo_s = ffi.typeof("struct foo_s")
-    assert foo_s.fields[0][0] == 'a'
-    assert foo_s.fields[0][1].type is ffi.typeof("int[4]")
-
-def test_const_function_args():
-    ffi = FFI()
-    ffi.cdef("""int foobar(const int a, const int *b, const int c[]);""")
-    lib = verify(ffi, 'test_const_function_args', """
-        int foobar(const int a, const int *b, const int c[]) {
-            return a + *b + *c;
-        }
-    """)
-    assert lib.foobar(100, ffi.new("int *", 40), ffi.new("int *", 2)) == 142
-
-def test_const_function_type_args():
-    ffi = FFI()
-    ffi.cdef("""int (*foobar)(const int a, const int *b, const int c[]);""")
-    lib = verify(ffi, 'test_const_function_type_args', """
-        int (*foobar)(const int a, const int *b, const int c[]);
-    """)
-    t = ffi.typeof(lib.foobar)
-    assert t.args[0] is ffi.typeof("int")
-    assert t.args[1] is ffi.typeof("int *")
-    assert t.args[2] is ffi.typeof("int *")
-
-def test_const_constant():
-    ffi = FFI()
-    ffi.cdef("""struct foo_s { int x,y; }; const struct foo_s myfoo;""")
-    lib = verify(ffi, 'test_const_constant', """
-        struct foo_s { int x,y; }; const struct foo_s myfoo = { 40, 2 };
-    """)
-    assert lib.myfoo.x == 40
-    assert lib.myfoo.y == 2
-
-def test_const_via_typedef():
-    ffi = FFI()
-    ffi.cdef("""typedef const int const_t; const_t aaa;""")
-    lib = verify(ffi, 'test_const_via_typedef', """
-        typedef const int const_t;
-        #define aaa 42
-    """)
-    assert lib.aaa == 42
-    py.test.raises(AttributeError, "lib.aaa = 43")
-
-def test_win32_calling_convention_0():
-    ffi = FFI()
-    ffi.cdef("""
-        int call1(int(__cdecl   *cb)(int));
-        int (*const call2)(int(__stdcall *cb)(int));
-    """)
-    lib = verify(ffi, 'test_win32_calling_convention_0', r"""
-        #ifndef _MSC_VER
-        #  define __stdcall  /* nothing */
-        #endif
-        int call1(int(*cb)(int)) {
-            int i, result = 0;
-            //printf("call1: cb = %p\n", cb);
-            for (i = 0; i < 1000; i++)
-                result += cb(i);
-            //printf("result = %d\n", result);
-            return result;
-        }
-        int call2(int(__stdcall *cb)(int)) {
-            int i, result = 0;
-            //printf("call2: cb = %p\n", cb);
-            for (i = 0; i < 1000; i++)
-                result += cb(-i);
-            //printf("result = %d\n", result);
-            return result;
-        }
-    """)
-    @ffi.callback("int(int)")
-    def cb1(x):
-        return x * 2
-    @ffi.callback("int __stdcall(int)")
-    def cb2(x):
-        return x * 3
-    res = lib.call1(cb1)
-    assert res == 500*999*2
-    assert res == ffi.addressof(lib, 'call1')(cb1)
-    res = lib.call2(cb2)
-    assert res == -500*999*3
-    assert res == ffi.addressof(lib, 'call2')(cb2)
-    if sys.platform == 'win32' and not sys.maxsize > 2**32:
-        assert '__stdcall' in str(ffi.typeof(cb2))
-        assert '__stdcall' not in str(ffi.typeof(cb1))
-        py.test.raises(TypeError, lib.call1, cb2)
-        py.test.raises(TypeError, lib.call2, cb1)
-    else:
-        assert '__stdcall' not in str(ffi.typeof(cb2))
-        assert ffi.typeof(cb2) is ffi.typeof(cb1)
-
-def test_win32_calling_convention_1():
-    ffi = FFI()
-    ffi.cdef("""
-        int __cdecl   call1(int(__cdecl   *cb)(int));
-        int __stdcall call2(int(__stdcall *cb)(int));
-        int (__cdecl   *const cb1)(int);
-        int (__stdcall *const cb2)(int);
-    """)
-    lib = verify(ffi, 'test_win32_calling_convention_1', r"""
-        #ifndef _MSC_VER
-        #  define __cdecl
-        #  define __stdcall
-        #endif
-        int __cdecl   cb1(int x) { return x * 2; }
-        int __stdcall cb2(int x) { return x * 3; }
-
-        int __cdecl call1(int(__cdecl *cb)(int)) {
-            int i, result = 0;
-            //printf("here1\n");
-            //printf("cb = %p, cb1 = %p\n", cb, (void *)cb1);
-            for (i = 0; i < 1000; i++)
-                result += cb(i);
-            //printf("result = %d\n", result);
-            return result;
-        }
-        int __stdcall call2(int(__stdcall *cb)(int)) {
-            int i, result = 0;
-            //printf("here1\n");
-            //printf("cb = %p, cb2 = %p\n", cb, (void *)cb2);
-            for (i = 0; i < 1000; i++)
-                result += cb(-i);
-            //printf("result = %d\n", result);
-            return result;
-        }
-    """)
-    #print '<<< cb1 =', ffi.addressof(lib, 'cb1')
-    ptr_call1 = ffi.addressof(lib, 'call1')
-    assert lib.call1(ffi.addressof(lib, 'cb1')) == 500*999*2
-    assert ptr_call1(ffi.addressof(lib, 'cb1')) == 500*999*2
-    #print '<<< cb2 =', ffi.addressof(lib, 'cb2')
-    ptr_call2 = ffi.addressof(lib, 'call2')
-    assert lib.call2(ffi.addressof(lib, 'cb2')) == -500*999*3
-    assert ptr_call2(ffi.addressof(lib, 'cb2')) == -500*999*3
-    #print '<<< done'
-
-def test_win32_calling_convention_2():
-    # any mistake in the declaration of plain function (including the
-    # precise argument types and, here, the calling convention) are
-    # automatically corrected.  But this does not apply to the 'cb'
-    # function pointer argument.
-    ffi = FFI()
-    ffi.cdef("""
-        int __stdcall call1(int(__cdecl   *cb)(int));
-        int __cdecl   call2(int(__stdcall *cb)(int));
-        int (__cdecl   *const cb1)(int);
-        int (__stdcall *const cb2)(int);
-    """)
-    lib = verify(ffi, 'test_win32_calling_convention_2', """
-        #ifndef _MSC_VER
-        #  define __cdecl
-        #  define __stdcall
-        #endif
-        int __cdecl call1(int(__cdecl *cb)(int)) {
-            int i, result = 0;
-            for (i = 0; i < 1000; i++)
-                result += cb(i);
-            return result;
-        }
-        int __stdcall call2(int(__stdcall *cb)(int)) {
-            int i, result = 0;
-            for (i = 0; i < 1000; i++)
-                result += cb(-i);
-            return result;
-        }
-        int __cdecl   cb1(int x) { return x * 2; }
-        int __stdcall cb2(int x) { return x * 3; }
-    """)
-    ptr_call1 = ffi.addressof(lib, 'call1')
-    ptr_call2 = ffi.addressof(lib, 'call2')
-    if sys.platform == 'win32' and not sys.maxsize > 2**32:
-        py.test.raises(TypeError, lib.call1, ffi.addressof(lib, 'cb2'))
-        py.test.raises(TypeError, ptr_call1, ffi.addressof(lib, 'cb2'))
-        py.test.raises(TypeError, lib.call2, ffi.addressof(lib, 'cb1'))
-        py.test.raises(TypeError, ptr_call2, ffi.addressof(lib, 'cb1'))
-    assert lib.call1(ffi.addressof(lib, 'cb1')) == 500*999*2
-    assert ptr_call1(ffi.addressof(lib, 'cb1')) == 500*999*2
-    assert lib.call2(ffi.addressof(lib, 'cb2')) == -500*999*3
-    assert ptr_call2(ffi.addressof(lib, 'cb2')) == -500*999*3
-
-def test_win32_calling_convention_3():
-    ffi = FFI()
-    ffi.cdef("""
-        struct point { int x, y; };
-
-        int (*const cb1)(struct point);
-        int (__stdcall *const cb2)(struct point);
-
-        struct point __stdcall call1(int(*cb)(struct point));
-        struct point call2(int(__stdcall *cb)(struct point));
-    """)
-    lib = verify(ffi, 'test_win32_calling_convention_3', r"""
-        #ifndef _MSC_VER
-        #  define __cdecl
-        #  define __stdcall
-        #endif
-        struct point { int x, y; };
-        int           cb1(struct point pt) { return pt.x + 10 * pt.y; }
-        int __stdcall cb2(struct point pt) { return pt.x + 100 * pt.y; }
-        struct point __stdcall call1(int(__cdecl *cb)(struct point)) {
-            int i;
-            struct point result = { 0, 0 };
-            //printf("here1\n");
-            //printf("cb = %p, cb1 = %p\n", cb, (void *)cb1);
-            for (i = 0; i < 1000; i++) {
-                struct point p = { i, -i };
-                int r = cb(p);
-                result.x += r;
-                result.y -= r;
-            }
-            return result;
-        }
-        struct point __cdecl call2(int(__stdcall *cb)(struct point)) {
-            int i;
-            struct point result = { 0, 0 };
-            for (i = 0; i < 1000; i++) {
-                struct point p = { -i, i };
-                int r = cb(p);
-                result.x += r;
-                result.y -= r;
-            }
-            return result;
-        }
-    """)
-    ptr_call1 = ffi.addressof(lib, 'call1')
-    ptr_call2 = ffi.addressof(lib, 'call2')
-    if sys.platform == 'win32' and not sys.maxsize > 2**32:
-        py.test.raises(TypeError, lib.call1, ffi.addressof(lib, 'cb2'))
-        py.test.raises(TypeError, ptr_call1, ffi.addressof(lib, 'cb2'))
-        py.test.raises(TypeError, lib.call2, ffi.addressof(lib, 'cb1'))
-        py.test.raises(TypeError, ptr_call2, ffi.addressof(lib, 'cb1'))
-    pt = lib.call1(ffi.addressof(lib, 'cb1'))
-    assert (pt.x, pt.y) == (-9*500*999, 9*500*999)
-    pt = ptr_call1(ffi.addressof(lib, 'cb1'))
-    assert (pt.x, pt.y) == (-9*500*999, 9*500*999)
-    pt = lib.call2(ffi.addressof(lib, 'cb2'))
-    assert (pt.x, pt.y) == (99*500*999, -99*500*999)
-    pt = ptr_call2(ffi.addressof(lib, 'cb2'))
-    assert (pt.x, pt.y) == (99*500*999, -99*500*999)

+ 0 - 43
desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_unicode_literals.py

@@ -1,43 +0,0 @@
-#
-# ----------------------------------------------
-# WARNING, ALL LITERALS IN THIS FILE ARE UNICODE
-# ----------------------------------------------
-#
-from __future__ import unicode_literals
-#
-#
-#
-from _cffi_backend import FFI
-
-
-def test_cast():
-    ffi = FFI()
-    assert int(ffi.cast("int", 3.14)) == 3        # unicode literal
-
-def test_new():
-    ffi = FFI()
-    assert ffi.new("int[]", [3, 4, 5])[2] == 5    # unicode literal
-
-def test_typeof():
-    ffi = FFI()
-    tp = ffi.typeof("int[51]")                    # unicode literal
-    assert tp.length == 51
-
-def test_sizeof():
-    ffi = FFI()
-    assert ffi.sizeof("int[51]") == 51 * 4        # unicode literal
-
-def test_alignof():
-    ffi = FFI()
-    assert ffi.alignof("int[51]") == 4            # unicode literal
-
-def test_getctype():
-    ffi = FFI()
-    assert ffi.getctype("int**") == "int * *"     # unicode literal
-    assert type(ffi.getctype("int**")) is str
-
-def test_callback():
-    ffi = FFI()
-    cb = ffi.callback("int(int)",                 # unicode literal
-                      lambda x: x + 42)
-    assert cb(5) == 47

+ 0 - 2271
desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_verify1.py

@@ -1,2271 +0,0 @@
-import os, sys, math, py
-from cffi import FFI, FFIError, VerificationError, VerificationMissing, model
-from cffi import recompiler
-from testing.support import *
-import _cffi_backend
-
-lib_m = ['m']
-if sys.platform == 'win32':
-    #there is a small chance this fails on Mingw via environ $CC
-    import distutils.ccompiler
-    if distutils.ccompiler.get_default_compiler() == 'msvc':
-        lib_m = ['msvcrt']
-    extra_compile_args = []      # no obvious -Werror equivalent on MSVC
-else:
-    if (sys.platform == 'darwin' and
-          [int(x) for x in os.uname()[2].split('.')] >= [11, 0, 0]):
-        # assume a standard clang or gcc
-        extra_compile_args = ['-Werror', '-Wall', '-Wextra', '-Wconversion']
-        # special things for clang
-        extra_compile_args.append('-Qunused-arguments')
-    else:
-        # assume a standard gcc
-        extra_compile_args = ['-Werror', '-Wall', '-Wextra', '-Wconversion']
-
-class FFI(FFI):
-    error = _cffi_backend.FFI.error
-    _extra_compile_args = extra_compile_args
-    _verify_counter = 0
-
-    def verify(self, preamble='', *args, **kwds):
-        # HACK to reuse the tests from ../cffi0/test_verify.py
-        FFI._verify_counter += 1
-        module_name = 'verify%d' % FFI._verify_counter
-        try:
-            del self._assigned_source
-        except AttributeError:
-            pass
-        self.set_source(module_name, preamble)
-        return recompiler._verify(self, module_name, preamble, *args,
-                                  extra_compile_args=self._extra_compile_args,
-                                  **kwds)
-
-class FFI_warnings_not_error(FFI):
-    _extra_compile_args = []
-
-
-def test_missing_function(ffi=None):
-    # uses the FFI hacked above with '-Werror'
-    if ffi is None:
-        ffi = FFI()
-    ffi.cdef("void some_completely_unknown_function();")
-    try:
-        lib = ffi.verify()
-    except (VerificationError, OSError, ImportError):
-        pass     # expected case: we get a VerificationError
-    else:
-        # but depending on compiler and loader details, maybe
-        # 'lib' could actually be imported but will fail if we
-        # actually try to call the unknown function...  Hard
-        # to test anything more.
-        pass
-
-def test_missing_function_import_error():
-    # uses the original FFI that just gives a warning during compilation
-    test_missing_function(ffi=FFI_warnings_not_error())
-
-def test_simple_case():
-    ffi = FFI()
-    ffi.cdef("double sin(double x);")
-    lib = ffi.verify('#include <math.h>', libraries=lib_m)
-    assert lib.sin(1.23) == math.sin(1.23)
-
-def _Wconversion(cdef, source, **kargs):
-    if sys.platform == 'win32':
-        py.test.skip("needs GCC or Clang")
-    ffi = FFI()
-    ffi.cdef(cdef)
-    py.test.raises(VerificationError, ffi.verify, source, **kargs)
-    extra_compile_args_orig = extra_compile_args[:]
-    extra_compile_args.remove('-Wconversion')
-    try:
-        lib = ffi.verify(source, **kargs)
-    finally:
-        extra_compile_args[:] = extra_compile_args_orig
-    return lib
-
-def test_Wconversion_unsigned():
-    _Wconversion("unsigned foo(void);",
-                 "int foo(void) { return -1;}")
-
-def test_Wconversion_integer():
-    _Wconversion("short foo(void);",
-                 "long long foo(void) { return 1<<sizeof(short);}")
-
-def test_Wconversion_floating():
-    lib = _Wconversion("float sin(double);",
-                       "#include <math.h>", libraries=lib_m)
-    res = lib.sin(1.23)
-    assert res != math.sin(1.23)     # not exact, because of double->float
-    assert abs(res - math.sin(1.23)) < 1E-5
-
-def test_Wconversion_float2int():
-    _Wconversion("int sinf(float);",
-                 "#include <math.h>", libraries=lib_m)
-
-def test_Wconversion_double2int():
-    _Wconversion("int sin(double);",
-                 "#include <math.h>", libraries=lib_m)
-
-def test_rounding_1():
-    ffi = FFI()
-    ffi.cdef("double sinf(float x);")
-    lib = ffi.verify('#include <math.h>', libraries=lib_m)
-    res = lib.sinf(1.23)
-    assert res != math.sin(1.23)     # not exact, because of double->float
-    assert abs(res - math.sin(1.23)) < 1E-5
-
-def test_rounding_2():
-    ffi = FFI()
-    ffi.cdef("double sin(float x);")
-    lib = ffi.verify('#include <math.h>', libraries=lib_m)
-    res = lib.sin(1.23)
-    assert res != math.sin(1.23)     # not exact, because of double->float
-    assert abs(res - math.sin(1.23)) < 1E-5
-
-def test_strlen_exact():
-    ffi = FFI()
-    ffi.cdef("size_t strlen(const char *s);")
-    lib = ffi.verify("#include <string.h>")
-    assert lib.strlen(b"hi there!") == 9
-
-def test_strlen_approximate():
-    lib = _Wconversion("int strlen(char *s);",
-                       "#include <string.h>")
-    assert lib.strlen(b"hi there!") == 9
-
-def test_return_approximate():
-    for typename in ['short', 'int', 'long', 'long long']:
-        ffi = FFI()
-        ffi.cdef("%s foo(signed char x);" % typename)
-        lib = ffi.verify("signed char foo(signed char x) { return x;}")
-        assert lib.foo(-128) == -128
-        assert lib.foo(+127) == +127
-
-def test_strlen_array_of_char():
-    ffi = FFI()
-    ffi.cdef("size_t strlen(char[]);")
-    lib = ffi.verify("#include <string.h>")
-    assert lib.strlen(b"hello") == 5
-
-def test_longdouble():
-    ffi = FFI()
-    ffi.cdef("long double sinl(long double x);")
-    lib = ffi.verify('#include <math.h>', libraries=lib_m)
-    for input in [1.23,
-                  ffi.cast("double", 1.23),
-                  ffi.cast("long double", 1.23)]:
-        x = lib.sinl(input)
-        assert repr(x).startswith("<cdata 'long double'")
-        assert (float(x) - math.sin(1.23)) < 1E-10
-
-def test_longdouble_precision():
-    # Test that we don't loose any precision of 'long double' when
-    # passing through Python and CFFI.
-    ffi = FFI()
-    ffi.cdef("long double step1(long double x);")
-    SAME_SIZE = ffi.sizeof("long double") == ffi.sizeof("double")
-    lib = ffi.verify("""
-        long double step1(long double x)
-        {
-            return 4*x-x*x;
-        }
-    """)
-    def do(cast_to_double):
-        x = 0.9789
-        for i in range(10000):
-            x = lib.step1(x)
-            if cast_to_double:
-                x = float(x)
-        return float(x)
-
-    more_precise = do(False)
-    less_precise = do(True)
-    if SAME_SIZE:
-        assert more_precise == less_precise
-    else:
-        assert abs(more_precise - less_precise) > 0.1
-        # Check the particular results on Intel
-        import platform
-        if (platform.machine().startswith('i386') or
-            platform.machine().startswith('i486') or
-            platform.machine().startswith('i586') or
-            platform.machine().startswith('i686') or
-            platform.machine().startswith('x86')):
-            assert abs(more_precise - 0.656769) < 0.001
-            assert abs(less_precise - 3.99091) < 0.001
-        else:
-            py.test.skip("don't know the very exact precision of 'long double'")
-
-
-all_primitive_types = model.PrimitiveType.ALL_PRIMITIVE_TYPES
-if sys.platform == 'win32':
-    all_primitive_types = all_primitive_types.copy()
-    del all_primitive_types['ssize_t']
-all_integer_types = sorted(tp for tp in all_primitive_types
-                           if all_primitive_types[tp] == 'i')
-all_float_types = sorted(tp for tp in all_primitive_types
-                            if all_primitive_types[tp] == 'f')
-
-def all_signed_integer_types(ffi):
-    return [x for x in all_integer_types if int(ffi.cast(x, -1)) < 0]
-
-def all_unsigned_integer_types(ffi):
-    return [x for x in all_integer_types if int(ffi.cast(x, -1)) > 0]
-
-
-def test_primitive_category():
-    for typename in all_primitive_types:
-        tp = model.PrimitiveType(typename)
-        C = tp.is_char_type()
-        F = tp.is_float_type()
-        I = tp.is_integer_type()
-        assert C == (typename in ('char', 'wchar_t'))
-        assert F == (typename in ('float', 'double', 'long double'))
-        assert I + F + C == 1      # one and only one of them is true
-
-def test_all_integer_and_float_types():
-    typenames = []
-    for typename in all_primitive_types:
-        if (all_primitive_types[typename] == 'c' or
-            typename == '_Bool' or typename == 'long double'):
-            pass
-        else:
-            typenames.append(typename)
-    #
-    ffi = FFI()
-    ffi.cdef('\n'.join(["%s foo_%s(%s);" % (tp, tp.replace(' ', '_'), tp)
-                       for tp in typenames]))
-    lib = ffi.verify('\n'.join(["%s foo_%s(%s x) { return (%s)(x+1); }" %
-                                (tp, tp.replace(' ', '_'), tp, tp)
-                                for tp in typenames]))
-    for typename in typenames:
-        foo = getattr(lib, 'foo_%s' % typename.replace(' ', '_'))
-        assert foo(42) == 43
-        if sys.version < '3':
-            assert foo(long(44)) == 45
-        assert foo(ffi.cast(typename, 46)) == 47
-        py.test.raises(TypeError, foo, ffi.NULL)
-        #
-        # check for overflow cases
-        if all_primitive_types[typename] == 'f':
-            continue
-        for value in [-2**80, -2**40, -2**20, -2**10, -2**5, -1,
-                      2**5, 2**10, 2**20, 2**40, 2**80]:
-            overflows = int(ffi.cast(typename, value)) != value
-            if overflows:
-                py.test.raises(OverflowError, foo, value)
-            else:
-                assert foo(value) == value + 1
-
-def test_var_signed_integer_types():
-    ffi = FFI()
-    lst = all_signed_integer_types(ffi)
-    csource = "\n".join(["%s somevar_%s;" % (tp, tp.replace(' ', '_'))
-                         for tp in lst])
-    ffi.cdef(csource)
-    lib = ffi.verify(csource)
-    for tp in lst:
-        varname = 'somevar_%s' % tp.replace(' ', '_')
-        sz = ffi.sizeof(tp)
-        max = (1 << (8*sz-1)) - 1
-        min = -(1 << (8*sz-1))
-        setattr(lib, varname, max)
-        assert getattr(lib, varname) == max
-        setattr(lib, varname, min)
-        assert getattr(lib, varname) == min
-        py.test.raises(OverflowError, setattr, lib, varname, max+1)
-        py.test.raises(OverflowError, setattr, lib, varname, min-1)
-
-def test_var_unsigned_integer_types():
-    ffi = FFI()
-    lst = all_unsigned_integer_types(ffi)
-    csource = "\n".join(["%s somevar_%s;" % (tp, tp.replace(' ', '_'))
-                         for tp in lst])
-    ffi.cdef(csource)
-    lib = ffi.verify(csource)
-    for tp in lst:
-        varname = 'somevar_%s' % tp.replace(' ', '_')
-        sz = ffi.sizeof(tp)
-        if tp != '_Bool':
-            max = (1 << (8*sz)) - 1
-        else:
-            max = 1
-        setattr(lib, varname, max)
-        assert getattr(lib, varname) == max
-        setattr(lib, varname, 0)
-        assert getattr(lib, varname) == 0
-        py.test.raises(OverflowError, setattr, lib, varname, max+1)
-        py.test.raises(OverflowError, setattr, lib, varname, -1)
-
-def test_fn_signed_integer_types():
-    ffi = FFI()
-    lst = all_signed_integer_types(ffi)
-    cdefsrc = "\n".join(["%s somefn_%s(%s);" % (tp, tp.replace(' ', '_'), tp)
-                         for tp in lst])
-    ffi.cdef(cdefsrc)
-    verifysrc = "\n".join(["%s somefn_%s(%s x) { return x; }" %
-                           (tp, tp.replace(' ', '_'), tp) for tp in lst])
-    lib = ffi.verify(verifysrc)
-    for tp in lst:
-        fnname = 'somefn_%s' % tp.replace(' ', '_')
-        sz = ffi.sizeof(tp)
-        max = (1 << (8*sz-1)) - 1
-        min = -(1 << (8*sz-1))
-        fn = getattr(lib, fnname)
-        assert fn(max) == max
-        assert fn(min) == min
-        py.test.raises(OverflowError, fn, max + 1)
-        py.test.raises(OverflowError, fn, min - 1)
-
-def test_fn_unsigned_integer_types():
-    ffi = FFI()
-    lst = all_unsigned_integer_types(ffi)
-    cdefsrc = "\n".join(["%s somefn_%s(%s);" % (tp, tp.replace(' ', '_'), tp)
-                         for tp in lst])
-    ffi.cdef(cdefsrc)
-    verifysrc = "\n".join(["%s somefn_%s(%s x) { return x; }" %
-                           (tp, tp.replace(' ', '_'), tp) for tp in lst])
-    lib = ffi.verify(verifysrc)
-    for tp in lst:
-        fnname = 'somefn_%s' % tp.replace(' ', '_')
-        sz = ffi.sizeof(tp)
-        if tp != '_Bool':
-            max = (1 << (8*sz)) - 1
-        else:
-            max = 1
-        fn = getattr(lib, fnname)
-        assert fn(max) == max
-        assert fn(0) == 0
-        py.test.raises(OverflowError, fn, max + 1)
-        py.test.raises(OverflowError, fn, -1)
-
-def test_char_type():
-    ffi = FFI()
-    ffi.cdef("char foo(char);")
-    lib = ffi.verify("char foo(char x) { return ++x; }")
-    assert lib.foo(b"A") == b"B"
-    py.test.raises(TypeError, lib.foo, b"bar")
-    py.test.raises(TypeError, lib.foo, "bar")
-
-def test_wchar_type():
-    ffi = FFI()
-    if ffi.sizeof('wchar_t') == 2:
-        uniexample1 = u+'\u1234'
-        uniexample2 = u+'\u1235'
-    else:
-        uniexample1 = u+'\U00012345'
-        uniexample2 = u+'\U00012346'
-    #
-    ffi.cdef("wchar_t foo(wchar_t);")
-    lib = ffi.verify("wchar_t foo(wchar_t x) { return x+1; }")
-    assert lib.foo(uniexample1) == uniexample2
-
-def test_no_argument():
-    ffi = FFI()
-    ffi.cdef("int foo(void);")
-    lib = ffi.verify("int foo(void) { return 42; }")
-    assert lib.foo() == 42
-
-def test_two_arguments():
-    ffi = FFI()
-    ffi.cdef("int foo(int, int);")
-    lib = ffi.verify("int foo(int a, int b) { return a - b; }")
-    assert lib.foo(40, -2) == 42
-
-def test_macro():
-    ffi = FFI()
-    ffi.cdef("int foo(int, int);")
-    lib = ffi.verify("#define foo(a, b) ((a) * (b))")
-    assert lib.foo(-6, -7) == 42
-
-def test_ptr():
-    ffi = FFI()
-    ffi.cdef("int *foo(int *);")
-    lib = ffi.verify("int *foo(int *a) { return a; }")
-    assert lib.foo(ffi.NULL) == ffi.NULL
-    p = ffi.new("int *", 42)
-    q = ffi.new("int *", 42)
-    assert lib.foo(p) == p
-    assert lib.foo(q) != p
-
-def test_bogus_ptr():
-    ffi = FFI()
-    ffi.cdef("int *foo(int *);")
-    lib = ffi.verify("int *foo(int *a) { return a; }")
-    py.test.raises(TypeError, lib.foo, ffi.new("short *", 42))
-
-
-def test_verify_typedefs():
-    py.test.skip("ignored so far")
-    types = ['signed char', 'unsigned char', 'int', 'long']
-    for cdefed in types:
-        for real in types:
-            ffi = FFI()
-            ffi.cdef("typedef %s foo_t;" % cdefed)
-            if cdefed == real:
-                ffi.verify("typedef %s foo_t;" % real)
-            else:
-                py.test.raises(VerificationError, ffi.verify,
-                               "typedef %s foo_t;" % real)
-
-def test_nondecl_struct():
-    ffi = FFI()
-    ffi.cdef("typedef struct foo_s foo_t; int bar(foo_t *);")
-    lib = ffi.verify("typedef struct foo_s foo_t;\n"
-                     "int bar(foo_t *f) { (void)f; return 42; }\n")
-    assert lib.bar(ffi.NULL) == 42
-
-def test_ffi_full_struct():
-    def check(verified_code):
-        ffi = FFI()
-        ffi.cdef("struct foo_s { char x; int y; long *z; };")
-        ffi.verify(verified_code)
-        ffi.new("struct foo_s *", {})
-
-    check("struct foo_s { char x; int y; long *z; };")
-    #
-    if sys.platform != 'win32':  # XXX fixme: only gives warnings
-        py.test.raises(VerificationError, check,
-            "struct foo_s { char x; int y; int *z; };")
-    #
-    py.test.raises(VerificationError, check,
-        "struct foo_s { int y; long *z; };")     # cdef'ed field x is missing
-    #
-    e = py.test.raises(FFI.error, check,
-                       "struct foo_s { int y; char x; long *z; };")
-    assert str(e.value).startswith(
-        "struct foo_s: wrong offset for field 'x'"
-        " (cdef says 0, but C compiler says 4)")
-    #
-    e = py.test.raises(FFI.error, check,
-        "struct foo_s { char x; int y; long *z; char extra; };")
-    assert str(e.value).startswith(
-        "struct foo_s: wrong total size"
-        " (cdef says %d, but C compiler says %d)" % (
-            8 + FFI().sizeof('long *'),
-            8 + FFI().sizeof('long *') * 2))
-    #
-    # a corner case that we cannot really detect, but where it has no
-    # bad consequences: the size is the same, but there is an extra field
-    # that replaces what is just padding in our declaration above
-    check("struct foo_s { char x, extra; int y; long *z; };")
-    #
-    e = py.test.raises(FFI.error, check,
-        "struct foo_s { char x; short pad; short y; long *z; };")
-    assert str(e.value).startswith(
-        "struct foo_s: wrong size for field 'y'"
-        " (cdef says 4, but C compiler says 2)")
-
-def test_ffi_nonfull_struct():
-    ffi = FFI()
-    ffi.cdef("""
-    struct foo_s {
-       int x;
-       ...;
-    };
-    """)
-    py.test.raises(VerificationMissing, ffi.sizeof, 'struct foo_s')
-    py.test.raises(VerificationMissing, ffi.offsetof, 'struct foo_s', 'x')
-    py.test.raises(VerificationMissing, ffi.new, 'struct foo_s *')
-    ffi.verify("""
-    struct foo_s {
-       int a, b, x, c, d, e;
-    };
-    """)
-    assert ffi.sizeof('struct foo_s') == 6 * ffi.sizeof('int')
-    assert ffi.offsetof('struct foo_s', 'x') == 2 * ffi.sizeof('int')
-
-def test_ffi_nonfull_alignment():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { char x; ...; };")
-    ffi.verify("struct foo_s { int a, b; char x; };")
-    assert ffi.sizeof('struct foo_s') == 3 * ffi.sizeof('int')
-    assert ffi.alignof('struct foo_s') == ffi.sizeof('int')
-
-def _check_field_match(typename, real, expect_mismatch):
-    ffi = FFI()
-    testing_by_size = (expect_mismatch == 'by_size')
-    if testing_by_size:
-        expect_mismatch = ffi.sizeof(typename) != ffi.sizeof(real)
-    ffi.cdef("struct foo_s { %s x; ...; };" % typename)
-    try:
-        ffi.verify("struct foo_s { %s x; };" % real)
-        ffi.new("struct foo_s *", [])  # because some mismatches show up lazily
-    except (VerificationError, ffi.error):
-        if not expect_mismatch:
-            if testing_by_size and typename != real:
-                print("ignoring mismatch between %s* and %s* even though "
-                      "they have the same size" % (typename, real))
-                return
-            raise AssertionError("unexpected mismatch: %s should be accepted "
-                                 "as equal to %s" % (typename, real))
-    else:
-        if expect_mismatch:
-            raise AssertionError("mismatch not detected: "
-                                 "%s != %s" % (typename, real))
-
-def test_struct_bad_sized_integer():
-    for typename in ['int8_t', 'int16_t', 'int32_t', 'int64_t']:
-        for real in ['int8_t', 'int16_t', 'int32_t', 'int64_t']:
-            _check_field_match(typename, real, "by_size")
-
-def test_struct_bad_sized_float():
-    for typename in all_float_types:
-        for real in all_float_types:
-            _check_field_match(typename, real, "by_size")
-
-def test_struct_signedness_ignored():
-    _check_field_match("int", "unsigned int", expect_mismatch=False)
-    _check_field_match("unsigned short", "signed short", expect_mismatch=False)
-
-def test_struct_float_vs_int():
-    if sys.platform == 'win32':
-        py.test.skip("XXX fixme: only gives warnings")
-    ffi = FFI()
-    for typename in all_signed_integer_types(ffi):
-        for real in all_float_types:
-            _check_field_match(typename, real, expect_mismatch=True)
-    for typename in all_float_types:
-        for real in all_signed_integer_types(ffi):
-            _check_field_match(typename, real, expect_mismatch=True)
-
-def test_struct_array_field():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int a[17]; ...; };")
-    ffi.verify("struct foo_s { int x; int a[17]; int y; };")
-    assert ffi.sizeof('struct foo_s') == 19 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *")
-    assert ffi.sizeof(s.a) == 17 * ffi.sizeof('int')
-
-def test_struct_array_no_length():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int a[]; int y; ...; };\n"
-             "int bar(struct foo_s *);\n")
-    lib = ffi.verify("struct foo_s { int x; int a[17]; int y; };\n"
-                     "int bar(struct foo_s *f) { return f->a[14]; }\n")
-    assert ffi.sizeof('struct foo_s') == 19 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *")
-    assert ffi.typeof(s.a) is ffi.typeof('int *')   # because no length
-    s.a[14] = 4242
-    assert lib.bar(s) == 4242
-    # with no declared length, out-of-bound accesses are not detected
-    s.a[17] = -521
-    assert s.y == s.a[17] == -521
-    #
-    s = ffi.new("struct foo_s *", {'a': list(range(17))})
-    assert s.a[16] == 16
-    # overflows at construction time not detected either
-    s = ffi.new("struct foo_s *", {'a': list(range(18))})
-    assert s.y == s.a[17] == 17
-
-def test_struct_array_guess_length():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int a[...]; };")
-    ffi.verify("struct foo_s { int x; int a[17]; int y; };")
-    assert ffi.sizeof('struct foo_s') == 19 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *")
-    assert ffi.sizeof(s.a) == 17 * ffi.sizeof('int')
-    py.test.raises(IndexError, 's.a[17]')
-
-def test_struct_array_c99_1():
-    if sys.platform == 'win32':
-        py.test.skip("requires C99")
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int x; int a[]; };")
-    ffi.verify("struct foo_s { int x; int a[]; };")
-    assert ffi.sizeof('struct foo_s') == 1 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *", [424242, 4])
-    assert ffi.sizeof(s[0]) == 1 * ffi.sizeof('int')   # the same in C
-    assert s.a[3] == 0
-    s = ffi.new("struct foo_s *", [424242, [-40, -30, -20, -10]])
-    assert ffi.sizeof(s[0]) == 1 * ffi.sizeof('int')
-    assert s.a[3] == -10
-    s = ffi.new("struct foo_s *")
-    assert ffi.sizeof(s[0]) == 1 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *", [424242])
-    assert ffi.sizeof(s[0]) == 1 * ffi.sizeof('int')
-
-def test_struct_array_c99_2():
-    if sys.platform == 'win32':
-        py.test.skip("requires C99")
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int x; int a[]; ...; };")
-    ffi.verify("struct foo_s { int x, y; int a[]; };")
-    assert ffi.sizeof('struct foo_s') == 2 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *", [424242, 4])
-    assert ffi.sizeof(s[0]) == 2 * ffi.sizeof('int')
-    assert s.a[3] == 0
-    s = ffi.new("struct foo_s *", [424242, [-40, -30, -20, -10]])
-    assert ffi.sizeof(s[0]) == 2 * ffi.sizeof('int')
-    assert s.a[3] == -10
-    s = ffi.new("struct foo_s *")
-    assert ffi.sizeof(s[0]) == 2 * ffi.sizeof('int')
-    s = ffi.new("struct foo_s *", [424242])
-    assert ffi.sizeof(s[0]) == 2 * ffi.sizeof('int')
-
-def test_struct_ptr_to_array_field():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int (*a)[17]; ...; }; struct bar_s { ...; };")
-    ffi.verify("struct foo_s { int x; int (*a)[17]; int y; };\n"
-               "struct bar_s { int x; int *a; int y; };")
-    assert ffi.sizeof('struct foo_s') == ffi.sizeof("struct bar_s")
-    s = ffi.new("struct foo_s *")
-    assert ffi.sizeof(s.a) == ffi.sizeof('int(*)[17]') == ffi.sizeof("int *")
-
-def test_struct_with_bitfield_exact():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int a:2, b:3; };")
-    ffi.verify("struct foo_s { int a:2, b:3; };")
-    s = ffi.new("struct foo_s *")
-    s.b = 3
-    py.test.raises(OverflowError, "s.b = 4")
-    assert s.b == 3
-
-def test_struct_with_bitfield_enum():
-    ffi = FFI()
-    code = """
-        typedef enum { AA, BB, CC } foo_e;
-        typedef struct { foo_e f:2; } foo_s;
-    """
-    ffi.cdef(code)
-    ffi.verify(code)
-    s = ffi.new("foo_s *")
-    s.f = 1
-    assert s.f == 1
-    if int(ffi.cast("foo_e", -1)) < 0:
-        two = -2
-    else:
-        two = 2
-    s.f = two
-    assert s.f == two
-
-def test_unsupported_struct_with_bitfield_ellipsis():
-    ffi = FFI()
-    py.test.raises(NotImplementedError, ffi.cdef,
-                   "struct foo_s { int a:2, b:3; ...; };")
-
-def test_global_constants():
-    ffi = FFI()
-    # use 'static const int', as generally documented, although in this
-    # case the 'static' is completely ignored.
-    ffi.cdef("static const int AA, BB, CC, DD;")
-    lib = ffi.verify("#define AA 42\n"
-                     "#define BB (-43)   // blah\n"
-                     "#define CC (22*2)  /* foobar */\n"
-                     "#define DD ((unsigned int)142)  /* foo\nbar */\n")
-    assert lib.AA == 42
-    assert lib.BB == -43
-    assert lib.CC == 44
-    assert lib.DD == 142
-
-def test_global_const_int_size():
-    # integer constants: ignore the declared type, always just use the value
-    for value in [-2**63, -2**31, -2**15,
-                  2**15-1, 2**15, 2**31-1, 2**31, 2**32-1, 2**32,
-                  2**63-1, 2**63, 2**64-1]:
-        ffi = FFI()
-        if value == int(ffi.cast("long long", value)):
-            if value < 0:
-                vstr = '(-%dLL-1)' % (~value,)
-            else:
-                vstr = '%dLL' % value
-        elif value == int(ffi.cast("unsigned long long", value)):
-            vstr = '%dULL' % value
-        else:
-            raise AssertionError(value)
-        ffi.cdef("static const unsigned short AA;")
-        lib = ffi.verify("#define AA %s\n" % vstr)
-        assert lib.AA == value
-        assert type(lib.AA) is type(int(lib.AA))
-
-def test_global_constants_non_int():
-    ffi = FFI()
-    ffi.cdef("static char *const PP;")
-    lib = ffi.verify('static char *const PP = "testing!";\n')
-    assert ffi.typeof(lib.PP) == ffi.typeof("char *")
-    assert ffi.string(lib.PP) == b"testing!"
-
-def test_nonfull_enum():
-    ffi = FFI()
-    ffi.cdef("enum ee { EE1, EE2, EE3, ... \n \t };")
-    py.test.raises(VerificationMissing, ffi.cast, 'enum ee', 'EE2')
-    ffi.verify("enum ee { EE1=10, EE2, EE3=-10, EE4 };")
-    assert ffi.string(ffi.cast('enum ee', 11)) == "EE2"
-    assert ffi.string(ffi.cast('enum ee', -10)) == "EE3"
-    #
-    # try again
-    ffi.verify("enum ee { EE1=10, EE2, EE3=-10, EE4 };")
-    assert ffi.string(ffi.cast('enum ee', 11)) == "EE2"
-    #
-    assert ffi.typeof("enum ee").relements == {'EE1': 10, 'EE2': 11, 'EE3': -10}
-    assert ffi.typeof("enum ee").elements == {10: 'EE1', 11: 'EE2', -10: 'EE3'}
-
-def test_full_enum():
-    ffi = FFI()
-    ffi.cdef("enum ee { EE1, EE2, EE3 };")
-    ffi.verify("enum ee { EE1, EE2, EE3 };")
-    py.test.raises(VerificationError, ffi.verify, "enum ee { EE1, EE2 };")
-    # disabled: for now, we always accept and fix transparently constant values
-    #e = py.test.raises(VerificationError, ffi.verify,
-    #                   "enum ee { EE1, EE3, EE2 };")
-    #assert str(e.value) == 'enum ee: EE2 has the real value 2, not 1'
-    # extra items cannot be seen and have no bad consequence anyway
-    lib = ffi.verify("enum ee { EE1, EE2, EE3, EE4 };")
-    assert lib.EE3 == 2
-
-def test_enum_usage():
-    ffi = FFI()
-    ffi.cdef("enum ee { EE1,EE2 }; typedef struct { enum ee x; } *sp;")
-    lib = ffi.verify("enum ee { EE1,EE2 }; typedef struct { enum ee x; } *sp;")
-    assert lib.EE2 == 1
-    s = ffi.new("sp", [lib.EE2])
-    assert s.x == 1
-    s.x = 17
-    assert s.x == 17
-
-def test_anonymous_enum():
-    ffi = FFI()
-    ffi.cdef("enum { EE1 }; enum { EE2, EE3 };")
-    lib = ffi.verify("enum { EE1 }; enum { EE2, EE3 };")
-    assert lib.EE1 == 0
-    assert lib.EE2 == 0
-    assert lib.EE3 == 1
-
-def test_nonfull_anonymous_enum():
-    ffi = FFI()
-    ffi.cdef("enum { EE1, ... }; enum { EE3, ... };")
-    lib = ffi.verify("enum { EE2, EE1 }; enum { EE3 };")
-    assert lib.EE1 == 1
-    assert lib.EE3 == 0
-
-def test_nonfull_enum_syntax2():
-    ffi = FFI()
-    ffi.cdef("enum ee { EE1, EE2=\t..., EE3 };")
-    py.test.raises(VerificationMissing, ffi.cast, 'enum ee', 'EE1')
-    ffi.verify("enum ee { EE1=10, EE2, EE3=-10, EE4 };")
-    assert ffi.string(ffi.cast('enum ee', 11)) == 'EE2'
-    assert ffi.string(ffi.cast('enum ee', -10)) == 'EE3'
-    #
-    ffi = FFI()
-    ffi.cdef("enum ee { EE1, EE2=\t... };")
-    py.test.raises(VerificationMissing, ffi.cast, 'enum ee', 'EE1')
-    ffi.verify("enum ee { EE1=10, EE2, EE3=-10, EE4 };")
-    assert ffi.string(ffi.cast('enum ee', 11)) == 'EE2'
-    #
-    ffi = FFI()
-    ffi.cdef("enum ee2 { EE4=..., EE5=..., ... };")
-    ffi.verify("enum ee2 { EE4=-1234-5, EE5 }; ")
-    assert ffi.string(ffi.cast('enum ee2', -1239)) == 'EE4'
-    assert ffi.string(ffi.cast('enum ee2', -1238)) == 'EE5'
-
-def test_get_set_errno():
-    ffi = FFI()
-    ffi.cdef("int foo(int);")
-    lib = ffi.verify("""
-        static int foo(int x)
-        {
-            errno += 1;
-            return x * 7;
-        }
-    """)
-    ffi.errno = 15
-    assert lib.foo(6) == 42
-    assert ffi.errno == 16
-
-def test_define_int():
-    ffi = FFI()
-    ffi.cdef("#define FOO ...\n"
-             "\t#\tdefine\tBAR\t...\t\n"
-             "#define BAZ ...\n")
-    lib = ffi.verify("#define FOO 42\n"
-                     "#define BAR (-44)\n"
-                     "#define BAZ 0xffffffffffffffffULL\n")
-    assert lib.FOO == 42
-    assert lib.BAR == -44
-    assert lib.BAZ == 0xffffffffffffffff
-
-def test_access_variable():
-    ffi = FFI()
-    ffi.cdef("int foo(void);\n"
-             "int somenumber;")
-    lib = ffi.verify("""
-        static int somenumber = 2;
-        static int foo(void) {
-            return somenumber * 7;
-        }
-    """)
-    assert lib.somenumber == 2
-    assert lib.foo() == 14
-    lib.somenumber = -6
-    assert lib.foo() == -42
-    assert lib.somenumber == -6
-    lib.somenumber = 2   # reset for the next run, if any
-
-def test_access_address_of_variable():
-    # access the address of 'somenumber': need a trick
-    ffi = FFI()
-    ffi.cdef("int somenumber; static int *const somenumberptr;")
-    lib = ffi.verify("""
-        static int somenumber = 2;
-        #define somenumberptr (&somenumber)
-    """)
-    assert lib.somenumber == 2
-    lib.somenumberptr[0] = 42
-    assert lib.somenumber == 42
-    lib.somenumber = 2    # reset for the next run, if any
-
-def test_access_array_variable(length=5):
-    ffi = FFI()
-    ffi.cdef("int foo(int);\n"
-             "int somenumber[%s];" % (length,))
-    lib = ffi.verify("""
-        static int somenumber[] = {2, 2, 3, 4, 5};
-        static int foo(int i) {
-            return somenumber[i] * 7;
-        }
-    """)
-    if length == '':
-        # a global variable of an unknown array length is implicitly
-        # transformed into a global pointer variable, because we can only
-        # work with array instances whose length we know.  using a pointer
-        # instead of an array gives the correct effects.
-        assert repr(lib.somenumber).startswith("<cdata 'int *' 0x")
-        py.test.raises(TypeError, len, lib.somenumber)
-    else:
-        assert repr(lib.somenumber).startswith("<cdata 'int[%s]' 0x" % length)
-        assert len(lib.somenumber) == 5
-    assert lib.somenumber[3] == 4
-    assert lib.foo(3) == 28
-    lib.somenumber[3] = -6
-    assert lib.foo(3) == -42
-    assert lib.somenumber[3] == -6
-    assert lib.somenumber[4] == 5
-    lib.somenumber[3] = 4    # reset for the next run, if any
-
-def test_access_array_variable_length_hidden():
-    test_access_array_variable(length='')
-
-def test_access_struct_variable():
-    ffi = FFI()
-    ffi.cdef("struct foo { int x; ...; };\n"
-             "int foo(int);\n"
-             "struct foo stuff;")
-    lib = ffi.verify("""
-        struct foo { int x, y, z; };
-        static struct foo stuff = {2, 5, 8};
-        static int foo(int i) {
-            switch (i) {
-            case 0: return stuff.x * 7;
-            case 1: return stuff.y * 7;
-            case 2: return stuff.z * 7;
-            }
-            return -1;
-        }
-    """)
-    assert lib.stuff.x == 2
-    assert lib.foo(0) == 14
-    assert lib.foo(1) == 35
-    assert lib.foo(2) == 56
-    lib.stuff.x = -6
-    assert lib.foo(0) == -42
-    assert lib.foo(1) == 35
-    lib.stuff.x = 2      # reset for the next run, if any
-
-def test_access_callback():
-    ffi = FFI()
-    ffi.cdef("int (*cb)(int);\n"
-             "int foo(int);\n"
-             "void reset_cb(void);")
-    lib = ffi.verify("""
-        static int g(int x) { return x * 7; }
-        static int (*cb)(int);
-        static int foo(int i) { return cb(i) - 1; }
-        static void reset_cb(void) { cb = g; }
-    """)
-    lib.reset_cb()
-    assert lib.foo(6) == 41
-    my_callback = ffi.callback("int(*)(int)", lambda n: n * 222)
-    lib.cb = my_callback
-    assert lib.foo(4) == 887
-
-def test_access_callback_function_typedef():
-    ffi = FFI()
-    ffi.cdef("typedef int mycallback_t(int);\n"
-             "mycallback_t *cb;\n"
-             "int foo(int);\n"
-             "void reset_cb(void);")
-    lib = ffi.verify("""
-        static int g(int x) { return x * 7; }
-        static int (*cb)(int);
-        static int foo(int i) { return cb(i) - 1; }
-        static void reset_cb(void) { cb = g; }
-    """)
-    lib.reset_cb()
-    assert lib.foo(6) == 41
-    my_callback = ffi.callback("int(*)(int)", lambda n: n * 222)
-    lib.cb = my_callback
-    assert lib.foo(4) == 887
-
-def test_call_with_struct_ptr():
-    ffi = FFI()
-    ffi.cdef("typedef struct { int x; ...; } foo_t; int foo(foo_t *);")
-    lib = ffi.verify("""
-        typedef struct { int y, x; } foo_t;
-        static int foo(foo_t *f) { return f->x * 7; }
-    """)
-    f = ffi.new("foo_t *")
-    f.x = 6
-    assert lib.foo(f) == 42
-
-def test_unknown_type():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef ... token_t;
-        int foo(token_t *);
-        #define TOKEN_SIZE ...
-    """)
-    lib = ffi.verify("""
-        typedef float token_t;
-        static int foo(token_t *tk) {
-            if (!tk)
-                return -42;
-            *tk += 1.601f;
-            return (int)*tk;
-        }
-        #define TOKEN_SIZE sizeof(token_t)
-    """)
-    # we cannot let ffi.new("token_t *") work, because we don't know ahead of
-    # time if it's ok to ask 'sizeof(token_t)' in the C code or not.
-    # See test_unknown_type_2.  Workaround.
-    tkmem = ffi.new("char[]", lib.TOKEN_SIZE)    # zero-initialized
-    tk = ffi.cast("token_t *", tkmem)
-    results = [lib.foo(tk) for i in range(6)]
-    assert results == [1, 3, 4, 6, 8, 9]
-    assert lib.foo(ffi.NULL) == -42
-
-def test_unknown_type_2():
-    ffi = FFI()
-    ffi.cdef("typedef ... token_t;")
-    lib = ffi.verify("typedef struct token_s token_t;")
-    # assert did not crash, even though 'sizeof(token_t)' is not valid in C.
-
-def test_unknown_type_3():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef ... *token_p;
-        token_p foo(token_p);
-    """)
-    lib = ffi.verify("""
-        typedef struct _token_s *token_p;
-        token_p foo(token_p arg) {
-            if (arg)
-                return (token_p)0x12347;
-            else
-                return (token_p)0x12345;
-        }
-    """)
-    p = lib.foo(ffi.NULL)
-    assert int(ffi.cast("intptr_t", p)) == 0x12345
-    q = lib.foo(p)
-    assert int(ffi.cast("intptr_t", q)) == 0x12347
-
-def test_varargs():
-    ffi = FFI()
-    ffi.cdef("int foo(int x, ...);")
-    lib = ffi.verify("""
-        int foo(int x, ...) {
-            va_list vargs;
-            va_start(vargs, x);
-            x -= va_arg(vargs, int);
-            x -= va_arg(vargs, int);
-            va_end(vargs);
-            return x;
-        }
-    """)
-    assert lib.foo(50, ffi.cast("int", 5), ffi.cast("int", 3)) == 42
-
-def test_varargs_exact():
-    if sys.platform == 'win32':
-        py.test.skip("XXX fixme: only gives warnings")
-    ffi = FFI()
-    ffi.cdef("int foo(int x, ...);")
-    py.test.raises(VerificationError, ffi.verify, """
-        int foo(long long x, ...) {
-            return x;
-        }
-    """)
-
-def test_varargs_struct():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { char a; int b; }; int foo(int x, ...);")
-    lib = ffi.verify("""
-        struct foo_s {
-            char a; int b;
-        };
-        int foo(int x, ...) {
-            va_list vargs;
-            struct foo_s s;
-            va_start(vargs, x);
-            s = va_arg(vargs, struct foo_s);
-            va_end(vargs);
-            return s.a - s.b;
-        }
-    """)
-    s = ffi.new("struct foo_s *", [b'B', 1])
-    assert lib.foo(50, s[0]) == ord('A')
-
-def test_autofilled_struct_as_argument():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { long a; double b; ...; };\n"
-             "int foo(struct foo_s);")
-    lib = ffi.verify("""
-        struct foo_s {
-            double b;
-            long a;
-        };
-        int foo(struct foo_s s) {
-            return (int)s.a - (int)s.b;
-        }
-    """)
-    s = ffi.new("struct foo_s *", [100, 1])
-    assert lib.foo(s[0]) == 99
-    assert lib.foo([100, 1]) == 99
-
-def test_autofilled_struct_as_argument_dynamic():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { long a; ...; };\n"
-             "int (*foo)(struct foo_s);")
-    lib = ffi.verify("""
-        struct foo_s {
-            double b;
-            long a;
-        };
-        int foo1(struct foo_s s) {
-            return (int)s.a - (int)s.b;
-        }
-        int (*foo)(struct foo_s s) = &foo1;
-    """)
-    e = py.test.raises(NotImplementedError, lib.foo, "?")
-    msg = ("ctype 'struct foo_s' not supported as argument (it is a struct "
-           'declared with "...;", but the C calling convention may depend '
-           'on the missing fields)')
-    assert str(e.value) == msg
-
-def test_func_returns_struct():
-    ffi = FFI()
-    ffi.cdef("""
-        struct foo_s { int aa, bb; };
-        struct foo_s foo(int a, int b);
-    """)
-    lib = ffi.verify("""
-        struct foo_s { int aa, bb; };
-        struct foo_s foo(int a, int b) {
-            struct foo_s r;
-            r.aa = a*a;
-            r.bb = b*b;
-            return r;
-        }
-    """)
-    s = lib.foo(6, 7)
-    assert repr(s) == "<cdata 'struct foo_s' owning 8 bytes>"
-    assert s.aa == 36
-    assert s.bb == 49
-
-def test_func_as_funcptr():
-    ffi = FFI()
-    ffi.cdef("int *(*const fooptr)(void);")
-    lib = ffi.verify("""
-        int *foo(void) {
-            return (int*)"foobar";
-        }
-        int *(*fooptr)(void) = foo;
-    """)
-    foochar = ffi.cast("char *(*)(void)", lib.fooptr)
-    s = foochar()
-    assert ffi.string(s) == b"foobar"
-
-def test_funcptr_as_argument():
-    ffi = FFI()
-    ffi.cdef("""
-        void qsort(void *base, size_t nel, size_t width,
-            int (*compar)(const void *, const void *));
-    """)
-    ffi.verify("#include <stdlib.h>")
-
-def test_func_as_argument():
-    ffi = FFI()
-    ffi.cdef("""
-        void qsort(void *base, size_t nel, size_t width,
-            int compar(const void *, const void *));
-    """)
-    ffi.verify("#include <stdlib.h>")
-
-def test_array_as_argument():
-    ffi = FFI()
-    ffi.cdef("""
-        size_t strlen(char string[]);
-    """)
-    ffi.verify("#include <string.h>")
-
-def test_enum_as_argument():
-    ffi = FFI()
-    ffi.cdef("""
-        enum foo_e { AA, BB, ... };
-        int foo_func(enum foo_e);
-    """)
-    lib = ffi.verify("""
-        enum foo_e { AA, CC, BB };
-        int foo_func(enum foo_e e) { return (int)e; }
-    """)
-    assert lib.foo_func(lib.BB) == 2
-    py.test.raises(TypeError, lib.foo_func, "BB")
-
-def test_enum_as_function_result():
-    ffi = FFI()
-    ffi.cdef("""
-        enum foo_e { AA, BB, ... };
-        enum foo_e foo_func(int x);
-    """)
-    lib = ffi.verify("""
-        enum foo_e { AA, CC, BB };
-        enum foo_e foo_func(int x) { return (enum foo_e)x; }
-    """)
-    assert lib.foo_func(lib.BB) == lib.BB == 2
-
-def test_enum_values():
-    ffi = FFI()
-    ffi.cdef("enum enum1_e { AA, BB };")
-    lib = ffi.verify("enum enum1_e { AA, BB };")
-    assert lib.AA == 0
-    assert lib.BB == 1
-    assert ffi.string(ffi.cast("enum enum1_e", 1)) == 'BB'
-
-def test_typedef_complete_enum():
-    ffi = FFI()
-    ffi.cdef("typedef enum { AA, BB } enum1_t;")
-    lib = ffi.verify("typedef enum { AA, BB } enum1_t;")
-    assert ffi.string(ffi.cast("enum1_t", 1)) == 'BB'
-    assert lib.AA == 0
-    assert lib.BB == 1
-
-def test_typedef_broken_complete_enum():
-    # xxx this is broken in old cffis, but works with recompiler.py
-    ffi = FFI()
-    ffi.cdef("typedef enum { AA, BB } enum1_t;")
-    lib = ffi.verify("typedef enum { AA, CC, BB } enum1_t;")
-    assert lib.AA == 0
-    assert lib.BB == 2
-
-def test_typedef_incomplete_enum():
-    ffi = FFI()
-    ffi.cdef("typedef enum { AA, BB, ... } enum1_t;")
-    lib = ffi.verify("typedef enum { AA, CC, BB } enum1_t;")
-    assert ffi.string(ffi.cast("enum1_t", 1)) == '1'
-    assert ffi.string(ffi.cast("enum1_t", 2)) == 'BB'
-    assert lib.AA == 0
-    assert lib.BB == 2
-
-def test_typedef_enum_as_argument():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef enum { AA, BB, ... } foo_t;
-        int foo_func(foo_t);
-    """)
-    lib = ffi.verify("""
-        typedef enum { AA, CC, BB } foo_t;
-        int foo_func(foo_t e) { return (int)e; }
-    """)
-    assert lib.foo_func(lib.BB) == lib.BB == 2
-    py.test.raises(TypeError, lib.foo_func, "BB")
-
-def test_typedef_enum_as_function_result():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef enum { AA, BB, ... } foo_t;
-        foo_t foo_func(int x);
-    """)
-    lib = ffi.verify("""
-        typedef enum { AA, CC, BB } foo_t;
-        foo_t foo_func(int x) { return (foo_t)x; }
-    """)
-    assert lib.foo_func(lib.BB) == lib.BB == 2
-
-def test_function_typedef():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef double func_t(double);
-        func_t sin;
-    """)
-    lib = ffi.verify('#include <math.h>', libraries=lib_m)
-    assert lib.sin(1.23) == math.sin(1.23)
-
-def test_opaque_integer_as_function_result():
-    #import platform
-    #if platform.machine().startswith('sparc'):
-    #    py.test.skip('Breaks horribly on sparc (SIGILL + corrupted stack)')
-    #elif platform.machine() == 'mips64' and sys.maxsize > 2**32:
-    #    py.test.skip('Segfaults on mips64el')
-    # XXX bad abuse of "struct { ...; }".  It only works a bit by chance
-    # anyway.  XXX think about something better :-(
-    ffi = FFI()
-    ffi.cdef("""
-        typedef struct { ...; } myhandle_t;
-        myhandle_t foo(void);
-    """)
-    lib = ffi.verify("""
-        typedef short myhandle_t;
-        myhandle_t foo(void) { return 42; }
-    """)
-    h = lib.foo()
-    assert ffi.sizeof(h) == ffi.sizeof("short")
-
-def test_return_partial_struct():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef struct { int x; ...; } foo_t;
-        foo_t foo(void);
-    """)
-    lib = ffi.verify("""
-        typedef struct { int y, x; } foo_t;
-        foo_t foo(void) { foo_t r = { 45, 81 }; return r; }
-    """)
-    h = lib.foo()
-    assert ffi.sizeof(h) == 2 * ffi.sizeof("int")
-    assert h.x == 81
-
-def test_take_and_return_partial_structs():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef struct { int x; ...; } foo_t;
-        foo_t foo(foo_t, foo_t);
-    """)
-    lib = ffi.verify("""
-        typedef struct { int y, x; } foo_t;
-        foo_t foo(foo_t a, foo_t b) {
-            foo_t r = { 100, a.x * 5 + b.x * 7 };
-            return r;
-        }
-    """)
-    args = ffi.new("foo_t[3]")
-    args[0].x = 1000
-    args[2].x = -498
-    h = lib.foo(args[0], args[2])
-    assert ffi.sizeof(h) == 2 * ffi.sizeof("int")
-    assert h.x == 1000 * 5 - 498 * 7
-
-def test_cannot_name_struct_type():
-    ffi = FFI()
-    ffi.cdef("typedef struct { int x; } **sp; void foo(sp);")
-    e = py.test.raises(VerificationError, ffi.verify,
-                       "typedef struct { int x; } **sp; void foo(sp x) { }")
-    assert 'in argument of foo: unknown type name' in str(e.value)
-
-def test_dont_check_unnamable_fields():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { struct { int x; } someone; };")
-    ffi.verify("struct foo_s { struct { int x; } someone; };")
-    # assert did not crash
-
-def test_nested_anonymous_struct_exact():
-    if sys.platform == 'win32':
-        py.test.skip("nested anonymous struct/union")
-    ffi = FFI()
-    ffi.cdef("""
-        struct foo_s { struct { int a; char b; }; union { char c, d; }; };
-    """)
-    assert ffi.offsetof("struct foo_s", "c") == 2 * ffi.sizeof("int")
-    assert ffi.sizeof("struct foo_s") == 3 * ffi.sizeof("int")
-    ffi.verify("""
-        struct foo_s { struct { int a; char b; }; union { char c, d; }; };
-    """)
-    p = ffi.new("struct foo_s *")
-    assert ffi.sizeof(p[0]) == 3 * ffi.sizeof("int")    # with alignment
-    p.a = 1234567
-    p.b = b'X'
-    p.c = b'Y'
-    assert p.a == 1234567
-    assert p.b == b'X'
-    assert p.c == b'Y'
-    assert p.d == b'Y'
-
-def test_nested_anonymous_struct_exact_error():
-    if sys.platform == 'win32':
-        py.test.skip("nested anonymous struct/union")
-    ffi = FFI()
-    ffi.cdef("""
-        struct foo_s { struct { int a; char b; }; union { char c, d; }; };
-    """)
-    py.test.raises(VerificationError, ffi.verify, """
-        struct foo_s { struct { int a; short b; }; union { char c, d; }; };
-    """)
-    # works fine now
-    #py.test.raises(VerificationError, ffi.verify, """
-    #    struct foo_s { struct { int a; char e, b; }; union { char c, d; }; };
-    #""")
-
-def test_nested_anonymous_struct_inexact_1():
-    ffi = FFI()
-    ffi.cdef("""
-        struct foo_s { struct { char b; ...; }; union { char c, d; }; };
-    """)
-    ffi.verify("""
-        struct foo_s { int a, padding; char c, d, b; };
-    """)
-    assert ffi.sizeof("struct foo_s") == 3 * ffi.sizeof("int")
-
-def test_nested_anonymous_struct_inexact_2():
-    ffi = FFI()
-    ffi.cdef("""
-        struct foo_s { union { char c, d; }; struct { int a; char b; }; ...; };
-    """)
-    ffi.verify("""
-        struct foo_s { int a, padding; char c, d, b; };
-    """)
-    assert ffi.sizeof("struct foo_s") == 3 * ffi.sizeof("int")
-
-def test_ffi_union():
-    ffi = FFI()
-    ffi.cdef("union foo_u { char x; long *z; };")
-    ffi.verify("union foo_u { char x; int y; long *z; };")
-
-def test_ffi_union_partial():
-    ffi = FFI()
-    ffi.cdef("union foo_u { char x; ...; };")
-    ffi.verify("union foo_u { char x; int y; };")
-    assert ffi.sizeof("union foo_u") == 4
-
-def test_ffi_union_with_partial_struct():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int x; ...; }; union foo_u { struct foo_s s; };")
-    ffi.verify("struct foo_s { int a; int x; }; "
-               "union foo_u { char b[32]; struct foo_s s; };")
-    assert ffi.sizeof("struct foo_s") == 8
-    assert ffi.sizeof("union foo_u") == 32
-
-def test_ffi_union_partial_2():
-    ffi = FFI()
-    ffi.cdef("typedef union { char x; ...; } u1;")
-    ffi.verify("typedef union { char x; int y; } u1;")
-    assert ffi.sizeof("u1") == 4
-
-def test_ffi_union_with_partial_struct_2():
-    ffi = FFI()
-    ffi.cdef("typedef struct { int x; ...; } s1;"
-             "typedef union { s1 s; } u1;")
-    ffi.verify("typedef struct { int a; int x; } s1; "
-               "typedef union { char b[32]; s1 s; } u1;")
-    assert ffi.sizeof("s1") == 8
-    assert ffi.sizeof("u1") == 32
-    assert ffi.offsetof("u1", "s") == 0
-
-def test_ffi_struct_packed():
-    if sys.platform == 'win32':
-        py.test.skip("needs a GCC extension")
-    ffi = FFI()
-    ffi.cdef("struct foo_s { int b; ...; };")
-    ffi.verify("""
-        struct foo_s {
-            char a;
-            int b;
-        } __attribute__((packed));
-    """)
-
-def test_tmpdir():
-    import tempfile, os
-    from testing.udir import udir
-    tmpdir = tempfile.mkdtemp(dir=str(udir))
-    ffi = FFI()
-    ffi.cdef("int foo(int);")
-    lib = ffi.verify("int foo(int a) { return a + 42; }", tmpdir=tmpdir)
-    assert os.listdir(tmpdir)
-    assert lib.foo(100) == 142
-
-def test_relative_to():
-    py.test.skip("not available")
-    import tempfile, os
-    from testing.udir import udir
-    tmpdir = tempfile.mkdtemp(dir=str(udir))
-    ffi = FFI()
-    ffi.cdef("int foo(int);")
-    f = open(os.path.join(tmpdir, 'foo.h'), 'w')
-    f.write("int foo(int a) { return a + 42; }\n")
-    f.close()
-    lib = ffi.verify('#include "foo.h"',
-                     include_dirs=['.'],
-                     relative_to=os.path.join(tmpdir, 'x'))
-    assert lib.foo(100) == 142
-
-def test_bug1():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef struct tdlhandle_s { ...; } *tdl_handle_t;
-        typedef struct my_error_code_ {
-            tdl_handle_t *rh;
-        } my_error_code_t;
-    """)
-    ffi.verify("""
-        typedef struct tdlhandle_s { int foo; } *tdl_handle_t;
-        typedef struct my_error_code_ {
-            tdl_handle_t *rh;
-        } my_error_code_t;
-    """)
-
-def test_bool():
-    if sys.platform == 'win32':
-        py.test.skip("_Bool not in MSVC")
-    ffi = FFI()
-    ffi.cdef("struct foo_s { _Bool x; };"
-             "_Bool foo(_Bool);")
-    lib = ffi.verify("""
-        struct foo_s { _Bool x; };
-        int foo(int arg) {
-            return !arg;
-        }
-    """)
-    p = ffi.new("struct foo_s *")
-    p.x = 1
-    assert p.x == 1
-    py.test.raises(OverflowError, "p.x = -1")
-    py.test.raises(TypeError, "p.x = 0.0")
-    assert lib.foo(1) == 0
-    assert lib.foo(0) == 1
-    py.test.raises(OverflowError, lib.foo, 42)
-    py.test.raises(TypeError, lib.foo, 0.0)
-    assert int(ffi.cast("_Bool", long(1))) == 1
-    assert int(ffi.cast("_Bool", long(0))) == 0
-    assert int(ffi.cast("_Bool", long(-1))) == 1
-    assert int(ffi.cast("_Bool", 10**200)) == 1
-    assert int(ffi.cast("_Bool", 10**40000)) == 1
-    #
-    class Foo(object):
-        def __int__(self):
-            self.seen = 1
-            return result
-    f = Foo()
-    f.seen = 0
-    result = 42
-    assert int(ffi.cast("_Bool", f)) == 1
-    assert f.seen
-    f.seen = 0
-    result = 0
-    assert int(ffi.cast("_Bool", f)) == 0
-    assert f.seen
-    #
-    py.test.raises(TypeError, ffi.cast, "_Bool", [])
-
-def test_bool_on_long_double():
-    if sys.platform == 'win32':
-        py.test.skip("_Bool not in MSVC")
-    f = 1E-250
-    if f == 0.0 or f*f != 0.0:
-        py.test.skip("unexpected precision")
-    ffi = FFI()
-    ffi.cdef("long double square(long double f); _Bool opposite(_Bool);")
-    lib = ffi.verify("long double square(long double f) { return f*f; }\n"
-                     "_Bool opposite(_Bool x) { return !x; }")
-    f0 = lib.square(0.0)
-    f2 = lib.square(f)
-    f3 = lib.square(f * 2.0)
-    if repr(f2) == repr(f3):
-        py.test.skip("long double doesn't have enough precision")
-    assert float(f0) == float(f2) == float(f3) == 0.0  # too tiny for 'double'
-    assert int(ffi.cast("_Bool", f2)) == 1
-    assert int(ffi.cast("_Bool", f3)) == 1
-    assert int(ffi.cast("_Bool", f0)) == 0
-    py.test.raises(TypeError, lib.opposite, f2)
-
-def test_cannot_pass_float():
-    for basetype in ['char', 'short', 'int', 'long', 'long long']:
-        for sign in ['signed', 'unsigned']:
-            type = '%s %s' % (sign, basetype)
-            ffi = FFI()
-            ffi.cdef("struct foo_s { %s x; };\n"
-                     "int foo(%s);" % (type, type))
-            lib = ffi.verify("""
-                struct foo_s { %s x; };
-                int foo(%s arg) {
-                    return !arg;
-                }
-            """ % (type, type))
-            p = ffi.new("struct foo_s *")
-            py.test.raises(TypeError, "p.x = 0.0")
-            assert lib.foo(42) == 0
-            assert lib.foo(0) == 1
-            py.test.raises(TypeError, lib.foo, 0.0)
-
-def test_addressof():
-    ffi = FFI()
-    ffi.cdef("""
-        struct point_s { int x, y; };
-        struct foo_s { int z; struct point_s point; };
-        struct point_s sum_coord(struct point_s *);
-    """)
-    lib = ffi.verify("""
-        struct point_s { int x, y; };
-        struct foo_s { int z; struct point_s point; };
-        struct point_s sum_coord(struct point_s *point) {
-            struct point_s r;
-            r.x = point->x + point->y;
-            r.y = point->x - point->y;
-            return r;
-        }
-    """)
-    p = ffi.new("struct foo_s *")
-    p.point.x = 16
-    p.point.y = 9
-    py.test.raises(TypeError, lib.sum_coord, p.point)
-    res = lib.sum_coord(ffi.addressof(p.point))
-    assert res.x == 25
-    assert res.y == 7
-    res2 = lib.sum_coord(ffi.addressof(res))
-    assert res2.x == 32
-    assert res2.y == 18
-    py.test.raises(TypeError, lib.sum_coord, res2)
-
-def test_callback_in_thread():
-    py.test.xfail("adapt or remove")
-    if sys.platform == 'win32':
-        py.test.skip("pthread only")
-    import os, subprocess, imp
-    arg = os.path.join(os.path.dirname(__file__), 'callback_in_thread.py')
-    g = subprocess.Popen([sys.executable, arg,
-                          os.path.dirname(imp.find_module('cffi')[1])])
-    result = g.wait()
-    assert result == 0
-
-def test_keepalive_lib():
-    py.test.xfail("adapt or remove")
-    ffi = FFI()
-    ffi.cdef("int foobar(void);")
-    lib = ffi.verify("int foobar(void) { return 42; }")
-    func = lib.foobar
-    ffi_r = weakref.ref(ffi)
-    lib_r = weakref.ref(lib)
-    del ffi
-    import gc; gc.collect()       # lib stays alive
-    assert lib_r() is not None
-    assert ffi_r() is not None
-    assert func() == 42
-
-def test_keepalive_ffi():
-    py.test.xfail("adapt or remove")
-    ffi = FFI()
-    ffi.cdef("int foobar(void);")
-    lib = ffi.verify("int foobar(void) { return 42; }")
-    func = lib.foobar
-    ffi_r = weakref.ref(ffi)
-    lib_r = weakref.ref(lib)
-    del lib
-    import gc; gc.collect()       # ffi stays alive
-    assert ffi_r() is not None
-    assert lib_r() is not None
-    assert func() == 42
-
-def test_FILE_stored_in_stdout():
-    if not sys.platform.startswith('linux'):
-        py.test.skip("likely, we cannot assign to stdout")
-    ffi = FFI()
-    ffi.cdef("int printf(const char *, ...); FILE *setstdout(FILE *);")
-    lib = ffi.verify("""
-        #include <stdio.h>
-        FILE *setstdout(FILE *f) {
-            FILE *result = stdout;
-            stdout = f;
-            return result;
-        }
-    """)
-    import os
-    fdr, fdw = os.pipe()
-    fw1 = os.fdopen(fdw, 'wb', 256)
-    old_stdout = lib.setstdout(fw1)
-    try:
-        #
-        fw1.write(b"X")
-        r = lib.printf(b"hello, %d!\n", ffi.cast("int", 42))
-        fw1.close()
-        assert r == len("hello, 42!\n")
-        #
-    finally:
-        lib.setstdout(old_stdout)
-    #
-    result = os.read(fdr, 256)
-    os.close(fdr)
-    # the 'X' might remain in the user-level buffer of 'fw1' and
-    # end up showing up after the 'hello, 42!\n'
-    assert result == b"Xhello, 42!\n" or result == b"hello, 42!\nX"
-
-def test_FILE_stored_explicitly():
-    ffi = FFI()
-    ffi.cdef("int myprintf11(const char *, int); FILE *myfile;")
-    lib = ffi.verify("""
-        #include <stdio.h>
-        FILE *myfile;
-        int myprintf11(const char *out, int value) {
-            return fprintf(myfile, out, value);
-        }
-    """)
-    import os
-    fdr, fdw = os.pipe()
-    fw1 = os.fdopen(fdw, 'wb', 256)
-    lib.myfile = ffi.cast("FILE *", fw1)
-    #
-    fw1.write(b"X")
-    r = lib.myprintf11(b"hello, %d!\n", ffi.cast("int", 42))
-    fw1.close()
-    assert r == len("hello, 42!\n")
-    #
-    result = os.read(fdr, 256)
-    os.close(fdr)
-    # the 'X' might remain in the user-level buffer of 'fw1' and
-    # end up showing up after the 'hello, 42!\n'
-    assert result == b"Xhello, 42!\n" or result == b"hello, 42!\nX"
-
-def test_global_array_with_missing_length():
-    ffi = FFI()
-    ffi.cdef("int fooarray[];")
-    lib = ffi.verify("int fooarray[50];")
-    assert repr(lib.fooarray).startswith("<cdata 'int *'")
-
-def test_global_array_with_dotdotdot_length():
-    ffi = FFI()
-    ffi.cdef("int fooarray[...];")
-    lib = ffi.verify("int fooarray[50];")
-    assert repr(lib.fooarray).startswith("<cdata 'int[50]'")
-
-def test_bad_global_array_with_dotdotdot_length():
-    py.test.xfail("was detected only because 23 bytes cannot be divided by 4; "
-                  "redo more generally")
-    ffi = FFI()
-    ffi.cdef("int fooarray[...];")
-    py.test.raises(VerificationError, ffi.verify, "char fooarray[23];")
-
-def test_struct_containing_struct():
-    ffi = FFI()
-    ffi.cdef("struct foo_s { ...; }; struct bar_s { struct foo_s f; ...; };")
-    ffi.verify("struct foo_s { int x; }; struct bar_s { struct foo_s f; };")
-    #
-    ffi = FFI()
-    ffi.cdef("struct foo_s { struct bar_s f; ...; }; struct bar_s { ...; };")
-    ffi.verify("struct bar_s { int x; }; struct foo_s { struct bar_s f; };")
-
-def test_struct_returned_by_func():
-    ffi = FFI()
-    ffi.cdef("typedef ... foo_t; foo_t myfunc(void);")
-    e = py.test.raises(TypeError, ffi.verify,
-                       "typedef struct { int x; } foo_t; "
-                       "foo_t myfunc(void) { foo_t x = { 42 }; return x; }")
-    assert str(e.value) == (
-        "function myfunc: 'foo_t' is used as result type, but is opaque")
-
-def test_include():
-    ffi1 = FFI()
-    ffi1.cdef("typedef struct { int x; ...; } foo_t;")
-    ffi1.verify("typedef struct { int y, x; } foo_t;")
-    ffi2 = FFI()
-    ffi2.include(ffi1)
-    ffi2.cdef("int myfunc(foo_t *);")
-    lib = ffi2.verify("typedef struct { int y, x; } foo_t;"
-                      "int myfunc(foo_t *p) { return 42 * p->x; }")
-    res = lib.myfunc(ffi2.new("foo_t *", {'x': 10}))
-    assert res == 420
-    res = lib.myfunc(ffi1.new("foo_t *", {'x': -10}))
-    assert res == -420
-
-def test_include_enum():
-    ffi1 = FFI()
-    ffi1.cdef("enum foo_e { AA, ... };")
-    lib1 = ffi1.verify("enum foo_e { CC, BB, AA };")
-    ffi2 = FFI()
-    ffi2.include(ffi1)
-    ffi2.cdef("int myfunc(enum foo_e);")
-    lib2 = ffi2.verify("enum foo_e { CC, BB, AA };"
-                       "int myfunc(enum foo_e x) { return (int)x; }")
-    res = lib2.myfunc(lib2.AA)
-    assert res == 2
-
-def test_named_pointer_as_argument():
-    ffi = FFI()
-    ffi.cdef("typedef struct { int x; } *mystruct_p;\n"
-             "mystruct_p ff5a(mystruct_p);")
-    lib = ffi.verify("typedef struct { int x; } *mystruct_p;\n"
-                     "mystruct_p ff5a(mystruct_p p) { p->x += 40; return p; }")
-    p = ffi.new("mystruct_p", [-2])
-    q = lib.ff5a(p)
-    assert q == p
-    assert p.x == 38
-
-def test_enum_size():
-    cases = [('123',           4, 4294967295),
-             ('4294967295U',   4, 4294967295),
-             ('-123',          4, -1),
-             ('-2147483647-1', 4, -1),
-             ]
-    if FFI().sizeof("long") == 8:
-        cases += [('4294967296L',        8, 2**64-1),
-                  ('%dUL' % (2**64-1),   8, 2**64-1),
-                  ('-2147483649L',       8, -1),
-                  ('%dL-1L' % (1-2**63), 8, -1)]
-    for hidden_value, expected_size, expected_minus1 in cases:
-        if sys.platform == 'win32' and 'U' in hidden_value:
-            continue   # skipped on Windows
-        ffi = FFI()
-        ffi.cdef("enum foo_e { AA, BB, ... };")
-        lib = ffi.verify("enum foo_e { AA, BB=%s };" % hidden_value)
-        assert lib.AA == 0
-        assert lib.BB == eval(hidden_value.replace('U', '').replace('L', ''))
-        assert ffi.sizeof("enum foo_e") == expected_size
-        if sys.platform != 'win32':
-            assert int(ffi.cast("enum foo_e", -1)) == expected_minus1
-    # test with the large value hidden:
-    # disabled so far, doesn't work
-##    for hidden_value, expected_size, expected_minus1 in cases:
-##        ffi = FFI()
-##        ffi.cdef("enum foo_e { AA, BB, ... };")
-##        lib = ffi.verify("enum foo_e { AA, BB=%s };" % hidden_value)
-##        assert lib.AA == 0
-##        assert ffi.sizeof("enum foo_e") == expected_size
-##        assert int(ffi.cast("enum foo_e", -1)) == expected_minus1
-
-def test_enum_bug118():
-    maxulong = 256 ** FFI().sizeof("unsigned long") - 1
-    for c2, c2c in [(-1, ''),
-                    (-1, ''),
-                    (0xffffffff, 'U'),
-                    (maxulong, 'UL'),
-                    (-int(maxulong / 3), 'L')]:
-        if c2c and sys.platform == 'win32':
-            continue     # enums may always be signed with MSVC
-        ffi = FFI()
-        ffi.cdef("enum foo_e { AA };")
-        lib = ffi.verify("enum foo_e { AA=%s%s };" % (c2, c2c))
-        assert lib.AA == c2
-
-def test_string_to_voidp_arg():
-    ffi = FFI()
-    ffi.cdef("int myfunc(void *);")
-    lib = ffi.verify("int myfunc(void *p) { return ((signed char *)p)[0]; }")
-    res = lib.myfunc(b"hi!")
-    assert res == ord(b"h")
-    p = ffi.new("char[]", b"gah")
-    res = lib.myfunc(p)
-    assert res == ord(b"g")
-    res = lib.myfunc(ffi.cast("void *", p))
-    assert res == ord(b"g")
-    res = lib.myfunc(ffi.cast("int *", p))
-    assert res == ord(b"g")
-
-def test_callback_indirection():
-    ffi = FFI()
-    ffi.cdef("""
-        int (*python_callback)(int how_many, int *values);
-        int (*const c_callback)(int,...);   /* pass this ptr to C routines */
-        int some_c_function(int(*cb)(int,...));
-    """)
-    lib = ffi.verify("""
-        #include <stdarg.h>
-        #ifdef _WIN32
-        #include <malloc.h>
-        #define alloca _alloca
-        #else
-        # ifdef __FreeBSD__
-        #  include <stdlib.h>
-        # else
-        #  include <alloca.h>
-        # endif
-        #endif
-        static int (*python_callback)(int how_many, int *values);
-        static int c_callback(int how_many, ...) {
-            va_list ap;
-            /* collect the "..." arguments into the values[] array */
-            int i, *values = alloca((size_t)how_many * sizeof(int));
-            va_start(ap, how_many);
-            for (i=0; i<how_many; i++)
-                values[i] = va_arg(ap, int);
-            va_end(ap);
-            return python_callback(how_many, values);
-        }
-        int some_c_function(int(*cb)(int,...)) {
-            int result = cb(2, 10, 20);
-            result += cb(3, 30, 40, 50);
-            return result;
-        }
-    """)
-    seen = []
-    @ffi.callback("int(int, int*)")
-    def python_callback(how_many, values):
-        seen.append([values[i] for i in range(how_many)])
-        return 42
-    lib.python_callback = python_callback
-
-    res = lib.some_c_function(lib.c_callback)
-    assert res == 84
-    assert seen == [[10, 20], [30, 40, 50]]
-
-def test_floatstar_argument():
-    ffi = FFI()
-    ffi.cdef("float sum3floats(float *);")
-    lib = ffi.verify("""
-        float sum3floats(float *f) {
-            return f[0] + f[1] + f[2];
-        }
-    """)
-    assert lib.sum3floats((1.5, 2.5, 3.5)) == 7.5
-    p = ffi.new("float[]", (1.5, 2.5, 3.5))
-    assert lib.sum3floats(p) == 7.5
-
-def test_charstar_argument():
-    ffi = FFI()
-    ffi.cdef("char sum3chars(char *);")
-    lib = ffi.verify("""
-        char sum3chars(char *f) {
-            return (char)(f[0] + f[1] + f[2]);
-        }
-    """)
-    assert lib.sum3chars((b'\x10', b'\x20', b'\x30')) == b'\x60'
-    p = ffi.new("char[]", b'\x10\x20\x30')
-    assert lib.sum3chars(p) == b'\x60'
-
-def test_passing_string_or_NULL():
-    ffi = FFI()
-    ffi.cdef("int seeme1(char *); int seeme2(int *);")
-    lib = ffi.verify("""
-        int seeme1(char *x) {
-            return (x == NULL);
-        }
-        int seeme2(int *x) {
-            return (x == NULL);
-        }
-    """)
-    assert lib.seeme1(b"foo") == 0
-    assert lib.seeme1(ffi.NULL) == 1
-    assert lib.seeme2([42, 43]) == 0
-    assert lib.seeme2(ffi.NULL) == 1
-    py.test.raises(TypeError, lib.seeme1, None)
-    py.test.raises(TypeError, lib.seeme2, None)
-    py.test.raises(TypeError, lib.seeme1, 0.0)
-    py.test.raises(TypeError, lib.seeme2, 0.0)
-    py.test.raises(TypeError, lib.seeme1, 0)
-    py.test.raises(TypeError, lib.seeme2, 0)
-    zeroL  = 99999999999999999999
-    zeroL -= 99999999999999999999
-    py.test.raises(TypeError, lib.seeme2, zeroL)
-
-def test_typeof_function():
-    ffi = FFI()
-    ffi.cdef("int foo(int, char);")
-    lib = ffi.verify("int foo(int x, char y) { (void)x; (void)y; return 42; }")
-    ctype = ffi.typeof(lib.foo)
-    assert len(ctype.args) == 2
-    assert ctype.result == ffi.typeof("int")
-
-def test_call_with_voidstar_arg():
-    ffi = FFI()
-    ffi.cdef("int f(void *);")
-    lib = ffi.verify("int f(void *x) { return ((char*)x)[0]; }")
-    assert lib.f(b"foobar") == ord(b"f")
-
-def test_dir():
-    ffi = FFI()
-    ffi.cdef("""void somefunc(void);
-                extern int somevar, somearray[2];
-                static char *const sv2;
-                enum my_e { AA, BB, ... };
-                #define FOO ...""")
-    lib = ffi.verify("""void somefunc(void) { }
-                        int somevar, somearray[2];
-                        #define sv2 "text"
-                        enum my_e { AA, BB };
-                        #define FOO 42""")
-    assert dir(lib) == ['AA', 'BB', 'FOO', 'somearray',
-                        'somefunc', 'somevar', 'sv2']
-
-def test_typeof_func_with_struct_argument():
-    ffi = FFI()
-    ffi.cdef("""struct s { int a; }; int foo(struct s);""")
-    lib = ffi.verify("""struct s { int a; };
-                        int foo(struct s x) { return x.a; }""")
-    s = ffi.new("struct s *", [-1234])
-    m = lib.foo(s[0])
-    assert m == -1234
-    assert repr(ffi.typeof(lib.foo)) == "<ctype 'int(*)(struct s)'>"
-
-def test_bug_const_char_ptr_array_1():
-    ffi = FFI()
-    ffi.cdef("""const char *a[...];""")
-    lib = ffi.verify("""const char *a[5];""")
-    assert repr(ffi.typeof(lib.a)) == "<ctype 'char *[5]'>"
-
-def test_bug_const_char_ptr_array_2():
-    ffi = FFI()
-    ffi.cdef("""const int a[];""")
-    lib = ffi.verify("""const int a[5];""")
-    assert repr(ffi.typeof(lib.a)) == "<ctype 'int *'>"
-
-def _test_various_calls(force_libffi):
-    cdef_source = """
-    int xvalue;
-    long long ivalue, rvalue;
-    float fvalue;
-    double dvalue;
-    long double Dvalue;
-    signed char tf_bb(signed char x, signed char c);
-    unsigned char tf_bB(signed char x, unsigned char c);
-    short tf_bh(signed char x, short c);
-    unsigned short tf_bH(signed char x, unsigned short c);
-    int tf_bi(signed char x, int c);
-    unsigned int tf_bI(signed char x, unsigned int c);
-    long tf_bl(signed char x, long c);
-    unsigned long tf_bL(signed char x, unsigned long c);
-    long long tf_bq(signed char x, long long c);
-    unsigned long long tf_bQ(signed char x, unsigned long long c);
-    float tf_bf(signed char x, float c);
-    double tf_bd(signed char x, double c);
-    long double tf_bD(signed char x, long double c);
-    """
-    if force_libffi:
-        cdef_source = (cdef_source
-            .replace('tf_', '(*const tf_')
-            .replace('(signed char x', ')(signed char x'))
-    ffi = FFI()
-    ffi.cdef(cdef_source)
-    lib = ffi.verify("""
-    int xvalue;
-    long long ivalue, rvalue;
-    float fvalue;
-    double dvalue;
-    long double Dvalue;
-
-    typedef signed char b_t;
-    typedef unsigned char B_t;
-    typedef short h_t;
-    typedef unsigned short H_t;
-    typedef int i_t;
-    typedef unsigned int I_t;
-    typedef long l_t;
-    typedef unsigned long L_t;
-    typedef long long q_t;
-    typedef unsigned long long Q_t;
-    typedef float f_t;
-    typedef double d_t;
-    typedef long double D_t;
-    #define S(letter)  xvalue = (int)x; letter##value = (letter##_t)c;
-    #define R(letter)  return (letter##_t)rvalue;
-
-    signed char tf_bb(signed char x, signed char c) { S(i) R(b) }
-    unsigned char tf_bB(signed char x, unsigned char c) { S(i) R(B) }
-    short tf_bh(signed char x, short c) { S(i) R(h) }
-    unsigned short tf_bH(signed char x, unsigned short c) { S(i) R(H) }
-    int tf_bi(signed char x, int c) { S(i) R(i) }
-    unsigned int tf_bI(signed char x, unsigned int c) { S(i) R(I) }
-    long tf_bl(signed char x, long c) { S(i) R(l) }
-    unsigned long tf_bL(signed char x, unsigned long c) { S(i) R(L) }
-    long long tf_bq(signed char x, long long c) { S(i) R(q) }
-    unsigned long long tf_bQ(signed char x, unsigned long long c) { S(i) R(Q) }
-    float tf_bf(signed char x, float c) { S(f) R(f) }
-    double tf_bd(signed char x, double c) { S(d) R(d) }
-    long double tf_bD(signed char x, long double c) { S(D) R(D) }
-    """)
-    lib.rvalue = 0x7182838485868788
-    for kind, cname in [('b', 'signed char'),
-                        ('B', 'unsigned char'),
-                        ('h', 'short'),
-                        ('H', 'unsigned short'),
-                        ('i', 'int'),
-                        ('I', 'unsigned int'),
-                        ('l', 'long'),
-                        ('L', 'unsigned long'),
-                        ('q', 'long long'),
-                        ('Q', 'unsigned long long'),
-                        ('f', 'float'),
-                        ('d', 'double'),
-                        ('D', 'long double')]:
-        sign = +1 if 'unsigned' in cname else -1
-        lib.xvalue = 0
-        lib.ivalue = 0
-        lib.fvalue = 0
-        lib.dvalue = 0
-        lib.Dvalue = 0
-        fun = getattr(lib, 'tf_b' + kind)
-        res = fun(-42, sign * 99)
-        if kind == 'D':
-            res = float(res)
-        assert res == int(ffi.cast(cname, 0x7182838485868788))
-        assert lib.xvalue == -42
-        if kind in 'fdD':
-            assert float(getattr(lib, kind + 'value')) == -99.0
-        else:
-            assert lib.ivalue == sign * 99
-
-def test_various_calls_direct():
-    _test_various_calls(force_libffi=False)
-
-def test_various_calls_libffi():
-    _test_various_calls(force_libffi=True)
-
-def test_ptr_to_opaque():
-    ffi = FFI()
-    ffi.cdef("typedef ... foo_t; int f1(foo_t*); foo_t *f2(int);")
-    lib = ffi.verify("""
-        #include <stdlib.h>
-        typedef struct { int x; } foo_t;
-        int f1(foo_t* p) {
-            int x = p->x;
-            free(p);
-            return x;
-        }
-        foo_t *f2(int x) {
-            foo_t *p = malloc(sizeof(foo_t));
-            p->x = x;
-            return p;
-        }
-    """)
-    p = lib.f2(42)
-    x = lib.f1(p)
-    assert x == 42
-
-def _run_in_multiple_threads(test1):
-    test1()
-    import sys
-    try:
-        import thread
-    except ImportError:
-        import _thread as thread
-    errors = []
-    def wrapper(lock):
-        try:
-            test1()
-        except:
-            errors.append(sys.exc_info())
-        lock.release()
-    locks = []
-    for i in range(10):
-        _lock = thread.allocate_lock()
-        _lock.acquire()
-        thread.start_new_thread(wrapper, (_lock,))
-        locks.append(_lock)
-    for _lock in locks:
-        _lock.acquire()
-        if errors:
-            raise errors[0][1]
-
-def test_errno_working_even_with_pypys_jit():
-    ffi = FFI()
-    ffi.cdef("int f(int);")
-    lib = ffi.verify("""
-        #include <errno.h>
-        int f(int x) { return (errno = errno + x); }
-    """)
-    @_run_in_multiple_threads
-    def test1():
-        ffi.errno = 0
-        for i in range(10000):
-            e = lib.f(1)
-            assert e == i + 1
-            assert ffi.errno == e
-        for i in range(10000):
-            ffi.errno = i
-            e = lib.f(42)
-            assert e == i + 42
-
-def test_getlasterror_working_even_with_pypys_jit():
-    if sys.platform != 'win32':
-        py.test.skip("win32-only test")
-    ffi = FFI()
-    ffi.cdef("void SetLastError(DWORD);")
-    lib = ffi.dlopen("Kernel32.dll")
-    @_run_in_multiple_threads
-    def test1():
-        for i in range(10000):
-            n = (1 << 29) + i
-            lib.SetLastError(n)
-            assert ffi.getwinerror()[0] == n
-
-def test_verify_dlopen_flags():
-    if not hasattr(sys, 'setdlopenflags'):
-        py.test.skip("requires sys.setdlopenflags()")
-    # Careful with RTLD_GLOBAL.  If by chance the FFI is not deleted
-    # promptly, like on PyPy, then other tests may see the same
-    # exported symbols as well.  So we must not export a simple name
-    # like 'foo'!
-    old = sys.getdlopenflags()
-    try:
-        ffi1 = FFI()
-        ffi1.cdef("int foo_verify_dlopen_flags;")
-        sys.setdlopenflags(ffi1.RTLD_GLOBAL | ffi1.RTLD_NOW)
-        lib1 = ffi1.verify("int foo_verify_dlopen_flags;")
-    finally:
-        sys.setdlopenflags(old)
-
-    ffi2 = FFI()
-    ffi2.cdef("int *getptr(void);")
-    lib2 = ffi2.verify("""
-        extern int foo_verify_dlopen_flags;
-        static int *getptr(void) { return &foo_verify_dlopen_flags; }
-    """)
-    p = lib2.getptr()
-    assert ffi1.addressof(lib1, 'foo_verify_dlopen_flags') == p
-
-def test_consider_not_implemented_function_type():
-    ffi = FFI()
-    ffi.cdef("typedef union { int a; float b; } Data;"
-             "typedef struct { int a:2; } MyStr;"
-             "typedef void (*foofunc_t)(Data);"
-             "typedef Data (*bazfunc_t)(void);"
-             "typedef MyStr (*barfunc_t)(void);")
-    fooptr = ffi.cast("foofunc_t", 123)
-    bazptr = ffi.cast("bazfunc_t", 123)
-    barptr = ffi.cast("barfunc_t", 123)
-    # assert did not crash so far
-    e = py.test.raises(NotImplementedError, fooptr, ffi.new("Data *"))
-    assert str(e.value) == (
-        "ctype 'Data' (size 4) not supported as argument")
-    e = py.test.raises(NotImplementedError, bazptr)
-    assert str(e.value) == (
-        "ctype 'Data' (size 4) not supported as return value")
-    e = py.test.raises(NotImplementedError, barptr)
-    assert str(e.value) == (
-        "ctype 'MyStr' not supported as return value "
-        "(it is a struct with bit fields)")
-
-def test_verify_extra_arguments():
-    ffi = FFI()
-    ffi.cdef("#define ABA ...")
-    lib = ffi.verify("", define_macros=[('ABA', '42')])
-    assert lib.ABA == 42
-
-def test_implicit_unicode_on_windows():
-    from cffi import FFIError
-    if sys.platform != 'win32':
-        py.test.skip("win32-only test")
-    ffi = FFI()
-    e = py.test.raises(FFIError, ffi.cdef, "int foo(LPTSTR);")
-    assert str(e.value) == ("The Windows type 'LPTSTR' is only available after"
-                            " you call ffi.set_unicode()")
-    for with_unicode in [True, False]:
-        ffi = FFI()
-        ffi.set_unicode(with_unicode)
-        ffi.cdef("""
-            DWORD GetModuleFileName(HMODULE hModule, LPTSTR lpFilename,
-                                    DWORD nSize);
-        """)
-        lib = ffi.verify("""
-            #include <windows.h>
-        """, libraries=['Kernel32'])
-        outbuf = ffi.new("TCHAR[]", 200)
-        n = lib.GetModuleFileName(ffi.NULL, outbuf, 500)
-        assert 0 < n < 500
-        for i in range(n):
-            #print repr(outbuf[i])
-            assert ord(outbuf[i]) != 0
-        assert ord(outbuf[n]) == 0
-        assert ord(outbuf[0]) < 128     # should be a letter, or '\'
-
-def test_define_known_value():
-    ffi = FFI()
-    ffi.cdef("#define FOO 0x123")
-    lib = ffi.verify("#define FOO 0x123")
-    assert lib.FOO == 0x123
-
-def test_define_wrong_value():
-    ffi = FFI()
-    ffi.cdef("#define FOO 123")
-    lib = ffi.verify("#define FOO 124")     # used to complain
-    e = py.test.raises(ffi.error, "lib.FOO")
-    assert str(e.value) == ("the C compiler says 'FOO' is equal to 124 (0x7c),"
-                            " but the cdef disagrees")
-
-def test_some_integer_type_for_issue73():
-    ffi = FFI()
-    ffi.cdef("""
-        typedef int... AnIntegerWith32Bits;
-        typedef AnIntegerWith32Bits (*AFunctionReturningInteger) (void);
-        AnIntegerWith32Bits InvokeFunction(AFunctionReturningInteger);
-    """)
-    lib = ffi.verify("""
-        #ifdef __LP64__
-        typedef int AnIntegerWith32Bits;
-        #else
-        typedef long AnIntegerWith32Bits;
-        #endif
-        typedef AnIntegerWith32Bits (*AFunctionReturningInteger) (void);
-        AnIntegerWith32Bits InvokeFunction(AFunctionReturningInteger f) {
-            return f();
-        }
-    """)
-    @ffi.callback("AFunctionReturningInteger")
-    def add():
-        return 3 + 4
-    x = lib.InvokeFunction(add)
-    assert x == 7
-
-def test_unsupported_some_primitive_types():
-    ffi = FFI()
-    py.test.raises(FFIError, ffi.cdef, """typedef void... foo_t;""")
-    #
-    ffi.cdef("typedef int... foo_t;")
-    py.test.raises(VerificationError, ffi.verify, "typedef float foo_t;")
-
-def test_windows_dllimport_data():
-    if sys.platform != 'win32':
-        py.test.skip("Windows only")
-    from testing.udir import udir
-    tmpfile = udir.join('dllimport_data.c')
-    tmpfile.write('int my_value = 42;\n')
-    ffi = FFI()
-    ffi.cdef("int my_value;")
-    lib = ffi.verify("extern __declspec(dllimport) int my_value;",
-                     sources = [str(tmpfile)])
-    assert lib.my_value == 42
-
-def test_macro_var():
-    ffi = FFI()
-    ffi.cdef("int myarray[50], my_value;")
-    lib = ffi.verify("""
-        int myarray[50];
-        int *get_my_value(void) {
-            static int index = 0;
-            return &myarray[index++];
-        }
-        #define my_value (*get_my_value())
-    """)
-    assert lib.my_value == 0             # [0]
-    lib.my_value = 42                    # [1]
-    assert lib.myarray[1] == 42
-    assert lib.my_value == 0             # [2]
-    lib.myarray[3] = 63
-    assert lib.my_value == 63            # [3]
-    p = ffi.addressof(lib, 'my_value')   # [4]
-    assert p[-1] == 63
-    assert p[0] == 0
-    assert p == lib.myarray + 4
-    p[1] = 82
-    assert lib.my_value == 82            # [5]
-
-def test_const_pointer_to_pointer():
-    ffi = FFI()
-    ffi.cdef("struct s { char *const *a; };")
-    ffi.verify("struct s { char *const *a; };")
-
-def test_share_FILE():
-    ffi1 = FFI()
-    ffi1.cdef("void do_stuff(FILE *);")
-    lib1 = ffi1.verify("void do_stuff(FILE *f) { (void)f; }")
-    ffi2 = FFI()
-    ffi2.cdef("FILE *barize(void);")
-    lib2 = ffi2.verify("FILE *barize(void) { return NULL; }")
-    lib1.do_stuff(lib2.barize())
-
-def test_win_common_types():
-    if sys.platform != 'win32':
-        py.test.skip("Windows only")
-    ffi = FFI()
-    ffi.set_unicode(True)
-    ffi.verify("")
-    assert ffi.typeof("PBYTE") is ffi.typeof("unsigned char *")
-    if sys.maxsize > 2**32:
-        expected = "unsigned long long"
-    else:
-        expected = "unsigned int"
-    assert ffi.typeof("UINT_PTR") is ffi.typeof(expected)
-    assert ffi.typeof("PTSTR") is ffi.typeof("wchar_t *")

+ 0 - 367
desktop/core/ext-py/cffi-1.3.1/testing/cffi1/test_zdist.py

@@ -1,367 +0,0 @@
-import sys, os, py
-import subprocess
-import cffi
-from testing.udir import udir
-
-
-def chdir_to_tmp(f):
-    f.chdir_to_tmp = True
-    return f
-
-def from_outside(f):
-    f.chdir_to_tmp = False
-    return f
-
-
-class TestDist(object):
-
-    def setup_method(self, meth):
-        self.executable = os.path.abspath(sys.executable)
-        self.rootdir = os.path.abspath(os.path.dirname(os.path.dirname(
-            cffi.__file__)))
-        self.udir = udir.join(meth.__name__)
-        os.mkdir(str(self.udir))
-        if meth.chdir_to_tmp:
-            self.saved_cwd = os.getcwd()
-            os.chdir(str(self.udir))
-
-    def teardown_method(self, meth):
-        if hasattr(self, 'saved_cwd'):
-            os.chdir(self.saved_cwd)
-
-    def run(self, args, cwd=None):
-        env = os.environ.copy()
-        # a horrible hack to prevent distutils from finding ~/.pydistutils.cfg
-        # (there is the --no-user-cfg option, but not in Python 2.6...)
-        env['HOME'] = '/this/path/does/not/exist'
-        if cwd is None:
-            newpath = self.rootdir
-            if 'PYTHONPATH' in env:
-                newpath += os.pathsep + env['PYTHONPATH']
-            env['PYTHONPATH'] = newpath
-        subprocess.check_call([self.executable] + args, cwd=cwd, env=env)
-
-    def _prepare_setuptools(self):
-        if hasattr(TestDist, '_setuptools_ready'):
-            return
-        try:
-            import setuptools
-        except ImportError:
-            py.test.skip("setuptools not found")
-        self.run(['setup.py', 'egg_info'], cwd=self.rootdir)
-        TestDist._setuptools_ready = True
-
-    def check_produced_files(self, content, curdir=None):
-        if curdir is None:
-            curdir = str(self.udir)
-        found_so = None
-        for name in os.listdir(curdir):
-            if (name.endswith('.so') or name.endswith('.pyd') or
-                name.endswith('.dylib')):
-                found_so = os.path.join(curdir, name)
-                # foo.cpython-34m.so => foo
-                name = name.split('.')[0]
-                # foo_d.so => foo (Python 2 debug builds)
-                if name.endswith('_d') and hasattr(sys, 'gettotalrefcount'):
-                    name = name.rsplit('_', 1)[0]
-                name += '.SO'
-            if name.startswith('pycparser') and name.endswith('.egg'):
-                continue    # no clue why this shows up sometimes and not others
-            if name == '.eggs':
-                continue    # seems new in 3.5, ignore it
-            assert name in content, "found unexpected file %r" % (
-                os.path.join(curdir, name),)
-            value = content.pop(name)
-            if value is None:
-                assert name.endswith('.SO') or (
-                    os.path.isfile(os.path.join(curdir, name)))
-            else:
-                subdir = os.path.join(curdir, name)
-                assert os.path.isdir(subdir)
-                if value == '?':
-                    continue
-                found_so = self.check_produced_files(value, subdir) or found_so
-        assert content == {}, "files or dirs not produced in %r: %r" % (
-            curdir, content.keys())
-        return found_so
-
-    @chdir_to_tmp
-    def test_empty(self):
-        self.check_produced_files({})
-
-    @chdir_to_tmp
-    def test_abi_emit_python_code_1(self):
-        ffi = cffi.FFI()
-        ffi.set_source("package_name_1.mymod", None)
-        ffi.emit_python_code('xyz.py')
-        self.check_produced_files({'xyz.py': None})
-
-    @chdir_to_tmp
-    def test_abi_emit_python_code_2(self):
-        ffi = cffi.FFI()
-        ffi.set_source("package_name_1.mymod", None)
-        py.test.raises(IOError, ffi.emit_python_code, 'unexisting/xyz.py')
-
-    @from_outside
-    def test_abi_emit_python_code_3(self):
-        ffi = cffi.FFI()
-        ffi.set_source("package_name_1.mymod", None)
-        ffi.emit_python_code(str(self.udir.join('xyt.py')))
-        self.check_produced_files({'xyt.py': None})
-
-    @chdir_to_tmp
-    def test_abi_compile_1(self):
-        ffi = cffi.FFI()
-        ffi.set_source("mod_name_in_package.mymod", None)
-        x = ffi.compile()
-        self.check_produced_files({'mod_name_in_package': {'mymod.py': None}})
-        assert x == os.path.join('.', 'mod_name_in_package', 'mymod.py')
-
-    @chdir_to_tmp
-    def test_abi_compile_2(self):
-        ffi = cffi.FFI()
-        ffi.set_source("mod_name_in_package.mymod", None)
-        x = ffi.compile('build2')
-        self.check_produced_files({'build2': {
-            'mod_name_in_package': {'mymod.py': None}}})
-        assert x == os.path.join('build2', 'mod_name_in_package', 'mymod.py')
-
-    @from_outside
-    def test_abi_compile_3(self):
-        ffi = cffi.FFI()
-        ffi.set_source("mod_name_in_package.mymod", None)
-        tmpdir = str(self.udir.join('build3'))
-        x = ffi.compile(tmpdir)
-        self.check_produced_files({'build3': {
-            'mod_name_in_package': {'mymod.py': None}}})
-        assert x == os.path.join(tmpdir, 'mod_name_in_package', 'mymod.py')
-
-    @chdir_to_tmp
-    def test_api_emit_c_code_1(self):
-        ffi = cffi.FFI()
-        ffi.set_source("package_name_1.mymod", "/*code would be here*/")
-        ffi.emit_c_code('xyz.c')
-        self.check_produced_files({'xyz.c': None})
-
-    @chdir_to_tmp
-    def test_api_emit_c_code_2(self):
-        ffi = cffi.FFI()
-        ffi.set_source("package_name_1.mymod", "/*code would be here*/")
-        py.test.raises(IOError, ffi.emit_c_code, 'unexisting/xyz.c')
-
-    @from_outside
-    def test_api_emit_c_code_3(self):
-        ffi = cffi.FFI()
-        ffi.set_source("package_name_1.mymod", "/*code would be here*/")
-        ffi.emit_c_code(str(self.udir.join('xyu.c')))
-        self.check_produced_files({'xyu.c': None})
-
-    @chdir_to_tmp
-    def test_api_compile_1(self):
-        ffi = cffi.FFI()
-        ffi.set_source("mod_name_in_package.mymod", "/*code would be here*/")
-        x = ffi.compile()
-        if sys.platform != 'win32':
-            sofile = self.check_produced_files({
-                'mod_name_in_package': {'mymod.SO': None,
-                                        'mymod.c': None,
-                                        'mymod.o': None}})
-            assert os.path.isabs(x) and os.path.samefile(x, sofile)
-        else:
-            self.check_produced_files({
-                'mod_name_in_package': {'mymod.SO': None,
-                                        'mymod.c': None},
-                'Release': '?'})
-
-    @chdir_to_tmp
-    def test_api_compile_2(self):
-        ffi = cffi.FFI()
-        ffi.set_source("mod_name_in_package.mymod", "/*code would be here*/")
-        x = ffi.compile('output')
-        if sys.platform != 'win32':
-            sofile = self.check_produced_files({
-                'output': {'mod_name_in_package': {'mymod.SO': None,
-                                                   'mymod.c': None,
-                                                   'mymod.o': None}}})
-            assert os.path.isabs(x) and os.path.samefile(x, sofile)
-        else:
-            self.check_produced_files({
-                'output': {'mod_name_in_package': {'mymod.SO': None,
-                                                   'mymod.c': None},
-                           'Release': '?'}})
-
-    @from_outside
-    def test_api_compile_3(self):
-        ffi = cffi.FFI()
-        ffi.set_source("mod_name_in_package.mymod", "/*code would be here*/")
-        x = ffi.compile(str(self.udir.join('foo')))
-        if sys.platform != 'win32':
-            sofile = self.check_produced_files({
-                'foo': {'mod_name_in_package': {'mymod.SO': None,
-                                                'mymod.c': None,
-                                                'mymod.o': None}}})
-            assert os.path.isabs(x) and os.path.samefile(x, sofile)
-        else:
-            self.check_produced_files({
-                'foo': {'mod_name_in_package': {'mymod.SO': None,
-                                                'mymod.c': None},
-                        'Release': '?'}})
-
-    @chdir_to_tmp
-    def test_api_distutils_extension_1(self):
-        ffi = cffi.FFI()
-        ffi.set_source("mod_name_in_package.mymod", "/*code would be here*/")
-        ext = ffi.distutils_extension()
-        self.check_produced_files({'build': {
-            'mod_name_in_package': {'mymod.c': None}}})
-        if hasattr(os.path, 'samefile'):
-            assert os.path.samefile(ext.sources[0],
-                                    'build/mod_name_in_package/mymod.c')
-
-    @from_outside
-    def test_api_distutils_extension_2(self):
-        ffi = cffi.FFI()
-        ffi.set_source("mod_name_in_package.mymod", "/*code would be here*/")
-        ext = ffi.distutils_extension(str(self.udir.join('foo')))
-        self.check_produced_files({'foo': {
-            'mod_name_in_package': {'mymod.c': None}}})
-        if hasattr(os.path, 'samefile'):
-            assert os.path.samefile(ext.sources[0],
-                str(self.udir.join('foo/mod_name_in_package/mymod.c')))
-
-
-    def _make_distutils_api(self):
-        os.mkdir("src")
-        os.mkdir(os.path.join("src", "pack1"))
-        with open(os.path.join("src", "pack1", "__init__.py"), "w") as f:
-            pass
-        with open("setup.py", "w") as f:
-            f.write("""if 1:
-                import cffi
-                ffi = cffi.FFI()
-                ffi.set_source("pack1.mymod", "/*code would be here*/")
-
-                from distutils.core import setup
-                setup(name='example1',
-                      version='0.1',
-                      packages=['pack1'],
-                      package_dir={'': 'src'},
-                      ext_modules=[ffi.distutils_extension()])
-            """)
-
-    @chdir_to_tmp
-    def test_distutils_api_1(self):
-        self._make_distutils_api()
-        self.run(["setup.py", "build"])
-        self.check_produced_files({'setup.py': None,
-                                   'build': '?',
-                                   'src': {'pack1': {'__init__.py': None}}})
-
-    @chdir_to_tmp
-    def test_distutils_api_2(self):
-        self._make_distutils_api()
-        self.run(["setup.py", "build_ext", "-i"])
-        self.check_produced_files({'setup.py': None,
-                                   'build': '?',
-                                   'src': {'pack1': {'__init__.py': None,
-                                                     'mymod.SO': None}}})
-
-    def _make_setuptools_abi(self):
-        self._prepare_setuptools()
-        os.mkdir("src0")
-        os.mkdir(os.path.join("src0", "pack2"))
-        with open(os.path.join("src0", "pack2", "__init__.py"), "w") as f:
-            pass
-        with open(os.path.join("src0", "pack2", "_build.py"), "w") as f:
-            f.write("""if 1:
-                import cffi
-                ffi = cffi.FFI()
-                ffi.set_source("pack2.mymod", None)
-            """)
-        with open("setup.py", "w") as f:
-            f.write("""if 1:
-                from setuptools import setup
-                setup(name='example1',
-                      version='0.1',
-                      packages=['pack2'],
-                      package_dir={'': 'src0'},
-                      cffi_modules=["src0/pack2/_build.py:ffi"])
-            """)
-
-    @chdir_to_tmp
-    def test_setuptools_abi_1(self):
-        self._make_setuptools_abi()
-        self.run(["setup.py", "build"])
-        self.check_produced_files({'setup.py': None,
-                                   'build': '?',
-                                   'src0': {'pack2': {'__init__.py': None,
-                                                      '_build.py': None}}})
-
-    @chdir_to_tmp
-    def test_setuptools_abi_2(self):
-        self._make_setuptools_abi()
-        self.run(["setup.py", "build_ext", "-i"])
-        self.check_produced_files({'setup.py': None,
-                                   'src0': {'pack2': {'__init__.py': None,
-                                                      '_build.py': None,
-                                                      'mymod.py': None}}})
-
-    def _make_setuptools_api(self):
-        self._prepare_setuptools()
-        os.mkdir("src1")
-        os.mkdir(os.path.join("src1", "pack3"))
-        with open(os.path.join("src1", "pack3", "__init__.py"), "w") as f:
-            pass
-        with open(os.path.join("src1", "pack3", "_build.py"), "w") as f:
-            f.write("""if 1:
-                import cffi
-                ffi = cffi.FFI()
-                ffi.set_source("pack3.mymod", "/*code would be here*/")
-                ffi._hi_there = 42
-            """)
-        with open("setup.py", "w") as f:
-            f.write("from __future__ import print_function\n"
-                """if 1:
-                from setuptools import setup
-                from distutils.command.build_ext import build_ext
-                import os
-
-                class TestBuildExt(build_ext):
-                    def pre_run(self, ext, ffi):
-                        print('_make_setuptools_api: in pre_run:', end=" ")
-                        assert ffi._hi_there == 42
-                        assert ext.name == "pack3.mymod"
-                        fn = os.path.join(os.path.dirname(self.build_lib),
-                                          '..', 'see_me')
-                        print('creating %r' % (fn,))
-                        open(fn, 'w').close()
-
-                setup(name='example1',
-                      version='0.1',
-                      packages=['pack3'],
-                      package_dir={'': 'src1'},
-                      cffi_modules=["src1/pack3/_build.py:ffi"],
-                      cmdclass={'build_ext': TestBuildExt},
-                      )
-            """)
-
-    @chdir_to_tmp
-    def test_setuptools_api_1(self):
-        self._make_setuptools_api()
-        self.run(["setup.py", "build"])
-        self.check_produced_files({'setup.py': None,
-                                   'build': '?',
-                                   'see_me': None,
-                                   'src1': {'pack3': {'__init__.py': None,
-                                                      '_build.py': None}}})
-
-    @chdir_to_tmp
-    def test_setuptools_api_2(self):
-        self._make_setuptools_api()
-        self.run(["setup.py", "build_ext", "-i"])
-        self.check_produced_files({'setup.py': None,
-                                   'build': '?',
-                                   'see_me': None,
-                                   'src1': {'pack3': {'__init__.py': None,
-                                                      '_build.py': None,
-                                                      'mymod.SO': None}}})

+ 0 - 19
desktop/core/ext-py/cffi-1.3.1/testing/support.py

@@ -1,19 +0,0 @@
-import sys
-
-if sys.version_info < (3,):
-    __all__ = ['u']
-
-    class U(object):
-        def __add__(self, other):
-            return eval('u'+repr(other).replace(r'\\u', r'\u')
-                                       .replace(r'\\U', r'\U'))
-    u = U()
-    assert u+'a\x00b' == eval(r"u'a\x00b'")
-    assert u+'a\u1234b' == eval(r"u'a\u1234b'")
-    assert u+'a\U00012345b' == eval(r"u'a\U00012345b'")
-
-else:
-    __all__ = ['u', 'unicode', 'long']
-    u = ""
-    unicode = str
-    long = int

+ 0 - 3
desktop/core/ext-py/cffi-1.3.1/testing/udir.py

@@ -1,3 +0,0 @@
-import py
-
-udir = py.path.local.make_numbered_dir(prefix = 'ffi-')

+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/AUTHORS → desktop/core/ext-py/cffi-1.5.2/AUTHORS


+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/LICENSE → desktop/core/ext-py/cffi-1.5.2/LICENSE


+ 2 - 2
desktop/core/ext-py/cffi-1.3.1/MANIFEST.in → desktop/core/ext-py/cffi-1.5.2/MANIFEST.in

@@ -1,6 +1,6 @@
 recursive-include cffi *.py *.h
 recursive-include c *.c *.h *.asm *.py win64.obj
-recursive-include testing *.py
+recursive-include testing *.py *.c *.h
 recursive-include doc *.py *.rst Makefile *.bat
-recursive-include demo py.cleanup *.py manual.c
+recursive-include demo py.cleanup *.py embedding_test.c manual.c
 include AUTHORS LICENSE setup.py setup_base.py

+ 1 - 1
desktop/core/ext-py/cffi-1.3.1/PKG-INFO → desktop/core/ext-py/cffi-1.5.2/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: cffi
-Version: 1.3.1
+Version: 1.5.2
 Summary: Foreign Function Interface for Python calling C code.
 Home-page: http://cffi.readthedocs.org
 Author: Armin Rigo, Maciej Fijalkowski

+ 131 - 80
desktop/core/ext-py/cffi-1.3.1/c/_cffi_backend.c → desktop/core/ext-py/cffi-1.5.2/c/_cffi_backend.c

@@ -2,6 +2,8 @@
 #include <Python.h>
 #include "structmember.h"
 
+#define CFFI_VERSION  "1.5.2"
+
 #ifdef MS_WIN32
 #include <windows.h>
 #include "misc_win32.h"
@@ -103,7 +105,11 @@
 #endif
 
 #if PY_MAJOR_VERSION < 3
-#define PyCapsule_New(pointer, name, destructor)        \
+# undef PyCapsule_GetPointer
+# undef PyCapsule_New
+# define PyCapsule_GetPointer(capsule, name) \
+    (PyCObject_AsVoidPtr(capsule))
+# define PyCapsule_New(pointer, name, destructor) \
     (PyCObject_FromVoidPtr(pointer, destructor))
 #endif
 
@@ -262,18 +268,7 @@ typedef struct {
 /* whenever running Python code, the errno is saved in this thread-local
    variable */
 #ifndef MS_WIN32
-# ifdef USE__THREAD
-/* This macro ^^^ is defined by setup.py if it finds that it is
-   syntactically valid to use "__thread" with this C compiler. */
-static __thread int cffi_saved_errno = 0;
-static void save_errno(void) { cffi_saved_errno = errno; }
-static void restore_errno(void) { errno = cffi_saved_errno; }
-static void init_errno(void) { }
-# else
-#  include "misc_thread.h"
-# endif
-# define save_errno_only      save_errno
-# define restore_errno_only   restore_errno
+# include "misc_thread_posix.h"
 #endif
 
 #include "minibuffer.h"
@@ -286,8 +281,11 @@ static void init_errno(void) { }
 # include "wchar_helper.h"
 #endif
 
-typedef PyObject *const cffi_allocator_t[3];
-static cffi_allocator_t default_allocator = { NULL, NULL, NULL };
+typedef struct _cffi_allocator_s {
+    PyObject *ca_alloc, *ca_free;
+    int ca_dont_clear;
+} cffi_allocator_t;
+static const cffi_allocator_t default_allocator = { NULL, NULL, 0 };
 static PyObject *FFIError;
 static PyObject *unique_cache;
 
@@ -1607,7 +1605,7 @@ static void cdataowninggc_dealloc(CDataObject *cd)
     PyObject_GC_UnTrack(cd);
 
     if (cd->c_type->ct_flags & CT_IS_VOID_PTR) {        /* a handle */
-        PyObject *x = (PyObject *)(cd->c_data + 42);
+        PyObject *x = ((CDataObject_own_structptr *)cd)->structobj;
         Py_DECREF(x);
     }
     else if (cd->c_type->ct_flags & CT_FUNCTIONPTR) {   /* a callback */
@@ -1627,7 +1625,7 @@ static void cdataowninggc_dealloc(CDataObject *cd)
 static int cdataowninggc_traverse(CDataObject *cd, visitproc visit, void *arg)
 {
     if (cd->c_type->ct_flags & CT_IS_VOID_PTR) {        /* a handle */
-        PyObject *x = (PyObject *)(cd->c_data + 42);
+        PyObject *x = ((CDataObject_own_structptr *)cd)->structobj;
         Py_VISIT(x);
     }
     else if (cd->c_type->ct_flags & CT_FUNCTIONPTR) {   /* a callback */
@@ -1645,9 +1643,10 @@ static int cdataowninggc_traverse(CDataObject *cd, visitproc visit, void *arg)
 static int cdataowninggc_clear(CDataObject *cd)
 {
     if (cd->c_type->ct_flags & CT_IS_VOID_PTR) {        /* a handle */
-        PyObject *x = (PyObject *)(cd->c_data + 42);
+        CDataObject_own_structptr *cd1 = (CDataObject_own_structptr *)cd;
+        PyObject *x = cd1->structobj;
         Py_INCREF(Py_None);
-        cd->c_data = ((char *)Py_None) - 42;
+        cd1->structobj = Py_None;
         Py_DECREF(x);
     }
     else if (cd->c_type->ct_flags & CT_FUNCTIONPTR) {   /* a callback */
@@ -1835,7 +1834,7 @@ static PyObject *cdataowning_repr(CDataObject *cd)
 static PyObject *cdataowninggc_repr(CDataObject *cd)
 {
     if (cd->c_type->ct_flags & CT_IS_VOID_PTR) {        /* a handle */
-        PyObject *x = (PyObject *)(cd->c_data + 42);
+        PyObject *x = ((CDataObject_own_structptr *)cd)->structobj;
         return _cdata_repr2(cd, "handle to", x);
     }
     else if (cd->c_type->ct_flags & CT_FUNCTIONPTR) {   /* a callback */
@@ -3025,21 +3024,18 @@ static CDataObject *allocate_gcp_object(CDataObject *origobj,
 static CDataObject *allocate_with_allocator(Py_ssize_t basesize,
                                             Py_ssize_t datasize,
                                             CTypeDescrObject *ct,
-                                            cffi_allocator_t allocator)
+                                            const cffi_allocator_t *allocator)
 {
     CDataObject *cd;
-    PyObject *my_alloc = allocator[0];
-    PyObject *my_free = allocator[1];
-    PyObject *dont_clear_after_alloc = allocator[2];
 
-    if (my_alloc == NULL) {   /* alloc */
+    if (allocator->ca_alloc == NULL) {
         cd = allocate_owning_object(basesize + datasize, ct);
         if (cd == NULL)
             return NULL;
         cd->c_data = ((char *)cd) + basesize;
     }
     else {
-        PyObject *res = PyObject_CallFunction(my_alloc, "n", datasize);
+        PyObject *res = PyObject_CallFunction(allocator->ca_alloc, "n", datasize);
         if (res == NULL)
             return NULL;
 
@@ -3064,16 +3060,16 @@ static CDataObject *allocate_with_allocator(Py_ssize_t basesize,
             return NULL;
         }
 
-        cd = allocate_gcp_object(cd, ct, my_free);
+        cd = allocate_gcp_object(cd, ct, allocator->ca_free);
         Py_DECREF(res);
     }
-    if (dont_clear_after_alloc == NULL)
+    if (!allocator->ca_dont_clear)
         memset(cd->c_data, 0, datasize);
     return cd;
 }
 
 static PyObject *direct_newp(CTypeDescrObject *ct, PyObject *init,
-                             cffi_allocator_t allocator)
+                             const cffi_allocator_t *allocator)
 {
     CTypeDescrObject *ctitem;
     CDataObject *cd;
@@ -3178,7 +3174,7 @@ static PyObject *b_newp(PyObject *self, PyObject *args)
     PyObject *init = Py_None;
     if (!PyArg_ParseTuple(args, "O!|O:newp", &CTypeDescr_Type, &ct, &init))
         return NULL;
-    return direct_newp(ct, init, default_allocator);
+    return direct_newp(ct, init, &default_allocator);
 }
 
 static int
@@ -4654,7 +4650,9 @@ static int fb_build(struct funcbuilder_s *fb, PyObject *fargs,
 
     if (cif_descr != NULL) {
         /* exchange data size */
-        cif_descr->exchange_size = exchange_offset;
+        /* we also align it to the next multiple of 8, in an attempt to
+           work around bugs(?) of libffi like #241 */
+        cif_descr->exchange_size = ALIGN_ARG(exchange_offset);
     }
     return 0;
 }
@@ -4903,7 +4901,8 @@ static PyObject *b_new_function_type(PyObject *self, PyObject *args)
 
 static int convert_from_object_fficallback(char *result,
                                            CTypeDescrObject *ctype,
-                                           PyObject *pyobj)
+                                           PyObject *pyobj,
+                                           int encode_result_for_libffi)
 {
     /* work work work around a libffi irregularity: for integer return
        types we have to fill at least a complete 'ffi_arg'-sized result
@@ -4919,6 +4918,8 @@ static int convert_from_object_fficallback(char *result,
                 return -1;
             }
         }
+        if (!encode_result_for_libffi)
+            goto skip;
         if (ctype->ct_flags & CT_PRIMITIVE_SIGNED) {
             PY_LONG_LONG value;
             /* It's probably fine to always zero-extend, but you never
@@ -4949,6 +4950,7 @@ static int convert_from_object_fficallback(char *result,
 #endif
         }
     }
+ skip:
     return convert_from_object(result, ctype, pyobj);
 }
 
@@ -4983,14 +4985,9 @@ static void _my_PyErr_WriteUnraisable(char *objdescr, PyObject *obj,
     Py_XDECREF(tb);
 }
 
-static void invoke_callback(ffi_cif *cif, void *result, void **args,
-                            void *userdata)
+static void general_invoke_callback(int decode_args_from_libffi,
+                                    void *result, char *args, void *userdata)
 {
-    save_errno();
-    {
-#ifdef WITH_THREAD
-    PyGILState_STATE state = PyGILState_Ensure();
-#endif
     PyObject *cb_args = (PyObject *)userdata;
     CTypeDescrObject *ct = (CTypeDescrObject *)PyTuple_GET_ITEM(cb_args, 0);
     PyObject *signature = ct->ct_stuff;
@@ -5012,7 +5009,19 @@ static void invoke_callback(ffi_cif *cif, void *result, void **args,
         goto error;
 
     for (i=0; i<n; i++) {
-        PyObject *a = convert_to_object(args[i], SIGNATURE(2 + i));
+        char *a_src;
+        PyObject *a;
+        CTypeDescrObject *a_ct = SIGNATURE(2 + i);
+
+        if (decode_args_from_libffi) {
+            a_src = ((void **)args)[i];
+        }
+        else {
+            a_src = args + i * 8;
+            if (a_ct->ct_flags & (CT_IS_LONGDOUBLE | CT_STRUCT | CT_UNION))
+                a_src = *(char **)a_src;
+        }
+        a = convert_to_object(a_src, a_ct);
         if (a == NULL)
             goto error;
         PyTuple_SET_ITEM(py_args, i, a);
@@ -5021,7 +5030,8 @@ static void invoke_callback(ffi_cif *cif, void *result, void **args,
     py_res = PyObject_Call(py_ob, py_args, NULL);
     if (py_res == NULL)
         goto error;
-    if (convert_from_object_fficallback(result, SIGNATURE(1), py_res) < 0) {
+    if (convert_from_object_fficallback(result, SIGNATURE(1), py_res,
+                                        decode_args_from_libffi) < 0) {
         extra_error_line = "Trying to convert the result back to C:\n";
         goto error;
     }
@@ -5029,10 +5039,6 @@ static void invoke_callback(ffi_cif *cif, void *result, void **args,
     Py_XDECREF(py_args);
     Py_XDECREF(py_res);
     Py_DECREF(cb_args);
-#ifdef WITH_THREAD
-    PyGILState_Release(state);
-#endif
-    restore_errno();
     return;
 
  error:
@@ -5057,7 +5063,8 @@ static void invoke_callback(ffi_cif *cif, void *result, void **args,
                                             NULL);
         if (res1 != NULL) {
             if (res1 != Py_None)
-                convert_from_object_fficallback(result, SIGNATURE(1), res1);
+                convert_from_object_fficallback(result, SIGNATURE(1), res1,
+                                                decode_args_from_libffi);
             Py_DECREF(res1);
         }
         if (!PyErr_Occurred()) {
@@ -5078,24 +5085,31 @@ static void invoke_callback(ffi_cif *cif, void *result, void **args,
         }
     }
     goto done;
-    }
 
 #undef SIGNATURE
 }
 
-static PyObject *b_callback(PyObject *self, PyObject *args)
+static void invoke_callback(ffi_cif *cif, void *result, void **args,
+                            void *userdata)
 {
-    CTypeDescrObject *ct, *ctresult;
-    CDataObject *cd;
-    PyObject *ob, *error_ob = Py_None, *onerror_ob = Py_None;
-    PyObject *py_rawerr, *infotuple = NULL;
-    cif_description_t *cif_descr;
-    ffi_closure *closure;
-    Py_ssize_t size;
+    save_errno();
+    {
+        PyGILState_STATE state = gil_ensure();
+        general_invoke_callback(1, result, (char *)args, userdata);
+        gil_release(state);
+    }
+    restore_errno();
+}
 
-    if (!PyArg_ParseTuple(args, "O!O|OO:callback", &CTypeDescr_Type, &ct, &ob,
-                          &error_ob, &onerror_ob))
-        return NULL;
+static PyObject *prepare_callback_info_tuple(CTypeDescrObject *ct,
+                                             PyObject *ob,
+                                             PyObject *error_ob,
+                                             PyObject *onerror_ob,
+                                             int decode_args_from_libffi)
+{
+    CTypeDescrObject *ctresult;
+    PyObject *py_rawerr, *infotuple;
+    Py_ssize_t size;
 
     if (!(ct->ct_flags & CT_FUNCTIONPTR)) {
         PyErr_Format(PyExc_TypeError, "expected a function ctype, got '%s'",
@@ -5125,13 +5139,38 @@ static PyObject *b_callback(PyObject *self, PyObject *args)
     memset(PyBytes_AS_STRING(py_rawerr), 0, size);
     if (error_ob != Py_None) {
         if (convert_from_object_fficallback(
-                PyBytes_AS_STRING(py_rawerr), ctresult, error_ob) < 0) {
+                PyBytes_AS_STRING(py_rawerr), ctresult, error_ob,
+                decode_args_from_libffi) < 0) {
             Py_DECREF(py_rawerr);
             return NULL;
         }
     }
     infotuple = Py_BuildValue("OOOO", ct, ob, py_rawerr, onerror_ob);
     Py_DECREF(py_rawerr);
+
+#ifdef WITH_THREAD
+    /* We must setup the GIL here, in case the callback is invoked in
+       some other non-Pythonic thread.  This is the same as ctypes. */
+    PyEval_InitThreads();
+#endif
+
+    return infotuple;
+}
+
+static PyObject *b_callback(PyObject *self, PyObject *args)
+{
+    CTypeDescrObject *ct;
+    CDataObject *cd;
+    PyObject *ob, *error_ob = Py_None, *onerror_ob = Py_None;
+    PyObject *infotuple;
+    cif_description_t *cif_descr;
+    ffi_closure *closure;
+
+    if (!PyArg_ParseTuple(args, "O!O|OO:callback", &CTypeDescr_Type, &ct, &ob,
+                          &error_ob, &onerror_ob))
+        return NULL;
+
+    infotuple = prepare_callback_info_tuple(ct, ob, error_ob, onerror_ob, 1);
     if (infotuple == NULL)
         return NULL;
 
@@ -5160,9 +5199,6 @@ static PyObject *b_callback(PyObject *self, PyObject *args)
         goto error;
     }
     assert(closure->user_data == infotuple);
-#ifdef WITH_THREAD
-    PyEval_InitThreads();
-#endif
     return (PyObject *)cd;
 
  error:
@@ -5605,10 +5641,26 @@ static PyObject *b_set_errno(PyObject *self, PyObject *arg)
     return Py_None;
 }
 
+static PyObject *newp_handle(CTypeDescrObject *ct_voidp, PyObject *x)
+{
+    CDataObject_own_structptr *cd;
+    cd = (CDataObject_own_structptr *)PyObject_GC_New(CDataObject_own_structptr,
+                                                      &CDataOwningGC_Type);
+    if (cd == NULL)
+        return NULL;
+    Py_INCREF(ct_voidp);
+    cd->head.c_type = ct_voidp;
+    cd->head.c_data = (char *)cd;
+    cd->head.c_weakreflist = NULL;
+    Py_INCREF(x);
+    cd->structobj = x;
+    PyObject_GC_Track(cd);
+    return (PyObject *)cd;
+}
+
 static PyObject *b_newp_handle(PyObject *self, PyObject *args)
 {
     CTypeDescrObject *ct;
-    CDataObject *cd;
     PyObject *x;
     if (!PyArg_ParseTuple(args, "O!O", &CTypeDescr_Type, &ct, &x))
         return NULL;
@@ -5618,47 +5670,38 @@ static PyObject *b_newp_handle(PyObject *self, PyObject *args)
         return NULL;
     }
 
-    cd = (CDataObject *)PyObject_GC_New(CDataObject, &CDataOwningGC_Type);
-    if (cd == NULL)
-        return NULL;
-    Py_INCREF(ct);
-    cd->c_type = ct;
-    Py_INCREF(x);
-    cd->c_data = ((char *)x) - 42;
-    cd->c_weakreflist = NULL;
-    PyObject_GC_Track(cd);
-    return (PyObject *)cd;
+    return newp_handle(ct, x);
 }
 
 static PyObject *b_from_handle(PyObject *self, PyObject *arg)
 {
     CTypeDescrObject *ct;
-    char *raw;
+    CDataObject_own_structptr *orgcd;
     PyObject *x;
     if (!CData_Check(arg)) {
         PyErr_SetString(PyExc_TypeError, "expected a 'cdata' object");
         return NULL;
     }
     ct = ((CDataObject *)arg)->c_type;
-    raw = ((CDataObject *)arg)->c_data;
     if (!(ct->ct_flags & CT_CAST_ANYTHING)) {
         PyErr_Format(PyExc_TypeError,
                      "expected a 'cdata' object with a 'void *' out of "
                      "new_handle(), got '%s'", ct->ct_name);
         return NULL;
     }
-    if (!raw) {
+    orgcd = (CDataObject_own_structptr *)((CDataObject *)arg)->c_data;
+    if (!orgcd) {
         PyErr_SetString(PyExc_RuntimeError,
                         "cannot use from_handle() on NULL pointer");
         return NULL;
     }
-    x = (PyObject *)(raw + 42);
-    if (Py_REFCNT(x) <= 0) {
+    if (Py_REFCNT(orgcd) <= 0 || Py_TYPE(orgcd) != &CDataOwningGC_Type) {
         Py_FatalError("ffi.from_handle() detected that the address passed "
                       "points to garbage. If it is really the result of "
                       "ffi.new_handle(), then the Python object has already "
                       "been garbage collected");
     }
+    x = orgcd->structobj;
     Py_INCREF(x);
     return x;
 }
@@ -5766,6 +5809,10 @@ static PyObject *direct_from_buffer(CTypeDescrObject *ct, PyObject *x)
     }
 
     view = PyObject_Malloc(sizeof(Py_buffer));
+    if (view == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
     if (_my_PyObject_GetContiguousBuffer(x, view, 0) < 0)
         goto error1;
 
@@ -6306,6 +6353,9 @@ static PyObject *_cffi_from_c_wchar_t(wchar_t x) {
 }
 #endif
 
+struct _cffi_externpy_s;      /* forward declaration */
+static void cffi_call_python(struct _cffi_externpy_s *, char *args);
+
 static void *cffi_exports[] = {
     NULL,
     _cffi_to_c_i8,
@@ -6337,6 +6387,7 @@ static void *cffi_exports[] = {
     _cffi_to_c__Bool,
     _prepare_pointer_call_argument,
     convert_array_from_object,
+    cffi_call_python,
 };
 
 static struct { const char *name; int value; } all_dlopen_flags[] = {
@@ -6451,7 +6502,7 @@ init_cffi_backend(void)
     if (v == NULL || PyModule_AddObject(m, "_C_API", v) < 0)
         INITERROR;
 
-    v = PyText_FromString("1.3.1");
+    v = PyText_FromString(CFFI_VERSION);
     if (v == NULL || PyModule_AddObject(m, "__version__", v) < 0)
         INITERROR;
 
@@ -6478,7 +6529,7 @@ init_cffi_backend(void)
             INITERROR;
     }
 
-    init_errno();
+    init_cffi_tls();
     if (PyErr_Occurred())
         INITERROR;
 

+ 230 - 0
desktop/core/ext-py/cffi-1.5.2/c/call_python.c

@@ -0,0 +1,230 @@
+
+static PyObject *_get_interpstate_dict(void)
+{
+    /* hack around to return a dict that is subinterpreter-local */
+    int err;
+    PyObject *m, *modules = PyThreadState_GET()->interp->modules;
+
+    if (modules == NULL) {
+        PyErr_SetString(FFIError, "subinterpreter already gone?");
+        return NULL;
+    }
+    m = PyDict_GetItemString(modules, "_cffi_backend._extern_py");
+    if (m == NULL) {
+        m = PyModule_New("_cffi_backend._extern_py");
+        if (m == NULL)
+            return NULL;
+        err = PyDict_SetItemString(modules, "_cffi_backend._extern_py", m);
+        Py_DECREF(m);    /* sys.modules keeps one reference to m */
+        if (err < 0)
+            return NULL;
+    }
+    return PyModule_GetDict(m);
+}
+
+static PyObject *_ffi_def_extern_decorator(PyObject *outer_args, PyObject *fn)
+{
+    char *s;
+    PyObject *error, *onerror, *infotuple, *old1;
+    int index, err;
+    const struct _cffi_global_s *g;
+    struct _cffi_externpy_s *externpy;
+    CTypeDescrObject *ct;
+    FFIObject *ffi;
+    builder_c_t *types_builder;
+    PyObject *name = NULL;
+    PyObject *interpstate_dict;
+    PyObject *interpstate_key;
+
+    if (!PyArg_ParseTuple(outer_args, "OzOO", &ffi, &s, &error, &onerror))
+        return NULL;
+
+    if (s == NULL) {
+        name = PyObject_GetAttrString(fn, "__name__");
+        if (name == NULL)
+            return NULL;
+        s = PyText_AsUTF8(name);
+        if (s == NULL) {
+            Py_DECREF(name);
+            return NULL;
+        }
+    }
+
+    types_builder = &ffi->types_builder;
+    index = search_in_globals(&types_builder->ctx, s, strlen(s));
+    if (index < 0)
+        goto not_found;
+    g = &types_builder->ctx.globals[index];
+    if (_CFFI_GETOP(g->type_op) != _CFFI_OP_EXTERN_PYTHON)
+        goto not_found;
+    Py_XDECREF(name);
+
+    ct = realize_c_type(types_builder, types_builder->ctx.types,
+                        _CFFI_GETARG(g->type_op));
+    if (ct == NULL)
+        return NULL;
+
+    infotuple = prepare_callback_info_tuple(ct, fn, error, onerror, 0);
+    Py_DECREF(ct);
+    if (infotuple == NULL)
+        return NULL;
+
+    /* don't directly attach infotuple to externpy: in the presence of
+       subinterpreters, each time we switch to a different
+       subinterpreter and call the C function, it will notice the
+       change and look up infotuple from the interpstate_dict.
+    */
+    interpstate_dict = _get_interpstate_dict();
+    if (interpstate_dict == NULL) {
+        Py_DECREF(infotuple);
+        return NULL;
+    }
+
+    externpy = (struct _cffi_externpy_s *)g->address;
+    interpstate_key = PyLong_FromVoidPtr((void *)externpy);
+    if (interpstate_key == NULL) {
+        Py_DECREF(infotuple);
+        return NULL;
+    }
+
+    err = PyDict_SetItem(interpstate_dict, interpstate_key, infotuple);
+    Py_DECREF(interpstate_key);
+    Py_DECREF(infotuple);    /* interpstate_dict owns the last ref */
+    if (err < 0)
+        return NULL;
+
+    /* force _update_cache_to_call_python() to be called the next time
+       the C function invokes cffi_call_python, to update the cache */
+    old1 = externpy->reserved1;
+    externpy->reserved1 = Py_None;   /* a non-NULL value */
+    Py_INCREF(Py_None);
+    Py_XDECREF(old1);
+
+    /* return the function object unmodified */
+    Py_INCREF(fn);
+    return fn;
+
+ not_found:
+    PyErr_Format(FFIError, "ffi.def_extern('%s'): no 'extern \"Python\"' "
+                 "function with this name", s);
+    Py_XDECREF(name);
+    return NULL;
+}
+
+
+static int _update_cache_to_call_python(struct _cffi_externpy_s *externpy)
+{
+    PyObject *interpstate_dict, *interpstate_key, *infotuple, *old1, *new1;
+    PyObject *old2;
+
+    interpstate_dict = _get_interpstate_dict();
+    if (interpstate_dict == NULL)
+        goto error;
+
+    interpstate_key = PyLong_FromVoidPtr((void *)externpy);
+    if (interpstate_key == NULL)
+        goto error;
+
+    infotuple = PyDict_GetItem(interpstate_dict, interpstate_key);
+    Py_DECREF(interpstate_key);
+    if (infotuple == NULL)
+        return 3;    /* no ffi.def_extern() from this subinterpreter */
+
+    new1 = PyThreadState_GET()->interp->modules;
+    Py_INCREF(new1);
+    Py_INCREF(infotuple);
+    old1 = (PyObject *)externpy->reserved1;
+    old2 = (PyObject *)externpy->reserved2;
+    externpy->reserved1 = new1;         /* holds a reference        */
+    externpy->reserved2 = infotuple;    /* holds a reference (issue #246) */
+    Py_XDECREF(old1);
+    Py_XDECREF(old2);
+
+    return 0;   /* no error */
+
+ error:
+    PyErr_Clear();
+    return 2;   /* out of memory? */
+}
+
+#if (defined(WITH_THREAD) && !defined(_MSC_VER) &&   \
+     !defined(__amd64__) && !defined(__x86_64__) &&   \
+     !defined(__i386__) && !defined(__i386))
+# define read_barrier()  __sync_synchronize()
+#else
+# define read_barrier()  (void)0
+#endif
+
+static void cffi_call_python(struct _cffi_externpy_s *externpy, char *args)
+{
+    /* Invoked by the helpers generated from extern "Python" in the cdef.
+
+       'externpy' is a static structure that describes which of the
+       extern "Python" functions is called.  It has got fields 'name' and
+       'type_index' describing the function, and more reserved fields
+       that are initially zero.  These reserved fields are set up by
+       ffi.def_extern(), which invokes _ffi_def_extern_decorator() above.
+
+       'args' is a pointer to an array of 8-byte entries.  Each entry
+       contains an argument.  If an argument is less than 8 bytes, only
+       the part at the beginning of the entry is initialized.  If an
+       argument is 'long double' or a struct/union, then it is passed
+       by reference.
+
+       'args' is also used as the place to write the result to
+       (directly, even if more than 8 bytes).  In all cases, 'args' is
+       at least 8 bytes in size.
+    */
+    int err = 0;
+
+    /* This read barrier is needed for _embedding.h.  It is paired
+       with the write_barrier() there.  Without this barrier, we can
+       in theory see the following situation: the Python
+       initialization code already ran (in another thread), and the
+       '_cffi_call_python' function pointer directed execution here;
+       but any number of other data could still be seen as
+       uninitialized below.  For example, 'externpy' would still
+       contain NULLs even though it was correctly set up, or
+       'interpreter_lock' (the GIL inside CPython) would still be seen
+       as NULL, or 'autoInterpreterState' (used by
+       PyGILState_Ensure()) would be NULL or contain bogus fields.
+    */
+    read_barrier();
+
+    save_errno();
+
+    /* We need the infotuple here.  We could always go through
+       interp->modules['..'][externpy], but to avoid the extra dict
+       lookups, we cache in (reserved1, reserved2) the last seen pair
+       (interp->modules, infotuple).
+    */
+    if (externpy->reserved1 == NULL) {
+        /* Not initialized!  We didn't call @ffi.def_extern() on this
+           externpy object from any subinterpreter at all. */
+        err = 1;
+    }
+    else {
+        PyGILState_STATE state = gil_ensure();
+        if (externpy->reserved1 != PyThreadState_GET()->interp->modules) {
+            /* Update the (reserved1, reserved2) cache.  This will fail
+               if we didn't call @ffi.def_extern() in this particular
+               subinterpreter. */
+            err = _update_cache_to_call_python(externpy);
+        }
+        if (!err) {
+            general_invoke_callback(0, args, args, externpy->reserved2);
+        }
+        gil_release(state);
+    }
+    if (err) {
+        static const char *msg[] = {
+            "no code was attached to it yet with @ffi.def_extern()",
+            "got internal exception (out of memory / shutdown issue)",
+            "@ffi.def_extern() was not called in the current subinterpreter",
+        };
+        fprintf(stderr, "extern \"Python\": function %s() called, "
+                        "but %s.  Returning 0.\n", externpy->name, msg[err-1]);
+        memset(args, 0, externpy->size_of_result);
+    }
+    restore_errno();
+}

+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/cdlopen.c → desktop/core/ext-py/cffi-1.5.2/c/cdlopen.c


+ 24 - 9
desktop/core/ext-py/cffi-1.3.1/c/cffi1_module.c → desktop/core/ext-py/cffi-1.5.2/c/cffi1_module.c

@@ -3,7 +3,7 @@
 #include "realize_c_type.c"
 
 #define CFFI_VERSION_MIN    0x2601
-#define CFFI_VERSION_MAX    0x26FF
+#define CFFI_VERSION_MAX    0x27FF
 
 typedef struct FFIObject_s FFIObject;
 typedef struct LibObject_s LibObject;
@@ -16,12 +16,13 @@ static PyTypeObject Lib_Type;   /* forward */
 #include "lib_obj.c"
 #include "cdlopen.c"
 #include "commontypes.c"
+#include "call_python.c"
 
 
 static int init_ffi_lib(PyObject *m)
 {
     PyObject *x;
-    int i;
+    int i, res;
     static char init_done = 0;
 
     if (PyType_Ready(&FFI_Type) < 0)
@@ -47,11 +48,13 @@ static int init_ffi_lib(PyObject *m)
 
         for (i = 0; all_dlopen_flags[i].name != NULL; i++) {
             x = PyInt_FromLong(all_dlopen_flags[i].value);
-            if (x == NULL || PyDict_SetItemString(FFI_Type.tp_dict,
-                                                  all_dlopen_flags[i].name,
-                                                  x) < 0)
+            if (x == NULL)
                 return -1;
+            res = PyDict_SetItemString(FFI_Type.tp_dict,
+                                       all_dlopen_flags[i].name, x);
             Py_DECREF(x);
+            if (res < 0)
+                return -1;
         }
         init_done = 1;
     }
@@ -149,7 +152,7 @@ static PyObject *b_init_cffi_1_0_external_module(PyObject *self, PyObject *arg)
     PyObject *m, *modules_dict;
     FFIObject *ffi;
     LibObject *lib;
-    Py_ssize_t version;
+    Py_ssize_t version, num_exports;
     char *module_name, *exports, *module_name_with_lib;
     void **raw;
     const struct _cffi_type_context_s *ctx;
@@ -166,13 +169,18 @@ static PyObject *b_init_cffi_1_0_external_module(PyObject *self, PyObject *arg)
     if (version < CFFI_VERSION_MIN || version > CFFI_VERSION_MAX) {
         if (!PyErr_Occurred())
             PyErr_Format(PyExc_ImportError,
-                         "cffi extension module '%s' has unknown version %p",
-                         module_name, (void *)version);
+                "cffi extension module '%s' uses an unknown version tag %p. "
+                "This module might need a more recent version of cffi "
+                "than the one currently installed, which is %s",
+                module_name, (void *)version, CFFI_VERSION);
         return NULL;
     }
 
     /* initialize the exports array */
-    memcpy(exports, (char *)cffi_exports, sizeof(cffi_exports));
+    num_exports = 25;
+    if (ctx->flags & 1)    /* set to mean that 'extern "Python"' is used */
+        num_exports = 26;
+    memcpy(exports, (char *)cffi_exports, num_exports * sizeof(void *));
 
     /* make the module object */
     m = _my_Py_InitModule(module_name);
@@ -206,5 +214,12 @@ static PyObject *b_init_cffi_1_0_external_module(PyObject *self, PyObject *arg)
                              (PyObject *)lib) < 0)
         return NULL;
 
+#if PY_MAJOR_VERSION >= 3
+    /* add manually 'module_name' in sys.modules: it seems that 
+       Py_InitModule() is not enough to do that */
+    if (PyDict_SetItemString(modules_dict, module_name, m) < 0)
+        return NULL;
+#endif
+
     return m;
 }

+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/cglob.c → desktop/core/ext-py/cffi-1.5.2/c/cglob.c


+ 2 - 1
desktop/core/ext-py/cffi-1.3.1/c/commontypes.c → desktop/core/ext-py/cffi-1.5.2/c/commontypes.c

@@ -199,7 +199,8 @@ static const char *get_common_type(const char *search, size_t search_len)
 
 static PyObject *b__get_common_types(PyObject *self, PyObject *arg)
 {
-    int i, err;
+    int err;
+    size_t i;
     for (i = 0; i < num_common_simple_types; i++) {
         const char *s = common_simple_types[i];
         PyObject *o = PyText_FromString(s + strlen(s) + 1);

+ 191 - 60
desktop/core/ext-py/cffi-1.3.1/c/ffi_obj.c → desktop/core/ext-py/cffi-1.5.2/c/ffi_obj.c

@@ -24,6 +24,7 @@
 struct FFIObject_s {
     PyObject_HEAD
     PyObject *gc_wrefs, *gc_wrefs_freelist;
+    PyObject *init_once_cache;
     struct _cffi_parse_info_s info;
     char ctx_is_static, ctx_is_nonempty;
     builder_c_t types_builder;
@@ -52,6 +53,7 @@ static FFIObject *ffi_internal_new(PyTypeObject *ffitype,
     }
     ffi->gc_wrefs = NULL;
     ffi->gc_wrefs_freelist = NULL;
+    ffi->init_once_cache = NULL;
     ffi->info.ctx = &ffi->types_builder.ctx;
     ffi->info.output = internal_output;
     ffi->info.output_size = FFI_COMPLEXITY_OUTPUT;
@@ -65,6 +67,7 @@ static void ffi_dealloc(FFIObject *ffi)
     PyObject_GC_UnTrack(ffi);
     Py_XDECREF(ffi->gc_wrefs);
     Py_XDECREF(ffi->gc_wrefs_freelist);
+    Py_XDECREF(ffi->init_once_cache);
 
     free_builder_c(&ffi->types_builder, ffi->ctx_is_static);
 
@@ -332,7 +335,7 @@ PyDoc_STRVAR(ffi_new_doc,
 "pointer to the memory somewhere else, e.g. into another structure.");
 
 static PyObject *_ffi_new(FFIObject *self, PyObject *args, PyObject *kwds,
-                          cffi_allocator_t allocator)
+                          const cffi_allocator_t *allocator)
 {
     CTypeDescrObject *ct;
     PyObject *arg, *init = Py_None;
@@ -350,15 +353,22 @@ static PyObject *_ffi_new(FFIObject *self, PyObject *args, PyObject *kwds,
 
 static PyObject *ffi_new(FFIObject *self, PyObject *args, PyObject *kwds)
 {
-    return _ffi_new(self, args, kwds, default_allocator);
+    return _ffi_new(self, args, kwds, &default_allocator);
 }
 
 static PyObject *_ffi_new_with_allocator(PyObject *allocator, PyObject *args,
                                          PyObject *kwds)
 {
+    cffi_allocator_t alloc1;
+    PyObject *my_alloc, *my_free;
+    my_alloc = PyTuple_GET_ITEM(allocator, 1);
+    my_free  = PyTuple_GET_ITEM(allocator, 2);
+    alloc1.ca_alloc = (my_alloc == Py_None ? NULL : my_alloc);
+    alloc1.ca_free  = (my_free  == Py_None ? NULL : my_free);
+    alloc1.ca_dont_clear = (PyTuple_GET_ITEM(allocator, 3) == Py_False);
+
     return _ffi_new((FFIObject *)PyTuple_GET_ITEM(allocator, 0),
-                    args, kwds,
-                    &PyTuple_GET_ITEM(allocator, 1));
+                    args, kwds, &alloc1);
 }
 
 PyDoc_STRVAR(ffi_new_allocator_doc,
@@ -393,27 +403,14 @@ static PyObject *ffi_new_allocator(FFIObject *self, PyObject *args,
         return NULL;
     }
 
-    allocator = PyTuple_New(4);
+    allocator = PyTuple_Pack(4,
+                             (PyObject *)self,
+                             my_alloc,
+                             my_free,
+                             PyBool_FromLong(should_clear_after_alloc));
     if (allocator == NULL)
         return NULL;
 
-    Py_INCREF(self);
-    PyTuple_SET_ITEM(allocator, 0, (PyObject *)self);
-
-    if (my_alloc != Py_None) {
-        Py_INCREF(my_alloc);
-        PyTuple_SET_ITEM(allocator, 1, my_alloc);
-    }
-    if (my_free != Py_None) {
-        Py_INCREF(my_free);
-        PyTuple_SET_ITEM(allocator, 2, my_free);
-    }
-    if (!should_clear_after_alloc) {
-        PyObject *my_true = Py_True;
-        Py_INCREF(my_true);
-        PyTuple_SET_ITEM(allocator, 3, my_true);  /* dont_clear_after_alloc */
-    }
-
     {
         static PyMethodDef md = {"allocator",
                                  (PyCFunction)_ffi_new_with_allocator,
@@ -676,18 +673,8 @@ PyDoc_STRVAR(ffi_new_handle_doc,
 
 static PyObject *ffi_new_handle(FFIObject *self, PyObject *arg)
 {
-    CDataObject *cd;
-
-    cd = (CDataObject *)PyObject_GC_New(CDataObject, &CDataOwningGC_Type);
-    if (cd == NULL)
-        return NULL;
-    Py_INCREF(g_ct_voidp);     // <ctype 'void *'>
-    cd->c_type = g_ct_voidp;
-    Py_INCREF(arg);
-    cd->c_data = ((char *)arg) - 42;
-    cd->c_weakreflist = NULL;
-    PyObject_GC_Track(cd);
-    return (PyObject *)cd;
+    /* g_ct_voidp is equal to <ctype 'void *'> */
+    return newp_handle(g_ct_voidp, arg);
 }
 
 PyDoc_STRVAR(ffi_from_handle_doc,
@@ -696,32 +683,8 @@ PyDoc_STRVAR(ffi_from_handle_doc,
 "cdata object returned by new_handle() is still alive (somewhere else\n"
 "in the program).  Failure to follow these rules will crash.");
 
-static PyObject *ffi_from_handle(PyObject *self, PyObject *arg)
-{
-    CTypeDescrObject *ct;
-    char *raw;
-    PyObject *x;
-    if (!CData_Check(arg)) {
-        PyErr_SetString(PyExc_TypeError, "expected a 'cdata' object");
-        return NULL;
-    }
-    ct = ((CDataObject *)arg)->c_type;
-    raw = ((CDataObject *)arg)->c_data;
-    if (!(ct->ct_flags & CT_CAST_ANYTHING)) {
-        PyErr_Format(PyExc_TypeError,
-                     "expected a 'cdata' object with a 'void *' out of "
-                     "new_handle(), got '%s'", ct->ct_name);
-        return NULL;
-    }
-    if (!raw) {
-        PyErr_SetString(PyExc_RuntimeError,
-                        "cannot use from_handle() on NULL pointer");
-        return NULL;
-    }
-    x = (PyObject *)(raw + 42);
-    Py_INCREF(x);
-    return x;
-}
+#define ffi_from_handle  b_from_handle   /* ffi_from_handle => b_from_handle
+                                            from _cffi_backend.c */
 
 PyDoc_STRVAR(ffi_from_buffer_doc,
 "Return a <cdata 'char[]'> that points to the data of the given Python\n"
@@ -744,6 +707,41 @@ PyDoc_STRVAR(ffi_gc_doc,
 #define ffi_gc  b_gcp     /* ffi_gc() => b_gcp()
                              from _cffi_backend.c */
 
+PyDoc_STRVAR(ffi_def_extern_doc,
+"A decorator.  Attaches the decorated Python function to the C code\n"
+"generated for the 'extern \"Python\"' function of the same name.\n"
+"Calling the C function will then invoke the Python function.\n"
+"\n"
+"Optional arguments: 'name' is the name of the C function, if\n"
+"different from the Python function; and 'error' and 'onerror'\n"
+"handle what occurs if the Python function raises an exception\n"
+"(see the docs for details).");
+
+/* forward; see call_python.c */
+static PyObject *_ffi_def_extern_decorator(PyObject *, PyObject *);
+
+static PyObject *ffi_def_extern(FFIObject *self, PyObject *args,
+                                PyObject *kwds)
+{
+    static PyMethodDef md = {"def_extern_decorator",
+                             (PyCFunction)_ffi_def_extern_decorator, METH_O};
+    PyObject *name = Py_None, *error = Py_None;
+    PyObject *res, *onerror = Py_None;
+    static char *keywords[] = {"name", "error", "onerror", NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", keywords,
+                                     &name, &error, &onerror))
+        return NULL;
+
+    args = Py_BuildValue("(OOOO)", (PyObject *)self, name, error, onerror);
+    if (args == NULL)
+        return NULL;
+
+    res = PyCFunction_New(&md, args);
+    Py_DECREF(args);
+    return res;
+}
+
 PyDoc_STRVAR(ffi_callback_doc,
 "Return a callback object or a decorator making such a callback object.\n"
 "'cdecl' must name a C function pointer type.  The callback invokes the\n"
@@ -881,12 +879,144 @@ PyDoc_STRVAR(ffi_memmove_doc,
 #define ffi_memmove  b_memmove     /* ffi_memmove() => b_memmove()
                                       from _cffi_backend.c */
 
+#ifdef WITH_THREAD
+# include "pythread.h"
+#else
+typedef void *PyThread_type_lock;
+# define PyThread_allocate_lock()        ((void *)-1)
+# define PyThread_free_lock(lock)        ((void)(lock))
+# define PyThread_acquire_lock(lock, _)  ((void)(lock))
+# define PyThread_release_lock(lock)     ((void)(lock))
+#endif
+
+PyDoc_STRVAR(ffi_init_once_doc,
+"init_once(function, tag): run function() once.  More precisely,\n"
+"'function()' is called the first time we see a given 'tag'.\n"
+"\n"
+"The return value of function() is remembered and returned by the current\n"
+"and all future init_once() with the same tag.  If init_once() is called\n"
+"from multiple threads in parallel, all calls block until the execution\n"
+"of function() is done.  If function() raises an exception, it is\n"
+"propagated and nothing is cached.");
+
+#if PY_MAJOR_VERSION < 3
+/* PyCapsule_New is redefined to be PyCObject_FromVoidPtr in _cffi_backend,
+   which gives 2.6 compatibility; but the destructor signature is different */
+static void _free_init_once_lock(void *lock)
+{
+    PyThread_free_lock((PyThread_type_lock)lock);
+}
+#else
+static void _free_init_once_lock(PyObject *capsule)
+{
+    PyThread_type_lock lock;
+    lock = PyCapsule_GetPointer(capsule, "cffi_init_once_lock");
+    if (lock != NULL)
+        PyThread_free_lock(lock);
+}
+#endif
+
+static PyObject *ffi_init_once(FFIObject *self, PyObject *args, PyObject *kwds)
+{
+    static char *keywords[] = {"func", "tag", NULL};
+    PyObject *cache, *func, *tag, *tup, *res, *x, *lockobj;
+    PyThread_type_lock lock;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO", keywords, &func, &tag))
+        return NULL;
+
+    /* a lot of fun with reference counting and error checking
+       in this function */
+
+    /* atomically get or create a new dict (no GIL release) */
+    cache = self->init_once_cache;
+    if (cache == NULL) {
+        cache = PyDict_New();
+        if (cache == NULL)
+            return NULL;
+        self->init_once_cache = cache;
+    }
+
+    /* get the tuple from cache[tag], or make a new one: (False, lock) */
+    tup = PyDict_GetItem(cache, tag);
+    if (tup == NULL) {
+        lock = PyThread_allocate_lock();
+        if (lock == NULL)
+            return NULL;
+        x = PyCapsule_New(lock, "cffi_init_once_lock", _free_init_once_lock);
+        if (x == NULL) {
+            PyThread_free_lock(lock);
+            return NULL;
+        }
+        tup = PyTuple_Pack(2, Py_False, x);
+        Py_DECREF(x);
+        if (tup == NULL)
+            return NULL;
+        x = tup;
+
+        /* Possible corner case if 'tag' is an object overriding __eq__
+           in pure Python: the GIL may be released when we are running it.
+           We really need to call dict.setdefault(). */
+        tup = PyObject_CallMethod(cache, "setdefault", "OO", tag, x);
+        Py_DECREF(x);
+        if (tup == NULL)
+            return NULL;
+
+        Py_DECREF(tup);   /* there is still a ref inside the dict */
+    }
+
+    res = PyTuple_GET_ITEM(tup, 1);
+    Py_INCREF(res);
+
+    if (PyTuple_GET_ITEM(tup, 0) == Py_True) {
+        /* tup == (True, result): return the result. */
+        return res;
+    }
+
+    /* tup == (False, lock) */
+    lockobj = res;
+    lock = (PyThread_type_lock)PyCapsule_GetPointer(lockobj,
+                                                    "cffi_init_once_lock");
+    if (lock == NULL) {
+        Py_DECREF(lockobj);
+        return NULL;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    PyThread_acquire_lock(lock, WAIT_LOCK);
+    Py_END_ALLOW_THREADS
+
+    x = PyDict_GetItem(cache, tag);
+    if (x != NULL && PyTuple_GET_ITEM(x, 0) == Py_True) {
+        /* the real result was put in the dict while we were waiting
+           for PyThread_acquire_lock() above */
+        res = PyTuple_GET_ITEM(x, 1);
+        Py_INCREF(res);
+    }
+    else {
+        res = PyObject_CallFunction(func, "");
+        if (res != NULL) {
+            tup = PyTuple_Pack(2, Py_True, res);
+            if (tup == NULL || PyDict_SetItem(cache, tag, tup) < 0) {
+                Py_XDECREF(tup);
+                Py_DECREF(res);
+                res = NULL;
+            }
+        }
+    }
+
+    PyThread_release_lock(lock);
+    Py_DECREF(lockobj);
+    return res;
+}
+
 
 #define METH_VKW  (METH_VARARGS | METH_KEYWORDS)
 static PyMethodDef ffi_methods[] = {
  {"addressof",  (PyCFunction)ffi_addressof,  METH_VARARGS, ffi_addressof_doc},
  {"alignof",    (PyCFunction)ffi_alignof,    METH_O,       ffi_alignof_doc},
  {"buffer",     (PyCFunction)ffi_buffer,     METH_VKW,     ffi_buffer_doc},
+ {"def_extern", (PyCFunction)ffi_def_extern, METH_VKW,     ffi_def_extern_doc},
  {"callback",   (PyCFunction)ffi_callback,   METH_VKW,     ffi_callback_doc},
  {"cast",       (PyCFunction)ffi_cast,       METH_VARARGS, ffi_cast_doc},
  {"dlclose",    (PyCFunction)ffi_dlclose,    METH_VARARGS, ffi_dlclose_doc},
@@ -898,6 +1028,7 @@ static PyMethodDef ffi_methods[] = {
 #ifdef MS_WIN32
  {"getwinerror",(PyCFunction)ffi_getwinerror,METH_VKW,     ffi_getwinerror_doc},
 #endif
+ {"init_once",  (PyCFunction)ffi_init_once,  METH_VKW,     ffi_init_once_doc},
  {"integer_const",(PyCFunction)ffi_int_const,METH_VKW,     ffi_int_const_doc},
  {"memmove",    (PyCFunction)ffi_memmove,    METH_VKW,     ffi_memmove_doc},
  {"new",        (PyCFunction)ffi_new,        METH_VKW,     ffi_new_doc},

+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/file_emulator.h → desktop/core/ext-py/cffi-1.5.2/c/file_emulator.h


+ 23 - 3
desktop/core/ext-py/cffi-1.3.1/c/lib_obj.c → desktop/core/ext-py/cffi-1.5.2/c/lib_obj.c

@@ -364,6 +364,16 @@ static PyObject *lib_build_and_cache_attr(LibObject *lib, PyObject *name,
         break;
     }
 
+    case _CFFI_OP_EXTERN_PYTHON:
+        /* for reading 'lib.bar' where bar is declared with extern "Python" */
+        ct = realize_c_type(types_builder, types_builder->ctx.types,
+                            _CFFI_GETARG(g->type_op));
+        if (ct == NULL)
+            return NULL;
+        x = convert_to_object((char *)&g->size_or_direct_fn, ct);
+        Py_DECREF(ct);
+        break;
+
     default:
         PyErr_Format(PyExc_NotImplementedError, "in lib_build_attr: op=%d",
                      (int)_CFFI_GETOP(g->type_op));
@@ -449,6 +459,7 @@ static PyObject *_lib_dict(LibObject *lib)
 
 static PyObject *lib_getattr(LibObject *lib, PyObject *name)
 {
+    char *p;
     PyObject *x;
     LIB_GET_OR_CACHE_ADDR(x, lib, name, goto missing);
 
@@ -459,16 +470,25 @@ static PyObject *lib_getattr(LibObject *lib, PyObject *name)
     return x;
 
  missing:
-    if (strcmp(PyText_AsUTF8(name), "__all__") == 0) {
+    p = PyText_AsUTF8(name);
+    if (p == NULL)
+        return NULL;
+    if (strcmp(p, "__all__") == 0) {
         PyErr_Clear();
         return _lib_dir1(lib, 1);
     }
-    if (strcmp(PyText_AsUTF8(name), "__dict__") == 0) {
+    if (strcmp(p, "__dict__") == 0) {
         PyErr_Clear();
         return _lib_dict(lib);
     }
+    if (strcmp(p, "__class__") == 0) {
+        PyErr_Clear();
+        x = (PyObject *)Py_TYPE(lib);
+        Py_INCREF(x);
+        return x;
+    }
     /* this hack is for Python 3.5 */
-    if (strcmp(PyText_AsUTF8(name), "__name__") == 0) {
+    if (strcmp(p, "__name__") == 0) {
         PyErr_Clear();
         return lib_repr(lib);
     }

+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/libffi_msvc/ffi.c → desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/ffi.c


+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/libffi_msvc/ffi.h → desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/ffi.h


+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/libffi_msvc/ffi_common.h → desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/ffi_common.h


+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/libffi_msvc/fficonfig.h → desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/fficonfig.h


+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/libffi_msvc/ffitarget.h → desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/ffitarget.h


+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/libffi_msvc/prep_cif.c → desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/prep_cif.c


+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/libffi_msvc/types.c → desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/types.c


+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/libffi_msvc/win32.c → desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/win32.c


+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/libffi_msvc/win64.asm → desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/win64.asm


BIN
desktop/core/ext-py/cffi-1.5.2/c/libffi_msvc/win64.obj


+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/malloc_closure.h → desktop/core/ext-py/cffi-1.5.2/c/malloc_closure.h


+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/minibuffer.h → desktop/core/ext-py/cffi-1.5.2/c/minibuffer.h


+ 136 - 0
desktop/core/ext-py/cffi-1.5.2/c/misc_thread_common.h

@@ -0,0 +1,136 @@
+#ifndef WITH_THREAD
+# error "xxx no-thread configuration not tested, please report if you need that"
+#endif
+
+
+struct cffi_tls_s {
+    /* The locally-made thread state.  This is only non-null in case
+       we build the thread state here.  It remains null if this thread
+       had already a thread state provided by CPython. */
+    PyThreadState *local_thread_state;
+
+#ifndef USE__THREAD
+    /* The saved errno.  If the C compiler supports '__thread', then
+       we use that instead. */
+    int saved_errno;
+#endif
+
+#ifdef MS_WIN32
+    /* The saved lasterror, on Windows. */
+    int saved_lasterror;
+#endif
+};
+
+static struct cffi_tls_s *get_cffi_tls(void);   /* in misc_thread_posix.h 
+                                                   or misc_win32.h */
+
+static void cffi_thread_shutdown(void *p)
+{
+    struct cffi_tls_s *tls = (struct cffi_tls_s *)p;
+
+    if (tls->local_thread_state != NULL) {
+        /* We need to re-acquire the GIL temporarily to free the
+           thread state.  I hope it is not a problem to do it in
+           a thread-local destructor.
+        */
+        PyEval_RestoreThread(tls->local_thread_state);
+        PyThreadState_DeleteCurrent();
+    }
+    free(tls);
+}
+
+/* USE__THREAD is defined by setup.py if it finds that it is
+   syntactically valid to use "__thread" with this C compiler. */
+#ifdef USE__THREAD
+
+static __thread int cffi_saved_errno = 0;
+static void save_errno_only(void) { cffi_saved_errno = errno; }
+static void restore_errno_only(void) { errno = cffi_saved_errno; }
+
+#else
+
+static void save_errno_only(void)
+{
+    int saved = errno;
+    struct cffi_tls_s *tls = get_cffi_tls();
+    if (tls != NULL)
+        tls->saved_errno = saved;
+}
+
+static void restore_errno_only(void)
+{
+    struct cffi_tls_s *tls = get_cffi_tls();
+    if (tls != NULL)
+        errno = tls->saved_errno;
+}
+
+#endif
+
+
+/* Seems that CPython 3.5.1 made our job harder.  Did not find out how
+   to do that without these hacks.  We can't use PyThreadState_GET(),
+   because that calls PyThreadState_Get() which fails an assert if the
+   result is NULL. */
+#if PY_MAJOR_VERSION >= 3 && !defined(_Py_atomic_load_relaxed)
+                             /* this was abruptly un-defined in 3.5.1 */
+void *volatile _PyThreadState_Current;
+   /* XXX simple volatile access is assumed atomic */
+#  define _Py_atomic_load_relaxed(pp)  (*(pp))
+#endif
+
+static PyThreadState *get_current_ts(void)
+{
+#if PY_MAJOR_VERSION >= 3
+    return (PyThreadState*)_Py_atomic_load_relaxed(&_PyThreadState_Current);
+#else
+    return _PyThreadState_Current;
+#endif
+}
+
+static PyGILState_STATE gil_ensure(void)
+{
+    /* Called at the start of a callback.  Replacement for
+       PyGILState_Ensure().
+    */
+    PyGILState_STATE result;
+    struct cffi_tls_s *tls;
+    PyThreadState *ts = PyGILState_GetThisThreadState();
+
+    if (ts != NULL) {
+        ts->gilstate_counter++;
+        if (ts != get_current_ts()) {
+            /* common case: 'ts' is our non-current thread state and
+               we have to make it current and acquire the GIL */
+            PyEval_RestoreThread(ts);
+            return PyGILState_UNLOCKED;
+        }
+        else {
+            return PyGILState_LOCKED;
+        }
+    }
+    else {
+        /* no thread state here so far. */
+        result = PyGILState_Ensure();
+        assert(result == PyGILState_UNLOCKED);
+
+        ts = PyGILState_GetThisThreadState();
+        assert(ts != NULL);
+        assert(ts == get_current_ts());
+        assert(ts->gilstate_counter >= 1);
+
+        /* Save the now-current thread state inside our 'local_thread_state'
+           field, to be removed at thread shutdown */
+        tls = get_cffi_tls();
+        if (tls != NULL) {
+            tls->local_thread_state = ts;
+            ts->gilstate_counter++;
+        }
+
+        return result;
+    }
+}
+
+static void gil_release(PyGILState_STATE oldstate)
+{
+    PyGILState_Release(oldstate);
+}

+ 49 - 0
desktop/core/ext-py/cffi-1.5.2/c/misc_thread_posix.h

@@ -0,0 +1,49 @@
+/*
+  Logic for a better replacement of PyGILState_Ensure().
+
+  This version is ready to handle the case of a non-Python-started
+  thread in which we do a large number of calls to CFFI callbacks.  If
+  we were to rely on PyGILState_Ensure() for that, we would constantly
+  be creating and destroying PyThreadStates---it is slow, and
+  PyThreadState_Delete() will actually walk the list of all thread
+  states, making it O(n). :-(
+
+  This version only creates one PyThreadState object the first time we
+  see a given thread, and keep it alive until the thread is really
+  shut down, using a destructor on the tls key.
+*/
+
+#include <pthread.h>
+#include "misc_thread_common.h"
+
+
+static pthread_key_t cffi_tls_key;
+
+static void init_cffi_tls(void)
+{
+    if (pthread_key_create(&cffi_tls_key, &cffi_thread_shutdown) != 0)
+        PyErr_SetString(PyExc_OSError, "pthread_key_create() failed");
+}
+
+static struct cffi_tls_s *_make_cffi_tls(void)
+{
+    void *p = calloc(1, sizeof(struct cffi_tls_s));
+    if (p == NULL)
+        return NULL;
+    if (pthread_setspecific(cffi_tls_key, p) != 0) {
+        free(p);
+        return NULL;
+    }
+    return p;
+}
+
+static struct cffi_tls_s *get_cffi_tls(void)
+{
+    void *p = pthread_getspecific(cffi_tls_key);
+    if (p == NULL)
+        p = _make_cffi_tls();
+    return (struct cffi_tls_s *)p;
+}
+
+#define save_errno      save_errno_only
+#define restore_errno   restore_errno_only

+ 42 - 42
desktop/core/ext-py/cffi-1.3.1/c/misc_win32.h → desktop/core/ext-py/cffi-1.5.2/c/misc_win32.h

@@ -1,16 +1,38 @@
 #include <malloc.h>   /* for alloca() */
 
+
 /************************************************************/
 /* errno and GetLastError support */
 
-struct cffi_errno_s {
-    int saved_errno;
-    int saved_lasterror;
-};
+#include "misc_thread_common.h"
 
 static DWORD cffi_tls_index = TLS_OUT_OF_INDEXES;
 
-static void init_errno(void)
+BOOL WINAPI DllMain(HINSTANCE hinstDLL,
+                    DWORD     reason_for_call,
+                    LPVOID    reserved)
+{
+    LPVOID p;
+
+    switch (reason_for_call) {
+
+    case DLL_THREAD_DETACH:
+        if (cffi_tls_index != TLS_OUT_OF_INDEXES) {
+            p = TlsGetValue(cffi_tls_index);
+            if (p != NULL) {
+                TlsSetValue(cffi_tls_index, NULL);
+                cffi_thread_shutdown(p);
+            }
+        }
+        break;
+
+    default:
+        break;
+    }
+    return TRUE;
+}
+
+static void init_cffi_tls(void)
 {
     if (cffi_tls_index == TLS_OUT_OF_INDEXES) {
         cffi_tls_index = TlsAlloc();
@@ -19,28 +41,29 @@ static void init_errno(void)
     }
 }
 
-static struct cffi_errno_s *_geterrno_object(void)
+static struct cffi_tls_s *get_cffi_tls(void)
 {
     LPVOID p = TlsGetValue(cffi_tls_index);
 
     if (p == NULL) {
-        /* XXX this malloc() leaks */
-        p = malloc(sizeof(struct cffi_errno_s));
+        p = malloc(sizeof(struct cffi_tls_s));
         if (p == NULL)
             return NULL;
-        memset(p, 0, sizeof(struct cffi_errno_s));
+        memset(p, 0, sizeof(struct cffi_tls_s));
         TlsSetValue(cffi_tls_index, p);
     }
-    return (struct cffi_errno_s *)p;
+    return (struct cffi_tls_s *)p;
 }
 
+#ifdef USE__THREAD
+# error "unexpected USE__THREAD on Windows"
+#endif
+
 static void save_errno(void)
 {
     int current_err = errno;
     int current_lasterr = GetLastError();
-    struct cffi_errno_s *p;
-
-    p = _geterrno_object();
+    struct cffi_tls_s *p = get_cffi_tls();
     if (p != NULL) {
         p->saved_errno = current_err;
         p->saved_lasterror = current_lasterr;
@@ -48,23 +71,9 @@ static void save_errno(void)
     /* else: cannot report the error */
 }
 
-static void save_errno_only(void)
-{
-    int current_err = errno;
-    struct cffi_errno_s *p;
-
-    p = _geterrno_object();
-    if (p != NULL) {
-        p->saved_errno = current_err;
-    }
-    /* else: cannot report the error */
-}
-
 static void restore_errno(void)
 {
-    struct cffi_errno_s *p;
-
-    p = _geterrno_object();
+    struct cffi_tls_s *p = get_cffi_tls();
     if (p != NULL) {
         SetLastError(p->saved_lasterror);
         errno = p->saved_errno;
@@ -72,16 +81,8 @@ static void restore_errno(void)
     /* else: cannot report the error */
 }
 
-static void restore_errno_only(void)
-{
-    struct cffi_errno_s *p;
+/************************************************************/
 
-    p = _geterrno_object();
-    if (p != NULL) {
-        errno = p->saved_errno;
-    }
-    /* else: cannot report the error */
-}
 
 #if PY_MAJOR_VERSION >= 3
 static PyObject *b_getwinerror(PyObject *self, PyObject *args, PyObject *kwds)
@@ -96,8 +97,7 @@ static PyObject *b_getwinerror(PyObject *self, PyObject *args, PyObject *kwds)
         return NULL;
 
     if (err == -1) {
-        struct cffi_errno_s *p;
-        p = _geterrno_object();
+        struct cffi_tls_s *p = get_cffi_tls();
         if (p == NULL)
             return PyErr_NoMemory();
         err = p->saved_lasterror;
@@ -138,7 +138,7 @@ static PyObject *b_getwinerror(PyObject *self, PyObject *args, PyObject *kwds)
     int len;
     char *s;
     char *s_buf = NULL; /* Free via LocalFree */
-    char s_small_buf[28]; /* Room for "Windows Error 0xFFFFFFFF" */
+    char s_small_buf[40]; /* Room for "Windows Error 0xFFFFFFFFFFFFFFFF" */
     PyObject *v;
     static char *keywords[] = {"code", NULL};
 
@@ -146,8 +146,7 @@ static PyObject *b_getwinerror(PyObject *self, PyObject *args, PyObject *kwds)
         return NULL;
 
     if (err == -1) {
-        struct cffi_errno_s *p;
-        p = _geterrno_object();
+        struct cffi_tls_s *p = get_cffi_tls();
         if (p == NULL)
             return PyErr_NoMemory();
         err = p->saved_lasterror;
@@ -182,6 +181,7 @@ static PyObject *b_getwinerror(PyObject *self, PyObject *args, PyObject *kwds)
 }
 #endif
 
+
 /************************************************************/
 /* Emulate dlopen()&co. from the Windows API */
 

+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/parse_c_type.c → desktop/core/ext-py/cffi-1.5.2/c/parse_c_type.c


+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/realize_c_type.c → desktop/core/ext-py/cffi-1.5.2/c/realize_c_type.c


+ 1 - 1
desktop/core/ext-py/cffi-1.3.1/c/test_c.py → desktop/core/ext-py/cffi-1.5.2/c/test_c.py

@@ -12,7 +12,7 @@ from _cffi_backend import _testfunc, _get_types, _get_common_types, __version__
 # ____________________________________________________________
 
 import sys
-assert __version__ == "1.3.1", ("This test_c.py file is for testing a version"
+assert __version__ == "1.5.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,):

+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/c/wchar_helper.h → desktop/core/ext-py/cffi-1.5.2/c/wchar_helper.h


+ 2 - 2
desktop/core/ext-py/cffi-1.3.1/cffi/__init__.py → desktop/core/ext-py/cffi-1.5.2/cffi/__init__.py

@@ -4,8 +4,8 @@ __all__ = ['FFI', 'VerificationError', 'VerificationMissing', 'CDefError',
 from .api import FFI, CDefError, FFIError
 from .ffiplatform import VerificationError, VerificationMissing
 
-__version__ = "1.3.1"
-__version_info__ = (1, 3, 1)
+__version__ = "1.5.2"
+__version_info__ = (1, 5, 2)
 
 # The verifier module file names are based on the CRC32 of a string that
 # contains the following version number.  It may be older than __version__

+ 15 - 2
desktop/core/ext-py/cffi-1.3.1/cffi/_cffi_include.h → desktop/core/ext-py/cffi-1.5.2/cffi/_cffi_include.h

@@ -146,7 +146,10 @@ extern "C" {
     ((Py_ssize_t(*)(CTypeDescrObject *, PyObject *, char **))_cffi_exports[23])
 #define _cffi_convert_array_from_object                                  \
     ((int(*)(char *, CTypeDescrObject *, PyObject *))_cffi_exports[24])
-#define _CFFI_NUM_EXPORTS 25
+#define _CFFI_CPIDX  25
+#define _cffi_call_python                                                \
+    ((void(*)(struct _cffi_externpy_s *, char *))_cffi_exports[_CFFI_CPIDX])
+#define _CFFI_NUM_EXPORTS 26
 
 typedef struct _ctypedescr CTypeDescrObject;
 
@@ -201,8 +204,12 @@ static PyObject **_cffi_unpack_args(PyObject *args_tuple, Py_ssize_t expected,
                                                   the others follow */
 }
 
-#endif
 /**********  end CPython-specific section  **********/
+#else
+_CFFI_UNUSED_FN
+static void (*_cffi_call_python_org)(struct _cffi_externpy_s *, char *);
+# define _cffi_call_python  _cffi_call_python_org
+#endif
 
 
 #define _cffi_array_len(array)   (sizeof(array) / sizeof((array)[0]))
@@ -224,6 +231,12 @@ static PyObject **_cffi_unpack_args(PyObject *args_tuple, Py_ssize_t expected,
     ((got_nonpos) == (expected <= 0) &&                 \
      (got) == (unsigned long long)expected)
 
+#ifdef MS_WIN32
+# define _cffi_stdcall  __stdcall
+#else
+# define _cffi_stdcall  /* nothing */
+#endif
+
 #ifdef __cplusplus
 }
 #endif

+ 517 - 0
desktop/core/ext-py/cffi-1.5.2/cffi/_embedding.h

@@ -0,0 +1,517 @@
+
+/***** Support code for embedding *****/
+
+#if defined(_MSC_VER)
+#  define CFFI_DLLEXPORT  __declspec(dllexport)
+#elif defined(__GNUC__)
+#  define CFFI_DLLEXPORT  __attribute__((visibility("default")))
+#else
+#  define CFFI_DLLEXPORT  /* nothing */
+#endif
+
+
+/* There are two global variables of type _cffi_call_python_fnptr:
+
+   * _cffi_call_python, which we declare just below, is the one called
+     by ``extern "Python"`` implementations.
+
+   * _cffi_call_python_org, which on CPython is actually part of the
+     _cffi_exports[] array, is the function pointer copied from
+     _cffi_backend.
+
+   After initialization is complete, both are equal.  However, the
+   first one remains equal to &_cffi_start_and_call_python until the
+   very end of initialization, when we are (or should be) sure that
+   concurrent threads also see a completely initialized world, and
+   only then is it changed.
+*/
+#undef _cffi_call_python
+typedef void (*_cffi_call_python_fnptr)(struct _cffi_externpy_s *, char *);
+static void _cffi_start_and_call_python(struct _cffi_externpy_s *, char *);
+static _cffi_call_python_fnptr _cffi_call_python = &_cffi_start_and_call_python;
+
+
+#ifndef _MSC_VER
+   /* --- Assuming a GCC not infinitely old --- */
+# define cffi_compare_and_swap(l,o,n)  __sync_bool_compare_and_swap(l,o,n)
+# define cffi_write_barrier()          __sync_synchronize()
+# if !defined(__amd64__) && !defined(__x86_64__) &&   \
+     !defined(__i386__) && !defined(__i386)
+#   define cffi_read_barrier()         __sync_synchronize()
+# else
+#   define cffi_read_barrier()         (void)0
+# endif
+#else
+   /* --- Windows threads version --- */
+# include <Windows.h>
+# define cffi_compare_and_swap(l,o,n) \
+                               (InterlockedCompareExchangePointer(l,n,o) == (o))
+# define cffi_write_barrier()       InterlockedCompareExchange(&_cffi_dummy,0,0)
+# define cffi_read_barrier()           (void)0
+static volatile LONG _cffi_dummy;
+#endif
+
+#ifdef WITH_THREAD
+# ifndef _MSC_VER
+#  include <pthread.h>
+   static pthread_mutex_t _cffi_embed_startup_lock;
+# else
+   static CRITICAL_SECTION _cffi_embed_startup_lock;
+# endif
+  static char _cffi_embed_startup_lock_ready = 0;
+#endif
+
+static void _cffi_acquire_reentrant_mutex(void)
+{
+    static void *volatile lock = NULL;
+
+    while (!cffi_compare_and_swap(&lock, NULL, (void *)1)) {
+        /* should ideally do a spin loop instruction here, but
+           hard to do it portably and doesn't really matter I
+           think: pthread_mutex_init() should be very fast, and
+           this is only run at start-up anyway. */
+    }
+
+#ifdef WITH_THREAD
+    if (!_cffi_embed_startup_lock_ready) {
+# ifndef _MSC_VER
+        pthread_mutexattr_t attr;
+        pthread_mutexattr_init(&attr);
+        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+        pthread_mutex_init(&_cffi_embed_startup_lock, &attr);
+# else
+        InitializeCriticalSection(&_cffi_embed_startup_lock);
+# endif
+        _cffi_embed_startup_lock_ready = 1;
+    }
+#endif
+
+    while (!cffi_compare_and_swap(&lock, (void *)1, NULL))
+        ;
+
+#ifndef _MSC_VER
+    pthread_mutex_lock(&_cffi_embed_startup_lock);
+#else
+    EnterCriticalSection(&_cffi_embed_startup_lock);
+#endif
+}
+
+static void _cffi_release_reentrant_mutex(void)
+{
+#ifndef _MSC_VER
+    pthread_mutex_unlock(&_cffi_embed_startup_lock);
+#else
+    LeaveCriticalSection(&_cffi_embed_startup_lock);
+#endif
+}
+
+
+/**********  CPython-specific section  **********/
+#ifndef PYPY_VERSION
+
+
+#define _cffi_call_python_org  _cffi_exports[_CFFI_CPIDX]
+
+PyMODINIT_FUNC _CFFI_PYTHON_STARTUP_FUNC(void);   /* forward */
+
+static void _cffi_py_initialize(void)
+{
+    /* XXX use initsigs=0, which "skips initialization registration of
+       signal handlers, which might be useful when Python is
+       embedded" according to the Python docs.  But review and think
+       if it should be a user-controllable setting.
+
+       XXX we should also give a way to write errors to a buffer
+       instead of to stderr.
+
+       XXX if importing 'site' fails, CPython (any version) calls
+       exit().  Should we try to work around this behavior here?
+    */
+    Py_InitializeEx(0);
+}
+
+static int _cffi_initialize_python(void)
+{
+    /* This initializes Python, imports _cffi_backend, and then the
+       present .dll/.so is set up as a CPython C extension module.
+    */
+    int result;
+    PyGILState_STATE state;
+    PyObject *pycode=NULL, *global_dict=NULL, *x;
+
+#if PY_MAJOR_VERSION >= 3
+    /* see comments in _cffi_carefully_make_gil() about the
+       Python2/Python3 difference 
+    */
+#else
+    /* Acquire the GIL.  We have no threadstate here.  If Python is 
+       already initialized, it is possible that there is already one
+       existing for this thread, but it is not made current now.
+    */
+    PyEval_AcquireLock();
+
+    _cffi_py_initialize();
+
+    /* The Py_InitializeEx() sometimes made a threadstate for us, but
+       not always.  Indeed Py_InitializeEx() could be called and do
+       nothing.  So do we have a threadstate, or not?  We don't know,
+       but we can replace it with NULL in all cases.
+    */
+    (void)PyThreadState_Swap(NULL);
+
+    /* Now we can release the GIL and re-acquire immediately using the
+       logic of PyGILState(), which handles making or installing the
+       correct threadstate.
+    */
+    PyEval_ReleaseLock();
+#endif
+    state = PyGILState_Ensure();
+
+    /* Call the initxxx() function from the present module.  It will
+       create and initialize us as a CPython extension module, instead
+       of letting the startup Python code do it---it might reimport
+       the same .dll/.so and get maybe confused on some platforms.
+       It might also have troubles locating the .dll/.so again for all
+       I know.
+    */
+    (void)_CFFI_PYTHON_STARTUP_FUNC();
+    if (PyErr_Occurred())
+        goto error;
+
+    /* Now run the Python code provided to ffi.embedding_init_code().
+     */
+    pycode = Py_CompileString(_CFFI_PYTHON_STARTUP_CODE,
+                              "<init code for '" _CFFI_MODULE_NAME "'>",
+                              Py_file_input);
+    if (pycode == NULL)
+        goto error;
+    global_dict = PyDict_New();
+    if (global_dict == NULL)
+        goto error;
+    if (PyDict_SetItemString(global_dict, "__builtins__",
+                             PyThreadState_GET()->interp->builtins) < 0)
+        goto error;
+    x = PyEval_EvalCode(
+#if PY_MAJOR_VERSION < 3
+                        (PyCodeObject *)
+#endif
+                        pycode, global_dict, global_dict);
+    if (x == NULL)
+        goto error;
+    Py_DECREF(x);
+
+    /* Done!  Now if we've been called from
+       _cffi_start_and_call_python() in an ``extern "Python"``, we can
+       only hope that the Python code did correctly set up the
+       corresponding @ffi.def_extern() function.  Otherwise, the
+       general logic of ``extern "Python"`` functions (inside the
+       _cffi_backend module) will find that the reference is still
+       missing and print an error.
+     */
+    result = 0;
+ done:
+    Py_XDECREF(pycode);
+    Py_XDECREF(global_dict);
+    PyGILState_Release(state);
+    return result;
+
+ error:;
+    {
+        /* Print as much information as potentially useful.
+           Debugging load-time failures with embedding is not fun
+        */
+        PyObject *exception, *v, *tb, *f, *modules, *mod;
+        PyErr_Fetch(&exception, &v, &tb);
+        if (exception != NULL) {
+            PyErr_NormalizeException(&exception, &v, &tb);
+            PyErr_Display(exception, v, tb);
+        }
+        Py_XDECREF(exception);
+        Py_XDECREF(v);
+        Py_XDECREF(tb);
+
+        f = PySys_GetObject((char *)"stderr");
+        if (f != NULL && f != Py_None) {
+            PyFile_WriteString("\nFrom: " _CFFI_MODULE_NAME
+                               "\ncompiled with cffi version: 1.5.2"
+                               "\n_cffi_backend module: ", f);
+            modules = PyImport_GetModuleDict();
+            mod = PyDict_GetItemString(modules, "_cffi_backend");
+            if (mod == NULL) {
+                PyFile_WriteString("not loaded", f);
+            }
+            else {
+                v = PyObject_GetAttrString(mod, "__file__");
+                PyFile_WriteObject(v, f, 0);
+                Py_XDECREF(v);
+            }
+            PyFile_WriteString("\nsys.path: ", f);
+            PyFile_WriteObject(PySys_GetObject((char *)"path"), f, 0);
+            PyFile_WriteString("\n\n", f);
+        }
+    }
+    result = -1;
+    goto done;
+}
+
+PyAPI_DATA(char *) _PyParser_TokenNames[];  /* from CPython */
+
+static int _cffi_carefully_make_gil(void)
+{
+    /* This does the basic initialization of Python.  It can be called
+       completely concurrently from unrelated threads.  It assumes
+       that we don't hold the GIL before (if it exists), and we don't
+       hold it afterwards.
+
+       What it really does is completely different in Python 2 and 
+       Python 3.
+
+    Python 2
+    ========
+
+       Initialize the GIL, without initializing the rest of Python,
+       by calling PyEval_InitThreads().
+
+       PyEval_InitThreads() must not be called concurrently at all.
+       So we use a global variable as a simple spin lock.  This global
+       variable must be from 'libpythonX.Y.so', not from this
+       cffi-based extension module, because it must be shared from
+       different cffi-based extension modules.  We choose
+       _PyParser_TokenNames[0] as a completely arbitrary pointer value
+       that is never written to.  The default is to point to the
+       string "ENDMARKER".  We change it temporarily to point to the
+       next character in that string.  (Yes, I know it's REALLY
+       obscure.)
+
+    Python 3
+    ========
+
+       In Python 3, PyEval_InitThreads() cannot be called before
+       Py_InitializeEx() any more.  So this function calls
+       Py_InitializeEx() first.  It uses the same obscure logic to
+       make sure we never call it concurrently.
+
+       Arguably, this is less good on the spinlock, because
+       Py_InitializeEx() takes much longer to run than
+       PyEval_InitThreads().  But I didn't find a way around it.
+    */
+
+#ifdef WITH_THREAD
+    char *volatile *lock = (char *volatile *)_PyParser_TokenNames;
+    char *old_value;
+
+    while (1) {    /* spin loop */
+        old_value = *lock;
+        if (old_value[0] == 'E') {
+            assert(old_value[1] == 'N');
+            if (cffi_compare_and_swap(lock, old_value, old_value + 1))
+                break;
+        }
+        else {
+            assert(old_value[0] == 'N');
+            /* should ideally do a spin loop instruction here, but
+               hard to do it portably and doesn't really matter I
+               think: PyEval_InitThreads() should be very fast, and
+               this is only run at start-up anyway. */
+        }
+    }
+#endif
+
+#if PY_MAJOR_VERSION >= 3
+    /* Python 3: call Py_InitializeEx() */
+    {
+        PyGILState_STATE state = PyGILState_UNLOCKED;
+        if (!Py_IsInitialized())
+            _cffi_py_initialize();
+        else
+            state = PyGILState_Ensure();
+
+        PyEval_InitThreads();
+        PyGILState_Release(state);
+    }
+#else
+    /* Python 2: call PyEval_InitThreads() */
+# ifdef WITH_THREAD
+    if (!PyEval_ThreadsInitialized()) {
+        PyEval_InitThreads();    /* makes the GIL */
+        PyEval_ReleaseLock();    /* then release it */
+    }
+    /* else: there is already a GIL, but we still needed to do the
+       spinlock dance to make sure that we see it as fully ready */
+# endif
+#endif
+
+#ifdef WITH_THREAD
+    /* release the lock */
+    while (!cffi_compare_and_swap(lock, old_value + 1, old_value))
+        ;
+#endif
+
+    return 0;
+}
+
+/**********  end CPython-specific section  **********/
+
+
+#else
+
+
+/**********  PyPy-specific section  **********/
+
+PyMODINIT_FUNC _CFFI_PYTHON_STARTUP_FUNC(const void *[]);   /* forward */
+
+static struct _cffi_pypy_init_s {
+    const char *name;
+    void (*func)(const void *[]);
+    const char *code;
+} _cffi_pypy_init = {
+    _CFFI_MODULE_NAME,
+    _CFFI_PYTHON_STARTUP_FUNC,
+    _CFFI_PYTHON_STARTUP_CODE,
+};
+
+extern int pypy_carefully_make_gil(const char *);
+extern int pypy_init_embedded_cffi_module(int, struct _cffi_pypy_init_s *);
+
+static int _cffi_carefully_make_gil(void)
+{
+    return pypy_carefully_make_gil(_CFFI_MODULE_NAME);
+}
+
+static int _cffi_initialize_python(void)
+{
+    return pypy_init_embedded_cffi_module(0xB011, &_cffi_pypy_init);
+}
+
+/**********  end PyPy-specific section  **********/
+
+
+#endif
+
+
+#ifdef __GNUC__
+__attribute__((noinline))
+#endif
+static _cffi_call_python_fnptr _cffi_start_python(void)
+{
+    /* Delicate logic to initialize Python.  This function can be
+       called multiple times concurrently, e.g. when the process calls
+       its first ``extern "Python"`` functions in multiple threads at
+       once.  It can also be called recursively, in which case we must
+       ignore it.  We also have to consider what occurs if several
+       different cffi-based extensions reach this code in parallel
+       threads---it is a different copy of the code, then, and we
+       can't have any shared global variable unless it comes from
+       'libpythonX.Y.so'.
+
+       Idea:
+
+       * _cffi_carefully_make_gil(): "carefully" call
+         PyEval_InitThreads() (possibly with Py_InitializeEx() first).
+
+       * then we use a (local) custom lock to make sure that a call to this
+         cffi-based extension will wait if another call to the *same*
+         extension is running the initialization in another thread.
+         It is reentrant, so that a recursive call will not block, but
+         only one from a different thread.
+
+       * then we grab the GIL and (Python 2) we call Py_InitializeEx().
+         At this point, concurrent calls to Py_InitializeEx() are not
+         possible: we have the GIL.
+
+       * do the rest of the specific initialization, which may
+         temporarily release the GIL but not the custom lock.
+         Only release the custom lock when we are done.
+    */
+    static char called = 0;
+
+    if (_cffi_carefully_make_gil() != 0)
+        return NULL;
+
+    _cffi_acquire_reentrant_mutex();
+
+    /* Here the GIL exists, but we don't have it.  We're only protected
+       from concurrency by the reentrant mutex. */
+
+    /* This file only initializes the embedded module once, the first
+       time this is called, even if there are subinterpreters. */
+    if (!called) {
+        called = 1;  /* invoke _cffi_initialize_python() only once,
+                        but don't set '_cffi_call_python' right now,
+                        otherwise concurrent threads won't call
+                        this function at all (we need them to wait) */
+        if (_cffi_initialize_python() == 0) {
+            /* now initialization is finished.  Switch to the fast-path. */
+
+            /* We would like nobody to see the new value of
+               '_cffi_call_python' without also seeing the rest of the
+               data initialized.  However, this is not possible.  But
+               the new value of '_cffi_call_python' is the function
+               'cffi_call_python()' from _cffi_backend.  So:  */
+            cffi_write_barrier();
+            /* ^^^ we put a write barrier here, and a corresponding
+               read barrier at the start of cffi_call_python().  This
+               ensures that after that read barrier, we see everything
+               done here before the write barrier.
+            */
+
+            assert(_cffi_call_python_org != NULL);
+            _cffi_call_python = (_cffi_call_python_fnptr)_cffi_call_python_org;
+        }
+        else {
+            /* initialization failed.  Reset this to NULL, even if it was
+               already set to some other value.  Future calls to
+               _cffi_start_python() are still forced to occur, and will
+               always return NULL from now on. */
+            _cffi_call_python_org = NULL;
+        }
+    }
+
+    _cffi_release_reentrant_mutex();
+
+    return (_cffi_call_python_fnptr)_cffi_call_python_org;
+}
+
+static
+void _cffi_start_and_call_python(struct _cffi_externpy_s *externpy, char *args)
+{
+    _cffi_call_python_fnptr fnptr;
+    int current_err = errno;
+#ifdef _MSC_VER
+    int current_lasterr = GetLastError();
+#endif
+    fnptr = _cffi_start_python();
+    if (fnptr == NULL) {
+        fprintf(stderr, "function %s() called, but initialization code "
+                        "failed.  Returning 0.\n", externpy->name);
+        memset(args, 0, externpy->size_of_result);
+    }
+#ifdef _MSC_VER
+    SetLastError(current_lasterr);
+#endif
+    errno = current_err;
+
+    if (fnptr != NULL)
+        fnptr(externpy, args);
+}
+
+
+/* The cffi_start_python() function makes sure Python is initialized
+   and our cffi module is set up.  It can be called manually from the
+   user C code.  The same effect is obtained automatically from any
+   dll-exported ``extern "Python"`` function.  This function returns
+   -1 if initialization failed, 0 if all is OK.  */
+_CFFI_UNUSED_FN
+static int cffi_start_python(void)
+{
+    if (_cffi_call_python == &_cffi_start_and_call_python) {
+        if (_cffi_start_python() == NULL)
+            return -1;
+    }
+    cffi_read_barrier();
+    return 0;
+}
+
+#undef cffi_compare_and_swap
+#undef cffi_write_barrier
+#undef cffi_read_barrier

+ 181 - 57
desktop/core/ext-py/cffi-1.3.1/cffi/api.py → desktop/core/ext-py/cffi-1.5.2/cffi/api.py

@@ -72,6 +72,9 @@ class FFI(object):
         self._cdefsources = []
         self._included_ffis = []
         self._windows_unicode = None
+        self._init_once_cache = {}
+        self._cdef_version = None
+        self._embedding = None
         if hasattr(backend, 'set_ffi'):
             backend.set_ffi(self)
         for name in backend.__dict__:
@@ -99,12 +102,21 @@ class FFI(object):
         If 'packed' is specified as True, all structs declared inside this
         cdef are packed, i.e. laid out without any field alignment at all.
         """
+        self._cdef(csource, override=override, packed=packed)
+
+    def embedding_api(self, csource, packed=False):
+        self._cdef(csource, packed=packed, dllexport=True)
+        if self._embedding is None:
+            self._embedding = ''
+
+    def _cdef(self, csource, override=False, **options):
         if not isinstance(csource, str):    # unicode, on Python 2
             if not isinstance(csource, basestring):
                 raise TypeError("cdef() argument must be a string")
             csource = csource.encode('ascii')
         with self._lock:
-            self._parser.parse(csource, override=override, packed=packed)
+            self._cdef_version = object()
+            self._parser.parse(csource, override=override, **options)
             self._cdefsources.append(csource)
             if override:
                 for cache in self._function_caches:
@@ -530,6 +542,50 @@ class FFI(object):
                                        ('_UNICODE', '1')]
         kwds['define_macros'] = defmacros
 
+    def _apply_embedding_fix(self, kwds):
+        # must include an argument like "-lpython2.7" for the compiler
+        def ensure(key, value):
+            lst = kwds.setdefault(key, [])
+            if value not in lst:
+                lst.append(value)
+        #
+        if '__pypy__' in sys.builtin_module_names:
+            if sys.platform == "win32":
+                # we need 'libpypy-c.lib'.  Right now, distributions of
+                # pypy contain it as 'include/python27.lib'.  You need
+                # to manually copy it back to 'libpypy-c.lib'.  XXX Will
+                # be fixed in the next pypy release.
+                pythonlib = "libpypy-c"
+                if hasattr(sys, 'prefix'):
+                    ensure('library_dirs', sys.prefix)
+            else:
+                # we need 'libpypy-c.{so,dylib}', which should be by
+                # default located in 'sys.prefix/bin'
+                pythonlib = "pypy-c"
+                if hasattr(sys, 'prefix'):
+                    import os
+                    ensure('library_dirs', os.path.join(sys.prefix, 'bin'))
+        else:
+            if sys.platform == "win32":
+                template = "python%d%d"
+                if hasattr(sys, 'gettotalrefcount'):
+                    template += '_d'
+            else:
+                try:
+                    import sysconfig
+                except ImportError:    # 2.6
+                    from distutils import sysconfig
+                template = "python%d.%d"
+                if sysconfig.get_config_var('DEBUG_EXT'):
+                    template += sysconfig.get_config_var('DEBUG_EXT')
+            pythonlib = (template %
+                    (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
+            if hasattr(sys, 'abiflags'):
+                pythonlib += sys.abiflags
+        ensure('libraries', pythonlib)
+        if sys.platform == "win32":
+            ensure('extra_link_args', '/MANIFEST')
+
     def set_source(self, module_name, source, source_extension='.c', **kwds):
         if hasattr(self, '_assigned_source'):
             raise ValueError("set_source() cannot be called several times "
@@ -589,14 +645,78 @@ class FFI(object):
         recompile(self, module_name, source,
                   c_file=filename, call_c_compiler=False, **kwds)
 
-    def compile(self, tmpdir='.'):
+    def compile(self, tmpdir='.', verbose=0, target=None):
+        """The 'target' argument gives the final file name of the
+        compiled DLL.  Use '*' to force distutils' choice, suitable for
+        regular CPython C API modules.  Use a file name ending in '.*'
+        to ask for the system's default extension for dynamic libraries
+        (.so/.dll/.dylib).
+
+        The default is '*' when building a non-embedded C API extension,
+        and (module_name + '.*') when building an embedded library.
+        """
         from .recompiler import recompile
         #
         if not hasattr(self, '_assigned_source'):
             raise ValueError("set_source() must be called before compile()")
         module_name, source, source_extension, kwds = self._assigned_source
         return recompile(self, module_name, source, tmpdir=tmpdir,
-                         source_extension=source_extension, **kwds)
+                         target=target, source_extension=source_extension,
+                         compiler_verbose=verbose, **kwds)
+
+    def init_once(self, func, tag):
+        # Read _init_once_cache[tag], which is either (False, lock) if
+        # we're calling the function now in some thread, or (True, result).
+        # Don't call setdefault() in most cases, to avoid allocating and
+        # immediately freeing a lock; but still use setdefaut() to avoid
+        # races.
+        try:
+            x = self._init_once_cache[tag]
+        except KeyError:
+            x = self._init_once_cache.setdefault(tag, (False, allocate_lock()))
+        # Common case: we got (True, result), so we return the result.
+        if x[0]:
+            return x[1]
+        # Else, it's a lock.  Acquire it to serialize the following tests.
+        with x[1]:
+            # Read again from _init_once_cache the current status.
+            x = self._init_once_cache[tag]
+            if x[0]:
+                return x[1]
+            # Call the function and store the result back.
+            result = func()
+            self._init_once_cache[tag] = (True, result)
+        return result
+
+    def embedding_init_code(self, pysource):
+        if self._embedding:
+            raise ValueError("embedding_init_code() can only be called once")
+        # fix 'pysource' before it gets dumped into the C file:
+        # - remove empty lines at the beginning, so it starts at "line 1"
+        # - dedent, if all non-empty lines are indented
+        # - check for SyntaxErrors
+        import re
+        match = re.match(r'\s*\n', pysource)
+        if match:
+            pysource = pysource[match.end():]
+        lines = pysource.splitlines() or ['']
+        prefix = re.match(r'\s*', lines[0]).group()
+        for i in range(1, len(lines)):
+            line = lines[i]
+            if line.rstrip():
+                while not line.startswith(prefix):
+                    prefix = prefix[:-1]
+        i = len(prefix)
+        lines = [line[i:]+'\n' for line in lines]
+        pysource = ''.join(lines)
+        #
+        compile(pysource, "cffi_init", "exec")
+        #
+        self._embedding = pysource
+
+    def def_extern(self, *args, **kwds):
+        raise ValueError("ffi.def_extern() is only available on API-mode FFI "
+                         "objects")
 
 
 def _load_backend_lib(backend, name, flags):
@@ -620,70 +740,70 @@ def _make_ffi_library(ffi, libname, flags):
     import os
     backend = ffi._backend
     backendlib = _load_backend_lib(backend, libname, flags)
-    copied_enums = []
     #
-    def make_accessor_locked(name):
+    def accessor_function(name):
         key = 'function ' + name
-        if key in ffi._parser._declarations:
-            tp, _ = ffi._parser._declarations[key]
-            BType = ffi._get_cached_btype(tp)
-            try:
-                value = backendlib.load_function(BType, name)
-            except KeyError as e:
-                raise AttributeError('%s: %s' % (name, e))
-            library.__dict__[name] = value
-            return
-        #
+        tp, _ = ffi._parser._declarations[key]
+        BType = ffi._get_cached_btype(tp)
+        try:
+            value = backendlib.load_function(BType, name)
+        except KeyError as e:
+            raise AttributeError('%s: %s' % (name, e))
+        library.__dict__[name] = value
+    #
+    def accessor_variable(name):
         key = 'variable ' + name
-        if key in ffi._parser._declarations:
-            tp, _ = ffi._parser._declarations[key]
-            BType = ffi._get_cached_btype(tp)
-            read_variable = backendlib.read_variable
-            write_variable = backendlib.write_variable
-            setattr(FFILibrary, name, property(
-                lambda self: read_variable(BType, name),
-                lambda self, value: write_variable(BType, name, value)))
+        tp, _ = ffi._parser._declarations[key]
+        BType = ffi._get_cached_btype(tp)
+        read_variable = backendlib.read_variable
+        write_variable = backendlib.write_variable
+        setattr(FFILibrary, name, property(
+            lambda self: read_variable(BType, name),
+            lambda self, value: write_variable(BType, name, value)))
+    #
+    def accessor_constant(name):
+        raise NotImplementedError("non-integer constant '%s' cannot be "
+                                  "accessed from a dlopen() library" % (name,))
+    #
+    def accessor_int_constant(name):
+        library.__dict__[name] = ffi._parser._int_constants[name]
+    #
+    accessors = {}
+    accessors_version = [False]
+    #
+    def update_accessors():
+        if accessors_version[0] is ffi._cdef_version:
             return
         #
-        if not copied_enums:
-            from . import model
-            error = None
-            for key, (tp, _) in ffi._parser._declarations.items():
-                if not isinstance(tp, model.EnumType):
-                    continue
-                try:
-                    tp.check_not_partial()
-                except Exception as e:
-                    error = e
-                    continue
-                for enumname, enumval in zip(tp.enumerators, tp.enumvalues):
-                    if enumname not in library.__dict__:
-                        library.__dict__[enumname] = enumval
-            if error is not None:
-                if name in library.__dict__:
-                    return     # ignore error, about a different enum
-                raise error
-
-            for key, val in ffi._parser._int_constants.items():
-                if key not in library.__dict__:
-                    library.__dict__[key] = val
-
-            copied_enums.append(True)
-            if name in library.__dict__:
-                return
-        #
-        key = 'constant ' + name
-        if key in ffi._parser._declarations:
-            raise NotImplementedError("fetching a non-integer constant "
-                                      "after dlopen()")
-        #
-        raise AttributeError(name)
+        from . import model
+        for key, (tp, _) in ffi._parser._declarations.items():
+            if not isinstance(tp, model.EnumType):
+                tag, name = key.split(' ', 1)
+                if tag == 'function':
+                    accessors[name] = accessor_function
+                elif tag == 'variable':
+                    accessors[name] = accessor_variable
+                elif tag == 'constant':
+                    accessors[name] = accessor_constant
+            else:
+                for i, enumname in enumerate(tp.enumerators):
+                    def accessor_enum(name, tp=tp, i=i):
+                        tp.check_not_partial()
+                        library.__dict__[name] = tp.enumvalues[i]
+                    accessors[enumname] = accessor_enum
+        for name in ffi._parser._int_constants:
+            accessors.setdefault(name, accessor_int_constant)
+        accessors_version[0] = ffi._cdef_version
     #
     def make_accessor(name):
         with ffi._lock:
             if name in library.__dict__ or name in FFILibrary.__dict__:
                 return    # added by another thread while waiting for the lock
-            make_accessor_locked(name)
+            if name not in accessors:
+                update_accessors()
+                if name not in accessors:
+                    raise AttributeError(name)
+            accessors[name](name)
     #
     class FFILibrary(object):
         def __getattr__(self, name):
@@ -697,6 +817,10 @@ def _make_ffi_library(ffi, libname, flags):
                 setattr(self, name, value)
             else:
                 property.__set__(self, value)
+        def __dir__(self):
+            with ffi._lock:
+                update_accessors()
+                return accessors.keys()
     #
     if libname is not None:
         try:

+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/cffi/backend_ctypes.py → desktop/core/ext-py/cffi-1.5.2/cffi/backend_ctypes.py


+ 1 - 0
desktop/core/ext-py/cffi-1.3.1/cffi/cffi_opcode.py → desktop/core/ext-py/cffi-1.5.2/cffi/cffi_opcode.py

@@ -54,6 +54,7 @@ OP_GLOBAL_VAR      = 33
 OP_DLOPEN_FUNC     = 35
 OP_DLOPEN_CONST    = 37
 OP_GLOBAL_VAR_F    = 39
+OP_EXTERN_PYTHON   = 41
 
 PRIM_VOID          = 0
 PRIM_BOOL          = 1

+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/cffi/commontypes.py → desktop/core/ext-py/cffi-1.5.2/cffi/commontypes.py


+ 85 - 18
desktop/core/ext-py/cffi-1.3.1/cffi/cparser.py → desktop/core/ext-py/cffi-1.5.2/cffi/cparser.py

@@ -29,6 +29,7 @@ _r_int_literal = re.compile(r"-?0?x?[0-9a-f]+[lu]*$", re.IGNORECASE)
 _r_stdcall1 = re.compile(r"\b(__stdcall|WINAPI)\b")
 _r_stdcall2 = re.compile(r"[(]\s*(__stdcall|WINAPI)\b")
 _r_cdecl = re.compile(r"\b__cdecl\b")
+_r_extern_python = re.compile(r'\bextern\s*"Python"\s*.')
 _r_star_const_space = re.compile(       # matches "* const "
     r"[*]\s*((const|volatile|restrict)\b\s*)+")
 
@@ -80,6 +81,47 @@ def _workaround_for_old_pycparser(csource):
     parts.append(csource)
     return ''.join(parts)
 
+def _preprocess_extern_python(csource):
+    # input: `extern "Python" int foo(int);` or
+    #        `extern "Python" { int foo(int); }`
+    # output:
+    #     void __cffi_extern_python_start;
+    #     int foo(int);
+    #     void __cffi_extern_python_stop;
+    parts = []
+    while True:
+        match = _r_extern_python.search(csource)
+        if not match:
+            break
+        endpos = match.end() - 1
+        #print
+        #print ''.join(parts)+csource
+        #print '=>'
+        parts.append(csource[:match.start()])
+        parts.append('void __cffi_extern_python_start; ')
+        if csource[endpos] == '{':
+            # grouping variant
+            closing = csource.find('}', endpos)
+            if closing < 0:
+                raise api.CDefError("'extern \"Python\" {': no '}' found")
+            if csource.find('{', endpos + 1, closing) >= 0:
+                raise NotImplementedError("cannot use { } inside a block "
+                                          "'extern \"Python\" { ... }'")
+            parts.append(csource[endpos+1:closing])
+            csource = csource[closing+1:]
+        else:
+            # non-grouping variant
+            semicolon = csource.find(';', endpos)
+            if semicolon < 0:
+                raise api.CDefError("'extern \"Python\": no ';' found")
+            parts.append(csource[endpos:semicolon+1])
+            csource = csource[semicolon+1:]
+        parts.append(' void __cffi_extern_python_stop;')
+        #print ''.join(parts)+csource
+        #print
+    parts.append(csource)
+    return ''.join(parts)
+
 def _preprocess(csource):
     # Remove comments.  NOTE: this only work because the cdef() section
     # should not contain any string literal!
@@ -103,8 +145,13 @@ def _preprocess(csource):
     csource = _r_stdcall2.sub(' volatile volatile const(', csource)
     csource = _r_stdcall1.sub(' volatile volatile const ', csource)
     csource = _r_cdecl.sub(' ', csource)
+    #
+    # Replace `extern "Python"` with start/end markers
+    csource = _preprocess_extern_python(csource)
+    #
     # Replace "[...]" with "[__dotdotdotarray__]"
     csource = _r_partial_array.sub('[__dotdotdotarray__]', csource)
+    #
     # Replace "...}" with "__dotdotdotNUM__}".  This construction should
     # occur only at the end of enums; at the end of structs we have "...;}"
     # and at the end of vararg functions "...);".  Also replace "=...[,}]"
@@ -173,8 +220,7 @@ class Parser(object):
         self._included_declarations = set()
         self._anonymous_counter = 0
         self._structnode2type = weakref.WeakKeyDictionary()
-        self._override = False
-        self._packed = False
+        self._options = {}
         self._int_constants = {}
         self._recomplete = []
         self._uses_new_feature = None
@@ -234,16 +280,15 @@ class Parser(object):
             msg = 'parse error\n%s' % (msg,)
         raise api.CDefError(msg)
 
-    def parse(self, csource, override=False, packed=False):
-        prev_override = self._override
-        prev_packed = self._packed
+    def parse(self, csource, override=False, packed=False, dllexport=False):
+        prev_options = self._options
         try:
-            self._override = override
-            self._packed = packed
+            self._options = {'override': override,
+                             'packed': packed,
+                             'dllexport': dllexport}
             self._internal_parse(csource)
         finally:
-            self._override = prev_override
-            self._packed = prev_packed
+            self._options = prev_options
 
     def _internal_parse(self, csource):
         ast, macros, csource = self._parse(csource)
@@ -257,6 +302,7 @@ class Parser(object):
                 break
         #
         try:
+            self._inside_extern_python = False
             for decl in iterator:
                 if isinstance(decl, pycparser.c_ast.Decl):
                     self._parse_decl(decl)
@@ -326,13 +372,22 @@ class Parser(object):
                     '  #define %s %s'
                     % (key, key, key, value))
 
+    def _declare_function(self, tp, quals, decl):
+        tp = self._get_type_pointer(tp, quals)
+        if self._options.get('dllexport'):
+            tag = 'dllexport_python '
+        elif self._inside_extern_python:
+            tag = 'extern_python '
+        else:
+            tag = 'function '
+        self._declare(tag + decl.name, tp)
+
     def _parse_decl(self, decl):
         node = decl.type
         if isinstance(node, pycparser.c_ast.FuncDecl):
             tp, quals = self._get_type_and_quals(node, name=decl.name)
             assert isinstance(tp, model.RawFunctionType)
-            tp = self._get_type_pointer(tp, quals)
-            self._declare('function ' + decl.name, tp)
+            self._declare_function(tp, quals, decl)
         else:
             if isinstance(node, pycparser.c_ast.Struct):
                 self._get_struct_union_enum_type('struct', node)
@@ -348,8 +403,7 @@ class Parser(object):
                 tp, quals = self._get_type_and_quals(node,
                                                      partial_length_ok=True)
                 if tp.is_raw_function:
-                    tp = self._get_type_pointer(tp, quals)
-                    self._declare('function ' + decl.name, tp)
+                    self._declare_function(tp, quals, decl)
                 elif (tp.is_integer_type() and
                         hasattr(decl, 'init') and
                         hasattr(decl.init, 'value') and
@@ -362,10 +416,23 @@ class Parser(object):
                         _r_int_literal.match(decl.init.expr.value)):
                     self._add_integer_constant(decl.name,
                                                '-' + decl.init.expr.value)
-                elif (quals & model.Q_CONST) and not tp.is_array_type:
-                    self._declare('constant ' + decl.name, tp, quals=quals)
+                elif (tp is model.void_type and
+                      decl.name.startswith('__cffi_extern_python_')):
+                    # hack: `extern "Python"` in the C source is replaced
+                    # with "void __cffi_extern_python_start;" and
+                    # "void __cffi_extern_python_stop;"
+                    self._inside_extern_python = not self._inside_extern_python
+                    assert self._inside_extern_python == (
+                        decl.name == '__cffi_extern_python_start')
                 else:
-                    self._declare('variable ' + decl.name, tp, quals=quals)
+                    if self._inside_extern_python:
+                        raise api.CDefError(
+                            "cannot declare constants or "
+                            "variables with 'extern \"Python\"'")
+                    if (quals & model.Q_CONST) and not tp.is_array_type:
+                        self._declare('constant ' + decl.name, tp, quals=quals)
+                    else:
+                        self._declare('variable ' + decl.name, tp, quals=quals)
 
     def parse_type(self, cdecl):
         return self.parse_type_and_quals(cdecl)[0]
@@ -383,7 +450,7 @@ class Parser(object):
             prevobj, prevquals = self._declarations[name]
             if prevobj is obj and prevquals == quals:
                 return
-            if not self._override:
+            if not self._options.get('override'):
                 raise api.FFIError(
                     "multiple declarations of %s (for interactive usage, "
                     "try cdef(xx, override=True))" % (name,))
@@ -662,7 +729,7 @@ class Parser(object):
             if isinstance(tp, model.StructType) and tp.partial:
                 raise NotImplementedError("%s: using both bitfields and '...;'"
                                           % (tp,))
-        tp.packed = self._packed
+        tp.packed = self._options.get('packed')
         if tp.completed:    # must be re-completed: it is not opaque any more
             tp.completed = 0
             self._recomplete.append(tp)

+ 14 - 8
desktop/core/ext-py/cffi-1.3.1/cffi/ffiplatform.py → desktop/core/ext-py/cffi-1.5.2/cffi/ffiplatform.py

@@ -17,15 +17,16 @@ LIST_OF_FILE_NAMES = ['sources', 'include_dirs', 'library_dirs',
 def get_extension(srcfilename, modname, sources=(), **kwds):
     from distutils.core import Extension
     allsources = [srcfilename]
-    allsources.extend(sources)
+    for src in sources:
+        allsources.append(os.path.normpath(src))
     return Extension(name=modname, sources=allsources, **kwds)
 
-def compile(tmpdir, ext):
+def compile(tmpdir, ext, compiler_verbose=0):
     """Compile a C extension module using distutils."""
 
     saved_environ = os.environ.copy()
     try:
-        outputfilename = _build(tmpdir, ext)
+        outputfilename = _build(tmpdir, ext, compiler_verbose)
         outputfilename = os.path.abspath(outputfilename)
     finally:
         # workaround for a distutils bugs where some env vars can
@@ -35,10 +36,10 @@ def compile(tmpdir, ext):
                 os.environ[key] = value
     return outputfilename
 
-def _build(tmpdir, ext):
+def _build(tmpdir, ext, compiler_verbose=0):
     # XXX compact but horrible :-(
     from distutils.core import Distribution
-    import distutils.errors
+    import distutils.errors, distutils.log
     #
     dist = Distribution({'ext_modules': [ext]})
     dist.parse_config_files()
@@ -48,13 +49,18 @@ def _build(tmpdir, ext):
     options['build_temp'] = ('ffiplatform', tmpdir)
     #
     try:
-        dist.run_command('build_ext')
+        old_level = distutils.log.set_threshold(0) or 0
+        try:
+            distutils.log.set_verbosity(compiler_verbose)
+            dist.run_command('build_ext')
+            cmd_obj = dist.get_command_obj('build_ext')
+            [soname] = cmd_obj.get_outputs()
+        finally:
+            distutils.log.set_threshold(old_level)
     except (distutils.errors.CompileError,
             distutils.errors.LinkError) as e:
         raise VerificationError('%s: %s' % (e.__class__.__name__, e))
     #
-    cmd_obj = dist.get_command_obj('build_ext')
-    [soname] = cmd_obj.get_outputs()
     return soname
 
 try:

+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/cffi/gc_weakref.py → desktop/core/ext-py/cffi-1.5.2/cffi/gc_weakref.py


+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/cffi/lock.py → desktop/core/ext-py/cffi-1.5.2/cffi/lock.py


+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/cffi/model.py → desktop/core/ext-py/cffi-1.5.2/cffi/model.py


+ 9 - 1
desktop/core/ext-py/cffi-1.3.1/cffi/parse_c_type.h → desktop/core/ext-py/cffi-1.5.2/cffi/parse_c_type.h

@@ -1,5 +1,6 @@
 
-/* See doc/misc/parse_c_type.rst in the source of CFFI for more information */
+/* This part is from file 'cffi/parse_c_type.h'.  It is copied at the
+   beginning of C sources generated by CFFI's ffi.set_source(). */
 
 typedef void *_cffi_opcode_t;
 
@@ -27,6 +28,7 @@ typedef void *_cffi_opcode_t;
 #define _CFFI_OP_DLOPEN_FUNC    35
 #define _CFFI_OP_DLOPEN_CONST   37
 #define _CFFI_OP_GLOBAL_VAR_F   39
+#define _CFFI_OP_EXTERN_PYTHON  41
 
 #define _CFFI_PRIM_VOID          0
 #define _CFFI_PRIM_BOOL          1
@@ -160,6 +162,12 @@ struct _cffi_parse_info_s {
     const char *error_message;
 };
 
+struct _cffi_externpy_s {
+    const char *name;
+    size_t size_of_result;
+    void *reserved1, *reserved2;
+};
+
 #ifdef _CFFI_INTERNAL
 static int parse_c_type(struct _cffi_parse_info_s *info, const char *input);
 static int search_in_globals(const struct _cffi_type_context_s *ctx,

+ 204 - 7
desktop/core/ext-py/cffi-1.3.1/cffi/recompiler.py → desktop/core/ext-py/cffi-1.5.2/cffi/recompiler.py

@@ -3,6 +3,7 @@ from . import ffiplatform, model
 from .cffi_opcode import *
 
 VERSION = "0x2601"
+VERSION_EMBEDDED = "0x2701"
 
 
 class GlobalExpr:
@@ -118,6 +119,7 @@ class TypenameExpr:
 
 
 class Recompiler:
+    _num_externpy = 0
 
     def __init__(self, ffi, module_name, target_is_python=False):
         self.ffi = ffi
@@ -280,6 +282,29 @@ class Recompiler:
         lines[i:i+1] = self._rel_readlines('parse_c_type.h')
         prnt(''.join(lines))
         #
+        # if we have ffi._embedding != None, we give it here as a macro
+        # and include an extra file
+        base_module_name = self.module_name.split('.')[-1]
+        if self.ffi._embedding is not None:
+            prnt('#define _CFFI_MODULE_NAME  "%s"' % (self.module_name,))
+            prnt('#define _CFFI_PYTHON_STARTUP_CODE  %s' %
+                 (self._string_literal(self.ffi._embedding),))
+            prnt('#ifdef PYPY_VERSION')
+            prnt('# define _CFFI_PYTHON_STARTUP_FUNC  _cffi_pypyinit_%s' % (
+                base_module_name,))
+            prnt('#elif PY_MAJOR_VERSION >= 3')
+            prnt('# define _CFFI_PYTHON_STARTUP_FUNC  PyInit_%s' % (
+                base_module_name,))
+            prnt('#else')
+            prnt('# define _CFFI_PYTHON_STARTUP_FUNC  init%s' % (
+                base_module_name,))
+            prnt('#endif')
+            lines = self._rel_readlines('_embedding.h')
+            prnt(''.join(lines))
+            version = VERSION_EMBEDDED
+        else:
+            version = VERSION
+        #
         # then paste the C source given by the user, verbatim.
         prnt('/************************************************************/')
         prnt()
@@ -356,17 +381,24 @@ class Recompiler:
         else:
             prnt('  NULL,  /* no includes */')
         prnt('  %d,  /* num_types */' % (len(self.cffi_types),))
-        prnt('  0,  /* flags */')
+        flags = 0
+        if self._num_externpy:
+            flags |= 1     # set to mean that we use extern "Python"
+        prnt('  %d,  /* flags */' % flags)
         prnt('};')
         prnt()
         #
         # the init function
-        base_module_name = self.module_name.split('.')[-1]
         prnt('#ifdef PYPY_VERSION')
         prnt('PyMODINIT_FUNC')
         prnt('_cffi_pypyinit_%s(const void *p[])' % (base_module_name,))
         prnt('{')
-        prnt('    p[0] = (const void *)%s;' % VERSION)
+        if self._num_externpy:
+            prnt('    if (((intptr_t)p[0]) >= 0x0A03) {')
+            prnt('        _cffi_call_python_org = '
+                 '(void(*)(struct _cffi_externpy_s *, char *))p[1];')
+            prnt('    }')
+        prnt('    p[0] = (const void *)%s;' % version)
         prnt('    p[1] = &_cffi_type_context;')
         prnt('}')
         # on Windows, distutils insists on putting init_cffi_xyz in
@@ -385,14 +417,14 @@ class Recompiler:
         prnt('PyInit_%s(void)' % (base_module_name,))
         prnt('{')
         prnt('  return _cffi_init("%s", %s, &_cffi_type_context);' % (
-            self.module_name, VERSION))
+            self.module_name, version))
         prnt('}')
         prnt('#else')
         prnt('PyMODINIT_FUNC')
         prnt('init%s(void)' % (base_module_name,))
         prnt('{')
         prnt('  _cffi_init("%s", %s, &_cffi_type_context);' % (
-            self.module_name, VERSION))
+            self.module_name, version))
         prnt('}')
         prnt('#endif')
 
@@ -1107,6 +1139,102 @@ class Recompiler:
         self._lsts["global"].append(
             GlobalExpr(name, '_cffi_var_%s' % name, CffiOp(op, type_index)))
 
+    # ----------
+    # extern "Python"
+
+    def _generate_cpy_extern_python_collecttype(self, tp, name):
+        assert isinstance(tp, model.FunctionPtrType)
+        self._do_collect_type(tp)
+
+    def _generate_cpy_dllexport_python_collecttype(self, tp, name):
+        self._generate_cpy_extern_python_collecttype(tp, name)
+
+    def _generate_cpy_extern_python_decl(self, tp, name, dllexport=False):
+        prnt = self._prnt
+        if isinstance(tp.result, model.VoidType):
+            size_of_result = '0'
+        else:
+            context = 'result of %s' % name
+            size_of_result = '(int)sizeof(%s)' % (
+                tp.result.get_c_name('', context),)
+        prnt('static struct _cffi_externpy_s _cffi_externpy__%s =' % name)
+        prnt('  { "%s", %s };' % (name, size_of_result))
+        prnt()
+        #
+        arguments = []
+        context = 'argument of %s' % name
+        for i, type in enumerate(tp.args):
+            arg = type.get_c_name(' a%d' % i, context)
+            arguments.append(arg)
+        #
+        repr_arguments = ', '.join(arguments)
+        repr_arguments = repr_arguments or 'void'
+        name_and_arguments = '%s(%s)' % (name, repr_arguments)
+        if tp.abi == "__stdcall":
+            name_and_arguments = '_cffi_stdcall ' + name_and_arguments
+        #
+        def may_need_128_bits(tp):
+            return (isinstance(tp, model.PrimitiveType) and
+                    tp.name == 'long double')
+        #
+        size_of_a = max(len(tp.args)*8, 8)
+        if may_need_128_bits(tp.result):
+            size_of_a = max(size_of_a, 16)
+        if isinstance(tp.result, model.StructOrUnion):
+            size_of_a = 'sizeof(%s) > %d ? sizeof(%s) : %d' % (
+                tp.result.get_c_name(''), size_of_a,
+                tp.result.get_c_name(''), size_of_a)
+        if dllexport:
+            tag = 'CFFI_DLLEXPORT'
+        else:
+            tag = 'static'
+        prnt('%s %s' % (tag, tp.result.get_c_name(name_and_arguments)))
+        prnt('{')
+        prnt('  char a[%s];' % size_of_a)
+        prnt('  char *p = a;')
+        for i, type in enumerate(tp.args):
+            arg = 'a%d' % i
+            if (isinstance(type, model.StructOrUnion) or
+                    may_need_128_bits(type)):
+                arg = '&' + arg
+                type = model.PointerType(type)
+            prnt('  *(%s)(p + %d) = %s;' % (type.get_c_name('*'), i*8, arg))
+        prnt('  _cffi_call_python(&_cffi_externpy__%s, p);' % name)
+        if not isinstance(tp.result, model.VoidType):
+            prnt('  return *(%s)p;' % (tp.result.get_c_name('*'),))
+        prnt('}')
+        prnt()
+        self._num_externpy += 1
+
+    def _generate_cpy_dllexport_python_decl(self, tp, name):
+        self._generate_cpy_extern_python_decl(tp, name, dllexport=True)
+
+    def _generate_cpy_extern_python_ctx(self, tp, name):
+        if self.target_is_python:
+            raise ffiplatform.VerificationError(
+                "cannot use 'extern \"Python\"' in the ABI mode")
+        if tp.ellipsis:
+            raise NotImplementedError("a vararg function is extern \"Python\"")
+        type_index = self._typesdict[tp]
+        type_op = CffiOp(OP_EXTERN_PYTHON, type_index)
+        self._lsts["global"].append(
+            GlobalExpr(name, '&_cffi_externpy__%s' % name, type_op, name))
+
+    def _generate_cpy_dllexport_python_ctx(self, tp, name):
+        self._generate_cpy_extern_python_ctx(tp, name)
+
+    def _string_literal(self, s):
+        def _char_repr(c):
+            # escape with a '\' the characters '\', '"' or (for trigraphs) '?'
+            if c in '\\"?': return '\\' + c
+            if ' ' <= c < '\x7F': return c
+            if c == '\n': return '\\n'
+            return '\\%03o' % ord(c)
+        lines = []
+        for line in s.splitlines(True):
+            lines.append('"%s"' % ''.join([_char_repr(c) for c in line]))
+        return ' \\\n'.join(lines)
+
     # ----------
     # emitting the opcodes for individual types
 
@@ -1231,13 +1359,69 @@ def _modname_to_file(outputdir, modname, extension):
     parts[-1] += extension
     return os.path.join(outputdir, *parts), parts
 
+
+# Aaargh.  Distutils is not tested at all for the purpose of compiling
+# DLLs that are not extension modules.  Here are some hacks to work
+# around that, in the _patch_for_*() functions...
+
+def _patch_meth(patchlist, cls, name, new_meth):
+    old = getattr(cls, name)
+    patchlist.append((cls, name, old))
+    setattr(cls, name, new_meth)
+    return old
+
+def _unpatch_meths(patchlist):
+    for cls, name, old_meth in reversed(patchlist):
+        setattr(cls, name, old_meth)
+
+def _patch_for_embedding(patchlist):
+    if sys.platform == 'win32':
+        # we must not remove the manifest when building for embedding!
+        from distutils.msvc9compiler import MSVCCompiler
+        _patch_meth(patchlist, MSVCCompiler, '_remove_visual_c_ref',
+                    lambda self, manifest_file: manifest_file)
+
+    if sys.platform == 'darwin':
+        # we must not make a '-bundle', but a '-dynamiclib' instead
+        from distutils.ccompiler import CCompiler
+        def my_link_shared_object(self, *args, **kwds):
+            if '-bundle' in self.linker_so:
+                self.linker_so = list(self.linker_so)
+                i = self.linker_so.index('-bundle')
+                self.linker_so[i] = '-dynamiclib'
+            return old_link_shared_object(self, *args, **kwds)
+        old_link_shared_object = _patch_meth(patchlist, CCompiler,
+                                             'link_shared_object',
+                                             my_link_shared_object)
+
+def _patch_for_target(patchlist, target):
+    from distutils.command.build_ext import build_ext
+    # if 'target' is different from '*', we need to patch some internal
+    # method to just return this 'target' value, instead of having it
+    # built from module_name
+    if target.endswith('.*'):
+        target = target[:-2]
+        if sys.platform == 'win32':
+            target += '.dll'
+        elif sys.platform == 'darwin':
+            target += '.dylib'
+        else:
+            target += '.so'
+    _patch_meth(patchlist, build_ext, 'get_ext_filename',
+                lambda self, ext_name: target)
+
+
 def recompile(ffi, module_name, preamble, tmpdir='.', call_c_compiler=True,
-              c_file=None, source_extension='.c', extradir=None, **kwds):
+              c_file=None, source_extension='.c', extradir=None,
+              compiler_verbose=1, target=None, **kwds):
     if not isinstance(module_name, str):
         module_name = module_name.encode('ascii')
     if ffi._windows_unicode:
         ffi._apply_windows_unicode(kwds)
     if preamble is not None:
+        embedding = (ffi._embedding is not None)
+        if embedding:
+            ffi._apply_embedding_fix(kwds)
         if c_file is None:
             c_file, parts = _modname_to_file(tmpdir, module_name,
                                              source_extension)
@@ -1246,15 +1430,28 @@ def recompile(ffi, module_name, preamble, tmpdir='.', call_c_compiler=True,
             ext_c_file = os.path.join(*parts)
         else:
             ext_c_file = c_file
+        #
+        if target is None:
+            if embedding:
+                target = '%s.*' % module_name
+            else:
+                target = '*'
+        #
         ext = ffiplatform.get_extension(ext_c_file, module_name, **kwds)
         updated = make_c_source(ffi, module_name, preamble, c_file)
         if call_c_compiler:
+            patchlist = []
             cwd = os.getcwd()
             try:
+                if embedding:
+                    _patch_for_embedding(patchlist)
+                if target != '*':
+                    _patch_for_target(patchlist, target)
                 os.chdir(tmpdir)
-                outputfilename = ffiplatform.compile('.', ext)
+                outputfilename = ffiplatform.compile('.', ext, compiler_verbose)
             finally:
                 os.chdir(cwd)
+                _unpatch_meths(patchlist)
             return outputfilename
         else:
             return ext, updated

+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/cffi/setuptools_ext.py → desktop/core/ext-py/cffi-1.5.2/cffi/setuptools_ext.py


+ 3 - 0
desktop/core/ext-py/cffi-1.3.1/cffi/vengine_cpy.py → desktop/core/ext-py/cffi-1.5.2/cffi/vengine_cpy.py

@@ -1,3 +1,6 @@
+#
+# DEPRECATED: implementation for ffi.verify()
+#
 import sys, imp
 from . import model, ffiplatform
 

+ 3 - 0
desktop/core/ext-py/cffi-1.3.1/cffi/vengine_gen.py → desktop/core/ext-py/cffi-1.5.2/cffi/vengine_gen.py

@@ -1,3 +1,6 @@
+#
+# DEPRECATED: implementation for ffi.verify()
+#
 import sys, os
 import types
 

+ 3 - 0
desktop/core/ext-py/cffi-1.3.1/cffi/verifier.py → desktop/core/ext-py/cffi-1.5.2/cffi/verifier.py

@@ -1,3 +1,6 @@
+#
+# DEPRECATED: implementation for ffi.verify()
+#
 import sys, os, binascii, shutil, io
 from . import __version_verifier_modules__
 from . import ffiplatform

+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/demo/_curses.py → desktop/core/ext-py/cffi-1.5.2/demo/_curses.py


+ 0 - 0
desktop/core/ext-py/cffi-1.3.1/demo/_curses_build.py → desktop/core/ext-py/cffi-1.5.2/demo/_curses_build.py


Algunos archivos no se mostraron porque demasiados archivos cambiaron en este cambio