import sys import pytest import weakref from pathlib import Path import numpy as np from numpy.ctypeslib import ndpointer, load_library, as_array from numpy.distutils.misc_util import get_shared_lib_extension from numpy.testing import assert_, assert_array_equal, assert_raises, assert_equal try: import ctypes except ImportError: ctypes = None else: cdll = None test_cdll = None if hasattr(sys, 'gettotalrefcount'): try: cdll = load_library('_multiarray_umath_d', np.core._multiarray_umath.__file__) except OSError: pass try: test_cdll = load_library('_multiarray_tests', np.core._multiarray_tests.__file__) except OSError: pass if cdll is None: cdll = load_library('_multiarray_umath', np.core._multiarray_umath.__file__) if test_cdll is None: test_cdll = load_library('_multiarray_tests', np.core._multiarray_tests.__file__) c_forward_pointer = test_cdll.forward_pointer @pytest.mark.skipif(ctypes is None, reason="ctypes not available in this python") @pytest.mark.skipif(sys.platform == 'cygwin', reason="Known to fail on cygwin") class TestLoadLibrary: def test_basic(self): loader_path = np.core._multiarray_umath.__file__ out1 = load_library('_multiarray_umath', loader_path) out2 = load_library(Path('_multiarray_umath'), loader_path) out3 = load_library('_multiarray_umath', Path(loader_path)) out4 = load_library(b'_multiarray_umath', loader_path) assert isinstance(out1, ctypes.CDLL) assert out1 is out2 is out3 is out4 def test_basic2(self): # Regression for #801: load_library with a full library name # (including extension) does not work. try: try: so = get_shared_lib_extension(is_python_ext=True) # Should succeed load_library('_multiarray_umath%s' % so, np.core._multiarray_umath.__file__) except ImportError: print("No distutils available, skipping test.") except ImportError as e: msg = ("ctypes is not available on this python: skipping the test" " (import error was: %s)" % str(e)) print(msg) class TestNdpointer: def test_dtype(self): dt = np.intc p = ndpointer(dtype=dt) assert_(p.from_param(np.array([1], dt))) dt = 'i4') p = ndpointer(dtype=dt) p.from_param(np.array([1], dt)) assert_raises(TypeError, p.from_param, np.array([1], dt.newbyteorder('swap'))) dtnames = ['x', 'y'] dtformats = [np.intc, np.float64] dtdescr = {'names': dtnames, 'formats': dtformats} dt = np.dtype(dtdescr) p = ndpointer(dtype=dt) assert_(p.from_param(np.zeros((10,), dt))) samedt = np.dtype(dtdescr) p = ndpointer(dtype=samedt) assert_(p.from_param(np.zeros((10,), dt))) dt2 = np.dtype(dtdescr, align=True) if dt.itemsize != dt2.itemsize: assert_raises(TypeError, p.from_param, np.zeros((10,), dt2)) else: assert_(p.from_param(np.zeros((10,), dt2))) def test_ndim(self): p = ndpointer(ndim=0) assert_(p.from_param(np.array(1))) assert_raises(TypeError, p.from_param, np.array([1])) p = ndpointer(ndim=1) assert_raises(TypeError, p.from_param, np.array(1)) assert_(p.from_param(np.array([1]))) p = ndpointer(ndim=2) assert_(p.from_param(np.array([[1]]))) def test_shape(self): p = ndpointer(shape=(1, 2)) assert_(p.from_param(np.array([[1, 2]]))) assert_raises(TypeError, p.from_param, np.array([[1], [2]])) p = ndpointer(shape=()) assert_(p.from_param(np.array(1))) def test_flags(self): x = np.array([[1, 2], [3, 4]], order='F') p = ndpointer(flags='FORTRAN') assert_(p.from_param(x)) p = ndpointer(flags='CONTIGUOUS') assert_raises(TypeError, p.from_param, x) p = ndpointer(flags=x.flags.num) assert_(p.from_param(x)) assert_raises(TypeError, p.from_param, np.array([[1, 2], [3, 4]])) def test_cache(self): assert_(ndpointer(dtype=np.float64) is ndpointer(dtype=np.float64)) # shapes are normalized assert_(ndpointer(shape=2) is ndpointer(shape=(2,))) # 1.12 <= v < 1.16 had a bug that made these fail assert_(ndpointer(shape=2) is not ndpointer(ndim=2)) assert_(ndpointer(ndim=2) is not ndpointer(shape=2)) @pytest.mark.skipif(ctypes is None, reason="ctypes not available on this python installation") class TestNdpointerCFunc: def test_arguments(self): """ Test that arguments are coerced from arrays """ c_forward_pointer.restype = ctypes.c_void_p c_forward_pointer.argtypes = (ndpointer(ndim=2),) c_forward_pointer(np.zeros((2, 3))) # too many dimensions assert_raises( ctypes.ArgumentError, c_forward_pointer, np.zeros((2, 3, 4))) @pytest.mark.parametrize( 'dt', [ float, np.dtype(dict( formats=['u2') ct = np.ctypeslib.as_ctypes_type(dt) assert_equal(ct, ctypes.c_uint16.__ctype_be__) dt = np.dtype('u2') ct = np.ctypeslib.as_ctypes_type(dt) assert_equal(ct, ctypes.c_uint16) def test_subarray(self): dt = np.dtype((np.int32, (2, 3))) ct = np.ctypeslib.as_ctypes_type(dt) assert_equal(ct, 2 * (3 * ctypes.c_int32)) def test_structure(self): dt = np.dtype([ ('a', np.uint16), ('b', np.uint32), ]) ct = np.ctypeslib.as_ctypes_type(dt) assert_(issubclass(ct, ctypes.Structure)) assert_equal(ctypes.sizeof(ct), dt.itemsize) assert_equal(ct._fields_, [ ('a', ctypes.c_uint16), ('b', ctypes.c_uint32), ]) def test_structure_aligned(self): dt = np.dtype([ ('a', np.uint16), ('b', np.uint32), ], align=True) ct = np.ctypeslib.as_ctypes_type(dt) assert_(issubclass(ct, ctypes.Structure)) assert_equal(ctypes.sizeof(ct), dt.itemsize) assert_equal(ct._fields_, [ ('a', ctypes.c_uint16), ('', ctypes.c_char * 2), # padding ('b', ctypes.c_uint32), ]) def test_union(self): dt = np.dtype(dict( names=['a', 'b'], offsets=[0, 0], formats=[np.uint16, np.uint32] )) ct = np.ctypeslib.as_ctypes_type(dt) assert_(issubclass(ct, ctypes.Union)) assert_equal(ctypes.sizeof(ct), dt.itemsize) assert_equal(ct._fields_, [ ('a', ctypes.c_uint16), ('b', ctypes.c_uint32), ]) def test_padded_union(self): dt = np.dtype(dict( names=['a', 'b'], offsets=[0, 0], formats=[np.uint16, np.uint32], itemsize=5, )) ct = np.ctypeslib.as_ctypes_type(dt) assert_(issubclass(ct, ctypes.Union)) assert_equal(ctypes.sizeof(ct), dt.itemsize) assert_equal(ct._fields_, [ ('a', ctypes.c_uint16), ('b', ctypes.c_uint32), ('', ctypes.c_char * 5), # padding ]) def test_overlapping(self): dt = np.dtype(dict( names=['a', 'b'], offsets=[0, 2], formats=[np.uint32, np.uint32] )) assert_raises(NotImplementedError, np.ctypeslib.as_ctypes_type, dt)