def test_direct_invalid():
    x1 = X()
    vref = virtual_ref(x1)
    assert vref._state == 'non-forced'
    virtual_ref_finish(vref, x1)
    assert vref._state == 'invalid'
    py.test.raises(InvalidVirtualRef, "vref()")

 def f(n):
     while n > 0:
         myjitdriver.can_enter_jit(n=n)
         myjitdriver.jit_merge_point(n=n)
         xy = XY()
         xy.next1 = lltype.malloc(A, 0)
         xy.next2 = lltype.malloc(A, 0)
         xy.next3 = lltype.malloc(A, 0)
         xy.next4 = lltype.malloc(A, 0)
         xy.next5 = lltype.malloc(A, 0)
         xy.n = n
         exctx.topframeref = vref = virtual_ref(xy)
         if n % 6 == 0:
             xy.next1 = lltype.nullptr(A)
             xy.next2 = lltype.nullptr(A)
             xy.next3 = lltype.nullptr(A)
             externalfn(n)
         n -= 1
         exctx.topframeref = vref_None
         xy.next1 = lltype.nullptr(A)
         xy.next2 = lltype.nullptr(A)
         xy.next3 = lltype.nullptr(A)
         xy.next4 = lltype.nullptr(A)
         xy.next5 = lltype.nullptr(A)
         virtual_ref_finish(vref, xy)
     return exctx.m

def test_direct_forced():
    x1 = X()
    vref = virtual_ref(x1)
    assert vref._state == 'non-forced'
    assert vref() is x1
    assert vref._state == 'forced'
    virtual_ref_finish(vref, x1)
    assert vref._state == 'forced'
    assert vref() is x1

 def leave(self, frame, got_exception):
     frame_vref = self.topframeref
     self.topframeref = frame.backref
     if frame.escaped or got_exception:
         back = frame.backref()
         if back is not None:
             back.escaped = True
         frame_vref()
     jit.virtual_ref_finish(frame_vref, frame)

 def fn(n):
     res = False
     while n > 0:
         myjitdriver.can_enter_jit(n=n)
         myjitdriver.jit_merge_point(n=n)
         xy = XY()
         xy.n = n
         vref = virtual_ref(xy)
         virtual_ref_finish(vref, xy)
         vref() # raises InvalidVirtualRef when jitted
         n -= 1
     return res

 def f(n):
     while n > 0:
         myjitdriver.can_enter_jit(n=n)
         myjitdriver.jit_merge_point(n=n)
         xy = XY()
         xy.n = n
         exctx.topframeref = virtual_ref(xy)
         exctx.later = exctx.topframeref
         n -= 1
         exctx.topframeref = vref_None
         virtual_ref_finish(xy)
     return g()

    def leave(self, frame, w_exitvalue, got_exception):
        try:
            if self.profilefunc:
                self._trace(frame, 'leaveframe', w_exitvalue)
        finally:
            frame_vref = self.topframeref
            self.topframeref = frame.f_backref
            if frame.escaped or got_exception:
                # if this frame escaped to applevel, we must ensure that also
                # f_back does
                f_back = frame.f_backref()
                if f_back:
                    f_back.mark_as_escaped()
                # force the frame (from the JIT point of view), so that it can
                # be accessed also later
                frame_vref()
            jit.virtual_ref_finish(frame_vref, frame)

        if self.w_tracefunc is not None and not frame.hide():
            self.space.frame_trace_action.fire()

 def leave():
     vref = exctx.topframeref
     exctx.topframeref = vref_None
     virtual_ref_finish(vref, exctx._frame)

def test_direct_2():
    x1 = X()
    vref = virtual_ref(x1)
    virtual_ref_finish(x1)
    assert vref() is x1

 def f():
     x1 = X()
     vref = virtual_ref(x1)
     x2 = vref()
     virtual_ref_finish(vref, x1)
     return x2

 def f(n, x, x0, x1, x2, x3, x4, x5, x6, x7, l, s):
     a = A()
     glob.v = vref = virtual_ref(a)
     virtual_ref_finish(vref, a)
     n -= 1
     return n, x, x0, x1, x2, x3, x4, x5, x6, x7, l, s

 def leave():
     exctx.topframeref = vref_None
     virtual_ref_finish(exctx._frame)