def entryBaz = instance.enterCall("BarCallerClass", "baz", INVOKE_METHOD)
        instance.leaveCall(entryBaz)
        def entryPointsToTest = [entryBaz, entryFoo]

        when:
        instance.leaveCall(entryPointsToTest[index])

        then:
        thrown(IllegalStateException)
        instance.leaveCall(entryBar)
        instance.leaveCall(entryFoo)

        where:
        entryPointKind                 | index

        }
    }

    /**
     * Registers the current call in the thread-specific instrumented call stack.
     * @return an entry point call site token that must later be passed to {@link InstrumentedGroovyCallsTracker#leaveCall}
     */
    @Override
    public EntryPointCallSite enterCall(String callerClassName, String callableName, CallKind callKind) {

 * Tracks the call stacks of instrumented Groovy methods, maintaining a call stack per thread. <p>
 *
 * A call is registered with {@link InstrumentedGroovyCallsTracker#enterCall} and unregistered {@link InstrumentedGroovyCallsTracker#leaveCall}, which should match each other exactly. <p>
 *
 * In between, a third party may query this structure with {@link InstrumentedGroovyCallsTracker#findCallerForCurrentCallIfNotIntercepted} to check if the current innermost call

        return perThreadImplementation.get().enterCall(callerClassName, callableName, callKind);
    }

    @Override
    public void leaveCall(EntryPointCallSite entryPoint) {
        perThreadImplementation.get().leaveCall(entryPoint);
    }

    @Nullable
    @Override
    public String findCallerForCurrentCallIfNotIntercepted(String callableName, CallKind kind) {

        InstrumentedGroovyCallsTracker.EntryPointCallSite entryPoint = INSTANCE.enterCall(consumerClass, callableName, kind);
        try {
            return callable.call();
        } finally {
            INSTANCE.leaveCall(entryPoint);
        }
    }

    @NonNullApi
    public interface ThrowingCallable<T> {
        @Nullable
        T call() throws Throwable;
    }

        def entryPoint = callTracker.enterCall("from-test", name, kind)
        try {
            return call()
        } finally {
            callTracker.leaveCall(entryPoint)
        }
    }