def test_make_jitdriver_callbacks_3():
    def get_location(x, y):
        assert x == 5
        assert y == 42.5
        return "hi there"  # abuse the return type, but nobody checks it

    GET_LOCATION = lltype.Ptr(lltype.FuncType([lltype.Signed, lltype.Float], lltype.Ptr(rstr.STR)))

    class FakeWarmRunnerDesc:
        rtyper = None
        cpu = None
        memory_manager = None

    class FakeJitDriverSD:
        jitdriver = None
        _green_args_spec = [lltype.Signed, lltype.Float]
        _get_printable_location_ptr = llhelper(GET_LOCATION, get_location)
        _confirm_enter_jit_ptr = None
        _can_never_inline_ptr = None
        _get_jitcell_at_ptr = None
        _should_unroll_one_iteration_ptr = None
        red_args_types = []

    state = WarmEnterState(FakeWarmRunnerDesc(), FakeJitDriverSD())
    state.make_jitdriver_callbacks()
    res = state.get_location_str([ConstInt(5), constfloat(42.5)])
    assert res == "hi there"

def test_make_jitcell_getter_custom():
    from pypy.rpython.typesystem import LowLevelTypeSystem
    class FakeRTyper:
        type_system = LowLevelTypeSystem.instance
    class FakeJitCell(BaseJitCell):
        pass
    celldict = {}
    def getter(x, y):
        return celldict.get((x, y))
    def setter(newcell, x, y):
        newcell.x = x
        newcell.y = y
        celldict[x, y] = newcell
    GETTER = lltype.Ptr(lltype.FuncType([lltype.Signed, lltype.Float],
                                        llmemory.GCREF))
    SETTER = lltype.Ptr(lltype.FuncType([llmemory.GCREF, lltype.Signed,
                                         lltype.Float], lltype.Void))
    class FakeWarmRunnerDesc:
        rtyper = FakeRTyper()
        cpu = None
        get_jitcell_at_ptr = llhelper(GETTER, getter)
        set_jitcell_at_ptr = llhelper(SETTER, setter)
    #
    state = WarmEnterState(FakeWarmRunnerDesc())
    get_jitcell = state._make_jitcell_getter_custom(FakeJitCell)
    cell1 = get_jitcell(5, 42.5)
    assert isinstance(cell1, FakeJitCell)
    assert cell1.x == 5
    assert cell1.y == 42.5
    cell2 = get_jitcell(5, 42.5)
    assert cell2 is cell1
    cell3 = get_jitcell(41, 42.5)
    cell4 = get_jitcell(42, 0.25)
    assert cell1 is not cell3 is not cell4 is not cell1

def test_make_jitdriver_callbacks_1():
    class FakeWarmRunnerDesc:
        cpu = None
        memory_manager = None

    class FakeJitDriverSD:
        jitdriver = None
        _green_args_spec = [lltype.Signed, lltype.Float]
        _get_printable_location_ptr = None
        _confirm_enter_jit_ptr = None
        _can_never_inline_ptr = None
        _should_unroll_one_iteration_ptr = None
        red_args_types = []

    class FakeCell:
        dont_trace_here = False

    state = WarmEnterState(FakeWarmRunnerDesc(), FakeJitDriverSD())

    def jit_getter(build, *args):
        return FakeCell()

    state.jit_getter = jit_getter
    state.make_jitdriver_callbacks()
    res = state.get_location_str([ConstInt(5), constfloat(42.5)])
    assert res == "(no jitdriver.get_printable_location!)"

def test_make_jitdriver_callbacks_4():
    def confirm_enter_jit(x, y, z):
        assert x == 5
        assert y == 42.5
        assert z == 3
        return True

    ENTER_JIT = lltype.Ptr(lltype.FuncType([lltype.Signed, lltype.Float, lltype.Signed], lltype.Bool))

    class FakeWarmRunnerDesc:
        rtyper = None
        cpu = None
        memory_manager = None

    class FakeJitDriverSD:
        jitdriver = None
        _green_args_spec = [lltype.Signed, lltype.Float]
        _get_printable_location_ptr = None
        _confirm_enter_jit_ptr = llhelper(ENTER_JIT, confirm_enter_jit)
        _can_never_inline_ptr = None
        _get_jitcell_at_ptr = None
        _should_unroll_one_iteration_ptr = None
        red_args_types = []

    state = WarmEnterState(FakeWarmRunnerDesc(), FakeJitDriverSD())
    state.make_jitdriver_callbacks()
    res = state.confirm_enter_jit(5, 42.5, 3)
    assert res is True

    def make_enter_function(self):
        from pypy.jit.metainterp.warmstate import WarmEnterState
        state = WarmEnterState(self)
        maybe_compile_and_run = state.make_entry_point()
        self.state = state

        def crash_in_jit(e):
            if not we_are_translated():
                print "~~~ Crash in JIT!"
                print '~~~ %s: %s' % (e.__class__, e)
                if sys.stdout == sys.__stdout__:
                    import pdb; pdb.post_mortem(sys.exc_info()[2])
                raise
            fatalerror('~~~ Crash in JIT! %s' % (e,), traceback=True)
        crash_in_jit._dont_inline_ = True

        if self.translator.rtyper.type_system.name == 'lltypesystem':
            def maybe_enter_jit(*args):
                try:
                    maybe_compile_and_run(*args)
                except JitException:
                    raise     # go through
                except Exception, e:
                    crash_in_jit(e)
            maybe_enter_jit._always_inline_ = True

def test_make_jitdriver_callbacks_5():
    def can_never_inline(x, y):
        assert x == 5
        assert y == 42.5
        return True

    CAN_NEVER_INLINE = lltype.Ptr(lltype.FuncType([lltype.Signed, lltype.Float], lltype.Bool))

    class FakeWarmRunnerDesc:
        rtyper = None
        cpu = None
        memory_manager = None

    class FakeJitDriverSD:
        jitdriver = None
        _green_args_spec = [lltype.Signed, lltype.Float]
        _get_printable_location_ptr = None
        _confirm_enter_jit_ptr = None
        _can_never_inline_ptr = llhelper(CAN_NEVER_INLINE, can_never_inline)
        _get_jitcell_at_ptr = None
        _should_unroll_one_iteration_ptr = None
        red_args_types = []

    state = WarmEnterState(FakeWarmRunnerDesc(), FakeJitDriverSD())
    state.make_jitdriver_callbacks()
    res = state.can_never_inline(5, 42.5)
    assert res is True

def test_make_unwrap_greenkey():
    class FakeJitDriverSD:
        _green_args_spec = [lltype.Signed, lltype.Float]
    state = WarmEnterState(None, FakeJitDriverSD())
    unwrap_greenkey = state.make_unwrap_greenkey()
    greenargs = unwrap_greenkey([ConstInt(42), constfloat(42.5)])
    assert greenargs == (42, 42.5)
    assert type(greenargs[0]) is int

def test_make_unwrap_greenkey():
    class FakeWarmRunnerDesc:
        green_args_spec = [lltype.Signed, lltype.Float]
    state = WarmEnterState(FakeWarmRunnerDesc())
    unwrap_greenkey = state.make_unwrap_greenkey()
    greenargs = unwrap_greenkey([ConstInt(42), ConstFloat(42.5)])
    assert greenargs == (42, 42.5)
    assert type(greenargs[0]) is int

def test_make_jitcell_getter():
    class FakeWarmRunnerDesc:
        green_args_spec = [lltype.Float]
        get_jitcell_at_ptr = None
    state = WarmEnterState(FakeWarmRunnerDesc())
    get_jitcell = state.make_jitcell_getter()
    cell1 = get_jitcell(1.75)
    cell2 = get_jitcell(1.75)
    assert cell1 is cell2
    assert get_jitcell is state.make_jitcell_getter()

def test_make_jitdriver_callbacks_1():
    class FakeWarmRunnerDesc:
        can_inline_ptr = None
        get_printable_location_ptr = None
    state = WarmEnterState(FakeWarmRunnerDesc())
    state.make_jitdriver_callbacks()
    res = state.can_inline_callable([BoxInt(5), BoxFloat(42.5)])
    assert res is True
    res = state.get_location_str([BoxInt(5), BoxFloat(42.5)])
    assert res == '(no jitdriver.get_printable_location!)'

def test_make_jitcell_getter():
    class FakeJitDriverSD:
        _green_args_spec = [lltype.Float]
        _get_jitcell_at_ptr = None
    state = WarmEnterState(None, FakeJitDriverSD())
    get_jitcell = state.make_jitcell_getter()
    cell1 = get_jitcell(True, 1.75)
    cell2 = get_jitcell(True, 1.75)
    assert cell1 is cell2
    assert get_jitcell is state.make_jitcell_getter()

def test_attach_unoptimized_bridge_from_interp():
    class FakeWarmRunnerDesc:
        green_args_spec = [lltype.Signed, lltype.Float]
        get_jitcell_at_ptr = None
    state = WarmEnterState(FakeWarmRunnerDesc())
    get_jitcell = state.make_jitcell_getter()
    state.attach_unoptimized_bridge_from_interp([BoxInt(5), BoxFloat(2.25)],
                                                "entry loop token")
    cell1 = get_jitcell(5, 2.25)
    assert cell1.counter < 0
    assert cell1.entry_loop_token == "entry loop token"

def test_make_jitcell_getter_default():
    class FakeJitDriverSD:
        _green_args_spec = [lltype.Signed, lltype.Float]
    state = WarmEnterState(None, FakeJitDriverSD())
    get_jitcell = state._make_jitcell_getter_default()
    cell1 = get_jitcell(True, 42, 42.5)
    assert isinstance(cell1, JitCell)
    cell2 = get_jitcell(True, 42, 42.5)
    assert cell1 is cell2
    cell3 = get_jitcell(True, 41, 42.5)
    assert get_jitcell(False, 42, 0.25) is None
    cell4 = get_jitcell(True, 42, 0.25)
    assert get_jitcell(False, 42, 0.25) is cell4
    assert cell1 is not cell3 is not cell4 is not cell1

def test_make_jitcell_getter_default():
    class FakeWarmRunnerDesc:
        green_args_spec = [lltype.Signed, lltype.Float]
    class FakeJitCell(BaseJitCell):
        pass
    state = WarmEnterState(FakeWarmRunnerDesc())
    get_jitcell = state._make_jitcell_getter_default(FakeJitCell)
    cell1 = get_jitcell(42, 42.5)
    assert isinstance(cell1, FakeJitCell)
    cell2 = get_jitcell(42, 42.5)
    assert cell1 is cell2
    cell3 = get_jitcell(41, 42.5)
    cell4 = get_jitcell(42, 0.25)
    assert cell1 is not cell3 is not cell4 is not cell1

def test_attach_unoptimized_bridge_from_interp():
    class FakeJitDriverSD:
        _green_args_spec = [lltype.Signed, lltype.Float]
        _get_jitcell_at_ptr = None
    state = WarmEnterState(None, FakeJitDriverSD())
    get_jitcell = state.make_jitcell_getter()
    class FakeLoopToken(object):
        pass
    looptoken = FakeLoopToken()
    state.attach_unoptimized_bridge_from_interp([ConstInt(5),
                                                 constfloat(2.25)],
                                                looptoken)
    cell1 = get_jitcell(True, 5, 2.25)
    assert cell1.counter < 0
    assert cell1.get_entry_loop_token() is looptoken

def test_make_jitdriver_callbacks_2():
    def can_inline(x, y):
        assert x == 5
        assert y == 42.5
        return False
    CAN_INLINE = lltype.Ptr(lltype.FuncType([lltype.Signed, lltype.Float],
                                            lltype.Bool))
    class FakeWarmRunnerDesc:
        rtyper = None
        green_args_spec = [lltype.Signed, lltype.Float]
        can_inline_ptr = llhelper(CAN_INLINE, can_inline)
        get_printable_location_ptr = None
    state = WarmEnterState(FakeWarmRunnerDesc())
    state.make_jitdriver_callbacks()
    res = state.can_inline_callable([BoxInt(5), BoxFloat(42.5)])
    assert res is False

def test_make_jitdriver_callbacks_3():
    def get_location(x, y):
        assert x == 5
        assert y == 42.5
        return "hi there"    # abuse the return type, but nobody checks it
    GET_LOCATION = lltype.Ptr(lltype.FuncType([lltype.Signed, lltype.Float],
                                              lltype.Ptr(rstr.STR)))
    class FakeWarmRunnerDesc:
        rtyper = None
        green_args_spec = [lltype.Signed, lltype.Float]
        can_inline_ptr = None
        get_printable_location_ptr = llhelper(GET_LOCATION, get_location)
    state = WarmEnterState(FakeWarmRunnerDesc())
    state.make_jitdriver_callbacks()
    res = state.get_location_str([BoxInt(5), BoxFloat(42.5)])
    assert res == "hi there"

def test_make_jitdriver_callbacks_4():
    def confirm_enter_jit(x, y, z):
        assert x == 5
        assert y == 42.5
        assert z == 3
        return True
    ENTER_JIT = lltype.Ptr(lltype.FuncType([lltype.Signed, lltype.Float,
                                            lltype.Signed], lltype.Bool))
    class FakeWarmRunnerDesc:
        rtyper = None
        green_args_spec = [lltype.Signed, lltype.Float]
        can_inline_ptr = None
        get_printable_location_ptr = None
        confirm_enter_jit_ptr = llhelper(ENTER_JIT, confirm_enter_jit)
        get_jitcell_at_ptr = None

    state = WarmEnterState(FakeWarmRunnerDesc())
    state.make_jitdriver_callbacks()
    res = state.confirm_enter_jit(5, 42.5, 3)
    assert res is True

def test_make_set_future_values():
    future_values = {}
    class FakeCPU:
        def set_future_value_int(self, j, value):
            future_values[j] = "int", value
        def set_future_value_float(self, j, value):
            future_values[j] = "float", value
    class FakeWarmRunnerDesc:
        cpu = FakeCPU()
        red_args_types = ["int", "float"]
        class metainterp_sd:
            virtualizable_info = None
    #
    state = WarmEnterState(FakeWarmRunnerDesc())
    set_future_values = state.make_set_future_values()
    set_future_values(5, 42.5)
    assert future_values == {
        0: ("int", 5),
        1: ("float", 42.5),
    }
    assert set_future_values is state.make_set_future_values()

def test_make_jitdriver_callbacks_2():
    def can_inline(x, y):
        assert x == 5
        assert y == 42.5
        return False
    CAN_INLINE = lltype.Ptr(lltype.FuncType([lltype.Signed, lltype.Float],
                                            lltype.Bool))
    class FakeCell:
        dont_trace_here = False
    class FakeWarmRunnerDesc:
        rtyper = None
        green_args_spec = [lltype.Signed, lltype.Float]
        can_inline_ptr = llhelper(CAN_INLINE, can_inline)
        get_printable_location_ptr = None
        confirm_enter_jit_ptr = None
    state = WarmEnterState(FakeWarmRunnerDesc())
    def jit_getter(*args):
        return FakeCell()
    state.jit_getter = jit_getter
    state.make_jitdriver_callbacks()
    res = state.can_inline_callable([ConstInt(5), ConstFloat(42.5)])
    assert res is False