"is still deeper in the stack" | 1
    }

    def 'throws an exception on instance.markCurrentCallAsIntercepted if its #part does not match'() {
        given:
        def entryFoo = instance.enterCall("FooCallerClass", "foo", INVOKE_METHOD)

        when:
        instance.markCurrentCallAsIntercepted(name, kind)

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

        return perThreadImplementation.get().findCallerForCurrentCallIfNotIntercepted(callableName, kind);
    }

    @Override
    public void markCurrentCallAsIntercepted(String callableName, CallKind kind) {
        perThreadImplementation.get().markCurrentCallAsIntercepted(callableName, kind);
    }

 * matches a method or property and has not been intercepted yet. <p>
 *
 * If it satisfies, then the third party may mark the call as intercepted with {@link InstrumentedGroovyCallsTracker#markCurrentCallAsIntercepted}, so that other
 * parties will not be able to match the call.
 */
@NonNullApi
public interface InstrumentedGroovyCallsTracker {
    /**
     * Registers the current call in the instrumented calls stack.

        }
        if (top.isMatchedAtDispatchSite()) {
            return null;
        }
        return top.getCallerClassName();
    }

    @Override
    public void markCurrentCallAsIntercepted(String callableName, CallKind kind) {
        String result = findCallerForCurrentCallIfNotIntercepted(callableName, kind);
        if (result == null) {
            throw new IllegalStateException(

            throw new IllegalStateException("this is an unreachable statement, the call above always throws an exception");
        } finally {
            if (!invokedOriginal.invoked) {
                callsTracker.markCurrentCallAsIntercepted(name, kind);
            }
        }
    }

    private static Invocation callOriginalReportingInvocation(Object receiver, Object[] arguments, Callable<Object> doCallOriginal, Runnable reportCallOriginal) {