def test_convert_return_value():
    builtin = import_module("__builtin__")
    operator = import_module("operator")

    assert builtin.int(32) == 32
    assert builtin.float(3.123) == 3.123

    for s in ['a string']: # TODO 'a string \00yep']:
        assert builtin.str(s) == s

    u = u"some буквы are странные"
    assert builtin.unicode(u) == u

    t = (1, (2.3,))
    assert builtin.tuple(t) == t

    d = {'a': 'b', 1: 2}
    assert builtin.dict(d) == d

    lst = ['a', 1, [2]]
    assert builtin.list(lst) == lst

    assert builtin.bool(True) is True
    assert builtin.bool(False) is False

    assert builtin.bool(None) is False
    assert operator.eq(None, None) is True
    assert operator.eq(None, False) is False

def test_no_convert():
    operator = import_module("operator")
    functools = import_module("functools")
    builtin = import_module("__builtin__", noconvert=True)

    lst = builtin.list()

    part = functools.partial(operator.iadd, lst)
    part([1, 2, 3])

    assert pypy_convert(lst.obj) == [1, 2, 3]

def test_callbacks_on_wrappers():
    builtin = import_module("__builtin__", noconvert=True)
    p1, p2, p3, p4 = points = [
        Point(0, 0),
        Point(0, 1),
        Point(1, 2),
        Point(3, 4)]
    lst = builtin.list([p3, p2, p1, p4])
    lst.sort(key=lambda x: x.norm())
    assert _pypy_convert_list(lst) == points

    # method callbacks
    class Norm(object):
        def __init__(self, n):
            self.n = n
        def norm(self, point):
            return math.pow(point.norm()**2, 1.0 / self.n)
    norm = Norm(2)
    lst.reverse()
    lst.sort(key=norm.norm)
    assert _pypy_convert_list(lst) == points

    # dict.get as a callback
    d = dict((p, p.norm()) for p in points)
    lst.reverse()
    lst.sort(key=d.get)

def test_slice():
    builtin = import_module("__builtin__", noconvert=True)
    lst = builtin.list(list(xrange(10)))
    assert _pypy_convert_list(lst) == list(xrange(10))
    assert _pypy_convert_list(lst[-1:]) == [9]
    assert _pypy_convert_list(lst[:2]) == [0, 1]
    assert _pypy_convert_list(lst[-9:3]) == [1, 2]

def test_opaque_objects():
    builtin = import_module("__builtin__")
    builtin_noconvert = import_module("__builtin__", noconvert=True)
    p1, p2 = Point(1.0, 2.0), Point(3.0, -1.0)
    d = DictSubclass()

    lst = builtin.list([p1, p2, d])
    assert lst == [p1, p2, d]

    lst_cpy = builtin_noconvert.list([p1, p2, d])
    assert pypy_convert(lst_cpy[0].obj) == p1
    assert pypy_convert(lst_cpy[1].obj) == p2
    assert pypy_convert(lst_cpy[2].obj) == d
    lst_cpy.reverse()
    assert pypy_convert(lst_cpy[0].obj) == d
    assert pypy_convert(lst_cpy[1].obj) == p2
    assert pypy_convert(lst_cpy[2].obj) == p1

def test_exceptions():
    builtin = import_module("__builtin__")

    with pytest.raises(AttributeError):
        builtin.foo

    with pytest.raises(ValueError): # TODO UnicodeDecodeError
        builtin.unicode('\124\323')

def test_len():
    builtin = import_module("__builtin__", noconvert=True)
    lst = builtin.list([1, 'a'])
    assert len(lst) == 2
    assert len(builtin.list()) == 0
    assert len(builtin.str('abc')) == 3

    with pytest.raises(TypeError):
        len(builtin.iter([1]))

def test_str_repr_dir():
    builtin = import_module("__builtin__", noconvert=True)

    assert str(builtin.None) == 'None'
    assert str(builtin.str('a')) == 'a'
    assert repr(builtin.str('a')) == "'a'"

    assert set(['rjust', 'rpartition', 'rstrip', '__le__'])\
            .issubset(dir(builtin.str('a')))

def register_cpy_numpy_to_pypy_builtin_converters():
    ''' Converts numpy types to builtin python types on PyPy side
    '''
    numpy = import_module("numpy")
    builtin = import_module("__builtin__", noconvert=True)
    def call_direct(f):
        f = MetabiosisWrapper(f.obj, noconvert=False)
        return lambda x: f._call((x,), args_kwargs_converted=True)

    cpy_to_pypy_converters.update({
        numpy.bool_.obj: call_direct(builtin.bool),
        numpy.int8.obj: call_direct(builtin.int),
        numpy.int16.obj: call_direct(builtin.int),
        numpy.int32.obj: call_direct(builtin.int),
        numpy.int64.obj: call_direct(builtin.int),
        numpy.float16.obj: call_direct(builtin.float),
        numpy.float32.obj: call_direct(builtin.float),
        numpy.float64.obj: call_direct(builtin.float),
    })

    if hasattr(numpy, "float128"):
        cpy_to_pypy_converters.update({numpy.float128.obj: call_direct(builtin.float)})

def test_callbacks_exceptions():
    builtin = import_module("__builtin__")
    d = {1: 2}
    fn = lambda x: d[x]
    assert builtin.apply(fn, (1,)) == 2
    # exception in callback
    with pytest.raises(KeyError):
        builtin.apply(fn, (2,))
    # exception in converting result
    try:
        builtin.apply(lambda : object())
    except SystemError:
        assert False
    except Exception:
        pass

def test_sqlite():
    # Taken from Python 2.7's sqlite doc
    sqlite3 = import_module("sqlite3")

    con = sqlite3.connect(":memory:")
    cur = con.cursor()
    cur.execute("create table people (name_last, age)")

    who = "Yeltsin"
    age = 72

    cur.execute("insert into people values (?, ?)", (who, age))

    cur.execute("select * from people where name_last=:who and age=:age", {"who": who, "age": age})

    ret = cur.fetchone()
    assert ret == (u'Yeltsin', 72)

def test_scalar_converter():
    try:
        numpy = import_module("numpy")
    except ImportError:
        pytest.skip("numpy isn't installed on the cpython side")

    assert numpy.bool_(True) is True
    assert numpy.bool_(False) is False

    assert numpy.int8(10) == 10
    assert numpy.int16(-10) == -10
    assert numpy.int32(int(2**31-1)).__int__() == int(2**31-1)
    assert numpy.int64(42) == 42

    assert numpy.float16(10.0) == 10.0
    assert numpy.float32(-10) == -10.0
    assert numpy.float64(42.0) == 42.0
    if hasattr(numpy, "float128"):
        assert numpy.float128(-42.0) == -42.0

def test_getitem_setitem_delitem():
    builtin = import_module("__builtin__", noconvert=True)

    d = builtin.dict({1: 'foo', (1, 'a'): 'zoo'})
    with pytest.raises(KeyError):
        d[2]
    assert pypy_convert(d[1].obj) == 'foo'
    assert pypy_convert(d[(1, 'a')].obj) == 'zoo'

    key, lst = (1, 2), ['a', 'b']
    d[key] = lst
    assert pypy_convert(d[key].obj) == lst

    with pytest.raises(TypeError):
        d[[1, 2]] = 0

    del d[1]
    with pytest.raises(KeyError):
        d[1]

    with pytest.raises(KeyError):
        del d[2]

def test_getattr_on_module():
    sqlite = import_module("sqlite3")
    assert isinstance(sqlite, MetabiosisWrapper)
    connect = sqlite.connect
    assert isinstance(connect, MetabiosisWrapper)
    assert repr(connect).startswith("<built-in function connect>")

def test_setattr_on_module():
    this = import_module("this")
    assert isinstance(this, MetabiosisWrapper)
    this.a = 42
    assert this.a == 42

def test_gettype():
    sqlite3 = import_module("sqlite3")

    assert repr(sqlite3.get_type()) == "<type 'module'>"

def test_import_error():
    with pytest.raises(ImportError):
        import_module('thereisnosuchmodule4sure')

def test_getattr_convert():
    builtin = import_module("__builtin__", noconvert=True)
    s = builtin.slice(10, 11)
    s.noconvert = False
    assert s.start == 10

def test_setattr_on_module():
    pickle = import_module("pickle")
    assert isinstance(pickle, MetabiosisWrapper)
    pickle.a = 42
    assert pickle.a == 42

def test_callbacks_simple():
    builtin = import_module("__builtin__", noconvert=True)
    lst = builtin.list([1, 2, 3, 4, 5, 6])
    lst.sort(key=lambda x: x % 3)
    assert _pypy_convert_list(lst) == [3, 6, 1, 4, 2, 5]