def test_translate():
    from pypy.translator.c.test.test_genc import compile

    def func():
        poll({})

    compile(func, [])

    def test_translated(self):
        from pypy.translator.c.test.test_genc import compile

        def func(no):
            m = mmap.mmap(no, 1)
            r = m.read_byte()
            m.close()
            return r

        compile(func, [int])

def test_stringstar():
    c_source = """
    #include <string.h>
    
    int f(char *args[]) {
        char **p = args;
        int l = 0;
        while (*p) {
            l += strlen(*p);
            p++;
        }
        return (l);
    }
    """
    c_file = udir.join("stringstar.c")
    c_file.write(c_source)
    z = llexternal('f', [CCHARPP], Signed, sources=[str(c_file)])

    def f():
        l = ["xxx", "x", "xxxx"]
        ss = liststr2charpp(l)
        result = z(ss)
        free_charpp(ss)
        return result

    xf = compile(f, [], backendopt=False)
    assert xf() == 8

def test_with_new_with_allocate_instance():
    def mytype_new(space, w_subtype, x):
        w_obj = space.allocate_instance(W_MyType, w_subtype)
        W_MyType.__init__(space.interp_w(W_MyType, w_obj), space, x)
        return w_obj
    mytype_new.unwrap_spec = [ObjSpace, W_Root, int]

    W_MyType.typedef = TypeDef("MyType",
                               __new__ = interp2app(mytype_new),
                               x = interp_attrproperty("x", W_MyType))
    space = CPyObjSpace()

    def build():
        w_type = space.gettypefor(W_MyType)
        return space.call_function(w_type, space.wrap(42))

    w_obj = build()
    w_name = space.getattr(space.type(w_obj), space.wrap('__name__'))
    assert space.unwrap(w_name) == 'MyType'
    assert space.int_w(space.getattr(w_obj, space.wrap('x'))) == 42

    fn = compile(build, [],
                 annotatorpolicy = CPyAnnotatorPolicy(space))
    res = fn(expected_extra_mallocs=1)
    assert type(res).__name__ == 'MyType'
    assert res.x == 42

def test_with_new_with_allocate_instance_subclass():
    py.test.skip("dealloction for now segfaults")
    def mytype_new(space, w_subtype, x):
        w_obj = space.allocate_instance(W_MyType, w_subtype)
        W_MyType.__init__(space.interp_w(W_MyType, w_obj), space, x)
        return w_obj
    mytype_new.unwrap_spec = [ObjSpace, W_Root, int]

    W_MyType.typedef = TypeDef("MyType",
                               __new__ = interp2app(mytype_new),
                               x = interp_attrproperty("x", W_MyType))
    space = CPyObjSpace()

    def build():
        w_type = space.gettypefor(W_MyType)
        return space.call_function(w_type, space.wrap(42))

    fn = compile(build, [],
                 annotatorpolicy = CPyAnnotatorPolicy(space))
    res = fn(expected_extra_mallocs=1)
    assert type(res).__name__ == 'MyType'
    assert res.x == 42

    class MyType2(type(res)):
        pass

    res2 = MyType2(42)
    assert type(res2) is MyType2
    assert res2.x == 42

    del res2
    import gc
    gc.collect()

def test_string_reverse():
    c_source = py.code.Source("""
    #include <string.h>

    char *f(char* arg)
    {
        char *ret;
        ret = (char*)malloc(strlen(arg) + 1);
        strcpy(ret, arg);
        return ret;
    }
    """)
    c_file = udir.join("stringrev.c")
    c_file.write(c_source)
    z = llexternal('f', [CCHARP], CCHARP, sources=[str(c_file)])    

    def f():
        s = str2charp("xxx")
        l_res = z(s)
        res = charp2str(l_res)
        lltype.free(l_res, flavor='raw')
        free_charp(s)
        return len(res)

    xf = compile(f, [], backendopt=False)
    assert xf(expected_extra_mallocs=-1) == 3

def test_expose_types():
    W_MyType.typedef = TypeDef("MyType")

    class W_MyType2(Wrappable):
        def __init__(self, space, x=1):
            self.space = space
            self.x = x
    W_MyType2.typedef = TypeDef("MyType2")
    space = CPyObjSpace()

    def get_mytype(n):
        if n:
            return space.gettypefor(W_MyType2)
        else:
            return space.gettypefor(W_MyType)
        return None
    fn = compile(get_mytype, [int],
                 annotatorpolicy = CPyAnnotatorPolicy(space))

    w_mytype2 = get_mytype(1)
    w_name = space.getattr(w_mytype2, space.wrap('__name__'))
    assert space.unwrap(w_name) == 'MyType2'
    w_mytype = get_mytype(0)
    w_name = space.getattr(w_mytype, space.wrap('__name__'))
    assert space.unwrap(w_name) == 'MyType'

    res2 = fn(1)
    assert type(res2) == type
    assert res2.__name__ == 'MyType2'
    res = fn(0)
    assert res.__name__ == 'MyType'

def test_math():
    f = compile(fn, [])
    res = f()
    if res >= 0:
        py.test.fail(repr(test_direct.MathTests.TESTCASES[res]))
    else:
        assert res == -42

    def test_os_setpgrp():
        def does_stuff():
            return os.setpgrp()

        f1 = compile(does_stuff, [])
        res = f1()
        assert res == os.setpgrp()

    def test_compile_pythonapi(self):
        from pypy.rpython.rctypes import apyobject
        class W_Object(py_object):
            pass
        apyobject.register_py_object_subclass(W_Object)
        PyInt_AsLong = pythonapi.PyInt_AsLong
        PyInt_AsLong.argtypes = [W_Object]
        PyInt_AsLong.restype = c_long
        assert PyInt_AsLong._flags_ & _FUNCFLAG_PYTHONAPI

        PyNumber_Add = pythonapi.PyNumber_Add
        PyNumber_Add.argtypes = [W_Object, W_Object]
        PyNumber_Add.restype = W_Object

        def fn1(x, crash):
            pyobj = W_Object(x)
            pyobj = PyNumber_Add(pyobj, pyobj)
            x = PyInt_AsLong(pyobj)
            if crash:
                # fn(sys.maxint, 1) should crash on PyInt_AsLong before
                # it arrives here.  If by mistake it arrives here then
                # we get a TypeError instead of the OverflowError
                PyNumber_Add(W_Object(5), W_Object("x"))
            return x

        fn = compile(fn1, [int, int])
        res = fn(17, 0)
        assert res == 34
        py.test.raises(OverflowError, 'fn(sys.maxint, 1)')

def test_rarith_float_to_str():
    def fn(f):
        return str(f)

    f = compile(fn, [float])
    res = f(1.5)
    assert eval(res) == 1.5

    def test_os_getpid():
        def does_stuff():
            return os.getpid()

        f1 = compile(does_stuff, [])
        res = f1()
        assert res == os.getpid()

def test_system():
    def does_stuff(cmd):
        return os.system(cmd)

    f1 = compile(does_stuff, [str])
    res = f1("echo hello")
    assert res == 0

def test_strerror():
    def does_stuff():
        return os.strerror(2)

    f1 = compile(does_stuff, [])
    res = f1()
    assert res == os.strerror(2)

def test_os_stat():
    filename = str(py.path.local(__file__))
    has_blksize = hasattr(os.stat_result, "st_blksize")
    has_blocks = hasattr(os.stat_result, "st_blocks")

    def call_stat():
        st = os.stat(filename)
        res = (st[0], st.st_ino, st.st_ctime)
        if has_blksize:
            res += (st.st_blksize,)
        if has_blocks:
            res += (st.st_blocks,)
        return res

    f = compile(call_stat, [])
    res = f()
    assert res[0] == os.stat(filename).st_mode
    assert res[1] == os.stat(filename).st_ino
    st_ctime = res[2]
    if isinstance(st_ctime, float):
        assert st_ctime == os.stat(filename).st_ctime
    else:
        assert st_ctime == int(os.stat(filename).st_ctime)
    if has_blksize:
        assert res[3] == os.stat(filename).st_blksize
        if has_blocks:
            assert res[4] == os.stat(filename).st_blocks

    def setup_class(self):
        if not test_c_compile:
            py.test.skip("c compilation disabled")

        from pypy.translator.c.test.test_genc import compile

        self.compile = lambda s, x, y: compile(x, y, backendopt=True)

def test_catches():
    def one(x):
        if x == 1:
            raise ValueError()
        elif x == 2:
            raise TypeError()
        return x - 5

    def foo(x):
        x = one(x)
        try:
            x = one(x)
        except ValueError:
            return 1 + x
        except TypeError:
            return 2 + x
        except:
            return 3 + x
        return 4 + x
    t, g = transform_func(foo, [int])
    assert len(list(g.iterblocks())) == 9
    f = compile(foo, [int])
    result = interpret(foo, [6])
    assert result == 2
    result = f(6)
    assert result == 2
    result = interpret(foo, [7])
    assert result == 4
    result = f(7)
    assert result == 4
    result = interpret(foo, [8])
    assert result == 2
    result = f(8)
    assert result == 2

    def test_compile_pyerrchecker(self):
        from pypy.rpython.rctypes import apyobject
        class W_Object(py_object):
            pass
        apyobject.register_py_object_subclass(W_Object)

        def mypyerrchecker():
            # for this test, always raises
            raise ZeroDivisionError

        PyNumber_Add = pythonapi.PyNumber_Add
        PyNumber_Add.argtypes = [W_Object, W_Object]
        PyNumber_Add.restype = W_Object
        assert PyNumber_Add._flags_ & _FUNCFLAG_PYTHONAPI
        PyNumber_Add._rctypes_pyerrchecker_ = mypyerrchecker
        # special extension ^^^ to support the CPyObjSpace
        try:
            def fn1(n):
                if n < 0:
                    # for this test, force mypyerrchecker() to be annotated
                    # using this trick
                    mypyerrchecker()
                pyobj = W_Object(n)
                return PyNumber_Add(pyobj, pyobj)

            fn = compile(fn1, [int])
            py.test.raises(ZeroDivisionError, fn, 64)
        finally:
            del PyNumber_Add._rctypes_pyerrchecker_

def test_simple_start_new_thread():
    import thread
    import pypy.module.thread.rpython.exttable   # for declare()/declaretype()
    class Arg:
        pass
    def mythreadedfunction(arg):
        assert arg.value == 42
    def myotherthreadedfunction(arg):
        assert arg.value == 43
    a42 = Arg()
    a42.value = 42
    a43 = Arg()
    a43.value = 43
    def fn(i):
        thread.start_new_thread(mythreadedfunction, (a42,))
        thread.start_new_thread(myotherthreadedfunction, (a43,))
        if i == 1:
            x = mythreadedfunction
            a = a42
        else:
            x = myotherthreadedfunction
            a = a43
        thread.start_new_thread(x, (a,))
        return 42
    f = compile(fn, [int])
    res = f(1)
    assert res == 42

def test_stat_result():
    import os
    from pypy.translator.c.test.test_genc import compile
    from pypy.rpython.module.ll_os_stat import s_StatResult

    marshal_stat_result = get_marshaller(s_StatResult)
    unmarshal_stat_result = get_unmarshaller(s_StatResult)

    def f(path):
        st = os.stat(path)
        buf = []
        marshal_stat_result(buf, st)
        buf = "".join(buf)
        st2 = unmarshal_stat_result(buf)
        assert st2.st_mode == st.st_mode
        assert st2[9] == st[9]
        return buf

    fn = compile(f, [str])
    res = fn(".")
    st = os.stat(".")
    sttuple = marshal.loads(res)
    assert sttuple[0] == st[0]
    assert sttuple[1] == st[1]
    assert sttuple[2] == st[2]
    assert sttuple[3] == st[3]
    assert sttuple[4] == st[4]
    assert sttuple[5] == st[5]
    assert len(sttuple) == 10