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_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_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_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_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_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_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_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_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')
        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_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_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]