tasks.withType<PublishToMavenRepository>().configureEach {
    notCompatibleWithConfigurationCache("Configures repository at execution time")
    doFirst {
        val address = com.example.MavenRepositoryStub.start()
        getRepository().setUrl(address)
    }
    doLast {
        com.example.MavenRepositoryStub.stop()
    }

tasks.withType(PublishToMavenRepository).configureEach {
    notCompatibleWithConfigurationCache("Configures repository at execution time")
    doFirst {
        def address = com.example.MavenRepositoryStub.start()
        getRepository().setUrl(address)
    }
    doLast {
        com.example.MavenRepositoryStub.stop()
    }

            definition.severity == Severity.WARNING
        }
    }

    def "notCompatibleWithConfigurationCache task problems are reported as Advice"() {
        given:
        buildFile """
            task run {
                notCompatibleWithConfigurationCache("because")
                doLast {
                    println(project.name)
                }
            }
        """

plugins {
    id 'java'
}

// tag::locking-all[]
dependencyLocking {
    lockAllConfigurations()
}
// end::locking-all[]

// tag::resolve-all[]
tasks.register('resolveAndLockAll') {
    notCompatibleWithConfigurationCache("Filters configurations at execution time")
    doFirst {
        assert gradle.startParameter.writeDependencyLocks : "$path must be run from the command line with the `--write-locks` flag"
    }
    doLast {

plugins {
    java
}

// tag::locking-all[]
dependencyLocking {
    lockAllConfigurations()
}
// end::locking-all[]

// tag::resolve-all[]
tasks.register("resolveAndLockAll") {
    notCompatibleWithConfigurationCache("Filters configurations at execution time")
    doFirst {
        require(gradle.startParameter.isWriteDependencyLocks) { "$path must be run from the command line with the `--write-locks` flag" }
    }
    doLast {

private
const val maxCauses = 5


internal
enum class ProblemSeverity {
    Info,
    Failure,

    /**
     * A problem produced by a task marked as [notCompatibleWithConfigurationCache][Task.notCompatibleWithConfigurationCache].
     */
    Suppressed
}


/**
 * This class is thread-safe.
 */
internal
class ConfigurationCacheProblemsSummary(

    private

        ) -> true

        else -> false
    }
}

gradle.taskGraph.whenReady {
    allTasks.filter(unsupportedTasksPredicate).forEach { task ->
        task.notCompatibleWithConfigurationCache("Task is not compatible with the configuration cache")
    }
}


fun String.startsWithAnyOf(vararg prefixes: String): Boolean =
    prefixes.any { prefix -> startsWith(prefix) }

        }
    }

    private addTasksWithoutProblems() {
        buildFile """
            tasks.register('declared') {
                notCompatibleWithConfigurationCache("not really")
                doLast {
                }
            }
        """
    }

    private addTasksWithProblems(String brokenFieldValue = 'project.configurations') {

                println("Materialized task \${task.name} from project \${task.project.name}")
            }

            tasks.register("offender") {
                notCompatibleWithConfigurationCache("calls getProject")
                // This task reaches out to other task at execution time and triggers its configuration.
                doLast { task ->

public abstract class DependentComponentsReport extends DefaultTask {

    private boolean showNonBuildable;
    private boolean showTestSuites;
    private List<String> components;

    {
        notCompatibleWithConfigurationCache("Requires access to the component model at execution time.");
    }

    /**
     * Should this include non-buildable components in the report?
     */
    @Console