public static void intercept_eachByte(
        @Receiver File self,
        Closure<?> closure,
        @CallerClassName String consumer
    ) throws IOException {
        Instrumented.fileOpened(self, consumer);
        ResourceGroovyMethods.eachByte(self, closure);
    }

    @InterceptGroovyCalls
    @InstanceMethod
    @WithExtensionReferences(toClass = ResourceGroovyMethods.class)

    public void beforeSettings(Closure<?> closure) {
        registerBuildListener("beforeSettings", closure);
    }

    @Override
    public void beforeSettings(Action<? super Settings> action) {
        buildListenerBroadcast.add("beforeSettings", action);
    }

    @Override
    public void settingsEvaluated(Closure closure) {
        registerBuildListener("settingsEvaluated", closure);
    }

    @Override

    }

    override fun projectsEvaluated(closure: Closure<*>) =
        delegate.projectsEvaluated(closure.withCrossProjectModelAccessChecks())

    override fun projectsEvaluated(action: Action<in Gradle>) =
        delegate.projectsEvaluated(action.withCrossProjectModelGradleAccessCheck())

    override fun beforeProject(closure: Closure<*>) {
        delegate.beforeProject(closure.withCrossProjectModelAccessChecks())
    }

     */
    @Incubating
    GradleLifecycle getLifecycle();

    /**
     * Adds a closure to be called immediately before a project is evaluated. The project is passed to the closure as a
     * parameter.
     *
     * @param closure The closure to execute.
     */
    void beforeProject(Closure closure);

    /**
     * Adds an action to be called immediately before a project is evaluated.
     *

        def closure = Mock(Closure)

        given:
        expectTestSuitePasses()

        task.afterSuite(closure)

        when:
        task.executeTests()

        then:
        _ * closure.maximumNumberOfParameters >> 0
        1 * closure.call()
        0 * closure._
    }

    def "notifies closure before test"() {
        def closure = Mock(Closure)

        given:

        delegate.beforeEvaluate(action)

    override fun beforeEvaluate(closure: Closure<*>) =
        delegate.beforeEvaluate(closure)

    override fun property(propertyName: String): Any? =
        delegate.property(propertyName)

    override fun buildscript(configureClosure: Closure<*>) =
        delegate.buildscript(configureClosure)

    override fun getProject(): Project =

     *
     * <p>The given closure is used to configure an {@link org.gradle.api.plugins.ObjectConfigurationAction} which is
     * then used to configure the delegate object.</p>
     *
     * @param closure The closure to configure the {@code ObjectConfigurationAction}.
     */
    void apply(Closure closure);

    /**

     * Also asserts that the appropriate console logging, reports and build operations are generated.
     */
    void assertStateStored(@DelegatesTo(StateStoreDetails) Closure closure = {}) {
        def details = new StateStoreDetails()
        closure.delegate = details
        closure()

        assertStateStored(details)
        assertHasWarningThatIncubatingFeatureUsed()
    }

    void assertStateStored(HasBuildActions details) {

        MethodShouldNotBeAnnotated config = methodShouldNotBeAnnotatedConfig(spec)
        config.render()
    }

    MethodShouldNotBeAnnotated methodShouldNotBeAnnotatedConfig(@DelegatesTo(value = MethodShouldNotBeAnnotated, strategy = Closure.DELEGATE_FIRST) Closure<?> spec) {

        assertEquals(
            null,
            closure { null }.call(null)
        )
    }

    @Test
    fun `can adapt binary function using KotlinClosure2`() {

        fun closure(function: (String, String) -> String) = KotlinClosure2(function)

        assertEquals(
            "foobar",