val getters = functionsByName
            .filterKeys { it.startsWith("get") && it.substringAfter("get").firstOrNull()?.isUpperCase() == true }
            .mapValues { (_, functions) -> functions.singleOrNull { fn -> fn.parameters.all { it == fn.instanceParameter } } }
            .filterValues { it != null && includeMemberFilter.shouldIncludeMember(it) }
        return getters.mapNotNull { (name, getter) ->
            checkNotNull(getter)

    }

    @Override
    public void onLoadFromConfigurationCache() {
        createPluginService();
    }

    @Override
    public void buildFinished(@Nullable Throwable buildFailure) {
        // Ensure that all tasks are complete prior to the buildFinished callback.
        requiredServices.getBackgroundJobExecutors().stop();

        if (pluginService != null) {

                override fun apply(project: Project) {
                    var value = ${read.kotlinExpression}
                    println("apply = " + value)

                    // Call from a function body
                    val f = { p: String ->
                        println("\$p FUNCTION = " + System.getProperty("FUNCTION"))
                    }
                    f("apply")

    }

    protected void setConvention(S convention) {
        assertCanMutate();
        this.value = state.applyConvention(value, convention);
    }

    /**
     * Call prior to reading the value of this property.
     */
    protected void beforeRead(EvaluationContext.ScopeContext context, ValueConsumer consumer) {
        beforeRead(context, producer, consumer);
    }

import spock.lang.Specification

import static org.gradle.integtests.fixtures.RetryConditions.onIssueWithReleasedGradleVersion
import static spock.lang.Retry.Mode.SETUP_FEATURE_CLEANUP

/**
 * A spec that executes tests against all compatible versions of tooling API consumer and testDirectoryProvider, including the current Gradle version under test.
 *

// This test doesn't live in :instrumentation-agent to avoid the latter being implicitly added to
// the test runtime classpath as part of the main source set's output.
// It is important to have the agent appended to the classpath of all integration tests.
class AgentApplicationTest extends AbstractIntegrationSpec {
    def "agent is enabled by default"() {
        given:
        withDumpAgentStatusTask()

        when:
        succeeds()

     *
     * The standard {@link Class#cast(Object)} method produces unsatisfactory error messages on some platforms
     * when it fails. All this method does is provide a better, consistent, error message.
     *
     * This should be used whenever there is a chance the cast could fail. If in doubt, use this.
     *
     * @param outputType The type to cast the input to

        TaskProvider<Javadoc> javadocAll = tasks.register("javadocAll", Javadoc.class, task -> {
            task.setGroup("documentation");
            task.setDescription("Generate Javadocs for all API classes");

            task.setTitle("Gradle API " + version);

            Javadocs javadocs = extension.getJavadocs();

            // TODO: This should be part of Javadoc task

        then:
        fixture.assertNoConfigurationCache()

        originalUpdatedModel.children.path == [":a", ":b"]
        originalUpdatedModel.children.all[0].tasks.name.contains("something")


        when:
        executer.withArguments(ENABLE_CLI)
        def updatedModel = fetchModel(GradleProject)

        then:
        fixture.assertStateUpdated {

== Build caching

Incremental Builds are a great optimization that helps avoid work already done.
If a developer continuously changes a single file, there is likely no need to rebuild all the other files in the project.

However, what happens when the same developer switches to a new branch created last week?
The files are rebuilt, even though the developer is building something that has been built before.