def test_array_type_bug(self): A = lltype.Array(lltype.Signed) a1 = lltype.malloc(A, 0, flavor='raw') a2 = lltype.malloc(A, 0, flavor='raw') c1 = lltype2ctypes(a1) c2 = lltype2ctypes(a2) assert type(c1) is type(c2)
def test_primitive(): assert lltype2ctypes(5) == 5 assert lltype2ctypes('?') == ord('?') assert lltype2ctypes('\xE0') == 0xE0 assert ctypes2lltype(lltype.Signed, 5) == 5 assert ctypes2lltype(lltype.Char, ord('a')) == 'a' assert ctypes2lltype(lltype.Char, 0xFF) == '\xFF'
def test_recursive_struct(self): SX = lltype.ForwardReference() S1 = lltype.Struct('S1', ('p', lltype.Ptr(SX)), ('x', lltype.Signed)) SX.become(S1) # a chained list s1 = lltype.malloc(S1, flavor='raw') s2 = lltype.malloc(S1, flavor='raw') s3 = lltype.malloc(S1, flavor='raw') s1.x = 111 s2.x = 222 s3.x = 333 s1.p = s2 s2.p = s3 s3.p = lltype.nullptr(S1) sc1 = lltype2ctypes(s1) sc2 = sc1.contents.p sc3 = sc2.contents.p assert not sc3.contents.p assert sc1.contents.x == 111 assert sc2.contents.x == 222 assert sc3.contents.x == 333 sc3.contents.x += 1 assert s3.x == 334 s3.x += 2 assert sc3.contents.x == 336 lltype.free(s1, flavor='raw') lltype.free(s2, flavor='raw') lltype.free(s3, flavor='raw') # a self-cycle s1 = lltype.malloc(S1, flavor='raw') s1.x = 12 s1.p = s1 sc1 = lltype2ctypes(s1) assert sc1.contents.x == 12 assert (ctypes.addressof(sc1.contents.p.contents) == ctypes.addressof( sc1.contents)) s1.x *= 5 assert sc1.contents.p.contents.p.contents.p.contents.x == 60 lltype.free(s1, flavor='raw') # a longer cycle s1 = lltype.malloc(S1, flavor='raw') s2 = lltype.malloc(S1, flavor='raw') s1.x = 111 s1.p = s2 s2.x = 222 s2.p = s1 sc1 = lltype2ctypes(s1) assert sc1.contents.x == 111 assert sc1.contents.p.contents.x == 222 assert (ctypes.addressof(sc1.contents.p.contents) != ctypes.addressof( sc1.contents)) assert (ctypes.addressof( sc1.contents.p.contents.p.contents) == ctypes.addressof( sc1.contents)) lltype.free(s1, flavor='raw') lltype.free(s2, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_recursive_struct(self): SX = lltype.ForwardReference() S1 = lltype.Struct('S1', ('p', lltype.Ptr(SX)), ('x', lltype.Signed)) SX.become(S1) # a chained list s1 = lltype.malloc(S1, flavor='raw') s2 = lltype.malloc(S1, flavor='raw') s3 = lltype.malloc(S1, flavor='raw') s1.x = 111 s2.x = 222 s3.x = 333 s1.p = s2 s2.p = s3 s3.p = lltype.nullptr(S1) sc1 = lltype2ctypes(s1) sc2 = sc1.contents.p sc3 = sc2.contents.p assert not sc3.contents.p assert sc1.contents.x == 111 assert sc2.contents.x == 222 assert sc3.contents.x == 333 sc3.contents.x += 1 assert s3.x == 334 s3.x += 2 assert sc3.contents.x == 336 lltype.free(s1, flavor='raw') lltype.free(s2, flavor='raw') lltype.free(s3, flavor='raw') # a self-cycle s1 = lltype.malloc(S1, flavor='raw') s1.x = 12 s1.p = s1 sc1 = lltype2ctypes(s1) assert sc1.contents.x == 12 assert (ctypes.addressof(sc1.contents.p.contents) == ctypes.addressof(sc1.contents)) s1.x *= 5 assert sc1.contents.p.contents.p.contents.p.contents.x == 60 lltype.free(s1, flavor='raw') # a longer cycle s1 = lltype.malloc(S1, flavor='raw') s2 = lltype.malloc(S1, flavor='raw') s1.x = 111 s1.p = s2 s2.x = 222 s2.p = s1 sc1 = lltype2ctypes(s1) assert sc1.contents.x == 111 assert sc1.contents.p.contents.x == 222 assert (ctypes.addressof(sc1.contents.p.contents) != ctypes.addressof(sc1.contents)) assert (ctypes.addressof(sc1.contents.p.contents.p.contents) == ctypes.addressof(sc1.contents)) lltype.free(s1, flavor='raw') lltype.free(s2, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_array_type_bug(self): A = lltype.Array(lltype.Signed) a1 = lltype.malloc(A, 0, flavor='raw') a2 = lltype.malloc(A, 0, flavor='raw') c1 = lltype2ctypes(a1) c2 = lltype2ctypes(a2) assert type(c1) is type(c2) lltype.free(a1, flavor='raw') lltype.free(a2, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_convert_subarray(self): A = lltype.GcArray(lltype.Signed) a = lltype.malloc(A, 20) inside = lltype.direct_ptradd(lltype.direct_arrayitems(a), 3) lltype2ctypes(inside) start = rffi.cast(lltype.Signed, lltype.direct_arrayitems(a)) inside_int = rffi.cast(lltype.Signed, inside) assert inside_int == start+rffi.sizeof(lltype.Signed)*3
def test_convert_subarray(self): A = lltype.GcArray(lltype.Signed) a = lltype.malloc(A, 20) inside = lltype.direct_ptradd(lltype.direct_arrayitems(a), 3) lltype2ctypes(inside) start = rffi.cast(lltype.Signed, lltype.direct_arrayitems(a)) inside_int = rffi.cast(lltype.Signed, inside) assert inside_int == start + rffi.sizeof(lltype.Signed) * 3
def test_funcptr2(self): FUNCTYPE = lltype.FuncType([rffi.CCHARP], lltype.Signed) cstrlen = standard_c_lib.strlen llstrlen = ctypes2lltype(lltype.Ptr(FUNCTYPE), cstrlen) assert lltype.typeOf(llstrlen) == lltype.Ptr(FUNCTYPE) p = rffi.str2charp("hi there") res = llstrlen(p) assert res == 8 cstrlen2 = lltype2ctypes(llstrlen) cp = lltype2ctypes(p) assert cstrlen2.restype == ctypes.c_long res = cstrlen2(cp) assert res == 8 rffi.free_charp(p) assert not ALLOCATED # detects memory leaks in the test
def test_substructures(self): S1 = lltype.Struct('S1', ('x', lltype.Signed)) BIG = lltype.Struct('BIG', ('s1a', S1), ('s1b', S1)) s = lltype.malloc(BIG, flavor='raw') s.s1a.x = 123 s.s1b.x = 456 sc = lltype2ctypes(s) assert sc.contents.s1a.x == 123 assert sc.contents.s1b.x == 456 sc.contents.s1a.x += 1 sc.contents.s1b.x += 10 assert s.s1a.x == 124 assert s.s1b.x == 466 s.s1a.x += 3 s.s1b.x += 30 assert sc.contents.s1a.x == 127 assert sc.contents.s1b.x == 496 lltype.free(s, flavor='raw') s = lltype.malloc(BIG, flavor='raw') s1ac = lltype2ctypes(s.s1a) s1ac.contents.x = 53 sc = lltype2ctypes(s) assert sc.contents.s1a.x == 53 sc.contents.s1a.x += 1 assert s1ac.contents.x == 54 assert s.s1a.x == 54 s.s1a.x += 2 assert s1ac.contents.x == 56 assert sc.contents.s1a.x == 56 sc.contents.s1a.x += 3 assert s1ac.contents.x == 59 assert s.s1a.x == 59 t = ctypes2lltype(lltype.Ptr(BIG), sc) assert t == s assert t.s1a == s.s1a assert t.s1a.x == 59 s.s1b.x = 8888 assert t.s1b == s.s1b assert t.s1b.x == 8888 t1 = ctypes2lltype(lltype.Ptr(S1), s1ac) assert t.s1a == t1 assert t1.x == 59 t1.x += 1 assert sc.contents.s1a.x == 60 lltype.free(s, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_cstruct_to_ll(self): S = lltype.Struct('S', ('x', lltype.Signed), ('y', lltype.Signed)) s = lltype.malloc(S, flavor='raw') s2 = lltype.malloc(S, flavor='raw') s.x = 123 sc = lltype2ctypes(s) t = ctypes2lltype(lltype.Ptr(S), sc) assert lltype.typeOf(t) == lltype.Ptr(S) assert s == t assert not (s != t) assert t == s assert not (t != s) assert t != lltype.nullptr(S) assert not (t == lltype.nullptr(S)) assert lltype.nullptr(S) != t assert not (lltype.nullptr(S) == t) assert t != s2 assert not (t == s2) assert s2 != t assert not (s2 == t) assert t.x == 123 t.x += 1 assert s.x == 124 s.x += 1 assert t.x == 125 lltype.free(s, flavor='raw') lltype.free(s2, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_uninitialized2ctypes(self): # for now, uninitialized fields are filled with 0xDD in the ctypes data def checkobj(o, size): p = ctypes.cast(ctypes.c_void_p(ctypes.addressof(o)), ctypes.POINTER(ctypes.c_ubyte*size)) for i in range(size): assert p.contents[i] == 0xDD def checkval(v, fmt): res = struct.pack(fmt, v) assert res == "\xDD" * len(res) checkval(uninitialized2ctypes(rffi.CHAR), 'B') checkval(uninitialized2ctypes(rffi.SHORT), 'h') checkval(uninitialized2ctypes(rffi.INT), 'i') checkval(uninitialized2ctypes(rffi.UINT), 'I') checkval(uninitialized2ctypes(rffi.LONGLONG), 'q') checkval(uninitialized2ctypes(rffi.DOUBLE), 'd') checkobj(uninitialized2ctypes(rffi.INTP), ctypes.sizeof(ctypes.c_void_p)) checkobj(uninitialized2ctypes(rffi.CCHARP), ctypes.sizeof(ctypes.c_void_p)) S = lltype.Struct('S', ('x', lltype.Signed), ('y', lltype.Signed)) s = lltype.malloc(S, flavor='raw') sc = lltype2ctypes(s) checkval(sc.contents.x, 'l') checkval(sc.contents.y, 'l') lltype.free(s, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_storage_stays_around(self): data = "hello, world!" * 100 A = lltype.Array(rffi.CHAR, hints={'nolength': True}) S = lltype.Struct('S', ('a', lltype.Ptr(A))) s = lltype.malloc(S, flavor='raw') lltype2ctypes(s) # force it to escape s.a = lltype.malloc(A, len(data), flavor='raw') # the storage for the array should not be freed by lltype even # though the _ptr object appears to go away here for i in xrange(len(data)): s.a[i] = data[i] for i in xrange(len(data)): assert s.a[i] == data[i] lltype.free(s.a, flavor='raw') lltype.free(s, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_arrayofstruct(self): S1 = lltype.Struct('S1', ('x', lltype.Signed)) A = lltype.Array(S1, hints={'nolength': True}) a = lltype.malloc(A, 5, flavor='raw') a[0].x = 100 a[1].x = 101 a[2].x = 102 a[3].x = 103 a[4].x = 104 ac = lltype2ctypes(a, normalize=False) assert ac.contents.items[0].x == 100 assert ac.contents.items[2].x == 102 ac.contents.items[3].x += 500 assert a[3].x == 603 a[4].x += 600 assert ac.contents.items[4].x == 704 a1 = ctypes2lltype(lltype.Ptr(A), ac) assert a1 == a assert a1[2].x == 102 aitem1 = ctypes2lltype(lltype.Ptr(S1), ctypes.pointer(ac.contents.items[1])) assert aitem1.x == 101 assert aitem1 == a1[1] lltype.free(a, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_forced_ptr_cast(self): import array A = lltype.Array(lltype.Signed, hints={'nolength': True}) B = lltype.Array(lltype.Char, hints={'nolength': True}) a = lltype.malloc(A, 10, flavor='raw') for i in range(10): a[i] = i*i b = rffi.cast(lltype.Ptr(B), a) checker = array.array('l') for i in range(10): checker.append(i*i) expected = checker.tostring() for i in range(len(expected)): assert b[i] == expected[i] c = rffi.cast(rffi.VOIDP, a) addr = lltype2ctypes(c) #assert addr == ctypes.addressof(a._obj._ctypes_storage) d = ctypes2lltype(rffi.VOIDP, addr) assert lltype.typeOf(d) == rffi.VOIDP assert c == d e = rffi.cast(lltype.Ptr(A), d) for i in range(10): assert e[i] == i*i c = lltype.nullptr(rffi.VOIDP.TO) addr = rffi.cast(lltype.Signed, c) assert addr == 0 lltype.free(a, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_carray_to_ll(self): A = lltype.Array(lltype.Signed, hints={'nolength': True}) a = lltype.malloc(A, 10, flavor='raw') a2 = lltype.malloc(A, 10, flavor='raw') a[0] = 100 a[1] = 101 a[2] = 110 ac = lltype2ctypes(a) b = ctypes2lltype(lltype.Ptr(A), ac) assert lltype.typeOf(b) == lltype.Ptr(A) assert b == a assert not (b != a) assert a == b assert not (a != b) assert b != lltype.nullptr(A) assert not (b == lltype.nullptr(A)) assert lltype.nullptr(A) != b assert not (lltype.nullptr(A) == b) assert b != a2 assert not (b == a2) assert a2 != b assert not (a2 == b) assert b[2] == 110 b[2] *= 2 assert a[2] == 220 a[2] *= 3 assert b[2] == 660 lltype.free(a, flavor='raw') lltype.free(a2, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_carray_to_ll(): A = lltype.Array(lltype.Signed, hints={'nolength': True}) a = lltype.malloc(A, 10, flavor='raw') a2 = lltype.malloc(A, 10, flavor='raw') a[0] = 100 a[1] = 101 a[2] = 110 ac = lltype2ctypes(a) b = ctypes2lltype(lltype.Ptr(A), ac) assert lltype.typeOf(b) == lltype.Ptr(A) assert b == a assert not (b != a) assert a == b assert not (a != b) assert b != lltype.nullptr(A) assert not (b == lltype.nullptr(A)) assert lltype.nullptr(A) != b assert not (lltype.nullptr(A) == b) assert b != a2 assert not (b == a2) assert a2 != b assert not (a2 == b) assert b[2] == 110 b[2] *= 2 assert a[2] == 220 a[2] *= 3 assert b[2] == 660 lltype.free(a, flavor='raw') lltype.free(a2, flavor='raw')
def test_cstruct_to_ll(): S = lltype.Struct('S', ('x', lltype.Signed), ('y', lltype.Signed)) s = lltype.malloc(S, flavor='raw') s2 = lltype.malloc(S, flavor='raw') s.x = 123 sc = lltype2ctypes(s) t = ctypes2lltype(lltype.Ptr(S), sc) assert lltype.typeOf(t) == lltype.Ptr(S) assert s == t assert not (s != t) assert t == s assert not (t != s) assert t != lltype.nullptr(S) assert not (t == lltype.nullptr(S)) assert lltype.nullptr(S) != t assert not (lltype.nullptr(S) == t) assert t != s2 assert not (t == s2) assert s2 != t assert not (s2 == t) assert t.x == 123 t.x += 1 assert s.x == 124 s.x += 1 assert t.x == 125 lltype.free(s, flavor='raw') lltype.free(s2, flavor='raw')
def test_forced_ptr_cast(self): import array A = lltype.Array(lltype.Signed, hints={'nolength': True}) B = lltype.Array(lltype.Char, hints={'nolength': True}) a = lltype.malloc(A, 10, flavor='raw') for i in range(10): a[i] = i * i b = rffi.cast(lltype.Ptr(B), a) checker = array.array('l') for i in range(10): checker.append(i * i) expected = checker.tostring() for i in range(len(expected)): assert b[i] == expected[i] c = rffi.cast(rffi.VOIDP, a) addr = lltype2ctypes(c) #assert addr == ctypes.addressof(a._obj._ctypes_storage) d = ctypes2lltype(rffi.VOIDP, addr) assert lltype.typeOf(d) == rffi.VOIDP assert c == d e = rffi.cast(lltype.Ptr(A), d) for i in range(10): assert e[i] == i * i c = lltype.nullptr(rffi.VOIDP.TO) addr = rffi.cast(lltype.Signed, c) assert addr == 0 lltype.free(a, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_uninitialized2ctypes(self): # for now, uninitialized fields are filled with 0xDD in the ctypes data def checkobj(o, size): p = ctypes.cast(ctypes.c_void_p(ctypes.addressof(o)), ctypes.POINTER(ctypes.c_ubyte * size)) for i in range(size): assert p.contents[i] == 0xDD def checkval(v, fmt): res = struct.pack(fmt, v) assert res == "\xDD" * len(res) checkval(uninitialized2ctypes(rffi.CHAR), 'B') checkval(uninitialized2ctypes(rffi.SHORT), 'h') checkval(uninitialized2ctypes(rffi.INT), 'i') checkval(uninitialized2ctypes(rffi.UINT), 'I') checkval(uninitialized2ctypes(rffi.LONGLONG), 'q') checkval(uninitialized2ctypes(rffi.DOUBLE), 'd') checkobj(uninitialized2ctypes(rffi.INTP), ctypes.sizeof(ctypes.c_void_p)) checkobj(uninitialized2ctypes(rffi.CCHARP), ctypes.sizeof(ctypes.c_void_p)) S = lltype.Struct('S', ('x', lltype.Signed), ('y', lltype.Signed)) s = lltype.malloc(S, flavor='raw') sc = lltype2ctypes(s) checkval(sc.contents.x, 'l') checkval(sc.contents.y, 'l') lltype.free(s, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_gcref_forth_and_back(self): cp = ctypes.c_void_p(1234) v = ctypes2lltype(llmemory.GCREF, cp) assert lltype2ctypes(v).value == cp.value v1 = ctypes2lltype(llmemory.GCREF, cp) assert v == v1 assert v v2 = ctypes2lltype(llmemory.GCREF, ctypes.c_void_p(1235)) assert v2 != v
def test_prebuilt_ll2ctypes_array(self): from pypy.rpython.lltypesystem import rffi, ll2ctypes A = rffi.CArray(Char) a = malloc(A, 6, flavor='raw', immortal=True) a[0] = 'a' a[1] = 'b' a[2] = 'c' a[3] = 'd' a[4] = '\x00' a[5] = '\x00' # side effects when converting to c structure ll2ctypes.lltype2ctypes(a) def llf(): s = '' for i in range(4): s += a[i] return 'abcd' == s fn = self.getcompiled(llf) assert fn()
def test_prebuilt_ll2ctypes_array(self): from pypy.rpython.lltypesystem import rffi, ll2ctypes A = rffi.CArray(Char) a = malloc(A, 6, flavor='raw') a[0] = 'a' a[1] = 'b' a[2] = 'c' a[3] = 'd' a[4] = '\x00' a[5] = '\x00' # side effects when converting to c structure ll2ctypes.lltype2ctypes(a) def llf(): s = '' for i in range(4): s += a[i] return 'abcd' == s fn = self.getcompiled(llf) assert fn()
def test_array_inside_struct(self): # like rstr.STR, but not Gc STR = lltype.Struct('STR', ('x', lltype.Signed), ('y', lltype.Array(lltype.Char))) a = lltype.malloc(STR, 3, flavor='raw') a.y[0] = 'x' a.y[1] = 'y' a.y[2] = 'z' ac = lltype2ctypes(a) assert ac.contents.y.length == 3 assert ac.contents.y.items[2] == ord('z') lltype.free(a, flavor='raw') assert not ALLOCATED
def test_struct_ptrs(self): S2 = lltype.Struct('S2', ('y', lltype.Signed)) S1 = lltype.Struct('S', ('x', lltype.Signed), ('p', lltype.Ptr(S2))) s1 = lltype.malloc(S1, flavor='raw') s2a = lltype.malloc(S2, flavor='raw') s2b = lltype.malloc(S2, flavor='raw') s2a.y = ord('a') s2b.y = ord('b') sc1 = lltype2ctypes(s1) sc1.contents.x = 50 assert s1.x == 50 sc1.contents.p = lltype2ctypes(s2a) assert s1.p == s2a s1.p.y -= 32 assert sc1.contents.p.contents.y == ord('A') s1.p = s2b sc1.contents.p.contents.y -= 32 assert s2b.y == ord('B') lltype.free(s1, flavor='raw') lltype.free(s2a, flavor='raw') lltype.free(s2b, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_recursive_struct_more(self): NODE = lltype.ForwardReference() NODE.become(lltype.Struct('NODE', ('value', lltype.Signed), ('next', lltype.Ptr(NODE)))) CNODEPTR = get_ctypes_type(NODE) pc = CNODEPTR() pc.value = 42 pc.next = ctypes.pointer(pc) p = ctypes2lltype(lltype.Ptr(NODE), ctypes.pointer(pc)) assert p.value == 42 assert p.next == p pc2 = lltype2ctypes(p) assert pc2.contents.value == 42 assert pc2.contents.next.contents.value == 42
def test_charp(): s = rffi.str2charp("hello") sc = lltype2ctypes(s, normalize=False) assert sc.contents.items[0] == ord('h') assert sc.contents.items[1] == ord('e') assert sc.contents.items[2] == ord('l') assert sc.contents.items[3] == ord('l') assert sc.contents.items[4] == ord('o') assert sc.contents.items[5] == 0 assert not hasattr(sc.contents, 'length') sc.contents.items[1] = ord('E') assert s[1] == 'E' s[0] = 'H' assert sc.contents.items[0] == ord('H')
def test_unicharp(self): SP = rffi.CArrayPtr(lltype.UniChar) s = lltype.malloc(SP.TO, 4, flavor='raw') s[0] = u'x' s[1] = u'y' s[2] = u'z' s[3] = u'\x00' sc = lltype2ctypes(s, normalize=False) assert sc.contents.items[0] == ord(u'x') assert sc.contents.items[1] == ord(u'y') assert sc.contents.items[2] == ord(u'z') assert not hasattr(sc.contents, 'length') lltype.free(s, flavor='raw') assert not ALLOCATED
def test_simple_struct(): S = lltype.Struct('S', ('x', lltype.Signed), ('y', lltype.Signed)) s = lltype.malloc(S, flavor='raw') s.x = 123 sc = lltype2ctypes(s) assert isinstance(sc.contents, ctypes.Structure) assert sc.contents.x == 123 sc.contents.x = 456 assert s.x == 456 s.x = 789 assert sc.contents.x == 789 s.y = 52 assert sc.contents.y == 52 lltype.free(s, flavor='raw')
def test_c_callback_with_void_arg_2(self): ftest = [] def f(x): ftest.append(x) F = lltype.FuncType([lltype.Void], lltype.Void) fn = lltype.functionptr(F, 'askjh', _callable=f, _void0=-5) fn(-5) assert ftest == [-5] fn2 = lltype2ctypes(fn) fn2() assert ftest == [-5, -5] fn3 = ctypes2lltype(lltype.Ptr(F), fn2) fn3(-5) assert ftest == [-5, -5, -5]
def test_funcptr1(self): def dummy(n): return n + 1 FUNCTYPE = lltype.FuncType([lltype.Signed], lltype.Signed) cdummy = lltype2ctypes(llhelper(lltype.Ptr(FUNCTYPE), dummy)) assert isinstance(cdummy, ctypes.CFUNCTYPE(ctypes.c_long, ctypes.c_long)) res = cdummy(41) assert res == 42 lldummy = ctypes2lltype(lltype.Ptr(FUNCTYPE), cdummy) assert lltype.typeOf(lldummy) == lltype.Ptr(FUNCTYPE) res = lldummy(41) assert res == 42 assert not ALLOCATED # detects memory leaks in the test
def test_recursive_struct_more(self): NODE = lltype.ForwardReference() NODE.become( lltype.Struct('NODE', ('value', lltype.Signed), ('next', lltype.Ptr(NODE)))) CNODEPTR = get_ctypes_type(NODE) pc = CNODEPTR() pc.value = 42 pc.next = ctypes.pointer(pc) p = ctypes2lltype(lltype.Ptr(NODE), ctypes.pointer(pc)) assert p.value == 42 assert p.next == p pc2 = lltype2ctypes(p) assert pc2.contents.value == 42 assert pc2.contents.next.contents.value == 42
def test_funcptr1(self): def dummy(n): return n+1 FUNCTYPE = lltype.FuncType([lltype.Signed], lltype.Signed) cdummy = lltype2ctypes(llhelper(lltype.Ptr(FUNCTYPE), dummy)) assert isinstance(cdummy, ctypes.CFUNCTYPE(ctypes.c_long, ctypes.c_long)) res = cdummy(41) assert res == 42 lldummy = ctypes2lltype(lltype.Ptr(FUNCTYPE), cdummy) assert lltype.typeOf(lldummy) == lltype.Ptr(FUNCTYPE) res = lldummy(41) assert res == 42 assert not ALLOCATED # detects memory leaks in the test
def test_array_nolength(): A = lltype.Array(lltype.Signed, hints={'nolength': True}) a = lltype.malloc(A, 10, flavor='raw') a[0] = 100 a[1] = 101 a[2] = 102 ac = lltype2ctypes(a, normalize=False) assert isinstance(ac.contents, ctypes.Structure) assert ac.contents.items[1] == 101 ac.contents.items[2] = 456 assert a[2] == 456 a[3] = 789 assert ac.contents.items[3] == 789 assert ctypes.sizeof(ac.contents) == 10 * ctypes.sizeof(ctypes.c_long) lltype.free(a, flavor='raw')
def test_simple_struct(self): S = lltype.Struct('S', ('x', lltype.Signed), ('y', lltype.Signed)) s = lltype.malloc(S, flavor='raw') s.x = 123 sc = lltype2ctypes(s) assert isinstance(sc.contents, ctypes.Structure) assert sc.contents.x == 123 sc.contents.x = 456 assert s.x == 456 s.x = 789 assert sc.contents.x == 789 s.y = 52 assert sc.contents.y == 52 lltype.free(s, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_array_inside_struct(self): # like rstr.STR, but not Gc STR = lltype.Struct('STR', ('x', lltype.Signed), ('y', lltype.Array(lltype.Char))) a = lltype.malloc(STR, 3, flavor='raw') a.y[0] = 'x' a.y[1] = 'y' a.y[2] = 'z' # we need to pass normalize=False, otherwise 'ac' is returned of # a normalized standard type, which complains about IndexError # when doing 'ac.contents.y.items[2]'. ac = lltype2ctypes(a, normalize=False) assert ac.contents.y.length == 3 assert ac.contents.y.items[2] == ord('z') lltype.free(a, flavor='raw') assert not ALLOCATED
def test_simple_array(): A = lltype.Array(lltype.Signed) a = lltype.malloc(A, 10, flavor='raw') a[0] = 100 a[1] = 101 a[2] = 102 ac = lltype2ctypes(a, normalize=False) assert isinstance(ac.contents, ctypes.Structure) assert ac.contents.length == 10 assert ac.contents.items[1] == 101 ac.contents.items[2] = 456 assert a[2] == 456 a[3] = 789 assert ac.contents.items[3] == 789 lltype.free(a, flavor='raw')
def test_charp(self): s = rffi.str2charp("hello") sc = lltype2ctypes(s, normalize=False) assert sc.contents.items[0] == ord('h') assert sc.contents.items[1] == ord('e') assert sc.contents.items[2] == ord('l') assert sc.contents.items[3] == ord('l') assert sc.contents.items[4] == ord('o') assert sc.contents.items[5] == 0 assert not hasattr(sc.contents, 'length') sc.contents.items[1] = ord('E') assert s[1] == 'E' s[0] = 'H' assert sc.contents.items[0] == ord('H') rffi.free_charp(s) assert not ALLOCATED # detects memory leaks in the test
def test_arrayoffloat(self): a = lltype.malloc(rffi.FLOATP.TO, 3, flavor='raw') a[0] = rffi.r_singlefloat(0.0) a[1] = rffi.r_singlefloat(1.1) a[2] = rffi.r_singlefloat(2.2) ac = lltype2ctypes(a, normalize=False) assert ac.contents.items[0] == 0.0 assert abs(ac.contents.items[1] - 1.1) < 1E-6 assert abs(ac.contents.items[2] - 2.2) < 1E-6 b = ctypes2lltype(rffi.FLOATP, ac) assert isinstance(b[0], rffi.r_singlefloat) assert float(b[0]) == 0.0 assert isinstance(b[1], rffi.r_singlefloat) assert abs(float(b[1]) - 1.1) < 1E-6 assert isinstance(b[2], rffi.r_singlefloat) assert abs(float(b[2]) - 2.2) < 1E-6
def test_simple_array(self): A = lltype.Array(lltype.Signed) a = lltype.malloc(A, 10, flavor='raw') a[0] = 100 a[1] = 101 a[2] = 102 ac = lltype2ctypes(a, normalize=False) assert isinstance(ac.contents, ctypes.Structure) assert ac.contents.length == 10 assert ac.contents.items[1] == 101 ac.contents.items[2] = 456 assert a[2] == 456 a[3] = 789 assert ac.contents.items[3] == 789 lltype.free(a, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_array_nolength(self): A = lltype.Array(lltype.Signed, hints={'nolength': True}) a = lltype.malloc(A, 10, flavor='raw') a[0] = 100 a[1] = 101 a[2] = 102 ac = lltype2ctypes(a, normalize=False) assert isinstance(ac.contents, ctypes.Structure) assert ac.contents.items[1] == 101 ac.contents.items[2] = 456 assert a[2] == 456 a[3] = 789 assert ac.contents.items[3] == 789 assert ctypes.sizeof(ac.contents) == 10 * ctypes.sizeof(ctypes.c_long) lltype.free(a, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_simple_array(self): A = lltype.Array(lltype.Signed) a = lltype.malloc(A, 10, flavor='raw') a[0] = 100 a[1] = 101 a[2] = 102 ac = lltype2ctypes(a, normalize=False) assert isinstance(ac.contents, ctypes.Structure) assert ac.contents.length == 10 assert ac.contents._fields_[0] == ('length', ctypes.c_long) assert ac.contents.items[1] == 101 ac.contents.items[2] = 456 assert a[2] == 456 a[3] = 789 assert ac.contents.items[3] == 789 lltype.free(a, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_indirect_recursive_struct(self): S2Forward = lltype.ForwardReference() S1 = lltype.Struct('S1', ('p', lltype.Ptr(S2Forward))) A2 = lltype.Array(lltype.Ptr(S1), hints={'nolength': True}) S2 = lltype.Struct('S2', ('a', lltype.Ptr(A2))) S2Forward.become(S2) s1 = lltype.malloc(S1, flavor='raw') a2 = lltype.malloc(A2, 10, flavor='raw') s2 = lltype.malloc(S2, flavor='raw') s2.a = a2 a2[5] = s1 s1.p = s2 ac2 = lltype2ctypes(a2, normalize=False) sc1 = ac2.contents.items[5] sc2 = sc1.contents.p assert (ctypes.addressof(sc2.contents.a.contents) == ctypes.addressof( ac2.contents)) lltype.free(s1, flavor='raw') lltype.free(a2, flavor='raw') lltype.free(s2, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_with_explicit_length(self): A = lltype.Array(lltype.Signed) a1 = lltype.malloc(A, 5, flavor='raw') a1[0] = 42 c1 = lltype2ctypes(a1, normalize=False) assert c1.contents.length == 5 assert c1.contents.items[0] == 42 res = ctypes2lltype(lltype.Ptr(A), c1) assert res == a1 assert len(res) == 5 assert res[0] == 42 res[0] += 1 assert c1.contents.items[0] == 43 assert a1[0] == 43 a1[0] += 2 assert c1.contents.items[0] == 45 assert a1[0] == 45 c1.contents.items[0] += 3 assert res[0] == 48 assert a1[0] == 48 lltype.free(a1, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_varsized_struct(self): S = lltype.Struct('S', ('x', lltype.Signed), ('a', lltype.Array(lltype.Char))) s1 = lltype.malloc(S, 6, flavor='raw') s1.x = 5 s1.a[2] = 'F' sc = lltype2ctypes(s1, normalize=False) assert isinstance(sc.contents, ctypes.Structure) assert sc.contents.x == 5 assert sc.contents.a.length == 6 assert sc.contents.a.items[2] == ord('F') sc.contents.a.items[3] = ord('P') assert s1.a[3] == 'P' s1.a[1] = 'y' assert sc.contents.a.items[1] == ord('y') # now go back to lltype... res = ctypes2lltype(lltype.Ptr(S), sc) assert res == s1 assert res.x == 5 assert len(res.a) == 6 lltype.free(s1, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_ll2ctypes_array_from_c(self): from pypy.rpython.lltypesystem import rffi, ll2ctypes A = rffi.CArray(Char) a = malloc(A, 6, flavor='raw') a[0] = 'a' a[1] = 'b' a[2] = 'c' a[3] = 'd' a[4] = '\x00' a[5] = '\x00' # side effects when converting to c structure c = ll2ctypes.lltype2ctypes(a) a = ll2ctypes.ctypes2lltype(Ptr(A), c) def llf(): s = '' for i in range(4): s += a[i] print s return s == 'abcd' fn = self.getcompiled(llf) assert fn()