tracker.leaveDynamicCall(entryPoint2)
        tracker.leaveDynamicCall(entryPoint1)

        then:
        log == ["enter", entryPoint1, "enter", entryPoint2, "leave", entryPoint2, "leave", entryPoint1]
    }

    def "throws exception on mismatched calls"() {
        when:
        tracker.enterDynamicCall(new Object())
        tracker.leaveDynamicCall(new Object())

        then:

 * which is triggered by {@code enterDynamicCall} and {@code leaveDynamicCall}.
 * <p>
 * An entry point is a boundary between non-dynamic code and a dynamic lookup. For example,
 * one such boundary is {@code Project.hasProperty}. The object used for entry point is checked
 * for equality with the argument passed to {@code leaveDynamicCall}.
 * <p>

        assertTrue(reporting.unreportedProblemInCurrentCall(key2))
        assertFalse(reporting.unreportedProblemInCurrentCall(key1))
        assertFalse(reporting.unreportedProblemInCurrentCall(key2))

        reporting.leaveDynamicCall(entryPoint2)
        assertFalse(reporting.unreportedProblemInCurrentCall(key1))
        assertFalse(reporting.unreportedProblemInCurrentCall(key2))
    }

    @Test

     * The [entryPoint] is stored and checked in [leaveDynamicCall] later.
     */
    fun enterDynamicCall(entryPoint: Any)

    /**
     * End tracking a dynamic call.
     * The [entryPoint] should match the one passed to [enterDynamicCall].
     */
    fun leaveDynamicCall(entryPoint: Any)

    /**

            val routine = TrackingDynamicLookupRoutine(tracker)
            action(routine)
            verify(tracker, times(1)).enterDynamicCall(receiver)
            verify(tracker, times(1)).leaveDynamicCall(receiver)
        }

        shouldTrackContext { property(receiver, "test") }
        shouldTrackContext { findProperty(receiver, "test") }
        shouldTrackContext { setProperty(receiver, "test", "test") }

        currentEntryPointStack().push(entryPoint);
        enterListeners.forEach(listener -> listener.accept(entryPoint));
    }

    @Override
    public void leaveDynamicCall(@Nonnull Object entryPoint) {
        Stack<Object> entryPointsStack = currentEntryPointStack();
        Object top = entryPointsStack.peek();
        if (top != entryPoint) {
            throw new IllegalStateException(

        try {
            dynamicCallContextTracker.enterDynamicCall(entryPoint)
            action()
        } finally {
            dynamicCallContextTracker.leaveDynamicCall(entryPoint)
        }

            DefaultDynamicCallProblemReporting().also { reporting ->
                dynamicCallContextTracker.onEnter(reporting::enterDynamicCall)
                dynamicCallContextTracker.onLeave(reporting::leaveDynamicCall)
            }

        @Provides
        fun createDynamicLookupRoutine(
            dynamicCallContextTracker: DynamicCallContextTracker,
            buildModelParameters: BuildModelParameters

                    return delegateResult.value
                }
                throw delegateBean.resultNotFoundExceptionProvider()
            } finally {
                dynamicCallProblemReporting.leaveDynamicCall(delegateBean)
            }
        }

        private
        fun withDelegateDynamicCallReportingConfigurationOrder(
            accessRef: String,